kmVec4* kmVec4Assign(kmVec4* pOut, const kmVec4* pIn) {
kdAssert(pOut != pIn);
kdMemcpy(pOut, pIn, sizeof(float) * 4);
return pOut;
}
/* kdGetImageIntATX, kdGetImageLevelIntATX: Get the value of an image integer attribute. */
KD_API KDint KD_APIENTRY kdGetImageIntATX(KDImageATX image, KDint attr)
{
_KDImageATX *_image = image;
switch(attr)
{
case(KD_IMAGE_WIDTH_ATX):
{
return _image->width;
}
case(KD_IMAGE_HEIGHT_ATX):
{
return _image->height;
}
case(KD_IMAGE_FORMAT_ATX):
{
return _image->format;
}
case(KD_IMAGE_STRIDE_ATX):
{
return 0;
}
case(KD_IMAGE_BITSPERPIXEL_ATX):
{
return _image->bpp;
}
case(KD_IMAGE_LEVELS_ATX):
{
return _image->levels;
}
case(KD_IMAGE_DATASIZE_ATX):
{
/* Specbug: Int is too small... */
kdAssert(0);
return (KDint)_image->size;
}
case(KD_IMAGE_BUFFEROFFSET_ATX):
{
return 0;
}
case(KD_IMAGE_ALPHA_ATX):
{
return _image->alpha;
}
default:
{
kdSetError(KD_EINVAL);
return 0;
}
}
}
NodeLoader * NodeLoaderLibrary::getNodeLoader(const char* pClassName) {
NodeLoaderMap::iterator ccNodeLoadersIterator = this->m_tNodeLoaders.find(pClassName);
kdAssert(ccNodeLoadersIterator != this->m_tNodeLoaders.end());
return ccNodeLoadersIterator->second;
}
XM_APP_MAIN_END
KD_API KDvoid KD_APIENTRY xmEventProc ( const KDEvent* event )
{
switch ( event->type )
{
case KD_EVENT_NATIVE :
{
// #if !defined ( SHP ) && defined ( _WIN32 )
// KDEventNativeWin32* proc = (KDEventNativeWin32*) event->data.native.p;
// #endif
}
break;
case KD_EVENT_CREATE :
{
// event->data.size.width;
// event->data.size.height;
// create device and exit if creation failed
CTutorial::s_pDevice = createDevice ( video::EDT_OGLES1, core::dimension2d<u32> ( event->data.size.width, event->data.size.height ), 32, false, false, false, 0 );
kdAssert ( CTutorial::s_pDevice );
CTutorial::s_pDriver = CTutorial::s_pDevice->getVideoDriver ( );
CTutorial::SetTutorial ( 0 );
}
break;
case KD_EVENT_DESTROY :
{
/*
In the end, delete the Irrlicht device.
*/
CTutorial::s_pDevice->drop ( );
CTutorial::s_pDevice = KD_NULL;
}
break;
case KD_EVENT_RESIZE :
break;
case KD_EVENT_FOCUS :
{
// event->data.value.i;
// 1 : focus
}
break;
case KD_EVENT_VISIBLE :
{
// event->data.value.i;
// 1 : visible
}
break;
case KD_EVENT_REDRAW :
{
CTutorial::Redraw ( );
}
break;
case KD_EVENT_UPDATE :
{
// event->data.update.msec;
}
break;
case KD_EVENT_TOUCH_BEGAN :
{
// event->data.touch.touches;
// event->data.touch.count;
}
break;
case KD_EVENT_TOUCH_MOVED :
{
}
break;
case KD_EVENT_TOUCH_ENDED :
{
}
break;
case KD_EVENT_TOUCH_CANCELLED :
{
}
break;
case KD_EVENT_KEY_RELEASED :
{
// event->data.keypad.code;
}
break;
case KD_EVENT_KEY_PRESSED :
{
}
break;
case KD_EVENT_ACCELEROMETER :
{
// event->data.accelerometer.x;
// event->data.accelerometer.y;
// event->data.accelerometer.z;
}
break;
case KD_EVENT_LOCATION :
{
// event->data.value.i;
// KD_NMEA_UPDATED_GPS, KD_NMEA_UPDATED_USER
}
break;
case KD_EVENT_INSERT_TEXT :
{
// event->data.insert.utf8;
}
break;
case KD_EVENT_SERIALIZE :
{
// event->data.serialize.type;
// event->data.serialize.data;
// event->data.serialize.size;
}
break;
}
if ( CTutorial::s_pDevice )
{
CTutorial::s_pDevice->EventProc ( event );
}
}
KDvoid xmEx_Regular ( KDvoid )
{
const KDEvent* wait;
KDEvent* event[4];
KDint ret = 0;
KDint i = 0;
kdLogMessage ( "* Case Regular\n\n" );
//
// 설명 : 이벤트 생성
// 반환 : 이벤트
//
event[i] = kdCreateEvent ();
kdAssert ( ( event[i] ) );
event[i]->type = XM_FOR_PUMP_EVENT; // 펌프 테스트 용
kdLogMessagefKHR ( "kdCreateEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
i++;
event[i] = kdCreateEvent ();
event[i]->type = XM_FOR_WAIT_EVENT; // 메세지 대기 테스트 용
kdLogMessagefKHR ( "kdCreateEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
i++;
event[i] = kdCreateEvent ();
event[i]->type = XM_FOR_PUMP_EVENT; // 이벤트 제거 테스트 용
kdLogMessagefKHR ( "kdCreateEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
i++;
event[i] = kdCreateEvent ();
event[i]->type = XM_FOR_PUMP_EVENT; // 메세지 대기시 펌프 테스트 용
kdLogMessagefKHR ( "kdCreateEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
i = 0;
//
// 설명 : 이벤트 전달
// 인자 : 이벤트
// 반환 : 성공 = 0, 실패 = -1
//
ret = kdPostEvent ( event[i] );
kdAssert ( !ret );
kdLogMessagefKHR ( "kdPostEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
i++;
//
// 설명 : 이벤트 전달 ( 해당 쓰레드로 이벤트 전달 )
// 인자 : 이벤트, 쓰레드 핸들
// 반환 : 성공 = 0, 실패 = -1
//
ret = kdPostThreadEvent ( event[i], kdThreadSelf() ); // 현재 쓰레드 구현 안됨.
kdAssert ( !ret );
kdLogMessagefKHR ( "kdPostThreadEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
i++;
//
// 설명 : 이벤트 제거 ( 이미 포스팅 또는 제거를 한 경우에는 예기치 않은 오류 발생 가능 )
// 인자 : 이벤트
//
kdFreeEvent ( event[i] );
kdLogMessagefKHR ( "kdFreeEvent : event = 0x%08x", event[i] );
i++;
//
// 설명 : 콜백 함수 등록 ( 이벤트 및 사용자 포인터를 이중으로 등록 가능 )
// 인자 : 콜백 함수, 이벤트 종류, 사용자 포인터
// 반환 : 성공 = 0, 실패 = -1
//
ret = kdInstallCallback ( xmRegularCallback, XM_FOR_PUMP_EVENT, KD_NULL );
kdAssert ( !ret );
kdLogMessagefKHR ( "kdInstallCallback : func = 0x%08x, type = %04d, userptr = 0x%08x", xmRegularCallback, XM_FOR_PUMP_EVENT, KD_NULL );
//
// 설명 : 이벤트 펌프( 등록된 콜백 함수 조건에 성립된 메세지들을 큐에서 꺼내 전부 콜백 함수를 호출한다 )
// 반환 : 성공 = 0, 실패 = -1
//
kdLogMessagefKHR ( "kdPumpEvents : pumping messages." );
ret = kdPumpEvents ( );
kdAssert ( !ret );
//
// 설명 : 메세지 대기
// 인자 : 시간제한 ( -1은 무한 )
// 반환 : 이벤트
//
i = 3;
kdPostEvent ( event[i] );
kdLogMessagefKHR ( "kdPostEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
kdLogMessagefKHR ( "kdWaitEvent : waiting message." );
wait = kdWaitEvent ( -1 );
kdAssert ( wait->type == XM_FOR_WAIT_EVENT );
kdLogMessagefKHR ( "kdWaitEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", wait, wait->type, wait->userptr );
//
// 설명 : 디폴트 처리 ( 전달된 이벤트는 삭제 됨 )
// 인자 : 이벤트
//
kdDefaultEvent ( wait );
kdLogMessagefKHR ( "kdDefaultEvent : event = 0x%08x", wait );
}
/// Returns the interpolation of 2 4D vectors based on t. Currently not implemented!
kmVec4* kmVec4Lerp(kmVec4* pOut, const kmVec4* pV1, const kmVec4* pV2, kmScalar t) {
kdAssert(0);
return pOut;
}
