void WindowSDL::SwapBuffers()
{
SDL_GL_SwapWindow(m_window);
}
int main( int argc, char* argv[] )
{
if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 )
return -1;
if( TTF_Init() < 0 )
return -1;
SDL_Window* window = SDL_CreateWindow( WINDOW_TITLE,
WINDOW_X, WINDOW_Y,
WINDOW_W, WINDOW_H,
SDL_WINDOW_OPENGL );
if( window )
{
SDL_GLContext context = SDL_GL_CreateContext( window );
if( context )
{
glewExperimental = GL_TRUE;
if( glewInit() != GLEW_OK )
return -1;
Memory memory;
memory.size = GAME_MEMORY_POOL;
memory.pointer = malloc( memory.size );
Input newInput = {}, oldInput = {};
const real64_t dt = GAME_DT;
real64_t accumulator = 0.0;
uint32_t ticks = SDL_GetTicks();
bool32_t running = GameInit( &memory );
while( running )
{
uint32_t curTicks = SDL_GetTicks();
uint32_t frametime = curTicks - ticks;
ticks = curTicks;
accumulator += (real64_t)frametime / 1000.0;
while( accumulator > dt )
{
oldInput = newInput;
SDL_Event e;
while( SDL_PollEvent( &e ) )
{
if( e.type == SDL_QUIT )
running = false;
else if( e.type == SDL_KEYDOWN )
{
if( e.key.keysym.sym == SDLK_ESCAPE )
running = false;
else if( e.key.keysym.sym == SDLK_SPACE )
newInput.keys[KEY_SPACE] = true;
else if( e.key.keysym.sym == SDLK_RETURN )
newInput.keys[KEY_ENTER] = true;
}
else if( e.type == SDL_KEYUP )
{
if( e.key.keysym.sym == SDLK_SPACE )
newInput.keys[KEY_SPACE] = false;
else if( e.key.keysym.sym == SDLK_RETURN )
newInput.keys[KEY_ENTER] = false;
}
else if( e.type == SDL_MOUSEBUTTONDOWN )
{
if( e.button.button == SDL_BUTTON_LEFT )
newInput.buttons[BUTTON_LEFT] = true;
else if( e.button.button == SDL_BUTTON_RIGHT )
newInput.buttons[BUTTON_RIGHT] = true;
}
else if( e.type == SDL_MOUSEBUTTONUP )
{
if( e.button.button == SDL_BUTTON_LEFT )
newInput.buttons[BUTTON_LEFT] = false;
else if( e.button.button == SDL_BUTTON_RIGHT )
newInput.buttons[BUTTON_RIGHT] = false;
}
else if( e.type == SDL_MOUSEMOTION )
{
newInput.mousePosition.x = e.motion.x;
newInput.mousePosition.y = e.motion.y;
newInput.mouseDelta.x = e.motion.xrel;
newInput.mouseDelta.y = e.motion.yrel;
}
}
if( !GameUpdate( &memory, &newInput, &oldInput, dt ) )
running = false;
accumulator -= dt;
}
GameRender( &memory );
SDL_GL_SwapWindow( window );
}
}
SDL_GL_DeleteContext( context );
}
TTF_Quit();
SDL_DestroyWindow( window );
SDL_Quit();
return 0;
}
void SDLContext::swap() const
{
if (!vsync_)
Chrono::sleep(0);
SDL_GL_SwapWindow(window_);
}
int Window::GLswapWindow(State & state, SDL_Window * window){
SDL_GL_SwapWindow(window);
return 0;
}
int main(int argc, char** argv)
{
int status;
SDL_WindowID window;
SDL_GLContext glcontext=NULL;
SDL_Event event;
SDL_bool done=SDL_FALSE;
status=SDL_Init(SDL_INIT_VIDEO);
if (status<0)
{
fprintf(stderr, "Can't init default SDL video driver: %s\n", SDL_GetError());
exit(-1);
}
/* Select first display */
status=SDL_SelectVideoDisplay(0);
if (status<0)
{
fprintf(stderr, "Can't attach to first display: %s\n", SDL_GetError());
exit(-1);
}
window=SDL_CreateWindow("SDL GLU ES Nurbs Curves test",
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
WINDOW_WIDTH, WINDOW_HEIGHT,
SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
if (window==0)
{
fprintf(stderr, "Can't create window: %s\n", SDL_GetError());
exit(-1);
}
glcontext=SDL_GL_CreateContext(window);
if (glcontext==NULL)
{
fprintf(stderr, "Can't create OpenGL ES context: %s\n", SDL_GetError());
exit(-1);
}
status=SDL_GL_MakeCurrent(window, glcontext);
if (status<0)
{
fprintf(stderr, "Can't set current OpenGL ES context: %s\n", SDL_GetError());
exit(-1);
}
init_scene(window_width, window_height);
do {
/* handle the events in the queue */
while (SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_WINDOWEVENT:
switch (event.window.event)
{
case SDL_WINDOWEVENT_CLOSE:
done=SDL_TRUE;
break;
case SDL_WINDOWEVENT_RESIZED:
resize(event.window.data1, event.window.data2);
break;
}
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym)
{
case SDLK_ESCAPE:
done=SDL_TRUE;
break;
}
break;
case SDL_QUIT:
done=SDL_TRUE;
break;
}
}
if (done==SDL_TRUE)
{
break;
}
render_scene();
SDL_GL_SwapWindow(window);
} while(1);
/* Destroy NURBS renderer */
gluDeleteNurbsRenderer(mynurbs);
SDL_GL_DeleteContext(glcontext);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
int main( int argc, char** argv )
{
unsigned int tickDelta;
unsigned int currTicks;
unsigned int physicsTickAcc;
int numPhysicsProcesses;
float renderDelta;
#ifdef _DEBUG
SDL_LogSetAllPriority( SDL_LOG_PRIORITY_VERBOSE );
#else
SDL_LogSetAllPriority( SDL_LOG_PRIORITY_WARN );
#endif
SDL_LogSetAllPriority( SDL_LOG_PRIORITY_VERBOSE );
if( initEverything( ) < 0 ) {
return 1;
}
srand( (unsigned int)time( NULL ) );
/* main loop */
running = 1;
lastTicks = SDL_GetTicks( );
physicsTickAcc = 0;
gsmEnterState( &globalFSM, &titleScreenState );
while( running ) {
if( !focused ) {
processEvents( 1 );
continue;
}
currTicks = SDL_GetTicks( );
tickDelta = currTicks - lastTicks;
lastTicks = currTicks;
physicsTickAcc += tickDelta;
/* process input */
processEvents( 0 );
sys_Process( );
gsmProcess( &globalFSM );
/* process movement and collision */
numPhysicsProcesses = 0;
while( physicsTickAcc > PHYSICS_TICK ) {
sys_PhysicsTick( PHYSICS_DELTA );
gsmPhysicsTick( &globalFSM, PHYSICS_DELTA );
physicsTickAcc -= PHYSICS_TICK;
++numPhysicsProcesses;
}
/* rendering */
if( numPhysicsProcesses > 0 ) {
/* set the new render positions */
renderDelta = PHYSICS_DELTA * (float)numPhysicsProcesses;
gfx_ClearDrawCommands( renderDelta );
cam_FinalizeStates( renderDelta );
/* render all the things */
sys_Draw( );
gsmDraw( &globalFSM );
}
float dt = (float)tickDelta / 1000.0f;
cam_Update( dt );
gfx_Render( dt );
// flip here so we don't have to store the window anywhere else
SDL_GL_SwapWindow( window );
}
return 0;
}
int main(int argc, char * arg[])
{
//Controls the game loop
bool run = true;
// init everyting - SDL, if it is nonzero we have a problem
if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
{
std::cout << "ERROR SDL_Init " << SDL_GetError() << std::endl;
return -1;
}
//
int imageInitFlags = IMG_INIT_JPG | IMG_INIT_PNG;
int returnInitFlags = IMG_Init(imageInitFlags);
if (((returnInitFlags)& (imageInitFlags)) != imageInitFlags) {
cout << "ERROR SDL_Image Init " << IMG_GetError() << endl;
}
if (TTF_Init() == -1) {
std::cout << "ERROR TTF_Init: " << TTF_GetError();
}
//Request opengl 4.1 context, Core Context
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
//Create a window
SDL_Window * window = SDL_CreateWindow(
"SDL", // window title
SDL_WINDOWPOS_CENTERED, // x position, centered
SDL_WINDOWPOS_CENTERED, // y position, centered
640, // width, in pixels
480, // height, in pixels
SDL_WINDOW_OPENGL // flags
);
// Create an OpenGL context associated with the window.
SDL_GLContext glcontext = SDL_GL_CreateContext(window);
//Call our InitOpenGL Function
initOpenGL();
//Set our viewport
setViewport(640, 480);
initScene();
//Value to hold the event generated by SDL
SDL_Event event;
//Game Loop
while (run)
{
//While we still have events in the queue
while (SDL_PollEvent(&event)) {
//Get event type
if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE) {
//set our boolean which controls the loop to false
run = false;
}
if (event.type == SDL_KEYDOWN){
switch (event.key.keysym.sym)
{
case SDLK_LEFT:
break;
case SDLK_RIGHT:
break;
case SDLK_UP:
break;
case SDLK_DOWN:
break;
default:
break;
}
}
}
//init Scene
update();
//render
render();
//Call swap so that our GL back buffer is displayed
SDL_GL_SwapWindow(window);
}
// clean up, reverse order!!!
cleanUp();
SDL_GL_DeleteContext(glcontext);
SDL_DestroyWindow(window);
IMG_Quit();
TTF_Quit();
SDL_Quit();
return 0;
}
/**
* Swap the buffers and possibly do other stuff that yet needs to be
* determined.
*/
void GLimp_EndFrame( void )
{
SDL_GL_SwapWindow( glw_state.sdl_window );
}
/*
===============
GLimp_EndFrame
Responsible for doing a swapbuffers
===============
*/
void GLimp_EndFrame( void )
{
// don't flip if drawing to front buffer
if ( Q_stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
{
SDL_GL_SwapWindow( window );
}
/*if( r_minimize && r_minimize->integer )
{
extern qboolean fullscreen_minimized;
extern void IN_DeactivateMouse( void );
SDL_Surface *s = SDL_GetWindowSurface( window );//SDL_GetVideoSurface( );
qboolean fullscreen = qfalse;
qboolean minimized = qfalse;
fullscreen = ( s && ( s->flags & SDL_WINDOW_FULLSCREEN ) );
#ifdef MACOS_X
// this is a bit crap, but the mac SDL_WM_IconifyWindow does not work
// on fullscreen windows, nor does the SDL_WM_ToggleFullscreen work
if( !fullscreen )
{
if( SDL_WM_IconifyWindow( ) )
IN_DeactivateMouse();
Cvar_Set( "r_minimize", "0" );
}
else if( r_fullscreen->integer )
{
Cvar_Set( "r_fullscreen", "0" );
fullscreen_minimized = qtrue;
}
#else
minimized = ( SDL_WM_IconifyWindow( ) != 0 );
if( fullscreen && minimized )
fullscreen_minimized = qtrue;
// this shouldn't be necessary, but seems to prevent X11 mouse problems
if( minimized )
IN_DeactivateMouse();
Cvar_Set( "r_minimize", "0" );
#endif // MACOS_X
}*/
/*
if( r_fullscreen->modified )
{
qboolean fullscreen;
qboolean needToToggle = qtrue;
qboolean sdlToggled = qfalse;
SDL_Surface *s = SDL_GetWindowSurface( window );
if( s )
{
// Find out the current state
fullscreen = !!( s->flags & SDL_WINDOW_FULLSCREEN );
if( r_fullscreen->integer && Cvar_VariableIntegerValue( "in_nograb" ) )
{
ri.Printf( PRINT_ALL, "Fullscreen not allowed with in_nograb 1\n");
ri.Cvar_Set( "r_fullscreen", "0" );
r_fullscreen->modified = qfalse;
}
// Is the state we want different from the current state?
needToToggle = !!r_fullscreen->integer != fullscreen;
if( needToToggle ) {
if( r_fullscreen->integer ) {
sdlToggled = SDL_SetWindowFullscreen( window, SDL_WINDOW_FULLSCREEN );
}
else {
sdlToggled = SDL_SetWindowFullscreen( window, 0 );
}
if( sdlToggled == 0 ) {
sdlToggled = 1;
}
}
}
if( needToToggle )
{
// SDL_WM_ToggleFullScreen didn't work, so do it the slow way
if( !sdlToggled )
Cbuf_AddText( "vid_restart" );
IN_Restart( );
}
r_fullscreen->modified = qfalse;
}*/
}
int main(int argc, char *argv[])
{
ShaderProgram program = setup();
Matrix paddle_left_matrix;
Matrix paddle_right_matrix;
Matrix ball_matrix;
Matrix view_matrix;
Matrix projection_matrix;
GLuint chartreuse_texture_ID = load_texture_rgb("chartreuse.png");
projection_matrix.setOrthoProjection(-3.55f, 3.55f, -2.0f, 2.0f, -1.0f, 1.0f);
SDL_Event event;
bool done = false;
bool game_started = false;
Paddle paddle_left(-3.5f, -3.4f, 0.5f, -0.5f);
Paddle paddle_right(3.4f, 3.5f, 0.5f, -0.5f);
Ball ball(0.0f, 0.0f, 0.05f, 0.0025f, (float)rand(), (float)rand());
while (!done)
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//Controls for the game
while (SDL_PollEvent(&event))
{
if (event.type == SDL_QUIT || event.type == SDL_WINDOWEVENT_CLOSE)
done = true;
if (event.type == SDL_KEYDOWN)
{
// left paddle
if (event.key.keysym.scancode == SDL_SCANCODE_W)
{
if (paddle_left.top < 2.0f){
paddle_left.top += 0.3f;
paddle_left.bottom += 0.3f;
paddle_left_matrix.Translate(0.0f, 0.3f, 0.0f);
}
}
if (event.key.keysym.scancode == SDL_SCANCODE_S)
{
if (paddle_left.bottom > -2.0f){
paddle_left.top -= 0.3f;
paddle_left.bottom -= 0.3f;
paddle_left_matrix.Translate(0.0f, -0.3f, 0.0f);
}
}
// right paddle
if (event.key.keysym.scancode == SDL_SCANCODE_UP)
{
if (paddle_right.top < 2.0f){
paddle_right.top += 0.3f;
paddle_right.bottom += 0.3f;
paddle_right_matrix.Translate(0.0f, 0.3f, 0.0f);
}
}
if (event.key.keysym.scancode == SDL_SCANCODE_DOWN)
{
if (paddle_right.bottom > -2.0f){
paddle_right.top -= 0.3f;
paddle_right.bottom -= 0.3f;
paddle_right_matrix.Translate(0.0f, -0.3f, 0.0f);
}
}
if (event.key.keysym.scancode == SDL_SCANCODE_SPACE || event.key.keysym.scancode == SDL_SCANCODE_RETURN)
{
if (!game_started)
game_started = true;
}
}
}
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
program.setModelMatrix(paddle_left_matrix);
program.setViewMatrix(view_matrix);
program.setProjectionMatrix(projection_matrix);
glUseProgram(program.programID);
float texture_coords[] = { 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f }; // global texture coordinates
// left paddle
float paddle_left_coords[] = { -3.5f, -0.5f, -3.4f, -0.5f, -3.4f, 0.5f, -3.4f, 0.5f, -3.5f, 0.5f, -3.5f, -0.5f };
glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, paddle_left_coords);
glEnableVertexAttribArray(program.positionAttribute);
glDrawArrays(GL_TRIANGLES, 0, 6);
glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texture_coords);
glEnableVertexAttribArray(program.texCoordAttribute);
glBindTexture(GL_TEXTURE_2D, chartreuse_texture_ID);
glDisableVertexAttribArray(program.positionAttribute);
glDisableVertexAttribArray(program.texCoordAttribute);
// right paddle
program.setModelMatrix(paddle_right_matrix);
float paddle_right_coords[] = { 3.4f, -0.5f, 3.5f, -0.5f, 3.5f, 0.5f, 3.5f, 0.5f, 3.4f, 0.5f, 3.4f, -0.5f };
glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, paddle_right_coords);
glEnableVertexAttribArray(program.positionAttribute);
glDrawArrays(GL_TRIANGLES, 0, 6);
glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texture_coords);
glEnableVertexAttribArray(program.texCoordAttribute);
glBindTexture(GL_TEXTURE_2D, chartreuse_texture_ID);
glDisableVertexAttribArray(program.positionAttribute);
glDisableVertexAttribArray(program.texCoordAttribute);
// ball
program.setModelMatrix(ball_matrix);
float ball_coords[] = { -0.1f, -0.1f, 0.1f, -0.1f, 0.1f, 0.1f, 0.1f, 0.1f, -0.1f, 0.1f, -0.1f, -0.1f };
glVertexAttribPointer(program.positionAttribute, 2, GL_FLOAT, false, 0, ball_coords);
glEnableVertexAttribArray(program.positionAttribute);
glDrawArrays(GL_TRIANGLES, 0, 6);
glVertexAttribPointer(program.texCoordAttribute, 2, GL_FLOAT, false, 0, texture_coords);
glEnableVertexAttribArray(program.texCoordAttribute);
glBindTexture(GL_TEXTURE_2D, chartreuse_texture_ID);
glDisableVertexAttribArray(program.positionAttribute);
glDisableVertexAttribArray(program.texCoordAttribute);
if (game_started)
{
// right wins
if (ball.position_x - 0.1f <= paddle_left.left)
{
game_started = false;
ball_matrix.Translate(-ball.position_x, -ball.position_y, 0.0f);
ball.position_x = 0.0f; // for some reason reset() doesn't work :-(
ball.position_y = 0.0f;
ball.direction_x = (float)rand() / (float)RAND_MAX;
ball.direction_y = (float)rand() / (float)RAND_MAX;
ball.speed = 0.05f;
std::cout << "Right player wins!\n";
}
// left wins
else if (ball.position_x + 0.1f >= paddle_right.right)
{
game_started = false;
ball_matrix.Translate(-ball.position_x, -ball.position_y, 0.0f);
ball.position_x = 0.0f;
ball.position_y = 0.0f;
ball.direction_x = (float)rand() / (float)RAND_MAX;
ball.direction_y = (float)rand() / (float)RAND_MAX;
ball.speed = 0.05f;
std::cout << "Left player wins!\n";
}
// hits top or bottom of screen
else if (ball.position_y + 0.1f >= 2.0f || ball.position_y - 0.1f <= -2.0f)
{
ball.direction_y *= -1;
ball.speed += ball.acceleration;
ball.move();
ball_matrix.Translate(ball.speed * ball.direction_x, ball.speed * ball.direction_y, 0.0f);
}
// hits a paddle
else if ((ball.position_x - 0.1f <= paddle_left.right && ball.position_y - 0.1f <= paddle_left.top && ball.position_y + 0.1f >= paddle_left.bottom) ||
(ball.position_x + 0.1f >= paddle_right.left && ball.position_y - 0.1f <= paddle_right.top && ball.position_y + 0.1f >= paddle_right.bottom))
{
ball.direction_x *= -1;
ball.speed += ball.acceleration;
ball.move();
ball_matrix.Translate((ball.speed * ball.direction_x), (ball.speed * ball.direction_y), 0.0f);
}
// general movement
else
{
ball.move();
ball_matrix.Translate((ball.speed * ball.direction_x), (ball.speed * ball.direction_y), 0.0f);
}
}
SDL_GL_SwapWindow(displayWindow);
}
SDL_Quit();
return 0;
}
void Window::Present()
{
SDL_GL_SwapWindow( m_pWindow );
}
void Renderer::swapBuffer()
{
assert(m_window);
SDL_GL_SwapWindow(m_window);
}
