void sdlgl_update(hwrbitmap d,s16 x,s16 y,s16 w,s16 h) { SDL_GL_SwapBuffers(); }
void Graphics::FlipBuffers() { SDL_GL_SwapBuffers(); }
int RunGLTest( int argc, char* argv[], int logo, int logocursor, int slowly, int bpp, float gamma, int noframe, int fsaa, int sync, int accel ) { int i; int rgb_size[3]; int w = 640; int h = 480; int done = 0; int frames; Uint32 start_time, this_time; float color[8][3]= {{ 1.0, 1.0, 0.0}, { 1.0, 0.0, 0.0}, { 0.0, 0.0, 0.0}, { 0.0, 1.0, 0.0}, { 0.0, 1.0, 1.0}, { 1.0, 1.0, 1.0}, { 1.0, 0.0, 1.0}, { 0.0, 0.0, 1.0}}; float cube[8][3]= {{ 0.5, 0.5, -0.5}, { 0.5, -0.5, -0.5}, {-0.5, -0.5, -0.5}, {-0.5, 0.5, -0.5}, {-0.5, 0.5, 0.5}, { 0.5, 0.5, 0.5}, { 0.5, -0.5, 0.5}, {-0.5, -0.5, 0.5}}; Uint32 video_flags; int value; if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) { fprintf(stderr,"Couldn't initialize SDL: %s\n",SDL_GetError()); exit( 1 ); } /* See if we should detect the display depth */ if ( bpp == 0 ) { if ( SDL_GetVideoInfo()->vfmt->BitsPerPixel <= 8 ) { bpp = 8; } else { bpp = 16; /* More doesn't seem to work */ } } /* Set the flags we want to use for setting the video mode */ if ( logo && USE_DEPRECATED_OPENGLBLIT ) { video_flags = SDL_OPENGLBLIT; } else { video_flags = SDL_OPENGL; } for ( i=1; argv[i]; ++i ) { if ( strcmp(argv[i], "-fullscreen") == 0 ) { video_flags |= SDL_FULLSCREEN; } } if (noframe) { video_flags |= SDL_NOFRAME; } /* Initialize the display */ switch (bpp) { case 8: rgb_size[0] = 3; rgb_size[1] = 3; rgb_size[2] = 2; break; case 15: case 16: rgb_size[0] = 5; rgb_size[1] = 5; rgb_size[2] = 5; break; default: rgb_size[0] = 8; rgb_size[1] = 8; rgb_size[2] = 8; break; } SDL_GL_SetAttribute( SDL_GL_RED_SIZE, rgb_size[0] ); SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, rgb_size[1] ); SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, rgb_size[2] ); SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 ); SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); if ( fsaa ) { SDL_GL_SetAttribute( SDL_GL_MULTISAMPLEBUFFERS, 1 ); SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, fsaa ); } if ( accel ) { SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 ); } if ( sync ) { SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 1 ); } else { SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 0 ); } if ( SDL_SetVideoMode( w, h, bpp, video_flags ) == NULL ) { fprintf(stderr, "Couldn't set GL mode: %s\n", SDL_GetError()); SDL_Quit(); exit(1); } printf("Screen BPP: %d\n", SDL_GetVideoSurface()->format->BitsPerPixel); printf("\n"); printf( "Vendor : %s\n", glGetString( GL_VENDOR ) ); printf( "Renderer : %s\n", glGetString( GL_RENDERER ) ); printf( "Version : %s\n", glGetString( GL_VERSION ) ); printf( "Extensions : %s\n", glGetString( GL_EXTENSIONS ) ); printf("\n"); SDL_GL_GetAttribute( SDL_GL_RED_SIZE, &value ); printf( "SDL_GL_RED_SIZE: requested %d, got %d\n", rgb_size[0],value); SDL_GL_GetAttribute( SDL_GL_GREEN_SIZE, &value ); printf( "SDL_GL_GREEN_SIZE: requested %d, got %d\n", rgb_size[1],value); SDL_GL_GetAttribute( SDL_GL_BLUE_SIZE, &value ); printf( "SDL_GL_BLUE_SIZE: requested %d, got %d\n", rgb_size[2],value); SDL_GL_GetAttribute( SDL_GL_DEPTH_SIZE, &value ); printf( "SDL_GL_DEPTH_SIZE: requested %d, got %d\n", bpp, value ); SDL_GL_GetAttribute( SDL_GL_DOUBLEBUFFER, &value ); printf( "SDL_GL_DOUBLEBUFFER: requested 1, got %d\n", value ); if ( fsaa ) { SDL_GL_GetAttribute( SDL_GL_MULTISAMPLEBUFFERS, &value ); printf("SDL_GL_MULTISAMPLEBUFFERS: requested 1, got %d\n", value ); SDL_GL_GetAttribute( SDL_GL_MULTISAMPLESAMPLES, &value ); printf("SDL_GL_MULTISAMPLESAMPLES: requested %d, got %d\n", fsaa, value ); } if ( accel ) { SDL_GL_GetAttribute( SDL_GL_ACCELERATED_VISUAL, &value ); printf( "SDL_GL_ACCELERATED_VISUAL: requested 1, got %d\n", value ); } if ( sync ) { SDL_GL_GetAttribute( SDL_GL_SWAP_CONTROL, &value ); printf( "SDL_GL_SWAP_CONTROL: requested 1, got %d\n", value ); } /* Set the window manager title bar */ SDL_WM_SetCaption( "SDL GL test", "testgl" ); /* Set the gamma for the window */ if ( gamma != 0.0 ) { SDL_SetGamma(gamma, gamma, gamma); } glViewport( 0, 0, w, h ); glMatrixMode( GL_PROJECTION ); glLoadIdentity( ); glOrtho( -2.0, 2.0, -2.0, 2.0, -20.0, 20.0 ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity( ); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glShadeModel(GL_SMOOTH); /* Loop until done. */ start_time = SDL_GetTicks(); frames = 0; while( !done ) { GLenum gl_error; char* sdl_error; SDL_Event event; /* Do our drawing, too. */ glClearColor( 0.0, 0.0, 0.0, 1.0 ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glBegin( GL_QUADS ); #ifdef SHADED_CUBE glColor3fv(color[0]); glVertex3fv(cube[0]); glColor3fv(color[1]); glVertex3fv(cube[1]); glColor3fv(color[2]); glVertex3fv(cube[2]); glColor3fv(color[3]); glVertex3fv(cube[3]); glColor3fv(color[3]); glVertex3fv(cube[3]); glColor3fv(color[4]); glVertex3fv(cube[4]); glColor3fv(color[7]); glVertex3fv(cube[7]); glColor3fv(color[2]); glVertex3fv(cube[2]); glColor3fv(color[0]); glVertex3fv(cube[0]); glColor3fv(color[5]); glVertex3fv(cube[5]); glColor3fv(color[6]); glVertex3fv(cube[6]); glColor3fv(color[1]); glVertex3fv(cube[1]); glColor3fv(color[5]); glVertex3fv(cube[5]); glColor3fv(color[4]); glVertex3fv(cube[4]); glColor3fv(color[7]); glVertex3fv(cube[7]); glColor3fv(color[6]); glVertex3fv(cube[6]); glColor3fv(color[5]); glVertex3fv(cube[5]); glColor3fv(color[0]); glVertex3fv(cube[0]); glColor3fv(color[3]); glVertex3fv(cube[3]); glColor3fv(color[4]); glVertex3fv(cube[4]); glColor3fv(color[6]); glVertex3fv(cube[6]); glColor3fv(color[1]); glVertex3fv(cube[1]); glColor3fv(color[2]); glVertex3fv(cube[2]); glColor3fv(color[7]); glVertex3fv(cube[7]); #else /* flat cube */ glColor3f(1.0, 0.0, 0.0); glVertex3fv(cube[0]); glVertex3fv(cube[1]); glVertex3fv(cube[2]); glVertex3fv(cube[3]); glColor3f(0.0, 1.0, 0.0); glVertex3fv(cube[3]); glVertex3fv(cube[4]); glVertex3fv(cube[7]); glVertex3fv(cube[2]); glColor3f(0.0, 0.0, 1.0); glVertex3fv(cube[0]); glVertex3fv(cube[5]); glVertex3fv(cube[6]); glVertex3fv(cube[1]); glColor3f(0.0, 1.0, 1.0); glVertex3fv(cube[5]); glVertex3fv(cube[4]); glVertex3fv(cube[7]); glVertex3fv(cube[6]); glColor3f(1.0, 1.0, 0.0); glVertex3fv(cube[5]); glVertex3fv(cube[0]); glVertex3fv(cube[3]); glVertex3fv(cube[4]); glColor3f(1.0, 0.0, 1.0); glVertex3fv(cube[6]); glVertex3fv(cube[1]); glVertex3fv(cube[2]); glVertex3fv(cube[7]); #endif /* SHADED_CUBE */ glEnd( ); glMatrixMode(GL_MODELVIEW); glRotatef(5.0, 1.0, 1.0, 1.0); /* Draw 2D logo onto the 3D display */ if ( logo ) { if ( USE_DEPRECATED_OPENGLBLIT ) { DrawLogoBlit(); } else { DrawLogoTexture(); } } if ( logocursor ) { DrawLogoCursor(); } SDL_GL_SwapBuffers( ); /* Check for error conditions. */ gl_error = glGetError( ); if( gl_error != GL_NO_ERROR ) { fprintf( stderr, "testgl: OpenGL error: %d\n", gl_error ); } sdl_error = SDL_GetError( ); if( sdl_error[0] != '\0' ) { fprintf(stderr, "testgl: SDL error '%s'\n", sdl_error); SDL_ClearError(); } /* Allow the user to see what's happening */ if ( slowly ) { SDL_Delay( 20 ); } /* Check if there's a pending event. */ while( SDL_PollEvent( &event ) ) { done = HandleEvent(&event); } ++frames; } /* Print out the frames per second */ this_time = SDL_GetTicks(); if ( this_time != start_time ) { printf("%2.2f FPS\n", ((float)frames/(this_time-start_time))*1000.0); } if ( global_image ) { SDL_FreeSurface(global_image); global_image = NULL; } if ( global_texture ) { glDeleteTextures( 1, &global_texture ); global_texture = 0; } if ( cursor_texture ) { glDeleteTextures( 1, &cursor_texture ); cursor_texture = 0; } /* Destroy our GL context, etc. */ SDL_Quit( ); return(0); }
bool menu_run(Settings *settings) { assert(settings != NULL); SDL_EnableKeyRepeat(10000 / WINDOW_FRAMERATE, 10000 / WINDOW_FRAMERATE); glClearColor(0, 0, 0, 1); int level_set_index = 0, theme_index = 0; menu_preload(); // default settings if(settings->first_run) { settings->play_with_computer = true; settings->volume = 100; strncpy(settings->level_set, s_sets_names[level_set_index], LIM_STR_LEN); settings->level = 1; strncpy(settings->theme, s_themes_names[theme_index], LIM_STR_LEN); settings->ball_speed = BALL_DEFAULT_SPEED; } Timer timer = timer_new(WINDOW_FRAMERATE); const bool* events = NULL; bool leave = false; bool vol_updated = false; while(!leave) { events = event_poll(); if(events[EVENT_QUIT] || events[EVENT_KEY_ESCAPE]) { return false; } if(events[EVENT_KEY_UP]) { if(s_focus == 0) { s_focus = __MENU_LABEL_LAST - 1; } else { s_focus--; } audio_play(SOUND_TOCK); } if(events[EVENT_KEY_DOWN]) { s_focus++; audio_play(SOUND_TOCK); if(s_focus == __MENU_LABEL_LAST) { s_focus = 0; } } if(events[EVENT_KEY_LEFT]) { bool action = true; switch(s_focus) { case LABEL_SECOND_PLAYER: settings->play_with_computer = !settings->play_with_computer; break; case LABEL_SOUND_VOLUME: settings->volume -= 10; if(settings->volume < 0) { settings->volume = 0; action = false; } else { vol_updated = true; } break; case LABEL_LEVEL_SET: s_level_set_index--; if(s_level_set_index < 0) { s_level_set_index = s_sets_names_length - 1; } settings->level = 1; break; case LABEL_LEVEL: (settings->level)--; if(settings->level <= 0) { settings->level = s_sets_levels[s_level_set_index]; } break; case LABEL_THEME: s_theme_index--; if(s_theme_index < 0) { s_theme_index = s_themes_names_length - 1; } break; case LABEL_BALL_SPEED: (settings->ball_speed)--; if(settings->ball_speed < BALL_MIN_SPEED) { settings->ball_speed = BALL_MAX_SPEED; } break; default: action = false; break; } if(action) { audio_play(SOUND_TICK); } } if(events[EVENT_KEY_RIGHT]) { bool action = true; switch(s_focus) { case LABEL_SECOND_PLAYER: settings->play_with_computer = !settings->play_with_computer; break; case LABEL_SOUND_VOLUME: settings->volume += 10; if(settings->volume > 100) { settings->volume = 100; action = false; } else { vol_updated = true; } break; case LABEL_LEVEL_SET: s_level_set_index++; if(s_level_set_index >= s_sets_names_length) { s_level_set_index = 0; } settings->level = 1; break; case LABEL_LEVEL: (settings->level)++; if(settings->level > s_sets_levels[s_level_set_index]) { settings->level = 1; } break; case LABEL_THEME: s_theme_index++; if(s_theme_index >= s_themes_names_length) { s_theme_index = 0; } break; case LABEL_BALL_SPEED: (settings->ball_speed)++; if(settings->ball_speed > BALL_MAX_SPEED) { settings->ball_speed = BALL_MIN_SPEED; } break; default: action = false; break; } if(action) { audio_play(SOUND_TICK); } } if(events[EVENT_KEY_ENTER]) { if(s_focus == LABEL_QUIT) { return false; } else { leave = true; } } if(vol_updated) { audio_set_volume(settings->volume); vol_updated = false; } glClear(GL_COLOR_BUFFER_BIT); menu_display(settings); SDL_GL_SwapBuffers(); timer_sleep(&timer); } strncpy(settings->level_set, s_sets_names[s_level_set_index], LIM_STR_LEN); strncpy(settings->theme, s_themes_names[s_theme_index], LIM_STR_LEN); settings->first_run = false; return true; }
int main(int argc, char *argv[]) { SDL_Surface *screen; if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); screen = SDL_SetVideoMode( 640, 480, 24, SDL_OPENGL ); if ( !screen ) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } glClearColor( 0, 0, 0, 0 ); glClear( GL_COLOR_BUFFER_BIT ); // Create a texture GLuint texture; glGenTextures( 1, &texture ); glBindTexture( GL_TEXTURE_2D, texture ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte textureData[16*16*4]; for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { *((int*)&textureData[(x*16 + y) * 4]) = x*16 + ((y*16) << 8); } } glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureData ); // Create a second texture GLuint texture2; glGenTextures( 1, &texture2 ); glBindTexture( GL_TEXTURE_2D, texture2 ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); GLubyte texture2Data[] = { 0xff, 0, 0, 0xff, 0, 0xff, 0, 0xaa, 0, 0, 0xff, 0x55, 0x80, 0x90, 0x70, 0 }; glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, texture2Data ); // BEGIN #if USE_GLEW glewInit(); #endif glMatrixMode(GL_PROJECTION); glLoadIdentity(); // original: glFrustum(-0.6435469817188064, 0.6435469817188064 ,-0.48266022190470925, 0.48266022190470925 ,0.5400000214576721, 2048); glFrustum(-0.6435469817188064, 0.1435469817188064 ,-0.48266022190470925, 0.88266022190470925 ,0.5400000214576721, 2048); glRotatef(-30, 1, 1, 1); //GLfloat pm[] = { 1.372136116027832, 0, 0, 0, 0, 0.7910231351852417, 0, 0, -0.6352481842041016, 0.29297152161598206, -1.0005275011062622, -1, 0, 0, -1.080284833908081, 0 }; //glLoadMatrixf(pm); glMatrixMode(GL_MODELVIEW); GLfloat matrixData[] = { -1, 0, 0, 0, 0, 0,-1, 0, 0, 1, 0, 0, 0, 0, 0, 1 }; glLoadMatrixf(matrixData); //glTranslated(-512,-512,-527); // XXX this should be uncommented, but if it is then nothing is shown glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glClear(GL_DEPTH_BUFFER_BIT); glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glActiveTexture(GL_TEXTURE0); glEnableClientState(GL_VERTEX_ARRAY); GLuint arrayBuffer, elementBuffer; glGenBuffers(1, &arrayBuffer); glGenBuffers(1, &elementBuffer); GLubyte arrayData[] = { /* [0, 0, 0, 67] ==> 128 float [0, 0, 128, 67] ==> 256 float [0, 0, 0, 68] ==> 512 float [0, 0, 128, 68] ==> 1024 float [vertex x ] [vertex y ] [vertex z ] [nr] [texture u ] [texture v ] [lm u ] [lm v ] [color r,g,b,a ] */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 11, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 0 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 23, 20, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 1 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 35, 30, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 2 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 47, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 3 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 51, 50, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 4 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 64, 60, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, // 5 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 70, 70, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 6 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 89, 80, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 7 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 94, 90, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 8 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 20, 10, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 9 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 31, 20, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 10 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 42, 30, 0, 0, 0, 0, 0, 0, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 11 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 53, 40, 0, 0, 0, 0, 0, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 12 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 64, 50, 0, 0, 0, 0, 128, 67, 0, 0, 0, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 13 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 75, 60, 0, 0, 0, 0, 128, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 14 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 86, 70, 0, 0, 0, 0, 0, 67, 0, 0, 128, 67, 0, 0, 0, 0, 128, 128, 128, 128, // 15 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 0, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 128, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128, 0, 0, 128, 68, 0, 0, 128, 68, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 128, 128, 128 }; assert(sizeof(arrayData) == 1408); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); glBufferData(GL_ARRAY_BUFFER, sizeof(arrayData), arrayData, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); GLushort elementData[] = { 1, 2, 0, 2, 3, 0, 5, 6, 4, 6, 7, 4, 9, 10, 8, 10, 11, 8, 13, 14, 12, 14, 15, 12 }; assert(sizeof(elementData) == 48); glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer); // sauer vertex data is apparently 0-12: V3F, 12: N1B, 16-24: T2F, 24-28: T2S, 28-32: C4B glVertexPointer(3, GL_FLOAT, 32, (void*)0); // all these apply to the ARRAY_BUFFER that is bound glTexCoordPointer(2, GL_FLOAT, 32, (void*)16); glClientActiveTexture(GL_TEXTURE1); // XXX seems to be ignored in native build glTexCoordPointer(2, GL_SHORT, 32, (void*)24); glClientActiveTexture(GL_TEXTURE0); // likely not needed, it is a cleanup glNormalPointer(GL_BYTE, 32, (void*)12); glColorPointer(4, GL_UNSIGNED_BYTE, 32, (void*)28); glBindTexture(GL_TEXTURE_2D, texture); // diffuse? glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, texture2); // lightmap? glActiveTexture(GL_TEXTURE0); GLint ok; const char *vertexShader = "uniform vec4 texgenscroll;\n" "void main(void)\n" "{\n" " gl_Position = ftransform();\n" " gl_TexCoord[0].xy = gl_MultiTexCoord0.xy/10000.0 + (0.001*texgenscroll.xy) + gl_Normal.xy;\n" // added /100 here " gl_TexCoord[1].xy = gl_MultiTexCoord1.xy/100.0 * 3.051851e-05;\n" "}\n"; const char *fragmentShader = "uniform vec4 colorparams;\n" "uniform sampler2D diffusemap, lightmap;\n" "void main(void)\n" "{\n" " vec4 diffuse = texture2D(diffusemap, gl_TexCoord[0].xy);\n" " vec4 lm = texture2D(lightmap, gl_TexCoord[1].xy);\n" " diffuse *= colorparams;\n" " gl_FragColor = diffuse * lm;\n" "}\n"; GLuint vs = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs, 1, &vertexShader, NULL); glCompileShader(vs); glGetShaderiv(vs, GL_COMPILE_STATUS, &ok); assert(ok); GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs, 1, &fragmentShader, NULL); glCompileShader(fs); glGetShaderiv(fs, GL_COMPILE_STATUS, &ok); assert(ok); GLuint program = glCreateProgram(); glAttachShader(program, vs); glAttachShader(program, fs); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &ok); assert(ok); glUseProgram(program); GLint lightmapLocation = glGetUniformLocation(program, "lightmap"); assert(lightmapLocation >= 0); glUniform1i(lightmapLocation, 1); // sampler2D? Is it the texture unit? GLint diffusemapLocation = glGetUniformLocation(program, "diffusemap"); assert(diffusemapLocation >= 0); glUniform1i(diffusemapLocation, 0); GLint texgenscrollLocation = glGetUniformLocation(program, "texgenscroll"); assert(texgenscrollLocation >= 0); GLint colorparamsLocation = glGetUniformLocation(program, "colorparams"); assert(colorparamsLocation >= 0); GLfloat texgenscrollData[] = { 0, 0, 0, 0 }; glUniform4fv(texgenscrollLocation, 1, texgenscrollData); GLfloat colorparamsData[] = { 2, 2, 2, 1 }; glUniform4fv(colorparamsLocation, 1, colorparamsData); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)&elementData[12/sizeof(GLushort)]); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)&elementData[ 0/sizeof(GLushort)]); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)&elementData[24/sizeof(GLushort)]); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)&elementData[36/sizeof(GLushort)]); // END SDL_GL_SwapBuffers(); #ifndef __EMSCRIPTEN__ SDL_Delay(1500); #endif SDL_Quit(); return 0; }
int main(int /*argc*/, char** /*argv*/) { // Init SDL if (SDL_Init(SDL_INIT_EVERYTHING) != 0) { printf("Could not initialise SDL\n"); return -1; } // Init OpenGL SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24); SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); const SDL_VideoInfo* vi = SDL_GetVideoInfo(); bool presentationMode = false; int width, height; SDL_Surface* screen = 0; if (presentationMode) { width = vi->current_w; height = vi->current_h; screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL|SDL_FULLSCREEN); } else { width = vi->current_w - 20; height = vi->current_h - 80; screen = SDL_SetVideoMode(width, height, 0, SDL_OPENGL); } if (!screen) { printf("Could not initialise SDL opengl\n"); return -1; } SDL_WM_SetCaption("Recast Demo", 0); if (!imguiRenderGLInit("DroidSans.ttf")) { printf("Could not init GUI renderer.\n"); SDL_Quit(); return -1; } float t = 0.0f; float timeAcc = 0.0f; Uint32 lastTime = SDL_GetTicks(); int mx = 0, my = 0; float rx = 45; float ry = -45; float moveW = 0, moveS = 0, moveA = 0, moveD = 0; float camx = 0, camy = 0, camz = 0, camr = 1000; float origrx = 0, origry = 0; int origx = 0, origy = 0; float scrollZoom = 0; bool rotate = false; bool movedDuringRotate = false; float rays[3], raye[3]; bool mouseOverMenu = false; bool showMenu = !presentationMode; bool showLog = false; bool showDebugMode = true; bool showTools = true; bool showMaps = false; bool showLevels = false; bool showSample = false; bool showTestCases = false; int propScroll = 0; int logScroll = 0; int toolsScroll = 0; int debugScroll = 0; char sampleName[64] = "Choose Sample..."; FileList maps; char mapName[128] = "Choose Map..."; FileList files; char meshName[128] = "Choose Tile..."; float mpos[3] = {0,0,0}; bool mposSet = false; SlideShow slideShow; slideShow.init("slides/"); InputGeom* geom = 0; Sample* sample = 0; TestCase* test = 0; BuildContext ctx; glEnable(GL_CULL_FACE); float fogCol[4] = { 0.32f,0.25f,0.25f,1 }; glEnable(GL_FOG); glFogi(GL_FOG_MODE, GL_LINEAR); glFogf(GL_FOG_START, camr*0.2f); glFogf(GL_FOG_END, camr*1.25f); glFogfv(GL_FOG_COLOR, fogCol); glDepthFunc(GL_LEQUAL); glEnable(GL_POINT_SMOOTH); glEnable(GL_LINE_SMOOTH); bool done = false; while(!done) { // Handle input events. int mscroll = 0; bool processHitTest = false; bool processHitTestShift = false; SDL_Event event; while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_KEYDOWN: // Handle any key presses here. if (event.key.keysym.sym == SDLK_ESCAPE) { done = true; } else if (event.key.keysym.sym == SDLK_t) { showLevels = false; showSample = false; showTestCases = true; scanDirectory("Tests", ".txt", files); } else if (event.key.keysym.sym == SDLK_TAB) { showMenu = !showMenu; } else if (event.key.keysym.sym == SDLK_SPACE) { if (sample) sample->handleToggle(); } else if (event.key.keysym.sym == SDLK_1) { if (sample) sample->handleStep(); } else if (event.key.keysym.sym == SDLK_9) { if (geom) geom->save("geomset.txt"); } else if (event.key.keysym.sym == SDLK_0) { delete geom; geom = new InputGeom; if (!geom || !geom->load(&ctx, "geomset.txt")) { delete geom; geom = 0; showLog = true; logScroll = 0; ctx.dumpLog("Geom load log %s:", meshName); } if (sample && geom) { sample->handleMeshChanged(geom); } if (geom || sample) { const float* bmin = 0; const float* bmax = 0; if (sample) { bmin = sample->getBoundsMin(); bmax = sample->getBoundsMax(); } else if (geom) { bmin = geom->getMeshBoundsMin(); bmax = geom->getMeshBoundsMax(); } // Reset camera and fog to match the mesh bounds. if (bmin && bmax) { camr = sqrtf(rcSqr(bmax[0]-bmin[0]) + rcSqr(bmax[1]-bmin[1]) + rcSqr(bmax[2]-bmin[2])) / 2; camx = (bmax[0] + bmin[0]) / 2 + camr; camy = (bmax[1] + bmin[1]) / 2 + camr; camz = (bmax[2] + bmin[2]) / 2 + camr; camr *= 3; } rx = 45; ry = -45; glFogf(GL_FOG_START, camr*0.2f); glFogf(GL_FOG_END, camr*1.25f); } } else if (event.key.keysym.sym == SDLK_RIGHT) { slideShow.nextSlide(); } else if (event.key.keysym.sym == SDLK_LEFT) { slideShow.prevSlide(); } break; case SDL_MOUSEBUTTONDOWN: if (event.button.button == SDL_BUTTON_RIGHT) { if (!mouseOverMenu) { // Rotate view rotate = true; movedDuringRotate = false; origx = mx; origy = my; origrx = rx; origry = ry; } } else if (event.button.button == SDL_BUTTON_WHEELUP) { if (mouseOverMenu) mscroll--; else scrollZoom -= 1.0f; } else if (event.button.button == SDL_BUTTON_WHEELDOWN) { if (mouseOverMenu) mscroll++; else scrollZoom += 1.0f; } break; case SDL_MOUSEBUTTONUP: // Handle mouse clicks here. if (event.button.button == SDL_BUTTON_RIGHT) { rotate = false; if (!mouseOverMenu) { if (!movedDuringRotate) { processHitTest = true; processHitTestShift = true; } } } else if (event.button.button == SDL_BUTTON_LEFT) { if (!mouseOverMenu) { processHitTest = true; processHitTestShift = (SDL_GetModState() & KMOD_SHIFT) ? true : false; } } break; case SDL_MOUSEMOTION: mx = event.motion.x; my = height-1 - event.motion.y; if (rotate) { int dx = mx - origx; int dy = my - origy; rx = origrx - dy*0.25f; ry = origry + dx*0.25f; if (dx*dx+dy*dy > 3*3) movedDuringRotate = true; } break; case SDL_QUIT: done = true; break; default: break; } } unsigned char mbut = 0; if (SDL_GetMouseState(0,0) & SDL_BUTTON_LMASK) mbut |= IMGUI_MBUT_LEFT; if (SDL_GetMouseState(0,0) & SDL_BUTTON_RMASK) mbut |= IMGUI_MBUT_RIGHT; Uint32 time = SDL_GetTicks(); float dt = (time - lastTime) / 1000.0f; lastTime = time; t += dt; // Hit test mesh. if (processHitTest && geom && sample) { float t; TimeVal t0 = getPerfTime(); bool hit = geom->raycastMesh(rays, raye, t); TimeVal t1 = getPerfTime(); printf("raycast() %.4fms\n", getPerfDeltaTimeUsec(t0,t1)/1000.0f); if (hit) { if (SDL_GetModState() & KMOD_CTRL) { // Marker mposSet = true; mpos[0] = rays[0] + (raye[0] - rays[0])*t; mpos[1] = rays[1] + (raye[1] - rays[1])*t; mpos[2] = rays[2] + (raye[2] - rays[2])*t; } else { float pos[3]; pos[0] = rays[0] + (raye[0] - rays[0])*t; pos[1] = rays[1] + (raye[1] - rays[1])*t; pos[2] = rays[2] + (raye[2] - rays[2])*t; sample->handleClick(rays, pos, processHitTestShift); } } else { if (SDL_GetModState() & KMOD_CTRL) { // Marker mposSet = false; } } } // Update sample simulation. const float SIM_RATE = 20; const float DELTA_TIME = 1.0f/SIM_RATE; timeAcc = rcClamp(timeAcc+dt, -1.0f, 1.0f); int simIter = 0; while (timeAcc > DELTA_TIME) { timeAcc -= DELTA_TIME; if (simIter < 5) { if (sample) sample->handleUpdate(DELTA_TIME); } simIter++; } // Update and render glViewport(0, 0, width, height); glClearColor(0.3f, 0.3f, 0.32f, 1.0f); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glDisable(GL_TEXTURE_2D); // Render 3d glEnable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(50.0f, (float)width/(float)height, 1.0f, camr); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glRotatef(rx,1,0,0); glRotatef(ry,0,1,0); glTranslatef(-camx, -camy, -camz); // Get hit ray position and direction. GLdouble proj[16]; GLdouble model[16]; GLint view[4]; glGetDoublev(GL_PROJECTION_MATRIX, proj); glGetDoublev(GL_MODELVIEW_MATRIX, model); glGetIntegerv(GL_VIEWPORT, view); GLdouble x, y, z; gluUnProject(mx, my, 0.0f, model, proj, view, &x, &y, &z); rays[0] = (float)x; rays[1] = (float)y; rays[2] = (float)z; gluUnProject(mx, my, 1.0f, model, proj, view, &x, &y, &z); raye[0] = (float)x; raye[1] = (float)y; raye[2] = (float)z; // Handle keyboard movement. Uint8* keystate = SDL_GetKeyState(NULL); moveW = rcClamp(moveW + dt * 4 * (keystate[SDLK_w] ? 1 : -1), 0.0f, 1.0f); moveS = rcClamp(moveS + dt * 4 * (keystate[SDLK_s] ? 1 : -1), 0.0f, 1.0f); moveA = rcClamp(moveA + dt * 4 * (keystate[SDLK_a] ? 1 : -1), 0.0f, 1.0f); moveD = rcClamp(moveD + dt * 4 * (keystate[SDLK_d] ? 1 : -1), 0.0f, 1.0f); float keybSpeed = 22.0f; if (SDL_GetModState() & KMOD_SHIFT) keybSpeed *= 4.0f; float movex = (moveD - moveA) * keybSpeed * dt; float movey = (moveS - moveW) * keybSpeed * dt; movey += scrollZoom * 2.0f; scrollZoom = 0; camx += movex * (float)model[0]; camy += movex * (float)model[4]; camz += movex * (float)model[8]; camx += movey * (float)model[2]; camy += movey * (float)model[6]; camz += movey * (float)model[10]; glEnable(GL_FOG); if (sample) sample->handleRender(); if (test) test->handleRender(); glDisable(GL_FOG); // Render GUI glDisable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, width, 0, height); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); mouseOverMenu = false; imguiBeginFrame(mx,my,mbut,mscroll); if (sample) { sample->handleRenderOverlay((double*)proj, (double*)model, (int*)view); } if (test) { if (test->handleRenderOverlay((double*)proj, (double*)model, (int*)view)) mouseOverMenu = true; } // Help text. if (showMenu) { const char msg[] = "W/S/A/D: Move RMB: Rotate LMB+SHIFT: Place Start LMB: Place End"; imguiDrawText(width/2, height-20, IMGUI_ALIGN_CENTER, msg, imguiRGBA(255,255,255,128)); } if (showMenu) { int propDiv = showDebugMode ? (int)(height*0.6f) : height; if (imguiBeginScrollArea("Properties", width-250-10, 10+height-propDiv, 250, propDiv-20, &propScroll)) mouseOverMenu = true; if (imguiCheck("Show Log", showLog)) showLog = !showLog; if (imguiCheck("Show Tools", showTools)) showTools = !showTools; if (imguiCheck("Show Debug Mode", showDebugMode)) showDebugMode = !showDebugMode; imguiSeparator(); imguiLabel("Sample"); if (imguiButton(sampleName)) { if (showSample) { showSample = false; } else { showMaps = false; showSample = true; showLevels = false; showTestCases = false; } } imguiSeparator(); imguiLabel("Map"); if (imguiButton(mapName, strncmp(sampleName, "Choose Sample...", 16))) { if (showMaps) { showMaps = false; } else { showMaps = true; showSample = false; showTestCases = false; showLevels = false; scanDirectory("Meshes", ".map", maps); } } imguiSeparator(); imguiLabel("Tile"); if (imguiButton(meshName, strncmp(mapName, "Choose Map...", 13))) { if (showLevels) { showLevels = false; } else { showMaps = false; showSample = false; showTestCases = false; showLevels = true; scanDirectory("Meshes", ".mesh", files); } } if (geom) { char text[64]; snprintf(text, 64, "Verts: %.1fk Tris: %.1fk", geom->getMesh()->getVertCount()/1000.0f, geom->getMesh()->getTriCount()/1000.0f); imguiValue(text); } imguiSeparator(); if (geom && sample) { sample->handleSettings(); if (imguiButton("Build")) { ctx.resetLog(); if (!sample->handleBuild()) { showLog = true; logScroll = 0; } ctx.dumpLog("Build log %s:", meshName); // Clear test. delete test; test = 0; } imguiSeparator(); } imguiEndScrollArea(); if (showDebugMode) { if (imguiBeginScrollArea("Debug Mode", width-250-10, 10, 250, height-propDiv-10, &debugScroll)) mouseOverMenu = true; if (sample) sample->handleDebugMode(); imguiEndScrollArea(); } } // Sample selection dialog. if (showSample) { static int levelScroll = 0; if (imguiBeginScrollArea("Choose Sample", width-10-250-10-200, height-10-250, 200, 250, &levelScroll)) mouseOverMenu = true; Sample* newSample = 0; for (int i = 0; i < g_nsamples; ++i) { if (imguiItem(g_samples[i].name)) { newSample = g_samples[i].create(); if (newSample) strcpy(sampleName, g_samples[i].name); } } if (newSample) { delete sample; sample = newSample; sample->setContext(&ctx); if (geom && sample) { sample->handleMeshChanged(geom); } showSample = false; } if (geom || sample) { const float* bmin = 0; const float* bmax = 0; if (sample) { bmin = sample->getBoundsMin(); bmax = sample->getBoundsMax(); } else if (geom) { bmin = geom->getMeshBoundsMin(); bmax = geom->getMeshBoundsMax(); } // Reset camera and fog to match the mesh bounds. if (bmin && bmax) { camr = sqrtf(rcSqr(bmax[0]-bmin[0]) + rcSqr(bmax[1]-bmin[1]) + rcSqr(bmax[2]-bmin[2])) / 2; camx = (bmax[0] + bmin[0]) / 2 + camr; camy = (bmax[1] + bmin[1]) / 2 + camr; camz = (bmax[2] + bmin[2]) / 2 + camr; camr *= 3; } rx = 45; ry = -45; glFogf(GL_FOG_START, camr*0.2f); glFogf(GL_FOG_END, camr*1.25f); } imguiEndScrollArea(); } // map selection dialog if (showMaps) { static int scrolPos = 0; if (imguiBeginScrollArea("Choose Map", width-10-250-10-200, height-10-450, 200, 450, &scrolPos)) mouseOverMenu = true; int selectedMap = -1; for (int i = 0; i < maps.size; ++i) if (imguiItem(maps.files[i])) selectedMap = i; if (selectedMap != -1) { strncpy(mapName, maps.files[selectedMap], sizeof(mapName)); mapName[sizeof(mapName)-1] = '\0'; showMaps = false; delete geom; geom = NULL; if (sample) sample->setMeshName(meshName); } } // Level selection dialog. if (showLevels) { static int levelScroll = 0; if (imguiBeginScrollArea("Choose Tile", width-10-250-10-200, height-10-450, 200, 450, &levelScroll)) mouseOverMenu = true; int levelToLoad = -1; for (int i = 0; i < files.size; ++i) { if (!strncmp(mapName, files.files[i], 3)) { if (imguiItem(files.files[i])) levelToLoad = i; } } if (levelToLoad != -1) { strncpy(meshName, files.files[levelToLoad], sizeof(meshName)); meshName[sizeof(meshName)-1] = '\0'; showLevels = false; delete geom; geom = 0; char path[256]; strcpy(path, "Meshes/"); strcat(path, meshName); geom = new InputGeom; if (!geom || !geom->loadMesh(&ctx, path)) { delete geom; geom = 0; showLog = true; logScroll = 0; ctx.dumpLog("Geom load log %s:", meshName); } if (sample && geom) { sample->handleMeshChanged(geom); sample->setMeshName(meshName); } if (geom || sample) { const float* bmin = 0; const float* bmax = 0; if (sample) { bmin = sample->getBoundsMin(); bmax = sample->getBoundsMax(); } else if (geom) { bmin = geom->getMeshBoundsMin(); bmax = geom->getMeshBoundsMax(); } // Reset camera and fog to match the mesh bounds. if (bmin && bmax) { camr = sqrtf(rcSqr(bmax[0]-bmin[0]) + rcSqr(bmax[1]-bmin[1]) + rcSqr(bmax[2]-bmin[2])) / 2; camx = (bmax[0] + bmin[0]) / 2 + camr; camy = (bmax[1] + bmin[1]) / 2 + camr; camz = (bmax[2] + bmin[2]) / 2 + camr; camr *= 3; } rx = 45; ry = -45; glFogf(GL_FOG_START, camr*0.2f); glFogf(GL_FOG_END, camr*1.25f); } } imguiEndScrollArea(); } // Test cases if (showTestCases) { static int testScroll = 0; if (imguiBeginScrollArea("Choose Test To Run", width-10-250-10-200, height-10-450, 200, 450, &testScroll)) mouseOverMenu = true; int testToLoad = -1; for (int i = 0; i < files.size; ++i) { if (imguiItem(files.files[i])) testToLoad = i; } if (testToLoad != -1) { char path[256]; strcpy(path, "Tests/"); strcat(path, files.files[testToLoad]); test = new TestCase; if (test) { // Load the test. if (!test->load(path)) { delete test; test = 0; } // Create sample Sample* newSample = 0; for (int i = 0; i < g_nsamples; ++i) { if (strcmp(g_samples[i].name, test->getSampleName()) == 0) { newSample = g_samples[i].create(); if (newSample) strcpy(sampleName, g_samples[i].name); } } if (newSample) { delete sample; sample = newSample; sample->setContext(&ctx); showSample = false; } // Load geom. strcpy(meshName, test->getGeomFileName()); meshName[sizeof(meshName)-1] = '\0'; delete geom; geom = 0; strcpy(path, "Meshes/"); strcat(path, meshName); geom = new InputGeom; if (!geom || !geom->loadMesh(&ctx, path)) { delete geom; geom = 0; showLog = true; logScroll = 0; ctx.dumpLog("Geom load log %s:", meshName); } if (sample && geom) { sample->handleMeshChanged(geom); } ctx.resetLog(); if (sample && !sample->handleBuild()) { ctx.dumpLog("Build log %s:", meshName); } if (geom || sample) { const float* bmin = 0; const float* bmax = 0; if (sample) { bmin = sample->getBoundsMin(); bmax = sample->getBoundsMax(); } else if (geom) { bmin = geom->getMeshBoundsMin(); bmax = geom->getMeshBoundsMax(); } // Reset camera and fog to match the mesh bounds. if (bmin && bmax) { camr = sqrtf(rcSqr(bmax[0]-bmin[0]) + rcSqr(bmax[1]-bmin[1]) + rcSqr(bmax[2]-bmin[2])) / 2; camx = (bmax[0] + bmin[0]) / 2 + camr; camy = (bmax[1] + bmin[1]) / 2 + camr; camz = (bmax[2] + bmin[2]) / 2 + camr; camr *= 3; } rx = 45; ry = -45; glFogf(GL_FOG_START, camr*0.2f); glFogf(GL_FOG_END, camr*1.25f); } // Do the tests. if (sample) test->doTests(sample->getNavMesh(), sample->getNavMeshQuery()); } } imguiEndScrollArea(); } // Log if (showLog && showMenu) { if (imguiBeginScrollArea("Log", 10, 10, width - 300, 200, &logScroll)) mouseOverMenu = true; for (int i = 0; i < ctx.getLogCount(); ++i) imguiLabel(ctx.getLogText(i)); imguiEndScrollArea(); } // Tools if (!showTestCases && showTools && showMenu && geom && sample) { if (imguiBeginScrollArea("Tools", 10, height - 10 - 350, 250, 350, &toolsScroll)) mouseOverMenu = true; sample->handleTools(); imguiEndScrollArea(); } slideShow.updateAndDraw(dt, (float)width, (float)height); // Marker if (mposSet && gluProject((GLdouble)mpos[0], (GLdouble)mpos[1], (GLdouble)mpos[2], model, proj, view, &x, &y, &z)) { // Draw marker circle glLineWidth(5.0f); glColor4ub(240,220,0,196); glBegin(GL_LINE_LOOP); const float r = 25.0f; for (int i = 0; i < 20; ++i) { const float a = (float)i / 20.0f * RC_PI*2; const float fx = (float)x + cosf(a)*r; const float fy = (float)y + sinf(a)*r; glVertex2f(fx,fy); } glEnd(); glLineWidth(1.0f); } imguiEndFrame(); imguiRenderGLDraw(); glEnable(GL_DEPTH_TEST); SDL_GL_SwapBuffers(); } imguiRenderGLDestroy(); SDL_Quit(); delete sample; delete geom; return 0; }
void ditto_render() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0f, 0.0f, -20.0f); GLfloat ambientLight[] = {0.3f, 0.3f, 0.3f, 1.0f}; glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight); GLfloat lightColor[] = {0.7f, 0.7f, 0.7f, 1.0f}; GLfloat lightPos[] = {-2 * BOX_SIZE, BOX_SIZE, 4 * BOX_SIZE, 1.0f}; glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor); glLightfv(GL_LIGHT0, GL_POSITION, lightPos); glRotatef(-angle, 1.0f, 1.0f, 1.0f); glBegin(GL_QUADS); //Top face glColor3f(1.0f, 1.0f, 0.0f); glNormal3f(0.0, 1.0f, 0.0f); glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2); glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2); glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2); glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2); //Bottom face glColor3f(1.0f, 0.0f, 1.0f); glNormal3f(0.0, -1.0f, 0.0f); glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2); glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2); glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2); glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2); //Left face glNormal3f(-1.0, 0.0f, 0.0f); glColor3f(0.0f, 1.0f, 1.0f); glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2); glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2); glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2); glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2); //Right face glNormal3f(1.0, 0.0f, 0.0f); glColor3f(1.0f, 0.0f, 0.0f); glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2); glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2); glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2); glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2); glEnd(); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D, texture); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glColor3f(1.0f, 1.0f, 1.0f); glBegin(GL_QUADS); //Front face glNormal3f(0.0, 0.0f, 1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2); glTexCoord2f(0.0f, 1.0f); glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, BOX_SIZE / 2); glTexCoord2f(0.0f, 0.0f); glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2); glTexCoord2f(1.0f, 0.0f); glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, BOX_SIZE / 2); //Back face glNormal3f(0.0, 0.0f, -1.0f); glTexCoord2f(1.0f, 1.0f); glVertex3f(-BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2); glTexCoord2f(0.0f, 1.0f); glVertex3f(-BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2); glTexCoord2f(0.0f, 0.0f); glVertex3f(BOX_SIZE / 2, BOX_SIZE / 2, -BOX_SIZE / 2); glTexCoord2f(1.0f, 0.0f); glVertex3f(BOX_SIZE / 2, -BOX_SIZE / 2, -BOX_SIZE / 2); glEnd(); glDisable(GL_TEXTURE_2D); SDL_GL_SwapBuffers(); }
void gemsdlwindow :: swapBuffers(void) { if(makeCurrent()) // FIXME: is this needed? SDL_GL_SwapBuffers(); }
void LoadingBar::Draw(float val) { // percent complete bar only draws in 2d mode prj->set_orthographic_projection(); // Draw the splash screen if available if (splash) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_TEXTURE_2D); glColor3f(1, 1, 1); glDisable(GL_CULL_FACE); glBindTexture(GL_TEXTURE_2D, splash->getID()); glBegin(GL_QUADS); glTexCoord2i(0, 0); // Bottom Left glVertex3f(splashx, splashy, 0.0f); glTexCoord2i(1, 0); // Bottom Right glVertex3f(splashx + width, splashy, 0.0f); glTexCoord2i(1, 1); // Top Right glVertex3f(splashx + width, splashy + height, 0.0f); glTexCoord2i(0, 1); // Top Left glVertex3f(splashx, splashy + height, 0.0f); glEnd(); } glDisable(GL_BLEND); glDisable(GL_TEXTURE_2D); // black out background of text for redraws (so can keep sky unaltered) glColor3f(0, 0, 0); glBegin(GL_QUAD_STRIP); glTexCoord2i(1, 0); // Bottom Right glVertex3f(splashx + width, bary-70, 0.0f); glTexCoord2i(0, 0); // Bottom Left glVertex3f(splashx, bary-70, 0.0f); glTexCoord2i(1, 1); // Top Right glVertex3f(splashx + width, bary-5, 0.0f); glTexCoord2i(0, 1); // Top Left glVertex3f(splashx, bary-5, 0.0f); glEnd(); glColor3f(0.8, 0.8, 1); glBegin(GL_QUAD_STRIP); glTexCoord2i(1, 0); // Bottom Right glVertex3f(barx + barwidth, bary + barheight, 0.0f); glTexCoord2i(0, 0); // Bottom Left glVertex3f(barx, bary + barheight, 0.0f); glTexCoord2i(1, 1); // Top Right glVertex3f(barx + barwidth, bary, 0.0f); glTexCoord2i(0, 1); // Top Left glVertex3f(barx, bary, 0.0f); glEnd(); glColor3f(0.4f, 0.4f, 0.6f); glBegin(GL_QUAD_STRIP); glTexCoord2i(1, 0); // Bottom Right glVertex3f(-1 + barx + barwidth * val, bary + barheight - 1, 0.0f); glTexCoord2i(0, 0); // Bottom Left glVertex3f(1 + barx, bary + barheight - 1, 0.0f); glTexCoord2i(1, 1); // Top Right glVertex3f(-1 + barx + barwidth * val, bary + 1, 0.0f); glTexCoord2i(0, 1); // Top Left glVertex3f(1 + barx, bary + 1, 0.0f); glEnd(); glColor3f(1, 1, 1); glEnable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode if(barfont) { barfont->print(barx, bary-15, message); // LEGAL NOTICES -- THE DISPLAY OF THESE AT STARTUP MAY NOT BE REMOVED as per GPL section 5 barfont->print(barx-20, bary-40, "<span color='#666699'>Nightshade is free, open source software with a GPLv3 license.</span>"); barfont->print(barx-20, bary-55, "<span color='#666699'>Nightshade is a registered trademark of Digitalis Education Solutions, Inc.</span>"); } if(extraTextFont) { extraTextFont->print(splashx + extraTextPos[0], splashy + extraTextPos[1], extraText); extraTextFont->print(splashx + extraTextPos[0], splashy + extraTextPos[1] - 20, EDITION); extraTextFont->print(splashx + extraTextPos[0], splashy + extraTextPos[1] - 40, "Edition"); } SDL_GL_SwapBuffers(); // And swap the buffers prj->reset_perspective_projection(); }
int main(int argc, char *argv[]) { SDL_Surface *screen; // Slightly different SDL initialization if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) { printf("Unable to initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new* screen = SDL_SetVideoMode( 640, 480, 16, SDL_OPENGL ); // *changed* if ( !screen ) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } // Check extensions const char *exts = (const char *)glGetString(GL_EXTENSIONS); assert(hasext(exts, "GL_ARB_texture_compression")); assert(hasext(exts, "GL_EXT_texture_compression_s3tc")); // Set the OpenGL state after creating the context with SDL_SetVideoMode glClearColor( 0, 0, 0, 0 ); glEnable( GL_TEXTURE_2D ); // Needed when we're using the fixed-function pipeline. glViewport( 0, 0, 640, 480 ); glMatrixMode( GL_PROJECTION ); GLfloat matrixData[] = { 2.0/640, 0, 0, 0, 0, -2.0/480, 0, 0, 0, 0, -1, 0, -1, 1, 0, 1 }; glLoadMatrixf(matrixData); // test loadmatrix glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); // Load the OpenGL textures GLuint texture; { const int DDS_SIZE = 65664; FILE *dds = fopen("ship.dds", "rb"); assert(dds); char *ddsdata = (char*)malloc(DDS_SIZE); assert(fread(ddsdata, 1, DDS_SIZE, dds) == DDS_SIZE); fclose(dds); glGenTextures( 1, &texture ); glBindTexture( GL_TEXTURE_2D, texture ); assert(!glGetError()); glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 256, 256, 0, DDS_SIZE-128, ddsdata+128); assert(!glGetError()); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); } // second texture GLuint texture2; { const int DDS_SIZE = 32896; FILE *dds = fopen("bloom.dds", "rb"); assert(dds); char *ddsdata = (char*)malloc(DDS_SIZE); assert(fread(ddsdata, 1, DDS_SIZE, dds) == DDS_SIZE); fclose(dds); glGenTextures( 1, &texture2 ); glBindTexture( GL_TEXTURE_2D, texture2 ); assert(!glGetError()); glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 256, 256, 0, DDS_SIZE-128, ddsdata+128); assert(!glGetError()); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); } // third, a non-square texture with mipmaps GLuint texture3; { const int DDS_SIZE = 43920; FILE *dds = fopen("water.dds", "rb"); assert(dds); char *ddsdata = (char*)malloc(DDS_SIZE); assert(fread(ddsdata, 1, DDS_SIZE, dds) == DDS_SIZE); fclose(dds); glGenTextures( 1, &texture3 ); glBindTexture( GL_TEXTURE_2D, texture3 ); assert(!glGetError()); glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 512, 64, 0, 512*64, ddsdata+128); assert(!glGetError()); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); } // Prepare and Render // Clear the screen before drawing glClear( GL_COLOR_BUFFER_BIT ); // Bind the texture to which subsequent calls refer to glBindTexture( GL_TEXTURE_2D, texture ); // Use clientside vertex pointers to render two items GLfloat vertexData[] = { 0, 0, 10, 10, // texture2, position2 1, 0, 300, 10, 1, 1, 300, 128, 0, 1, 10, 128, 0, 0.5, 410, 10, 1, 0.5, 600, 10, 1, 1, 630, 200, 0.5, 1, 310, 250 }; glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(2, GL_FLOAT, 4*4, &vertexData[0]); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(2, GL_FLOAT, 4*4, &vertexData[2]); glDrawArrays(GL_QUADS, 0, 4); glBindTexture( GL_TEXTURE_2D, texture3 ); glDrawArrays(GL_QUADS, 4, 4); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); // Render the last item using oldschool glBegin etc glBindTexture( GL_TEXTURE_2D, texture2 ); glBegin( GL_TRIANGLE_STRIP ); glTexCoord2i( 0, 0 ); glVertex3f( 100, 300, 0 ); glTexCoord2i( 1, 0 ); glVertex3f( 300, 300, 0 ); glTexCoord2i( 1, 1 ); glVertex3f( 300, 400, 0 ); glTexCoord2i( 0, 1 ); glVertex3f( 500, 410, 0 ); glEnd(); SDL_GL_SwapBuffers(); #if !EMSCRIPTEN // Wait for 3 seconds to give us a chance to see the image SDL_Delay(1500); #endif // Now we can delete the OpenGL texture and close down SDL glDeleteTextures( 1, &texture ); SDL_Quit(); return 0; }
void display() { int i, wm; float size = 5; if (!can_render()) { return; } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); if (render_mode == IR) { /* draw the IR stuff */ glDisable(GL_LIGHTING); glBegin(GL_TRIANGLES); /* green center */ glColor3f(0.0, 1.0, 0.0); DRAW_TRIANGLE(width / 2, height / 2, 0, size); glEnd(); for (wm = 0; wm < MAX_WIIMOTES; ++wm) { glBegin(GL_TRIANGLES); /* red ir */ glColor3f(1.0, 0.0, 0.0); for (i = 0; i < 4; ++i) { if (wiimotes[wm]->ir.dot[i].visible) { DRAW_TRIANGLE(wiimotes[wm]->ir.dot[i].rx, wiimotes[wm]->ir.dot[i].ry, 0, size); } } /* yellow corrected ir */ glColor3f(1.0, 1.0, 0.0); for (i = 0; i < 4; ++i) { if (wiimotes[wm]->ir.dot[i].visible) { DRAW_TRIANGLE(wiimotes[wm]->ir.dot[i].x, wiimotes[wm]->ir.dot[i].y, 0, size); } } /* blue cursor */ glColor3f(0.0, 0.0, 1.0); DRAW_TRIANGLE(wiimotes[wm]->ir.x, wiimotes[wm]->ir.y - size, 0, size); glEnd(); } } else { /* draw the teapot */ gluLookAt(0.0, 0.0, -5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); update_light(GL_LIGHT0, &light); set_material(&red_plastic); glRotatef(wiimotes[0]->orient.roll, 0.0f, 0.0f, 1.0f); glRotatef(wiimotes[0]->orient.pitch, 1.0f, 0.0f, 0.0f); glutSolidTeapot(1); } SDL_GL_SwapBuffers(); }
/* * r_drawFrame * Perform any drawing and setup necessary to produce a single frame. */ static void r_drawFrame() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Orient and position the camera r_setupModelview(); //Draw sky? glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glPushMatrix(); glLoadIdentity(); r_setupModelviewforSky(); renderer_model_drawASE(0); glPopMatrix(); glClear(GL_DEPTH_BUFFER_BIT); //Draw fighter. Needs to stay with the camera. //Doesn't rotate. Only stays in the same position relative to camera. glPushMatrix(); glLoadIdentity(); renderer_model_drawASE(1); glPopMatrix(); //Texture stuff past this point. glColor3f(1.0, 1.0, 1.0); glBindTexture(GL_TEXTURE_2D, face1); glBegin(GL_QUADS); //Set up appropriate texture for the forward face. //I've been visualizing this the wrong way. Each four is considered a square. //Face 1 glTexCoord2f(0.0, 0.0); glVertex3f(-0.5, -0.5, -8.0); glTexCoord2f(1.0, 0.0); glVertex3f( 0.5, -0.5, -8.0); glTexCoord2f(1.0, 1.0); glVertex3f( 0.5, 0.5, -8.0); glTexCoord2f(0.0, 1.0); glVertex3f(-0.5, 0.5, -8.0); glEnd(); //Face 2 glBindTexture(GL_TEXTURE_2D, face4); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(-0.5, -0.5, -9.0); glTexCoord2f(1.0, 0.0); glVertex3f(-0.5, -0.5, -8.0); glTexCoord2f(1.0, 1.0); glVertex3f(-0.5, 0.5, -8.0); glTexCoord2f(0.0, 1.0); glVertex3f(-0.5, 0.5, -9.0); glEnd(); //Face 3 glBindTexture(GL_TEXTURE_2D, face3); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(0.5, -0.5, -8.0); glTexCoord2f(1.0, 0.0); glVertex3f(0.5, -0.5, -9.0); glTexCoord2f(1.0, 1.0); glVertex3f(0.5, 0.5, -9.0); glTexCoord2f(0.0, 1.0); glVertex3f(0.5, 0.5, -8.0); glEnd(); //Face 4 glBindTexture(GL_TEXTURE_2D, face6); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(0.5, -0.5, -9.0); glTexCoord2f(1.0, 0.0); glVertex3f(-0.5, -0.5, -9.0); glTexCoord2f(1.0, 1.0); glVertex3f(-0.5, 0.5, -9.0); glTexCoord2f(0.0, 1.0); glVertex3f(0.5, 0.5, -9.0); glEnd(); //Face 5 glBindTexture(GL_TEXTURE_2D, face5); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(-0.5, 0.5, -8.0); glTexCoord2f(1.0, 0.0); glVertex3f(0.5, 0.5, -8.0); glTexCoord2f(1.0, 1.0); glVertex3f(0.5, 0.5, -9.0); glTexCoord2f(0.0, 1.0); glVertex3f(-0.5, 0.5, -9.0); glEnd(); //Face 6 glBindTexture(GL_TEXTURE_2D, face2); glBegin(GL_QUADS); glTexCoord2f(0.0, 0.0); glVertex3f(0.5, -0.5, -8.0); glTexCoord2f(1.0, 0.0); glVertex3f(-0.5, -0.5, -8.0); glTexCoord2f(1.0, 1.0); glVertex3f(-0.5, -0.5, -9.0); glTexCoord2f(0.0, 1.0); glVertex3f(0.5, -0.5, -9.0); glEnd(); SDL_GL_SwapBuffers(); }
void Graphics::SwapFrameBuffer() { // Swap OpenGL framebuffer SDL_GL_SwapBuffers(); }
void gl_drawwin() { int i; NGNoTransp = 0; // Set this value to 1 within the appropriate // video mode if you want to add a custom // transparency routine or hardware // transparency. This only works if // the value of newengen is equal to 1. // (see ProcessTransparencies in newgfx16.asm // for ZSNES' current transparency code) UpdateVFrame(); if (curblank != 0) return; if (BilinearFilter) { glfilters = GL_LINEAR; if (GUIOn2 && !FilteredGUI) glfilters = GL_NEAREST; } else { glfilters = GL_NEAREST; } if (En2xSaI && SurfaceX != 256) { /* We have to use copy640x480x16bwin for 2xSaI */ AddEndBytes = 0; NumBytesPerLine = 1024; WinVidMemStart = (void *) glvidbuffer; copy640x480x16bwin(); /* Display 4 256x256 quads for the 512x448 buffer */ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, glfilters); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, glfilters); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); /* Upper left quad */ glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); glPixelStorei(GL_UNPACK_ROW_LENGTH, 512); glTexImage2D(GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, glvidbuffer); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, -1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f(0.0f, 1.0f, -1.0f); glTexCoord2f(1.0f, (224.0 / 256.0)); glVertex3f(0.0f, 0.0f, -1.0f); glTexCoord2f(0.0f, (224.0 / 256.0)); glVertex3f(-1.0f, 0.0f, -1.0f); glEnd(); /* Upper right quad */ glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); glPixelStorei(GL_UNPACK_ROW_LENGTH, 512); glTexImage2D(GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, glvidbuffer + 256); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex3f(0.0f, 1.0f, -1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, -1.0f); glTexCoord2f(1.0f, (224.0 / 256.0)); glVertex3f(1.0f, 0.0f, -1.0f); glTexCoord2f(0.0f, (224.0 / 256.0)); glVertex3f(0.0f, 0.0f, -1.0f); glEnd(); /* Lower left quad */ glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); glPixelStorei(GL_UNPACK_ROW_LENGTH, 512); glTexImage2D(GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, glvidbuffer + 512 * 224); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 0.0f, -1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f(0.0f, 0.0f, -1.0f); glTexCoord2f(1.0f, (224.0 / 256.0)); glVertex3f(0.0f, -1.0f, -1.0f); glTexCoord2f(0.0f, (224.0 / 256.0)); glVertex3f(-1.0f, -1.0f, -1.0f); glEnd(); /* Lower right quad */ glTexImage2D(GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, glvidbuffer + 512 * 224 + 256); glBegin(GL_QUADS); glTexCoord2f(0.0f, 0.0f); glVertex3f(0.0f, 0.0f, -1.0f); glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 0.0f, -1.0f); glTexCoord2f(1.0f, (224.0 / 256.0)); glVertex3f(1.0f, -1.0f, -1.0f); glTexCoord2f(0.0f, (224.0 / 256.0)); glVertex3f(0.0f, -1.0f, -1.0f); glEnd(); } else { /* * This code splits the hires/lores portions up, and draws * them with gl_drawspan */ int lasthires, lasthires_line = 0; gltexture256 = gltexture512 = 0; lasthires = SpecialLine[1]; for (i = 1; i < 222; i++) { if (SpecialLine[i + 1]) { if (lasthires) continue; gl_drawspan(lasthires, lasthires_line, i); lasthires = SpecialLine[i + 1]; lasthires_line = i; } else { if (!lasthires) continue; gl_drawspan(lasthires, lasthires_line, i); lasthires = SpecialLine[i + 1]; lasthires_line = i; } } gl_drawspan(lasthires, lasthires_line, i); /* * This is here rather than right outside this if because the * GUI doesn't allow scanlines to be selected while filters are * on.. There is no technical reason they can't be on while * filters are on, however. Feel free to change the GUI, and * move this outside the if (En2xSaI) {}, if you do. */ if (scanlines) { glDisable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBindTexture(GL_TEXTURE_1D, gltextures[3]); glColor4f(1.0f, 1.0f, 1.0f, scanlines == 1 ? 1.0f : (scanlines == 2 ? 0.25f : 0.50f)); for (i = 0; i < SurfaceY; i += 256) { glBegin(GL_QUADS); glTexCoord1f(0.0f); glVertex3f(-1.0f, (SurfaceY - i * 2.0) / SurfaceY, -1.0f); glTexCoord1f(0.0f); glVertex3f(1.0f, (SurfaceY - i * 2.0) / SurfaceY, -1.0f); glTexCoord1f(1.0f); glVertex3f(1.0f, (SurfaceY - (i + 256) * 2.0) / SurfaceY, -1.0f); glTexCoord1f(1.0f); glVertex3f(-1.0f, (SurfaceY - (i + 256) * 2.0) / SurfaceY, -1.0f); glEnd(); } glDisable(GL_BLEND); glEnable(GL_TEXTURE_2D); } } SDL_GL_SwapBuffers(); }
bool MenuScreen::display_menu(SDL_Surface *screen,SELECTION &selection) { Uint32 ticks=SDL_GetTicks(); Uint32 frame_count=0; //logo sprites const Sprite *logo_free=spr_coll->get_sprite("logo_free"); const Sprite *logo_siege=spr_coll->get_sprite("logo_siege"); //~ const Sprite *logo_sword=spr_coll->get_sprite("logo_sword"); //background sprites const Sprite *back_hill=spr_coll->get_sprite("title_foreground"); const Sprite *back_castle=spr_coll->get_sprite("title_castle"); const Sprite *back_sky=spr_coll->get_sprite("title_sky"); SDL_Event event; float shift=1.0; while (true) { Menu *current_menu=menus.top(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //fill_rect_opengl(0,0,SCREEN_W,SCREEN_H,1,1,0,1); back_sky->draw(0,0); back_castle->draw(0,CASTLE_BIAS+CASTLE_SHIFT*shift); back_hill->draw(0,HILL_BIAS+HILL_SHIFT*shift); shift-=D_SHIFT; if (shift<0) shift=0; //draw_fadein(logo_sword,(SCREEN_W-logo_sword->w)/2,MENUSCREEN_BASE_Y-logo_sword->h/2-4,frame_count,MENUSCREEN_SWORD_FRAME_COUNT,30,4); draw_fadein(logo_free,MENUSCREEN_BASE_X,MENUSCREEN_BASE_Y,frame_count,MENUSCREEN_FREE_FRAME_COUNT,MENUSCREEN_DELAY); draw_fadein(logo_siege,SCREEN_W-logo_siege->w-MENUSCREEN_BASE_X,MENUSCREEN_BASE_Y,frame_count,MENUSCREEN_SIEGE_FRAME_COUNT,MENUSCREEN_DELAY); current_menu->draw(); SDL_GL_SwapBuffers(); SDL_Flip(screen); while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_KEYDOWN: switch (event.key.keysym.sym) { case SDLK_ESCAPE: if (!menus.empty()) menus.pop(); if (menus.empty()) { selection=QUIT; return true; } break; case SDLK_RETURN: case SDLK_SPACE: if (current_menu==main_menu) { switch (current_menu->get_selected()->n) { case 0://2 players versus selection=TWO_PLAYERS; return false; break; case 1://training mode selection=TRAINING; return false; break; case 2://combinaisons selection=COMBINAISONS; return false; break; case 3://options menus.push(option_menu); break; case 4://quit selection=QUIT; return true; break; default: break; } } else if (current_menu==option_menu) { switch (current_menu->get_selected()->n) { case 0://ai level switch (ai_level) { case EASY: ai_level=NORMAL; current_menu->get_selected()->title="AI Level: Knight"; break; case NORMAL: ai_level=HARD; current_menu->get_selected()->title="AI Level: Galaad the Righteous"; break; case HARD: ai_level=EXTREME; current_menu->get_selected()->title="AI Level: Morgoth the Cruel"; break; case EXTREME: ai_level=EASY; current_menu->get_selected()->title="AI Level: Farmer"; break; } break; case 1://keys menus.push(key_menu); break; case 2://Sound if (!Options::soundOn()) { Mix_ResumeMusic(); Options::setSound(true); current_menu->get_selected()->title="Sound: on"; } else { Mix_PauseMusic(); Options::setSound(false); current_menu->get_selected()->title="Sound: off"; } break; case 4://return menus.pop(); break; default: break; } } else if (current_menu==key_menu) { } break; case SDLK_UP: current_menu->previous(); break; case SDLK_DOWN: current_menu->next(); break; default: break; } break; case SDL_QUIT: return true; break; default: break; } } while (ticks>(SDL_GetTicks()-1000/FPS)) SDL_Delay(3); ticks=SDL_GetTicks(); frame_count++; } return true; }
int main(int argc, char *argv[]) { //Essas duas funções servem pra criar a nossa janela. A primeira inicializa //a SDL, enquanto que a segunda cria de fato a janela. Os parâmetros para a //segunda função são: largura, altura, bpp, modo. // * largura, altura: as dimensões da janela que queremos criar // * bpp: bits per pixel, a "resolução de cores" da janela. O valor 32 // significa que queremos uma janela RGBA com 8 bits pra cada componente // * modo: como a janela deve ser criada. O valor SDL_OPENGL indica que a // janela deve ser criada com suporte a OpenGL SDL_Init(SDL_INIT_EVERYTHING); SDL_Surface *tela = SDL_SetVideoMode(300, 600, 32, SDL_OPENGL); //Ah, o loop principal. Jogue "false" em "rodando" e o programa para bool rodando = true; while (rodando) { //A primeira coisa a se fazer todo frame é verificar quais foram os //eventos gerados pelo sistema operacional no frame anterior. Por //"evento", entende-se: // * Tecla pressionada/solta // * Botão do mouse pressionado/solto // * Mouse movimentado // * Ícone "X" da janela clicado // * Janela redimensionada // * Outros eventos do sistema operacional que não nos interessam agora SDL_Event e; //A função SDL_PollEvent pega o primeiro evento não processado até //agora (são armazenados em uma fila). Ela retorna 0 quando não há mais //eventos pra serem processados e alguma coisa diferente de zero quando //há algo ainda pendente. Isso é usado pra tratar todos os eventos //_antes_ de fazer qualquer outra coisa no programa while (SDL_PollEvent(&e)) { //Um evento bastante comum: tecla pressionada. Os códigos das teclas //como SDLK_ESCAPE, SDLK_UP etc. estão no arquivo SDL/SDL_keysym.h if (e.type == SDL_KEYDOWN) if ((e.key.keysym.sym == SDLK_ESCAPE) or (e.key.keysym.sym == SDLK_e)) rodando = false; //Esse é o evento gerado quando o usuário clicou no "x" da janela. //Só clicar não faz nada, o programa é quem tem que decidir o que //fazer quando isso acontece. Aqui, só fechamos o programa direto if (e.type == SDL_QUIT) rodando = false; } //Esses comandos servem pra limpar a tela. O primeiro serve pra //especificar a cor que é pra ser usada pra limpar a tela, e não //precisaria ser chamada toda vez, pois ela seta a cor pra qual você //quer até que essa função seja chamada de novo. A segunda limpa de fato //a tela. O argumento indica o que deve ser limpo. Nesse caso, só //estamos limpando o "color buffer", mas há outros que usaremos em //outros projetos glClearColor(1,1,0,0); glClear(GL_COLOR_BUFFER_BIT); //Isso aqui é pra mostrar o buffer na tela. Até agora, todos os comandos //de desenhar alguma coisa foram aplicados em um buffer "escondido", pra //que não apareça na tela uma imagem pela metade. Essa função faz com //que o buffer que estava escondido seja mostrado e, a partir de agora, //os comandos de desenho vão pro buffer que aparecia antes. Depois troca //de novo e troca troca troca troca... Por isso que chama "double //buffering". A janela do SDL com OpenGL por padrão é criada com o //double buffer. Prático, né? SDL_GL_SwapBuffers(); //Isso é só pra fazer o programa não gastar 100% de CPU pra uma coisa //tão simples. SDL_Delay(10); } //Faz a SDL fechar todas as coisas dela SDL_Quit(); //Tchau! return 0; }
void RendererOpenGL::StopDrawingScene(void) const { SDL_GL_SwapBuffers(); }
void SDLWindow::showFrame() { SDL_GL_SwapBuffers(); }
/* * r_drawFrame * Perform any drawing and setup necessary to produce a single frame. */ static void r_drawFrame() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); r_setupModelviewRotate(); glClear(GL_DEPTH_BUFFER_BIT); // Just in case we set all vertices to white. glColor4f(1,1,1,1); glBindTexture(GL_TEXTURE_2D, textureStars); // Render the front quad glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex3f( 1.0f, -1.0f, -1.0f ); glTexCoord2f(1, 0); glVertex3f( -1.0f, -1.0f, -1.0f ); glTexCoord2f(1, 1); glVertex3f( -1.0f, 1.0f, -1.0f ); glTexCoord2f(0, 1); glVertex3f( 1.0f, 1.0f, -1.0f ); glEnd(); // Render the left quad glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex3f( 1.0f, -1.0f, 1.0f ); glTexCoord2f(1, 0); glVertex3f( 1.0f, -1.0f, -1.0f ); glTexCoord2f(1, 1); glVertex3f( 1.0f, 1.0f, -1.0f ); glTexCoord2f(0, 1); glVertex3f( 1.0f, 1.0f, 1.0f ); glEnd(); // Render the back quad glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex3f( -1.0f, -1.0f, 1.0f ); glTexCoord2f(1, 0); glVertex3f( 1.0f, -1.0f, 1.0f ); glTexCoord2f(1, 1); glVertex3f( 1.0f, 1.0f, 1.0f ); glTexCoord2f(0, 1); glVertex3f( -1.0f, 1.0f, 1.0f ); glEnd(); // Render the right quad glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex3f( -1.0f, -1.0f, -1.0f ); glTexCoord2f(1, 0); glVertex3f( -1.0f, -1.0f, 1.0f ); glTexCoord2f(1, 1); glVertex3f( -1.0f, 1.0f, 1.0f ); glTexCoord2f(0, 1); glVertex3f( -1.0f, 1.0f, -1.0f ); glEnd(); // Render the top quad glBegin(GL_QUADS); glTexCoord2f(0, 1); glVertex3f( -1.0f, 1.0f, -1.0f ); glTexCoord2f(0, 0); glVertex3f( -1.0f, 1.0f, 1.0f ); glTexCoord2f(1, 0); glVertex3f( 1.0f, 1.0f, 1.0f ); glTexCoord2f(1, 1); glVertex3f( 1.0f, 1.0f, -1.0f ); glEnd(); // Render the bottom quad glBegin(GL_QUADS); glTexCoord2f(0, 0); glVertex3f( -1.0f, -1.0f, -1.0f ); glTexCoord2f(0, 1); glVertex3f( -1.0f, -1.0f, 1.0f ); glTexCoord2f(1, 1); glVertex3f( 1.0f, -1.0f, 1.0f ); glTexCoord2f(1, 0); glVertex3f( 1.0f, -1.0f, -1.0f ); glEnd(); glClear(GL_DEPTH_BUFFER_BIT); r_setupModelviewTranslate(); renderer_model_drawASE(0); glBindTexture(GL_TEXTURE_2D, textureLava); glBegin(GL_QUADS); glTexCoord2f(0,0); glVertex3f(200,-201,200); glTexCoord2f(1,0); glVertex3f(200,-201,-200); glTexCoord2f(1,1); glVertex3f(-200,-201,-200); glTexCoord2f(0,1); glVertex3f(-200,-201,200); glEnd(); glBindTexture(GL_TEXTURE_2D, textureScore); glBegin(GL_QUADS); glTexCoord2f(0,0); glVertex3f(20,-200,20); glTexCoord2f(1,0); glVertex3f(20,-200,120); glTexCoord2f(1,1); glVertex3f(120,-200,120); glTexCoord2f(0,1); glVertex3f(120,-200,20); glEnd(); glBindTexture(GL_TEXTURE_2D, textureBrick); glBegin(GL_QUADS); glTexCoord2f(0,0); glVertex3f(2,-1,2); glTexCoord2f(1,0); glVertex3f(2,-1,-2); glTexCoord2f(1,1); glVertex3f(-2,-1,-2); glTexCoord2f(0,1); glVertex3f(-2,-1,2); glEnd(); glBegin(GL_QUADS); glTexCoord2f(0,0); glVertex3f(randx+size,-100,randz+size); glTexCoord2f(size/4,0); glVertex3f(randx+size,-100,randz-size); glTexCoord2f(size/4,size/4); glVertex3f(randx-size,-100,randz-size); glTexCoord2f(0,size/4); glVertex3f(randx-size,-100,randz+size); glEnd(); // DrawOverlay(); r_setupModelview(); glBindTexture(GL_TEXTURE_2D, textureBrick); // // Render a square in front of us // // Render the front quad // glBegin(GL_QUADS); // glTexCoord2f(0, 0); glVertex3f( 0.0f, SQRT_2*-0.1f, -0.2f ); // glTexCoord2f(1, 0); glVertex3f( 0.05f, SQRT_2*-0.1f, -0.1f ); // glTexCoord2f(1, 1); glVertex3f( 0.05f, SQRT_2*-0.05f, -0.1f ); // glTexCoord2f(0, 1); glVertex3f( 0.0f, SQRT_2*-0.05f, -0.2f ); // glEnd(); // // Render the left quad // glBegin(GL_QUADS); // glTexCoord2f(0, 0); glVertex3f( 0.15f, SQRT_2*-0.1f, -0.3f ); // glTexCoord2f(1, 0); glVertex3f( 0.0f, SQRT_2*-0.1f, -0.2f ); // glTexCoord2f(1, 1); glVertex3f( 0.0f, SQRT_2*-0.05f, -0.2f ); // glTexCoord2f(0, 1); glVertex3f( 0.15f, SQRT_2*-0.05f, -0.3f ); // glEnd(); // // Render the back quad // glBegin(GL_QUADS); // glTexCoord2f(0, 0); glVertex3f( 0.2f, SQRT_2*-0.1f, -0.2f ); // glTexCoord2f(1, 0); glVertex3f( 0.15f, SQRT_2*-0.1f, -0.3f ); // glTexCoord2f(1, 1); glVertex3f( 0.15f, SQRT_2*-0.05f, -0.3f ); // glTexCoord2f(0, 1); glVertex3f( 0.2f, SQRT_2*-0.05f, -0.2f ); // glEnd(); // // Render the right quad // glBegin(GL_QUADS); // glTexCoord2f(0, 0); glVertex3f( 0.05f, SQRT_2*-0.1f, -0.1f ); // glTexCoord2f(1, 0); glVertex3f( 0.2f, SQRT_2*-0.1f, -0.2f ); // glTexCoord2f(1, 1); glVertex3f( 0.2f, SQRT_2*-0.05f, -0.2f ); // glTexCoord2f(0, 1); glVertex3f( 0.05f, SQRT_2*-0.05f, -0.1f ); // glEnd(); // // Render the top quad // glBegin(GL_QUADS); // glTexCoord2f(0, 0); glVertex3f( 0.05f, SQRT_2*-0.05f, -0.1f ); // glTexCoord2f(1, 0); glVertex3f( 0.2f, SQRT_2*-0.05f, -0.2f ); // glTexCoord2f(1, 1); glVertex3f( 0.15f, SQRT_2*-0.05f, -0.3f ); // glTexCoord2f(0, 1); glVertex3f( 0.0f, SQRT_2*-0.05f, -0.2f ); // glEnd(); // // Render the bottom quad // glBegin(GL_QUADS); // glTexCoord2f(0, 0); glVertex3f( 0.05f, SQRT_2*-0.1f, -0.1f ); // glTexCoord2f(1, 0); glVertex3f( 0.2f, SQRT_2*-0.1f, -0.2f ); // glTexCoord2f(1, 1); glVertex3f( 0.15f, SQRT_2*-0.1f, -0.3f ); // glTexCoord2f(0, 1); glVertex3f( 0.0f, SQRT_2*-0.1f, -0.2f ); // glEnd(); SDL_GL_SwapBuffers(); }
static void draw_screen() { static double last_frame_time; static int frame_index; static float frame_rates[FRAME_INDEX_MAX]; static float frame_times[FRAME_INDEX_MAX]; double start_time = time_now_double(); glClearColor(0.0, 0.0, 0.0, 0.0); graph_dev_start_frame(); sng_set_foreground(WHITE); sng_abs_xy_draw_string("F1 FOR HELP", NANO_FONT, SCREEN_WIDTH - 100, 10); static struct entity_context *cx; if (!cx) cx = entity_context_new(50, 50); if (wireframe != oldwireframe) { oldwireframe = wireframe; if (wireframe) set_renderer(cx, WIREFRAME_RENDERER | BLACK_TRIS); else set_renderer(cx, FLATSHADING_RENDERER); } float r = target_mesh->radius / tan(FOV / 3.0); /* 50% size for middle zoom */ float r_cam = r * lobby_zoom / 255.0; camera_set_parameters(cx, 0.1f, r * 2.2, SCREEN_WIDTH, SCREEN_HEIGHT, FOV); camera_set_pos(cx, r_cam, 0, 0); camera_look_at(cx, 0, 0, 0); camera_assign_up_direction(cx, 0, 1, 0); union vec3 light_pos = { { 1.01 * r, 0, 0 } }; quat_rot_vec_self(&light_pos, &light_orientation); set_lighting(cx, light_pos.v.x, light_pos.v.y, light_pos.v.z); calculate_camera_transform(cx); struct entity *e = add_entity(cx, target_mesh, 0, 0, 0, WHITE); struct entity *ae = NULL; if (planet_mode) { update_entity_material(e, &planet_material); if (draw_atmosphere) { ae = add_entity(cx, atmosphere_mesh, 0, 0, 0, WHITE); update_entity_scale(ae, 1.03); update_entity_material(ae, &atmosphere_material); } } update_entity_orientation(e, &lobby_orientation); if (isDraggingLight) { union vec3 light_dir = { { 10.75 * r_cam, 0, 0 } }; quat_rot_vec_self(&light_dir, &light_orientation); sng_set_foreground(WHITE); render_line(cx, light_dir.v.x, light_dir.v.y, light_dir.v.z, 0, 0, 0); e = add_entity(cx, light_mesh, light_dir.v.x, light_dir.v.y, light_dir.v.z, WHITE); } else { e = add_entity(cx, light_mesh, light_pos.v.x, light_pos.v.y, light_pos.v.z, WHITE); } render_entities(cx); remove_all_entity(cx); if (helpmode) draw_help_screen(0); if (display_frame_stats > 0) { float avg_frame_rate = 0; float avg_frame_time = 0; int i; for (i = 0; i < FRAME_INDEX_MAX; i++) { avg_frame_rate += frame_rates[i]; avg_frame_time += frame_times[i]; } avg_frame_rate /= (float)FRAME_INDEX_MAX; avg_frame_time /= (float)FRAME_INDEX_MAX; sng_set_foreground(WHITE); char stat_buffer[30]; sprintf(stat_buffer, "fps %5.2f", 1.0/avg_frame_rate); sng_abs_xy_draw_string(stat_buffer, NANO_FONT, 2, 10); sprintf(stat_buffer, "t %0.2f ms", avg_frame_time * 1000.0); sng_abs_xy_draw_string(stat_buffer, NANO_FONT, 92, 10); } if (display_frame_stats > 1) graph_dev_display_debug_menu_show(); graph_dev_end_frame(); glFinish(); /* * Swap the buffers. This this tells the driver to * render the next frame from the contents of the * back-buffer, and to set all rendering operations * to occur on what was the front-buffer. * * Double buffering prevents nasty visual tearing * from the application drawing on areas of the * screen that are being updated at the same time. */ SDL_GL_SwapBuffers(); if (display_frame_stats > 0) { double end_time = time_now_double(); frame_rates[frame_index] = start_time - last_frame_time; frame_times[frame_index] = end_time - start_time; frame_index = (frame_index + 1) % FRAME_INDEX_MAX; last_frame_time = start_time; } }
int main(int argc,char* argv[]) { SDL_Surface *screen; SDL_Surface *ball_bmp; struct ball red_ball, blue_ball; SDL_TimerID timer, timer2; int done; init(&screen); /* Load the BMP file into a surface */ red_ball.ball_bmp = SDL_LoadBMP("ball.bmp"); if (red_ball.ball_bmp == NULL) { fprintf(stderr, "Couldn't load %s: %sn", "ball.bmp", SDL_GetError()); exit(1); } /* Load the BMP file into a surface */ blue_ball.ball_bmp = SDL_LoadBMP("ball2.bmp"); if (blue_ball.ball_bmp == NULL) { fprintf(stderr, "Couldn't load %s: %sn", "ball2.bmp", SDL_GetError()); exit(1); } /* * Palettized screen modes will have a default palette (a standard * 8*8*4 colour cube), but if the image is palettized as well we can * use that palette for a nicer colour matching. * */ if (red_ball.ball_bmp->format->palette && screen->format->palette) { SDL_SetColors(screen, ball_bmp->format->palette->colors, 0, ball_bmp->format->palette->ncolors); } /* Blit onto the screen surface */ if(SDL_BlitSurface(red_ball.ball_bmp, NULL, screen, NULL) < 0) fprintf(stderr, "BlitSurface error: %sn", SDL_GetError()); if(SDL_BlitSurface(blue_ball.ball_bmp, NULL, screen, NULL) < 0) fprintf(stderr, "BlitSurface error: %sn", SDL_GetError()); SDL_UpdateRect(screen, 0, 0, red_ball.ball_bmp->w, red_ball.ball_bmp->h); //This could be put in an init function: red_ball.startx=0; red_ball.starty=0; red_ball.destx=0; red_ball.desty=0; red_ball.x = (float)red_ball.startx; red_ball.y = (float)red_ball.starty; red_ball.dx = 0.0; red_ball.dy = 0.0; red_ball.screen = screen; blue_ball.startx=0; blue_ball.starty=0; blue_ball.destx=0; blue_ball.desty=0; blue_ball.x = (float)blue_ball.startx; blue_ball.y = (float)blue_ball.starty; blue_ball.dx = 0.0; blue_ball.dy = 0.0; blue_ball.screen = screen; glClearColor(0, 0, 0, 0); glClearDepth(1.0f); glViewport(0, 0, 640, 480); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0, 640, 480, 0, 1, -1); glMatrixMode(GL_MODELVIEW); glEnable(GL_TEXTURE_2D); glLoadIdentity(); glBegin(GL_QUADS); glColor3f(1, 0, 0); glVertex3f(0, 0, 0); glColor3f(1, 1, 0); glVertex3f(100, 0, 0); glColor3f(1, 0, 1); glVertex3f(100, 100, 0); glColor3f(1, 1, 1); glVertex3f(0, 100, 0); glEnd(); SDL_GL_SwapBuffers(); timer = SDL_AddTimer(20, move_ball, &red_ball); SDL_Delay(10); timer2 = SDL_AddTimer(20, move_ball, &blue_ball); /*Handle the keyboards events here. Catch the SDL_Quit event to exit*/ done = 0; while (!done) { SDL_Event event; /* Check for events */ while (SDL_PollEvent (&event)) { switch (event.type) { case SDL_KEYDOWN: break; case SDL_MOUSEBUTTONDOWN: { switch(event.button.button) { case SDL_BUTTON_LEFT: { red_ball.destx = event.button.x; red_ball.desty = event.button.y; red_ball.dx = (red_ball.destx - red_ball.x)/50.0; red_ball.dy = (red_ball.desty - red_ball.y)/50.0; break; } case SDL_BUTTON_RIGHT: { blue_ball.destx = event.button.x; blue_ball.desty = event.button.y; blue_ball.dx = (blue_ball.destx - blue_ball.x)/50.0; blue_ball.dy = (blue_ball.desty - blue_ball.y)/50.0; break; } } } break; case SDL_QUIT: done = 1; break; default: break; } } } /* Free the allocated surface*/ SDL_FreeSurface(red_ball.ball_bmp); SDL_FreeSurface(blue_ball.ball_bmp); }
static void wrap_SDL_GL_SwapBuffers(void* ret, void* const* args) { (void)ret; (void)args; SDL_GL_SwapBuffers(); }
/* Here goes our drawing code */ int drawGLScene( GLvoid ) { SDL_Delay(1.0f / 60.0f * 1024); /* These are to calculate our fps */ static GLint T0 = 0; static GLint Frames = 0; /* Clear The Screen And The Depth Buffer */ glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); /* Move Into The Screen 5 Units */ glLoadIdentity( ); glTranslatef( 0.0f, 0.0f, -15.0f ); //glRotatef( xrot, 1.0f, 0.0f, 0.0f); /* Rotate On The X Axis */ glRotatef( yrot, 0.0f, 1.0f, 0.0f); /* Rotate On The Y Axis */ //glRotatef( zrot, 0.0f, 0.0f, 1.0f); /* Rotate On The Z Axis */ /* Select Our Texture */ glBindTexture( GL_TEXTURE_2D, texture[0] ); /* NOTE: * The x coordinates of the glTexCoord2f function need to inverted * for SDL because of the way SDL_LoadBmp loads the data. So where * in the tutorial it has glTexCoord2f( 1.0f, 0.0f ); it should * now read glTexCoord2f( 0.0f, 0.0f ); */ for(int i=-10;i<10;i++){ if(i == 0){ glColor3f(1,0,0); }else{ glColor3f(1,1,1); } glPushMatrix(); glTranslatef( i*3, 0.0f, 0 ); glBegin(GL_QUADS); /* Front Face */ /* Bottom Left Of The Texture and Quad */ glTexCoord2f( 0.0f, 1.0f ); glVertex3f( -1.0f, -1.0f, 1.0f ); /* Bottom Right Of The Texture and Quad */ glTexCoord2f( 1.0f, 1.0f ); glVertex3f( 1.0f, -1.0f, 1.0f ); /* Top Right Of The Texture and Quad */ glTexCoord2f( 1.0f, 0.0f ); glVertex3f( 1.0f, 1.0f, 1.0f ); /* Top Left Of The Texture and Quad */ glTexCoord2f( 0.0f, 0.0f ); glVertex3f( -1.0f, 1.0f, 1.0f ); /* Back Face */ /* Bottom Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 0.0f ); glVertex3f( -1.0f, -1.0f, -1.0f ); /* Top Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 1.0f ); glVertex3f( -1.0f, 1.0f, -1.0f ); /* Top Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 1.0f ); glVertex3f( 1.0f, 1.0f, -1.0f ); /* Bottom Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 0.0f ); glVertex3f( 1.0f, -1.0f, -1.0f ); /* Top Face */ /* Top Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 1.0f ); glVertex3f( -1.0f, 1.0f, -1.0f ); /* Bottom Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 0.0f ); glVertex3f( -1.0f, 1.0f, 1.0f ); /* Bottom Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 0.0f ); glVertex3f( 1.0f, 1.0f, 1.0f ); /* Top Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 1.0f ); glVertex3f( 1.0f, 1.0f, -1.0f ); /* Bottom Face */ /* Top Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 1.0f ); glVertex3f( -1.0f, -1.0f, -1.0f ); /* Top Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 1.0f ); glVertex3f( 1.0f, -1.0f, -1.0f ); /* Bottom Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 0.0f ); glVertex3f( 1.0f, -1.0f, 1.0f ); /* Bottom Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 0.0f ); glVertex3f( -1.0f, -1.0f, 1.0f ); /* Right face */ /* Bottom Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 0.0f ); glVertex3f( 1.0f, -1.0f, -1.0f ); /* Top Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 1.0f ); glVertex3f( 1.0f, 1.0f, -1.0f ); /* Top Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 1.0f ); glVertex3f( 1.0f, 1.0f, 1.0f ); /* Bottom Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 0.0f ); glVertex3f( 1.0f, -1.0f, 1.0f ); /* Left Face */ /* Bottom Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 0.0f ); glVertex3f( -1.0f, -1.0f, -1.0f ); /* Bottom Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 0.0f ); glVertex3f( -1.0f, -1.0f, 1.0f ); /* Top Right Of The Texture and Quad */ glTexCoord2f( 0.0f, 1.0f ); glVertex3f( -1.0f, 1.0f, 1.0f ); /* Top Left Of The Texture and Quad */ glTexCoord2f( 1.0f, 1.0f ); glVertex3f( -1.0f, 1.0f, -1.0f ); glEnd( ); glPopMatrix(); } /* Draw it to the screen */ SDL_GL_SwapBuffers( ); /* Gather our frames per second */ Frames++; { GLint t = SDL_GetTicks(); if (t - T0 >= 5000) { GLfloat seconds = (t - T0) / 1000.0; GLfloat fps = Frames / seconds; printf("%d frames in %g seconds = %g FPS\n", Frames, seconds, fps); T0 = t; Frames = 0; } } if(rotate){ xrot += 0.3f; /* X Axis Rotation */ yrot += 0.2f; /* Y Axis Rotation */ zrot += 0.4f; /* Z Axis Rotation */ } return( TRUE ); }
int main( int argc, char *argv[] ) { printf("It's dangerous to go alone! Take this.\n" ); printf("Game Data Dir: %s\n", getResourceDir().c_str() ); // Initialize SDL if (SDL_Init( SDL_INIT_NOPARACHUTE | SDL_INIT_VIDEO ) < 0 ) { printf("Unable to init SDL: %s\n", SDL_GetError() ); exit(1); } // cheezy check for fullscreen Uint32 mode_flags = SDL_OPENGL; for (int i=1; i < argc; i++) { if (!_stricmp( argv[i], "-fullscreen")) { mode_flags |= SDL_FULLSCREEN; } } // TODO: flag to control this SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, 4 ); if (SDL_SetVideoMode( 800, 600, 32, mode_flags ) == 0 ) { printf( "Unable to set video mode: %s\n", SDL_GetError() ) ; exit(1); } SDL_WM_SetCaption( "Take This.", NULL ); // Initialize resources TakeThisGame *game = new TakeThisGame(); game->init(); atexit( TakeThisGame::shutdown ); // init graphics glViewport( 0, 0, 800, 600 ); //=====[ Main loop ]====== bool done = false; Uint32 ticks = SDL_GetTicks(), ticks_elapsed, sim_ticks = 0; float lookMoveX, lookMoveY; while(!done) { SDL_Event event; while (SDL_PollEvent( &event ) ) { switch (event.type ) { case SDL_KEYDOWN: switch( event.key.keysym.sym ) { case SDLK_ESCAPE: done = true; break; default: game->keypress( event.key.keysym.sym ); break; } break; case SDL_MOUSEMOTION: game->mouseMotion( event.motion.xrel, event.motion.yrel ); break; case SDL_MOUSEBUTTONDOWN: //game->mouse( event.button ); break; case SDL_MOUSEBUTTONUP: //game->mouse( event.button ); break; case SDL_QUIT: done = true; break; default: break; } } // Do continuous keys Uint8 *keyState = SDL_GetKeyState( NULL ); // convert to btn mask Uint32 btnMask = 0; btnMask |= (keyState[SDLK_LEFT]||keyState[SDLK_a])?BTN_LEFT:0; btnMask |= (keyState[SDLK_RIGHT]||keyState[SDLK_d])?BTN_RIGHT:0; btnMask |= (keyState[SDLK_UP]||keyState[SDLK_w])?BTN_UP:0; btnMask |= (keyState[SDLK_DOWN]||keyState[SDLK_s])?BTN_DOWN:0; btnMask |= (keyState[SDLK_z]||keyState[SDLK_COMMA])?BTN_A:0; btnMask |= (keyState[SDLK_x]||keyState[SDLK_PERIOD])?BTN_B:0; game->updateButtons( btnMask ); // Timing ticks_elapsed = SDL_GetTicks() - ticks; ticks += ticks_elapsed; // fixed sim update sim_ticks += ticks_elapsed; while (sim_ticks > STEPTIME) { sim_ticks -= STEPTIME; //printf("update sim_ticks %d ticks_elapsed %d\n", sim_ticks, ticks_elapsed ); game->updateSim( (float)STEPTIME / 1000.0f ); } // redraw as fast as possible float dtRaw = (float)(ticks_elapsed) / 1000.0f; game->updateFree( dtRaw ); game->redraw(); SDL_GL_SwapBuffers(); // Call this once a frame if using tweakables //ReloadChangedTweakableValues(); } return 1; };
//============================================================================ int main( int argc, char *argv[] ) { printf("Game Data Dir: %s\n", getResourceDir().c_str() ); // Initialize SDL if (SDL_Init( SDL_INIT_NOPARACHUTE | SDL_INIT_VIDEO ) < 0 ) { fprintf( stderr, "Unable to init SDL: %s\n", SDL_GetError() ); } if (SDL_SetVideoMode( SCREEN_RES_X, SCREEN_RES_Y, 32, SDL_OPENGL /* | SDL_FULLSCREEN */ ) == 0 ) { fprintf(stderr, "Unable to set video mode: %s\n", SDL_GetError()); exit(1); } SDL_WM_SetCaption( "LD13 Crossroads", NULL ); // seed rand srand( time(0) ); // Game GameState game; game.nextLevel(); GameViewGL gameView( &game ); //=====[ Main loop ]====== Uint32 ticks = SDL_GetTicks(), ticks_elapsed, sim_ticks = 0; bool done = false; while(!done) { SDL_Event event; while (SDL_PollEvent( &event ) ) { switch (event.type ) { case SDL_KEYDOWN: switch( event.key.keysym.sym ) { case SDLK_ESCAPE: game.cancelWord(); break; case SDLK_RETURN: case SDLK_SPACE: game.commitWord(); break; case SDLK_r: game.restartLevel(); break; case SDLK_n: game.nextLevel(); break; default: break; } break; case SDL_MOUSEMOTION: gameView.mouseMove( event.motion.x, event.motion.y ); break; case SDL_MOUSEBUTTONDOWN: gameView.mouseDown(); break; case SDL_MOUSEBUTTONUP: gameView.mouseUp(); break; case SDL_QUIT: done = true; break; } } // Timing ticks_elapsed = SDL_GetTicks() - ticks; ticks += ticks_elapsed; // fixed sim update sim_ticks += ticks_elapsed; while (sim_ticks > STEPTIME) { sim_ticks -= STEPTIME; // printf("update sim_ticks %d ticks_elapsed %d\n", sim_ticks, ticks_elapsed ); game.update( (float)STEPTIME / 1000.0f ); } // redraw as fast as possible float dtRaw = (float)(ticks_elapsed) / 1000.0f; //_RPT2( _CRT_WARN, "ticks_elapsed %d dtraw %f\n", ticks_elapsed, dtRaw ); gameView.update( dtRaw ); gameView.redraw( dtRaw ); SDL_GL_SwapBuffers(); } SDL_Quit(); return 0; }
void render_gl() { const glVec WHITE_COLOR(1.0f,1.0f,1.0f,1.0f); const glVec GREY_COLOR(0.6f,0.6f,0.6f,0.6f); const glVec I_COLOR(1.0f,0.0f,0.0f,1.0f); const glVec J_COLOR(0.0f,1.0f,0.0f,1.0f); const glVec L_COLOR(0.0f,0.0f,1.0f,1.0f); const glVec O_COLOR(1.0f,1.0f,0.0f,1.0f); const glVec S_COLOR(1.0f,0.0f,1.0f,1.0f); const glVec T_COLOR(0.0f,1.0f,1.0f,1.0f); const glVec Z_COLOR(0.5f,1.0f,0.5f,1.0f); const DataBuffer &gameState=GAME_STATE.buffer.swap_and_read(); SDL_GL_SwapBuffers(); printGlError(); glClear(GL_COLOR_BUFFER_BIT); // Draw blocks set in field glUniform4fv(GL_STATE.tintUniform, 1, GREY_COLOR.data); for(unsigned i=0;i<FIELD_WIDTH;++i) { for(unsigned j=0;j<FIELD_VIEW_HEIGHT;++j) { if(gameState.field.get(i,j)) { glUniform2f(GL_STATE.offsetUniform,(GLfloat)i,(GLfloat)j); glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_SHORT,0); } } } // Draw current piece arrayt blocks=gameState.current.getBlocks(); switch(gameState.current.getType()) { case I: glUniform4fv(GL_STATE.tintUniform, 1, I_COLOR.data); break; case J: glUniform4fv(GL_STATE.tintUniform, 1, J_COLOR.data); break; case L: glUniform4fv(GL_STATE.tintUniform, 1, L_COLOR.data); break; case O: glUniform4fv(GL_STATE.tintUniform, 1, O_COLOR.data); break; case S: glUniform4fv(GL_STATE.tintUniform, 1, S_COLOR.data); break; case T: glUniform4fv(GL_STATE.tintUniform, 1, T_COLOR.data); break; case Z: glUniform4fv(GL_STATE.tintUniform, 1, Z_COLOR.data); break; default: std::cerr << "Unhandled case in enumerated switch statement!\n"; break; } for(auto block : blocks) { glUniform2f(GL_STATE.offsetUniform,(GLfloat)block.x,(GLfloat)block.y); glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_SHORT,0); } }
static void Frame() { g_Profiler2.RecordFrameStart(); PROFILE2("frame"); g_Profiler2.IncrementFrameNumber(); PROFILE2_ATTR("%d", g_Profiler2.GetFrameNumber()); ogl_WarnIfError(); // get elapsed time const double time = timer_Time(); g_frequencyFilter->Update(time); // .. old method - "exact" but contains jumps #if 0 static double last_time; const double time = timer_Time(); const float TimeSinceLastFrame = (float)(time-last_time); last_time = time; ONCE(return); // first call: set last_time and return // .. new method - filtered and more smooth, but errors may accumulate #else const float realTimeSinceLastFrame = 1.0 / g_frequencyFilter->SmoothedFrequency(); #endif ENSURE(realTimeSinceLastFrame > 0.0f); // decide if update/render is necessary bool need_render = !g_app_minimized; bool need_update = true; // If we are not running a multiplayer game, disable updates when the game is // minimized or out of focus and relinquish the CPU a bit, in order to make // debugging easier. if(g_PauseOnFocusLoss && !g_NetClient && !g_app_has_focus) { PROFILE3("non-focus delay"); need_update = false; // don't use SDL_WaitEvent: don't want the main loop to freeze until app focus is restored SDL_Delay(10); } // TODO: throttling: limit update and render frequency to the minimum. // this is mostly relevant for "inactive" state, so that other windows // get enough CPU time, but it's always nice for power+thermal management. bool is_building_archive = ProgressiveBuildArchive(); // this scans for changed files/directories and reloads them, thus // allowing hotloading (changes are immediately assimilated in-game). // must not be done during archive building because it changes the // archive file each iteration, but keeps it locked; reloading // would trigger a warning because the file can't be opened. if(!is_building_archive) ReloadChangedFiles(); ProgressiveLoad(); RendererIncrementalLoad(); PumpEvents(); // if the user quit by closing the window, the GL context will be broken and // may crash when we call Render() on some drivers, so leave this loop // before rendering if (quit) return; // respond to pumped resize events if (g_ResizedW || g_ResizedH) { g_VideoMode.ResizeWindow(g_ResizedW, g_ResizedH); g_ResizedW = g_ResizedH = 0; } if (g_NetClient) g_NetClient->Poll(); ogl_WarnIfError(); g_GUI->TickObjects(); ogl_WarnIfError(); if (g_Game && g_Game->IsGameStarted() && need_update) { g_Game->Update(realTimeSinceLastFrame); g_Game->GetView()->Update(float(realTimeSinceLastFrame)); } // Immediately flush any messages produced by simulation code if (g_NetClient) g_NetClient->Flush(); g_UserReporter.Update(); g_Console->Update(realTimeSinceLastFrame); ogl_WarnIfError(); if(need_render) { Render(); PROFILE3("swap buffers"); #if SDL_VERSION_ATLEAST(2, 0, 0) SDL_GL_SwapWindow(g_VideoMode.GetWindow()); #else SDL_GL_SwapBuffers(); #endif } ogl_WarnIfError(); g_Profiler.Frame(); g_GameRestarted = false; }
/* Renders the frame and calls calcFps() */ static void render(RenderConf *rc) { double ws = world.worldSize; RenderMat3 m3; double m4[16]; calcFps(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* 3D */ renderSet3D(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); mat3_from_quat(m3, quat_conjugate(cam_orientation)); mat4_from_mat3(m4, m3); glMultMatrixd(m4); glTranslatef(-cam_position.x, -cam_position.y, -cam_position.z); if (autorotate) camOrbit(5, 0); if (renderSPGridBoxes) renderBoxes(rc->numBoxes); if (renderWorldLoops) { /* Line loops for world box */ glColor3f(0.0, 1.0, 0.0); glBegin(GL_LINE_LOOP); glVertex3f(-ws/2, -ws/2, -ws/2); glVertex3f(-ws/2, -ws/2, +ws/2); glVertex3f(-ws/2, +ws/2, +ws/2); glVertex3f(-ws/2, +ws/2, -ws/2); glEnd(); glBegin(GL_LINE_LOOP); glVertex3f(+ws/2, -ws/2, -ws/2); glVertex3f(+ws/2, -ws/2, +ws/2); glVertex3f(+ws/2, +ws/2, +ws/2); glVertex3f(+ws/2, +ws/2, -ws/2); glEnd(); } /* Strands */ for (int s = 0; s < world.numStrands; s++) renderStrand(&world.strands[s], rc); /* Text */ renderSet2D(); const int n = 64; char string[n]; snprintf(string, n, "T = %lf K", getKineticTemperature()); renderString(string, 10, 40); snprintf(string, n, "t = %lf µs (dt = %lf fs)", getTime() / MICROSECONDS, getIntegratorTimeStep() / FEMTOSECONDS); renderString(string, 10, 25); int ips; double tps; getProgressPerSecond(&ips, &tps); snprintf(string, n, "ips = %d (time/min = %lf ns)", ips, tps / NANOSECONDS * 60); renderString(string, 10, 10); glLoadIdentity(); renderString(fps_string, 10, SCREEN_H - 10); StringList *node = strings; while (node != NULL) { renderString(node->rsc.string, node->rsc.x, node->rsc.y); node = node->next; } SDL_GL_SwapBuffers(); }
void displaySDL() { if (runningSDL) SDL_GL_SwapBuffers(); }
void Main::Execute() { if(SDL_Init(SDL_INIT_EVERYTHING) < 0) { printf("SDL Failed to init"); return; } // Allow the game pads to be polled. SDL_JoystickEventState(SDL_IGNORE); SDL_EnableUNICODE(1); SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 32); SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 8); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2); // Done once before maingame loop to force assets to load ResetRenderWindow(); // mac setups up OpenGL here mDinodeck->ForceReload(); ResetRenderWindow(); // height + width info loaded unsigned int thisTime = 0; unsigned int lastTime = 0; unsigned int framesPerSecond = 60; unsigned int millisecondsPerFrame = 1000 / framesPerSecond; unsigned int fpsTicks = 0; SDL_Event event; while(mRunning) { // Calculate delta time thisTime = SDL_GetTicks(); // returns in milliseconds double deltaTime = static_cast<double>((thisTime - lastTime) / 1000); // convert to seconds lastTime = thisTime; while(SDL_PollEvent(&event)) { OnEvent(&event); } mDinodeck->Update(deltaTime); fpsTicks = SDL_GetTicks() - fpsTicks; if (fpsTicks < millisecondsPerFrame) { SDL_Delay(millisecondsPerFrame - fpsTicks); } SDL_GL_SwapBuffers(); } SDL_Quit(); return; }