static jmethodID getMethodID ( const char* methodName, const char *paramCode )
{
jmethodID ret = 0;
if ( (*l_vm)->GetEnv ( l_vm, (void**) &l_env, JNI_VERSION_1_4) != JNI_OK)
{
kdLogMessagefKHR ( "Failed to get the environment using GetEnv()" );
return 0;
}
if ( (*l_vm)->AttachCurrentThread ( l_vm, &l_env, 0 ) < 0 )
{
kdLogMessagefKHR ( "Failed to get the environment using AttachCurrentThread()" );
return 0;
}
l_class = (*l_env)->FindClass ( l_env, "XMKode/XMNative" );
if ( !l_class )
{
kdLogMessagefKHR ( "Failed to find class of XMKode/XMNative" );
return 0;
}
if ( l_env != 0 && l_class != 0 )
{
ret = (*l_env)->GetStaticMethodID ( l_env, l_class, methodName, paramCode );
}
if ( !ret )
{
kdLogMessagefKHR ( "get method id of %s error", methodName );
}
return ret;
}
// FTFont *FTSimpleLayout::GetFont()
FTGLfont *ftglGetLayoutFont(FTGLlayout *l)
{
if(!l || !l->ptr)
{
kdLogMessagefKHR( "FTGL warning: NULL pointer in %s\n", __FUNCTION__ );
return NULL;
}
if(l->type != FTGL::LAYOUT_SIMPLE)
{
kdLogMessagefKHR( "FTGL warning: %s not implemented for %d\n", __FUNCTION__, l->type );
}
return l->font;
}
// void FTSimpleLayout::SetFont(FTFont *fontInit)
void ftglSetLayoutFont(FTGLlayout *l, FTGLfont *font)
{
if(!l || !l->ptr)
{
kdLogMessagefKHR( "FTGL warning: NULL pointer in %s\n", __FUNCTION__ );
return;
}
if(l->type != FTGL::LAYOUT_SIMPLE)
{
kdLogMessagefKHR( "FTGL warning: %s not implemented for %d\n", __FUNCTION__, l->type );
}
l->font = font;
return ((FTSimpleLayout *) l->ptr)->SetFont(font->ptr);
}
KDvoid xmEx_Recursive ( KDvoid )
{
const KDEvent* wait;
KDEvent* event[2];
KDint i = 0;
kdLogMessage ( "\n* Case Recursive\n\n" );
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 );
kdPostEvent ( event[i] );
kdLogMessagefKHR ( "kdPostEvent : 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 );
kdPostEvent ( event[i] );
kdLogMessagefKHR ( "kdPostEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
kdInstallCallback ( xmRecursiveCallback, XM_FOR_PUMP_EVENT, KD_NULL );
kdLogMessagefKHR ( "kdInstallCallback : func = 0x%08x, type = %04d, userptr = 0x%08x", xmRecursiveCallback, XM_FOR_PUMP_EVENT, KD_NULL );
kdLogMessagefKHR ( "kdWaitEvent : waiting message." );
wait = kdWaitEvent ( -1 );
kdLogMessagefKHR ( "kdWaitEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", wait, wait->type, wait->userptr );
kdDefaultEvent( wait );
kdLogMessagefKHR ( "kdDefaultEvent : event = 0x%08x", wait );
}
static void SaveTrack(DefBlobTrack* pTrack, char* pFileName, int norm = 0)
{ /* Save blob track: */
int j;
FILE* out = NULL;
CvBlobSeq* pS = pTrack->pSeq;
CvBlob* pB0 = pS?pS->GetBlob(0):NULL;
if(pFileName == NULL) return;
if(pTrack == NULL) return;
out = fopen(pFileName,"at");
if(out == NULL)
{
kdLogMessagefKHR ("Warning! Cannot open %s file for track output\n", pFileName);
return;
}
fprintf(out,"%d",pTrack->FrameBegin);
if(pS) for(j=0; j<pS->GetBlobNum(); ++j)
{
CvBlob* pB = pS->GetBlob(j);
fprintf(out,", %.1f, %.1f", CV_BLOB_X(pB),CV_BLOB_Y(pB));
if(CV_BLOB_WX(pB0)>0)
fprintf(out,", %.2f",CV_BLOB_WX(pB)/(norm?CV_BLOB_WX(pB0):1));
if(CV_BLOB_WY(pB0)>0)
fprintf(out,", %.2f",CV_BLOB_WY(pB)/(norm?CV_BLOB_WY(pB0):1));
}
fprintf(out,"\n");
fclose(out);
pTrack->Saved = 1;
} /* Save blob track. */
KDvoid xmRecursiveCallback ( const KDEvent *event )
{
kdLogMessagefKHR ( "recursive_callback : event = 0x%08x, type = %04d, userptr = 0x%08x", event, event->type, event->userptr );
if ( event->userptr == 0 )
{
const KDEvent* wait;
KDEvent* event[3];
KDint i = 0;
event[i] = kdCreateEvent ();
event[i]->type = XM_FOR_PUMP_EVENT;
event[i]->userptr = (KDvoid *) xmRecursiveCallback;
kdLogMessagefKHR ( "kdCreateEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
kdPostEvent ( event[i] );
kdLogMessagefKHR ( "kdPostEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
i++;
kdLogMessagefKHR ( "kdWaitEvent : waiting message." );
wait = kdWaitEvent ( 0 );
kdLogMessagefKHR ( "kdWaitEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", wait, wait->type, wait->userptr );
kdDefaultEvent( wait );
kdLogMessagefKHR ( "kdDefaultEvent : event = 0x%08x", wait );
event[i] = kdCreateEvent ();
event[i]->type = XM_FOR_PUMP_EVENT;
event[i]->userptr = (KDvoid *) xmRecursiveCallback;
kdLogMessagefKHR ( "kdCreateEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
kdPostEvent ( event[i] );
kdLogMessagefKHR ( "kdPostEvent : 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;
event[i]->userptr = (KDvoid *) xmRecursiveCallback;
kdLogMessagefKHR ( "kdCreateEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
kdPostEvent ( event[i] );
kdLogMessagefKHR ( "kdPostEvent : event = 0x%08x, type = %04d, userptr = 0x%08x", event[i], event[i]->type, event[i]->userptr );
}
}
///
// kdMain()
//
// Main function for OpenKODE application
//
KDint KD_APIENTRY kdMain(KDint argc, const KDchar *const *argv)
{
Example *example = exampleInit();
UserData userdata;
example->userptr = &userdata;
Init(example);
KDust t1 = kdGetTimeUST();
KDfloat32 deltatime;
KDfloat32 totaltime = 0.0f;
KDuint frames = 0;
// Main Loop
while(example->run)
{
const KDEvent *event = kdWaitEvent(-1);
if(event)
{
switch(event->type)
{
case(KD_EVENT_QUIT):
case(KD_EVENT_WINDOW_CLOSE):
{
example->run = KD_FALSE;
break;
}
default:
{
kdDefaultEvent(event);
break;
}
}
}
// Update
KDust t2 = kdGetTimeUST();
deltatime = (KDfloat32)((t2 - t1) * 1e-9);
t1 = t2;
Update(example, deltatime);
// Draw frame
Draw(example);
exampleRun(example);
// Benchmark
totaltime += deltatime;
frames++;
if(totaltime > 5.0f)
{
kdLogMessagefKHR("%d frames in %3.1f seconds = %6.3f FPS\n", frames, totaltime, frames / totaltime);
totaltime -= 5.0f;
frames = 0;
}
}
ShutDown(example);
return exampleDestroy(example);
}
// FTFont::~FTFont();
void ftglDestroyFont(FTGLfont *f)
{
if(!f || !f->ptr)
{
kdLogMessagefKHR( "FTGL warning: NULL pointer in %s\n", __FUNCTION__ );
return;
}
delete f->ptr;
free(f);
}
// FTLayout::~FTLayout();
void ftglDestroyLayout(FTGLlayout *l)
{
if(!l || !l->ptr)
{
kdLogMessagefKHR( "FTGL warning: NULL pointer in %s\n", __FUNCTION__ );
return;
}
delete l->ptr;
free(l);
}
KDvoid xmEx_RemoveCallback ( KDvoid )
{
kdLogMessage ( "\n* Case RemoveCallback\n\n" );
//
// 콜백 등록 제거
//
kdLogMessagefKHR ( "kdInstallCallback : uninstall all callbacks." );
kdInstallCallback ( KD_NULL, (KDint) KD_NULL, KD_NULL );
}
KDvoid xmEx_GetTLS ( KDvoid )
{
XMData* data = 0;
//
// 설명 : 쓰레드 로컬 스토리지 데이타 가져오기
// 반환 : 쓰레드 로컬 스토리지 데이타
//
data = (XMData *) kdGetTLS ( );
kdLogMessagefKHR ( "kdGetTLS : str = '%s', val = %d", data->str, data->val );
}
jmethodID getMethodID ( const char* szMethod, const char* szParam )
{
jmethodID ret = 0;
m_pVM = (JavaVM*) xmGetWindow ( );
m_pEnv = 0;
if ( m_pVM->GetEnv ( (void**) &m_pEnv, JNI_VERSION_1_4 ) != JNI_OK )
{
kdLogMessagefKHR ( "Failed to get the environment using GetEnv()" );
return 0;
}
if ( m_pVM->AttachCurrentThread ( &m_pEnv, 0 ) < 0 )
{
kdLogMessagefKHR ( "Failed to get the environment using AttachCurrentThread()" );
return 0;
}
m_pCls = m_pEnv->FindClass ( "XMKode/XMNative" );
if ( !m_pCls )
{
kdLogMessagefKHR ( "Failed to find class of XMKode/XMNative" );
return 0;
}
if ( m_pEnv != 0 && m_pCls != 0 )
{
ret = m_pEnv->GetStaticMethodID ( m_pCls, szMethod, szParam );
}
if ( !ret )
{
kdLogMessagefKHR ( "get method id of %s error", szMethod );
}
return ret;
}
virtual void DelBlob(int BlobIndex)
{
DefBlobTracker* pBT = (DefBlobTracker*)m_BlobList.GetBlob(BlobIndex);
if(pBT==NULL) return;
if(pBT->pPredictor)
{
pBT->pPredictor->Release();
}
else
{
kdLogMessagefKHR ("WARNING!!! Invalid Predictor in CC tracker");
}
delete pBT->pBlobHyp;
m_BlobList.DelBlob(BlobIndex);
};
KDvoid xmEx_SetTLS ( KDvoid )
{
XMData* data = 0;
data = (XMData *) kdMalloc ( sizeof ( XMData ) );
kdStrcpy_s ( data->str, 256, "hello" );
data->val = 100;
//
// 설명 : 쓰레드 로컬 스토리지 데이타 저장
//
kdSetTLS ( data );
kdLogMessagefKHR ( "kdSetTLS : str = '%s', val = %d", data->str, data->val );
}
static void callback_tess_error ( GLenum error )
{
kdLogMessagefKHR ( "Tessellation Error : %s", (const KDchar *) gluErrorString ( error ) );
}
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 );
}
KDvoid xmRegularCallback ( const KDEvent *event )
{
kdLogMessagefKHR ( "regular_callback : event = 0x%08x, type = %04d, userptr = 0x%08x", event, event->type, event->userptr );
}
KD_API KDImageATX KD_APIENTRY kdGetImageFromStreamATX(KDFile *file, KDint format, KDint flags)
{
_KDImageATX *image = (_KDImageATX *)kdMalloc(sizeof(_KDImageATX));
if(image == KD_NULL)
{
kdSetError(KD_ENOMEM);
return KD_NULL;
}
image->levels = 0;
image->bpp = 8;
KDStat st;
if(kdFstat(file, &st) == -1)
{
kdFree(image);
kdSetError(KD_EIO);
return KD_NULL;
}
void *filedata = kdMalloc((KDsize)st.st_size);
if(filedata == KD_NULL)
{
kdFree(image);
kdSetError(KD_ENOMEM);
return KD_NULL;
}
if(kdFread(filedata, 1, (KDsize)st.st_size, file) != (KDsize)st.st_size)
{
kdFree(filedata);
kdFree(image);
kdSetError(KD_EIO);
return KD_NULL;
}
if(kdFseek(file, 0, KD_SEEK_SET) == -1)
{
kdFree(filedata);
kdFree(image);
kdSetError(KD_EIO);
return KD_NULL;
}
KDint channels = 0;
image->format = format;
switch(image->format)
{
case(KD_IMAGE_FORMAT_RGBA8888_ATX):
{
channels = 4;
image->alpha = KD_TRUE;
break;
}
case(KD_IMAGE_FORMAT_RGB888_ATX):
{
channels = 3;
image->alpha = KD_FALSE;
break;
}
case(KD_IMAGE_FORMAT_LUMALPHA88_ATX):
{
channels = 2;
image->alpha = KD_TRUE;
break;
}
case(KD_IMAGE_FORMAT_LUM8_ATX):
{
channels = 1;
image->alpha = KD_FALSE;
break;
}
case(KD_IMAGE_FORMAT_COMPRESSED_ATX):
{
/* TODO: Load compressed formats (do not decode) */
}
default:
{
kdFree(filedata);
kdFree(image);
kdSetError(KD_EINVAL);
return KD_NULL;
}
}
if(kdStrstrVEN(file->pathname, ".pvr"))
{
if(channels == 4)
{
/* PVR v2 only*/
struct PVR_Texture_Header {
KDuint dwHeaderSize; /* size of the structure */
KDuint dwHeight; /* height of surface to be created */
KDuint dwWidth; /* width of input surface */
KDuint dwMipMapCount; /* number of mip-map levels requested */
KDuint dwpfFlags; /* pixel format flags */
KDuint dwTextureDataSize; /* Total size in bytes */
KDuint dwBitCount; /* number of bits per pixel */
KDuint dwRBitMask; /* mask for red bit */
KDuint dwGBitMask; /* mask for green bits */
KDuint dwBBitMask; /* mask for blue bits */
KDuint dwAlphaBitMask; /* mask for alpha channel */
KDuint dwPVR; /* magic number identifying pvr file */
KDuint dwNumSurfs; /* the number of surfaces present in the pvr */
};
struct PVR_Texture_Header header;
kdMemcpy(&header, filedata, sizeof(KDuint) * 13);
image->height = (KDint)header.dwHeight;
image->width = (KDint)header.dwWidth;
image->size = (KDsize)image->width * (KDsize)image->height * (KDsize)channels * sizeof(KDuint);
image->buffer = kdMalloc(image->size);
/* PVRCT2/4 RGB/RGBA compressed formats for now */
__kdDecompressPVRTC((const KDuint8 *)filedata + header.dwHeaderSize, 0, image->width, image->height, image->buffer);
}
}
else
{
if(flags == KD_IMAGE_FLAG_FLIP_X_ATX)
{
stbi_set_flip_vertically_on_load(1);
}
image->buffer = stbi_load_from_memory(filedata, (KDint)st.st_size, &image->width, &image->height, (KDint[]) {0}, channels);
image->size = (KDsize)image->width * (KDsize)image->height * (KDsize)channels * sizeof(KDuint);
}
kdFree(filedata);
if(image->buffer == KD_NULL)
{
kdLogMessagefKHR("%s.\n", stbi_failure_reason());
kdFree(image);
kdSetError(KD_EILSEQ);
return KD_NULL;
}
return image;
}
