void run(bool* const quit_game)
{
vector<Str_and_clr> lines;
mk_info_lines(lines);
Menu_browser browser(6, 0);
render_menu(browser);
while (true)
{
const Menu_action action = menu_input_handling::get_action(browser);
switch (action)
{
case Menu_action::esc:
case Menu_action::space:
case Menu_action::selected_shift: {} break;
case Menu_action::browsed:
{
render_menu(browser);
} break;
case Menu_action::selected:
{
if (browser.is_at_idx(0))
{
run_info(lines);
render_menu(browser);
}
else if (browser.is_at_idx(1))
{
mk_memorial_file(lines);
}
else if (browser.is_at_idx(2))
{
high_score::run_high_score_screen();
render_menu(browser);
}
else if (browser.is_at_idx(3))
{
msg_log::display_history();
render_menu(browser);
}
else if (browser.is_at_idx(4))
{
return;
}
else if (browser.is_at_idx(5))
{
*quit_game = true;
return;
}
} break;
}
}
}
int main(void)
{
unsigned short matrix_n;
unsigned short input = 10000;
int default_value, row, column, value;
printf("========== UPPER TRIANGULAR MATRIX IMPLEMENTATION ==========\n");
printf("=== Input your matrix size (< %d): ", MAX_MATRIX_N);
scanf("%d", &matrix_n);
printf("=== Input your default value: ");
scanf("%d", &default_value);
matrix_t *matrix = make_upper_triangular(matrix_n, default_value);
render_menu();
while(input != 0)
{
printf("=== Choose an option: ");
scanf("%d", &input);
switch(input) {
case 1:
print_matrix(matrix);
break;
case 2:
printf("=== Input the <row> <column> <value>: ");
scanf("%d %d %d", &row, &column, &value);
matrix->set(matrix, row, column, value);
break;
case 3:
printf("=== Input the <row> <column>: ");
scanf("%d %d", &row, &column);
printf("=== Value is: %d\n", matrix->get(matrix, row, column));
break;
case 4:
printf("=== Number of non-default elements is: %d\n", upper_triangular_count_non_default_values(matrix));
break;
case 9:
render_menu();
break;
case 0:
break;
default:
printf("Wrong choice!\n");
break;
}
}
free(matrix);
return 0;
}
int main(void)
{
unsigned short preffered_stack_size;
unsigned short input = 10000;
unsigned int value;
printf("========== STATIC ARRAY STACK IMPLEMENTATION ==========\n");
printf("=== Input your prefered stack size (< %d): ", MAX_STACK);
scanf("%d", &preffered_stack_size);
stack_t *stack = stack_create(preffered_stack_size);
render_menu();
while(input != 0)
{
printf("=== Choose an option: ");
scanf("%d", &input);
switch(input) {
case 1:
printf("=== Value to be pushed: ");
scanf("%d", &value);
push(stack, value);
break;
case 2:
printf("=== Value: %d\n", pop(stack));
break;
case 3:
printf("=== Value %d\n", peek(stack));
break;
case 4:
printf("=== Stack usage: %d\n", memused(stack));
break;
case 5:
printf("=== Stack size: %d\n", stack_size(stack));
break;
case 9:
render_menu();
break;
case 0:
break;
default:
printf("Wrong choice!\n");
break;
}
}
free(stack);
return 0;
}
int loop_hook(t_event *e)
{
if (e->menu == MAIN_MENU)
control_menu(e);
else if (e->menu == GAME)
control_player(e);
else if (e->menu == TEXTURE_EDITOR)
control_edit_tex(e);
clear(e);
if (e->menu == GAME)
{
render_map(e);
render_minimap(e);
}
else if (e->menu == TEXTURE_EDITOR)
render_edit_tex(e);
mlx_put_image_to_window(e->mlx, e->win, e->img.addr, 0, 0);
if (e->menu == GAME)
mlx_string_put(e->mlx, e->win, 5, e->height - 22, 0xffffff,
"Arrow or WASD to move and rotate");
if (e->menu == MAIN_MENU)
render_menu(e);
else if (e->menu == TEXTURE_EDITOR)
render_edit_tex_gui(e);
return (0);
}
void GUI::OnRender() {
if(current_screen == MENU_SCREEN) {
render_menu(menu);
} else if(current_screen == MAP_SCREEN) {
std::vector<std::vector<MapTile> > map_canvas = world_map_gui.get_canvas();
for(size_t i = 0; i < map_canvas.size(); i++) {
for(size_t j = 0; j < map_canvas[i].size(); j++) {
drawChr(j, i, map_canvas[i][j].char_count, ascii, screen, map_canvas[i][j].color);
}
}
drawStr(0, GAME_HEIGHT - 2, std::string("Use the arrow keys to move the cursor.").c_str(),
ascii, screen, WHITE);
drawStr(0, GAME_HEIGHT - 1, std::string("Press ENTER to spawn on the selected map tile.").c_str(),
ascii, screen, WHITE);
} else if (current_screen == GAME_SCREEN) {
render_canvas();
render_target();
render_characters();
render_main_char();
render_animations();
clear_area(IntPoint(0, UI_START), IntPoint(UI_HEIGHT, UI_WIDTH));
render_interface();
render_message();
} else if(current_screen == DIRECTION_SCREEN)
{
drawStr(0, 0, std::string("Pick a direction to perform the action.").c_str(), ascii, screen, WHITE);
} else if (current_screen == DEATH_SCREEN) {
clear_screen();
drawStr(GAME_WIDTH/2 - 12, GAME_HEIGHT/2, std::string("You suck, uninstall bro.").c_str(), ascii, screen, WHITE);
} else if (current_screen == DEBUG_CONSOLE) {
render_canvas();
render_target();
render_characters();
render_main_char();
render_debug();
}
if(game.is_paused()) {
drawStr(GAME_WIDTH-20, 0, std::string("Paused").c_str(), ascii, screen, WHITE);
}
SDL_Flip(screen);
}
void menu::run()
{
bool loop {true};
SDL_Event event;
render_menu();
while (loop)
{
SDL_WaitEvent(&event);
if (event.type == SDL_QUIT)
{
loop = false;
}
if (event.type == SDL_KEYDOWN)
{
SDL_Keycode key = event.key.keysym.sym;
if (key == SDLK_DOWN)
{
++selected_item;
if (selected_item > 3)
{
selected_item = 0;
}
}
else if (key == SDLK_UP)
{
--selected_item;
if (selected_item < 0)
{
selected_item = 3;
}
}
else if (key == SDLK_ESCAPE)
{
loop = false;
}
else if (key == SDLK_RETURN || key == SDLK_RETURN2)
{
if (selected_item == 0)
{
si->run();
//int score = si->run();
//hs->save_score(score);
}
else if (selected_item == 1)
{
hs->show_highscore();
}
else if(selected_item == 2)
{
h->show_help();
}
else if(selected_item == 3)
{
loop = false;
}
else
{
//TODO: ERROR
}
}
render_menu();
}
}
}
void
Compositor::render(Viewer& viewer)
{
// render the world, twice if stereo is enabled
if (true)
{
OpenGLState state;
#ifndef HAVE_OPENGLES2
if (m_render_shadowmap)
{
g_shadowmap->bind();
render_shadowmap(viewer);
g_shadowmap->unbind();
}
#endif
if (m_stereo_mode == StereoMode::None)
{
m_renderbuffer1->bind();
render_scene(viewer, Stereo::Center);
m_renderbuffer1->unbind();
m_renderbuffer1->blit(*m_framebuffer1);
}
else
{
m_renderbuffer1->bind();
render_scene(viewer, Stereo::Left);
m_renderbuffer1->unbind();
m_renderbuffer2->bind();
render_scene(viewer, Stereo::Right);
m_renderbuffer2->unbind();
m_renderbuffer1->blit(*m_framebuffer1);
m_renderbuffer2->blit(*m_framebuffer2);
}
}
// composit the final image
if (true)
{
OpenGLState state;
MaterialPtr material = std::make_shared<Material>();
{ // setup material
material->set_program(m_composition_prog);
material->set_uniform("MVP", UniformSymbol::ModelViewProjectionMatrix);
material->set_uniform("barrel_power", m_barrel_power);
material->set_uniform("left_eye", 0);
material->set_uniform("right_eye", 1);
if (!viewer.m_cfg.m_show_calibration)
{
material->set_texture(0, m_framebuffer1->get_color_texture());
material->set_texture(1, m_framebuffer2->get_color_texture());
}
else
{
material->set_texture(0, m_calibration_left_texture);
material->set_texture(1, m_calibration_right_texture);
}
m_viewport_offset = {0, 0};
switch(m_stereo_mode)
{
case StereoMode::Cybermaxx:
m_viewport_offset = {-41, 16};
m_composition_prog = m_cybermaxx_prog;
break;
case StereoMode::CrossEye:
m_composition_prog = m_crosseye_prog;
break;
case StereoMode::Anaglyph:
m_composition_prog = m_anaglyph_prog;
break;
case StereoMode::Depth:
material->set_texture(0, m_framebuffer1->get_depth_texture());
m_composition_prog = m_depth_prog;
break;
case StereoMode::Newsprint:
m_composition_prog = m_newsprint_prog;
break;
default:
m_composition_prog = m_mono_prog;
break;
}
} // setup material
ModelPtr model = std::make_shared<Model>();
model->add_mesh(Mesh::create_rect(0.0f, 0.0f, m_screen_w, m_screen_h, -20.0f));
model->set_material(material);
Camera camera;
camera.ortho(0, m_screen_w, m_screen_h, 0.0f, 0.1f, 10000.0f);
SceneManager mgr;
mgr.get_world()->attach_model(model);
RenderContext ctx(camera, mgr.get_world());
glViewport(m_viewport_offset.x, m_viewport_offset.y, m_screen_w, m_screen_h);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
mgr.render(camera);
render_menu(ctx, viewer);
}
assert_gl("display:exit()");
}
int main(void)
{
int done=0;
srand(time(NULL));
initXWindows();
init_opengl();
//declare game object
Game game;
game.numberDefenseMissiles=0;
//JG
game.nparticles=MAX_PARTICLES;
game.numberDefenseMissiles=0;
// JBC 5/19/16
// added globally accesible defMissileSpeed so that we can
// change it dynamically
game.defMissileSpeed = 10;
initStruc(&game);
//Structures sh;
//Changed call for function prototype 5-17-16 -DT
createEMissiles(&game, 0, 0);
initRadar(&game);
initUFO(&game);
initHighScores(&game);
//JR - Menu Object Shapes and Locations
drawMenu(&game);
drawSettings(&game);
game.sounds.loadAudio();
//start animation
while (!done) {
int state = gameState(&game);
while (XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_mouse(&e, &game);
done = check_keys(&e, &game);
}
if (state == 1) {
render_menu(&game);
} else if (state == 2) {
drawSettings(&game);
render_settings(&game);
} else if (state == 3) {
render_newgame(&game);
} else if (state == 0 || state == 5) {
if (lvlState(&game) < 0) {
movement(&game);
render(&game);
}
if (lvlState(&game) == 1) {
levelEnd(&game);
}
} else {
render_gameover(&game);
}
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
return 0;
}
void CRender::Render ()
{
g_r = 1;
VERIFY (0==mapDistort.size());
bool _menu_pp = g_pGamePersistent?g_pGamePersistent->OnRenderPPUI_query():false;
if (_menu_pp) {
render_menu () ;
return ;
};
if( !(g_pGameLevel && g_pGameLevel->pHUD) ) return;
//. VERIFY (g_pGameLevel && g_pGameLevel->pHUD);
// Configure
RImplementation.o.distortion = FALSE; // disable distorion
Fcolor sun_color = ((light*)Lights.sun_adapted._get())->color;
BOOL bSUN = ps_r2_ls_flags.test(R2FLAG_SUN) && (u_diffuse2s(sun_color.r,sun_color.g,sun_color.b)>EPS);
if (o.sunstatic) bSUN = FALSE;
// Msg ("sstatic: %s, sun: %s",o.sunstatic?"true":"false", bSUN?"true":"false");
// HOM
ViewBase.CreateFromMatrix (Device.mFullTransform, FRUSTUM_P_LRTB + FRUSTUM_P_FAR);
View = 0;
if (!ps_r2_ls_flags.test(R2FLAG_EXP_MT_CALC)) {
HOM.Enable ();
HOM.Render (ViewBase);
}
//******* Z-prefill calc - DEFERRER RENDERER
if (ps_r2_ls_flags.test(R2FLAG_ZFILL)) {
Device.Statistic->RenderCALC.Begin ();
float z_distance = ps_r2_zfill ;
Fmatrix m_zfill, m_project ;
m_project.build_projection (
deg2rad(Device.fFOV/* *Device.fASPECT*/),
Device.fASPECT, VIEWPORT_NEAR,
z_distance * g_pGamePersistent->Environment().CurrentEnv.far_plane);
m_zfill.mul (m_project,Device.mView);
r_pmask (true,false); // enable priority "0"
set_Recorder (NULL) ;
phase = PHASE_SMAP;
render_main (m_zfill,false) ;
r_pmask (true,false); // disable priority "1"
Device.Statistic->RenderCALC.End ( ) ;
// flush
Target->phase_scene_prepare ();
RCache.set_ColorWriteEnable (FALSE);
r_dsgraph_render_graph (0);
RCache.set_ColorWriteEnable ( );
} else {
Target->phase_scene_prepare ();
}
//*******
// Sync point
Device.Statistic->RenderDUMP_Wait_S.Begin ();
if (1)
{
CTimer T; T.Start ();
BOOL result = FALSE;
HRESULT hr = S_FALSE;
while ((hr=q_sync_point[q_sync_count]->GetData (&result,sizeof(result),D3DGETDATA_FLUSH))==S_FALSE) {
if (!SwitchToThread()) Sleep(ps_r2_wait_sleep);
if (T.GetElapsed_ms() > 500) {
result = FALSE;
break;
}
}
}
Device.Statistic->RenderDUMP_Wait_S.End ();
q_sync_count = (q_sync_count+1)%2;
CHK_DX (q_sync_point[q_sync_count]->Issue(D3DISSUE_END));
//******* Main calc - DEFERRER RENDERER
// Main calc
Device.Statistic->RenderCALC.Begin ();
r_pmask (true,false,true); // enable priority "0",+ capture wmarks
if (bSUN) set_Recorder (&main_coarse_structure);
else set_Recorder (NULL);
phase = PHASE_NORMAL;
render_main (Device.mFullTransform,true);
set_Recorder (NULL);
r_pmask (true,false); // disable priority "1"
Device.Statistic->RenderCALC.End ();
BOOL split_the_scene_to_minimize_wait = FALSE;
if (ps_r2_ls_flags.test(R2FLAG_EXP_SPLIT_SCENE)) split_the_scene_to_minimize_wait=TRUE;
//******* Main render :: PART-0 -- first
if (!split_the_scene_to_minimize_wait)
{
// level, DO NOT SPLIT
Target->phase_scene_begin ();
r_dsgraph_render_hud ();
r_dsgraph_render_graph (0);
r_dsgraph_render_lods (true,true);
if(Details) Details->Render ();
Target->phase_scene_end ();
} else {
// level, SPLIT
Target->phase_scene_begin ();
r_dsgraph_render_graph (0);
Target->disable_aniso ();
}
//******* Occlusion testing of volume-limited light-sources
Target->phase_occq ();
LP_normal.clear ();
LP_pending.clear ();
{
// perform tests
u32 count = 0;
light_Package& LP = Lights.package;
// stats
stats.l_shadowed = LP.v_shadowed.size();
stats.l_unshadowed = LP.v_point.size() + LP.v_spot.size();
stats.l_total = stats.l_shadowed + stats.l_unshadowed;
// perform tests
count = _max (count,LP.v_point.size());
count = _max (count,LP.v_spot.size());
count = _max (count,LP.v_shadowed.size());
for (u32 it=0; it<count; it++) {
if (it<LP.v_point.size()) {
light* L = LP.v_point [it];
L->vis_prepare ();
if (L->vis.pending) LP_pending.v_point.push_back (L);
else LP_normal.v_point.push_back (L);
}
if (it<LP.v_spot.size()) {
light* L = LP.v_spot [it];
L->vis_prepare ();
if (L->vis.pending) LP_pending.v_spot.push_back (L);
else LP_normal.v_spot.push_back (L);
}
if (it<LP.v_shadowed.size()) {
light* L = LP.v_shadowed [it];
L->vis_prepare ();
if (L->vis.pending) LP_pending.v_shadowed.push_back (L);
else LP_normal.v_shadowed.push_back (L);
}
}
}
LP_normal.sort ();
LP_pending.sort ();
//******* Main render :: PART-1 (second)
if (split_the_scene_to_minimize_wait) {
// skybox can be drawn here
if (0)
{
Target->u_setrt ( Target->rt_Generic_0, Target->rt_Generic_1,0,HW.pBaseZB );
RCache.set_CullMode ( CULL_NONE );
RCache.set_Stencil ( FALSE );
// draw skybox
RCache.set_ColorWriteEnable ();
CHK_DX(HW.pDevice->SetRenderState ( D3DRS_ZENABLE, FALSE ));
g_pGamePersistent->Environment().RenderSky ();
CHK_DX(HW.pDevice->SetRenderState ( D3DRS_ZENABLE, TRUE ));
}
// level
Target->phase_scene_begin ();
r_dsgraph_render_hud ();
r_dsgraph_render_lods (true,true);
if(Details) Details->Render ();
Target->phase_scene_end ();
}
// Wall marks
if(Wallmarks) {
Target->phase_wallmarks ();
if (!ps_common_flags.test(RFLAG_BLOODMARKS)) g_r = 0;
Wallmarks->Render (); // wallmarks has priority as normal geometry
}
// Update incremental shadowmap-visibility solver
{
u32 it=0;
for (it=0; it<Lights_LastFrame.size(); it++) {
if (0==Lights_LastFrame[it]) continue ;
try {
Lights_LastFrame[it]->svis.flushoccq() ;
} catch (...)
{
Msg ("! Failed to flush-OCCq on light [%d] %X",it,*(u32*)(&Lights_LastFrame[it]));
}
}
Lights_LastFrame.clear ();
}
// Directional light - f*****g sun
if (bSUN) {
RImplementation.stats.l_visible ++;
render_sun_near ();
render_sun ();
render_sun_filtered ();
Target->accum_direct_blend ();
}
// Lighting, non dependant on OCCQ
Target->phase_accumulator ();
HOM.Disable ();
render_lights (LP_normal);
// Lighting, dependant on OCCQ
render_lights (LP_pending);
// Postprocess
Target->phase_combine ();
VERIFY (0==mapDistort.size());
}
