void
HaloRefImage::copy_to_scratch()
{
check_resize();
assert(_scratch_tex &&
_scratch_tex->image().dims() == Point2i(VIEW::cur_size()));
glPushAttrib(GL_ENABLE_BIT);
// Specify texture
_scratch_tex->apply_texture(); // GL_ENABLE_BIT
glReadBuffer(GL_BACK);
// Copies the frame buffer into a texture in gpu texture memory.
glCopyTexImage2D(
GL_TEXTURE_2D, // The target to which the image data will be changed.
0, // Level of detail, 0 is base detail
GL_RGBA, // internal format
0, // x-coord of lower left corner of the window
0, // y-coord of lower left corner of the window
_width, // texture width
_height, // texture height
0); // border size, must be 0 or 1
glPopAttrib();
}
int main(void)
{
logOpen();
initXWindows();
init_opengl();
Game game;
init(&game);
srand(time(NULL));
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
int done=0;
while (!done) {
while (XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
check_mouse(&e);
done = check_keys(&e);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while (physicsCountdown >= physicsRate) {
physics(&game);
physicsCountdown -= physicsRate;
}
render(&game);
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
logClose();
return 0;
}
void Player_ControlsGUI::set_screen_resize(int width_value, int height_value)
{
// now we fool our selves that we could own large tvs
video_area.set_size_request(width_value, height_value);
resize(1,1);
check_resize();
}
int main(void)
{
logOpen();
initXWindows();
init_opengl();
init();
init_sounds();
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
while(!done) {
while(XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
check_mouse(&e);
check_keys(&e);
}
//
//Below is a process to apply physics at a consistent rate.
//1. Get the time right now.
clock_gettime(CLOCK_REALTIME, &timeCurrent);
//2. How long since we were here last?
timeSpan = timeDiff(&timeStart, &timeCurrent);
//3. Save the current time as our new starting time.
timeCopy(&timeStart, &timeCurrent);
//4. Add time-span to our countdown amount.
physicsCountdown += timeSpan;
//5. Has countdown gone beyond our physics rate?
// if yes,
// In a loop...
// Apply physics
// Reducing countdown by physics-rate.
// Break when countdown < physics-rate.
// if no,
// Apply no physics this frame.
while(physicsCountdown >= physicsRate) {
//6. Apply physics
physics();
//7. Reduce the countdown by our physics-rate
physicsCountdown -= physicsRate;
}
//Always render every frame.
render();
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
#ifdef USE_SOUND
fmod_cleanup();
#endif //USE_SOUND
logClose();
return 0;
}
void
HaloRefImage::copy_to_tex_aux()
{
check_resize();
assert(_texture && _texture->image().dims() == Point2i(VIEW::cur_size()));
glPushAttrib(GL_ENABLE_BIT);
// Specify texture
_texture->apply_texture(); // GL_ENABLE_BIT
if (use_fbos) {
//copy contents of the frame buffer to output texture
glBindFramebuffer(GL_READ_FRAMEBUFFER, _fbo);
// Copies the frame buffer into a texture in gpu texture memory.
glCopyTexImage2D(
GL_TEXTURE_2D, // The target to which the image data will be changed.
0, // Level of detail, 0 is base detail
GL_RGBA, // internal format
0, // x-coord of lower left corner of the window
0, // y-coord of lower left corner of the window
_width, // texture width
_height, // texture height
0); // border size, must be 0 or 1
glBindFramebuffer(GL_FRAMEBUFFER, 0);
} else {
//copy contents of the aux0 buffer to output texture
glReadBuffer(GL_AUX0);
// Copies the frame buffer into a texture in gpu texture memory.
glCopyTexImage2D(
GL_TEXTURE_2D, // The target to which the image data will be changed.
0, // Level of detail, 0 is base detail
GL_RGBA, // internal format
0, // x-coord of lower left corner of the window
0, // y-coord of lower left corner of the window
_width, // texture width
_height, // texture height
0); // border size, must be 0 or 1
}
glPopAttrib();
}
int main(void)
{
int done=0;
srand(time(NULL));
initXWindows();
init_opengl();
init_sounds();
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
//declare game object
Game game;
fmod_playsound(1);
//start animation
while(!done) {
while(XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
check_mouse(&e, &game);
done = check_keys(&e, &game);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
movementCountdown += timeSpan;
while(movementCountdown >= movementRate)
{
movement(&game);
movementCountdown -= movementRate;
}
render(&game);
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
#ifdef USE_SOUND
fmod_cleanup();
#endif //USE_SOUND
return 0;
}
int main(void)
{
int done=0;
srand(time(NULL));
initXWindows();
init_opengl();
//declare game object
Game game;
game.n=0;
// used to check if jumped, already in the air
game.space = false; // deny jumping til collision on floor
//declare a box shape
game.box.width = BOX_WIDTH;
game.box.height = BOX_HEIGHT;
game.box.center.x = 20;//120 + 5*65;
game.box.center.y = 10;//500 - 5*60;
game.box.velocity.y = 0;
game.box.velocity.x = 0;
//start animation
while(!done) {
while(XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_mouse(&e, &game);
check_resize(&e);
done = check_keys(&e, &game);
}
movement(&game);
render(&game);
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
return 0;
}
int main(void)
{
logOpen();
initXWindows();
init_opengl();
init();
//buttonsInit();------------------------------------------------------------------
init_sounds();
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
while(!done) {
while(XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
check_mouse(&e);
GOcheck_mouse(&e);
check_keys(&e);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while(physicsCountdown >= physicsRate) {
physics();
physicsCountdown -= physicsRate;
}
render();
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
#ifdef USE_SOUND
fmod_cleanup();
#endif //USE_SOUND
logClose();
return 0;
}
int main(void)
{
int done=0;
srand(time(NULL));
initXWindows();
Game game;
DefineRagdoll(&game);
init_opengl(&game);
create_sounds();
play();
//declare game object
init_keys();
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
//start animation
while(!done) {
while(XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_mouse(&e, &game);
check_resize(&game, &e);
done = check_keys(&e);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while(physicsCountdown >= physicsRate) {
movement(&game);
physicsCountdown -= physicsRate;
}
render(&game);
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
return 0;
}
int main(void)
{
initXWindows();
srand(time(NULL));
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
init_opengl();
init_ship();
//Do this to allow fonts
glEnable(GL_TEXTURE_2D);
initialize_fonts();
init_textures();
while(!done) {
while(XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
check_mouse(&e);
check_keys(&e);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while (physicsCountdown >= physicsRate) {
physics();
physicsCountdown -= physicsRate;
render();
}
//physics();
//render();
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
return 0;
}
int main(int argc, char *argv[])
{
if(argc > 1) {
if(argv[1] != NULL) {
beginTesting();
}
return 0;
}
logOpen();
initXWindows();
init_opengl();
Game game;
init(&game);
srand(time(NULL));
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
hud = new Hud(xres ,yres);
if (TEST_Hud){
hud->testHUDAll();
return 0;
}
//DEFUALT IS LEVEL 1 SELECTED:
selected_screen = LEFT;
level =1;
//--------------
is_gameover = false;
high_score = 0;
gameStarted = false;
lastPaddleHit = 'N';//'N' means no paddle hit
bombBegin = time(NULL);
bombRandom = random(7);
beginSmallLeftPaddle = time(NULL);
smallLeftPaddleTime = 7;
beginSmallRightPaddle = time(NULL);
smallRightPaddleTime = 7;
hud->setAI(false);//DEFAULT: player2 is human
ball_saved_X_velocity = 8.0f * cos(30);
ball_saved_Y_velocity = 8.0f * sin(90);
obstacle_saved_Y_velocity = -5.0;
int min;
if (xres<yres){
min=xres;
}
else{
min=yres;
}
bomb_radius = ((int)(3*min)/10);
//MAIN MENU LOOP
while(intro != 0) {
while (XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
intro = check_keys(&e, &game);
}
render(&game);
glXSwapBuffers(dpy, win);
}
//BEGIN MAIN GAME LOOP
int done=0;
while (!done) {
while (XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_resize(&e);
done = check_keys(&e, &game);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while (physicsCountdown >= physicsRate) {
physics(&game);
physicsCountdown -= physicsRate;
}
render(&game);
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
logClose();
return 0;
}
void
HaloRefImage::update()
{
// render the scene and read pixels to main memory
// and/or texture memory
if (!need_update())
return;
static bool debug = Config::get_var_bool("DEBUG_HALO_UPDATE",false);
err_adv(debug, "HaloRefImage::update: updating...");
check_resize();
glPushAttrib(
GL_LINE_BIT |
GL_DEPTH_BUFFER_BIT |
GL_ENABLE_BIT |
GL_LIGHTING_BIT |
GL_VIEWPORT | // XXX - not needed
GL_COLOR_BUFFER_BIT | // XXX - not needed
GL_TEXTURE_BIT // XXX - not needed
);
// XXX - remove this:
assert(_view && _view == VIEW::peek());
// set up lights
_view->setup_lights();
// set default state
// XXX - check
glLineWidth(1.0); // GL_LINE_BIT
glDepthMask(GL_TRUE); // GL_DEPTH_BUFFER_BIT
glDepthFunc(GL_LESS); // GL_DEPTH_BUFFER_BIT
glEnable(GL_DEPTH_TEST); // GL_DEPTH_BUFFER_BIT
glDisable(GL_NORMALIZE); // GL_ENABLE_BIT
glDisable(GL_BLEND); // GL_ENABLE_BIT
glEnable(GL_CULL_FACE); // GL_ENABLE_BIT
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL); // GL_ENABLE_BIT
glShadeModel(GL_SMOOTH); // GL_LIGHTING_BIT
// set viewport to ref image size:
glViewport(0,0,_width,_height); // GL_VIEWPORT_BIT
draw_objects(_view->drawn());
// copy image to main memory or texture memory
// (or both) as requested:
if (_update_main_mem) {
if (use_fbos)
glBindFramebuffer(GL_READ_FRAMEBUFFER, _fbo);
else
glReadBuffer(GL_AUX0); //because the image is constructed in aux0
copy_to_ram();
if (use_fbos)
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
else
glReadBuffer(GL_BACK);
}
if (_update_tex_mem)
copy_to_tex_aux(); //copies from aux0
// clear update flags until next update request is made:
_update_main_mem = _update_tex_mem = false;
glPopAttrib();
// restore viewport to window size:
int w, h;
_view->get_size(w,h);
glViewport(0,0,w,h);
}
static int post_sleep_hook (pingobj_t *ping) /* {{{ */
{
return (check_resize (ping));
} /* }}} int pre_sleep_hook */
void tasklist_window() /* {{{ */
{
/* ncurses main function */
int c;
task *cur;
char *uuid = NULL;
/* get field lengths */
cfg.fieldlengths.project = max_project_length();
cfg.fieldlengths.date = DATELENGTH;
/* create windows */
rows = LINES;
cols = COLS;
tnc_fprintf(logfp, LOG_DEBUG_VERBOSE, "rows: %d, columns: %d", rows, cols);
header = newwin(1, cols, 0, 0);
tasklist = newwin(rows-2, cols, 1, 0);
statusbar = newwin(1, cols, rows-1, 0);
tnc_fprintf(logfp, LOG_DEBUG_VERBOSE, "ncurses windows: h:%p, t:%p, s:%p (%d,%d)", header, tasklist, statusbar, rows, cols);
if (statusbar==NULL || tasklist==NULL || header==NULL)
{
tnc_fprintf(logfp, LOG_ERROR, "window creation failed (rows:%d, cols:%d)", rows, cols);
ncurses_end(-1);
}
/* set curses settings */
set_curses_mode(NCURSES_MODE_STD);
/* print task list */
check_screen_size();
cfg.fieldlengths.description = COLS-cfg.fieldlengths.project-1-cfg.fieldlengths.date;
task_count();
print_header();
tasklist_print_task_list();
/* main loop */
while (1)
{
/* set variables for determining actions */
done = false;
redraw = false;
reload = false;
/* check for an empty task list */
if (head == NULL)
{
if (strcmp(active_filter,"") == 0){
tnc_fprintf(logfp, LOG_ERROR, "it appears that your task list is empty. %s does not yet support empty task lists.", PROGNAME);
ncurses_end(-1);
}
active_filter = strdup("");
reload = true;
}
/* get the screen size */
rows = LINES;
cols = COLS;
/* check for a screen thats too small */
check_screen_size();
/* check for size changes */
check_resize();
/* apply staged window updates */
doupdate();
/* get a character */
c = wgetch(statusbar);
/* handle the character */
handle_keypress(c, MODE_TASKLIST);
/* exit */
if (done)
break;
/* reload task list */
if (reload)
{
cur = get_task_by_position(selline);
if (cur != NULL)
uuid = strdup(cur->uuid);
wipe_tasklist();
reload_tasks();
task_count();
redraw = true;
if (cfg.follow_task)
set_position_by_uuid(uuid);
check_free(uuid);
uuid = NULL;
tasklist_check_curs_pos();
}
/* redraw all windows */
if (redraw)
{
cfg.fieldlengths.project = max_project_length();
cfg.fieldlengths.description = cols-cfg.fieldlengths.project-1-cfg.fieldlengths.date;
print_header();
tasklist_print_task_list();
tasklist_check_curs_pos();
touchwin(tasklist);
touchwin(header);
touchwin(statusbar);
wnoutrefresh(tasklist);
wnoutrefresh(header);
wnoutrefresh(statusbar);
doupdate();
}
statusbar_timeout();
}
} /* }}} */
void PlayGame()
{
bool menuToggle = true;
Game game;
game.setResolution(window_width, window_height);
if(window_height > 1080)
{
//game.gravity = 9;
MAX_VELOCITY = 12;
INITIAL_VELOCITY = 7;
}
srand(time(NULL));
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
clock_gettime(CLOCK_REALTIME, &start);
while(game.run)
{
game = Game(); //reinitializes upon replay
if(TOGGLE_SOUND) //Sound switch so that the background music doesnt get recalled after the initial call
{ //otherwise they loop over each other and it sounds bad, plus it created a memory leak
Buffer = alutCreateBufferFromFile("./Sounds/music.wav");
playBackgroundSound();
TOGGLE_SOUND = false;
}
gutsToggle = true;
bloodToggle = true; //Reset switches to clear the prev game information. This includes the score and blood particles
TOGGLE_PAUSE = true; //basically reinitializing anything that didnt get reinitialized in the game = Game();
numblood = 0;
SCORE = 0;
game.setMissiles = false;
while(STATE == MAIN_MENU && game.run)
{
XEvent menu;
while(XPending(dpy))
{
XNextEvent(dpy, &menu);
check_keys(&menu, &game); //Ahhh STATES, made this far easier to control.
check_mouse(&menu, &game); //Each while(STATE == X) loop renders a background and checks for input
game.setResolution(window_width, window_height); //and the input functions all have checks to see what STATE is currently running
} //and only allows proper input
setMenuBackground();
glXSwapBuffers(dpy, win);
}
while(STATE == HOW_TO && game.run && menuToggle)
{
XEvent howTo;
while(XPending(dpy))
{
XNextEvent(dpy, &howTo);
check_keys(&howTo, &game);
check_mouse(&howTo, &game);
game.setResolution(window_width, window_height);
}
setHowToBackground();
glXSwapBuffers(dpy, win);
}
if(menuToggle) //No one wants to see the how to menu over and over and over again.
menuToggle = false;
STATE = RUN_GAME; //gotta have this here, otherwise if the player clicks the green button after one game the STATE will be HOW_TO but it cant access it
game.setResolution(window_width, window_height);
game.setPos(window_width/2, window_height + game.player.height); //this is when playforms are created and the players position is set to the top
game.setGravity(GRAVITY); //if this is called beforehand it wont take proper screen size into consideration
makePlatform(5,&game);
while(STATE == RUN_GAME && game.run)
{
// check input
XEvent e;
while(XPending(dpy))
{
if(TOGGLE_PAUSE)
{
TOGGLE_PAUSE = false;
pausegame = false;
}
XNextEvent(dpy, &e);
check_keys(&e, &game);
check_resize(&e);
game.setResolution(window_width, window_height);
}
if(game.guts && numblood <= 50)
{
STATE = DEATH; //changes the game state to the death screen once the person has died and the blood particles are off the screen
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
if(!pausegame && numblood < 1)
{
SCORE++; //iterates the score every loop that the game is not paused and the player is not dead
}
physicsCountdown += timeSpan;
// check for collisions, move player
while(physicsCountdown >= physicsRate) {
physics(&game);
physicsCountdown -= physicsRate;
}
// used for sprite timing DON'T TOUCH
if(frames > 2)
frames = 0;
frames++;
// FPS COUNTER/RESET
if(fps > 100)
{
clock_gettime(CLOCK_REALTIME, &start);
fps = 0;
}
fps++;
render(&game);
glXSwapBuffers(dpy, win);
}
while(STATE == DEATH && game.run)
{
XEvent death;
while(XPending(dpy))
{
XNextEvent(dpy, &death);
check_keys(&death, &game);
check_mouse(&death, &game);
game.setResolution(window_width, window_height);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while(physicsCountdown >= physicsRate)
{
physics(&game);
physicsCountdown -= physicsRate; //this will keep the game rendering so that the user can see the players full body explosion
}
render(&game);
glXSwapBuffers(dpy, win);
}
}
return;
}
