void idle()
{
g_iFrame++;
g_iTime = glutGet(GLUT_ELAPSED_TIME);
if (g_iTime - g_iTimebase > 1000) {
sprintf_s(fpsString, "FPS:%4.2f\n Planets: %i Time: %i", g_iFrame * 1000.0 / (g_iTime - g_iTimebase), getNumberOfPlanets(), g_iTime / 1000);
g_iTimebase = g_iTime;
g_iFrame = 0;
}
if (g_bPlaying) {
for(jrPlanet *pPlanet=g_pHead; pPlanet; pPlanet=pPlanet->m_pNext) {
applyTransitions(pPlanet);
}
}
if (g_bMaintainPlanets) {
maintainPlanetNumber();
}
g_uiNextTick += 1000 / (g_uiMaxFPS * g_fFPSMultiplier);
int iSleepTime = g_uiNextTick - glutGet(GLUT_ELAPSED_TIME);
if (iSleepTime < -1000) {
g_uiNextTick = glutGet(GLUT_ELAPSED_TIME); //we don't want the simulation getting faster, even if we lose time
}
if (iSleepTime >= 0) {
Sleep(iSleepTime);
}
mouseMotion();
glutPostRedisplay();
}
int inputManager::update(void)
{
SDL_Event currentEvent;
while ( !messageP.empty() )
{
AssetManager::lockMutex( inputManager::mutex_event );
currentEvent = messageP.receiveMessage();
AssetManager::unlockMutex( inputManager::mutex_event );
if (currentEvent.type == SDL_ACTIVEEVENT)
{
if ( currentEvent.active.state & SDL_APPINPUTFOCUS )
{
if (currentEvent.active.gain==0)
{
active = false;
SDL_WM_GrabInput(SDL_GRAB_OFF);
SDL_ShowCursor(SDL_ENABLE);
}
else
{
active = true;
SDL_ShowCursor(SDL_DISABLE);
SDL_WM_GrabInput(SDL_GRAB_ON);
}
}
}
if (active)
{
switch (currentEvent.type)
{
case SDL_KEYDOWN:
case SDL_KEYUP:
keyPress(currentEvent);
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
mousePress(currentEvent);
break;
case SDL_MOUSEMOTION:
mouseMotion(currentEvent);
break;
default:
break;
}
}
}
return 0;
}
bool EHLevel::handleEvent(Event * event)
{
bool ret = false;
switch(event->type()) {
case EVENT_MOUSE_CLICK:
{
EMouse * mouseEvent = static_cast<EMouse *>(event);
//Logger::write(Logger::ss << "Mouse Click " << mouseEvent->position().toString());
if(mouseEvent->button() == MOUSE_BUTTON_LEFT) {
mouseLeftClick(mouseEvent->position());
}
else if(mouseEvent->button() == MOUSE_BUTTON_RIGHT) {
mouseRightClick(mouseEvent->position());
}
ret = true;
break;
}
case EVENT_MOUSE_MOTION:
{
EMouse * mouseEvent = static_cast<EMouse *>(event);
mouseMotion(mouseEvent->position());
ret = true;
break;
}
case EVENT_GAME_QUIT:
{
Game::instance()->setQuit(true);
ret = true;
break;
}
case EVENT_KEY_PRESS:
{
EKeyPress * keyEvent = static_cast<EKeyPress *>(event);
keyPress(keyEvent->keyType());
ret = true;
break;
}
}
return ret;
}
/**
* Handles application input.
*/
void BaseGame::pEvents()
{
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type)
{
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE)
{
running = false;
break;
}
keyDown(event.key.keysym.sym);
break;
case SDL_KEYUP:
keyUp(event.key.keysym.sym);
break;
case SDL_QUIT:
running = false;
break;
case SDL_VIDEORESIZE:
screen = SDL_SetVideoMode(event.resize.w, event.resize.h, 32, flags);
resize(event.resize.w, event.resize.h);
break;
case SDL_MOUSEMOTION:
mouseMotion(event.button.button, event.motion.x, event.motion.y);
break;
case SDL_MOUSEBUTTONUP:
mouseBtnUp(event.button.button, event.motion.x, event.motion.y);
break;
case SDL_MOUSEBUTTONDOWN:
mouseBtnDown(event.button.button, event.motion.x, event.motion.y);
break;
}
}
}
void AParameterUIObjectSliderFloat::mouseDown( int _x, int _y, int _button )
{
// update child objects
AParameterUIObjectBase* tmpObj;
for( unsigned int i = 0; i < uiObjects.size(); i++ )
{
tmpObj = (AParameterUIObjectBase*) uiObjects.at( i );
//tmpObj->mouseDown( insideX, insideY, _button );
tmpObj->mouseDown( _x, _y, _button );
}
if( isPointInsideRect( _x, _y, posx, posy, width, height ) )
{
int insideX = _x - posx;
int insideY = _y - posy;
if( slider.pointIsInsideSlider( insideX, insideY ) )
{
//cout << _button;
slider.isBeingDragged = true;
mouseMotion( _x, _y ); // generate a dragged event to move the slider into this position
// update child objects
AParameterUIObjectBase* tmpObj;
for( unsigned int i = 0; i < uiObjects.size(); i++ )
{
tmpObj = (AParameterUIObjectBase*) uiObjects.at( i );
tmpObj->mouseDown( insideX, insideY, _button );
}
}
else
{
slider.isBeingDragged = false;
}
}
else
{
slider.isBeingDragged = false;
}
}
int main(int argc, char **argv) {
//////////////////////////////////////////////////////////////////////
// check joystick
//////////////////////////////////////////////////////////////////////
std::string commandNoJoystick = std::string(argv[0]) + " --no-joystick ";
Herve::utilInfo("to disable joystick, use : ", commandNoJoystick.c_str() , __FILE__, __LINE__);
if (argc == 2 and std::string(argv[1]) == "--no-joystick")
gEnableJoystick = false;
//////////////////////////////////////////////////////////////////////
// init
//////////////////////////////////////////////////////////////////////
// display device
gUptrDisplayDevice.reset(new HerveOvr::DisplayDeviceStereoOvr(1024, 1024));
if (not gUptrDisplayDevice->initDevice()) {
gUptrDisplayDevice.reset(new Herve::DisplayDeviceMono());
//gUptrDisplayDevice.reset(new Herve::DisplayDeviceStereoFake(1024, 1024));
gUptrDisplayDevice->initDevice();
}
// SDL
if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 )
Herve::utilError("SDL_Init", "", __FILE__, __LINE__);
const SDL_VideoInfo* info = SDL_GetVideoInfo();
int maxWidth = info->current_w;
int maxHeight = info->current_h;
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
gPtrSurface = SDL_SetVideoMode( gUptrDisplayDevice->getWidth(), gUptrDisplayDevice->getHeight(), 24, SDL_OPENGL|SDL_RESIZABLE );
if( gPtrSurface == NULL )
Herve::utilError("SDL_SetVideoMode", "", __FILE__, __LINE__);
atexit(SDL_Quit);
SDL_EnableUNICODE( SDL_TRUE );
SDL_WM_SetCaption( "DemoSdl1", NULL );
// joysticks
int nbJoysticks = SDL_NumJoysticks();
for(int i=0; i<nbJoysticks; i++) {
SDL_Joystick * stick = SDL_JoystickOpen( i );
if( stick ) {
Herve::utilInfo("joystick = ", SDL_JoystickName(i), __FILE__, __LINE__);
}
}
// scene data
gUptrDisplayDevice->initDisplay(maxWidth, maxHeight);
gScene.init(gUptrDisplayDevice.get());
gFpsCounter.start();
Herve::utilInfo("width = ", std::to_string(gUptrDisplayDevice->getWidth()).c_str(), __FILE__, __LINE__);
Herve::utilInfo("height = ", std::to_string(gUptrDisplayDevice->getHeight()).c_str(), __FILE__, __LINE__);
Herve::utilInfo("maxWidth = ", std::to_string(gUptrDisplayDevice->getMaxWidth()).c_str(), __FILE__, __LINE__);
Herve::utilInfo("maxHeight = ", std::to_string(gUptrDisplayDevice->getMaxHeight()).c_str(), __FILE__, __LINE__);
//////////////////////////////////////////////////////////////////////
// main loop
//////////////////////////////////////////////////////////////////////
SDL_Event event;
while (true) {
// handle events
while( SDL_PollEvent( &event ) ) {
switch(event.type) {
case SDL_QUIT:
exit(0);
break;
case SDL_KEYDOWN:
keyDown(event.key);
break;
case SDL_KEYUP:
keyUp(event.key);
break;
case SDL_MOUSEBUTTONUP :
mouseUp(event.button);
break;
case SDL_MOUSEBUTTONDOWN :
mouseDown(event.button);
break;
case SDL_MOUSEMOTION :
mouseMotion(event.motion);
break;
case SDL_VIDEORESIZE :
resize(event.resize);
break;
case SDL_JOYAXISMOTION :
joyMotion(event.jaxis);
break;
}
}
updateCamera();
render();
}
return 0;
}
bool EventHandler::handleEvent(SDL_Event &event) {
switch (event.type) {
case SDL_TEXTINPUT:
textInput(std::string(event.text.text));
break;
case SDL_KEYUP:
keyRelease((int32_t) event.key.keysym.sym);
break;
case SDL_KEYDOWN:
// we are handling this on our own
if (!event.key.repeat)
keyPress((int32_t) event.key.keysym.sym, (int16_t) event.key.keysym.mod);
break;
case SDL_MOUSEMOTION: {
if (event.motion.which == SDL_TOUCH_MOUSEID)
break;
SDL_Window *window = SDL_GetWindowFromID(event.motion.windowID);
if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_INPUT_FOCUS))
break;
mouseMotion(event.motion.x, event.motion.y, event.motion.xrel, event.motion.yrel);
break;
}
case SDL_MOUSEBUTTONDOWN:
if (event.button.which == SDL_TOUCH_MOUSEID)
break;
mouseButtonPress(event.button.x, event.button.y, event.button.button);
break;
case SDL_MOUSEBUTTONUP:
if (event.button.which == SDL_TOUCH_MOUSEID)
break;
mouseButtonRelease(event.button.x, event.button.y, event.button.button);
break;
case SDL_MOUSEWHEEL:
if (event.wheel.which == SDL_TOUCH_MOUSEID)
break;
mouseWheel(event.wheel.x, event.wheel.y);
break;
case SDL_CONTROLLERAXISMOTION: {
const uint8_t axis = event.caxis.axis;
if (axis != SDL_CONTROLLER_AXIS_LEFTX && axis != SDL_CONTROLLER_AXIS_LEFTY && axis != SDL_CONTROLLER_AXIS_RIGHTX && axis != SDL_CONTROLLER_AXIS_RIGHTY)
break;
const bool horizontal = (axis == SDL_CONTROLLER_AXIS_LEFTX || axis == SDL_CONTROLLER_AXIS_RIGHTX);
joystickMotion(horizontal, event.caxis.value);
break;
}
case SDL_CONTROLLERBUTTONDOWN:
controllerButtonPress(getControllerButtonName(event.cbutton.button));
break;
case SDL_CONTROLLERBUTTONUP:
controllerButtonRelease(getControllerButtonName(event.cbutton.button));
break;
case SDL_CONTROLLERDEVICEADDED:
joystickDeviceAdded(event.cdevice.which);
break;
case SDL_CONTROLLERDEVICEREMOVED:
joystickDeviceRemoved(event.cdevice.which);
break;
case SDL_JOYDEVICEADDED:
joystickDeviceAdded(event.jdevice.which);
break;
case SDL_JOYDEVICEREMOVED:
joystickDeviceRemoved(event.jdevice.which);
break;
case SDL_DOLLARRECORD:
gestureRecord(event.dgesture.gestureId);
break;
case SDL_DOLLARGESTURE:
gesture(event.dgesture.gestureId, event.dgesture.error, event.dgesture.numFingers);
break;
case SDL_MULTIGESTURE:
multiGesture(event.mgesture.dTheta, event.mgesture.dDist, event.mgesture.numFingers);
break;
case SDL_JOYHATMOTION:
break;
case SDL_JOYBUTTONDOWN:
joystickButtonPress(event.jbutton.button);
break;
case SDL_JOYBUTTONUP:
joystickButtonRelease(event.jbutton.button);
break;
case SDL_JOYAXISMOTION:
joystickMotion(event.jaxis.axis == 0, event.jaxis.value);
break;
case SDL_FINGERDOWN:
fingerPress(event.tfinger.fingerId, event.tfinger.x, event.tfinger.y);
break;
case SDL_FINGERUP:
fingerRelease(event.tfinger.fingerId, event.tfinger.x, event.tfinger.y);
break;
case SDL_FINGERMOTION:
fingerMotion(event.tfinger.fingerId, event.tfinger.x, event.tfinger.y, event.tfinger.dx, event.tfinger.dy);
break;
case SDL_WINDOWEVENT:
switch (event.window.event) {
case SDL_WINDOWEVENT_RESIZED:
case SDL_WINDOWEVENT_SIZE_CHANGED:
for (EventObservers::iterator i = _observers.begin(); i != _observers.end(); ++i) {
(*i)->onWindowResize();
}
break;
case SDL_WINDOWEVENT_CLOSE:
return false;
}
break;
}
return true;
}
void EventRecorder::redisplay(double t, double dt)
{
if (isRecording) {
recordedEvents.push_back(Event(t, dt, TerrainNode::nextGroundHeightAtCamera));
} else if (isPlaying) {
ostringstream s;
bool replay = true;
isPlaying = false;
while (replay && lastPlayed < recordedEvents.size()) {
Event e = recordedEvents[lastPlayed++];
switch (e.kind) {
case Event::DISPLAY:
t = e.display.t;
dt = e.display.dt;
TerrainNode::nextGroundHeightAtCamera = e.display.groundHeight;
replay = false;
break;
case Event::MOUSE:
mouseClick((button) e.e.arg1, (state) e.e.arg2, (modifier) e.e.m, e.e.arg3, e.e.arg4);
savedX = e.e.arg3;
savedY = e.e.arg4;
break;
case Event::MOTION:
mouseMotion(e.e.arg1, e.e.arg2);
savedX = e.e.arg1;
savedY = e.e.arg2;
break;
case Event::PASSIVEMOTION:
mousePassiveMotion(e.e.arg1, e.e.arg2);
savedX = e.e.arg1;
savedY = e.e.arg2;
break;
case Event::WHEEL:
mouseWheel((wheel) e.e.arg1, (modifier) e.e.m, e.e.arg2, e.e.arg3);
savedX = e.e.arg2;
savedY = e.e.arg3;
break;
case Event::KEYBOARD:
if (e.e.arg4 == 0) {
keyTyped(e.e.arg1, (modifier) e.e.m, e.e.arg2, e.e.arg3);
if (e.e.arg1 == 27) {
::exit(0);
}
} else {
keyReleased(e.e.arg1, (modifier) e.e.m, e.e.arg2, e.e.arg3);
}
break;
case Event::SPECIAL:
if (e.e.arg4 == 0) {
specialKey((key) e.e.arg1, (modifier) e.e.m, e.e.arg2, e.e.arg3);
} else {
specialKeyReleased((key) e.e.arg1, (modifier) e.e.m, e.e.arg2, e.e.arg3);
}
break;
}
}
isPlaying = lastPlayed < recordedEvents.size();
}
if (next != NULL) {
next->redisplay(t, dt);
}
if (isPlaying) {
ptr<FrameBuffer> fb = FrameBuffer::getDefault();
vec4<GLint> vp = fb->getViewport();
fb->setBlend(true, ADD, SRC_ALPHA, ONE_MINUS_SRC_ALPHA, ADD, ZERO, ONE);
fb->setColorMask(true, true, true, false);
fb->setDepthMask(false);
fb->setStencilMask(0, 0);
correctU->set(vec3f(0.f, 0.f, 1.f));
rescaleU->set(vec4f(2.0f * (float)(savedX + 0.5f * cursW) / vp.z - 1.0f, 2.0f * (float)(vp.w - savedY - 0.5f * cursH) / vp.w - 1.0f, cursW / (float)vp.z, cursH / (float)vp.w));
cursorSamplerU->set(cursor);
fb->drawQuad(cursorProg);
fb->setBlend(false);
fb->setColorMask(true, true, true, true);
fb->setDepthMask(true);
fb->setStencilMask(0xFFFFFFFF,0xFFFFFFFF);
}
if (isPlaying && saveVideo) {
int frameCount = 0;
if (lastSavedEvent >= 0) {
double prevTime = recordedEvents[lastSavedEvent].display.t;
double curTime = recordedEvents[lastPlayed - 1].display.t;
assert(recordedEvents[lastSavedEvent].kind == Event::DISPLAY && prevTime > 0.0);
assert(recordedEvents[lastPlayed - 1].kind == Event::DISPLAY && curTime > 0.0);
frameCount = int(floor(curTime / 40000.0) - floor(prevTime / 40000.0));
}
// if the delay between two recorded frames is more than 1/25 of a second
// the first one must be saved several times in the video to keep a video
// framerate of 25 frames per second.
for (int i = 0; i < frameCount; ++i) {
char name[256];
sprintf(name, frames, lastSavedFrame++);
saveFrame(name);
}
lastSavedEvent = lastPlayed - 1;
}
}
void TransIcelandicExpress::eventLoop() {
while (1) {
SDL_Event event;
/* Grab all the events off the queue. */
while( SDL_PollEvent( &event ) ) {
switch( event.type ) {
case SDL_MOUSEMOTION:
mouseMotion( event.motion.xrel, event.motion.yrel );
break;
case SDL_KEYDOWN:
switch( event.key.keysym.sym ) {
case SDLK_ESCAPE:
do_quit();
break;
case SDLK_SPACE:
printf("space\n");
break;
case SDLK_1:
sfx_chan[0] = Mix_PlayChannel(-1, sfx[0], 0);
break;
case SDLK_2:
sfx_chan[1] = Mix_PlayChannel(-1, sfx[1], 0);
break;
case SDLK_3:
sfx_chan[2] = Mix_PlayChannel(-1, sfx[2], 0);
break;
case SDLK_HOME:
ilutGLScreenie();
break;
case SDLK_h:
showHelp = !showHelp;
break;
case SDLK_m:
if (!musicOn) {
printf("Playing\n");
Mix_PlayMusic( music, -1 );
musicOn = 1;
} else {
printf("Halting\n");
Mix_HaltMusic();
musicOn = 0;
}
default:
break;
}
break;
case SDL_QUIT:
/* Handle quit requests (like Ctrl-c). */
do_quit();
break;
}
}
// check non-instant keys
cf_moveForward = 0.0;
cf_moveSideways = 0.0;
Uint8 *keys;
keys = SDL_GetKeyState(NULL);
if (keys[SDLK_w] && !keys[SDLK_s]) {
cf_moveForward = 1.0;
}
if (!keys[SDLK_w] && keys[SDLK_s]) {
cf_moveForward = -1.0;
}
if (keys[SDLK_a] && !keys[SDLK_d]) {
cf_moveSideways = -1.0;
}
if (!keys[SDLK_a] && keys[SDLK_d]) {
cf_moveSideways = 1.0;
}
computeTimeDelta();
simulate();
redraw();
}
}
