void camera_render_stereo(Camera* c) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//left
camera_look(c);
glColorMask(1, 0, 0, 0);// bloque Green et Blue et Transparence
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(
0,0,0,//pos
1,0,0,//pt visé
0,0,1);//up
glRotated(c->rho,1,0,0);
glRotated(c->theta, 0.0, 1.0, 0.0);
glRotated(c->phi, 0.0, 0.0, 1.0);
glTranslated(c->x, c->y, c->z);
camera_ApplyLeftFrustum(c);
game_render(c->game);
//clear buffer
glClear(GL_DEPTH_BUFFER_BIT) ;
//right
camera_look(c);
glColorMask(0, 1, 1, 0);//bloque Red et Transparence
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(
0,0,0,//pos
1,0,0,//pt visé
0,0,1);//up
glRotated(c->rho,1,0,0);
glRotated(c->theta, 0.0, 1.0, 0.0);
glRotated(c->phi, 0.0, 0.0, 1.0);
glTranslated(c->x, c->y, c->z);
camera_ApplyRightFrustum(c);
game_render(c->game);
//
glColorMask(1, 1, 1, 1);
glClear(GL_DEPTH_BUFFER_BIT);
camera_HUD(c);
//update screen
// glFlush();
// SDL_GL_SwapBuffers();
}
void setup_render(SDL_Surface *buffer, camera *camera, PLAYERS *players, float interpolation) {
game_render(buffer, camera, players, interpolation);
SDL_BlitSurface(instructions, NULL, buffer, &instruction_rect);
if(paused)
paused_state.render(buffer, camera, players, interpolation);
}
void render(void)
{
al_hold_bitmap_drawing(true);
switch(state)
{
case STATE_LOGO:
{
logo_render();
break;
}
case STATE_INTRO:
{
cinema_render(cinema);
break;
}
case STATE_TITLE:
{
title_render();
break;
}
case STATE_GAME:
{
game_render();
break;
}
case STATE_ENDING:
{
cinema_render(ending_cinema);
break;
}
}
al_hold_bitmap_drawing(false);
}
void camera_render(Camera* c) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// // glFramebufferTexture2D (GL_FRAMEBUFFER, GL_DEPTH_COMPONENT, GL_TEXTURE_2D, game->depth_tex_id, 0);
// glUseProgram(game->shader_id_dummy);
// glFramebufferTexture2D(game->frame_buffer_id,GL_COLOR_ATTACHMENT0,GL_TEXTURE_2D,game->color_tex_id,0);
// // glFramebufferTexture2D(game->frame_buffer_id,GL_DEPTH_ATTACHMENT,GL_TEXTURE_2D,game->depth_tex_id,0);
// glBindFramebuffer(GL_FRAMEBUFFER,game->frame_buffer_id);
// camera_HUD(c);
double time_=SDL_GetTicks()*0.001;
camera_look(c);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(
0,0,0,//pos
1,0,0,//pt visé
0,0,1);//up
glRotated(c->rho,1,0,0);
glRotated(c->theta, 0.0, 1.0, 0.0);
glRotated(c->phi, 0.0, 0.0, 1.0);
// glTranslated(c->x, c->y + 10*cos(time_), c->z + 0.5 * 10*sin(time_));
glTranslated(c->x, c->y + c->fake_y, c->z + c->fake_z);
game_render(c->game);
// c->game->render(c->game);
glClear(GL_DEPTH_BUFFER_BIT);
camera_HUD(c);
// glFlush();
// SDL_GL_SwapBuffers();
// // SDL_Surface * image = IMG_Load("screenshot/01.png");
// // glTexImage2D (GL_TEXTURE_2D, 0, 3,
// // image->w, image->h, 0,
// // GL_RGB, GL_UNSIGNED_BYTE, image->pixels);
// glBindFramebuffer(GL_FRAMEBUFFER,0);
// glUseProgram(game->shader_id_dof);
// glActiveTexture (GL_TEXTURE0);
// glBindTexture (GL_TEXTURE_2D, game->color_tex_id);
// // glBindTexture (GL_TEXTURE_2D, game->depth_tex_id);
// glUniform1i(game->shader_dof_color_id,GL_TEXTURE0);
// glBegin( GL_QUADS );
// glVertex2d(-1,-1);
// glVertex2d(-1, 1);
// glVertex2d( 1, 1);
// glVertex2d( 1,-1);
// glEnd();
}
int main(void)
{
// initialize stdlib things
signal(SIGINT, _finish);
srand(time(NULL));
atexit(_exit_cb);
// initialize ncurses
initscr();
keypad(stdscr, true);
nonl();
cbreak(); // TODO use raw() and handle CTRL inputs manually (no signal)
noecho();
curs_set(false);
nodelay(stdscr, true);
// TODO support no color mode (just investigate if attron works)
if (!has_colors()) {
FPRINTF(stderr, "ncurses colors not supported\n");
exit(EXIT_FAILURE);
}
start_color();
init_pair(COLOR__GRASS, COLOR_WHITE, COLOR_GREEN);
init_pair(COLOR__HP_GOOD, COLOR_GREEN, COLOR_GREEN);
init_pair(COLOR__HP_WARNING, COLOR_YELLOW, COLOR_YELLOW);
init_pair(COLOR__HP_DANGER, COLOR_RED, COLOR_RED);
names_init();
struct game game;
audio_init(&game.audio);
game_init(&game);
// TODO clean this up
struct map_chunk chunk;
map_chunk_init(&chunk);
game.chunk = &chunk;
// TODO improve game loop
// - "rendering" and update tick do not need to have same rate
// - fix input triggering after letting go, etc.
for (;;) {
int c = getch();
game_handle_input(&game, c);
game_tick(&game);
game_render(&game);
++game.frame;
usleep(100000);
}
// clean up audio
audio_destroy(&game.audio);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
game_init();
while (!quit_flag) {
game_event(&event);
game_loop();
game_render();
}
game_destroy();
return EXIT_SUCCESS;
}
// Engine ----------------------------------------------------------------------
// -----------------------------------------------------------------------------
int engine_create(const int width, const int height, const int scale, const int fps) {
engine = (struct Engine*)malloc(sizeof(struct Engine));
if (!engine_init(width, height, scale, fps)) {
free(engine);
return 1;
}
game_init();
// Main Loop, o'rly?
int render_start = 0, render_diff = 0, render_wait = 0;
int fps_count = 0, fps_time = 0;
while (engine->running) {
render_start = SDL_GetTicks();
engine_events();
if (key_pressed(SDLK_p)) {
engine_pause(!engine->paused);
}
if (!engine->paused) {
game_update();
}
engine_clear_keys();
engine_clear_mouse();
game_render(engine->screen);
SDL_Flip(engine->screen->bg);
// Limit FPS
render_diff = SDL_GetTicks() - render_start;
if (render_diff > 0) {
render_wait = engine->fps_wait - render_diff;
if (render_wait > 0) {
SDL_Delay(render_wait);
}
if (!engine->paused) {
engine->time += SDL_GetTicks() - render_start;
}
}
// Count FPS
if (!engine->paused) {
fps_count++;
if (fps_count >= 10) {
engine->fps_current = 1000 / ((engine->time - fps_time) / fps_count);
fps_count = 0;
fps_time = engine->time;
}
}
}
// Cleanup
game_quit();
engine_cleanup();
return 0;
}
int main( int argc, char *argv[] )
{
Uint32 FPS_MAX = 1000 / 63; // 60 fps
game_init();
while ( quit_flag == false ) {
game_event( &event );
game_loop();
game_render();
SDL_Delay( FPS_MAX );
}
game_destroy();
return EXIT_SUCCESS;
}
/* When widget is exposed it's contents are redrawn. */
gint draw(GtkWidget *widget, GdkEventExpose *event)
{
/* Draw only last expose. */
if (event->count > 0)
return TRUE;
if (gtk_gl_area_make_current(GTK_GL_AREA(widget)))
game_render();
/* Swap backbuffer to front */
gtk_gl_area_swapbuffers(GTK_GL_AREA(widget));
return TRUE;
}
void retro_run(void)
{
key_state_t ks;
input_poll_cb();
ks.up = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP);
ks.right = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT);
ks.down = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN);
ks.left = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT);
ks.start = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START);
ks.select = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT);
game_update(frame_time, &ks);
game_render();
}
int dgreed_main(int argc, const char** argv) {
params_init(argc, argv);
rand_init(time(NULL));
layouts_init();
layouts_set("dvorak");
bool fullscreen = true;
if(params_find("-windowed") != ~0)
fullscreen = false;
video_init_ex(SCREEN_WIDTH, SCREEN_HEIGHT,
SCREEN_WIDTH, SCREEN_HEIGHT, "KeyMingler", fullscreen);
font = font_load(FONT_FILE);
float text_width = font_width(font, LOADING_TEXT);
float text_height = font_height(font);
Vector2 pos = vec2((SCREEN_WIDTH - text_width) / 2.0f,
(SCREEN_HEIGHT - text_height) / 2.0f);
font_draw(font, LOADING_TEXT, 0, &pos, COLOR_WHITE);
video_present();
system_update();
game_init();
sounds_init();
music = sound_load_stream(MUSIC_FILE);
sound_play(music);
while(system_update()) {
game_update();
game_render();
video_present();
sound_update();
if(key_up(KEY_QUIT))
break;
}
font_free(font);
sound_free(music);
sounds_close();
game_close();
video_close();
layouts_close();
return 0;
}
void pause_render() {
game_render();
d_text_surface_draw(pause.title);
}
//------------------------------------------------------------
// La función principal main()
//------------------------------------------------------------
int main(int argc, char **argv)
{
// Iniciar Allegro (y añadidos)
al_init();
al_init_image_addon();
al_init_primitives_addon();
// Instalar el mouse, teclado, etc.
al_install_keyboard();
al_install_mouse();
if (FULLSCREEN)
al_set_new_display_flags(ALLEGRO_FULLSCREEN);
// Crear el "display"
display = al_create_display(SCREEN_W, SCREEN_H);
if (!SHOW_CURSOR)
al_hide_mouse_cursor(display);
// Poner el título de la ventana
al_set_window_title(display, WINDOW_TITLE);
// Creamos el timer (controlador de FPS)
timer = al_create_timer(1.0 / FRAMERATE);
// Creamos la 'pila' de eventos
event_queue = al_create_event_queue();
// Preparamos el juego
game_setup();
// Los eventos que usaremos
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_start_timer(timer);
// Si esta variable se pone a 0, el juego terminará de inmediato
game_is_running = 1;
ALLEGRO_EVENT event;
// El 'loop' principal del juego
while (game_is_running)
{
al_wait_for_event(event_queue, &event);
// Si el botón para cerrar fue presionado...
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
// Actualizamos las teclas
if (event.type == ALLEGRO_EVENT_KEY_DOWN)
{
// Al presionar <Esc> el juego terminará
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
game_is_running = 0;
if (event.keyboard.keycode == ALLEGRO_KEY_LEFT)
key[KEY_LEFT] = 1;
if (event.keyboard.keycode == ALLEGRO_KEY_RIGHT)
key[KEY_RIGHT] = 1;
if (event.keyboard.keycode == ALLEGRO_KEY_UP)
key[KEY_UP] = 1;
if (event.keyboard.keycode == ALLEGRO_KEY_DOWN)
key[KEY_DOWN] = 1;
if (event.keyboard.keycode == ALLEGRO_KEY_X)
key[KEY_X] = 1;
}
// Actualizamos las teclas
if (event.type == ALLEGRO_EVENT_KEY_UP)
{
if (event.keyboard.keycode == ALLEGRO_KEY_LEFT)
key[KEY_LEFT] = 0;
if (event.keyboard.keycode == ALLEGRO_KEY_RIGHT)
key[KEY_RIGHT] = 0;
if (event.keyboard.keycode == ALLEGRO_KEY_UP)
key[KEY_UP] = 0;
if (event.keyboard.keycode == ALLEGRO_KEY_DOWN)
key[KEY_DOWN] = 0;
if (event.keyboard.keycode == ALLEGRO_KEY_X)
key[KEY_X] = 0;
}
if (event.type == ALLEGRO_EVENT_TIMER)
{
game_update();
redraw = 1;
}
if (redraw)
{
redraw = 0;
al_clear_to_color(al_map_rgb(0, 0, 0));
game_render();
al_flip_display();
}
}
al_destroy_display(display);
al_destroy_timer(timer);
al_destroy_event_queue(event_queue);
game_shutdown();
return 0;
}
int main()
{
if( SDL_Init( SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_JOYSTICK ) < 0 )
{
SYS_BREAK( "SDL_Init failed!\n" );
}
SDL_SetVideoMode( ScreenWidth, ScreenHeight, 0u, SDL_OPENGL /*| SDL_FULLSCREEN */ );
#ifndef FONT_EDITOR
SDL_ShowCursor( SDL_DISABLE );
#endif
SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 1 );
SDL_AudioSpec audioSpec;
audioSpec.freq = SoundSampleRate;
audioSpec.format = AUDIO_S16SYS;
audioSpec.channels = SoundChannelCount;
audioSpec.silence = 0;
audioSpec.samples = SoundBufferSampleCount;
audioSpec.size = 0;
audioSpec.callback = soundCallback;
audioSpec.userdata = s_soundBuffer;
SDL_OpenAudio( &audioSpec, NULL );
game_init();
SDL_PauseAudio( 0 );
uint32 lastTime = SDL_GetTicks();
uint32 buttonMask = 0u;
uint32 joystickButtonMask = 0u;
#ifndef SYS_BUILD_MASTER
uint32 lastTimingTime = lastTime;
uint32 timingFrameCount = 0u;
#endif
SDL_JoystickEventState( SDL_ENABLE );
SDL_Joystick* pJoystick0 = SDL_JoystickOpen( 0 );
SYS_USE_ARGUMENT(pJoystick0);
int16 joystickAxis0 = 0;
int16 joystickAxis1 = 0;
float2 mousePos;
float2_set(&mousePos, 0.0f, 0.0f);
int leftMouseDown=0;
int leftMousePressed=0;
int rightMouseDown=0;
int rightMousePressed=0u;
int quit = 0;
do
{
uint32 currentTime = SDL_GetTicks();
const float timeStep = ( float )( currentTime - lastTime ) / 1000.0f;
lastTime = currentTime;
#ifndef SYS_BUILD_MASTER
if( currentTime - lastTimingTime > 500u )
{
const float timingTimeSpan = ( float )( currentTime - lastTimingTime ) / 1000.0f;
const float currentFps = ( float )( timingFrameCount ) / timingTimeSpan;
char windowTitle[ 100u ];
sprintf( windowTitle, "fps=%f cb=%i", currentFps, s_callbackCount );
SDL_WM_SetCaption( windowTitle, 0 );
lastTimingTime = currentTime;
timingFrameCount = 0u;
}
#endif
// get local user input:
SDL_Event event;
while( SDL_PollEvent( &event ) )
{
switch( event.type )
{
case SDL_JOYAXISMOTION:
if( event.jaxis.axis == 0u )
{
joystickAxis0 = event.jaxis.value;
}
else if( event.jaxis.axis == 1u )
{
joystickAxis1 = event.jaxis.value;
}
break;
case SDL_JOYBUTTONDOWN:
if( event.jbutton.button == 0 )
{
updateButtonMask( &joystickButtonMask, ButtonMask_PlaceBomb, 1 );
}
break;
case SDL_JOYBUTTONUP:
if( event.jbutton.button == 0 )
{
updateButtonMask( &joystickButtonMask, ButtonMask_PlaceBomb, 0 );
}
break;
case SDL_MOUSEMOTION:
float2_set(&mousePos, (float)event.motion.x, (float)event.motion.y);
break;
case SDL_MOUSEBUTTONDOWN:
SYS_TRACE_DEBUG("down=%i\n", event.button.button);
if( event.button.button == 1 )
{
leftMouseDown = 1;
leftMousePressed = 1;
}
else if( event.button.button == 3)
{
rightMouseDown = 1;
rightMousePressed = 1;
}
break;
case SDL_MOUSEBUTTONUP:
if(event.button.button == 1)
{
leftMouseDown = 0;
}
else if(event.button.button == 3)
{
rightMouseDown = 0;
}
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
{
const int ctrlPressed = ( event.key.keysym.mod & KMOD_CTRL ) != 0;
switch( event.key.keysym.sym )
{
case SDLK_ESCAPE:
quit = 1;
break;
case SDLK_LEFT:
updateButtonMask( &buttonMask, ctrlPressed ? ButtonMask_CtrlLeft : ButtonMask_Left, event.type == SDL_KEYDOWN );
break;
case SDLK_RIGHT:
updateButtonMask( &buttonMask, ctrlPressed ? ButtonMask_CtrlRight : ButtonMask_Right, event.type == SDL_KEYDOWN );
break;
case SDLK_UP:
updateButtonMask( &buttonMask, ctrlPressed ? ButtonMask_CtrlUp : ButtonMask_Up, event.type == SDL_KEYDOWN );
break;
case SDLK_DOWN:
updateButtonMask( &buttonMask, ctrlPressed ? ButtonMask_CtrlDown : ButtonMask_Down, event.type == SDL_KEYDOWN );
break;
case SDLK_SPACE:
updateButtonMask( &buttonMask, ButtonMask_PlaceBomb, event.type == SDL_KEYDOWN );
break;
case SDLK_c:
updateButtonMask( &buttonMask, ButtonMask_Client, event.type == SDL_KEYDOWN );
break;
case SDLK_s:
updateButtonMask( &buttonMask, ButtonMask_Server, event.type == SDL_KEYDOWN );
break;
case SDLK_l:
updateButtonMask( &buttonMask, ButtonMask_Leave, event.type == SDL_KEYDOWN );
break;
default:
break;
}
}
break;
case SDL_QUIT:
quit = 1;
break;
}
}
updateButtonMaskFromJoystick( &joystickButtonMask, ButtonMask_Right, joystickAxis0, 16000 );
updateButtonMaskFromJoystick( &joystickButtonMask, ButtonMask_Left, -joystickAxis0, 16000 );
updateButtonMaskFromJoystick( &joystickButtonMask, ButtonMask_Down, joystickAxis1, 3200 );
updateButtonMaskFromJoystick( &joystickButtonMask, ButtonMask_Up, -joystickAxis1, 3200 );
#ifdef FONT_EDITOR
static uint currentChar = '0';
static uint dataChar = '\0';
static float2 charPoints[ 128u ];
static uint charPointCount = 0u;
static uint32 lastButtonMask = 0u;
static int currentPointIndex = -1;
static float2 oldMousePagePos;
const uint32 buttonPressMask = buttonMask & ~lastButtonMask;
lastButtonMask = buttonMask;
float2 mousePagePos;
mousePagePos.x=64.0f*mousePos.x/(float)ScreenWidth;
mousePagePos.y=36.0f+-36.0f*mousePos.y/(float)ScreenHeight;
if( buttonPressMask & ButtonMask_Right )
{
currentChar=font_getNextGlyphCharCode(currentChar,1);
}
if( buttonPressMask & ButtonMask_Left )
{
currentChar=font_getNextGlyphCharCode(currentChar,-1);
}
if( currentChar != dataChar )
{
if( dataChar != '\0' )
{
char filename[128u];
sprintf(filename,"./source/font/char_%i.h",dataChar);
SYS_TRACE_DEBUG("writing char to file '%s'\n", filename);
FILE* pFile=fopen(filename, "w");
if(pFile)
{
fprintf(pFile,"static const float2 s_points_%i[] =\n{\n",dataChar);
for( uint i=0u;i<charPointCount;++i)
{
fprintf(pFile,"\t{%ff,%ff},\n",charPoints[i].x,charPoints[i].y);
}
fprintf(pFile,"};\n\n");
fclose(pFile);
}
else
{
SYS_TRACE_ERROR("Could not open file '%s'\n", filename);
}
}
const FontGlyph* pGlyph=font_getGlyph((uint)currentChar);
if(pGlyph)
{
charPointCount = uint_min(SYS_COUNTOF(charPoints),pGlyph->pointCount);
memcpy(charPoints,pGlyph->pPoints,charPointCount*sizeof(float2));
dataChar = currentChar;
}
else
{
charPointCount = 0u;
}
currentPointIndex = -1;
}
if( dataChar && ( buttonPressMask & ButtonMask_Down ) )
{
// add a point:
if(charPointCount>0)
{
charPointCount--;
}
}
if( dataChar && ( buttonPressMask & ButtonMask_Up ) )
{
// add a point:
if(charPointCount<SYS_COUNTOF(charPoints))
{
float2_set(&charPoints[charPointCount],0.0f,0.0f);
charPointCount++;
}
}
if( renderer_isPageDone() )
{
// new page:
renderer_flipPage();
renderer_setPen( Pen_Font );
/* const float2 worldOffset = { 32.0f, 16.0f };
const float2 position = { 0.0f, 0.0f };*/
renderer_setVariance( 0.0f );
renderer_setTransform( 0 );
const float fontSize=3.0f;
float2 textPos;
float2_set(&textPos,32.0f,16.0f);
if( charPointCount > 0u )
{
float2x3 transform;
float2x2_identity(&transform.rot);
float2x2_scale1f(&transform.rot,&transform.rot,fontSize);
transform.pos=textPos;
renderer_setTransform( &transform );
renderer_addQuadraticStroke(charPoints,charPointCount);
transform.pos.x -= 10.0f;
renderer_setTransform( &transform );
renderer_addQuadraticStroke(charPoints,charPointCount);
}
// draw control points:
const float cpSize=0.5f;
int inRangePoint=-1;
for(uint i = 0u; i < charPointCount; ++i)
{
float2 pos;
float2_set(&pos,32.0f,16.0f);
float2_addScaled1f(&pos,&pos,&charPoints[i],fontSize);
const int inRange = float2_distance(&mousePagePos,&pos)<cpSize;
if( inRange && inRangePoint==-1)
{
inRangePoint=(int)i;
}
if(currentPointIndex==-1&&inRange&&leftMousePressed)
{
currentPointIndex=(int)i;
}
else if(currentPointIndex!=-1)
{
if(!leftMouseDown)
{
currentPointIndex=-1;
}
else if( currentPointIndex==(int)i )
{
// move cp to be under the mouse cursor:
float2 newCpPos;
float2_sub(&newCpPos,&mousePagePos,&textPos);
float2_scale1f(&charPoints[i],&newCpPos,1.0f/fontSize);
}
}
float3 color;
if((int)i==currentPointIndex)
{
float3_set(&color,0.2f,1.0f,0.2f);
}
else if(inRange)
{
float3_set(&color,0.5f,0.5f,0.2f);
}
else
{
float3_set(&color,0.8f,0.2f,0.2f);
}
renderer_drawCircle(&pos,cpSize,&color);
}
oldMousePagePos=mousePagePos;
leftMousePressed=0;
rightMousePressed=0;
float2_set(&textPos,5.0f,4.0f);
font_drawText(&textPos,1.0f,0.0f,"0123456789A" );
}
renderer_updatePage( timeStep );
FrameData frame;
//memset( &frame, 0u, sizeof( frame ) );
//frame.time = s_game.gameTime;
//frame.playerPos = s_game.player[ 0u ].position;
renderer_drawFrame( &frame );
#elif defined( TEST_RENDERER )
if( renderer_isPageDone() )
{
// new page:
renderer_flipPage();
/*float2 points[] =
{
{ -4.0f, 0.0f },
{ -4.0f, -4.0f },
{ 0.0f, -4.0f },
{ 4.0f, -4.0f },
{ 4.0f, 0.0f },
{ 4.0f, 4.0f },
{ 0.0f, 4.0f },
{ -4.0f, 4.0f },
{ -4.0f, 0.0f }
{ -0.2f, 1.0f }
};*/
renderer_setPen( Pen_DebugGreen );
const float2 worldOffset = { 32.0f, 16.0f };
const float2 position = { 0.0f, 0.0f };
float2x3 bombTransform;
float2x2_rotationY( &bombTransform.rot, 0.0f );
float2x2_scale1f( &bombTransform.rot, &bombTransform.rot, 1.0f );
float2_add( &bombTransform.pos, &position, &worldOffset );
renderer_setTransform( &bombTransform );
//renderer_addQuadraticStroke(&points[0u],&points[1u],&points[2u]);
//renderer_addQuadraticStroke(points,SYS_COUNTOF(points));
float2 textPos;
float2_set(&textPos,5.0f,4.0f);
font_drawText(&textPos,2.0f,0.0f,"P");
}
renderer_updatePage( timeStep );
FrameData frame;
//memset( &frame, 0u, sizeof( frame ) );
//frame.time = s_game.gameTime;
//frame.playerPos = s_game.player[ 0u ].position;
renderer_drawFrame( &frame );
#else
renderer_setVariance(0.0f);
GameInput gameInput;
memset( &gameInput, 0u, sizeof( gameInput ) );
gameInput.timeStep = timeStep;
gameInput.buttonMask = buttonMask | joystickButtonMask;
game_update( &gameInput );
game_render();
#endif
SDL_GL_SwapBuffers();
#ifndef SYS_BUILD_MASTER
timingFrameCount++;
#endif
}
while( !quit );
// :TODO: nicer fade out..
SDL_PauseAudio( 1 );
game_done();
}
int main(int argc, char *argv[]) {
if (!window_init()) {
return 1;
}
gameRunning = true;
SDL_Event sdlEvent;
u32 lastTickCount = 0;
g_entities = entityManager_new();
g_sprites = spriteMngr_new();
{
Entity *player = entity_new();
CTransform *tx = player->transform;
tx->position->x = 200;
tx->position->y = SCREEN_HEIGHT / 2;
CSpriteRenderer *sr =
(CSpriteRenderer *)entity_addComponent(player, C_SPRITE_RENDERER);
entity_addComponent(player, C_PLAYER_CONTROLLER);
sprite_setTexture(sr->sprite, "pship3_blue");
entityManager_add(g_entities, player);
}
entityManager_start(g_entities);
u32 secondCounter = 0;
u32 framesCounted = 0;
while (gameRunning) {
while(SDL_PollEvent(&sdlEvent) != 0) {
app_handle_event(sdlEvent);
}
u32 ticks = SDL_GetTicks();
u32 delta = ticks - lastTickCount;
f32 dt = delta / 1000.0f;
lastTickCount = ticks;
game_update(dt);
game_render();
++framesCounted;
secondCounter += delta;
if (secondCounter >= 1000) {
printf("FPS: %d\n", framesCounted);
secondCounter -= 1000;
framesCounted = 0;
}
}
window_destroy();
return 0;
}
