void
flake::planar::conversion::object::to_arrow_vb(
flakelib::planar::float2_view const &_planar_buffer,
sge::opencl::memory_object::buffer &_vb,
conversion::grid_scale const &_grid_scale,
conversion::arrow_scale const &_arrow_scale)
{
to_arrow_vb_kernel_->buffer_argument(
"vb",
_vb);
to_arrow_vb_kernel_->buffer_argument(
"buffer",
_planar_buffer.buffer());
to_arrow_vb_kernel_->numerical_argument(
"buffer_pitch",
sge::opencl::kernel::numeric_type(
static_cast<cl_uint>(
_planar_buffer.size().w())));
to_arrow_vb_kernel_->numerical_argument(
"grid_scale",
sge::opencl::kernel::numeric_type(
_grid_scale.get()));
to_arrow_vb_kernel_->numerical_argument(
"arrow_scale",
sge::opencl::kernel::numeric_type(
_arrow_scale.get()));
sge::opencl::memory_object::base_ref_sequence mem_objects;
mem_objects.push_back(
&_vb);
sge::opencl::memory_object::scoped_objects scoped_vb(
command_queue_,
mem_objects);
to_arrow_vb_kernel_->enqueue_automatic(
sge::opencl::command_queue::global_dim2(
_planar_buffer.size()));
}
void
sge::postprocessing::fullscreen_quad::render(
sge::renderer::context::core &_context)
{
sge::renderer::vertex::scoped_declaration scoped_vd(
_context,
vertex_declaration_);
sge::renderer::vertex::scoped_buffer scoped_vb(
_context,
*vertex_buffer_);
_context.render_nonindexed(
sge::renderer::vertex::first(
0u),
sge::renderer::vertex::count(
vertex_buffer_->linear_size()),
sge::renderer::primitive_type::triangle_strip);
}
void
flake::planar::conversion::object::scalar_to_texture(
flakelib::planar::float_view const &_planar_buffer,
sge::opencl::memory_object::image::planar &_texture,
conversion::scaling_factor const &_scaling,
conversion::constant_addition const &_constant_addition)
{
FCPPT_ASSERT_PRE(
_planar_buffer.size() == _texture.size());
scalar_to_texture_kernel_->buffer_argument(
"input",
_planar_buffer.buffer());
scalar_to_texture_kernel_->buffer_argument(
"output",
_texture);
scalar_to_texture_kernel_->numerical_argument(
"scaling",
sge::opencl::kernel::numeric_type(
_scaling.get()));
scalar_to_texture_kernel_->numerical_argument(
"addition",
sge::opencl::kernel::numeric_type(
_constant_addition.get()));
sge::opencl::memory_object::base_ref_sequence mem_objects;
mem_objects.push_back(
&_texture);
sge::opencl::memory_object::scoped_objects scoped_vb(
command_queue_,
mem_objects);
scalar_to_texture_kernel_->enqueue_automatic(
sge::opencl::command_queue::global_dim2(
_planar_buffer.size()));
}
void
fruitapp::fruit::rendering::ffp::render(
sge::renderer::context::core &_context)
{
sge::renderer::context::ffp &ffp_context(
dynamic_cast<sge::renderer::context::ffp &>(
_context));
sge::renderer::state::ffp::lighting::scoped const scoped_lighting(
ffp_context,
*lighting_);
sge::renderer::state::ffp::lighting::light::scoped const scoped_light(
ffp_context,
sge::renderer::state::ffp::lighting::light::const_object_ref_vector{
fcppt::make_cref(
*light_)});
sge::renderer::state::core::depth_stencil::scoped scoped_depth_stencil(
ffp_context,
*depth_stencil_state_);
sge::renderer::state::ffp::transform::object_unique_ptr const projection_state(
renderer_.create_transform_state(
sge::renderer::state::ffp::transform::parameters(
camera_.projection_matrix().get())));
sge::renderer::state::ffp::transform::scoped const projection_transform(
ffp_context,
sge::renderer::state::ffp::transform::mode::projection,
*projection_state);
sge::renderer::vertex::scoped_declaration scoped_vd(
ffp_context,
manager_.vertex_declaration());
fruitapp::fruit::rendering::fruit_pointer_sequence fruit_pointers;
fruitapp::fruit::rendering::sort_fruits(
manager_.fruits(),
fruit_pointers);
fruitapp::fruit::prototype const *previous_prototype =
nullptr;
fcppt::optional::object<
sge::renderer::state::ffp::lighting::material::object_unique_ptr
>
previous_material_state;
for(
fruitapp::fruit::rendering::fruit_pointer_sequence::const_iterator i =
fruit_pointers.begin();
i != fruit_pointers.end();
++i)
{
sge::renderer::vertex::scoped_buffer scoped_vb(
_context,
(*i)->vb());
sge::renderer::state::ffp::transform::object_unique_ptr const world_state(
renderer_.create_transform_state(
sge::renderer::state::ffp::transform::parameters(
sge::camera::matrix_conversion::world(
camera_.coordinate_system()) *
(*i)->world_transform())));
sge::renderer::state::ffp::transform::scoped const world_transform(
ffp_context,
sge::renderer::state::ffp::transform::mode::world,
*world_state);
if(&((*i)->prototype()) != previous_prototype)
{
ffp_context.texture(
sge::renderer::texture::const_optional_base_ref(
fcppt::reference_to_base<
sge::renderer::texture::base const
>(
fcppt::make_cref(
*(*i)->prototype().texture()))),
sge::renderer::texture::stage(
0u));
sge::renderer::state::ffp::lighting::material::object_unique_ptr const &material_state(
fcppt::optional::assign(
previous_material_state,
renderer_.create_material_state(
fruit_material_to_ffp_material(
(*i)->prototype().material(),
ambient_intensity_))));
ffp_context.material_state(
sge::renderer::state::ffp::lighting::material::const_optional_object_ref(
fcppt::make_cref(
*material_state)));
previous_prototype =
&((*i)->prototype());
}
ffp_context.render_nonindexed(
sge::renderer::vertex::first(
static_cast<sge::renderer::size_type>(
0)),
sge::renderer::vertex::count(
(*i)->vb().linear_size()),
sge::renderer::primitive_type::triangle_list);
}
ffp_context.texture(
sge::renderer::texture::const_optional_base_ref(),
sge::renderer::texture::stage(
0u));
ffp_context.material_state(
sge::renderer::state::ffp::lighting::material::const_optional_object_ref());
}
void
flake::volume::density_visualization::raycaster::object::render(
sge::renderer::context::core &_context)
{
sge::renderer::vertex::scoped_declaration scoped_vd(
_context,
*vertex_declaration_);
sge::shader::scoped_pair scoped_shader(
_context,
shader_);
mvp_parameter_.set(
sge::camera::matrix_conversion::world_projection(
camera_.coordinate_system(),
camera_.projection_matrix()));
camera_position_parameter_.set(
-camera_.coordinate_system().position().get());
camera_is_inside_cube_parameter_.set(
this->camera_is_inside_cube()
?
static_cast<sge::renderer::scalar>(
1.0f)
:
static_cast<sge::renderer::scalar>(
0.0f));
sge::renderer::state::core::blend::scoped scoped_blend_state(
_context,
*blend_state_);
sge::renderer::state::core::rasterizer::object_unique_ptr const rasterizer_state(
renderer_.create_rasterizer_state(
sge::renderer::state::core::rasterizer::parameters(
this->camera_is_inside_cube()
?
sge::renderer::state::core::rasterizer::cull_mode::counter_clockwise
:
sge::renderer::state::core::rasterizer::cull_mode::clockwise,
sge::renderer::state::core::rasterizer::fill_mode::solid,
sge::renderer::state::core::rasterizer::enable_scissor_test(
false))));
sge::renderer::state::core::rasterizer::scoped scoped_rasterizer_state(
_context,
*rasterizer_state);
sge::renderer::state::core::sampler::scoped scoped_sampler_state{
_context,
sge::renderer::state::core::sampler::const_object_ref_map{
sge::renderer::state::core::sampler::const_object_ref_map::value_type{
sge::renderer::texture::stage{
0u
},
fcppt::make_cref(
*sampler_state_
)
}
}
};
sge::renderer::vertex::scoped_buffer scoped_vb(
_context,
*vertex_buffer_);
_context.render_nonindexed(
sge::renderer::vertex::first(
0u),
sge::renderer::vertex::count(
36u),
sge::renderer::primitive_type::triangle_list);
}
int
main()
try
{
sge::opencl::system opencl_system;
fcppt::io::cout()
<< FCPPT_TEXT("Querying the number of available platforms...\n");
sge::opencl::platform::object_sequence &platforms(
opencl_system.platforms());
if(platforms.empty())
{
fcppt::io::cerr()
<< FCPPT_TEXT("Couldn't find any OpenCL platforms on your system.\n");
return EXIT_FAILURE;
}
fcppt::io::cout()
<< FCPPT_TEXT("Number of OpenCL platforms: ") << platforms.size() << FCPPT_TEXT("\n")
<< FCPPT_TEXT("Platform listing begin:\n")
<< FCPPT_TEXT("-----------------------\n");
sge::opencl::platform::object_sequence::size_type platform_index = 0;
for(
sge::opencl::platform::object const ¤t_platform
:
platforms
)
{
fcppt::io::cout()
<< FCPPT_TEXT("\tPlatform ")
<< platform_index++
<< FCPPT_TEXT(":\n")
<< FCPPT_TEXT("\tName: ")
<< fcppt::from_std_string(
current_platform.name()
)
<< FCPPT_TEXT("\n")
<< FCPPT_TEXT("\tVendor: ")
<< fcppt::from_std_string(
current_platform.vendor()
)
<< FCPPT_TEXT("\n")
<< FCPPT_TEXT("Profile type: ")
<<
(current_platform.profile() == sge::opencl::platform::profile_type::full
?
fcppt::string(FCPPT_TEXT("full"))
:
fcppt::string(FCPPT_TEXT("embedded")))
<< FCPPT_TEXT("\n")
<< FCPPT_TEXT("\tVersion: ")
<< current_platform.version().major_part()
<< FCPPT_TEXT(".")
<< current_platform.version().minor_part()
<< FCPPT_TEXT("\n");
if(!current_platform.version().platform_specific().empty())
fcppt::io::cout()
<< FCPPT_TEXT("\tPlatform specific version info: ")
<< fcppt::from_std_string(current_platform.version().platform_specific())
<< FCPPT_TEXT("\n");
fcppt::io::cout()
<< FCPPT_TEXT("\tExtension list begin:\n")
<< FCPPT_TEXT("\t*********************\n")
<< FCPPT_TEXT("\t\t")
<<
fcppt::from_std_string(
boost::algorithm::join(
current_platform.extensions(),
std::string("\n\t\t")))
<< FCPPT_TEXT("\r\t*********************\n")
<< FCPPT_TEXT("-----------------------\n");
}
fcppt::io::cout()
<< FCPPT_TEXT("Platform listing end\n");
sge::opencl::platform::object_sequence::size_type chosen_platform_index;
if(platforms.size() == 1)
{
chosen_platform_index = 0;
}
else
{
fcppt::io::cout()
<< FCPPT_TEXT("Your choice: ");
do
chosen_platform_index =
query_value_from_user<sge::opencl::platform::object_sequence::size_type>(
fcppt::io::cin());
while(chosen_platform_index >= platforms.size());
}
fcppt::io::cout()
<< FCPPT_TEXT("List devices with properties? [y/n] ");
fcppt::char_type list_devices;
do
list_devices =
query_value_from_user<fcppt::char_type>(
fcppt::io::cin());
while(list_devices != FCPPT_TEXT('y') && list_devices != FCPPT_TEXT('n'));
sge::opencl::platform::object &chosen_platform =
platforms[chosen_platform_index];
if(list_devices == FCPPT_TEXT('y'))
{
fcppt::io::cout()
<< FCPPT_TEXT("Number of devices on this platform: ")
<< chosen_platform.devices().size()
<< FCPPT_TEXT('\n')
<< FCPPT_TEXT("Device listing begin:\n")
<< FCPPT_TEXT("-----------------------\n");
for(
sge::opencl::device::object const ¤t_device
:
chosen_platform.devices()
)
{
current_device.output_info(
std::cout);
fcppt::io::cout()
<< FCPPT_TEXT("-----------------------\n");
}
fcppt::io::cout()
<< FCPPT_TEXT("-----------------------\n")
<< FCPPT_TEXT("Device listing end\n");
}
fcppt::io::cout()
<< FCPPT_TEXT("Creating sge::systems object...\n");
sge::window::dim const window_dim{
1024u,
768u
};
sge::systems::instance<
brigand::list<
sge::systems::with_window,
sge::systems::with_renderer<
sge::systems::renderer_caps::core
>
>
> const sys(
sge::systems::make_list
(
// FIXME: Move this higher?
sge::systems::config()
.log_settings(
sge::systems::log_settings{
sge::log::option_container{
sge::log::option{
sge::opencl::log_location(),
fcppt::log::level::verbose
}
}
}
)
)
(
sge::systems::window(
sge::systems::window_source(
sge::systems::original_window(
sge::window::title(
FCPPT_TEXT("Simple OpenCL example")
)
)
)
)
.dont_show()
)
(
sge::systems::renderer(
sge::renderer::pixel_format::object(
sge::renderer::pixel_format::color::depth32,
sge::renderer::pixel_format::depth_stencil::off,
sge::renderer::pixel_format::optional_multi_samples(),
sge::renderer::pixel_format::srgb::no
),
sge::renderer::display_mode::parameters(
sge::renderer::display_mode::vsync::on,
sge::renderer::display_mode::optional_object()
),
sge::viewport::optional_resize_callback{
sge::viewport::center_on_resize(
window_dim
)
}
)
)
);
fcppt::io::cout()
<< FCPPT_TEXT("Done. Creating a context with all devices on this platform...\n");
sge::opencl::device::object_ref_sequence const device_refs(
fcppt::algorithm::map<
sge::opencl::device::object_ref_sequence
>(
chosen_platform.devices(),
[](
sge::opencl::device::object &_device
)
{
return
fcppt::make_ref(
_device
);
}
)
);
sge::opencl::context::object main_context(
sge::opencl::context::parameters(
chosen_platform,
device_refs
)
.share_with(
sys.renderer_device_core())
.error_callback(
sge::opencl::context::error_callback{
&opencl_error_callback
}
)
);
fcppt::io::cout()
<< FCPPT_TEXT("Context created, listing available planar image formats (read/write)\n");
sge::opencl::memory_object::image::format_sequence const planar_image_formats =
main_context.supported_planar_image_formats(
CL_MEM_READ_WRITE);
for(
auto const format
:
planar_image_formats
)
{
sge::opencl::memory_object::image::format_output(
std::cout,
format
);
std::cout << '\n';
}
fcppt::io::cout()
<< FCPPT_TEXT("Listing available volume image formats (read/write)...\n");
sge::opencl::memory_object::image::format_sequence const volume_image_formats =
main_context.supported_volume_image_formats(
CL_MEM_READ_WRITE);
for(
auto const format
:
volume_image_formats
)
{
sge::opencl::memory_object::image::format_output(
std::cout,
format
);
std::cout << '\n';
}
fcppt::io::cout()
<< FCPPT_TEXT("Done, now creating a program...");
sge::opencl::program::object main_program(
sys.log_context(),
main_context,
sge::opencl::program::source_string_sequence{
std::string(
"__kernel void hello_kernel("
"float const multiplier,"
"__global float *input)"
"{"
"int gid = get_global_id(0);"
"int lid = get_local_id(0);"
"input[gid] = lid * multiplier;"
"}"
)
},
sge::opencl::program::optional_build_parameters());
fcppt::io::cout()
<< FCPPT_TEXT("Program created, building the program...\n");
volatile bool build_finished =
false;
main_program.build(
sge::opencl::program::build_parameters()
.notification_callback(
sge::opencl::program::notification_callback{
std::bind(
&program_build_finished,
std::ref(
build_finished
)
)
}
)
);
std::cout << "Waiting for build completion\n";
while(!build_finished)
std::cout << "Build not finished yet\n";
fcppt::io::cout()
<< FCPPT_TEXT("Program built, now creating a kernel...\n");
sge::opencl::kernel::object main_kernel(
main_program,
sge::opencl::kernel::name(
"hello_kernel"));
fcppt::io::cout()
<< FCPPT_TEXT("Kernel created, now creating a vertex buffer...\n");
sge::renderer::vertex::declaration_unique_ptr const vertex_declaration(
sys.renderer_device_core().create_vertex_declaration(
sge::renderer::vertex::declaration_parameters(
sge::renderer::vf::dynamic::make_format<vf::format>())));
sge::renderer::vertex::buffer_unique_ptr const vb(
sys.renderer_device_core().create_vertex_buffer(
sge::renderer::vertex::buffer_parameters(
*vertex_declaration,
sge::renderer::vf::dynamic::make_part_index<
vf::format,
vf::part
>(),
sge::renderer::vertex::count(
6u),
sge::renderer::resource_flags_field{
sge::renderer::resource_flags::readable})));
fcppt::io::cout()
<< FCPPT_TEXT("Done, now creating OpenCL buffer from it\n");
sge::opencl::memory_object::buffer cl_vb(
main_context,
*vb,
sge::opencl::memory_object::renderer_buffer_lock_mode::write_only);
main_kernel.argument(
sge::opencl::kernel::argument_index(
1u),
cl_vb);
main_kernel.argument(
sge::opencl::kernel::argument_index(
0u),
sge::opencl::kernel::numeric_type(
static_cast<cl_float>(
2.0
)
)
);
fcppt::io::cout()
<< FCPPT_TEXT("Done, now creating a command queue\n");
sge::opencl::command_queue::object main_queue(
device_refs[0].get(),
main_context,
sge::opencl::command_queue::execution_mode::out_of_order,
sge::opencl::command_queue::profiling_mode::disabled);
fcppt::io::cout()
<< FCPPT_TEXT("Done, now enqueueing kernel and running it\n");
{
sge::opencl::memory_object::scoped_objects scoped_vb(
main_queue,
sge::opencl::memory_object::base_ref_sequence{
fcppt::reference_to_base<
sge::opencl::memory_object::base
>(
fcppt::make_ref(
cl_vb
)
)
}
);
sge::opencl::command_queue::enqueue_kernel(
main_queue,
main_kernel,
sge::opencl::command_queue::global_dim1(
sge::opencl::dim1(
vb->linear_size()
* 2u
)
),
sge::opencl::command_queue::local_dim1(
sge::opencl::dim1(
2u
)
),
sge::opencl::event::sequence()
);
}
fcppt::io::cout()
<< FCPPT_TEXT("Now locking the vb for reading and printing the values\n");
{
sge::renderer::vertex::scoped_lock const scoped_vb(
*vb,
sge::renderer::lock_mode::readwrite);
typedef
sge::renderer::vf::view<vf::part>
vertex_view;
vertex_view const vertices(
scoped_vb.value());
for(
auto const vertex
:
vertices
)
{
fcppt::io::cout()
<< vertex.get<vf::scalar_quantity>()
<< FCPPT_TEXT('\n');
}
}
fcppt::io::cout()
<< FCPPT_TEXT("Done\n");
}
catch(
fcppt::exception const &_error
)
{
fcppt::io::cerr()
<< _error.string()
<< FCPPT_TEXT('\n');
return EXIT_FAILURE;
}
catch(
std::exception const &_error
)
{
std::cerr
<< _error.what()
<< '\n';
return EXIT_FAILURE;
}
