static bool game_enter_portal (GAME *game, SCENE_PORTAL *portal)
{
assert (game);
if (portal) {
debug ("Going to portal %s", portal->name);
game->current_scene = portal->scene;
sprite_center (game->current_actor, &portal->position);
screen_center (&game->screen, portal->position, game->current_scene->map);
return true;
}
return false;
}
void RenderEngine::Stereoscopic()
{
if (stereo_method_ != STM_None)
{
fb_stage_ = 3;
#ifndef KLAYGE_SHIP
stereoscopic_pp_perf_->Begin();
#endif
this->BindFrameBuffer(screen_frame_buffer_);
if (stereoscopic_pp_)
{
Camera const & camera = *screen_frame_buffer_->GetViewport()->camera;
stereoscopic_pp_->SetParam(0, stereo_separation_);
stereoscopic_pp_->SetParam(1, camera.NearPlane());
float const q = camera.FarPlane() / (camera.FarPlane() - camera.NearPlane());
float2 near_q(camera.NearPlane() * q, q);
stereoscopic_pp_->SetParam(2, near_q);
}
if (stereo_method_ != STM_LCDShutter)
{
if (STM_OculusVR == stereo_method_)
{
Viewport const & vp = *screen_frame_buffer_->GetViewport();
float w = 0.5f;
float h = 1;
float x_left = 0;
float x_right = 0.5f;
float y = 0;
float aspect = static_cast<float>(vp.width / 2) / vp.height;
float3 lens_center(x_left + (w + ovr_x_center_offset_ * 0.5f) * 0.5f,
x_right + (w - ovr_x_center_offset_ * 0.5f) * 0.5f, y + h * 0.5f);
float3 screen_center(x_left + w * 0.5f, x_right + w * 0.5f, y + h * 0.5f);
float scale_factor = 1.0f / ovr_scale_;
float2 scale((w / 2) * scale_factor, (h / 2) * scale_factor * aspect);
float2 scale_in(2 / w, 2 / h / aspect);
stereoscopic_pp_->SetParam(3, lens_center);
stereoscopic_pp_->SetParam(4, screen_center);
stereoscopic_pp_->SetParam(5, scale);
stereoscopic_pp_->SetParam(6, scale_in);
stereoscopic_pp_->SetParam(7, ovr_hmd_warp_param_);
stereoscopic_pp_->SetParam(8, ovr_chrom_ab_param_);
}
stereoscopic_pp_->Render();
}
else
{
this->StereoscopicForLCDShutter(1);
this->StereoscopicForLCDShutter(0);
this->BindFrameBuffer(screen_frame_buffer_);
}
#ifndef KLAYGE_SHIP
stereoscopic_pp_perf_->End();
#endif
fb_stage_ = 0;
}
}
GAME * game_init ()
{
if (!al_init ()) {
fprintf (stderr, "Failed to initialize Allegro.\n");
return NULL;
}
if (!al_init_image_addon ()) {
fprintf (stderr, "Failed to initialize image addon.\n");
return NULL;
}
if (!al_install_keyboard ()) {
fprintf (stderr, "Failed to install keyboard.\n");
return NULL;
}
al_init_font_addon ();
if (!al_init_ttf_addon ()) {
fprintf (stderr, "Failed to initialize ttf addon.\n");
return NULL;
}
if (!al_init_primitives_addon ()) {
fprintf (stderr, "Failed to initialize primitives addon.\n");
return NULL;
}
GAME *game = al_malloc (sizeof (GAME));
if (!game)
return NULL;
srand (time (NULL));
game->running = true;
game->paused = false;
game->fullscreen = 1;
game->windowed = 1;
game->rrate = 60;
game->suggest_vsync = 1;
game->force_vsync = 0;
game->current_npc = NULL;
game->screen = screen_new ();
char *filename;
const char *str;
filename = get_resource_path_str ("data/game.ini");
ALLEGRO_CONFIG *game_config = al_load_config_file (filename);
al_free (filename);
str = al_get_config_value (game_config, "", "org");
al_set_org_name (str);
str = al_get_config_value (game_config, "", "app");
al_set_app_name (str);
ALLEGRO_PATH *settpath = al_get_standard_path (ALLEGRO_USER_SETTINGS_PATH);
ALLEGRO_PATH *gcpath = al_clone_path (settpath);
al_set_path_filename (gcpath, "general.ini");
const char * gcpath_str = al_path_cstr (gcpath, ALLEGRO_NATIVE_PATH_SEP);
ALLEGRO_CONFIG *gconfig = al_load_config_file (gcpath_str);
if (!gconfig) {
gconfig = al_create_config ();
al_make_directory (al_path_cstr (settpath, ALLEGRO_NATIVE_PATH_SEP));
set_config_i (gconfig, "display", "width", game->screen.width);
set_config_i (gconfig, "display", "height", game->screen.height);
set_config_i (gconfig, "display", "fullscreen", game->fullscreen);
set_config_i (gconfig, "display", "windowed", game->windowed);
set_config_i (gconfig, "display", "refreshrate", game->rrate);
set_config_i (gconfig, "display", "suggest_vsync", game->suggest_vsync);
set_config_i (gconfig, "display", "force_vsync", game->force_vsync);
} else {
get_config_i (gconfig, "display", "width", &game->screen.width);
get_config_i (gconfig, "display", "height", &game->screen.height);
get_config_i (gconfig, "display", "fullscreen", &game->fullscreen);
get_config_i (gconfig, "display", "windowed", &game->windowed);
get_config_i (gconfig, "display", "refreshrate", &game->rrate);
get_config_i (gconfig, "display", "suggest_vsync", &game->suggest_vsync);
get_config_i (gconfig, "display", "force_vsync", &game->force_vsync);
}
al_save_config_file (gcpath_str, gconfig);
al_destroy_path (settpath);
al_destroy_path (gcpath);
al_destroy_config (gconfig);
int flags = 0;
if (game->fullscreen == game->windowed)
flags |= ALLEGRO_FULLSCREEN_WINDOW;
else if (game->fullscreen)
flags |= ALLEGRO_FULLSCREEN;
else
flags |= ALLEGRO_WINDOWED;
al_set_new_display_option (ALLEGRO_VSYNC, game->suggest_vsync, ALLEGRO_SUGGEST);
al_set_new_display_option (ALLEGRO_DEPTH_SIZE, 8, ALLEGRO_SUGGEST);
al_set_new_display_flags (flags);
al_set_new_display_refresh_rate (game->rrate);
game->display = al_create_display (game->screen.width, game->screen.height);
if (!game->display) {
fprintf (stderr, "Failed to create display.\n");
al_free (game);
return NULL;
}
al_set_new_bitmap_flags (ALLEGRO_VIDEO_BITMAP);
game->timer = al_create_timer (1.0 / FPS);
if (!game->timer) {
fprintf (stderr, "Failed to create timer.\n");
al_free (game);
return NULL;
}
game->screen.width = al_get_display_width (game->display);
game->screen.height = al_get_display_height (game->display);
screen_update_size (&game->screen, game->screen.width, game->screen.height);
game->rrate = al_get_display_refresh_rate (game->display);
game->event_queue = al_create_event_queue ();
if (!game->event_queue) {
fprintf (stderr, "Failed to create event queue.\n");
al_free (game);
return NULL;
}
al_register_event_source (game->event_queue, al_get_display_event_source (game->display));
al_register_event_source (game->event_queue, al_get_timer_event_source (game->timer));
al_set_render_state (ALLEGRO_ALPHA_FUNCTION, ALLEGRO_RENDER_EQUAL);
al_set_render_state (ALLEGRO_ALPHA_TEST_VALUE, 1);
filename = get_resource_path_str ("data/sprites.ini");
game->sprites = sprite_load_sprites (filename);
al_free (filename);
filename = get_resource_path_str ("data/scenes.ini");
game->scenes = scene_load_file (filename);
scene_load_scenes (game->scenes, game->sprites);
al_free (filename);
str = al_get_config_value (game_config, "", "scene");
game->current_scene = scene_get (game->scenes, str);
str = al_get_config_value (game_config, "", "actor");
game->current_actor = sprite_new_actor (game->sprites, str);
str = al_get_config_value (game_config, "", "portal");
SCENE_PORTAL *portal = scene_get_portal (game->scenes, str);
al_destroy_config (game_config);
filename = get_resource_path_str ("data/ui.ini");
game->ui = ui_load_file (filename);
al_free (filename);
sprite_center (game->current_actor, &portal->position);
screen_center (&game->screen, portal->position, game->current_scene->map);
return game;
}
void
Lensflare::draw()
{
Vector2f screen_center(static_cast<float>(m_aspect_ratio.width) / 2.0f,
static_cast<float>(m_aspect_ratio.height) / 2.0f);
float dist = (m_mouse - screen_center).length();
float factor = 0.3f - (dist / static_cast<float>(m_aspect_ratio.width + m_aspect_ratio.height));
factor *= 3.3f;
std::cout << factor << std::endl;
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glAlphaFunc ( GL_GREATER, 0.5f );
glEnable(GL_ALPHA_TEST);
m_cover->draw(SurfaceDrawingParameters()
.set_pos(Vector2f(600, 400))
.set_color(Color(0.15f, 0.15f, 0.15f, 1.0f))
);
glDisable(GL_ALPHA_TEST);
if (true)
{
GLint samples = 0;
GLint total_samples = 0;
GLuint query_id;
GLuint total_query_id;
glGenQueries(1, &query_id);
glGenQueries(1, &total_query_id);
assert_gl("Broken");
// disable all buffer writing
glDepthMask(GL_FALSE);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
// query the number of visible samples
glBeginQuery(GL_SAMPLES_PASSED, query_id);
m_lightquery->draw(SurfaceDrawingParameters()
.set_pos(Vector2f(m_mouse.x - m_lightquery->get_width()/2,
m_mouse.y - m_lightquery->get_height()/2)));
glEndQuery(GL_SAMPLES_PASSED);
glGetQueryObjectiv(query_id, GL_QUERY_RESULT, &samples);
glClear(GL_DEPTH_BUFFER_BIT);
// reference query, to get the total amount of samples
glDisable(GL_DEPTH_TEST);
glBeginQuery(GL_SAMPLES_PASSED, total_query_id);
m_lightquery->draw(SurfaceDrawingParameters()
.set_pos(Vector2f(m_mouse.x - m_lightquery->get_width()/2,
m_mouse.y - m_lightquery->get_height()/2)));
glEndQuery(GL_SAMPLES_PASSED);
glEnable(GL_DEPTH_TEST);
glGetQueryObjectiv(total_query_id, GL_QUERY_RESULT, &total_samples);
glDepthMask(GL_TRUE);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
std::cout << "samples: " << samples << " -/- " << total_samples << std::endl;
glDeleteQueries(1, &query_id);
glDeleteQueries(1, &total_query_id);
float visibility = static_cast<float>(samples) / static_cast<float>(total_samples);
factor *= visibility;
glDepthMask(GL_FALSE);
m_halo->draw(SurfaceDrawingParameters()
.set_blend_func(GL_SRC_ALPHA, GL_ONE)
.set_color(Color(1,1,1,visibility))
.set_scale(1.0f)
.set_pos(Vector2f(m_mouse.x,
m_mouse.y)
- Vector2f(m_halo->get_width()/2 * (1.0f),
m_halo->get_height()/2 * (1.0f))));
glDisable(GL_DEPTH_TEST);
m_light->draw(SurfaceDrawingParameters()
.set_blend_func(GL_SRC_ALPHA, GL_ONE)
.set_color(Color(1,1,1,1))
.set_scale(visibility)
.set_pos(Vector2f(m_mouse.x - m_light->get_width()/2 * visibility,
m_mouse.y - m_light->get_height()/2 * visibility)));
glDepthMask(GL_TRUE);
m_halo->draw(SurfaceDrawingParameters()
.set_blend_func(GL_SRC_ALPHA, GL_ONE)
.set_color(Color(1,1,1,visibility))
.set_scale(2.0f + factor*5.0f)
.set_pos(Vector2f(m_mouse.x,
m_mouse.y)
- Vector2f(m_halo->get_width()/2 * (2.0f + factor*5.0f),
m_halo->get_height()/2 * (2.0f + factor*5.0f))));
m_superlight->draw(SurfaceDrawingParameters()
.set_blend_func(GL_SRC_ALPHA, GL_ONE)
.set_color(Color(1.0f, 1.0f, 1.0f, factor))
.set_scale(factor)
.set_pos(Vector2f(m_mouse.x - m_superlight->get_width()/2 * factor,
m_mouse.y - m_superlight->get_height()/2 * factor)));
for(Flairs::iterator i = m_flairs.begin(); i != m_flairs.end(); ++i)
{
i->m_surface->draw(SurfaceDrawingParameters()
.set_blend_func(GL_SRC_ALPHA, GL_ONE)
.set_scale(i->m_scale)
.set_color(Color(i->m_color.r, i->m_color.g, i->m_color.b, i->m_color.a * visibility))
.set_pos(screen_center + (m_mouse - screen_center) * i->m_distance
- Vector2f(i->m_surface->get_width() /2 * i->m_scale,
i->m_surface->get_height()/2 * i->m_scale)));
}
}
}
