mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-22 11:29:54 +01:00
Record the opaque scene once and replay it for the depth prepass and the colour pass
This commit is contained in:
@@ -279,6 +279,7 @@ view; the shadow maps of lamps and headlights, the cab and other views go as bef
|
|||||||
| `gfx.gpucull.reflections yes/no` | `yes` | with `gfx.gpucull yes` or `compare`: the models of the faces of the environment map too (its own range of models, as before) |
|
| `gfx.gpucull.reflections yes/no` | `yes` | with `gfx.gpucull yes` or `compare`: the models of the faces of the environment map too (its own range of models, as before) |
|
||||||
| `gfx.gpucull.sleepers yes/no` | `yes` | with `gfx.gpucull yes` or `compare`: the sleepers of the tracks (`sleepermodel`) of the main view too, each one tested against the view and given its level of detail by its distance, as before (the tracks within `sleeperdistance` are chosen as before); they also take the occlusion test, the depth prepass and the two phases of the models |
|
| `gfx.gpucull.sleepers yes/no` | `yes` | with `gfx.gpucull yes` or `compare`: the sleepers of the tracks (`sleepermodel`) of the main view too, each one tested against the view and given its level of detail by its distance, as before (the tracks within `sleeperdistance` are chosen as before); they also take the occlusion test, the depth prepass and the two phases of the models |
|
||||||
| `gfx.depthprepass.scene yes/no` | `no` | the depth of the whole opaque scene of the main view (terrain, tracks, buildings, models, vehicles, the cab) is drawn before its colour, see below |
|
| `gfx.depthprepass.scene yes/no` | `no` | the depth of the whole opaque scene of the main view (terrain, tracks, buildings, models, vehicles, the cab) is drawn before its colour, see below |
|
||||||
|
| `gfx.depthprepass.replay yes/no` | `yes` | the scene is gone through once for its depth and its colour: what the colour pass draws is recorded and both are drawn from the record, see below. `no`: twice, as before |
|
||||||
|
|
||||||
With `gfx.gpucull.occlusion.instances yes` the test goes in two phases: the models seen in the previous frame are drawn
|
With `gfx.gpucull.occlusion.instances yes` the test goes in two phases: the models seen in the previous frame are drawn
|
||||||
first (their depth, or their colour without the depth prepass), the depth they leave is added to what the others are tested
|
first (their depth, or their colour without the depth prepass), the depth they leave is added to what the others are tested
|
||||||
@@ -316,6 +317,19 @@ walk and drawn from the same result in the second. The picture is the same eithe
|
|||||||
drawn last, after the precipitation) the cab isn't in the depth pass. Can be changed while the simulator runs, in the
|
drawn last, after the precipitation) the cab isn't in the depth pass. Can be changed while the simulator runs, in the
|
||||||
**Instance culling** debug window.
|
**Instance culling** debug window.
|
||||||
|
|
||||||
|
With `gfx.depthprepass.replay yes` (the default) the scene isn't gone through twice: the walk of the colour pass is made
|
||||||
|
once, in the depth pass, and every opaque draw it would make is recorded with what it needs (the data of the model part, the
|
||||||
|
material and its texture variant, the light of tunnels and of the cab). The depth is drawn from the record in runs of the
|
||||||
|
same kind (with or without the alpha test, the texture of the test, the model or section the geometry is kept in), each run
|
||||||
|
with one multi draw, and the colour pass then draws the record in the order of the walk, with the programs of the materials.
|
||||||
|
The depth is drawn before the depth pyramid of the occlusion test of the models (`gfx.gpucull.occlusion`) and before the
|
||||||
|
cursor of the editor reads the ground, so they see the same as before. When the depth pass is there only for the contact
|
||||||
|
shadows (`gfx.depthprepass.scene no`), the parts lying whole farther than the reach of the contact shadows
|
||||||
|
(`gfx.contactshadows.range` and a little more) are left out of it and only drawn in colour, as they would be without the depth
|
||||||
|
pass; the copies of models drawn from the GPU always have their depth drawn. With fewer parts in the depth the occlusion test
|
||||||
|
of the models has less to hide them behind past that reach. In the editor the whole depth is drawn. The picture is the same
|
||||||
|
either way; `no` walks the scene twice, as before, for comparison.
|
||||||
|
|
||||||
### Model data of the draws
|
### Model data of the draws
|
||||||
|
|
||||||
Before every draw the renderer hands the graphics card the data of the drawn part of the model (its position in the view, its
|
Before every draw the renderer hands the graphics card the data of the drawn part of the model (its position in the view, its
|
||||||
@@ -394,7 +408,10 @@ editor goes through the first `dynamiclights` headlights, the reflections throug
|
|||||||
`instance cull shadows 1:` … and `instance cull reflections, last face:`. With `gfx.gpucull.sleepers` the row
|
`instance cull shadows 1:` … and `instance cull reflections, last face:`. With `gfx.gpucull.sleepers` the row
|
||||||
`gpu cull:` is followed by how many sleepers of how many tracks were queued (they are counted among the models).
|
`gpu cull:` is followed by how many sleepers of how many tracks were queued (they are counted among the models).
|
||||||
- With `gfx.depthprepass.scene yes` Shift+F12 shows the `scene depth:` row (draws of the depth pass and its processor time)
|
- With `gfx.depthprepass.scene yes` Shift+F12 shows the `scene depth:` row (draws of the depth pass and its processor time)
|
||||||
and the timing `scene depth:` (its GPU time).
|
and the timing `scene depth:` (its GPU time). With `gfx.depthprepass.replay yes` the row tells how many of the recorded
|
||||||
|
parts (of models, of the scenery; neighbouring tracks count one by one) had their depth drawn, in how many calls, how many
|
||||||
|
were left beyond the reach of the contact shadows, and the processor time of the depth pass, which holds the walk of the
|
||||||
|
colour pass now (the `color:` time is the one to compare).
|
||||||
- With `gfx.contactshadows` on Shift+F12 shows the `contact shadows:` row (the level, the length and reach of the rays, or
|
- With `gfx.contactshadows` on Shift+F12 shows the `contact shadows:` row (the level, the length and reach of the rays, or
|
||||||
`off in this view`), the `scene depth:` row and timing of the depth pass they turn on, and the timing `contact shadows depth:`
|
`off in this view`), the `scene depth:` row and timing of the depth pass they turn on, and the timing `contact shadows depth:`
|
||||||
(copying the depth for them). The rays themselves are part of the shading of the colour pass: their cost shows as the
|
(copying the depth for them). The rays themselves are part of the shading of the colour pass: their cost shows as the
|
||||||
|
|||||||
@@ -42,6 +42,11 @@ gl::frame_stream::~frame_stream()
|
|||||||
{
|
{
|
||||||
release(slot);
|
release(slot);
|
||||||
}
|
}
|
||||||
|
for (auto &retired : m_retired)
|
||||||
|
{
|
||||||
|
if (!retired.empty())
|
||||||
|
glDeleteBuffers(static_cast<GLsizei>(retired.size()), retired.data());
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void gl::frame_stream::create(slot &Slot, GLsizeiptr Size)
|
void gl::frame_stream::create(slot &Slot, GLsizeiptr Size)
|
||||||
@@ -125,6 +130,13 @@ void gl::frame_stream::next_frame()
|
|||||||
}
|
}
|
||||||
m_slot = (m_slot + 1) % FRAMES;
|
m_slot = (m_slot + 1) % FRAMES;
|
||||||
wait(m_slots[m_slot]);
|
wait(m_slots[m_slot]);
|
||||||
|
// the buffers this slot outgrew in its last frame, which the gpu is done with now
|
||||||
|
auto &retired{m_retired[m_slot]};
|
||||||
|
if (!retired.empty())
|
||||||
|
{
|
||||||
|
glDeleteBuffers(static_cast<GLsizei>(retired.size()), retired.data());
|
||||||
|
retired.clear();
|
||||||
|
}
|
||||||
m_fill = m_start;
|
m_fill = m_start;
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -139,8 +151,12 @@ GLintptr gl::frame_stream::push(void const *Data, GLsizeiptr Size)
|
|||||||
if (size > current->size)
|
if (size > current->size)
|
||||||
{
|
{
|
||||||
// a bigger buffer for the rest of the frame, starting after its header again. the fence of the slot (if any) was
|
// a bigger buffer for the rest of the frame, starting after its header again. the fence of the slot (if any) was
|
||||||
// waited for when the frame took the slot over, the old buffer is only read by the draws of this frame
|
// waited for when the frame took the slot over, the old buffer is only read by this frame, which may still bind it
|
||||||
release(*current);
|
// for what it wrote there (a recorded draw drawn later), so it's kept, mapped, until the slot is taken over again
|
||||||
|
m_retired[m_slot].push_back(current->buffer);
|
||||||
|
current->buffer = 0;
|
||||||
|
current->data = nullptr;
|
||||||
|
current->size = 0;
|
||||||
create(*current, size);
|
create(*current, size);
|
||||||
++m_grows;
|
++m_grows;
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -31,8 +31,8 @@ namespace gl
|
|||||||
// ends the frame: what was written so far goes with its fence, the next frame writes to the next buffer
|
// ends the frame: what was written so far goes with its fence, the next frame writes to the next buffer
|
||||||
void next_frame();
|
void next_frame();
|
||||||
// appends Size bytes to the buffer of the frame and returns their offset. may replace the buffer of the frame with a
|
// appends Size bytes to the buffer of the frame and returns their offset. may replace the buffer of the frame with a
|
||||||
// bigger one (generation() changes, buffer() tells which to bind); the draws issued before keep the old one until the
|
// bigger one (generation() changes, buffer() tells which to bind); the old one stays until the frame is done with, so
|
||||||
// gpu is done with them
|
// what was written to it can still be bound and drawn from later in the frame
|
||||||
GLintptr push(void const *Data, GLsizeiptr Size);
|
GLintptr push(void const *Data, GLsizeiptr Size);
|
||||||
|
|
||||||
GLuint buffer() const
|
GLuint buffer() const
|
||||||
@@ -83,6 +83,8 @@ namespace gl
|
|||||||
void wait(slot &Slot);
|
void wait(slot &Slot);
|
||||||
|
|
||||||
std::array<slot, FRAMES> m_slots;
|
std::array<slot, FRAMES> m_slots;
|
||||||
|
// buffers of the slots replaced by bigger ones in their frame, deleted when the slot is taken over again
|
||||||
|
std::array<std::vector<GLuint>, FRAMES> m_retired;
|
||||||
std::size_t m_slot = 0;
|
std::size_t m_slot = 0;
|
||||||
GLsizeiptr m_alignment;
|
GLsizeiptr m_alignment;
|
||||||
bool m_mapped; // buffers made from now on are mapped
|
bool m_mapped; // buffers made from now on are mapped
|
||||||
|
|||||||
@@ -214,6 +214,9 @@ bool opengl46_renderer::Init(GLFWwindow *Window)
|
|||||||
m_alpha_shadow_multidraw_shader = std::make_unique<gl::program>(std::vector<std::reference_wrapper<const gl::shader>>{shadowvertex, alphashadowfragment});
|
m_alpha_shadow_multidraw_shader = std::make_unique<gl::program>(std::vector<std::reference_wrapper<const gl::shader>>{shadowvertex, alphashadowfragment});
|
||||||
m_drawblockstream = std::make_unique<gl::frame_stream>(
|
m_drawblockstream = std::make_unique<gl::frame_stream>(
|
||||||
static_cast<GLsizeiptr>(4096 * sizeof(gl::model_ubs)), static_cast<GLsizeiptr>(sizeof(gl::model_ubs)), Global.gfx_bufferstreaming);
|
static_cast<GLsizeiptr>(4096 * sizeof(gl::model_ubs)), static_cast<GLsizeiptr>(sizeof(gl::model_ubs)), Global.gfx_bufferstreaming);
|
||||||
|
// and the commands of the multi draws of the recorded depth pass of the scene (Render_Scene_Prepass())
|
||||||
|
m_scenecommandstream = std::make_unique<gl::frame_stream>(
|
||||||
|
static_cast<GLsizeiptr>(4096 * sizeof(gl::instance_draw_command)), static_cast<GLsizeiptr>(sizeof(gl::instance_draw_command)), Global.gfx_bufferstreaming);
|
||||||
}
|
}
|
||||||
catch (gl::shader_exception const &e)
|
catch (gl::shader_exception const &e)
|
||||||
{
|
{
|
||||||
@@ -224,6 +227,7 @@ bool opengl46_renderer::Init(GLFWwindow *Window)
|
|||||||
m_shadow_multidraw_shader.reset();
|
m_shadow_multidraw_shader.reset();
|
||||||
m_alpha_shadow_multidraw_shader.reset();
|
m_alpha_shadow_multidraw_shader.reset();
|
||||||
m_drawblockstream.reset();
|
m_drawblockstream.reset();
|
||||||
|
m_scenecommandstream.reset();
|
||||||
}
|
}
|
||||||
|
|
||||||
try
|
try
|
||||||
@@ -712,6 +716,8 @@ bool opengl46_renderer::Render()
|
|||||||
model_ubo->next_frame();
|
model_ubo->next_frame();
|
||||||
if (m_drawblockstream)
|
if (m_drawblockstream)
|
||||||
m_drawblockstream->next_frame();
|
m_drawblockstream->next_frame();
|
||||||
|
if (m_scenecommandstream)
|
||||||
|
m_scenecommandstream->next_frame();
|
||||||
|
|
||||||
m_renderpass.draw_mode = rendermode::none; // force setup anew
|
m_renderpass.draw_mode = rendermode::none; // force setup anew
|
||||||
m_renderpass.draw_stats = debug_stats();
|
m_renderpass.draw_stats = debug_stats();
|
||||||
@@ -851,7 +857,12 @@ void opengl46_renderer::SwapBuffers()
|
|||||||
+ " =" + to_string( m_colorpass.draw_stats.instances + shadowstats.instances, 7 )
|
+ " =" + to_string( m_colorpass.draw_stats.instances + shadowstats.instances, 7 )
|
||||||
+ " (" + std::to_string( m_colorpass.draw_stats.instanced_drawcalls + shadowstats.instanced_drawcalls ) + " batches)\n"
|
+ " (" + std::to_string( m_colorpass.draw_stats.instanced_drawcalls + shadowstats.instanced_drawcalls ) + " batches)\n"
|
||||||
+ ( ( Global.gfx_depthprepass_scene || m_contactshadowslast ) ?
|
+ ( ( Global.gfx_depthprepass_scene || m_contactshadowslast ) ?
|
||||||
" scene depth: " + std::to_string( m_scenedepthstats.drawcalls ) + " draws, cpu " + to_string( m_scenedepthcputime, 2 ) + " ms\n" :
|
( m_scenereplayed ?
|
||||||
|
" scene depth: " + std::to_string( m_sceneprepassdraws ) + " of " + std::to_string( m_scenerecordedparts ) + " recorded parts in "
|
||||||
|
+ std::to_string( m_sceneprepasscalls ) + " calls"
|
||||||
|
+ ( m_scenebeyondreach > 0 ? ", " + std::to_string( m_scenebeyondreach ) + " beyond the contact shadows" : std::string{} )
|
||||||
|
+ ", cpu " + to_string( m_scenedepthcputime, 2 ) + " ms with the walk of the colour pass\n" :
|
||||||
|
" scene depth: " + std::to_string( m_scenedepthstats.drawcalls ) + " draws, cpu " + to_string( m_scenedepthcputime, 2 ) + " ms\n" ) :
|
||||||
std::string{} )
|
std::string{} )
|
||||||
+ ( Global.gfx_contactshadows > 0 ?
|
+ ( Global.gfx_contactshadows > 0 ?
|
||||||
" contact shadows: " + std::string{ Global.gfx_contactshadows == 3 ? "high" : Global.gfx_contactshadows == 2 ? "medium" : "low" }
|
" contact shadows: " + std::string{ Global.gfx_contactshadows == 3 ? "high" : Global.gfx_contactshadows == 2 ? "medium" : "low" }
|
||||||
@@ -1014,6 +1025,7 @@ void opengl46_renderer::draw_debug_ui()
|
|||||||
ImGui::Checkbox("draw the depth of the whole scene before its colour (gfx.depthprepass.scene)", &Global.gfx_depthprepass_scene);
|
ImGui::Checkbox("draw the depth of the whole scene before its colour (gfx.depthprepass.scene)", &Global.gfx_depthprepass_scene);
|
||||||
if (Global.gfx_contactshadows > 0)
|
if (Global.gfx_contactshadows > 0)
|
||||||
ImGui::TextUnformatted("(drawn anyway for the contact shadows, gfx.contactshadows)");
|
ImGui::TextUnformatted("(drawn anyway for the contact shadows, gfx.contactshadows)");
|
||||||
|
ImGui::Checkbox("walk the scene once for its depth and colour, drawing both from a record (gfx.depthprepass.replay)", &Global.gfx_depthprepass_replay);
|
||||||
auto info{m_instancecull.info()};
|
auto info{m_instancecull.info()};
|
||||||
if (Global.gfx_gpucull_shadows)
|
if (Global.gfx_gpucull_shadows)
|
||||||
{
|
{
|
||||||
@@ -1279,12 +1291,13 @@ void opengl46_renderer::Render_pass(viewport_config &vp, rendermode const Mode)
|
|||||||
// the depth of the whole opaque scene before its colour, which the contact shadows need
|
// the depth of the whole opaque scene before its colour, which the contact shadows need
|
||||||
m_scenedepthdrawn = false;
|
m_scenedepthdrawn = false;
|
||||||
m_indirectcolourpending = false;
|
m_indirectcolourpending = false;
|
||||||
|
m_scenerecorded = false;
|
||||||
auto const contactshadows{Contact_Shadows_Wanted(vp)};
|
auto const contactshadows{Contact_Shadows_Wanted(vp)};
|
||||||
if ((Global.gfx_depthprepass_scene || contactshadows) && vp.main && (false == Global.bWireFrame))
|
if ((Global.gfx_depthprepass_scene || contactshadows) && vp.main && (false == Global.bWireFrame))
|
||||||
{
|
{
|
||||||
glDebug("render scene depth");
|
glDebug("render scene depth");
|
||||||
gpupart("scene depth");
|
gpupart("scene depth");
|
||||||
Render_Scene_Depth(future);
|
Render_Scene_Depth(future, contactshadows && (false == Global.gfx_depthprepass_scene));
|
||||||
if (contactshadows)
|
if (contactshadows)
|
||||||
{
|
{
|
||||||
gpupart("contact shadows depth");
|
gpupart("contact shadows depth");
|
||||||
@@ -1298,27 +1311,37 @@ void opengl46_renderer::Render_pass(viewport_config &vp, rendermode const Mode)
|
|||||||
gpupart("colour, opaque");
|
gpupart("colour, opaque");
|
||||||
setup_drawing(false);
|
setup_drawing(false);
|
||||||
|
|
||||||
// without rain/snow we can render the cab early to limit the overdraw
|
if (m_scenerecorded)
|
||||||
// precipitation happens when overcast is in 1-2 range
|
|
||||||
if (!FreeFlyModeFlag && Global.Overcast <= 1.0f && Global.render_cab)
|
|
||||||
{
|
{
|
||||||
glDebug("render opaque cab");
|
// the depth pass walked the scene for this pass, which draws what it recorded (the cab drawn early included)
|
||||||
model_ubs.future = glm::mat4();
|
glDebug("render recorded opaque scene");
|
||||||
auto const *vehicle{ simulation::Train->Dynamic() };
|
Render_Scene_Colour();
|
||||||
// the lamp lighting the shadows of the sun, unless it is a light of its own
|
m_scenerecorded = false;
|
||||||
if( ( vehicle->InteriorLightLevel > 0.f ) && ( false == m_cablamplit ) ) {
|
|
||||||
setup_shadow_color( glm::min( colors::white, m_shadowcolor + glm::vec4( vehicle->InteriorLight * vehicle->InteriorLightLevel, 1.f ) ) );
|
|
||||||
}
|
|
||||||
Render_cab( vehicle, vehicle->InteriorLightLevel, false );
|
|
||||||
}
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// without rain/snow we can render the cab early to limit the overdraw
|
||||||
|
// precipitation happens when overcast is in 1-2 range
|
||||||
|
if (!FreeFlyModeFlag && Global.Overcast <= 1.0f && Global.render_cab)
|
||||||
|
{
|
||||||
|
glDebug("render opaque cab");
|
||||||
|
model_ubs.future = glm::mat4();
|
||||||
|
auto const *vehicle{ simulation::Train->Dynamic() };
|
||||||
|
// the lamp lighting the shadows of the sun, unless it is a light of its own
|
||||||
|
if( ( vehicle->InteriorLightLevel > 0.f ) && ( false == m_cablamplit ) ) {
|
||||||
|
setup_shadow_color( glm::min( colors::white, m_shadowcolor + glm::vec4( vehicle->InteriorLight * vehicle->InteriorLightLevel, 1.f ) ) );
|
||||||
|
}
|
||||||
|
Render_cab( vehicle, vehicle->InteriorLightLevel, false );
|
||||||
|
}
|
||||||
|
|
||||||
setup_shadow_color( m_shadowcolor );
|
setup_shadow_color( m_shadowcolor );
|
||||||
|
|
||||||
glDebug("render opaque region");
|
glDebug("render opaque region");
|
||||||
|
|
||||||
model_ubs.future = future;
|
model_ubs.future = future;
|
||||||
|
|
||||||
Render(simulation::Region);
|
Render(simulation::Region);
|
||||||
|
}
|
||||||
m_scenedepthdrawn = false;
|
m_scenedepthdrawn = false;
|
||||||
m_indirectcolourpending = false;
|
m_indirectcolourpending = false;
|
||||||
|
|
||||||
@@ -2327,6 +2350,13 @@ void opengl46_renderer::setup_sunlight_intensity( float const Factor ) {
|
|||||||
// the header of the light buffer and the sun in its first slot. the headlights are written once per pass by Update_Lights()
|
// the header of the light buffer and the sun in its first slot. the headlights are written once per pass by Update_Lights()
|
||||||
void opengl46_renderer::upload_light_header()
|
void opengl46_renderer::upload_light_header()
|
||||||
{
|
{
|
||||||
|
if( m_scenerecording ) {
|
||||||
|
// the recorded walk of Render_Scene_Depth() draws nothing lit: the draws which follow go with this header, uploaded
|
||||||
|
// when the colour pass draws them
|
||||||
|
auto &header { m_sceneheaders.emplace_back() };
|
||||||
|
std::memcpy( header.data(), &light_data, header.size() );
|
||||||
|
return;
|
||||||
|
}
|
||||||
light_ssbo->update( &light_data, 0, offsetof( gl::light_data, lights ) + sizeof( gl::light_element ) );
|
light_ssbo->update( &light_data, 0, offsetof( gl::light_data, lights ) + sizeof( gl::light_element ) );
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -2568,6 +2598,7 @@ bool opengl46_renderer::Replace(gfx::vertex_array &Vertices, gfx::userdata_array
|
|||||||
{
|
{
|
||||||
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
|
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
|
||||||
|
|
||||||
|
m_chunkspheres.erase(static_cast<std::uint64_t>(Geometry));
|
||||||
return m_geometry.replace(Vertices, Userdata, Geometry, Offset);
|
return m_geometry.replace(Vertices, Userdata, Geometry, Offset);
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -2576,6 +2607,7 @@ bool opengl46_renderer::Append(gfx::vertex_array &Vertices, gfx::userdata_array
|
|||||||
{
|
{
|
||||||
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
|
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
|
||||||
|
|
||||||
|
m_chunkspheres.erase(static_cast<std::uint64_t>(Geometry));
|
||||||
return m_geometry.append(Vertices, Userdata, Geometry);
|
return m_geometry.append(Vertices, Userdata, Geometry);
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -2736,6 +2768,15 @@ void opengl46_renderer::Bind_Material( material_handle const Material, TSubModel
|
|||||||
m_indirectsubmodel = sm;
|
m_indirectsubmodel = sm;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
if (m_scenerecording)
|
||||||
|
{
|
||||||
|
// the recorded walk of Render_Scene_Depth(): the draws which follow are made with this material, bound later
|
||||||
|
m_scenematerial = Material;
|
||||||
|
m_scenesubmodel = sm;
|
||||||
|
m_sceneseed = TSubModel::iVariantSeed;
|
||||||
|
m_scenevariant = (material.texture_variants.empty() ? 0 : TSubModel::VariantId(sm));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
// materials which declare texture variants provide a different texture set per model instance,
|
// materials which declare texture variants provide a different texture set per model instance,
|
||||||
// picked from the seed of the rendered instance and the variant group of the submodel
|
// picked from the seed of the rendered instance and the variant group of the submodel
|
||||||
@@ -3010,6 +3051,11 @@ void opengl46_renderer::Render(scene::basic_region *Region)
|
|||||||
// when editor mode is active calculate world position of the cursor
|
// when editor mode is active calculate world position of the cursor
|
||||||
// at this stage the z-buffer is filled with only ground geometry
|
// at this stage the z-buffer is filled with only ground geometry
|
||||||
// (with the depth pass of the whole scene it's done there, at the same stage)
|
// (with the depth pass of the whole scene it's done there, at the same stage)
|
||||||
|
if (m_scenerecording)
|
||||||
|
{
|
||||||
|
// the depth of what the walk recorded so far
|
||||||
|
Render_Scene_Prepass();
|
||||||
|
}
|
||||||
Update_Mouse_Position();
|
Update_Mouse_Position();
|
||||||
}
|
}
|
||||||
// draw opaque cells front-to-back: with the depth test enabled this
|
// draw opaque cells front-to-back: with the depth test enabled this
|
||||||
@@ -3405,25 +3451,7 @@ void opengl46_renderer::Render(cell_sequence::iterator First, cell_sequence::ite
|
|||||||
// (For pickscenery/pickcontrols modes the map stays empty, so this is a no-op.)
|
// (For pickscenery/pickcontrols modes the map stays empty, so this is a no-op.)
|
||||||
if( m_indirectcolourpending ) {
|
if( m_indirectcolourpending ) {
|
||||||
// the instances culled and recorded by the depth pass of the whole scene, the buckets weren't queued for the cpu
|
// the instances culled and recorded by the depth pass of the whole scene, the buckets weren't queued for the cpu
|
||||||
m_indirectcolourpending = false;
|
Render_Instances_Indirect_Pending();
|
||||||
indirect_counts colourcounts;
|
|
||||||
if( false == m_indirectdraws.empty() ) {
|
|
||||||
auto const cpustart { std::chrono::steady_clock::now() };
|
|
||||||
m_indirectcull = &m_instancecull;
|
|
||||||
m_instancecull.bind_draw();
|
|
||||||
colourcounts = Render_Instances_Indirect_Colour( m_indirectcolourset );
|
|
||||||
::glBindBuffer( GL_DRAW_INDIRECT_BUFFER, 0 );
|
|
||||||
Bind_Instance_Stream();
|
|
||||||
m_instancecull.draw_result(
|
|
||||||
colourcounts.draws,
|
|
||||||
m_instancecull.prepass_draws(),
|
|
||||||
colourcounts.calls,
|
|
||||||
m_instancecull.prepass_calls(),
|
|
||||||
m_instancecull.cpu_time() + std::chrono::duration<double, std::milli>( std::chrono::steady_clock::now() - cpustart ).count() );
|
|
||||||
}
|
|
||||||
m_renderpass.draw_stats.instanced_drawcalls += static_cast<int>( colourcounts.calls );
|
|
||||||
m_renderpass.draw_stats.instances += static_cast<int>( m_instancecull.last_count() );
|
|
||||||
m_renderpass.draw_stats.models += static_cast<int>( m_instancecull.last_count() );
|
|
||||||
}
|
}
|
||||||
if( m_instancecullpass ) {
|
if( m_instancecullpass ) {
|
||||||
if( m_passcull->drawing() ) {
|
if( m_passcull->drawing() ) {
|
||||||
@@ -3492,6 +3520,11 @@ void opengl46_renderer::draw(const gfx::geometry_handle &handle)
|
|||||||
}
|
}
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
if( m_scenerecording ) {
|
||||||
|
// the recorded walk of Render_Scene_Depth(): the depth pass and the colour pass draw it later, with this state
|
||||||
|
Record_Scene_Draw( &handle, 1, false );
|
||||||
|
return;
|
||||||
|
}
|
||||||
if( m_scenedepthpass && ( false == Scene_Depth_Draws( handle ) ) ) {
|
if( m_scenedepthpass && ( false == Scene_Depth_Draws( handle ) ) ) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
@@ -3510,6 +3543,12 @@ void opengl46_renderer::draw(const gfx::geometry_handle &handle)
|
|||||||
void opengl46_renderer::draw(std::vector<gfx::geometrybank_handle>::iterator it, std::vector<gfx::geometrybank_handle>::iterator end)
|
void opengl46_renderer::draw(std::vector<gfx::geometrybank_handle>::iterator it, std::vector<gfx::geometrybank_handle>::iterator end)
|
||||||
{
|
{
|
||||||
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
|
model_ubs.set_modelview(OpenGLMatrices.data(GL_MODELVIEW));
|
||||||
|
if( m_scenerecording ) {
|
||||||
|
if( it != end ) {
|
||||||
|
Record_Scene_Draw( &( *it ), static_cast<std::size_t>( std::distance( it, end ) ), true );
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
if( m_scenedepthpass && ( ( it == end ) || ( false == Scene_Depth_Draws( *it ) ) ) ) {
|
if( m_scenedepthpass && ( ( it == end ) || ( false == Scene_Depth_Draws( *it ) ) ) ) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
@@ -4045,6 +4084,11 @@ void opengl46_renderer::Render_Instances_Indirect()
|
|||||||
auto const cpustart { std::chrono::steady_clock::now() };
|
auto const cpustart { std::chrono::steady_clock::now() };
|
||||||
auto *viewport { m_current_viewport };
|
auto *viewport { m_current_viewport };
|
||||||
|
|
||||||
|
if( m_scenerecording ) {
|
||||||
|
// the depth of what the recorded walk of the depth pass of the scene went through so far, for the occlusion test
|
||||||
|
// and for the depth of the instances to be tested against
|
||||||
|
Render_Scene_Prepass();
|
||||||
|
}
|
||||||
// occlusion test against the depth drawn so far in the pass: cab, terrain, shapes, tracks, vehicles, other models
|
// occlusion test against the depth drawn so far in the pass: cab, terrain, shapes, tracks, vehicles, other models
|
||||||
opengl46_instance_cull::occlusion_setup occlusion;
|
opengl46_instance_cull::occlusion_setup occlusion;
|
||||||
auto const useocclusion {
|
auto const useocclusion {
|
||||||
@@ -4114,6 +4158,12 @@ void opengl46_renderer::Render_Instances_Indirect()
|
|||||||
m_indirectcolourpending = true;
|
m_indirectcolourpending = true;
|
||||||
m_indirectcolourset = colourset;
|
m_indirectcolourset = colourset;
|
||||||
m_indirectcoloursleepers = m_sleeperspass;
|
m_indirectcoloursleepers = m_sleeperspass;
|
||||||
|
if( m_scenerecording ) {
|
||||||
|
// where the colour pass, which draws the record, draws them, in the light the walk had here
|
||||||
|
auto &marker { m_scenedraws.emplace_back() };
|
||||||
|
marker.instances = true;
|
||||||
|
marker.header = static_cast<std::uint32_t>( m_sceneheaders.size() - 1 );
|
||||||
|
}
|
||||||
m_renderpass.draw_stats.drawcalls += static_cast<int>( prepasscounts.calls );
|
m_renderpass.draw_stats.drawcalls += static_cast<int>( prepasscounts.calls );
|
||||||
colourcounts.draws = static_cast<std::uint32_t>( m_indirectdraws.size() );
|
colourcounts.draws = static_cast<std::uint32_t>( m_indirectdraws.size() );
|
||||||
}
|
}
|
||||||
@@ -4647,7 +4697,7 @@ gl::program *opengl46_renderer::Multidraw_Program( gl::program const *Program )
|
|||||||
// them (Bind_Material(), draw()), with the depth a little farther than the surface like the prepass of the instances, so the
|
// them (Bind_Material(), draw()), with the depth a little farther than the surface like the prepass of the instances, so the
|
||||||
// colour pass, which tests and writes its depth as usual, passes where it's the same surface. the gpu culling of the
|
// colour pass, which tests and writes its depth as usual, passes where it's the same surface. the gpu culling of the
|
||||||
// instances runs here, against the same depth as without this pass, and the colour pass draws what it recorded
|
// instances runs here, against the same depth as without this pass, and the colour pass draws what it recorded
|
||||||
void opengl46_renderer::Render_Scene_Depth( glm::mat4 const &Future )
|
void opengl46_renderer::Render_Scene_Depth( glm::mat4 const &Future, bool const Contactonly )
|
||||||
{
|
{
|
||||||
auto const cpustart { std::chrono::steady_clock::now() };
|
auto const cpustart { std::chrono::steady_clock::now() };
|
||||||
m_scenedepthtimer.begin();
|
m_scenedepthtimer.begin();
|
||||||
@@ -4661,14 +4711,63 @@ void opengl46_renderer::Render_Scene_Depth( glm::mat4 const &Future )
|
|||||||
::glEnable( GL_POLYGON_OFFSET_FILL );
|
::glEnable( GL_POLYGON_OFFSET_FILL );
|
||||||
::glPolygonOffset( -1.f, -1.f );
|
::glPolygonOffset( -1.f, -1.f );
|
||||||
|
|
||||||
// the conditions of the cab drawn early by the colour pass
|
m_scenereplayed = Global.gfx_depthprepass_replay;
|
||||||
if( ( false == FreeFlyModeFlag ) && ( Global.Overcast <= 1.0f ) && ( Global.render_cab ) ) {
|
if( m_scenereplayed ) {
|
||||||
model_ubs.future = glm::mat4();
|
// the walk of the colour pass, recorded: the same steps as in Render_pass(), the shadow tone of the cab lamp included
|
||||||
auto const *vehicle { simulation::Train->Dynamic() };
|
m_scenerecording = true;
|
||||||
Render_cab( vehicle, vehicle->InteriorLightLevel, false );
|
m_scenedraws.clear();
|
||||||
|
m_scenechunks.clear();
|
||||||
|
m_scenegeometry.clear();
|
||||||
|
m_sceneheaders.clear();
|
||||||
|
std::memcpy( m_sceneheaders.emplace_back().data(), &light_data, std::tuple_size_v<light_header> );
|
||||||
|
m_sceneflushed = 0;
|
||||||
|
m_scenematerial = null_handle;
|
||||||
|
m_scenesubmodel = nullptr;
|
||||||
|
m_sceneseed = TSubModel::iVariantSeed;
|
||||||
|
m_scenevariant = 0;
|
||||||
|
m_sceneprepassdraws = 0;
|
||||||
|
m_sceneprepasscalls = 0;
|
||||||
|
m_scenebeyondreach = 0;
|
||||||
|
// the contact shadows alone need the depth only within their reach: a ray of a pixel there runs up to their length
|
||||||
|
// towards the light, and a surface counts as in its way up to 0.3 m and 4 pixels behind it (see contact_shadow()).
|
||||||
|
// past that the colour pass draws with no depth before it, as without the depth pass. the cursor of the editor reads
|
||||||
|
// the depth of the ground anywhere
|
||||||
|
m_scenedepthreach = ( Contactonly && ( false == EditorModeFlag ) );
|
||||||
|
if( m_scenedepthreach ) {
|
||||||
|
auto const reach { Global.gfx_contactshadows_range + Global.gfx_contactshadows_length };
|
||||||
|
auto const scale { scene_ubs.projection[ 1 ][ 1 ] };
|
||||||
|
auto const height { ( m_current_viewport != nullptr ? m_current_viewport->height : Global.gfx_framebuffer_height ) };
|
||||||
|
auto const pixel { ( ( scale > 0.f ) && ( height > 0 ) ) ? 2.f * reach / ( scale * static_cast<float>( height ) ) : reach };
|
||||||
|
m_scenedepthlimit = reach + 0.3f + 4.f * pixel + 1.f;
|
||||||
|
}
|
||||||
|
|
||||||
|
if( ( false == FreeFlyModeFlag ) && ( Global.Overcast <= 1.0f ) && ( Global.render_cab ) ) {
|
||||||
|
model_ubs.future = glm::mat4();
|
||||||
|
auto const *vehicle { simulation::Train->Dynamic() };
|
||||||
|
if( ( vehicle->InteriorLightLevel > 0.f ) && ( false == m_cablamplit ) ) {
|
||||||
|
setup_shadow_color( glm::min( colors::white, m_shadowcolor + glm::vec4( vehicle->InteriorLight * vehicle->InteriorLightLevel, 1.f ) ) );
|
||||||
|
}
|
||||||
|
Render_cab( vehicle, vehicle->InteriorLightLevel, false );
|
||||||
|
}
|
||||||
|
setup_shadow_color( m_shadowcolor );
|
||||||
|
model_ubs.future = Future;
|
||||||
|
Render( simulation::Region );
|
||||||
|
// the depth of what's left
|
||||||
|
Render_Scene_Prepass();
|
||||||
|
m_scenerecording = false;
|
||||||
|
m_scenerecorded = true;
|
||||||
|
m_scenerecordedparts = static_cast<std::uint32_t>( m_scenechunks.size() );
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
// the conditions of the cab drawn early by the colour pass
|
||||||
|
if( ( false == FreeFlyModeFlag ) && ( Global.Overcast <= 1.0f ) && ( Global.render_cab ) ) {
|
||||||
|
model_ubs.future = glm::mat4();
|
||||||
|
auto const *vehicle { simulation::Train->Dynamic() };
|
||||||
|
Render_cab( vehicle, vehicle->InteriorLightLevel, false );
|
||||||
|
}
|
||||||
|
model_ubs.future = Future;
|
||||||
|
Render( simulation::Region );
|
||||||
}
|
}
|
||||||
model_ubs.future = Future;
|
|
||||||
Render( simulation::Region );
|
|
||||||
|
|
||||||
::glDisable( GL_POLYGON_OFFSET_FILL );
|
::glDisable( GL_POLYGON_OFFSET_FILL );
|
||||||
::glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
|
::glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
|
||||||
@@ -4678,10 +4777,351 @@ void opengl46_renderer::Render_Scene_Depth( glm::mat4 const &Future )
|
|||||||
|
|
||||||
m_scenedepthstats = m_renderpass.draw_stats;
|
m_scenedepthstats = m_renderpass.draw_stats;
|
||||||
m_renderpass.draw_stats = colourstats;
|
m_renderpass.draw_stats = colourstats;
|
||||||
|
if( m_scenereplayed ) {
|
||||||
|
// the walk was the one of the colour pass, which counts it
|
||||||
|
m_renderpass.draw_stats += m_scenedepthstats;
|
||||||
|
}
|
||||||
m_scenedepthtimer.end();
|
m_scenedepthtimer.end();
|
||||||
m_scenedepthcputime = std::chrono::duration<double, std::milli>( std::chrono::steady_clock::now() - cpustart ).count();
|
m_scenedepthcputime = std::chrono::duration<double, std::milli>( std::chrono::steady_clock::now() - cpustart ).count();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void opengl46_renderer::Record_Scene_Draw( gfx::geometry_handle const *First, std::size_t const Count, bool const Batch )
|
||||||
|
{
|
||||||
|
auto const index { static_cast<std::uint32_t>( m_scenedraws.size() ) };
|
||||||
|
auto &draw { m_scenedraws.emplace_back() };
|
||||||
|
draw.ubs = model_ubs;
|
||||||
|
draw.material = m_scenematerial;
|
||||||
|
draw.submodel = m_scenesubmodel;
|
||||||
|
draw.seed = m_sceneseed;
|
||||||
|
draw.variant = m_scenevariant;
|
||||||
|
draw.chunkfirst = static_cast<std::uint32_t>( m_scenechunks.size() );
|
||||||
|
draw.chunkcount = static_cast<std::uint32_t>( Count );
|
||||||
|
// a batch is drawn without instances, as Draw_Geometry() draws it
|
||||||
|
draw.instancecount = ( Batch ? 0 : static_cast<std::uint32_t>( m_current_instance_count ) );
|
||||||
|
draw.instancebase = ( draw.instancecount > 0 ? m_current_instance_base : 0 );
|
||||||
|
draw.instancebuffer = ( draw.instancecount > 0 ? m_instancestream->buffer() : 0 );
|
||||||
|
draw.header = static_cast<std::uint32_t>( m_sceneheaders.size() - 1 );
|
||||||
|
draw.blending = m_blendingenabled;
|
||||||
|
draw.batch = Batch;
|
||||||
|
// what the depth pass leaves out, as Bind_Material() and draw() do without the record (V41): the blended draws, those of
|
||||||
|
// negative opacity, of materials the depth programs can't stand for, and the ones with the alpha test without a texture
|
||||||
|
draw.prepassclass = 0;
|
||||||
|
draw.prepasstexture = null_handle;
|
||||||
|
if( ( false == m_blendingenabled ) && ( model_ubs.opacity >= 0.f ) ) {
|
||||||
|
draw.prepassclass = Prepass_Class( m_scenematerial );
|
||||||
|
if( draw.prepassclass == 2 ) {
|
||||||
|
// the diffuse texture of the colour pass, the same choice as Bind_Material() makes
|
||||||
|
auto const &material { m_materials.material( m_scenematerial ) };
|
||||||
|
auto const &textures { material.texture_variants.empty() ? material.textures : material.GetTextures( m_scenevariant ) };
|
||||||
|
draw.prepasstexture = textures[ 0 ];
|
||||||
|
if( draw.prepasstexture == null_handle ) {
|
||||||
|
draw.prepassclass = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// the sphere of a chunk of a draw which isn't instanced, in the view: centre and the radius scaled with the model
|
||||||
|
glm::mat3 const rotationscale { draw.ubs.modelview };
|
||||||
|
auto const scale { std::sqrt( std::max( { glm::length2( rotationscale[ 0 ] ), glm::length2( rotationscale[ 1 ] ), glm::length2( rotationscale[ 2 ] ) } ) ) };
|
||||||
|
for( std::size_t chunk = 0; chunk < Count; ++chunk ) {
|
||||||
|
auto const &geometry { First[ chunk ] };
|
||||||
|
auto depth { draw.prepassclass != 0 };
|
||||||
|
if( depth ) {
|
||||||
|
// the program of the prepass doesn't size points, and lines aren't surfaces
|
||||||
|
auto const type { m_geometry.type( geometry ) };
|
||||||
|
depth = ( ( type == GL_TRIANGLES ) || ( type == GL_TRIANGLE_STRIP ) || ( type == GL_TRIANGLE_FAN ) );
|
||||||
|
}
|
||||||
|
if( depth && m_scenedepthreach && ( draw.instancecount == 0 ) ) {
|
||||||
|
auto const &sphere { Chunk_Sphere( geometry ) };
|
||||||
|
if( sphere.w >= 0.f ) {
|
||||||
|
auto const centre { glm::vec3{ draw.ubs.modelview * glm::vec4{ glm::vec3{ sphere }, 1.f } } };
|
||||||
|
if( glm::length( centre ) - sphere.w * scale > m_scenedepthlimit ) {
|
||||||
|
depth = false;
|
||||||
|
++m_scenebeyondreach;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
m_scenechunks.push_back( { geometry, index, depth } );
|
||||||
|
m_scenegeometry.push_back( geometry );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void opengl46_renderer::Render_Scene_Prepass()
|
||||||
|
{
|
||||||
|
auto const end { m_scenechunks.size() };
|
||||||
|
if( m_sceneflushed >= end ) { return; }
|
||||||
|
|
||||||
|
// the chunks the depth is drawn for, in runs of the same program, texture of the alpha test, bank, primitive and instance
|
||||||
|
// buffer. the depth doesn't depend on the order of the draws; within a bank the chunks keep the order of the walk
|
||||||
|
m_sceneprepassitems.clear();
|
||||||
|
for( auto chunkindex { m_sceneflushed }; chunkindex < end; ++chunkindex ) {
|
||||||
|
auto const &chunk { m_scenechunks[ chunkindex ] };
|
||||||
|
if( false == chunk.depth ) { continue; }
|
||||||
|
auto const &draw { m_scenedraws[ chunk.draw ] };
|
||||||
|
gfx::indirect_source source;
|
||||||
|
if( false == m_geometry.indirect_source( chunk.geometry, source ) ) { continue; }
|
||||||
|
auto &item { m_sceneprepassitems.emplace_back() };
|
||||||
|
item.prepassclass = draw.prepassclass;
|
||||||
|
item.texture = ( draw.prepassclass == 2 ? draw.prepasstexture : null_handle );
|
||||||
|
item.bank = chunk.geometry.bank;
|
||||||
|
item.type = source.type;
|
||||||
|
item.indexed = ( source.indexed ? 1u : 0u );
|
||||||
|
item.instancebuffer = draw.instancebuffer;
|
||||||
|
item.chunk = static_cast<std::uint32_t>( chunkindex );
|
||||||
|
// count, instances, first, base vertex (the base instance of an array draw), base instance
|
||||||
|
auto const instances { std::max<std::uint32_t>( draw.instancecount, 1 ) };
|
||||||
|
item.command = {
|
||||||
|
source.count,
|
||||||
|
instances,
|
||||||
|
source.first,
|
||||||
|
( source.indexed ? static_cast<std::uint32_t>( source.basevertex ) : draw.instancebase ),
|
||||||
|
( source.indexed ? draw.instancebase : 0u ),
|
||||||
|
0, item.indexed, 0 };
|
||||||
|
}
|
||||||
|
m_sceneflushed = end;
|
||||||
|
if( m_sceneprepassitems.empty() ) { return; }
|
||||||
|
std::sort(
|
||||||
|
std::begin( m_sceneprepassitems ), std::end( m_sceneprepassitems ),
|
||||||
|
[]( scene_prepass_item const &Left, scene_prepass_item const &Right ) { return Left.tie() < Right.tie(); } );
|
||||||
|
|
||||||
|
auto const multidraw { ( m_drawblockstream != nullptr ) && ( m_scenecommandstream != nullptr ) };
|
||||||
|
GLuint const frameinstances { m_instancestream->buffer() };
|
||||||
|
GLuint boundinstances { frameinstances };
|
||||||
|
auto const bind_instances = [ & ]( GLuint const Buffer ) {
|
||||||
|
// a draw which isn't instanced reads the identity at the start of any of the buffers
|
||||||
|
if( ( Buffer == 0 ) || ( Buffer == boundinstances ) ) { return; }
|
||||||
|
::glBindBuffersBase( GL_SHADER_STORAGE_BUFFER, gl::INSTANCE_SSBO_BINDING, 1, &Buffer );
|
||||||
|
boundinstances = Buffer;
|
||||||
|
};
|
||||||
|
auto const count { m_sceneprepassitems.size() };
|
||||||
|
auto const samerun = []( scene_prepass_item const &Left, scene_prepass_item const &Right ) {
|
||||||
|
return ( Left.prepassclass == Right.prepassclass )
|
||||||
|
&& ( Left.texture == Right.texture )
|
||||||
|
&& ( Left.bank == Right.bank )
|
||||||
|
&& ( Left.type == Right.type )
|
||||||
|
&& ( Left.indexed == Right.indexed )
|
||||||
|
&& ( Left.instancebuffer == Right.instancebuffer ); };
|
||||||
|
|
||||||
|
if( multidraw ) {
|
||||||
|
// the model blocks and the commands of all of them go to the buffers of the frame at once, a run is one call
|
||||||
|
m_sceneprepassblocks.clear();
|
||||||
|
m_sceneprepasscommands.clear();
|
||||||
|
for( auto const &item : m_sceneprepassitems ) {
|
||||||
|
m_sceneprepassblocks.push_back( m_scenedraws[ m_scenechunks[ item.chunk ].draw ].ubs );
|
||||||
|
m_sceneprepasscommands.push_back( item.command );
|
||||||
|
}
|
||||||
|
auto const blockoffset { m_drawblockstream->push( m_sceneprepassblocks.data(), static_cast<GLsizeiptr>( count * sizeof( gl::model_ubs ) ) ) };
|
||||||
|
GLuint const blockbuffer { m_drawblockstream->buffer() };
|
||||||
|
auto const commandoffset { m_scenecommandstream->push( m_sceneprepasscommands.data(), static_cast<GLsizeiptr>( count * sizeof( gl::instance_draw_command ) ) ) };
|
||||||
|
::glBindBuffer( GL_DRAW_INDIRECT_BUFFER, m_scenecommandstream->buffer() );
|
||||||
|
auto boundclass { 0 };
|
||||||
|
for( std::size_t first = 0; first < count; ) {
|
||||||
|
auto const &item { m_sceneprepassitems[ first ] };
|
||||||
|
auto last { first + 1 };
|
||||||
|
while( ( last < count ) && samerun( item, m_sceneprepassitems[ last ] ) ) {
|
||||||
|
++last;
|
||||||
|
}
|
||||||
|
auto const drawcount { last - first };
|
||||||
|
auto const run { first };
|
||||||
|
first = last;
|
||||||
|
if( ( item.prepassclass == 2 ) && ( false == m_textures.mark_as_used( item.texture ).bind( 0 ) ) ) {
|
||||||
|
// a texture which isn't there (yet) would leave the one bound before to the alpha test
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if( item.prepassclass != boundclass ) {
|
||||||
|
( item.prepassclass == 2 ? m_prepass_alpha_multidraw_shader : m_prepass_multidraw_shader )->bind();
|
||||||
|
boundclass = item.prepassclass;
|
||||||
|
}
|
||||||
|
bind_instances( item.instancebuffer );
|
||||||
|
GLintptr const offset { blockoffset + static_cast<GLintptr>( run * sizeof( gl::model_ubs ) ) };
|
||||||
|
GLsizeiptr const size { static_cast<GLsizeiptr>( drawcount * sizeof( gl::model_ubs ) ) };
|
||||||
|
::glBindBuffersRange( GL_SHADER_STORAGE_BUFFER, gl::MODEL_DRAW_SSBO_BINDING, 1, &blockbuffer, &offset, &size );
|
||||||
|
m_geometry.draw_indirect_multi(
|
||||||
|
m_scenechunks[ item.chunk ].geometry,
|
||||||
|
commandoffset + static_cast<std::intptr_t>( run * sizeof( gl::instance_draw_command ) ),
|
||||||
|
static_cast<std::uint32_t>( drawcount ),
|
||||||
|
sizeof( gl::instance_draw_command ) );
|
||||||
|
m_sceneprepassdraws += static_cast<std::uint32_t>( drawcount );
|
||||||
|
++m_sceneprepasscalls;
|
||||||
|
}
|
||||||
|
::glBindBuffer( GL_DRAW_INDIRECT_BUFFER, 0 );
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
// one by one, with the model block of each draw, as without the record
|
||||||
|
auto const walkubs { model_ubs };
|
||||||
|
auto boundclass { 0 };
|
||||||
|
auto drawn { false };
|
||||||
|
for( std::size_t first = 0; first < count; ) {
|
||||||
|
auto const &item { m_sceneprepassitems[ first ] };
|
||||||
|
auto last { first + 1 };
|
||||||
|
while( ( last < count ) && samerun( item, m_sceneprepassitems[ last ] ) ) {
|
||||||
|
++last;
|
||||||
|
}
|
||||||
|
auto const run { first };
|
||||||
|
first = last;
|
||||||
|
if( ( item.prepassclass == 2 ) && ( false == m_textures.mark_as_used( item.texture ).bind( 0 ) ) ) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if( item.prepassclass != boundclass ) {
|
||||||
|
( item.prepassclass == 2 ? m_prepass_alpha_shader : m_prepass_shader )->bind();
|
||||||
|
boundclass = item.prepassclass;
|
||||||
|
}
|
||||||
|
bind_instances( item.instancebuffer );
|
||||||
|
for( auto index { run }; index < last; ++index ) {
|
||||||
|
auto const &chunk { m_scenechunks[ m_sceneprepassitems[ index ].chunk ] };
|
||||||
|
auto const &draw { m_scenedraws[ chunk.draw ] };
|
||||||
|
model_ubs = draw.ubs;
|
||||||
|
model_ubo->update( model_ubs );
|
||||||
|
if( draw.instancecount > 0 ) {
|
||||||
|
m_geometry.draw_instanced( chunk.geometry, draw.instancecount, draw.instancebase );
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
m_geometry.draw( chunk.geometry );
|
||||||
|
}
|
||||||
|
++m_sceneprepassdraws;
|
||||||
|
++m_sceneprepasscalls;
|
||||||
|
drawn = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// the walk goes on with its own state
|
||||||
|
model_ubs = walkubs;
|
||||||
|
if( drawn ) {
|
||||||
|
model_ubo->update( model_ubs );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if( boundinstances != frameinstances ) {
|
||||||
|
Bind_Instance_Stream();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void opengl46_renderer::Render_Scene_Colour()
|
||||||
|
{
|
||||||
|
// what the walk left behind, which the passes after this one go on with
|
||||||
|
auto const walkubs { model_ubs };
|
||||||
|
auto const walkseed { TSubModel::iVariantSeed };
|
||||||
|
|
||||||
|
// the light buffer has the header the walk began with (it uploaded none while recording)
|
||||||
|
std::uint32_t header { 0 };
|
||||||
|
auto blending { false };
|
||||||
|
auto bound { false };
|
||||||
|
material_handle boundmaterial { null_handle };
|
||||||
|
std::uint32_t boundvariant { 0 };
|
||||||
|
GLuint const frameinstances { m_instancestream->buffer() };
|
||||||
|
GLuint boundinstances { frameinstances };
|
||||||
|
for( auto const &draw : m_scenedraws ) {
|
||||||
|
if( draw.instances ) {
|
||||||
|
// the instances culled in the walk, where the colour pass would draw them
|
||||||
|
if( blending ) {
|
||||||
|
setup_drawing( false );
|
||||||
|
blending = false;
|
||||||
|
}
|
||||||
|
if( draw.header != header ) {
|
||||||
|
light_ssbo->update( m_sceneheaders[ draw.header ].data(), 0, std::tuple_size_v<light_header> );
|
||||||
|
header = draw.header;
|
||||||
|
}
|
||||||
|
if( m_indirectcolourpending ) {
|
||||||
|
Render_Instances_Indirect_Pending();
|
||||||
|
}
|
||||||
|
// they bind their own programs, textures and the instance buffer of the frame
|
||||||
|
bound = false;
|
||||||
|
boundinstances = m_instancestream->buffer();
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if( draw.header != header ) {
|
||||||
|
light_ssbo->update( m_sceneheaders[ draw.header ].data(), 0, std::tuple_size_v<light_header> );
|
||||||
|
header = draw.header;
|
||||||
|
}
|
||||||
|
if( draw.blending != blending ) {
|
||||||
|
// the transparency hack of submodels faded out
|
||||||
|
setup_drawing( draw.blending );
|
||||||
|
blending = draw.blending;
|
||||||
|
}
|
||||||
|
if( ( false == bound ) || ( draw.material != boundmaterial ) || ( draw.variant != boundvariant ) ) {
|
||||||
|
// the textures of the variant follow from the seed of the vehicle and the submodel
|
||||||
|
TSubModel::iVariantSeed = draw.seed;
|
||||||
|
Bind_Material( draw.material, draw.submodel );
|
||||||
|
bound = true;
|
||||||
|
boundmaterial = draw.material;
|
||||||
|
boundvariant = draw.variant;
|
||||||
|
}
|
||||||
|
model_ubs = draw.ubs;
|
||||||
|
model_ubo->update( model_ubs );
|
||||||
|
auto const *chunks { m_scenegeometry.data() + draw.chunkfirst };
|
||||||
|
if( draw.instancecount > 0 ) {
|
||||||
|
if( draw.instancebuffer != boundinstances ) {
|
||||||
|
::glBindBuffersBase( GL_SHADER_STORAGE_BUFFER, gl::INSTANCE_SSBO_BINDING, 1, &draw.instancebuffer );
|
||||||
|
boundinstances = draw.instancebuffer;
|
||||||
|
}
|
||||||
|
m_geometry.draw_instanced( chunks[ 0 ], draw.instancecount, draw.instancebase );
|
||||||
|
}
|
||||||
|
else if( draw.batch ) {
|
||||||
|
m_geometry.draw_batch( chunks, chunks + draw.chunkcount );
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
m_geometry.draw( chunks[ 0 ] );
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if( blending ) {
|
||||||
|
setup_drawing( false );
|
||||||
|
}
|
||||||
|
if( header + 1 != m_sceneheaders.size() ) {
|
||||||
|
// the header the walk ended with
|
||||||
|
light_ssbo->update( m_sceneheaders.back().data(), 0, std::tuple_size_v<light_header> );
|
||||||
|
}
|
||||||
|
if( boundinstances != m_instancestream->buffer() ) {
|
||||||
|
Bind_Instance_Stream();
|
||||||
|
}
|
||||||
|
model_ubs = walkubs;
|
||||||
|
TSubModel::iVariantSeed = walkseed;
|
||||||
|
}
|
||||||
|
|
||||||
|
void opengl46_renderer::Render_Instances_Indirect_Pending()
|
||||||
|
{
|
||||||
|
m_indirectcolourpending = false;
|
||||||
|
indirect_counts colourcounts;
|
||||||
|
if( false == m_indirectdraws.empty() ) {
|
||||||
|
auto const cpustart { std::chrono::steady_clock::now() };
|
||||||
|
m_indirectcull = &m_instancecull;
|
||||||
|
m_instancecull.bind_draw();
|
||||||
|
colourcounts = Render_Instances_Indirect_Colour( m_indirectcolourset );
|
||||||
|
::glBindBuffer( GL_DRAW_INDIRECT_BUFFER, 0 );
|
||||||
|
Bind_Instance_Stream();
|
||||||
|
m_instancecull.draw_result(
|
||||||
|
colourcounts.draws,
|
||||||
|
m_instancecull.prepass_draws(),
|
||||||
|
colourcounts.calls,
|
||||||
|
m_instancecull.prepass_calls(),
|
||||||
|
m_instancecull.cpu_time() + std::chrono::duration<double, std::milli>( std::chrono::steady_clock::now() - cpustart ).count() );
|
||||||
|
}
|
||||||
|
m_renderpass.draw_stats.instanced_drawcalls += static_cast<int>( colourcounts.calls );
|
||||||
|
m_renderpass.draw_stats.instances += static_cast<int>( m_instancecull.last_count() );
|
||||||
|
m_renderpass.draw_stats.models += static_cast<int>( m_instancecull.last_count() );
|
||||||
|
}
|
||||||
|
|
||||||
|
glm::vec4 const &opengl46_renderer::Chunk_Sphere( gfx::geometry_handle const &Geometry )
|
||||||
|
{
|
||||||
|
auto const key { static_cast<std::uint64_t>( Geometry ) };
|
||||||
|
if( auto const lookup { m_chunkspheres.find( key ) }; lookup != m_chunkspheres.end() ) {
|
||||||
|
return lookup->second;
|
||||||
|
}
|
||||||
|
glm::vec4 sphere { 0.f, 0.f, 0.f, -1.f };
|
||||||
|
auto const &vertices { m_geometry.vertices( Geometry ) };
|
||||||
|
if( false == vertices.empty() ) {
|
||||||
|
glm::vec3 low { std::numeric_limits<float>::max() };
|
||||||
|
glm::vec3 high { std::numeric_limits<float>::lowest() };
|
||||||
|
for( auto const &vertex : vertices ) {
|
||||||
|
low = glm::min( low, vertex.position );
|
||||||
|
high = glm::max( high, vertex.position );
|
||||||
|
}
|
||||||
|
glm::vec3 const centre { ( low + high ) * 0.5f };
|
||||||
|
auto radius { 0.f };
|
||||||
|
for( auto const &vertex : vertices ) {
|
||||||
|
radius = std::max( radius, glm::length2( vertex.position - centre ) );
|
||||||
|
}
|
||||||
|
sphere = glm::vec4{ centre, std::sqrt( radius ) };
|
||||||
|
}
|
||||||
|
return m_chunkspheres.emplace( key, sphere ).first->second;
|
||||||
|
}
|
||||||
|
|
||||||
bool opengl46_renderer::Scene_Depth_Draws( gfx::geometry_handle const &Geometry ) const
|
bool opengl46_renderer::Scene_Depth_Draws( gfx::geometry_handle const &Geometry ) const
|
||||||
{
|
{
|
||||||
if( m_scenedepthskip ) { return false; }
|
if( m_scenedepthskip ) { return false; }
|
||||||
|
|||||||
@@ -404,8 +404,23 @@ class opengl46_renderer : public gfx_renderer {
|
|||||||
int Prepass_Class( material_handle const Material );
|
int Prepass_Class( material_handle const Material );
|
||||||
// depth of the whole opaque scene of the colour pass, before its colour (Global.gfx_depthprepass_scene): the colour pass
|
// depth of the whole opaque scene of the colour pass, before its colour (Global.gfx_depthprepass_scene): the colour pass
|
||||||
// walks the scene a second time, Bind_Material() binds the programs of the depth prepass and draw() leaves out what they
|
// walks the scene a second time, Bind_Material() binds the programs of the depth prepass and draw() leaves out what they
|
||||||
// can't draw. Future: the motion matrix the colour pass draws the region with
|
// can't draw. with Global.gfx_depthprepass_replay the walk of the colour pass is made here, once: its opaque draws are
|
||||||
void Render_Scene_Depth( glm::mat4 const &Future );
|
// recorded (Record_Scene_Draw()), their depth is drawn from the record (Render_Scene_Prepass()) and the colour pass draws
|
||||||
|
// them from it (Render_Scene_Colour()). Future: the motion matrix the colour pass draws the region with. Contactonly: the
|
||||||
|
// depth is drawn only for the contact shadows, which need it within their reach
|
||||||
|
void Render_Scene_Depth( glm::mat4 const &Future, bool const Contactonly );
|
||||||
|
// notes a draw of the walk recorded by Render_Scene_Depth(): the chunks drawn, with the state the walk left for them
|
||||||
|
void Record_Scene_Draw( gfx::geometry_handle const *First, std::size_t const Count, bool const Batch );
|
||||||
|
// draws the depth of the recorded draws not drawn yet, in runs of the same program, bank and texture of the alpha test,
|
||||||
|
// with multi draws when there are any. the depth pyramid of the occlusion test and the cursor of the editor take the depth
|
||||||
|
// drawn so far, and the end of the walk the rest
|
||||||
|
void Render_Scene_Prepass();
|
||||||
|
// the colour of the recorded draws, in the order of the walk, with the programs of their materials
|
||||||
|
void Render_Scene_Colour();
|
||||||
|
// the colour of the instances culled and recorded by the depth pass of the whole scene (m_indirectcolourpending)
|
||||||
|
void Render_Instances_Indirect_Pending();
|
||||||
|
// the bounding sphere of a geometry chunk in the space of its vertices, w the radius (negative if there's none)
|
||||||
|
glm::vec4 const &Chunk_Sphere( gfx::geometry_handle const &Geometry );
|
||||||
// whether the colour pass of the viewport gets contact shadows, which need the depth pass of the scene
|
// whether the colour pass of the viewport gets contact shadows, which need the depth pass of the scene
|
||||||
bool Contact_Shadows_Wanted( viewport_config const &Viewport ) const;
|
bool Contact_Shadows_Wanted( viewport_config const &Viewport ) const;
|
||||||
// resolves the depth drawn by Render_Scene_Depth() for the contact shadows and sets them up for the colour pass
|
// resolves the depth drawn by Render_Scene_Depth() for the contact shadows and sets them up for the colour pass
|
||||||
@@ -683,6 +698,71 @@ class opengl46_renderer : public gfx_renderer {
|
|||||||
debug_stats m_scenedepthstats; // of its last run
|
debug_stats m_scenedepthstats; // of its last run
|
||||||
double m_scenedepthcputime { 0.0 }; // ms
|
double m_scenedepthcputime { 0.0 }; // ms
|
||||||
gl::gpu_timer m_scenedepthtimer;
|
gl::gpu_timer m_scenedepthtimer;
|
||||||
|
// the recorded walk of the colour pass (Global.gfx_depthprepass_replay): a draw with the state it was made with
|
||||||
|
struct scene_draw {
|
||||||
|
gl::model_ubs ubs;
|
||||||
|
material_handle material { null_handle }; // bound last before it (Bind_Material())
|
||||||
|
TSubModel const *submodel { nullptr };
|
||||||
|
std::uint32_t seed { 0 }; // TSubModel::iVariantSeed then
|
||||||
|
std::uint32_t variant { 0 }; // TSubModel::VariantId() then: which textures of the material were bound
|
||||||
|
std::uint32_t chunkfirst { 0 }; // in m_scenechunks
|
||||||
|
std::uint32_t chunkcount { 0 };
|
||||||
|
std::uint32_t instancecount { 0 }; // instanced draw (Render_Instanced(), Render_Sleepers()), 0 if not
|
||||||
|
std::uint32_t instancebase { 0 };
|
||||||
|
GLuint instancebuffer { 0 }; // the instance buffer of the frame the matrices of the instances went to
|
||||||
|
std::uint32_t header { 0 }; // the light header (m_sceneheaders) it is lit with
|
||||||
|
texture_handle prepasstexture { null_handle }; // of the alpha test of the depth pass
|
||||||
|
int prepassclass { 0 }; // Prepass_Class(), 0 as well for what the depth pass leaves out (blending, opacity < 0)
|
||||||
|
bool blending { false };
|
||||||
|
bool batch { false }; // drawn with draw_batch() (neighbouring tracks)
|
||||||
|
bool instances { false }; // no draw: the colour of the instances culled in the walk goes here
|
||||||
|
};
|
||||||
|
struct scene_chunk {
|
||||||
|
gfx::geometry_handle geometry;
|
||||||
|
std::uint32_t draw;
|
||||||
|
bool depth; // drawn in the depth pass
|
||||||
|
};
|
||||||
|
using light_header = std::array<std::uint8_t, offsetof( gl::light_data, lights ) + sizeof( gl::light_element )>;
|
||||||
|
bool m_scenerecording { false }; // inside the walk of Render_Scene_Depth(): draw(), Bind_Material(), upload_light_header() record
|
||||||
|
bool m_scenerecorded { false }; // the colour pass under way draws the record
|
||||||
|
bool m_scenereplayed { false }; // the last depth pass of the scene was drawn from a record
|
||||||
|
bool m_scenedepthreach { false }; // the depth pass leaves out the draws lying whole farther than m_scenedepthlimit
|
||||||
|
float m_scenedepthlimit { 0.f };
|
||||||
|
material_handle m_scenematerial { null_handle }; // what Bind_Material() bound last in the walk
|
||||||
|
TSubModel const *m_scenesubmodel { nullptr };
|
||||||
|
std::uint32_t m_sceneseed { 0 };
|
||||||
|
std::uint32_t m_scenevariant { 0 };
|
||||||
|
std::vector<scene_draw> m_scenedraws;
|
||||||
|
std::vector<scene_chunk> m_scenechunks;
|
||||||
|
std::vector<gfx::geometry_handle> m_scenegeometry; // the chunks of m_scenechunks, for draw_batch()
|
||||||
|
std::vector<light_header> m_sceneheaders; // the first one is in the light buffer when the walk begins
|
||||||
|
std::size_t m_sceneflushed { 0 }; // chunks Render_Scene_Prepass() went through
|
||||||
|
// working space of Render_Scene_Prepass(): a chunk drawn and what its run has in common
|
||||||
|
struct scene_prepass_item {
|
||||||
|
int prepassclass;
|
||||||
|
texture_handle texture;
|
||||||
|
std::uint32_t bank;
|
||||||
|
unsigned int type;
|
||||||
|
std::uint32_t indexed;
|
||||||
|
GLuint instancebuffer; // 0 for a draw which isn't instanced, which reads the identity every buffer starts with
|
||||||
|
std::uint32_t chunk;
|
||||||
|
gl::instance_draw_command command;
|
||||||
|
auto tie() const {
|
||||||
|
return std::tie( prepassclass, texture, bank, type, indexed, instancebuffer, chunk ); }
|
||||||
|
};
|
||||||
|
std::vector<scene_prepass_item> m_sceneprepassitems;
|
||||||
|
std::vector<gl::model_ubs> m_sceneprepassblocks;
|
||||||
|
std::vector<gl::instance_draw_command> m_sceneprepasscommands;
|
||||||
|
// the commands of the multi draws of the depth pass, one buffer for each of the last frames (nullptr: no multi draws)
|
||||||
|
std::unique_ptr<gl::frame_stream> m_scenecommandstream;
|
||||||
|
// of the last recorded walk: parts drawn (chunks of geometry; neighbouring tracks are drawn together), those of them drawn in
|
||||||
|
// the depth pass and its gl calls, and those left out of it as farther than the reach of the contact shadows
|
||||||
|
std::uint32_t m_scenerecordedparts { 0 };
|
||||||
|
std::uint32_t m_sceneprepassdraws { 0 };
|
||||||
|
std::uint32_t m_sceneprepasscalls { 0 };
|
||||||
|
std::uint32_t m_scenebeyondreach { 0 };
|
||||||
|
// Chunk_Sphere() of the chunks asked about, dropped when their vertices change (Replace(), Append())
|
||||||
|
std::unordered_map<std::uint64_t, glm::vec4> m_chunkspheres;
|
||||||
// contact shadows: set up for the colour pass under way, and whether the last main view had them
|
// contact shadows: set up for the colour pass under way, and whether the last main view had them
|
||||||
bool m_contactshadows { false };
|
bool m_contactshadows { false };
|
||||||
bool m_contactshadowslast { false };
|
bool m_contactshadowslast { false };
|
||||||
|
|||||||
@@ -1474,6 +1474,11 @@ global_settings::ConfigParse_gfx( cParser &Parser, std::string_view const Token
|
|||||||
Parser.getTokens(1);
|
Parser.getTokens(1);
|
||||||
Parser >> gfx_depthprepass_scene;
|
Parser >> gfx_depthprepass_scene;
|
||||||
}
|
}
|
||||||
|
else if (Token == "gfx.depthprepass.replay")
|
||||||
|
{
|
||||||
|
Parser.getTokens(1);
|
||||||
|
Parser >> gfx_depthprepass_replay;
|
||||||
|
}
|
||||||
else if (Token == "gfx.bufferstreaming")
|
else if (Token == "gfx.bufferstreaming")
|
||||||
{
|
{
|
||||||
Parser.getTokens(1);
|
Parser.getTokens(1);
|
||||||
@@ -1969,6 +1974,7 @@ global_settings::export_as_text( std::ostream &Output ) const {
|
|||||||
export_as_text( Output, "gfx.gpucull.reflections", gfx_gpucull_reflections );
|
export_as_text( Output, "gfx.gpucull.reflections", gfx_gpucull_reflections );
|
||||||
export_as_text( Output, "gfx.gpucull.sleepers", gfx_gpucull_sleepers );
|
export_as_text( Output, "gfx.gpucull.sleepers", gfx_gpucull_sleepers );
|
||||||
export_as_text( Output, "gfx.depthprepass.scene", gfx_depthprepass_scene );
|
export_as_text( Output, "gfx.depthprepass.scene", gfx_depthprepass_scene );
|
||||||
|
export_as_text( Output, "gfx.depthprepass.replay", gfx_depthprepass_replay );
|
||||||
export_as_text( Output, "gfx.bufferstreaming", gfx_bufferstreaming );
|
export_as_text( Output, "gfx.bufferstreaming", gfx_bufferstreaming );
|
||||||
export_as_text( Output, "gfx.postfx.motionblur.enabled", gfx_postfx_motionblur_enabled );
|
export_as_text( Output, "gfx.postfx.motionblur.enabled", gfx_postfx_motionblur_enabled );
|
||||||
export_as_text( Output, "gfx.postfx.motionblur.shutter", gfx_postfx_motionblur_shutter );
|
export_as_text( Output, "gfx.postfx.motionblur.shutter", gfx_postfx_motionblur_shutter );
|
||||||
|
|||||||
@@ -303,6 +303,10 @@ struct global_settings {
|
|||||||
bool gfx_gpucull_sleepers = true;
|
bool gfx_gpucull_sleepers = true;
|
||||||
// (opengl 4.6) the depth of the whole opaque scene of the main view is drawn before its colour, the instances included
|
// (opengl 4.6) the depth of the whole opaque scene of the main view is drawn before its colour, the instances included
|
||||||
bool gfx_depthprepass_scene = false;
|
bool gfx_depthprepass_scene = false;
|
||||||
|
// (opengl 4.6) the depth pass of the scene (gfx_depthprepass_scene, or the one of the contact shadows) walks the scene for
|
||||||
|
// the colour pass as well: its opaque draws are recorded once, their depth drawn from the record (with the contact shadows
|
||||||
|
// alone only within their reach) and their colour too. false: the scene is walked twice, as before
|
||||||
|
bool gfx_depthprepass_replay = true;
|
||||||
// (opengl 4.6) the model block of every draw and the matrices of instances are written to persistently mapped buffers,
|
// (opengl 4.6) the model block of every draw and the matrices of instances are written to persistently mapped buffers,
|
||||||
// one for each of the last frames, instead of with glBufferSubData. read at the start
|
// one for each of the last frames, instead of with glBufferSubData. read at the start
|
||||||
bool gfx_bufferstreaming = true;
|
bool gfx_bufferstreaming = true;
|
||||||
|
|||||||
Reference in New Issue
Block a user