void
application_window::update(const gl::render_device_ptr& device,
const gl::render_context_ptr& context)
{
_camera_block->update(context, _viewer->main_camera());
unsigned* d = reinterpret_cast<unsigned*>(context->map_buffer(_atomic_counter, gl::ACCESS_WRITE_INVALIDATE_BUFFER));
if (d) {
*d = 0u;
}
context->unmap_buffer(_atomic_counter);
}
void
coordinate_cross::draw_overlay(
const gl::render_context_ptr& context,
const math::mat4f& proj_matrix,
const math::mat4f& view_matrix,
const float line_width)
{
using namespace scm;
using namespace scm::gl;
using namespace scm::math;
context_state_objects_guard csg(context);
context_program_guard cpg(context);
context_vertex_input_guard vig(context);
_coord_program->uniform("in_mvp", proj_matrix * view_matrix);
context->set_depth_stencil_state(_dstate_overlay);
context->set_blend_state(_no_blend);
context->set_rasterizer_state(_raster_no_cull, line_width);
context->bind_program(_coord_program);
context->bind_vertex_array(_vertex_array);
context->apply();
context->draw_arrays(_prim_topology, 0, _vertex_count);
}
void
volume_renderer::draw(const gl::render_context_ptr& context,
const volume_data_ptr& vdata,
const vr_mode mode) const
{
using namespace scm;
using namespace scm::gl;
using namespace scm::math;
switch (mode) {
case volume_raw:
_program->uniform_subroutine(STAGE_FRAGMENT_SHADER, "volume_color_lookup", "raw_lookup");
break;
case volume_color_map:
_program->uniform_subroutine(STAGE_FRAGMENT_SHADER, "volume_color_lookup", "raw_color_map_lookup");
break;
}
_program->uniform("volume_lod", vdata->selected_lod());
context_state_objects_guard csg(context);
context_texture_units_guard tug(context);
context_uniform_buffer_guard ubg(context);
context->reset_state_objects();
context->set_depth_stencil_state(_dstate);
context->set_blend_state(_bstate);
context->set_rasterizer_state(_rstate);
context->bind_uniform_buffer(_camera_block->block().block_buffer(), 0);
context->bind_uniform_buffer(vdata->volume_block().block_buffer(), 1);
context->bind_program(_program);
context->reset_texture_units();
#if SCM_TEXT_NV_BINDLESS_TEXTURES != 1
context->bind_texture(vdata->volume_raw(), _sstate_lin_mip, 0);
context->bind_texture(vdata->color_alpha_map(), _sstate_lin, 2);
#else
context->bind_texture(vdata->texture_handles(), _sstate_nearest, 4);
#endif SCM_TEXT_NV_BINDLESS_TEXTURES != 1
vdata->bbox_geometry()->draw(context, geometry::MODE_SOLID);
}
void
application_window::display(const gl::render_context_ptr& context)
{
using namespace scm::gl;
using namespace scm::math;
{ // image rendering pass
context_program_guard cpg(context);
context_state_objects_guard csg(context);
context_texture_units_guard ctg(context);
context_uniform_buffer_guard cug(context);
context_atomic_counter_buffer_guard acg(context);
context_image_units_guard cig(context);
_atomic_test_prog->uniform("screen_res", vec2f(_viewport_size));
context->bind_atomic_counter_buffer(_atomic_counter, 0);
context->bind_uniform_buffer(_camera_block->block().block_buffer(), 0);
context->bind_program(_atomic_test_prog);
context->set_rasterizer_state(_rstate_cback);
context->set_depth_stencil_state(_dstate_less);
context->set_blend_state(_bstate_off);
_model_geometry->draw_raw(context, geometry::MODE_SOLID);
}
}
void
application_window::display(const gl::render_context_ptr& context)
{
using namespace scm::gl;
using namespace scm::math;
const mat4f& view_matrix = _viewer->main_camera().view_matrix();
const mat4f& proj_matrix = _viewer->main_camera().projection_matrix();
{ // image rendering pass
context_state_objects_guard csg(context);
context_texture_units_guard tug(context);
context->set_depth_stencil_state(_dstate_less);
context->set_blend_state(_no_blend);
context->set_rasterizer_state(_cull_back_ms);
_readback_benchmark->draw(context);
}
{ // overlays
}
}
void
texture_output::draw_texture_2d_uint(const gl::render_context_ptr& context,
const gl::texture_2d_ptr& tex,
const math::vec4f& scale,
const math::vec2ui& position,
const math::vec2ui& extend) const
{
using namespace scm::gl;
using namespace scm::math;
context_state_objects_guard csg(context);
context_texture_units_guard tug(context);
context_framebuffer_guard fbg(context);
vec2ui tile_size = vec2ui(0);
float aspect = static_cast<float>(tex->descriptor()._size.x)
/ static_cast<float>(tex->descriptor()._size.y);
tile_size.x = extend.x;
tile_size.y = static_cast<unsigned>(tile_size.x / aspect);
if (tile_size.y > extend.y) {
tile_size.y = extend.y;
tile_size.x = static_cast<unsigned>(tile_size.y * aspect);
}
context->set_depth_stencil_state(_dstate_no_z_write);
context->set_blend_state(_bstate_no_blend);
context->set_rasterizer_state(_rstate_cull_back);
context->set_viewport(viewport(position, tile_size));
if (channel_count(tex->descriptor()._format) > 1) {
_fs_program_color_uint->uniform("in_scale", scale);
context->bind_program(_fs_program_color_uint);
}
else {
_fs_program_gray_uint->uniform("in_scale", scale);
context->bind_program(_fs_program_gray_uint);
}
context->bind_texture(tex, _filter_nearest, 0/*texture unit 0*/);
_quad_geom->draw(context, geometry::MODE_SOLID);
}
void
application_window::display_scene(const gl::render_context_ptr& context)
{
using namespace scm::gl;
using namespace scm::math;
const mat4f& view_matrix = _viewer->main_camera().view_matrix();
const mat4f& proj_matrix = _viewer->main_camera().projection_matrix();
{ // draw volumes
context_framebuffer_guard cfg(context);
//_coord_cross->draw(context, proj_matrix, view_matrix, 4.0f);
if (_volume_data) {
vec2f o = vec2f(0.0f, 0.0f);
vec2f s = vec2f(_viewport_size.x, _viewport_size.y);
context->set_viewport(viewport(o, s));
#if 1
mat4f mv_matrix = view_matrix * _volume_data->transform();
_volume_highlight->draw(context, _volume_data->bbox_geometry(),
proj_matrix, mv_matrix,
geometry::MODE_WIRE_FRAME, vec4f(0.0f, 1.0f, 0.3f, 1.0f), 2.0f);
#endif
if (_use_opencl_renderer) {
_volume_renderer_cuda->draw(context, _volume_data_cuda);
_volume_renderer_cuda->present(context);
}
else {
_volume_renderer->draw(context, _volume_data,
_show_raw ? volume_renderer::volume_raw : volume_renderer::volume_color_map,
_use_sample_shading, _use_volume_supersampling);
}
}
}
}
void
height_field_tessellator::draw(const gl::render_context_ptr& context,
const height_field_data_ptr& hf_data,
bool super_sample,
const mesh_mode hf_mesh_mode,
const draw_mode hf_draw_mode) const
{
using namespace scm::gl;
using namespace scm::math;
static float tessellation_factor = 1.2f;
static float tessellation_inc = 0.01f;
context_state_objects_guard csg(context);
context_program_guard cpg(context);
context_uniform_buffer_guard ubg(context);
context_texture_units_guard tug(context);
tessellation_factor += tessellation_inc;
if (tessellation_factor >= 32.0) tessellation_inc = -tessellation_inc;
if (tessellation_factor < 1.1) tessellation_inc = -tessellation_inc;
context->bind_uniform_buffer(_main_camera_block->block().block_buffer(), 0);
context->bind_texture(hf_data->height_map(), _sstate_linear_mip, 0);
context->bind_texture(hf_data->height_map(), _sstate_nearest, 1);
context->bind_texture(hf_data->density_map(), _sstate_nearest, 2);
context->bind_texture(hf_data->color_map(), _sstate_linear, 3);
context->set_depth_stencil_state(_dstate_less);
context->set_blend_state(_bstate_no_blend);
//context->set_blend_state(_bstate_omsa);
if (hf_draw_mode == MODE_SOLID) {
context->set_rasterizer_state(super_sample ? _rstate_ms_solid_ss : _rstate_ms_solid);
}
else if (hf_draw_mode == MODE_WIRE_FRAME) {
context->set_rasterizer_state(_rstate_ms_wire);
}
if (hf_mesh_mode == MODE_QUAD_PATCHES) {
_hf_quad_tessellation_program->uniform("tessellation_factor", 5.0f);//tessellation_factor);
_hf_quad_tessellation_program->uniform("model_matrix", hf_data->transform());
_hf_quad_tessellation_program->uniform("height_scale", hf_data->extends().z);
_hf_quad_tessellation_program->uniform("pixel_tolerance", _pixel_tolerance);
_hf_quad_tessellation_program->uniform("screen_size", vec2f(1920.0f, 1200.0f));
context->bind_program(_hf_quad_tessellation_program);
hf_data->patch_mesh()->draw(context, patch_grid_mesh::MODE_QUAD_PATCHES);
}
else if (hf_mesh_mode == MODE_TRIANGLE_PATCHES) {
_hf_triangle_tessellation_program->uniform("tessellation_factor", 5.0f);//tessellation_factor);
_hf_triangle_tessellation_program->uniform("model_matrix", hf_data->transform());
_hf_triangle_tessellation_program->uniform("height_scale", hf_data->extends().z);
_hf_triangle_tessellation_program->uniform("pixel_tolerance", _pixel_tolerance);
_hf_triangle_tessellation_program->uniform("screen_size", vec2f(1920.0f, 1200.0f));
context->bind_texture(hf_data->triangle_edge_density_buffer(), _sstate_nearest, 4);
context->bind_program(_hf_triangle_tessellation_program);
hf_data->patch_mesh()->draw(context, patch_grid_mesh::MODE_TRIANGLE_PATCHES);
}
else {
err() << log::warning << "height_field_tessellator::draw(): unknown mesh mode." << log::end;
}
}