insula::physics::debug_drawer::debug_drawer(
world &_world,
sge::renderer::device_ptr const _renderer,
graphics::camera::object &_camera)
:
world_(
_world),
renderer_(
_renderer),
camera_(
_camera),
shader_(
renderer_,
media_path()/FCPPT_TEXT("debug_vertex.glsl"),
media_path()/FCPPT_TEXT("debug_fragment.glsl"),
graphics::shader::vf_to_string<vertex_format>(),
{
graphics::shader::variable(
"mvp",
graphics::shader::variable_type::uniform,
graphics::mat4())
},
graphics::shader::sampler_sequence()),
debug_mode_(
btIDebugDraw::DBG_NoDebug) // should be zero
{
world_.handle().setDebugDrawer(
this);
}
boost::program_options::variables_map const
insula::create_variables_map(
int argc,
char **argv,
sge::parse::json::object const &config_file)
{
boost::program_options::options_description desc("Allowed options");
desc.add_options()
("console-redirect",boost::program_options::value<bool>(),"Redirect stdout and stderr to console")
("help","produce help message");
desc.add(
game_cli_options());
desc.add(
graphics::camera::cli_options());
desc.add(
height_map::cli_options());
desc.add(
water::cli_options());
desc.add(
graphics::cli_options());
desc.add(
physics::cli_options());
desc.add(
states::camera_move::cli_options());
desc.add(
states::game_outer::cli_options());
boost::program_options::variables_map vm;
boost::program_options::store(
boost::program_options::parse_command_line(
argc,
argv,
desc),
vm);
boost::program_options::notify(
vm);
if (fcppt::filesystem::exists(media_path()/FCPPT_TEXT("user_config.json")))
{
boost::program_options::store(
json::parse_config(
sge::parse::json::parse_file_exn(
media_path()/FCPPT_TEXT("user_config.json")),
desc),
vm);
// I don't know if that's neccessary since we do it again after
// parsing the command line
boost::program_options::notify(
vm);
}
boost::program_options::store(
json::parse_config(
sge::parse::json::find_member_exn<sge::parse::json::object>(
config_file.members,
FCPPT_TEXT("cli")),
desc),
vm);
// I don't know if that's neccessary since we do it again after
// parsing the command line
boost::program_options::notify(
vm);
if (vm.count("help"))
throw
help_needed(
options_to_string(
desc));
return vm;
}
insula::overlay::object::object(
parameters const ¶ms)
:
renderer_(
params.systems.renderer()),
camera_(
params.camera),
texture_backend_(
params.scene_manager,
{"overlay"},
// Has to be high priority so it's drawn before the overlay
// (otherwise it would override everything that's there)
scene::backend_priority::high),
user_backend_(
params.scene_manager,
{"overlay"}),
overlay_texture_(
renderer_->create_texture(
fcppt::math::dim::structure_cast<sge::renderer::dim_type>(
renderer_->screen_size()),
sge::image::color::format::rgb8,
sge::renderer::filter::point,
sge::renderer::resource_flags::none)),
target_(
renderer_->create_target(
overlay_texture_,
sge::renderer::no_depth_stencil_texture())),
vb_(
renderer_->create_vertex_buffer(
sge::renderer::vf::dynamic::make_format<vf::format>(),
static_cast<sge::renderer::size_type>(
6),
sge::renderer::resource_flags::none)),
quad_shader_(
renderer_,
media_path()/FCPPT_TEXT("quad_vertex.glsl"),
media_path()/FCPPT_TEXT("quad_fragment.glsl"),
graphics::shader::vf_to_string<vf::format>(),
{
graphics::shader::variable(
"mvp",
graphics::shader::variable_type::uniform,
graphics::mat4()),
graphics::shader::variable(
"screen_size",
graphics::shader::variable_type::const_,
fcppt::math::dim::structure_cast<graphics::vec2>(
renderer_->screen_size()))
},
{
graphics::shader::sampler(
"texture",
overlay_texture_)
}),
internal_connection_(
texture_backend_.register_callback(
std::bind(
&object::render,
this,
std::placeholders::_1)))
{
params.scene_manager.add(
scene::render_pass::object(
FCPPT_TEXT("normal"),
[&camera_]()
{
return camera_.gizmo();
},
[this]()
{
return
sge::renderer::viewport(
sge::renderer::pixel_pos::null(),
renderer_->screen_size());
},
[&target_]()
{
return target_;
}),
{"water","shadow"});
params.scene_manager.add(
scene::render_pass::object(
FCPPT_TEXT("overlay"),
[¶ms]()
{
return
graphics::gizmo(
graphics::gizmo::init()
.position(graphics::vec3(0,0,0))
.forward(graphics::vec3(0,0,1))
.up(graphics::vec3(0,1,0))
.right(graphics::vec3(1,0,0)));
},
[this]()
{
return
sge::renderer::viewport(
sge::renderer::pixel_pos::null(),
renderer_->screen_size());
},
[]()
{
return sge::renderer::default_target();
}),
{"normal"});
// We have to activate the shader here because we want to fill the
// vertex buffer with "custom" attributes.
sge::renderer::glsl::scoped_program scoped_shader_(
renderer_,
quad_shader_.program());
{
graphics::camera::scoped cam(
params.camera,
graphics::gizmo(
graphics::gizmo::init()
.position(graphics::vec3(0,0,-params.camera.near()))
.forward(graphics::vec3(0,0,1))
.up(graphics::vec3(0,1,0))
.right(graphics::vec3(1,0,0))));
quad_shader_.set_uniform(
FCPPT_TEXT("mvp"),
fcppt::math::matrix::orthogonal_xy<graphics::scalar>()
* params.camera.world());
}
sge::renderer::scoped_vertex_lock const vblock(
vb_,
sge::renderer::lock_mode::writeonly);
vf::vertex_view const vertices(
vblock.value());
vf::vertex_view::iterator vb_it(
vertices.begin());
// Left top
(vb_it++)->set<vf::position>(
vf::position::packed_type(
-1,
1,
0));
// Left bottom
(vb_it++)->set<vf::position>(
vf::position::packed_type(
-1,-1,0));
// Right top
(vb_it++)->set<vf::position>(
vf::position::packed_type(
1,1,0));
// Right top
(vb_it++)->set<vf::position>(
vf::position::packed_type(
1,1,0));
// Left bottom
(vb_it++)->set<vf::position>(
vf::position::packed_type(
-1,-1,0));
// Right bottom
(vb_it++)->set<vf::position>(
vf::position::packed_type(
1,-1,0));
}
sgetris::backgrounds::flakes::object::object(
boost::program_options::variables_map &_program_options,
sge::renderer::device &_renderer,
// The flakes get the loader because in a later version more than one flake image could be loaded
// from a directory
texture_manager &_texture_manager)
:
texture_manager_(
_texture_manager),
ss_(
_renderer),
clock_(),
frame_timer_(
sgetris::diff_timer::parameters(
fcppt::chrono::second(1)
)
),
flakes_()
{
texture_manager_.load(
media_path()/FCPPT_TEXT("backgrounds")/FCPPT_TEXT("flakes")/FCPPT_TEXT("textures.ini"));
fcppt::random::uniform<sprite::scalar>
xposition_rng(
fcppt::random::make_inclusive_range(
static_cast<sprite::scalar>(0),
static_cast<sprite::scalar>(
_renderer->screen_size().w()))),
yposition_rng(
fcppt::random::make_inclusive_range(
static_cast<sprite::scalar>(0),
static_cast<sprite::scalar>(
_renderer.screen_size().h())));
// Those pairs are real to avoid ugly casting below, they'll be cast
// one time sprite::scalar
std::pair<real,real>
size_range(
static_cast<real>(
_renderer.screen_size().w())*
_program_options["flakes-size-min"].as<real>(),
static_cast<real>(
_renderer.screen_size().w())*
_program_options["flakes-size-max"].as<real>());
std::pair<real,real>
speed_range(
_program_options["flakes-speed-min"].as<real>(),
_program_options["flakes-speed-max"].as<real>());
fcppt::random::uniform<real> rng(
fcppt::random::make_inclusive_range(
static_cast<real>(
0),
static_cast<real>(
1)));
for(
flake_count i = 0,
fc = _program_options["flakes-count"].as<flake_count>();
i < fc;
++i)
{
// Roll the dice
real const v =
rng();
sprite::vector const position(
xposition_rng(),
yposition_rng());
sprite::dim const size(
fcppt::math::dim::structure_cast<sprite::dim>(
fcppt::math::dim::make(
size_range.first + v * (size_range.second - size_range.first),
size_range.first + v * (size_range.second - size_range.first))));
sprite::scalar const speed =
static_cast<sprite::scalar>(
speed_range.first + v * (speed_range.second - speed_range.first));
flakes_.push_back(
new flake(
real(
v),
_renderer.screen_size(),
sprite::parameters()
.system(
&ss_)
.order(
0u)
.pos(
position)
.texture(
texture_manager_.texture(
FCPPT_TEXT("flake")))
.size(
size),
speed));
}
_renderer.state(
sge::renderer::state::list
(sge::renderer::state::bool_::clear_backbuffer = true)
(sge::renderer::state::color::clear_color
= sge::image::colors::black()
)
);
}
