kgmDSound::~kgmDSound()
{
m_proceed = false;
if(m_timer)
timeKillEvent(m_timer);
Sleep(100);
m_thread.join();
kgmThread::mxfree(m_mutex);
if(m_pSbuf)
{
if(FAILED(m_pSbuf->Release()))
{
#ifdef DEBUG
kgm_log() << "Error: can't release direct sound buffer.\n";
#endif
}
}
if(m_pSnd)
{
if(FAILED(m_pSnd->Release()))
{
#ifdef DEBUG
kgm_log() << "Error: can't release direct sound.\n";
#endif
}
}
}
kgmOSL::_Sound::~_Sound()
{
#ifdef DEBUG
kgm_log() << "OSL delete sound \n";
#endif
if(audioPlayerObject)
{
stop();
(*audioPlayerObject)->Destroy(audioPlayerObject);
}
if(buffer)
{
#ifdef DEBUG
kgm_log() << "OSL delete sound buffer\n";
#endif
free(buffer);
}
#ifdef DEBUG
kgm_log() << "OSL sound deleted...\n";
#endif
}
kgmWindow::~kgmWindow()
{
//Prepare to close window
#ifdef DEBUG
kgm_log() << "kgmWindow::~kgmWindow Prepare to close window.\n";
#endif
#ifdef WIN32
DestroyWindow(m_wnd);
#elif defined(ANDROID)
#else
/*XDestroyWindow(m_dpy, m_wnd);
if(!m_parent)
{
XCloseDisplay(m_dpy);
m_dpy = null;
}*/
XDestroyWindow(m_dpy, m_wnd);
XCloseDisplay(m_dpy);
//XEvent ev;
/*XClientMessageEvent ev;
memset(&ev, 0, sizeof (ev));
ev.type = ClientMessage;
ev.window = m_wnd;
ev.format = 32;
XSendEvent(m_dpy, m_wnd, 0, 0, (XEvent*)&ev);*/
/*ev.xclient.type = ClientMessage;
ev.xclient.window = m_wnd;
ev.xclient.message_type = XInternAtom(m_dpy, "WM_PROTOCOLS", false);
ev.xclient.format = 32;
ev.xclient.data.l[0] = XInternAtom(m_dpy, "WM_DELETE_WINDOW", false);
ev.xclient.data.l[1] = CurrentTime;
XSendEvent(m_dpy, m_wnd, False, NoEventMask, &ev);*/
#endif
#ifdef DEBUG
kgm_log() << "kgmWindow::~kgmWindow.\n";
#endif
}
void kgmCharacter::action(kgmString &a)
{
kgm_log() << "kgmCharacter action: " << (char*)a << "\n";
if(a == "idle")
{
m_body->m_velocity = speed_idl;
}
else if(a == "walk")
{
m_body->m_velocity = speed_wlk;
}
else if(a == "run")
{
m_body->m_velocity = speed_run;
}
else if(a == "jump")
{
}
else if(a == "fall")
{
}
else if(a == "die")
{
}
}
void kgmOSL::_Sound::play(bool loop)
{
SLresult result;
result = (*audioPlayerQueue)->Enqueue(audioPlayerQueue, buffer, length);
if(result != SL_RESULT_SUCCESS)
return;
this->loop = loop;
if(loop && audioSeek)
{
SLmillisecond msec;
result = (*audioPlayer)->GetDuration(audioPlayer, &msec);
if(SL_RESULT_SUCCESS == result)
{
result = (*audioSeek)->SetLoop(audioSeek, SL_BOOLEAN_TRUE, 0, msec);
}
}
#ifdef DEBUG
kgm_log() << "OSL sound played\n";
#endif
}
kgmShader* kgmGameResources::getShader(const char* id)
{
kgm_log() << "Resources: get shader " << id << "\n";
kgmShader* shader = (kgmShader*)get(id);
if(shader)
return shader;
kgmCString name;
name = id;
kgmMemory<u8> mem;
if(getFile(name, mem))
{
kgmString s((const char*)mem.data(), mem.length());
shader = m_tools.genShader(m_gc, s);
}
if(shader)
{
shader->m_id = id;
lock(shader);
add(shader);
}
return shader;
}
JNIEXPORT void JNICALL Java_com_kgmEngine_kSpacer_kSpacerLib_onKeyboard(JNIEnv * env, jobject obj, jint a, jint key)
{
#ifdef DEBUG
kgm_log() << "Java_com_kgmEngine_kSpacer_kSpacerLib_onKeyboard \n";
#endif
kgmGameApp::gameApplication()->android_onKeyboard(env, obj, a, key);
}
void kgmOSL::_Sound::release()
{
remove = true;
#ifdef DEBUG
kgm_log() << "OSL remove flag set \n";
#endif
}
JNIEXPORT void JNICALL Java_com_kgmEngine_kSpacer_kSpacerLib_idle(JNIEnv * env, jobject obj)
{
#ifdef DEBUG
kgm_log() << "Java_com_kgmEngine_kSpacer_kSpacerLib_idle \n";
#endif
kgmGameApp::gameApplication()->android_idle(env, obj);
}
JNIEXPORT void JNICALL Java_com_kgmEngine_kSpacer_kSpacerLib_onTouch(JNIEnv * env, jobject obj, jint a, jint x, jint y)
{
#ifdef DEBUG
kgm_log() << "Java_com_kgmEngine_kSpacer_kSpacerLib_onTouch \n";
#endif
kgmGameApp::gameApplication()->android_onTouch(env, obj, a, x, y);
}
JNIEXPORT void JNICALL Java_com_kgmEngine_kSpacer_kSpacerLib_onGyroscope(JNIEnv * env, jobject obj, jfloat x, jfloat y, jfloat z)
{
#ifdef DEBUG
kgm_log() << "Java_com_kgmEngine_kSpacer_kSpacerLib_onGyroscope \n";
#endif
kgmGameApp::gameApplication()->android_onGyroscope(env, obj, x, y, z);
}
//WinMain Function
int __stdcall WinMain(HINSTANCE a, HINSTANCE b, LPSTR pStr, int s)
{
typedef char* char_ptr;
int rValue = 0;
hInst = a;
int argc = 0;
char *args = 0;
char **argv = 0;
if(pStr != NULL)
{
argv = new char_ptr[sizeof(char_ptr) * 256];
args = new char[strlen(GetCommandLine()) + 1];
memset(args, 0, strlen(GetCommandLine()) + 1);
strcpy(args, GetCommandLine());
char* pch = strtok(args, " ");
while(pch != NULL)
{
argc++;
if(argc > 255)
break;
argv[argc - 1] = pch;
pch = strtok(NULL, " ");
}
}
signal(SIGINT, kgm_signal_handler);
signal(SIGILL, kgm_signal_handler);
signal(SIGTERM, kgm_signal_handler);
signal(SIGSEGV, kgm_signal_handler);
signal(SIGABRT, kgm_signal_handler);
signal(SIGBREAK, kgm_signal_handler);
kgm_log() << "LOL: " << pStr << "\n";
if(kgmApp::application())
kgmApp::application()->main(argc, argv);
if(args)
delete [] args;
if(argv)
delete [] argv;
//kgmClearAllocatedMemory();
return rValue;
}
void kgmOSL::run()
{
active = true;
#ifdef DEBUG
kgm_log() << "OSL Gues whooo.....\n";
kgm_log() << "osl thread id " << (s32)gettid();
#endif
while(active)
{
kgmThread::mutex_lock(mux);
for(int i = sounds.length(); i > 0; --i)
{
_Sound* s = sounds[i - 1];
#ifdef DEBUG
kgm_log() << "OSL sound " << i << "\n";
#endif
if(s->remove)
{
delete s;
sounds.erase(i - 1);
continue;
}
float dst = s->position.distance(position);
float vol = (700 - dst) / 750;
if(vol < 0)
vol = 0;
s->volume(vol);
}
kgmThread::mutex_unlock(mux);
kgmSystem::sleep(500);
}
}
~kApp()
{
if (game)
{
delete game;
}
#ifdef DEBUG
kgm_log() << "kApp::~kApp.\n";
#endif
}
void kApp::main()
{
kgm_log() << "Start\n";
editor = new kEditor();
m_game = editor;
editor->loop();
delete editor;
}
int gCommand(kgmString s)
{
if(s == "gameover_fail")
{
m_state = kgmIGame::State_Stop;
gui->viewAgain();
}
else if(s == "gameover_success")
{
m_state = kgmIGame::State_Stop;
gui->viewAgain();
}
else if(s == "gui_update")
{
kgm_log() << "update gui";
gui->updateMaps((char**)g_maps, (u32)g_maps_unlock);
data.umaps = g_maps_unlock;
saveData();
kgm_log() << "updated gui";
}
}
void kgmOSL::OSL_sound_bufferQueue_callback(SLBufferQueueItf caller,void *pContext)
{
_Sound* s = (_Sound*)pContext;
#ifdef DEBUG
kgm_log() << "OSL queue callback\n";
#endif
if(!s)
return;
#ifdef DEBUG
kgm_log() << "OSL context is valid\n";
#endif
if(s->loop && s->audioPlayerQueue)
{
(*s->audioPlayerQueue)->Clear(s->audioPlayerQueue);
s->play(s->loop);
s->volume(s->vol);
}
}
void kgmOSL::_Sound::pause()
{
SLresult result;
result = (*audioPlayer)->SetPlayState(audioPlayer, SL_PLAYSTATE_PAUSED);
#ifdef DEBUG
if(SL_RESULT_SUCCESS != result)
{
kgm_log() << "OSL error while sound pause\n";
}
#endif
}
void kgmOSL::_Sound::stop()
{
SLresult result;
result = (*audioPlayer)->SetPlayState(audioPlayer, SL_PLAYSTATE_STOPPED);
if (result) {
}
#ifdef DEBUG
kgm_log() << "OSL sound stopped\n";
#endif
}
kgmOSL::~kgmOSL()
{
active = false;
#ifdef DEBUG
kgm_log() << "OSL stoping thread\n";
#endif
join();
#ifdef DEBUG
kgm_log() << "OSL thread stoped\n";
#endif
if(outputMixObject)
{
#ifdef DEBUG
kgm_log() << "OSL delete outputMixObject \n";
#endif
(*outputMixObject)->Destroy(outputMixObject);
}
if(engineObject)
{
#ifdef DEBUG
kgm_log() << "OSL delete engineObject \n";
#endif
(*engineObject)->Destroy(engineObject);
}
kgmThread::mutex_free(mux);
#ifdef DEBUG
kgm_log() << "OSL finish\n";
#endif
}
JNIEXPORT void JNICALL Java_com_kgmEngine_kSpacer_kSpacerLib_init(JNIEnv* env, jobject obj, jint width, jint height, jobject am,
jobject surface)
{
#ifdef DEBUG
kgm_log() << "Java_com_kgmEngine_kSpacer_kSpacerLib_init\n";
#endif
g_loc_dir = "/data/data/com.kgmEngine.kSpacer";
if(kgmGameApp::gameApplication()->game())
{
kgmGameApp::gameApplication()->game()->getWindow()->setRect(0, 0, width, height);
}
else
{
kgm_android_init_app();
kgmGameApp::gameApplication()->android_init(env, obj, width, height, am, surface);
}
}
bool kgmGameApp::exportProject(kgmString path)
{
kgmFile file;
if (!file.open(path, kgmFile::Write | kgmFile::Create))
{
kgm_log() << "Cannot open path " << (s8*) path << "\n";
return false;
}
for (u32 i = 0; i < kgmUnit::g_typ_objects.length(); i++)
{
}
file.close();
return true;
}
void kgmOSL::_Sound::volume(float v)
{
SLresult result;
if(audioVolume)
{
SLmillibel minvol = -900;
SLmillibel maxvol;
SLmillibel newvol = minvol + 900 * v; //((minvol - maxvol) * (1.0 - vol)) + maxvol;
result = (*audioVolume)->GetMaxVolumeLevel(audioVolume, &maxvol);
result = (*audioVolume)->SetVolumeLevel(audioVolume, newvol);
if(SL_RESULT_SUCCESS != result)
{
#ifdef DEBUG
kgm_log() << "OSL can't set volume: " << newvol << "from max volume: " << maxvol << "\n";
#endif
}
vol = v;
}
}
int kgmWindow::WndProc(kgmWindow* wnd, XEvent* evt)
{
Window wroot, wchild;
kgmEvent::Event m_evt = {0};
int rx, ry, cx, cy;
unsigned int mask;
KeySym ksym;
switch(evt->type)
{
case Expose:
m_evt.event = evtPaint;
break;
case ConfigureNotify:
m_evt.event = evtResize;
m_evt.x = evt->xconfigure.x;
m_evt.y = evt->xconfigure.y;
m_evt.width = evt->xconfigure.width;
m_evt.height = evt->xconfigure.height;
break;
case MotionNotify:
XQueryPointer(wnd->m_dpy, wnd->m_wnd, &wroot, &wchild, &rx, &ry, &cx, &cy, &mask);
m_evt.event = evtMsMove;
switch(((XMotionEvent*)evt)->state)
{
case Button1Mask:
m_evt.keyMask = KEY_MSBLEFT;
break;
case Button2Mask:
m_evt.keyMask = KEY_MSBMIDDLE;
break;
case Button3Mask:
m_evt.keyMask = KEY_MSBRIGHT;
break;
default:
m_evt.keyMask = KEY_NONE;
}
if(!wnd->m_msAbs)
{
unsigned int x, y, w, h, border, depth;
Window dummy;
XGetGeometry(wnd->m_dpy, wnd->m_wnd, &dummy, (int*)&x, (int*)&y, (u32*)&w, (u32*)&h, &border, &depth);
m_evt.msx = w / 2 - evt->xbutton.x;
m_evt.msy = h / 2 - evt->xbutton.y;
static bool seted = false;
if(seted)
{
seted = false;
}
else
{
XWarpPointer(wnd->m_dpy, wnd->m_wnd, wnd->m_wnd, 0, 0, w, h, w / 2, h / 2);
seted = true;
}
}
else
{
m_evt.msx = evt->xbutton.x;
m_evt.msy = evt->xbutton.y;
}
break;
case MappingNotify:
XRefreshKeyboardMapping (&evt->xmapping) ;
break;
case ButtonPress:
case ButtonRelease:
m_evt.msx = evt->xbutton.x;
m_evt.msy = evt->xbutton.y;
switch(evt->xbutton.button){
case Button1:
if(evt->type == ButtonPress)
m_evt.event = evtMsLeftDown;
else
m_evt.event = evtMsLeftUp;
break;
case Button2:
if(evt->type == ButtonPress)
m_evt.event = evtMsMiddleDown;
else
m_evt.event = evtMsMiddleUp;
break;
case Button3:
if(evt->type == ButtonPress)
m_evt.event = evtMsRightDown;
else
m_evt.event = evtMsRightUp;
break;
case Button4:
m_evt.event = evtMsWheel;
m_evt.msz = 1;
break;
case Button5:
m_evt.event = evtMsWheel;
m_evt.msz = -1;
break;
}
break;
case KeyPress:
ksym = keyTranslate(XLookupKeysym(&evt->xkey, 0));
m_evt.event = evtKeyDown;
m_evt.key = ksym;
break;
case KeyRelease:
ksym = keyTranslate(XLookupKeysym(&evt->xkey, 0));
m_evt.event = evtKeyUp;
m_evt.key = ksym;
break;
case ClientMessage:
m_evt.event = evtClose;
//if(evt->xclient.data.l[0] == wnd->m_wmDelete)
// wnd->m_loop = false;
// if (*XGetAtomName(wnd->m_dpy, (Atom)&evt->xclient.message_type) == *"WM_PROTOCOLS")
// m_evt.event = evtClose;
kgm_log() << "got close event" << "\n";
break;
default:
m_evt.event = evtNone;
break;
}
if(wnd && m_evt.event)
wnd->onEvent(&m_evt);
return 1;
}
kgmIAudio::Sound kgmOSL::create(FMT fmt, u16 freq, u32 size, void* data)
{
if(!engineObject)
return null;
SLuint32 bitsPerSample = 0xffffffff;
#ifdef DEBUG
kgm_log() << "OSL create buffer: " << (s32)fmt << " " << (s32)freq << "\n";
#endif
switch((u32) fmt)
{
case FMT_MONO8:
bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_8;
break;
case FMT_MONO16:
bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
break;
case FMT_STEREO8:
bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_8;
break;
case FMT_STEREO16:
bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
break;
}
SLuint32 samplingRate = freq * 1000;
if(!data || !size ||
(samplingRate == 0xffffffff) ||
(bitsPerSample == 0xffffffff))
return null;
_Sound* sound = new _Sound(this);
SLresult result;
sound->buffer = malloc(size);
memcpy(sound->buffer, data, size);
sound->length = size;
/*const SLuint32 lBGMPlayerIIDCount = 1;
const SLInterfaceID lBGMPlayerIIDs[] =
{ SL_IID_PLAY, SL_IID_SEEK };
const SLboolean lBGMPlayerReqs[] =
{ SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE };
SLDataLocator_Address loc_bufq = {SL_DATALOCATOR_ADDRESS, sound->buffer, size};
SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, 1, samplingRate,
bitsPerSample, bitsPerSample,
SL_SPEAKER_FRONT_CENTER, SL_BYTEORDER_LITTLEENDIAN};
SLDataSource audioSrc = {&loc_bufq, &format_pcm};
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
SLDataSink audioSnk = {&loc_outmix, NULL};
result = (*engineEngine)->CreateAudioPlayer(engineEngine,
&sound->audioPlayerObject, &audioSrc, &audioSnk,
lBGMPlayerIIDCount, lBGMPlayerIIDs, lBGMPlayerReqs);
if (result != SL_RESULT_SUCCESS)
{
}
result = (*sound->audioPlayerObject)->Realize(sound->audioPlayerObject, SL_BOOLEAN_FALSE);
if (result != SL_RESULT_SUCCESS)
{
}
result = (*sound->audioPlayerObject)->GetInterface(sound->audioPlayerObject,
SL_IID_PLAY, &sound->audioPlayer);
if (result != SL_RESULT_SUCCESS)
{
}
result = (*sound->audioPlayerObject)->GetInterface(sound->audioPlayerObject,
SL_IID_SEEK, &sound->audioSeek);
if (result != SL_RESULT_SUCCESS)
{
}*/
// configure audio source
SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, 1, samplingRate,
bitsPerSample, bitsPerSample,
SL_SPEAKER_FRONT_CENTER, SL_BYTEORDER_LITTLEENDIAN};
SLDataSource audioSrc = {&loc_bufq, &format_pcm};
// configure audio sink
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
SLDataSink audioSnk = {&loc_outmix, NULL};
// create audio player
const SLInterfaceID ids_1[3] = {SL_IID_BUFFERQUEUE, SL_IID_EFFECTSEND, SL_IID_VOLUME};
const SLboolean req_1[3] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
#ifdef DEBUG
kgm_log() << "OSL init audioPlayerObject \n";
#endif
result = (*engineEngine)->CreateAudioPlayer(engineEngine, &sound->audioPlayerObject, &audioSrc, &audioSnk,
3, ids_1, req_1);
if(result != SL_RESULT_SUCCESS)
{
delete sound;
return null;
}
// realize the player
#ifdef DEBUG
kgm_log() << "OSL Realize audioPlayerObject \n";
#endif
result = (*sound->audioPlayerObject)->Realize(sound->audioPlayerObject, SL_BOOLEAN_FALSE);
if(result != SL_RESULT_SUCCESS)
{
delete sound;
return null;
}
#ifdef DEBUG
kgm_log() << "OSL init audioPlayerQueue \n";
#endif
result = (*sound->audioPlayerObject)->GetInterface(sound->audioPlayerObject, SL_IID_BUFFERQUEUE, &sound->audioPlayerQueue);
if(result != SL_RESULT_SUCCESS)
{
delete sound;
return null;
}
//OSL_sound_bufferQueue_callback
(*sound->audioPlayerQueue)->RegisterCallback(sound->audioPlayerQueue, (slAndroidSimpleBufferQueueCallback) OSL_sound_bufferQueue_callback, sound);
#ifdef DEBUG
kgm_log() << "OSL init audioPlayer \n";
#endif
result = (*sound->audioPlayerObject)->GetInterface(sound->audioPlayerObject, SL_IID_PLAY, &sound->audioPlayer);
if(result != SL_RESULT_SUCCESS)
{
delete sound;
return null;
}
#ifdef DEBUG
kgm_log() << "OSL init audioVolume \n";
#endif
result = (*sound->audioPlayerObject)->GetInterface(sound->audioPlayerObject, SL_IID_VOLUME, &sound->audioVolume);
if(result != SL_RESULT_SUCCESS)
{
delete sound;
return null;
}
#ifdef DEBUG
kgm_log() << "OSL init audioSeek \n";
#endif
result = (*sound->audioPlayerObject)->GetInterface(sound->audioPlayerObject, SL_IID_SEEK, &sound->audioSeek);
if(result != SL_RESULT_SUCCESS)
{
#ifdef DEBUG
kgm_log() << "OSL failed audioSeek\n";
#endif
//delete sound;
//return null;
}
#ifdef DEBUG
kgm_log() << "OSL SetPlayState audioPlayer \n";
#endif
result = (*sound->audioPlayer)->SetPlayState(sound->audioPlayer, SL_PLAYSTATE_PLAYING);
if(result != SL_RESULT_SUCCESS)
{
delete sound;
return null;
}
if(listenerObject)
{
}
sounds.add(sound);
return (kgmIAudio::Sound*) sound;
}
~kGame()
{
#ifdef DEBUG
kgm_log() << "kGame::~kGame.\n";
#endif
}
bool kgmGameResources::getFile(const char* id, kgmMemory<u8>& m)
{
kgmString path;
int i = 0;
if(!id)
return false;
#ifdef WIN32
const kgmString delim((const char*)"\\", 1);
#else
const kgmString delim((const char*)"/", 1);
#endif
#ifdef ANDROID
#ifdef DEBUG
kgm_log() << "\nkgmEngine android loading file " << id << "\n";
#endif
AAsset* asset = AAssetManager_open(kgm_android_getAssetManager(), (const char *) id, AASSET_MODE_UNKNOWN);
if (NULL == asset)
{
#ifdef DEBUG
kgmLog::log("_ASSET_NOT_FOUND_");
#endif
return false;
}
long size = AAsset_getLength(asset);
m.alloc(size);
AAsset_read (asset, m.data(), size);
#ifdef DEBUG
kgm_log() << "\nkgmEngine android file size: " << (s32)size << "\n";
#endif
AAsset_close(asset);
return true;
#else
for(i = 0; i < m_paths.size(); i++)
{
kgmFile file;
if(m_paths[i]->type == 2)
{
path = m_paths[i]->path + delim + kgmString(id, strlen(id));
if(kgmIGame::getGame()->getSystem()->isFile(path) && file.open(path, kgmFile::Read))
{
m.alloc(file.length());
file.read(m.data(), file.length());
file.close();
return true;
}
}
else if(m_paths[i]->type == 1)
{
if(m_paths[i]->archive.copy(id, m))
{
return true;
}
}
}
#endif
#ifdef DEBUG
kgm_log() << "kgmGameResources::getFile Cannot load file: " << id << "\n";
#endif
return false;
}
kgmWindow::kgmWindow(kgmWindow* wp, kgmString wname, int x, int y, int w, int h, int bpp, bool fs)
{
m_parent = wp;
m_msAbs = true;
m_msf = false;
m_fs = false;
kgmLog::log("Init screen");
#ifdef WIN32
WNDCLASS wcl;
if(!GetClassInfo(0, cWndClass, &wcl))
kgmRegisterWindowClass();
m_wnd = CreateWindow(cWndClass, wname,
(fs)?(WS_POPUP|WS_VISIBLE):(WS_OVERLAPPEDWINDOW|WS_VISIBLE),
x, y, w, h,
(wp)?(wp->m_wnd):(0), 0, 0, 0);
SetWindowLong(m_wnd, GWL_USERDATA, (LONG)this);
ShowWindow(m_wnd, SW_SHOW);
UpdateWindow(m_wnd);
#elif defined(ANDROID)
kgm_log() << "Init window rect: " << w << " " << h << ".";
m_wRect[0] = x;
m_wRect[1] = y;
m_wRect[2] = w;
m_wRect[3] = h;
#else
XSetWindowAttributes swa;
int cmask = CWColormap | CWBorderPixel | CWEventMask | CWOverrideRedirect;
m_dpy = (wp) ? (wp->m_dpy) : XOpenDisplay(NULL);
m_screen = (wp) ? (wp->m_screen) : DefaultScreen(m_dpy);
m_wnd = XCreateSimpleWindow(m_dpy, (wp)?(wp->m_wnd):RootWindow(m_dpy, 0),
x, y, w, h, 0, BlackPixel(m_dpy, 0), BlackPixel(m_dpy, 0));
//m_wnd = XCreateWindow(m_dpy, DefaultRootWindow(m_dpy), x, y, w, h, 0,
// DefaultDepth(m_dpy, 0), InputOutput, DefaultVisual(m_dpy, 0),
// cmask, &swa);
//m_wnd = XCreateWindow(m_dpy, RootWindow(m_dpy, 0), x, y, w, h, 0,
// DefaultDepth(m_dpy, 0), InputOutput, DefaultVisual(m_dpy, 0),
// cmask, &swa);
Atom delWindow = XInternAtom( m_dpy, "WM_DELETE_WINDOW", 0 );
XSetWMProtocols(m_dpy, m_wnd, &delWindow, 1);
XSelectInput(m_dpy, m_wnd, ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask |
ButtonReleaseMask | PointerMotionMask | StructureNotifyMask | ButtonMotionMask);
XMapWindow(m_dpy, m_wnd);
XStoreName(m_dpy, m_wnd, wname);
XFlush(m_dpy);
Bool b_ret;
XkbSetDetectableAutoRepeat(m_dpy, True, &b_ret);
#endif
}
kgmDSound::kgmDSound()
{
m_pSnd = null;
m_pSbuf = null;
m_proceed = false;
if(FAILED(DirectSoundCreate(0, &m_pSnd, 0)))
{
#ifdef DEBUG
kgm_log() << "Error: can't create direct sound.\n";
#endif
return;
}
//Set Cooperative Level
HWND hWnd = GetForegroundWindow();
if (hWnd == NULL)
{
hWnd = GetDesktopWindow();
}
if(m_pSnd->SetCooperativeLevel((HWND)hWnd, DSSCL_PRIORITY) != DS_OK)
{
#ifdef DEBUG
kgm_log() << "Error: can't set cooperative level.\n";
#endif
}
m_mixer.prepare(2, 16, 44100);
u32 size = m_mixer.getLength();
void* data = m_mixer.getBuffer();
DSBUFFERDESC dsb = {0};
WAVEFORMATEX wf = {0};
if(!m_pSnd)
{
#ifdef DEBUG
kgm_log() << "Error: not valid direct sound or data.\n";
#endif
return;
}
wf.cbSize = sizeof(WAVEFORMATEX);
wf.nSamplesPerSec = m_mixer.getRate();
wf.wFormatTag = WAVE_FORMAT_PCM;
switch(m_mixer.getFormat())
{
case FMT_MONO8:
wf.nChannels = 1;
wf.wBitsPerSample = 8;
break;
case FMT_MONO16:
wf.nChannels = 1;
wf.wBitsPerSample = 16;
break;
case FMT_STEREO8:
wf.nChannels = 2;
wf.wBitsPerSample = 8;
break;
case FMT_STEREO16:
wf.nChannels = 2;
wf.wBitsPerSample = 16;
break;
default:
m_pSnd->Release();
m_pSnd = null;
return;
}
wf.nBlockAlign = wf.nChannels * ( wf.wBitsPerSample / 8 );
wf.nAvgBytesPerSec = wf.nBlockAlign * wf.nSamplesPerSec;
dsb.dwSize = sizeof(DSBUFFERDESC);
dsb.dwFlags = DSBCAPS_STATIC | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPAN;
dsb.dwBufferBytes = size;
dsb.lpwfxFormat = &wf;
if(FAILED(m_pSnd->CreateSoundBuffer(&dsb, &m_pSbuf, 0)))
{
#ifdef DEBUG
kgm_log() << "Error: can't create sound buffer.\n";
#endif
m_pSbuf = null;
m_pSnd->Release();
m_pSnd = null;
return;
}
if(m_pSbuf)
{
if(FAILED(m_pSbuf->Play(0, 0, DSBPLAY_LOOPING)))
{
m_pSbuf->Release();
m_pSnd->Release();
m_pSbuf = null;
m_pSnd = null;
}
else
{
m_timer = timeSetEvent(m_mixer.getMsTime() - 10, 0, (LPTIMECALLBACK)DirectSoundProc, (DWORD)this,
(UINT)TIME_CALLBACK_FUNCTION | TIME_PERIODIC);
m_proceed = true;
//m_thread.start(this, &kgmDSound::proceed);
m_thread.priority(kgmThread::PrIdle);
m_mutex = kgmThread::mutex();
}
}
}
int kgmDSound::proceed(int p)
{
static u32 max_sounds = 10;
(void*)p;
m_proceed = true;
while(m_proceed)
{
u32 snd_cound = 0;
kgmThread::lock(m_mutex);
#ifdef DEBUG
kgm_log() << "kgmDSound:: proceed lock " << kgmTime::getTimeText() << "\n";
#endif
m_mixer.clean();
u32 t1 = kgmTime::getTicks();
for(kgmList<_Sound*>::iterator i = m_sounds.begin(); i != m_sounds.end(); ++i)
{
_Sound* sound = (*i);
if(snd_cound > max_sounds)
break;
if(sound->remove)
{
i = m_sounds.erase(i);
delete sound;
continue;
}
if(sound->state != _Sound::StPlay)
continue;
u32 size = m_mixer.mixdata((void*) (((size_t) sound->data) + sound->cursor),
(sound->size - sound->cursor),
sound->channels,
sound->bps,
sound->rate,
sound->vol,
sound->pan);
if((sound->cursor + size) == sound->size)
{
sound->cursor = 0;
if(!sound->loop)
sound->stop();
}
else
{
sound->cursor += size;
}
snd_cound++;
}
//render();
kgmThread::unlock(m_mutex);
#ifdef DEBUG
kgm_log() << "kgmDSound:: proceed unlock " << kgmTime::getTimeText() << "\n";
#endif
u32 t2 = kgmTime::getTicks();
u32 t3 = t2 - t1;
if(t3 < m_mixer.getMsTime())
{
s32 wtime = m_mixer.getMsTime() - t3;
kgmThread::sleep(wtime / 2);
}
}
return 0;
}
