mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-21 05:04:58 +01:00
* Local lights: street lamps of the scenery light their surroundings Optional settings, all off by default (nothing changes without them): - gfx.lights.stars: Stars submodels (e.g. "lamp" of the SGP340 street lights) whose glowing points light downwards as lamps; signal LEDs, chimneys and the sky only glow - gfx.lights.points.near: scenery lamps shining downwards light also closer than their glare is seen from - gfx.lights.freespot.mincone: wider cones for scenery lamps shining downwards (many have the narrow cone of their glare) - gfx.lights.lamps.gain: brightness of the scenery lamps shining downwards - gfx.lights.hideglow: textures of the planes faking the light of lamps (pools of light, glows), hidden while the lamps light Lights shining sideways (signals) keep their cones, brightness and distances. The lamps made of glowing points are gathered also from the opaque instances of a cell. * Local lights: the lamp settings in a parser of their own, the draw phase test in a helper The entries of the lamps are read by ConfigParse_gfx_lamps, which the parser of the sky hands the tokens it doesn't know, and the opaque and translucent draws ask drawn_in_phase whether a submodel has a part in them, so the long functions keep their complexity. The fake glow cache is private, the colour of a light point is lightcolor (no shadowing of rendermode::color), the minimal distance of a submodel comes from walk_min_distance and the lit instances of a cell from add_lit_instances. * Settings: the lamp entries are tried by the main loop of the parser, the parser of the sky stays as it was * Local lights: the fake glows are left out only within the reach the lamps are gathered from Beyond gfx.lights.range nothing lights the ground in place of the pools of light and glows of the lamps, so a scenery model keeps them there. Render_Alpha(TAnimModel *) tells hide_fake_glows() which model it draws, and is_fake_glow() leaves out the glows of that model only, when it is within the range (and its radius) of the camera the lamps are gathered around. The glow planes are translucent, so the opaque draws are as they were. * Local lights: hide_fake_glows() takes the model as it is drawn (radius() isn't const) * Local lights: the fake glows hidden at any distance again, gfx.lights.lamps.range to see the lamps from afar Glow planes kept beyond the reach of the lamps don't light a distant station either, they only float above it, so the glows listed in gfx.lights.hideglow are left out at any distance again. A lit station is seen from afar with gfx.lights.lamps.range instead: the lamps are gathered from that far when it's above gfx.lights.range (0, the default: from gfx.lights.range). * Local lights: gfx.lights.lamps.range for the lamps of the scenery only, the vehicles keep gfx.lights.range * Local lights: the fake glows are kept with gfx.lights.range 0, the limits of gfx.lights.hideglow in the docs
3426 lines
129 KiB
C++
3426 lines
129 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
// the walk of the scene shared by the renderers (stage N6 of claude/vulkan14-renderer-plan.md): what is drawn in a pass, in
|
|
// which order, with which material and transform. the backends get the draws through the walk_* methods, the opengl renderer
|
|
// makes them at once, the vulkan renderer records them. moved out of opengl46renderer.cpp without changes to what it does
|
|
|
|
#include "stdafx.h"
|
|
#include "rendering/common/scenewalk.h"
|
|
#include "rendering/common/walksync.h"
|
|
#include "utilities/color.h"
|
|
#include "utilities/Globals.h"
|
|
#include "utilities/utilities.h"
|
|
#include "vehicle/Train.h"
|
|
#include "vehicle/Camera.h"
|
|
#include "vehicle/DynObj.h"
|
|
#include "simulation/simulation.h"
|
|
#include "world/Track.h"
|
|
#include "world/Traction.h"
|
|
#include "world/catenary_span.h"
|
|
#include "world/MemCell.h"
|
|
#include "world/TrackSleepers.h"
|
|
#include "world/SleeperRules.h"
|
|
#include "model/AnimModel.h"
|
|
#include "model/Model3d.h"
|
|
#include "rendering/common/skyocclusion.h"
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <string>
|
|
#include <string_view>
|
|
|
|
namespace gfx
|
|
{
|
|
|
|
namespace
|
|
{
|
|
|
|
// the environment of a track the drawing takes into its light: the flag of the track (a tunnel, a canyon) only with
|
|
// Global.gfx_tunnelflags. otherwise the light is the one of the geometry around it (gfx::sky_occlusion)
|
|
TEnvironmentType track_environment(TTrack const *Track)
|
|
{
|
|
return (Global.gfx_tunnelflags ? Track->eEnvironment : e_flat);
|
|
}
|
|
|
|
// the name of a texture or a material the way gfx_lights_hideglow lists it: lower case, with /, without the folder of the textures
|
|
// and without the extension
|
|
std::string glow_name(std::string_view const Name)
|
|
{
|
|
auto name{ToLower(std::string{Name})};
|
|
std::ranges::replace(name, '\\', '/');
|
|
if (name.starts_with("textures/"))
|
|
{
|
|
name.erase(0, std::string_view{"textures/"}.size());
|
|
}
|
|
if (auto const dot{name.rfind('.')}; (dot != std::string::npos) && (name.find('/', dot) == std::string::npos))
|
|
{
|
|
name.erase(dot);
|
|
}
|
|
return name;
|
|
}
|
|
|
|
// whether the material named Name is one of the textures separated with | in List: the same name, or the end of it after a /
|
|
bool is_listed_glow(std::string_view const Name, std::string_view const List)
|
|
{
|
|
std::size_t start{0};
|
|
while (start <= List.size())
|
|
{
|
|
auto end{List.find('|', start)};
|
|
if (end == std::string_view::npos)
|
|
{
|
|
end = List.size();
|
|
}
|
|
if (auto const entry{glow_name(List.substr(start, end - start))}; (false == entry.empty()) && ((Name == entry) || Name.ends_with("/" + entry)))
|
|
{
|
|
return true;
|
|
}
|
|
start = end + 1;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool scene_walk::drawn_in_phase(TSubModel const *Submodel, int const Mask)
|
|
{
|
|
return ((Submodel->iAlpha & Submodel->iFlags & Mask) != 0) && (false == is_fake_glow(Submodel));
|
|
}
|
|
|
|
bool scene_walk::is_fake_glow(TSubModel const *Submodel)
|
|
{
|
|
// kept when no lamp lights in their place: the local lights off, or gathered from nowhere (gfx_lights_range 0)
|
|
if (Global.gfx_lights_hideglow.empty() || (false == Global.gfx_lights_clustered) || (false == Global.gfx_lights_scenery) || (Global.gfx_lights_range <= 0.f) ||
|
|
(Submodel->m_material <= 0))
|
|
{
|
|
return false;
|
|
}
|
|
auto lookup{m_fakeglows.find(Submodel->m_material)};
|
|
if (lookup == m_fakeglows.end())
|
|
{
|
|
auto const fake{is_listed_glow(glow_name(walk_material_data(Submodel->m_material).GetName()), Global.gfx_lights_hideglow)};
|
|
lookup = m_fakeglows.emplace(Submodel->m_material, fake).first;
|
|
}
|
|
return lookup->second;
|
|
}
|
|
|
|
// the top view of the editor shows everything this close to the camera, the corners of the screen included
|
|
float scene_walk::editor_ortho_reach()
|
|
{
|
|
auto const aspect{Global.window_size.x / std::max(1.f, static_cast<float>(Global.window_size.y))};
|
|
return Global.EditorOrthoExtent * std::sqrt(1.f + aspect * aspect) + 500.f;
|
|
}
|
|
|
|
float scene_walk::editor_track_view_range(float const Range, bool const Apply)
|
|
{
|
|
if (false == Apply || false == Global.editor_tracks)
|
|
return Range;
|
|
float extra = 50000.0f;
|
|
if (Global.EditorOrtho)
|
|
extra = editor_ortho_reach();
|
|
return Range > extra ? Range : extra;
|
|
}
|
|
|
|
// the top view of the editor may leave the ballast of the railway out, for the ground under the tracks to show
|
|
bool scene_walk::editor_ballast_hidden(TTrack const *Track, bool const Colour)
|
|
{
|
|
return Colour && EditorModeFlag && Global.EditorOrtho && Global.EditorOrthoTracks > 0 && (Track->iCategoryFlag & 15) == 1;
|
|
}
|
|
|
|
// ...or the sleepers and the timbers of the switches too, the rails alone as on a plan
|
|
bool scene_walk::editor_sleepers_hidden()
|
|
{
|
|
return EditorModeFlag && Global.EditorOrtho && Global.EditorOrthoTracks > 1;
|
|
}
|
|
|
|
// far off the camera the tracks of the editor are drawn alone, the terrain, the models and the rest only as far as the
|
|
// scenery reaches in the game; the top view measures it off its centre on the ground, its camera being high above it
|
|
bool scene_walk::editor_far_tracks_only(bool const Apply, scene::bounding_area const &Area, glm::dvec3 const &Camera, double const SceneryLimit)
|
|
{
|
|
if (false == Apply)
|
|
return false;
|
|
auto offset{Area.center - Camera};
|
|
if (Global.EditorOrtho)
|
|
offset.y = 0.0;
|
|
double nearest = glm::length(offset) - static_cast<double>(Area.radius);
|
|
if (nearest < 0.0)
|
|
nearest = 0.0;
|
|
return nearest > SceneryLimit;
|
|
}
|
|
|
|
material_handle scene_walk::submodel_material( TSubModel const *Submodel ) {
|
|
|
|
if( Submodel->m_material >= 0 ) {
|
|
return Submodel->m_material;
|
|
}
|
|
return (
|
|
TSubModel::ReplacableSkinId != nullptr ?
|
|
TSubModel::ReplacableSkinId[ -Submodel->m_material ] :
|
|
null_handle );
|
|
}
|
|
|
|
glm::vec3 scene_walk::pick_color(std::size_t const Index)
|
|
{
|
|
return glm::vec3{((Index & 0xff0000) >> 16) / 255.0f, ((Index & 0x00ff00) >> 8) / 255.0f, (Index & 0x0000ff) / 255.0f};
|
|
}
|
|
|
|
std::size_t scene_walk::pick_index(glm::ivec3 const &Color)
|
|
{
|
|
return Color.b + (Color.g * 256) + (Color.r * 256 * 256);
|
|
}
|
|
|
|
bool scene_walk::Render_interior( bool const Alpha ) {
|
|
gfx::walk_sync::vehicle_hold hold;
|
|
// TODO: early frustum based cull, camera might be pointing elsewhere
|
|
std::vector< std::pair<float, TDynamicObject *> > dynamics;
|
|
auto *dynamic { simulation::Train->Dynamic() };
|
|
// draw interiors of the occupied vehicle, and all vehicles behind it with permanent coupling, in case they're open-ended
|
|
while( dynamic != nullptr ) {
|
|
|
|
glm::dvec3 const originoffset { dynamic->vPosition - m_renderpass.pass_camera.position() };
|
|
float const squaredistance{ glm::length2( glm::vec3{ originoffset } / Global.ZoomFactor ) };
|
|
dynamics.emplace_back( squaredistance, dynamic );
|
|
dynamic = dynamic->Next( coupling::permanent );
|
|
}
|
|
// draw also interiors of permanently coupled vehicles in front, if there's any
|
|
dynamic = simulation::Train->Dynamic()->Prev( coupling::permanent );
|
|
while( dynamic != nullptr ) {
|
|
|
|
glm::dvec3 const originoffset { dynamic->vPosition - m_renderpass.pass_camera.position() };
|
|
float const squaredistance{ glm::length2( glm::vec3{ originoffset } / Global.ZoomFactor ) };
|
|
dynamics.emplace_back( squaredistance, dynamic );
|
|
dynamic = dynamic->Prev( coupling::permanent );
|
|
}
|
|
if( Alpha ) {
|
|
std::sort(
|
|
std::begin( dynamics ), std::end( dynamics ),
|
|
[]( std::pair<float, TDynamicObject *> const &Left, std::pair<float, TDynamicObject *> const &Right ) {
|
|
return ( Left.first ) > ( Right.first ); } );
|
|
}
|
|
for( auto &dynamic : dynamics ) {
|
|
Render_lowpoly( dynamic.second, dynamic.first, true, Alpha );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool scene_walk::Render_lowpoly( TDynamicObject *Dynamic, float const Squaredistance, bool const Setup, bool const Alpha ) {
|
|
|
|
if( Dynamic->mdLowPolyInt == nullptr ) { return false; }
|
|
gfx::walk_sync::vehicle_hold hold;
|
|
|
|
// low poly interior
|
|
if( Setup ) {
|
|
|
|
TSubModel::iInstance = reinterpret_cast<std::uintptr_t>( Dynamic ); //żeby nie robić cudzych animacji
|
|
TSubModel::iVariantSeed = Dynamic->variant_seed();
|
|
glm::dvec3 const originoffset{ Dynamic->vPosition - m_renderpass.pass_camera.position() };
|
|
|
|
Dynamic->ABuLittleUpdate( Squaredistance ); // ustawianie zmiennych submodeli dla wspólnego modelu
|
|
|
|
glm::mat4 mv = OpenGLMatrices.data( GL_MODELVIEW );
|
|
|
|
::glPushMatrix();
|
|
::glTranslated( originoffset.x, originoffset.y, originoffset.z );
|
|
::glMultMatrixd( glm::value_ptr(Dynamic->mMatrix) );
|
|
}
|
|
// HACK: reduce light level for vehicle interior if there's strong global lighting source
|
|
if( false == Alpha ) {
|
|
/*
|
|
auto const luminance { static_cast<float>( std::min(
|
|
( Dynamic->fShade > 0.0 ? Dynamic->fShade * Global.fLuminance : Global.fLuminance ),
|
|
Global.fLuminance - 0.5 * ( std::max( 0.3, Global.fLuminance - Global.Overcast ) ) ) ) };
|
|
*/
|
|
auto const luminance{ static_cast<float>(
|
|
0.5
|
|
* ( std::max(
|
|
0.3,
|
|
( Global.fLuminance - Global.Overcast )
|
|
* gfx::vehicle_light_level( Dynamic ) ) ) ) };
|
|
walk_sunlight(
|
|
std::clamp( (
|
|
gfx::vehicle_shade( Dynamic ) > 0.f ?
|
|
gfx::vehicle_shade( Dynamic ) :
|
|
1.f )
|
|
- luminance,
|
|
0.f, 1.f ) );
|
|
// the sun coming in through the windows bounces around the interior
|
|
model_ubs.cab_interior = 2.f;
|
|
Render( Dynamic->mdLowPolyInt, Dynamic->Material(), Squaredistance );
|
|
// HACK: if the model has low poly interior, we presume the load is placed inside and also affected by reduced light level
|
|
if( Dynamic->mdLoad ) {
|
|
// renderowanie nieprzezroczystego ładunku
|
|
Render( Dynamic->mdLoad, Dynamic->Material(), Squaredistance, { 0.f, Dynamic->LoadOffset, 0.f }, {} );
|
|
}
|
|
model_ubs.cab_interior = 0.f;
|
|
walk_sunlight( gfx::vehicle_shade( Dynamic ) > 0.f ? gfx::vehicle_shade( Dynamic ) : 1.f );
|
|
}
|
|
else {
|
|
// Render_Alpha( Dynamic->mdLowPolyInt, Dynamic->Material(), Squaredistance );
|
|
// HACK: some models have windows included as part of the main model instead of lowpoly
|
|
if( Dynamic->mdModel ) {
|
|
// main model
|
|
Render_Alpha( Dynamic->mdModel, Dynamic->Material(), Squaredistance );
|
|
}
|
|
}
|
|
|
|
if( Setup ) {
|
|
|
|
if( gfx::vehicle_shade( Dynamic ) > 0.0f ) {
|
|
// restore regular light level
|
|
walk_sunlight();
|
|
}
|
|
|
|
::glPopMatrix();
|
|
|
|
// TODO: check if this reset is needed. In theory each object should render all parts based on its own instance data anyway?
|
|
if( Dynamic->btnOn ) {
|
|
Dynamic->TurnOff(); // przywrócenie domyślnych pozycji submodeli
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool scene_walk::Render_coupler_adapter( TDynamicObject *Dynamic, float const Squaredistance, int const End, bool const Alpha ) {
|
|
|
|
if( Dynamic->m_coupleradapters[ End ] == nullptr ) { return false; }
|
|
gfx::walk_sync::vehicle_hold hold;
|
|
|
|
auto const position { glm::dvec3 {
|
|
0.f,
|
|
Dynamic->MoverParameters->Couplers[ End ].adapter_height,
|
|
( Dynamic->MoverParameters->Couplers[ End ].adapter_length + Dynamic->MoverParameters->Dim.L * 0.5 ) * ( End == end::front ? 1 : -1 ) } };
|
|
|
|
auto const angle { glm::vec3{
|
|
0,
|
|
( End == end::front ? 0 : 180 ),
|
|
0 } };
|
|
|
|
if( Alpha ) {
|
|
Render_Alpha( Dynamic->m_coupleradapters[ End ], Dynamic->Material(), Squaredistance, position, angle );
|
|
}
|
|
else {
|
|
Render( Dynamic->m_coupleradapters[ End ], Dynamic->Material(), Squaredistance, position, angle );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void scene_walk::Render(scene::basic_region *Region)
|
|
{
|
|
|
|
m_sectionqueue.clear();
|
|
m_cellqueue.clear();
|
|
// discard last pass's accumulated instance buckets before this pass starts.
|
|
// the vectors themselves are kept, so their allocations get reused by the following passes
|
|
for( auto &bucket : m_frame_instance_buckets ) {
|
|
bucket.second.clear();
|
|
}
|
|
// the backend gets ready for the pass (the gpu culling of the opengl renderer)
|
|
walk_region_begin();
|
|
m_modelcpudistances.clear();
|
|
// build a list of region sections to render
|
|
glm::vec3 const cameraposition{m_renderpass.pass_camera.position()};
|
|
auto const camerax = static_cast<int>(std::floor(cameraposition.x / scene::EU07_SECTIONSIZE + scene::EU07_REGIONSIDESECTIONCOUNT / 2));
|
|
auto const cameraz = static_cast<int>(std::floor(cameraposition.z / scene::EU07_SECTIONSIZE + scene::EU07_REGIONSIDESECTIONCOUNT / 2));
|
|
float section_range = m_renderpass.draw_range * Global.fDistanceFactor;
|
|
section_range = editor_track_view_range(section_range, EditorModeFlag && (m_renderpass.draw_mode == rendermode::color || m_renderpass.draw_mode == rendermode::pickscenery));
|
|
int const segmentcount = 2 * static_cast<int>(std::ceil(section_range / scene::EU07_SECTIONSIZE));
|
|
int const originx = camerax - segmentcount / 2;
|
|
int const originz = cameraz - segmentcount / 2;
|
|
|
|
for (int row = originz; row <= originz + segmentcount; ++row)
|
|
{
|
|
if (row < 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (row >= scene::EU07_REGIONSIDESECTIONCOUNT)
|
|
{
|
|
break;
|
|
}
|
|
for (int column = originx; column <= originx + segmentcount; ++column)
|
|
{
|
|
if (column < 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (column >= scene::EU07_REGIONSIDESECTIONCOUNT)
|
|
{
|
|
break;
|
|
}
|
|
auto *section{Region->m_sections[row * scene::EU07_REGIONSIDESECTIONCOUNT + column]};
|
|
if ((section != nullptr) && (m_renderpass.pass_camera.visible(section->m_area)))
|
|
{
|
|
m_sectionqueue.emplace_back(section);
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
{
|
|
Render(std::begin(m_sectionqueue), std::end(m_sectionqueue));
|
|
// draw queue is filled while rendering sections
|
|
if (EditorModeFlag)
|
|
{
|
|
// when editor mode is active calculate world position of the cursor
|
|
// at this stage the z-buffer is filled with only ground geometry
|
|
walk_editor_cursor();
|
|
}
|
|
// draw opaque cells front-to-back: with the depth test enabled this
|
|
// lets the GPU reject hidden fragments early, before the (expensive)
|
|
// lit fragment shader runs on them. Order is irrelevant to the final
|
|
// image for opaque geometry, so this is purely a fill-rate win.
|
|
std::sort( std::begin( m_cellqueue ), std::end( m_cellqueue ),
|
|
[]( distancecell_pair const &Left, distancecell_pair const &Right ) { return Left.first < Right.first; } );
|
|
Render(std::begin(m_cellqueue), std::end(m_cellqueue));
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
case rendermode::pickscenery:
|
|
{
|
|
// these render modes don't bother with lights
|
|
Render(std::begin(m_sectionqueue), std::end(m_sectionqueue));
|
|
// they can also skip queue sorting, as they only deal with opaque geometry
|
|
// NOTE: there's benefit from rendering front-to-back, but is it significant enough? TODO: investigate
|
|
Render(std::begin(m_cellqueue), std::end(m_cellqueue));
|
|
break;
|
|
}
|
|
case rendermode::reflections:
|
|
{
|
|
Render(std::begin(m_sectionqueue), std::end(m_sectionqueue));
|
|
if( Global.reflectiontune.fidelity >= 1 ) {
|
|
Render(std::begin(m_cellqueue), std::end(m_cellqueue));
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::pickcontrols:
|
|
default:
|
|
{
|
|
// no need to render anything ourside of the cab in control picking mode
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void scene_walk::Render(section_sequence::iterator First, section_sequence::iterator Last)
|
|
{
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
case rendermode::shadows:
|
|
break;
|
|
case rendermode::pickscenery:
|
|
{
|
|
// non-interactive scenery elements get neutral colour
|
|
model_ubs.param[0] = colors::none;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// the ground of the sections far off, the terrain of the editor among it, isn't drawn with the tracks reaching there
|
|
auto const scenery_limit{static_cast<double>(Global.BaseDrawRange) * Global.fDistanceFactor + 250.0};
|
|
bool const far_paths{EditorModeFlag && Global.editor_tracks && (m_renderpass.draw_mode == rendermode::color || m_renderpass.draw_mode == rendermode::pickscenery)};
|
|
glm::dvec3 const camera{m_renderpass.pass_camera.position()};
|
|
|
|
while (First != Last)
|
|
{
|
|
|
|
auto *section = *First;
|
|
gfx::walk_sync::yield();
|
|
{
|
|
// made by the first walk which needs it, one at a time (walk_sync)
|
|
gfx::walk_sync::change change{section->geometry_pending()};
|
|
section->create_geometry();
|
|
}
|
|
|
|
// render shapes held by the section
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
case rendermode::shadows:
|
|
case rendermode::pickscenery:
|
|
{
|
|
if (false == section->m_shapes.empty() && false == editor_far_tracks_only(far_paths, section->m_area, camera, scenery_limit))
|
|
{
|
|
// since all shapes of the section share center point we can optimize out a few calls here
|
|
::glPushMatrix();
|
|
auto const originoffset{section->m_area.center - m_renderpass.pass_camera.position()};
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
// render
|
|
for (auto const &shape : section->m_shapes)
|
|
{
|
|
Render(shape, true);
|
|
}
|
|
// post-render cleanup
|
|
::glPopMatrix();
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::pickcontrols:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// add the section's cells to the cell queue
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
case rendermode::shadows:
|
|
case rendermode::pickscenery:
|
|
{
|
|
// TBD, TODO: refactor into a method to reuse below?
|
|
for (auto &cell : section->m_cells)
|
|
{
|
|
if ((true == cell.m_active) && (m_renderpass.pass_camera.visible(cell.m_area)))
|
|
{
|
|
// store visible cells with content as well as their current distance, for sorting later
|
|
m_cellqueue.emplace_back(glm::length2(m_renderpass.pass_camera.position() - cell.m_area.center), &cell);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::reflections:
|
|
{
|
|
// we can skip filling the cell queue if reflections pass isn't going to use it
|
|
if( Global.reflectiontune.fidelity == 0 ) { break; }
|
|
for (auto &cell : section->m_cells)
|
|
{
|
|
if ((true == cell.m_active) && (m_renderpass.pass_camera.visible(cell.m_area)))
|
|
{
|
|
// store visible cells with content as well as their current distance, for sorting later
|
|
m_cellqueue.emplace_back(glm::length2(m_renderpass.pass_camera.position() - cell.m_area.center), &cell);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::pickcontrols:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
// proceed to next section
|
|
++First;
|
|
}
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::shadows:
|
|
{
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void scene_walk::Render(cell_sequence::iterator First, cell_sequence::iterator Last)
|
|
{
|
|
|
|
// cache initial iterator for the second sweep
|
|
auto first{First};
|
|
auto const scenery_limit{static_cast<double>(Global.BaseDrawRange) * Global.fDistanceFactor + 250.0};
|
|
bool const far_paths{EditorModeFlag && Global.editor_tracks && (m_renderpass.draw_mode == rendermode::color || m_renderpass.draw_mode == rendermode::pickscenery)};
|
|
glm::dvec3 const camera{m_renderpass.pass_camera.position()};
|
|
// first pass draws elements which we know are located in section banks, to reduce vbo switching
|
|
while (First != Last)
|
|
{
|
|
|
|
auto *cell = First->second;
|
|
gfx::walk_sync::yield();
|
|
{
|
|
// przeliczenia animacji torów w sektorze
|
|
gfx::walk_sync::change change{cell->animation_pending(m_framestamp)};
|
|
cell->RaAnimate(m_framestamp);
|
|
}
|
|
bool const tracks_only{editor_far_tracks_only(far_paths, cell->m_area, camera, scenery_limit)};
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
{
|
|
// since all shapes of the section share center point we can optimize out a few calls here
|
|
::glPushMatrix();
|
|
auto const originoffset{cell->m_area.center - m_renderpass.pass_camera.position()};
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
|
|
// render
|
|
// opaque non-instanced shapes
|
|
if (false == tracks_only)
|
|
{
|
|
for (auto const &shape : cell->m_shapesopaque)
|
|
{
|
|
Render(shape, false);
|
|
}
|
|
}
|
|
// tracks
|
|
// TODO: update after path node refactoring
|
|
Render(std::begin(cell->m_paths), std::end(cell->m_paths));
|
|
// post-render cleanup
|
|
::glPopMatrix();
|
|
|
|
break;
|
|
}
|
|
case rendermode::reflections:
|
|
{
|
|
// since all shapes of the section share center point we can optimize out a few calls here
|
|
::glPushMatrix();
|
|
auto const originoffset{cell->m_area.center - m_renderpass.pass_camera.position()};
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
|
|
// render
|
|
// opaque non-instanced shapes
|
|
for (auto const &shape : cell->m_shapesopaque)
|
|
Render(shape, false);
|
|
// tracks: the ray traced reflections (the one user of this mode) show the trackbed and the platforms made of roads
|
|
Render(std::begin(cell->m_paths), std::end(cell->m_paths));
|
|
|
|
// post-render cleanup
|
|
::glPopMatrix();
|
|
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
{
|
|
// since all shapes of the section share center point we can optimize out a few calls here
|
|
::glPushMatrix();
|
|
auto const originoffset{cell->m_area.center - m_renderpass.pass_camera.position()};
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
|
|
// render
|
|
// opaque non-instanced shapes
|
|
for (auto const &shape : cell->m_shapesopaque)
|
|
Render(shape, false);
|
|
// tracks
|
|
Render(std::begin(cell->m_paths), std::end(cell->m_paths));
|
|
|
|
// post-render cleanup
|
|
::glPopMatrix();
|
|
|
|
break;
|
|
}
|
|
case rendermode::pickscenery:
|
|
{
|
|
// same procedure like with regular render, but editor-enabled nodes receive custom colour used for picking
|
|
// since all shapes of the section share center point we can optimize out a few calls here
|
|
::glPushMatrix();
|
|
auto const originoffset{cell->m_area.center - m_renderpass.pass_camera.position()};
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
// render
|
|
// opaque non-instanced shapes
|
|
// non-interactive scenery elements get neutral colour
|
|
if (false == tracks_only)
|
|
{
|
|
model_ubs.param[0] = colors::none;
|
|
for (auto const &shape : cell->m_shapesopaque)
|
|
Render(shape, false);
|
|
}
|
|
// tracks
|
|
for (auto *path : cell->m_paths)
|
|
{
|
|
model_ubs.param[0] = glm::vec4(pick_color(m_picksceneryitems.size() + 1), 1.0f);
|
|
Render(path);
|
|
}
|
|
// post-render cleanup
|
|
::glPopMatrix();
|
|
break;
|
|
}
|
|
case rendermode::pickcontrols:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
++First;
|
|
}
|
|
// the sleepers and timbers of the tracks of all the cells at once
|
|
Flush_Timbers();
|
|
// second pass draws elements with their own vbos
|
|
while (first != Last)
|
|
{
|
|
|
|
auto const *cell = first->second;
|
|
gfx::walk_sync::yield();
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
case rendermode::shadows:
|
|
{
|
|
if (editor_far_tracks_only(far_paths, cell->m_area, camera, scenery_limit))
|
|
break;
|
|
// TBD, TODO: refactor in to a method to reuse in branch below?
|
|
// opaque parts of instanced models -- accumulate this cell's buckets
|
|
// into the frame-level map; the actual Render_Instanced() calls are
|
|
// issued once per unique model after the cell loop (see flush below).
|
|
//
|
|
// Cell-level far-distance pre-cull: when the whole cell lies beyond
|
|
// the instance draw distance, every instance in it would fail the
|
|
// per-instance drawdistancethreshold test inside Render_Instanced(),
|
|
// so there is no point merging its buckets into the frame map. The
|
|
// test reproduces Render_Instanced()'s distance maths exactly -- same
|
|
// ZoomFactor / fDistanceFactor scaling, same +250 margin -- applied to
|
|
// the nearest point of the cell's bounding sphere. basic_cell::enclose_area
|
|
// guarantees m_area.radius >= |m_area.center - instance.location()| for
|
|
// every contained instance, so the nearest-point distance is a true
|
|
// lower bound on every instance's distance: the cull can never drop a
|
|
// cell that still holds a drawable instance. Shadows measure from the
|
|
// real (viewport) camera, matching Render_Instanced()'s shadow branch;
|
|
// every other gated mode measures from the pass camera. Non-instanced
|
|
// scenery drawn by the cpu and vehicles below keep their own per-node
|
|
// culling and are intentionally left untouched; the non-instanced models
|
|
// culled on the gpu (Queue_Model()) are left out with the cell the same way.
|
|
{
|
|
auto const &distancecamera = (
|
|
m_renderpass.draw_mode == rendermode::shadows
|
|
? m_renderpass.viewport_camera
|
|
: m_renderpass.pass_camera );
|
|
auto const cellcenterdistance { glm::length( cell->m_area.center - distancecamera.position() ) };
|
|
auto const cellnearestdistance { std::max( 0.0, cellcenterdistance - cell->m_area.radius ) };
|
|
auto const cellnearestdistancesquared {
|
|
( cellnearestdistance * cellnearestdistance )
|
|
/ ( static_cast<double>( Global.ZoomFactor ) * static_cast<double>( Global.ZoomFactor ) )
|
|
/ static_cast<double>( Global.fDistanceFactor ) };
|
|
auto const cellinrange { cellnearestdistancesquared <= sq( static_cast<double>( m_renderpass.draw_range ) + 250.0 ) };
|
|
if( cellinrange ) {
|
|
Queue_Instances( cell );
|
|
}
|
|
// remaining (non-instanceable) opaque instance nodes go through the per-node path, or with the instances
|
|
// to the gpu culling, each on its own
|
|
// (the instanceable ones are handled via bucket)
|
|
for (auto *instance : Single_Instances(*cell))
|
|
{
|
|
// the model of a lamp would shadow everything in the map of the lamp
|
|
if( instance == m_cubeskipinstance ) { continue; }
|
|
if( walk_queue_model( instance, cellinrange ) ) { continue; }
|
|
Render(instance);
|
|
m_modelcomparekey = nullptr;
|
|
}
|
|
}
|
|
// opaque parts of vehicles. the kept scenery part of the map of a lamp is drawn without them
|
|
if( false == m_cubescenery ) {
|
|
for (auto *path : cell->m_paths)
|
|
{
|
|
for (auto *dynamic : path->Dynamics)
|
|
{
|
|
// the vehicle of the headlights a map is drawn for would cover all of it
|
|
if (dynamic == m_shadowskipvehicle)
|
|
continue;
|
|
Render(dynamic);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::reflections:
|
|
{
|
|
// a cell lying whole beyond the range the reflections draw model instances at is left out, as each
|
|
// of its instances would fail the range test done for it in Render_Instanced() and Render( TAnimModel * ).
|
|
// like the cull of the regular passes above, the test goes by the nearest point of the bounding sphere
|
|
// of the cell, which holds the locations of all its instances
|
|
auto const cellnearestdistance { std::max( 0.0, glm::length( cell->m_area.center - m_renderpass.pass_camera.position() ) - cell->m_area.radius ) };
|
|
if( ( Global.reflectiontune.fidelity >= 1 )
|
|
&& ( cellnearestdistance <= Global.reflectiontune.range_instances ) ) {
|
|
// opaque parts of instanced models -- accumulate into the
|
|
// frame-level map; flushed once per unique model after the loop.
|
|
Queue_Instances( cell );
|
|
for( auto *instance : Single_Instances( *cell ) ) {
|
|
if( walk_queue_model( instance, true ) ) { continue; }
|
|
Render( instance );
|
|
m_modelcomparekey = nullptr;
|
|
}
|
|
}
|
|
if( Global.reflectiontune.fidelity >= 2 ) {
|
|
// opaque parts of vehicles, but the one the backend leaves out (the vehicle of the cab, seen from the inside)
|
|
for( auto *path : cell->m_paths ) {
|
|
for( auto *dynamic : path->Dynamics ) {
|
|
if( dynamic == m_shadowskipvehicle ) { continue; }
|
|
Render( dynamic );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::pickscenery:
|
|
{
|
|
if (editor_far_tracks_only(far_paths, cell->m_area, camera, scenery_limit))
|
|
break;
|
|
// opaque parts of instanced models
|
|
// same procedure like with regular render, but each node receives custom colour used for picking.
|
|
// picking always uses the per-instance path because each instance needs a unique pick colour;
|
|
// batching would assign the same colour to every instance in the bucket.
|
|
for (auto *instance : cell->m_instancesopaque)
|
|
{
|
|
model_ubs.param[0] = glm::vec4(pick_color(m_picksceneryitems.size() + 1), 1.0f);
|
|
Render(instance);
|
|
}
|
|
// vehicles aren't included in scenery picking for the time being
|
|
break;
|
|
}
|
|
case rendermode::pickcontrols:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
++first;
|
|
}
|
|
|
|
// flush accumulated instance buckets: issue one Render_Instanced() per unique
|
|
// (TModel3d*, skins) key across every cell visited in this pass, instead of
|
|
// one call per cell. All per-instance frustum/distance/pixel-area culling
|
|
// still happens inside Render_Instanced(), so correctness is unchanged -- only
|
|
// the number of calls and glBufferSubData round-trips drops sharply.
|
|
// (For pickscenery/pickcontrols modes the map stays empty, so this is a no-op.)
|
|
// what the backend draws of the instances itself (the gpu culling of the opengl renderer), and the comparison with it
|
|
auto const compare { walk_instances_begin() };
|
|
for( auto &bucket : m_frame_instance_buckets ) {
|
|
if( bucket.second.empty() ) { continue; }
|
|
gfx::walk_sync::yield();
|
|
Render_Instanced( bucket.first.pModel, bucket.second, ( compare ? &m_instance_bandcounts : nullptr ) );
|
|
if( compare ) {
|
|
walk_instances_compare( bucket.first, m_instance_bandcounts );
|
|
}
|
|
bucket.second.clear();
|
|
}
|
|
walk_instances_end();
|
|
m_modelcpudistances.clear();
|
|
}
|
|
|
|
void scene_walk::Render(scene::shape_node const &Shape, bool const Ignorerange)
|
|
{
|
|
auto const &data{Shape.data()};
|
|
|
|
// a shape lying wholly outside the view of the pass draws nothing. the section and the cell holding it were tested as a
|
|
// whole, while a section holds the chunks of the heightmap terrain (250 m each, 16 of them) and the large shapes of the
|
|
// scenery, drawn in every pass the section is seen in: in a cascade of the sun shadows or a face of the environment map
|
|
// most of them are out of view. a shape merged from others has its radius invalidated (-1) and keeps being drawn
|
|
if ((data.area.radius > 0.f) && (false == m_renderpass.pass_camera.visible(data.area)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (false == Ignorerange)
|
|
{
|
|
double distancesquared;
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::shadows:
|
|
{
|
|
// 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
|
|
distancesquared = glm::length2((data.area.center - m_renderpass.viewport_camera.position()) / (double)Global.ZoomFactor) / Global.fDistanceFactor;
|
|
break;
|
|
}
|
|
case rendermode::reflections:
|
|
{
|
|
// reflection mode draws simplified version of the shapes, by artificially increasing view range
|
|
distancesquared =
|
|
// TBD, TODO: bind offset value with setting variable?
|
|
sq(EU07_REFLECTIONFIDELITYOFFSET)
|
|
+ glm::length2( ( data.area.center - m_renderpass.pass_camera.position() ) );
|
|
/*
|
|
// TBD: take into account distance multipliers?
|
|
/ Global.fDistanceFactor;
|
|
*/
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
distancesquared = glm::length2((data.area.center - m_renderpass.pass_camera.position()) / (double)Global.ZoomFactor) / Global.fDistanceFactor;
|
|
break;
|
|
}
|
|
}
|
|
if ((distancesquared < data.rangesquared_min) || (distancesquared >= data.rangesquared_max))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// setup
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
walk_material(data.material, nullptr, &Shape.data().lighting );
|
|
break;
|
|
case rendermode::shadows:
|
|
// skip if the shadow caster rank is too low for currently set threshold
|
|
if( walk_material_data( data.material ).shadow_rank > Global.gfx_shadow_rank_cutoff )
|
|
return;
|
|
walk_shadow_material(data.material);
|
|
break;
|
|
case rendermode::pickscenery:
|
|
case rendermode::pickcontrols:
|
|
walk_program( walk_shader::pick );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
// render
|
|
auto const decal{data.decal && (m_renderpass.draw_mode != rendermode::shadows)};
|
|
if (decal)
|
|
{
|
|
walk_decal(true);
|
|
}
|
|
walk_draw(data.geometry);
|
|
if (decal)
|
|
{
|
|
walk_decal(false);
|
|
}
|
|
// debug data
|
|
++m_renderpass.draw_stats.shapes;
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
}
|
|
|
|
void scene_walk::Render(TAnimModel *Instance)
|
|
{
|
|
|
|
if (false == Instance->m_visible) { return; }
|
|
if( false == m_renderpass.pass_camera.visible( Instance->m_area ) ) { return; }
|
|
|
|
double distancesquared;
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::shadows:
|
|
{
|
|
// 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
|
|
distancesquared = glm::length2((Instance->location() - m_renderpass.viewport_camera.position()) / (double)Global.ZoomFactor) / Global.fDistanceFactor;
|
|
break;
|
|
}
|
|
case rendermode::reflections:
|
|
{
|
|
// reflection mode draws simplified version of the shapes, by artificially increasing view range
|
|
// it also ignores zoom settings and distance multipliers
|
|
// TBD: take into account distance multipliers?
|
|
distancesquared = glm::length2((Instance->location() - m_renderpass.pass_camera.position())) /* / Global.fDistanceFactor */;
|
|
// NOTE: arbitrary draw range limit
|
|
if( distancesquared > Global.reflectiontune.range_instances * Global.reflectiontune.range_instances ) {
|
|
return;
|
|
}
|
|
// TBD, TODO: bind offset value with setting variable?
|
|
distancesquared += sq(EU07_REFLECTIONFIDELITYOFFSET);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
distancesquared = glm::length2((Instance->location() - m_renderpass.pass_camera.position()) / (double)Global.ZoomFactor) / Global.fDistanceFactor;
|
|
break;
|
|
}
|
|
}
|
|
if ((distancesquared < Instance->m_rangesquaredmin) || (distancesquared >= Instance->m_rangesquaredmax))
|
|
{
|
|
return;
|
|
}
|
|
// crude way to reject early items too far to affect the output (mostly relevant for shadow passes)
|
|
auto const drawdistancethreshold{ m_renderpass.draw_range + 250 };
|
|
if( distancesquared > sq(drawdistancethreshold) ) {
|
|
return;
|
|
}
|
|
// second stage visibility cull, reject modelstoo far away to be noticeable
|
|
auto const radiussquared { Instance->radius() * Instance->radius() };
|
|
if( radiussquared * Global.ZoomFactor / distancesquared < 0.003 * 0.003 ) {
|
|
return;
|
|
}
|
|
if( m_modelcomparekey != nullptr ) {
|
|
// queued in the gpu culling as well, to compare with (Queue_Model())
|
|
m_modelcpudistances.emplace_back( *m_modelcomparekey, static_cast<float>( distancesquared ) );
|
|
}
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::pickscenery:
|
|
{
|
|
// add the node to the pick list
|
|
m_picksceneryitems.emplace_back(Instance);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// the animations and the lights of the instance are set in the model the instances share, held till it's drawn (walk_sync)
|
|
gfx::walk_sync::model_hold hold{Instance->pModel};
|
|
Instance->RaAnimate(m_framestamp); // jednorazowe przeliczenie animacji
|
|
Instance->RaPrepare();
|
|
if (Instance->pModel)
|
|
{
|
|
// per-instance uniform scale: applied between the rotation and the
|
|
// submodel-local transform chain. Pushing it on the matrix stack here
|
|
// means Render(TModel3d, ..., position, angle) doesn't need a new
|
|
// signature and the same scale flows naturally into Render_Alpha and
|
|
// any other recursive callers.
|
|
auto const &scale = Instance->Scale();
|
|
bool const scaled = ( scale.x != 1.0f || scale.y != 1.0f || scale.z != 1.0f );
|
|
if( scaled ) {
|
|
// Per-axis scale applied between rotation and the submodel-local
|
|
// chain: build the per-instance transform here so we can inject
|
|
// glScalef before the submodel walk.
|
|
::glPushMatrix();
|
|
auto const Position = Instance->location() - m_renderpass.pass_camera.position();
|
|
auto const Angle = Instance->vAngle;
|
|
::glTranslated( Position.x, Position.y, Position.z );
|
|
if( Angle.y != 0.0 ) ::glRotated( Angle.y, 0.f, 1.f, 0.f );
|
|
if( Angle.x != 0.0 ) ::glRotated( Angle.x, 1.f, 0.f, 0.f );
|
|
if( Angle.z != 0.0 ) ::glRotated( Angle.z, 0.f, 0.f, 1.f );
|
|
::glScalef( scale.x, scale.y, scale.z );
|
|
Render( Instance->pModel, Instance->Material(), distancesquared );
|
|
::glPopMatrix();
|
|
}
|
|
else {
|
|
// fast path for unscaled (the common case): existing behaviour
|
|
Render(Instance->pModel, Instance->Material(), distancesquared, Instance->location() - m_renderpass.pass_camera.position(), Instance->vAngle);
|
|
}
|
|
// debug data
|
|
++m_renderpass.draw_stats.models;
|
|
}
|
|
}
|
|
|
|
// adds the bucketed instances of a scene cell to the frame-level buckets, for Render_Instanced() to draw.
|
|
// Render_Instanced() culls each instance it's given by its record. the tests it makes are repeated here, with some slack
|
|
// for the single precision of the records, and the instances which fail are left out of the queue
|
|
void scene_walk::Queue_Instances( scene::basic_cell const *Cell )
|
|
{
|
|
// the editor moves and resizes the instances in place. the records are made anew for each frame then,
|
|
// but aren't relied on to leave instances out of the queue
|
|
auto const userecords { false == EditorModeFlag };
|
|
auto const reflections { m_renderpass.draw_mode == rendermode::reflections };
|
|
// same choices as in Render_Instanced(): shadows measure the distance from the real camera, reflections
|
|
// ignore zoom and distance factor, test the plain distance against their own range and add the fidelity offset
|
|
auto const &distancecamera { m_renderpass.draw_mode == rendermode::shadows ? m_renderpass.viewport_camera : m_renderpass.pass_camera };
|
|
glm::dvec3 const cameraposition { distancecamera.position() };
|
|
auto const distancescale { reflections ? 1.0 : 1.0 / ( static_cast<double>( Global.ZoomFactor ) * static_cast<double>( Global.ZoomFactor ) * static_cast<double>( Global.fDistanceFactor ) ) };
|
|
auto const distanceoffset { reflections ? sq( static_cast<double>( EU07_REFLECTIONFIDELITYOFFSET ) ) : 0.0 };
|
|
auto const slack { 1.001 };
|
|
auto const distancelimit { slack * ( reflections ? sq( static_cast<double>( Global.reflectiontune.range_instances ) ) : sq( static_cast<double>( m_renderpass.draw_range ) + 250.0 ) ) };
|
|
// up close the rounding of the records is too large a part of the distance for the slack to cover it
|
|
auto const distancetested { sq( 64.0 ) };
|
|
// a bucket whose visible instances all fail the tests of the culling by the bounds of their records (Bucket_Culled()) is left
|
|
// out of the pass before the culling. the bounds are made with the records, which the editor doesn't let go by
|
|
auto const buckettests { Global.gfx_gpucull_bucketrange && userecords };
|
|
|
|
for( auto const &bucket : Cell->m_instancebuckets_opaque ) {
|
|
auto const &instancebucket { bucket.second };
|
|
auto const stale = [ & ]() {
|
|
return ( instancebucket.recordsversion != m_instancerecordsversion )
|
|
|| ( instancebucket.records.size() != instancebucket.instances.size() ); };
|
|
if( stale() ) {
|
|
// the records the passes share are made by one walk at a time (walk_sync)
|
|
gfx::walk_sync::change change;
|
|
if( stale() ) {
|
|
Update_Instance_Records( bucket.first.pModel, instancebucket, Cell->m_area.center );
|
|
}
|
|
}
|
|
if( buckettests && Bucket_Culled( instancebucket ) ) {
|
|
walk_bucket_culled( instancebucket );
|
|
continue;
|
|
}
|
|
// the backend may draw the instances of the bucket itself (the gpu culling of the opengl renderer); the lod bands drawn go
|
|
// by the distances the locations of the instances can be at: of their own bounds, or of the cell, which holds them too
|
|
if( false == walk_bucket( bucket.first, instancebucket, buckettests, Cell->m_area ) ) { continue; }
|
|
auto const &records { instancebucket.records };
|
|
std::vector<queued_instance> *dest { nullptr }; // looked up when there's something to put in it
|
|
for( std::size_t idx = 0; idx < records.size(); ++idx ) {
|
|
if( userecords ) {
|
|
auto const &record { records[ idx ] };
|
|
auto const center { instancebucket.recordorigin + glm::dvec3{ record.position } };
|
|
auto const distancesquared { glm::length2( center - cameraposition ) };
|
|
if( distancesquared > distancetested ) {
|
|
auto const scaleddistancesquared { distancesquared * distancescale };
|
|
if( scaleddistancesquared > distancelimit ) { continue; }
|
|
if( scaleddistancesquared + distanceoffset >= slack * std::min( instancebucket.lodrangesquared, record.rangesquaredmax ) ) { continue; }
|
|
}
|
|
if( false == m_renderpass.pass_camera.visible( scene::bounding_area{ center, record.radius } ) ) { continue; }
|
|
}
|
|
if( dest == nullptr ) {
|
|
dest = &m_frame_instance_buckets[ bucket.first ];
|
|
}
|
|
dest->push_back( { &instancebucket, idx } );
|
|
}
|
|
}
|
|
}
|
|
|
|
// makes the records of the instances held by a bucket of a scene cell, with locations relative to Origin
|
|
void scene_walk::Update_Instance_Records( TModel3d const *Model, scene::basic_cell::instance_bucket const &Bucket, glm::dvec3 const &Origin )
|
|
{
|
|
// a submodel is drawn only closer than its fSquareMaxDist, see Render( TSubModel * ). past the largest of these
|
|
// there's nothing of the model left to draw, which makes it another limit of the range of its instances
|
|
auto lodrangesquared { ( Model != nullptr && Model->Root != nullptr ) ? 0.f : std::numeric_limits<float>::max() };
|
|
m_instance_lodpending.clear();
|
|
m_instance_lodpending.push_back( Model != nullptr ? Model->Root : nullptr );
|
|
while( false == m_instance_lodpending.empty() ) {
|
|
auto const *submodel = m_instance_lodpending.back();
|
|
m_instance_lodpending.pop_back();
|
|
if( submodel == nullptr ) { continue; }
|
|
lodrangesquared = std::max( lodrangesquared, submodel->fSquareMaxDist );
|
|
m_instance_lodpending.push_back( submodel->Child );
|
|
m_instance_lodpending.push_back( submodel->Next );
|
|
}
|
|
Bucket.lodrangesquared = lodrangesquared;
|
|
Bucket.recordorigin = Origin;
|
|
|
|
auto const tofloat = []( double const Value ) {
|
|
return static_cast<float>( std::min( Value, static_cast<double>( std::numeric_limits<float>::max() ) ) ); };
|
|
|
|
Bucket.records.clear();
|
|
Bucket.records.reserve( Bucket.instances.size() );
|
|
// the range of the bucket: past it none of its instances is drawn, by its own range or by the submodels of the model
|
|
auto rangesquared { 0.f };
|
|
for( auto *instance : Bucket.instances ) {
|
|
scene::basic_cell::instance_record record;
|
|
if( instance != nullptr ) {
|
|
record.position = packed_vec3{ instance->location() - Origin };
|
|
record.radius = instance->radius();
|
|
record.rangesquaredmin = tofloat( instance->m_rangesquaredmin );
|
|
record.rangesquaredmax = tofloat( instance->m_rangesquaredmax );
|
|
rangesquared = std::max( rangesquared, record.rangesquaredmax );
|
|
record.flags =
|
|
( instance->visible() ? scene::basic_cell::instance_visible : 0u )
|
|
| ( instance->m_instanceable ? scene::basic_cell::instance_instanceable : 0u );
|
|
auto const &rotationscale { instance->rotation_scale() };
|
|
for( int column = 0; column < 3; ++column ) {
|
|
record.rotationscale[ column ] = rotationscale[ column ];
|
|
}
|
|
}
|
|
// an empty slot keeps its record without flags, and isn't drawn
|
|
Bucket.records.emplace_back( record );
|
|
}
|
|
Bucket.rangesquared = std::min( rangesquared, lodrangesquared );
|
|
|
|
// bounds of the visible instances, for Bucket_Culled(): the centre of the box around their locations, and the spheres
|
|
// around it which hold the locations and the instances whole. the gpu leaves out the ones which aren't visible
|
|
glm::dvec3 low { std::numeric_limits<double>::max() };
|
|
glm::dvec3 high { std::numeric_limits<double>::lowest() };
|
|
auto radiusmax { 0.f };
|
|
for( auto const &record : Bucket.records ) {
|
|
if( ( record.flags & scene::basic_cell::instance_visible ) == 0 ) { continue; }
|
|
glm::dvec3 const position { record.position };
|
|
low = glm::min( low, position );
|
|
high = glm::max( high, position );
|
|
radiusmax = std::max( radiusmax, record.radius );
|
|
}
|
|
Bucket.recordlocationradius = 0.f;
|
|
Bucket.recordradius = -1.f;
|
|
Bucket.recordradiusmax = radiusmax;
|
|
if( low.x <= high.x ) {
|
|
auto const center { 0.5 * ( low + high ) };
|
|
auto locationradius { 0.0 };
|
|
auto radius { 0.0 };
|
|
for( auto const &record : Bucket.records ) {
|
|
if( ( record.flags & scene::basic_cell::instance_visible ) == 0 ) { continue; }
|
|
auto const distance { glm::length( glm::dvec3{ record.position } - center ) };
|
|
locationradius = std::max( locationradius, distance );
|
|
radius = std::max( radius, distance + record.radius );
|
|
}
|
|
Bucket.recordcenter = Origin + center;
|
|
Bucket.recordlocationradius = static_cast<float>( locationradius );
|
|
Bucket.recordradius = static_cast<float>( radius );
|
|
}
|
|
else {
|
|
Bucket.recordcenter = Origin;
|
|
}
|
|
Bucket.recordsversion = m_instancerecordsversion;
|
|
Bucket.gpustale = true;
|
|
}
|
|
|
|
// the opaque instances of a scene cell drawn each on its own. an instance stops being drawn with the others of its model by an event
|
|
// (TAnimModel::AddContainer()), which changes scene::node_state_version and with it the version of the instance records; the editor
|
|
// makes the records anew in every frame. the list is made once for a version, before any walk of the frame reads it, so a walk going
|
|
// through it doesn't see it change
|
|
scene::basic_cell::instance_sequence const &scene_walk::Single_Instances( scene::basic_cell const &Cell ) const
|
|
{
|
|
auto const stale = [ this, &Cell ]() {
|
|
return ( Cell.m_instancessingleversion != m_instancerecordsversion )
|
|
|| ( Cell.m_instancessinglesource != Cell.m_instancesopaque.size() ); };
|
|
if( stale() ) {
|
|
// the lists the passes share are made by one walk at a time (walk_sync)
|
|
gfx::walk_sync::change change;
|
|
if( stale() ) {
|
|
Cell.m_instancessingle.clear();
|
|
for( auto *instance : Cell.m_instancesopaque ) {
|
|
if( false == instance->m_instanceable ) {
|
|
Cell.m_instancessingle.emplace_back( instance );
|
|
}
|
|
}
|
|
Cell.m_instancessinglesource = Cell.m_instancesopaque.size();
|
|
Cell.m_instancessingleversion = m_instancerecordsversion;
|
|
}
|
|
}
|
|
return Cell.m_instancessingle;
|
|
}
|
|
|
|
// whether none of the instances of a bucket can pass the tests of the culling of the pass (Render_Instanced(), on the gpu
|
|
// instance_cull.comp): by the bounds of their records the visible ones lie wholly out of the frustum of the pass, beyond their
|
|
// range or the draw range, or are too small on the screen. the tests are those of the culling with the nearest location and
|
|
// the largest instance of the bucket, with a margin for the single precision of the records and of the gpu, so they leave out
|
|
// only buckets which the culling would leave out whole
|
|
bool scene_walk::Bucket_Culled( scene::basic_cell::instance_bucket const &Bucket ) const
|
|
{
|
|
if( Bucket.recordradius < 0.f ) { return true; }
|
|
|
|
auto const slack { 1.001 };
|
|
auto const margin { 0.5 }; // metres
|
|
// the planes of the frustum in world coordinates, the ones the gpu culling moves to the camera of the pass
|
|
auto const &planes { m_renderpass.pass_camera.frustum().planes() };
|
|
auto const ¢er { Bucket.recordcenter };
|
|
auto const radius { slack * Bucket.recordradius + margin };
|
|
for( auto const *plane : planes ) {
|
|
if( plane[ 0 ] * center.x + plane[ 1 ] * center.y + plane[ 2 ] * center.z + plane[ 3 ] <= -radius ) { return true; }
|
|
}
|
|
|
|
// the same choices as in Render_Instanced(): shadows measure the distance from the real camera, reflections ignore zoom and
|
|
// distance factor, test the plain distance against their own range and add the fidelity offset
|
|
auto const reflections { m_renderpass.draw_mode == rendermode::reflections };
|
|
auto const &distancecamera { m_renderpass.draw_mode == rendermode::shadows ? m_renderpass.viewport_camera : m_renderpass.pass_camera };
|
|
auto const nearest { std::max( 0.0, glm::length( center - distancecamera.position() ) - ( slack * Bucket.recordlocationradius + margin ) ) };
|
|
auto const zoom { static_cast<double>( Global.ZoomFactor ) };
|
|
auto const scaledsquared { nearest * nearest * ( reflections ? 1.0 : 1.0 / ( zoom * zoom * static_cast<double>( Global.fDistanceFactor ) ) ) };
|
|
if( reflections && ( scaledsquared > slack * sq( static_cast<double>( Global.reflectiontune.range_instances ) ) ) ) { return true; }
|
|
auto const distancesquared { scaledsquared + ( reflections ? sq( static_cast<double>( EU07_REFLECTIONFIDELITYOFFSET ) ) : 0.0 ) };
|
|
if( distancesquared >= slack * Bucket.rangesquared ) { return true; }
|
|
if( distancesquared > slack * sq( static_cast<double>( m_renderpass.draw_range ) + 250.0 ) ) { return true; }
|
|
// the largest instance at the nearest location takes the largest part of the view
|
|
auto const radiusmax { static_cast<double>( Bucket.recordradiusmax ) };
|
|
if( radiusmax * radiusmax * zoom * slack < 0.003 * 0.003 * distancesquared ) { return true; }
|
|
|
|
return false;
|
|
}
|
|
|
|
// the sphere around the locations of the visible instances of a bucket, with the margin of Bucket_Culled(): their distances
|
|
// from it set the lod bands the gpu culling can put them in
|
|
scene::bounding_area scene_walk::Bucket_Area( scene::basic_cell::instance_bucket const &Bucket )
|
|
{
|
|
return scene::bounding_area{ Bucket.recordcenter, static_cast<float>( 1.001 * Bucket.recordlocationradius + 0.5 ) };
|
|
}
|
|
|
|
// True GPU-instanced render path for a group of TAnimModel instances sharing the same
|
|
// TModel3d. The submodel tree is walked ONCE per lod band; at every submodel that draws
|
|
// geometry we issue a single glDrawElementsInstancedBaseVertexBaseInstance(N) covering all
|
|
// visible instances of the band. The vertex shader multiplies effective_modelview =
|
|
// instance_modelview[gl_BaseInstance + gl_InstanceID] * model_ubs.modelview, where
|
|
// instance_modelview[i] is the camera-space root transform of an instance (precomputed below)
|
|
// and model_ubs.modelview is the submodel-local chain (accumulated by the matrix stack starting
|
|
// from identity, NOT the camera/instance frame).
|
|
void scene_walk::Render_Instanced( TModel3d *Model, std::vector<queued_instance> const &Instances, std::vector<std::uint32_t> *Bandcounts )
|
|
{
|
|
if( Bandcounts != nullptr ) { Bandcounts->clear(); }
|
|
if( Model == nullptr ) { return; }
|
|
if( Instances.empty() ) { return; }
|
|
// the first instance drawn prepares the model the instances share, held till the bands are drawn (walk_sync)
|
|
gfx::walk_sync::model_hold hold { Model };
|
|
|
|
// LOD: a submodel is drawn only while fSquareDist lies inside its [fSquareMinDist, fSquareMaxDist)
|
|
// range, so the distinct range bounds split distance into bands with constant LOD. The bucket
|
|
// collects instances from every visible cell, so a single fSquareDist for all of them would draw
|
|
// far instances at the LOD of the nearest one. Each instance is assigned to its band and every
|
|
// band is drawn with its own fSquareDist, like in Render_Sleepers(). The grouping is a counting
|
|
// sort, linear in the instance count.
|
|
// the same walk also checks whether any piece of the model can get into the shadow map. Models
|
|
// whose materials are all excluded by the shadow rank cutoff (e.g. grass) would otherwise go through
|
|
// the whole per-instance culling and the batched draws in every shadow pass, only for every submodel
|
|
// to be skipped in Render(TSubModel*)
|
|
auto const *frontinstance { Instances.front().bucket->instances[ Instances.front().index ] };
|
|
auto const *skins { frontinstance != nullptr && frontinstance->Material() != nullptr ? frontinstance->Material()->replacable_skins : nullptr };
|
|
bool castsshadow { m_renderpass.draw_mode != rendermode::shadows };
|
|
m_instance_lodbounds.clear();
|
|
m_instance_lodpending.clear();
|
|
m_instance_lodpending.push_back( Model->Root );
|
|
while( false == m_instance_lodpending.empty() ) {
|
|
auto const *submodel = m_instance_lodpending.back();
|
|
m_instance_lodpending.pop_back();
|
|
if( submodel == nullptr ) { continue; }
|
|
if( submodel->fSquareMinDist > 0.f ) { m_instance_lodbounds.emplace_back( submodel->fSquareMinDist ); }
|
|
if( submodel->fSquareMaxDist < std::numeric_limits<float>::max() ) { m_instance_lodbounds.emplace_back( submodel->fSquareMaxDist ); }
|
|
if( ( false == castsshadow ) && ( submodel->eType < TP_ROTATOR ) ) {
|
|
auto const material { submodel->m_material >= 0 ? submodel->m_material : ( skins != nullptr ? skins[ -submodel->m_material ] : null_handle ) };
|
|
castsshadow = ( walk_material_data( material ).shadow_rank <= Global.gfx_shadow_rank_cutoff );
|
|
}
|
|
m_instance_lodpending.push_back( submodel->Child );
|
|
m_instance_lodpending.push_back( submodel->Next );
|
|
}
|
|
if( false == castsshadow ) { return; }
|
|
std::sort( m_instance_lodbounds.begin(), m_instance_lodbounds.end() );
|
|
m_instance_lodbounds.erase( std::unique( m_instance_lodbounds.begin(), m_instance_lodbounds.end() ), m_instance_lodbounds.end() );
|
|
auto const bandcount { m_instance_lodbounds.size() + 1 };
|
|
if( Bandcounts != nullptr ) { Bandcounts->assign( bandcount, 0 ); }
|
|
|
|
// 1. Visibility / distance cull, by the records of the instances. Collect surviving instances with
|
|
// their precomputed camera-space root modelview matrices and lod bands. m_instance_survivors and the
|
|
// other scratch vectors are persistent members reused across every Render_Instanced() call:
|
|
// clear() drops the contents but keeps the allocated capacity, so after the first few
|
|
// frames this stops calling malloc/free entirely.
|
|
m_instance_survivors.clear();
|
|
m_instance_survivors.reserve( Instances.size() );
|
|
|
|
// Pull the current pass camera/view transform once. We use the current GL
|
|
// modelview matrix as the view matrix because at the point Render_Instanced
|
|
// is called, OpenGLMatrices is set to the camera view (scene root) — no
|
|
// per-instance transform has been pushed yet.
|
|
glm::mat4 const view_matrix = OpenGLMatrices.data( GL_MODELVIEW );
|
|
|
|
TAnimModel *batch_instance { nullptr }; // the first instance drawn; its RaPrepare() and material serve the whole bucket
|
|
material_data const *batch_material { nullptr };
|
|
float farthest_distancesquared { 0.f };
|
|
|
|
for( auto const &queued : Instances ) {
|
|
auto const &record { queued.bucket->records[ queued.index ] };
|
|
// instances which lost their instanceable status after being bucketed (animation or skin
|
|
// assigned by an event) are drawn by the per-node path
|
|
if( ( record.flags & scene::basic_cell::instance_instanceable ) == 0 ) { continue; }
|
|
if( ( record.flags & scene::basic_cell::instance_visible ) == 0 ) { continue; }
|
|
glm::dvec3 const location { queued.bucket->recordorigin + glm::dvec3{ record.position } };
|
|
if( false == m_renderpass.pass_camera.visible( scene::bounding_area{ location, record.radius } ) ) { continue; }
|
|
|
|
double distancesquared;
|
|
switch( m_renderpass.draw_mode ) {
|
|
case rendermode::shadows:
|
|
distancesquared = glm::length2( ( location - m_renderpass.viewport_camera.position() ) / (double)Global.ZoomFactor ) / Global.fDistanceFactor;
|
|
break;
|
|
case rendermode::reflections:
|
|
distancesquared = glm::length2( ( location - m_renderpass.pass_camera.position() ) );
|
|
if( distancesquared > Global.reflectiontune.range_instances * Global.reflectiontune.range_instances ) { continue; }
|
|
distancesquared += sq( EU07_REFLECTIONFIDELITYOFFSET );
|
|
break;
|
|
default:
|
|
distancesquared = glm::length2( ( location - m_renderpass.pass_camera.position() ) / (double)Global.ZoomFactor ) / Global.fDistanceFactor;
|
|
break;
|
|
}
|
|
if( ( distancesquared < record.rangesquaredmin )
|
|
|| ( distancesquared >= record.rangesquaredmax ) ) { continue; }
|
|
|
|
auto const drawdistancethreshold { m_renderpass.draw_range + 250 };
|
|
if( distancesquared > sq( drawdistancethreshold ) ) { continue; }
|
|
|
|
auto const radiussquared { record.radius * record.radius };
|
|
if( radiussquared * Global.ZoomFactor / distancesquared < 0.003 * 0.003 ) { continue; }
|
|
|
|
if( batch_instance == nullptr ) {
|
|
batch_instance = queued.bucket->instances[ queued.index ];
|
|
batch_instance->RaPrepare();
|
|
batch_material = batch_instance->Material();
|
|
}
|
|
|
|
// Build the camera-relative root modelview for this instance:
|
|
// mv = view * translate(instance_pos - camera_pos) * rotate(instance_angles) * scale(m_scale)
|
|
// The rotation and scale part comes from the record, the translation goes into its last
|
|
// column. The scale is folded in so the GPU-instanced path produces visually identical output
|
|
// to the regular per-instance path; the shader applies it via effective_modelview = instance_mv * model_local.
|
|
glm::mat4 const root {
|
|
record.rotationscale[ 0 ],
|
|
record.rotationscale[ 1 ],
|
|
record.rotationscale[ 2 ],
|
|
glm::vec4( glm::vec3( location - m_renderpass.pass_camera.position() ), 1.f ) };
|
|
|
|
auto const distance { static_cast<float>( distancesquared ) };
|
|
farthest_distancesquared = std::max( farthest_distancesquared, distance );
|
|
m_instance_survivors.push_back( {
|
|
view_matrix * root,
|
|
distance,
|
|
static_cast<std::uint32_t>( std::upper_bound( m_instance_lodbounds.begin(), m_instance_lodbounds.end(), distance ) - m_instance_lodbounds.begin() ) } );
|
|
}
|
|
|
|
if( m_instance_survivors.empty() ) { return; }
|
|
|
|
// group the modelviews by lod band into a contiguous array, for the upload. every distance in
|
|
// a band selects the same lod; the nearest one represents the band.
|
|
// within a band the instances are additionally ordered roughly near-to-far, in distance slots. dense
|
|
// alpha tested foliage then gets the most out of the early depth test, as the nearest instances fill
|
|
// the depth buffer first and hide the fragments of those behind them before they get shaded.
|
|
// both levels are done with a single counting sort, linear in the instance count
|
|
auto const distanceslots { 16 };
|
|
auto const keycount { bandcount * distanceslots };
|
|
auto const slotscale { distanceslots / std::sqrt( std::max( farthest_distancesquared, 1.f ) ) };
|
|
m_instance_bandstarts.assign( keycount + 1, 0 );
|
|
m_instance_banddistances.assign( bandcount, std::numeric_limits<float>::max() );
|
|
for( auto &survivor : m_instance_survivors ) {
|
|
m_instance_banddistances[ survivor.band ] = std::min( m_instance_banddistances[ survivor.band ], survivor.distancesquared );
|
|
auto const slot { std::min( distanceslots - 1, static_cast<int>( std::sqrt( survivor.distancesquared ) * slotscale ) ) };
|
|
survivor.band = static_cast<std::uint32_t>( survivor.band * distanceslots + slot ); // from now on it's the sort key
|
|
++m_instance_bandstarts[ survivor.band + 1 ];
|
|
}
|
|
for( std::size_t key = 1; key <= keycount; ++key ) {
|
|
m_instance_bandstarts[ key ] += m_instance_bandstarts[ key - 1 ];
|
|
}
|
|
m_instance_bandcursors.assign( m_instance_bandstarts.begin(), m_instance_bandstarts.end() - 1 );
|
|
m_instance_modelviews.resize( m_instance_survivors.size() );
|
|
for( auto const &survivor : m_instance_survivors ) {
|
|
m_instance_modelviews[ m_instance_bandcursors[ survivor.band ]++ ] = survivor.modelview;
|
|
}
|
|
if( Bandcounts != nullptr ) {
|
|
for( std::size_t band = 0; band < bandcount; ++band ) {
|
|
( *Bandcounts )[ band ] = static_cast<std::uint32_t>( m_instance_bandstarts[ ( band + 1 ) * distanceslots ] - m_instance_bandstarts[ band * distanceslots ] );
|
|
}
|
|
}
|
|
// all bands go to the instance buffer at once, each band is drawn from its own base instance
|
|
auto const baseinstance { walk_instances( m_instance_modelviews.data(), m_instance_modelviews.size() ) };
|
|
|
|
auto alpha = ( batch_material != nullptr ? batch_material->textures_alpha : 0x30300030 );
|
|
alpha ^= 0x0F0F000F;
|
|
|
|
// 2. Walk the submodel tree once per lod band. The submodel-local matrix
|
|
// stack starts at identity; the per-instance camera transform comes from
|
|
// instance_modelview[gl_BaseInstance + gl_InstanceID] in the shader.
|
|
for( std::size_t band = 0; band < bandcount; ++band ) {
|
|
|
|
std::size_t const band_start = m_instance_bandstarts[ band * distanceslots ];
|
|
std::size_t const band_end = m_instance_bandstarts[ ( band + 1 ) * distanceslots ];
|
|
if( band_start == band_end ) { continue; }
|
|
|
|
// 2a. Push identity onto the matrix stack so submodel transforms
|
|
// accumulate from identity, not from camera/instance space.
|
|
::glPushMatrix();
|
|
::glLoadIdentity();
|
|
|
|
// 2b. Configure the existing TModel3d/TSubModel render path. Setting
|
|
// m_current_instance_count routes walk_draw(handle) calls to draw_instanced.
|
|
m_current_instance_count = band_end - band_start;
|
|
m_current_instance_base = baseinstance + static_cast<std::uint32_t>( band_start );
|
|
|
|
Model->Root->fSquareDist = m_instance_banddistances[ band ]; // shared global, used by submodel LOD
|
|
Model->Root->ReplacableSet( ( batch_material != nullptr ? batch_material->replacable_skins : nullptr ), alpha );
|
|
Model->Root->pRoot = Model;
|
|
|
|
Render( Model->Root );
|
|
|
|
m_current_instance_count = 0;
|
|
m_current_instance_base = 0;
|
|
|
|
::glPopMatrix();
|
|
|
|
++m_renderpass.draw_stats.instanced_drawcalls;
|
|
}
|
|
|
|
m_renderpass.draw_stats.instances += static_cast<int>( m_instance_survivors.size() );
|
|
m_renderpass.draw_stats.models += static_cast<int>( m_instance_survivors.size() );
|
|
}
|
|
|
|
void scene_walk::Render_Sleepers( TTrack *Track )
|
|
{
|
|
if( Track == nullptr ) { return; }
|
|
if( false == Track->m_sleeper_enabled ) { return; }
|
|
if( Track->m_sleeper_model == nullptr ) { return; }
|
|
if( Track->m_sleeper_local_transforms.empty() ) { return; }
|
|
if( Global.SleeperDistance <= 0.f ) { return; }
|
|
|
|
// only the color and reflection passes draw sleepers; shadow/pick skip them on purpose
|
|
// (sleeper shadows would mostly fall back under the trackbed and pick already operates on
|
|
// the track itself).
|
|
switch( m_renderpass.draw_mode ) {
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
// distance gate -- compare against Globals.SleeperDistance squared to avoid the sqrt
|
|
auto const camerapos = m_renderpass.pass_camera.position();
|
|
auto const trackpos = Track->location();
|
|
auto const distsq = glm::length2( trackpos - camerapos );
|
|
auto const cutoffsq = static_cast<double>( Global.SleeperDistance ) * static_cast<double>( Global.SleeperDistance );
|
|
if( distsq > cutoffsq ) { return; }
|
|
|
|
// build camera-space modelview matrices.
|
|
// each sleeper's stored matrix is in track-local space (relative to Track->m_origin).
|
|
// Render_Sleepers is called from inside the per-cell origin push -- the cell's center
|
|
// already equals Track->m_origin (see basic_cell::insert), so the current GL_MODELVIEW
|
|
// is already view * translate(m_origin - camera). We just need to compose with each
|
|
// per-sleeper local transform to get the final modelview.
|
|
glm::mat4 const origin_mv = OpenGLMatrices.data( GL_MODELVIEW );
|
|
|
|
// per-sleeper frustum cull + LOD selection. The whole-track SleeperDistance
|
|
// gate above keeps or drops the track as a unit; everything from here on
|
|
// operates on individual sleepers.
|
|
//
|
|
// Each m_sleeper_local_transforms entry is
|
|
// translate(world_pos - m_origin) * rotate(...) * translate(local_offset)
|
|
// so its translation column is the sleeper position relative to m_origin;
|
|
// adding m_origin back yields the sleeper's world-space position. The model's
|
|
// bounding radius (floored to a small minimum, in case it was never measured)
|
|
// serves both as the frustum test sphere and -- via the distance to that
|
|
// world position -- as the per-sleeper LOD distance.
|
|
auto const sleeperradius = std::max( Track->m_sleeper_model->bounding_radius(), 2.0f );
|
|
|
|
// Phase 1 -- frustum cull. For every sleeper that survives, store its
|
|
// camera-space modelview paired with the squared distance from the camera
|
|
// to ITS OWN world position (not the track / segment origin). That
|
|
// per-sleeper distance is what drives LOD selection below. A sleeper whose
|
|
// origin sits just off screen while its geometry still reaches into view is
|
|
// kept rather than wrongly culled.
|
|
std::vector<std::pair<float, glm::mat4>> survivors;
|
|
survivors.reserve( Track->m_sleeper_local_transforms.size() );
|
|
for( auto const &local : Track->m_sleeper_local_transforms ) {
|
|
glm::dvec3 const sleeperworldpos {
|
|
Track->m_origin + glm::dvec3( local[ 3 ].x, local[ 3 ].y, local[ 3 ].z ) };
|
|
if( false == m_renderpass.pass_camera.visible( scene::bounding_area{ sleeperworldpos, sleeperradius } ) ) {
|
|
continue;
|
|
}
|
|
auto const sleeperdistancesquared = static_cast<float>( glm::length2( sleeperworldpos - camerapos ) );
|
|
survivors.emplace_back( sleeperdistancesquared, origin_mv * local );
|
|
}
|
|
|
|
// every sleeper of this track was frustum-culled -- nothing left to draw
|
|
if( survivors.empty() ) { return; }
|
|
|
|
// Phase 2 -- sort survivors near-to-far. A submodel is drawn only while
|
|
// fSquareDist lies inside its [fSquareMinDist, fSquareMaxDist) range, so
|
|
// every distance between two consecutive range bounds selects an identical
|
|
// set of submodels -- i.e. the same LOD. Sorting turns each such LOD band
|
|
// into a contiguous run, letting the draw loop emit one instanced batch per
|
|
// band instead of one track-wide batch at a single distance.
|
|
std::sort( survivors.begin(), survivors.end(),
|
|
[]( std::pair<float, glm::mat4> const &Left, std::pair<float, glm::mat4> const &Right ) {
|
|
return Left.first < Right.first; } );
|
|
|
|
// contiguous copy of the sorted modelview matrices, for the upload.
|
|
// Per-sleeper distances stay available as survivors[i].first, in lockstep.
|
|
std::vector<glm::mat4> instance_modelviews;
|
|
instance_modelviews.reserve( survivors.size() );
|
|
for( auto const &survivor : survivors ) {
|
|
instance_modelviews.emplace_back( survivor.second );
|
|
}
|
|
|
|
// collect the model's distinct LOD distance bounds. The sorted, de-duplicated
|
|
// set of every submodel's fSquareMinDist / fSquareMaxDist partitions distance
|
|
// into bands within which the selected LOD is constant. A model with no LOD
|
|
// yields a single band, and the draw loop below then behaves exactly like a
|
|
// single plain batched draw.
|
|
std::vector<float> lodbounds;
|
|
{
|
|
std::vector<TSubModel const *> pending;
|
|
if( Track->m_sleeper_model->Root != nullptr ) {
|
|
pending.push_back( Track->m_sleeper_model->Root );
|
|
}
|
|
while( false == pending.empty() ) {
|
|
auto const *submodel = pending.back();
|
|
pending.pop_back();
|
|
lodbounds.emplace_back( submodel->fSquareMinDist );
|
|
lodbounds.emplace_back( submodel->fSquareMaxDist );
|
|
if( submodel->Child != nullptr ) { pending.push_back( submodel->Child ); }
|
|
if( submodel->Next != nullptr ) { pending.push_back( submodel->Next ); }
|
|
}
|
|
}
|
|
std::sort( lodbounds.begin(), lodbounds.end() );
|
|
lodbounds.erase( std::unique( lodbounds.begin(), lodbounds.end() ), lodbounds.end() );
|
|
|
|
// optional replacable skin: build a transient material_data so we can drive ReplacableSet
|
|
// the same way Render_Instanced does. when no skin is set we fall back to the model defaults.
|
|
material_data sleeper_material {};
|
|
bool const has_skin = ( Track->m_sleeper_skin != null_handle );
|
|
if( has_skin ) {
|
|
sleeper_material.replacable_skins[ 1 ] = Track->m_sleeper_skin;
|
|
}
|
|
|
|
// Phase 3 -- draw. Walk the sorted survivors one LOD band at a time. Each
|
|
// band is submitted as one instanced draw from its own base instance; every
|
|
// draw uses an in-band fSquareDist, so each sleeper renders at the LOD its own
|
|
// distance selects while instancing stays fully in effect.
|
|
auto *Model = Track->m_sleeper_model;
|
|
gfx::walk_sync::model_hold hold { Model };
|
|
std::size_t const total = instance_modelviews.size();
|
|
auto const baseinstance { walk_instances( instance_modelviews.data(), total ) };
|
|
std::size_t band_start = 0;
|
|
while( band_start < total ) {
|
|
// the band ends at the first sleeper distance that reaches the next LOD
|
|
// bound above the band's starting distance.
|
|
auto const upperbound = std::upper_bound(
|
|
lodbounds.begin(), lodbounds.end(), survivors[ band_start ].first );
|
|
float const band_limit = ( upperbound == lodbounds.end()
|
|
? std::numeric_limits<float>::max()
|
|
: *upperbound );
|
|
std::size_t band_end = band_start;
|
|
while( ( band_end < total ) && ( survivors[ band_end ].first < band_limit ) ) {
|
|
++band_end;
|
|
}
|
|
// every distance in the band selects the same LOD; the band's nearest
|
|
// sleeper is used as the representative fSquareDist.
|
|
float const band_distancesquared = survivors[ band_start ].first;
|
|
|
|
::glPushMatrix();
|
|
::glLoadIdentity();
|
|
|
|
m_current_instance_count = band_end - band_start;
|
|
m_current_instance_base = baseinstance + static_cast<std::uint32_t>( band_start );
|
|
|
|
Model->Root->fSquareDist = band_distancesquared;
|
|
auto alpha = ( has_skin ? sleeper_material.textures_alpha : 0x30300030 );
|
|
alpha ^= 0x0F0F000F;
|
|
Model->Root->ReplacableSet( ( has_skin ? sleeper_material.replacable_skins : nullptr ), alpha );
|
|
Model->Root->pRoot = Model;
|
|
|
|
Render( Model->Root );
|
|
|
|
m_current_instance_count = 0;
|
|
m_current_instance_base = 0;
|
|
|
|
::glPopMatrix();
|
|
|
|
++m_renderpass.draw_stats.instanced_drawcalls;
|
|
|
|
band_start = band_end;
|
|
}
|
|
|
|
m_renderpass.draw_stats.instances += static_cast<int>( total );
|
|
m_renderpass.draw_stats.models += static_cast<int>( total );
|
|
|
|
// the comparison with the gpu culling of the opengl renderer
|
|
walk_sleepers_drawn( *Track, lodbounds, survivors );
|
|
}
|
|
|
|
// Gathers the sleepers and switch timbers of a run of tracks of a cell. Each beam is made of instances of the parts of a model or
|
|
// of a whole model, kept by its track relative to the origin of the track (and with walk_timbers_gpu() on the gpu as well). The runs
|
|
// of beams in range and in sight are gathered by the model and its part or its level of detail, for all the cells of the pass, which
|
|
// Flush_Timbers() draws each in one instanced batch. In the shadow pass only those near the camera are drawn, their shadows falling
|
|
// where they can be seen.
|
|
void scene_walk::Render_Timbers( scene::basic_cell::path_sequence::const_iterator First, scene::basic_cell::path_sequence::const_iterator Last )
|
|
{
|
|
if( Global.SleeperDistance <= 0.f ) { return; }
|
|
|
|
auto const shadows = ( m_renderpass.draw_mode == rendermode::shadows );
|
|
// the distance is taken from the camera of the view, the shadow pass culling against its own frustum
|
|
auto const camera = ( shadows ? m_renderpass.viewport_camera.position() : m_renderpass.pass_camera.position() );
|
|
auto const range = static_cast<double>( shadows ? std::min( Global.SleeperDistance, 50.f ) : Global.SleeperDistance );
|
|
if( m_renderpass.draw_mode == rendermode::color && m_timbersweepframe != m_framestamp ) {
|
|
// once a frame the beams of the tracks well past where they're laid and worked out ahead are let go. with the passes walked
|
|
// by several threads, after they're done (Release_Deferred())
|
|
m_timbersweepframe = m_framestamp;
|
|
if( gfx::walk_sync::parallel() ) {
|
|
m_deferredrelease = std::make_pair( camera, range + 600.0 );
|
|
}
|
|
else {
|
|
track_sleepers::release_far( camera, range + 600.0 );
|
|
}
|
|
}
|
|
if( m_timberlayframe != m_framestamp ) {
|
|
m_timberlayframe = m_framestamp;
|
|
m_timberlaying = 0.0;
|
|
}
|
|
// the fastenings laid out to a little past where they're drawn
|
|
auto const fasteningrange = std::min( static_cast<double>( Global.SleeperDistance ), track_sleepers::fastening_range ) + track_sleepers::fastening_lead;
|
|
auto const bucket_for = [&]( track_sleepers::beam_model const *Model, int const Part, float const Band ) -> timber_bucket & {
|
|
for( auto &bucket : m_timberbuckets ) {
|
|
if( bucket.model == Model && bucket.part == Part && bucket.band == Band ) {
|
|
return bucket;
|
|
}
|
|
}
|
|
m_timberbuckets.push_back( { Model, Part, Band, {}, {}, 0, 0 } );
|
|
return m_timberbuckets.back(); };
|
|
// the level of detail of the whole model a run of beams is seen at, from its distance
|
|
auto const band_of = []( track_sleepers::beam_model const &Model, double const Distance ) {
|
|
auto const squaredistance { static_cast<float>( Distance * Distance ) };
|
|
auto band { Model.bands.empty() ? 0.f : Model.bands.front() };
|
|
for( auto const start : Model.bands ) {
|
|
if( squaredistance >= start ) {
|
|
band = start;
|
|
}
|
|
}
|
|
return band; };
|
|
m_timbertracks.clear();
|
|
for( auto first { First }; first != Last; ++first ) {
|
|
auto *track = *first;
|
|
if( false == track->m_visible || false == track->m_sleepers3d.active ) { continue; }
|
|
auto const trackdistance = glm::length( track->location() - camera );
|
|
if( trackdistance > range + track->radius() ) {
|
|
// worked out ahead, in the background, before it comes in range
|
|
if( false == shadows && track->m_sleepers3d.dirty && trackdistance < range + track->radius() + 300.0 ) {
|
|
if( gfx::walk_sync::parallel() ) {
|
|
m_deferredprefetch.push_back( track );
|
|
}
|
|
else {
|
|
track_sleepers::prefetch( *track );
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
auto const fastened = ( trackdistance < fasteningrange + track->radius() );
|
|
if( track->m_sleepers3d.dirty || ( fastened && false == track->m_sleepers3d.fastened ) ) {
|
|
// the nearest at once, the others while the frame has the time, the cells nearest coming first; till then a track draws
|
|
// what it had
|
|
if( trackdistance < track_sleepers::lay_near + track->radius() || m_timberlaying < track_sleepers::lay_budget ) {
|
|
// laid by one walk at a time (walk_sync)
|
|
gfx::walk_sync::change change;
|
|
auto const start = std::chrono::steady_clock::now();
|
|
if( track->m_sleepers3d.dirty ) {
|
|
track_sleepers::lay( *track, fastened );
|
|
}
|
|
else if( fastened && false == track->m_sleepers3d.fastened ) {
|
|
track_sleepers::fasten( *track );
|
|
}
|
|
m_timberlaying += std::chrono::duration<double, std::milli>( std::chrono::steady_clock::now() - start ).count();
|
|
}
|
|
}
|
|
if( track->m_sleepers3d.timbers == nullptr || track->m_sleepers3d.chunks.empty() ) { continue; }
|
|
m_timbertracks.push_back( track );
|
|
}
|
|
if( m_timbertracks.empty() ) { return; }
|
|
auto const gpu = walk_timbers_gpu();
|
|
// the instances of the tracks on the gpu; those of the cells before expanded first when the buffer is to be started over
|
|
if( gpu && false == walk_timbers_place( m_timbertracks, false ) ) {
|
|
Flush_Timbers();
|
|
walk_timbers_place( m_timbertracks, true );
|
|
}
|
|
// the runs of them in range and in sight, turned by the modelview of the cell: on the gpu, or here
|
|
glm::mat4 const originmodelview = OpenGLMatrices.data( GL_MODELVIEW );
|
|
auto const origin { static_cast<std::uint32_t>( m_timberorigins.size() ) };
|
|
if( gpu ) {
|
|
m_timberorigins.push_back( originmodelview );
|
|
}
|
|
// a run of instances of a track for the bucket; the reference to it goes with the next bucket added
|
|
auto const add_run = [&]( timber_bucket &Bucket, std::vector<glm::mat4> const &Transforms, std::uint32_t const From, std::uint32_t const Source, std::uint32_t const Count ) {
|
|
if( gpu ) {
|
|
Bucket.runs.push_back( { Source, Count, 0, origin } );
|
|
}
|
|
else {
|
|
for( auto index = From; index < From + Count; ++index ) {
|
|
Bucket.instances.emplace_back( originmodelview * Transforms[ index ] );
|
|
}
|
|
}
|
|
Bucket.count += Count; };
|
|
for( auto *track : m_timbertracks ) {
|
|
auto const &laid = track->m_sleepers3d;
|
|
// where the instances of the parts, of the whole timbers and of the plain sleepers of the track start on the gpu
|
|
std::array<std::uint32_t, track_sleepers::part_count> partfirst;
|
|
auto next { gpu ? walk_timbers_first( *track ) : 0 };
|
|
for( int part = 0; part < track_sleepers::part_count; ++part ) {
|
|
partfirst[ part ] = next;
|
|
next += static_cast<std::uint32_t>( laid.instances[ part ].size() );
|
|
}
|
|
auto const wholefirst { next };
|
|
auto const plainfirst { wholefirst + static_cast<std::uint32_t>( laid.whole.size() ) };
|
|
for( auto const &chunk : laid.chunks ) {
|
|
auto const centre = track->m_origin + glm::dvec3( chunk.centre );
|
|
auto const distance = glm::length( centre - camera );
|
|
if( distance > range + chunk.radius ) { continue; }
|
|
if( false == m_renderpass.pass_camera.visible( scene::bounding_area{ centre, chunk.radius } ) ) { continue; }
|
|
if( laid.timbers->stretchable ) {
|
|
for( int part = 0; part < track_sleepers::part_count; ++part ) {
|
|
if( chunk.last[ part ] <= chunk.first[ part ] ) { continue; }
|
|
// the fastenings only near, they're small
|
|
if( part >= track_sleepers::timber_parts && distance > std::min( range, track_sleepers::fastening_range ) + chunk.radius ) { continue; }
|
|
add_run( bucket_for( laid.timbers, part, 0.f ), laid.instances[ part ], chunk.first[ part ], partfirst[ part ] + chunk.first[ part ], chunk.last[ part ] - chunk.first[ part ] );
|
|
}
|
|
}
|
|
// the beams made of a whole model at the level of detail of the distance of the run
|
|
if( chunk.wholelast > chunk.wholefirst ) {
|
|
add_run( bucket_for( laid.timbers, -1, band_of( *laid.timbers, distance ) ), laid.whole, chunk.wholefirst, wholefirst + chunk.wholefirst, chunk.wholelast - chunk.wholefirst );
|
|
}
|
|
if( laid.plains != nullptr && chunk.plainlast > chunk.plainfirst ) {
|
|
add_run( bucket_for( laid.plains, -1, band_of( *laid.plains, distance ) ), laid.plain, chunk.plainfirst, plainfirst + chunk.plainfirst, chunk.plainlast - chunk.plainfirst );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// the sleepers and timbers gathered by Render_Timbers() over the cells of the pass placed in the instance buffer of the frame at once
|
|
// (with walk_timbers_gpu() made into modelviews on the gpu there), and each bucket drawn in one instanced batch
|
|
void scene_walk::Flush_Timbers()
|
|
{
|
|
std::size_t total { 0 };
|
|
for( auto const &bucket : m_timberbuckets ) {
|
|
total += bucket.count;
|
|
}
|
|
if( total > 0 ) {
|
|
// in the instance buffer of the frame bucket after bucket, as in Render_Sleepers(), which the recorded walk of the depth
|
|
// pass keeps for its replay as well
|
|
if( walk_timbers_gpu() ) {
|
|
auto target { walk_instances_reserve( total ) };
|
|
m_timberranges.clear();
|
|
for( auto &bucket : m_timberbuckets ) {
|
|
bucket.first = target;
|
|
for( auto const &run : bucket.runs ) {
|
|
m_timberranges.push_back( { run.source, run.count, target, run.origin } );
|
|
target += run.count;
|
|
}
|
|
}
|
|
walk_timbers_expand( m_timberorigins, m_timberranges );
|
|
}
|
|
else {
|
|
for( auto &bucket : m_timberbuckets ) {
|
|
if( bucket.count == 0 ) { continue; }
|
|
bucket.first = walk_instances( bucket.instances.data(), bucket.instances.size() );
|
|
}
|
|
}
|
|
auto const alpha = ( 0x30300030 ^ 0x0F0F000F );
|
|
for( auto &bucket : m_timberbuckets ) {
|
|
if( bucket.count == 0 ) { continue; }
|
|
auto const &beammodel = *bucket.model;
|
|
auto *model = beammodel.model;
|
|
// the parts of the model shown and hidden for the bucket, held till it's drawn (walk_sync)
|
|
gfx::walk_sync::model_hold hold { model };
|
|
if( bucket.part >= 0 ) {
|
|
// only the part of the model is visible, its siblings are skipped as the model is walked
|
|
for( int part = 0; part < track_sleepers::part_count; ++part ) {
|
|
if( beammodel.parts[ part ] != nullptr ) {
|
|
beammodel.parts[ part ]->iVisible = ( part == bucket.part ? 1 : 0 );
|
|
}
|
|
}
|
|
}
|
|
material_data skins {};
|
|
if( beammodel.skin != null_handle ) {
|
|
skins.replacable_skins[ 1 ] = beammodel.skin;
|
|
}
|
|
::glPushMatrix();
|
|
::glLoadIdentity();
|
|
m_current_instance_count = bucket.count;
|
|
m_current_instance_base = bucket.first;
|
|
// inside the range of the level of detail the beams are at
|
|
model->Root->fSquareDist = ( bucket.part >= 0 ? 0.f : bucket.band + 1.f );
|
|
model->Root->ReplacableSet( ( beammodel.skin != null_handle ? skins.replacable_skins : nullptr ), alpha );
|
|
model->Root->pRoot = model;
|
|
Render( model->Root );
|
|
m_current_instance_count = 0;
|
|
m_current_instance_base = 0;
|
|
::glPopMatrix();
|
|
++m_renderpass.draw_stats.instanced_drawcalls;
|
|
if( bucket.part >= 0 ) {
|
|
for( int part = 0; part < track_sleepers::part_count; ++part ) {
|
|
if( beammodel.parts[ part ] != nullptr ) {
|
|
beammodel.parts[ part ]->iVisible = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
m_renderpass.draw_stats.instances += static_cast<int>( total );
|
|
}
|
|
for( auto &bucket : m_timberbuckets ) {
|
|
bucket.instances.clear();
|
|
bucket.runs.clear();
|
|
bucket.count = 0;
|
|
}
|
|
m_timberorigins.clear();
|
|
}
|
|
|
|
bool scene_walk::Render(TDynamicObject *Dynamic)
|
|
{
|
|
glDebug("Render TDynamicObject");
|
|
|
|
if (!Global.render_cab && Global.pCamera.m_owner == Dynamic)
|
|
return false;
|
|
|
|
set_renderme( Dynamic,
|
|
( Global.pCamera.m_owner == Dynamic && !FreeFlyModeFlag )
|
|
|| ( m_renderpass.pass_camera.visible( Dynamic ) ) );
|
|
|
|
if (false == renderme( Dynamic )) { return false; }
|
|
|
|
// setup
|
|
TSubModel::iInstance = reinterpret_cast<std::uintptr_t>(Dynamic); //żeby nie robić cudzych animacji
|
|
TSubModel::iVariantSeed = Dynamic->variant_seed();
|
|
glm::dvec3 const originoffset = Dynamic->vPosition - m_renderpass.pass_camera.position();
|
|
// lod visibility ranges are defined for base (x 1.0) viewing distance. for render we adjust them for actual range multiplier and zoom
|
|
float squaredistance;
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::shadows:
|
|
{
|
|
squaredistance = glm::length2(glm::vec3{glm::dvec3{Dynamic->vPosition - m_renderpass.viewport_camera.position()}} / Global.ZoomFactor);
|
|
if( false == FreeFlyModeFlag ) {
|
|
// filter out small details if we're in vehicle cab
|
|
squaredistance = std::max( 100.f * 100.f, squaredistance );
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::reflections:
|
|
{
|
|
// reflection mode draws simplified version of the shapes, by artificially increasing view range
|
|
// it also ignores zoom settings and distance multipliers
|
|
squaredistance =
|
|
std::max(
|
|
100.f * 100.f,
|
|
// TBD: take into account distance multipliers?
|
|
glm::length2( glm::vec3{ originoffset } ) /* / Global.fDistanceFactor */ );
|
|
// NOTE: arbitrary draw range limit
|
|
if( squaredistance > Global.reflectiontune.range_vehicles * Global.reflectiontune.range_vehicles ) {
|
|
return false;
|
|
}
|
|
// TBD, TODO: bind offset value with setting variable?
|
|
// NOTE: combined 'squared' distance doesn't equal actual squared (distance + offset) but, eh
|
|
squaredistance += sq(EU07_REFLECTIONFIDELITYOFFSET);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
squaredistance = glm::length2(glm::vec3{originoffset} / Global.ZoomFactor);
|
|
// TODO: filter out small details based on fidelity setting
|
|
break;
|
|
}
|
|
}
|
|
// crude way to reject early items too far to affect the output (mostly relevant for shadow and reflection passes)
|
|
auto const drawdistancethreshold{ m_renderpass.draw_range + 250 };
|
|
if( squaredistance > sq(drawdistancethreshold) ) {
|
|
return false;
|
|
}
|
|
// second stage visibility cull, reject vehicles too far away to be noticeable
|
|
auto const squareradius{ Dynamic->radius() * Dynamic->radius() };
|
|
set_renderme( Dynamic, ( squareradius * Global.ZoomFactor / squaredistance > 0.003 * 0.003 ) );
|
|
if( false == renderme( Dynamic ) ) {
|
|
return false;
|
|
}
|
|
|
|
// debug data
|
|
++m_renderpass.draw_stats.dynamics;
|
|
|
|
// the submodels of the models the vehicle shares, set up for it and held till it's drawn (walk_sync)
|
|
gfx::walk_sync::vehicle_hold hold;
|
|
Dynamic->ABuLittleUpdate(squaredistance); // ustawianie zmiennych submodeli dla wspólnego modelu
|
|
|
|
glm::mat4 future_stack = model_ubs.future;
|
|
|
|
glm::mat4 mv = OpenGLMatrices.data(GL_MODELVIEW);
|
|
model_ubs.future *= glm::translate(mv, glm::vec3(m_motionhistory ? -Dynamic->get_future_movement() : Dynamic->get_future_movement())) * glm::inverse(mv);
|
|
// the velocity it leaves in the colour pass keeps the motion blur on (Render_pass())
|
|
if ((m_renderpass.draw_mode == rendermode::color) && (Dynamic->get_future_movement() != glm::dvec3{0.0}))
|
|
m_vehiclesmoving = true;
|
|
|
|
::glPushMatrix();
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
::glMultMatrixd(glm::value_ptr(Dynamic->mMatrix));
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
{
|
|
if (gfx::vehicle_shade(Dynamic) > 0.0f)
|
|
{
|
|
// change light level based on light level of the occupied track
|
|
walk_sunlight(gfx::vehicle_shade(Dynamic));
|
|
}
|
|
|
|
// render
|
|
if( Dynamic->mdLowPolyInt ) {
|
|
// low poly interior
|
|
Render_lowpoly( Dynamic, squaredistance, false );
|
|
}
|
|
else {
|
|
// HACK: if the model lacks low poly interior, we presume the load is placed outside
|
|
if( Dynamic->mdLoad ) {
|
|
// renderowanie nieprzezroczystego ładunku
|
|
Render( Dynamic->mdLoad, Dynamic->Material(), squaredistance, { 0.f, Dynamic->LoadOffset, 0.f }, {} );
|
|
}
|
|
}
|
|
if( Dynamic->mdModel ) {
|
|
// main model
|
|
Render( Dynamic->mdModel, Dynamic->Material(), squaredistance );
|
|
}
|
|
// optional attached models
|
|
for( auto *attachment : Dynamic->mdAttachments ) {
|
|
Render( attachment, Dynamic->Material(), squaredistance );
|
|
}
|
|
// optional coupling adapters
|
|
Render_coupler_adapter( Dynamic, squaredistance, end::front );
|
|
Render_coupler_adapter( Dynamic, squaredistance, end::rear );
|
|
|
|
// post-render cleanup
|
|
if (gfx::vehicle_shade(Dynamic) > 0.0f)
|
|
{
|
|
// restore regular light level
|
|
walk_sunlight();
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
{
|
|
if( Dynamic->mdLowPolyInt ) {
|
|
// low poly interior
|
|
Render( Dynamic->mdLowPolyInt, Dynamic->Material(), squaredistance );
|
|
}
|
|
if( Dynamic->mdModel ) {
|
|
// main model
|
|
Render( Dynamic->mdModel, Dynamic->Material(), squaredistance );
|
|
}
|
|
// optional attached models
|
|
for( auto *attachment : Dynamic->mdAttachments ) {
|
|
Render( attachment, Dynamic->Material(), squaredistance );
|
|
}
|
|
// optional coupling adapters
|
|
Render_coupler_adapter( Dynamic, squaredistance, end::front );
|
|
Render_coupler_adapter( Dynamic, squaredistance, end::rear );
|
|
if( Dynamic->mdLoad ) {
|
|
// renderowanie nieprzezroczystego ładunku
|
|
Render( Dynamic->mdLoad, Dynamic->Material(), squaredistance, { 0.f, Dynamic->LoadOffset, 0.f }, {} );
|
|
}
|
|
// post-render cleanup
|
|
break;
|
|
}
|
|
case rendermode::pickcontrols:
|
|
{
|
|
if (Dynamic->mdLowPolyInt) {
|
|
// low poly interior
|
|
Render(Dynamic->mdLowPolyInt, Dynamic->Material(), squaredistance);
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::pickscenery:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
::glPopMatrix();
|
|
|
|
model_ubs.future = future_stack;
|
|
|
|
// TODO: check if this reset is needed. In theory each object should render all parts based on its own instance data anyway?
|
|
if (Dynamic->btnOn)
|
|
Dynamic->TurnOff(); // przywrócenie domyślnych pozycji submodeli
|
|
|
|
return true;
|
|
}
|
|
|
|
// rendering kabiny gdy jest oddzielnym modelem i ma byc wyswietlana
|
|
bool scene_walk::Render_cab(TDynamicObject const *Dynamic, float const Lightlevel, bool const Alpha)
|
|
{
|
|
// the cab models of the vehicles are held with the vehicles (walk_sync)
|
|
gfx::walk_sync::vehicle_hold hold;
|
|
|
|
if (Dynamic == nullptr)
|
|
{
|
|
|
|
TSubModel::iInstance = 0;
|
|
TSubModel::iVariantSeed = 0;
|
|
return false;
|
|
}
|
|
|
|
TSubModel::iInstance = reinterpret_cast<std::uintptr_t>(Dynamic);
|
|
TSubModel::iVariantSeed = Dynamic->variant_seed();
|
|
|
|
if ((true == FreeFlyModeFlag) || (false == Dynamic->bDisplayCab) || (Dynamic->mdKabina == Dynamic->mdModel))
|
|
{
|
|
// ABu: Rendering kabiny jako ostatniej, zeby bylo widac przez szyby, tylko w widoku ze srodka
|
|
return false;
|
|
}
|
|
|
|
if (Dynamic->mdKabina)
|
|
{ // bo mogła zniknąć przy przechodzeniu do innego pojazdu
|
|
// setup shared by all render paths
|
|
::glPushMatrix();
|
|
|
|
auto const originoffset = Dynamic->GetPosition() - m_renderpass.pass_camera.position();
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
::glMultMatrixd(glm::value_ptr(Dynamic->mMatrix));
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
{
|
|
// render path specific setup:
|
|
if (gfx::vehicle_shade(Dynamic) > 0.0f)
|
|
{
|
|
// change light level based on light level of the occupied track
|
|
walk_sunlight(gfx::vehicle_shade(Dynamic));
|
|
}
|
|
|
|
walk_ambient_save();
|
|
auto const luminance { Global.fLuminance * gfx::vehicle_light_level( Dynamic ) };
|
|
if( Lightlevel > 0.f ) {
|
|
// crude way to light the cabin, until we have something more complete in place. with the lamp of the cab among the
|
|
// lights a share of it is kept for the light which bounces around the cab, unless the probe of the cab gives that light
|
|
auto const share { m_cablamplit ? ( m_cabprobelit ? 0.f : Global.gfx_lights_cab_bounce ) : 1.f };
|
|
if( share > 0.f ) {
|
|
walk_ambient_add( ( Dynamic->InteriorLight * Lightlevel ) * std::clamp( 1.25f - (float)luminance, 0.f, 1.f ) * share );
|
|
}
|
|
}
|
|
// the parts of the cab read its probe
|
|
model_ubs.cab_interior = 1.f;
|
|
|
|
// render
|
|
if (true == Alpha)
|
|
{
|
|
// translucent parts
|
|
Render_Alpha(Dynamic->mdKabina, Dynamic->Material(), 0.0);
|
|
}
|
|
else
|
|
{
|
|
// opaque parts
|
|
Render(Dynamic->mdKabina, Dynamic->Material(), 0.0);
|
|
}
|
|
// post-render restore
|
|
model_ubs.cab_interior = 0.f;
|
|
walk_ambient_restore();
|
|
walk_sunlight();
|
|
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
{
|
|
if( true == Alpha ) {
|
|
// translucent parts
|
|
Render_Alpha( Dynamic->mdKabina, Dynamic->Material(), 0.0 );
|
|
}
|
|
else {
|
|
// opaque parts
|
|
Render( Dynamic->mdKabina, Dynamic->Material(), 0.0 );
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::pickcontrols:
|
|
{
|
|
Render(Dynamic->mdKabina, Dynamic->Material(), 0.0);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
// post-render restore
|
|
::glPopMatrix();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool scene_walk::Render(TModel3d *Model, material_data const *Material, float const Squaredistance)
|
|
{
|
|
|
|
auto alpha = (Material != nullptr ? Material->textures_alpha : 0x30300030);
|
|
alpha ^= 0x0F0F000F; // odwrócenie flag tekstur, aby wyłapać nieprzezroczyste
|
|
if (0 == (alpha & Model->iFlags & 0x1F1F001F))
|
|
{
|
|
// czy w ogóle jest co robić w tym cyklu?
|
|
return false;
|
|
}
|
|
|
|
Model->Root->fSquareDist = Squaredistance; // zmienna globalna!
|
|
|
|
// setup
|
|
Model->Root->ReplacableSet((Material != nullptr ? Material->replacable_skins : nullptr), alpha);
|
|
|
|
Model->Root->pRoot = Model;
|
|
|
|
// render
|
|
Render(Model->Root);
|
|
|
|
// post-render cleanup
|
|
|
|
return true;
|
|
}
|
|
|
|
bool scene_walk::Render(TModel3d *Model, material_data const *Material, float const Squaredistance, glm::dvec3 const &Position, glm::vec3 const &Angle)
|
|
{
|
|
::glPushMatrix();
|
|
::glTranslated(Position.x, Position.y, Position.z);
|
|
if (Angle.y != 0.0)
|
|
::glRotated(Angle.y, 0.f, 1.f, 0.f);
|
|
if (Angle.x != 0.0)
|
|
::glRotated(Angle.x, 1.f, 0.f, 0.f);
|
|
if (Angle.z != 0.0)
|
|
::glRotated(Angle.z, 0.f, 0.f, 1.f);
|
|
|
|
auto const result = Render(Model, Material, Squaredistance);
|
|
|
|
::glPopMatrix();
|
|
|
|
return result;
|
|
}
|
|
|
|
void scene_walk::Render(TSubModel *Submodel)
|
|
{
|
|
glDebug("Render TSubModel");
|
|
|
|
if ((Submodel->iVisible) && (TSubModel::fSquareDist >= Submodel->fSquareMinDist) && (TSubModel::fSquareDist < Submodel->fSquareMaxDist) && (false == m_previewing || Submodel->fVisible > 0.f))
|
|
{
|
|
glm::mat4 future_stack = model_ubs.future;
|
|
|
|
if (Submodel->iFlags & 0xC000)
|
|
{
|
|
::glPushMatrix();
|
|
if (Submodel->fMatrix)
|
|
::glMultMatrixf(Submodel->fMatrix->readArray());
|
|
if (Submodel->b_aAnim != TAnimType::at_None)
|
|
{
|
|
Submodel->RaAnimation(Submodel->b_aAnim);
|
|
|
|
glm::mat4 mv = OpenGLMatrices.data(GL_MODELVIEW);
|
|
model_ubs.future *= (mv * (m_motionhistory ? glm::inverse(Submodel->future_transform) : Submodel->future_transform)) * glm::inverse(mv);
|
|
// the placement may be different in the next frame: the walk isn't kept (Record_Indirect_Draws())
|
|
m_indirectchanging = true;
|
|
}
|
|
}
|
|
|
|
if (Submodel->eType < TP_ROTATOR)
|
|
{
|
|
// renderowanie obiektów OpenGL
|
|
if (Submodel->iAlpha & Submodel->iFlags & 0x1F)
|
|
{
|
|
// rysuj gdy element nieprzezroczysty
|
|
|
|
// debug data
|
|
++m_renderpass.draw_stats.submodels;
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
{
|
|
// material configuration:
|
|
// transparency hack
|
|
if (Submodel->fVisible < 1.0f)
|
|
walk_blending(true);
|
|
|
|
// textures...
|
|
if (Submodel->m_material < 0)
|
|
{ // zmienialne skóry
|
|
walk_material(submodel_material(Submodel), Submodel);
|
|
}
|
|
else
|
|
{
|
|
// również 0
|
|
walk_material(Submodel->m_material, Submodel);
|
|
}
|
|
|
|
// ...luminance
|
|
auto const isemissive { ( Submodel->f4Emision.a > 0.f ) && ( Global.fLuminance < Submodel->fLight ) };
|
|
if( ( Submodel->f4Emision.a > 0.f ) && ( Submodel->fLight > -1.f ) )
|
|
{
|
|
// lit or not by the luminance of the moment: the walk isn't kept (Record_Indirect_Draws())
|
|
m_indirectchanging = true;
|
|
}
|
|
if (isemissive)
|
|
model_ubs.emission = Submodel->f4Emision.a;
|
|
|
|
// main draw call
|
|
walk_draw(Submodel->m_geometry.handle);
|
|
|
|
// post-draw reset
|
|
model_ubs.emission = 0.0f;
|
|
if (Submodel->fVisible < 1.0f)
|
|
walk_blending(false);
|
|
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
{
|
|
// skip if the shadow caster rank is too low for currently set threshold
|
|
// or if the submodel is hidden (colour pass only fades it out, e.g. inactive seasonal variant)
|
|
if( ( walk_material_data( Submodel ).shadow_rank > Global.gfx_shadow_rank_cutoff )
|
|
|| ( Submodel->fVisible <= 0.f ) )
|
|
{
|
|
--m_renderpass.draw_stats.submodels;
|
|
--m_renderpass.draw_stats.drawcalls;
|
|
break;
|
|
}
|
|
|
|
if (Submodel->m_material < 0)
|
|
{ // zmienialne skóry
|
|
walk_shadow_material(submodel_material(Submodel));
|
|
}
|
|
else
|
|
{
|
|
// również 0
|
|
walk_shadow_material(Submodel->m_material);
|
|
}
|
|
walk_draw(Submodel->m_geometry.handle);
|
|
break;
|
|
}
|
|
case rendermode::pickscenery:
|
|
{
|
|
walk_program( walk_shader::pick );
|
|
walk_draw(Submodel->m_geometry.handle);
|
|
break;
|
|
}
|
|
case rendermode::pickcontrols:
|
|
{
|
|
if (Submodel->screen_touch_list) {
|
|
// touch screen gradient
|
|
walk_program( walk_shader::pick_surface );
|
|
model_ubs.param[0] = glm::vec4(1.0f - m_picksurfaceitems.size() / 255.0f, 0.0f, 0.0f, 1.0f);
|
|
m_picksurfaceitems.emplace_back(Submodel);
|
|
}
|
|
else {
|
|
// control picking applies individual colour for each submodel
|
|
walk_program( walk_shader::pick );
|
|
m_pickcontrolsitems.emplace_back(Submodel);
|
|
model_ubs.param[0] = glm::vec4(pick_color(m_pickcontrolsitems.size()), 1.0f);
|
|
}
|
|
|
|
walk_draw(Submodel->m_geometry.handle);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (Submodel->eType == TP_STARS)
|
|
{
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
// colour points are only rendered in colour mode(s)
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
{
|
|
m_indirectchanging = true;
|
|
if (Global.fLuminance < Submodel->fLight)
|
|
{
|
|
walk_material(Submodel->m_material, Submodel);
|
|
|
|
// main draw call
|
|
model_ubs.param[1].x = 8.0f;
|
|
|
|
walk_draw(Submodel->m_geometry.handle);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (Submodel->Child != nullptr)
|
|
if (Submodel->iAlpha & Submodel->iFlags & 0x001F0000)
|
|
Render(Submodel->Child);
|
|
|
|
if (Submodel->iFlags & 0xC000)
|
|
{
|
|
model_ubs.future = future_stack;
|
|
::glPopMatrix();
|
|
}
|
|
}
|
|
/*
|
|
if( Submodel->b_Anim < at_SecondsJump )
|
|
Submodel->b_Anim = at_None; // wyłączenie animacji dla kolejnego użycia subm
|
|
*/
|
|
if (Submodel->Next)
|
|
if (Submodel->iAlpha & Submodel->iFlags & 0x1F000000)
|
|
Render(Submodel->Next); // dalsze rekurencyjnie
|
|
}
|
|
|
|
void scene_walk::Render(TTrack *Track)
|
|
{
|
|
if ((Track->m_material1 == 0) && (Track->m_material2 == 0) && (Track->eType != tt_Switch || Track->SwitchExtension->m_material3 == 0))
|
|
{
|
|
return;
|
|
}
|
|
if (false == Track->m_visible)
|
|
{
|
|
return;
|
|
}
|
|
|
|
++m_renderpass.draw_stats.paths;
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
// single path pieces are rendererd in pick scenery mode only
|
|
case rendermode::pickscenery:
|
|
{
|
|
walk_program( walk_shader::pick );
|
|
m_picksceneryitems.emplace_back( Track );
|
|
|
|
walk_draw(std::begin(Track->Geometry1), std::end(Track->Geometry1));
|
|
walk_draw(std::begin(Track->Geometry2), std::end(Track->Geometry2));
|
|
for (auto &tread : Track->GeometryTreads)
|
|
walk_draw(std::begin(tread.geometry), std::end(tread.geometry));
|
|
if (Track->eType == tt_Switch)
|
|
walk_draw(Track->SwitchExtension->Geometry3);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// experimental, does track rendering in two passes, to take advantage of reduced texture switching
|
|
void scene_walk::Render(scene::basic_cell::path_sequence::const_iterator First, scene::basic_cell::path_sequence::const_iterator Last)
|
|
{
|
|
|
|
// setup
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::shadows:
|
|
{
|
|
// NOTE: roads-based platforms tend to miss parts of shadows if rendered with either back or front culling
|
|
walk_cull_face(false);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// geometry of neighbouring tracks which share the material is gathered and drawn together.
|
|
// only neighbours are combined, the tracks are still drawn in their order in the cell
|
|
material_handle batchmaterial{null_handle};
|
|
auto const flush_batch = [&]()
|
|
{
|
|
if (false == m_pathbatch.empty())
|
|
{
|
|
walk_draw(std::begin(m_pathbatch), std::end(m_pathbatch));
|
|
m_pathbatch.clear();
|
|
}
|
|
batchmaterial = null_handle;
|
|
};
|
|
// returns: true if the material starts a new batch, false if it continues the current one
|
|
auto const begin_batch = [&](material_handle const Material)
|
|
{
|
|
if (Material == batchmaterial)
|
|
{
|
|
return false;
|
|
}
|
|
flush_batch();
|
|
walk_material(Material);
|
|
batchmaterial = Material;
|
|
return true;
|
|
};
|
|
|
|
// TODO: render auto generated trackbeds together with regular trackbeds in pass 1, and all rails in pass 2
|
|
// first pass, material 1
|
|
for (auto first{First}; first != Last; ++first)
|
|
{
|
|
|
|
auto const track{*first};
|
|
|
|
if (track->m_material1 == 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (false == track->m_visible)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
++m_renderpass.draw_stats.paths;
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
{
|
|
if (track_environment(track) != e_flat)
|
|
{
|
|
// track with light level of its own is drawn on its own
|
|
flush_batch();
|
|
walk_environment(track_environment(track));
|
|
walk_material(track->m_blendmaterial1 != null_handle ? track->m_blendmaterial1 : track->m_material1);
|
|
walk_draw(std::begin(track->Geometry1), std::end(track->Geometry1));
|
|
// restore default lighting
|
|
walk_environment();
|
|
break;
|
|
}
|
|
if (false == begin_batch(track->m_blendmaterial1 != null_handle ? track->m_blendmaterial1 : track->m_material1))
|
|
{
|
|
// the track is drawn with the call of its predecessor
|
|
--m_renderpass.draw_stats.drawcalls;
|
|
}
|
|
m_pathbatch.insert(std::end(m_pathbatch), std::begin(track->Geometry1), std::end(track->Geometry1));
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
{
|
|
if ((std::abs(track->fTexHeight1) < 0.35f) || (track->iCategoryFlag != 2))
|
|
{
|
|
// shadows are only calculated for high enough roads, typically meaning track platforms
|
|
--m_renderpass.draw_stats.paths;
|
|
--m_renderpass.draw_stats.drawcalls;
|
|
continue;
|
|
}
|
|
if( walk_material_data( track->m_material1 ).shadow_rank > Global.gfx_shadow_rank_cutoff ) {
|
|
// skip if the shadow caster rank is too low for currently set threshold
|
|
--m_renderpass.draw_stats.paths;
|
|
--m_renderpass.draw_stats.drawcalls;
|
|
continue;
|
|
}
|
|
walk_shadow_material(track->m_material1);
|
|
walk_draw(std::begin(track->Geometry1), std::end(track->Geometry1));
|
|
break;
|
|
}
|
|
case rendermode::pickscenery: // pick scenery mode uses piece-by-piece approach
|
|
case rendermode::pickcontrols:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
flush_batch();
|
|
// second pass, material 2
|
|
for (auto first{First}; first != Last; ++first)
|
|
{
|
|
auto const track{*first};
|
|
|
|
if (track->m_material2 == 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (false == track->m_visible)
|
|
{
|
|
continue;
|
|
}
|
|
if (track->eType == tt_Normal && editor_ballast_hidden(track, m_renderpass.draw_mode == rendermode::color))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
{
|
|
if (track_environment(track) != e_flat)
|
|
{
|
|
flush_batch();
|
|
walk_environment(track_environment(track));
|
|
walk_material(track->m_blendmaterial2 != null_handle ? track->m_blendmaterial2 : track->m_material2);
|
|
walk_draw(std::begin(track->Geometry2), std::end(track->Geometry2));
|
|
// restore default lighting
|
|
walk_environment();
|
|
break;
|
|
}
|
|
begin_batch(track->m_blendmaterial2 != null_handle ? track->m_blendmaterial2 : track->m_material2);
|
|
m_pathbatch.insert(std::end(m_pathbatch), std::begin(track->Geometry2), std::end(track->Geometry2));
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
{
|
|
if ((std::abs(track->fTexHeight1) < 0.35f) || ((track->iCategoryFlag == 1) && (track->eType != tt_Normal)))
|
|
{
|
|
// shadows are only calculated for high enough trackbeds
|
|
continue;
|
|
}
|
|
if( walk_material_data( track->m_material2 ).shadow_rank > Global.gfx_shadow_rank_cutoff ) {
|
|
// skip if the shadow caster rank is too low for currently set threshold
|
|
continue;
|
|
}
|
|
walk_shadow_material(track->m_material2);
|
|
walk_draw(std::begin(track->Geometry2), std::end(track->Geometry2));
|
|
break;
|
|
}
|
|
case rendermode::pickscenery: // pick scenery mode uses piece-by-piece approach
|
|
case rendermode::pickcontrols:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
flush_batch();
|
|
|
|
// third pass, material 3
|
|
for (auto first{First}; first != Last; ++first)
|
|
{
|
|
|
|
auto const track{*first};
|
|
|
|
if (track->eType != tt_Switch)
|
|
{
|
|
continue;
|
|
}
|
|
if (track->SwitchExtension->m_material3 == 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (false == track->m_visible)
|
|
{
|
|
continue;
|
|
}
|
|
if (editor_ballast_hidden(track, m_renderpass.draw_mode == rendermode::color))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
case rendermode::reflections:
|
|
{
|
|
if (track_environment(track) != e_flat)
|
|
{
|
|
flush_batch();
|
|
walk_environment(track_environment(track));
|
|
walk_material(track->m_blendmaterial3 != null_handle ? track->m_blendmaterial3 : track->SwitchExtension->m_material3);
|
|
walk_draw(track->SwitchExtension->Geometry3);
|
|
// restore default lighting
|
|
walk_environment();
|
|
break;
|
|
}
|
|
begin_batch(track->m_blendmaterial3 != null_handle ? track->m_blendmaterial3 : track->SwitchExtension->m_material3);
|
|
m_pathbatch.emplace_back(track->SwitchExtension->Geometry3);
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
{
|
|
if ((std::abs(track->fTexHeight1) < 0.35f) || ((track->iCategoryFlag == 1) && (track->eType != tt_Normal)))
|
|
{
|
|
// shadows are only calculated for high enough trackbeds
|
|
continue;
|
|
}
|
|
if( walk_material_data( track->m_material2 ).shadow_rank > Global.gfx_shadow_rank_cutoff ) {
|
|
// skip if the shadow caster rank is too low for currently set threshold
|
|
continue;
|
|
}
|
|
walk_shadow_material(track->SwitchExtension->m_material3);
|
|
walk_draw(track->SwitchExtension->Geometry3);
|
|
break;
|
|
}
|
|
case rendermode::pickscenery: // pick scenery mode uses piece-by-piece approach
|
|
case rendermode::pickcontrols:
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
flush_batch();
|
|
|
|
// cut faces of rails, in matte variants of the rail materials
|
|
if ((m_renderpass.draw_mode == rendermode::color) || (m_renderpass.draw_mode == rendermode::reflections))
|
|
{
|
|
for (auto first{First}; first != Last; ++first)
|
|
{
|
|
auto const track{*first};
|
|
|
|
if (false == track->m_visible)
|
|
{
|
|
continue;
|
|
}
|
|
std::vector<std::pair<material_handle, TTrack::geometryhandle_sequence *>> parts{{track->m_materialcut1, &track->GeometryCut1}, {track->m_materialcut2, &track->GeometryCut2}};
|
|
for (auto &tread : track->GeometryTreads)
|
|
{
|
|
parts.emplace_back(tread.material, &tread.geometry);
|
|
parts.emplace_back(tread.matte, &tread.cuts);
|
|
}
|
|
for (auto const &cuts : parts)
|
|
{
|
|
if ((cuts.first == null_handle) || cuts.second->empty())
|
|
{
|
|
continue;
|
|
}
|
|
if (track_environment(track) != e_flat)
|
|
{
|
|
flush_batch();
|
|
walk_environment(track_environment(track));
|
|
walk_material(cuts.first);
|
|
walk_draw(std::begin(*cuts.second), std::end(*cuts.second));
|
|
walk_environment();
|
|
continue;
|
|
}
|
|
begin_batch(cuts.first);
|
|
m_pathbatch.insert(std::end(m_pathbatch), std::begin(*cuts.second), std::end(*cuts.second));
|
|
}
|
|
}
|
|
flush_batch();
|
|
}
|
|
|
|
// fourth pass: per-track sleeper models (sleepermodel optional directive).
|
|
// drawn after rails/trackbeds so depth pre-pass culling is favourable, and only in passes
|
|
// where Render_Sleepers actually does work (it gates itself on draw mode / distance).
|
|
switch( m_renderpass.draw_mode ) {
|
|
case rendermode::color:
|
|
case rendermode::reflections: {
|
|
if( editor_sleepers_hidden() ) { break; }
|
|
for( auto first { First }; first != Last; ++first ) {
|
|
auto *track = *first;
|
|
if( false == track->m_visible ) { continue; }
|
|
if( false == track->m_sleeper_enabled ) { continue; }
|
|
// a track with the sleepers and timbers of eu07.ini lays its sleeper model there
|
|
if( track->m_sleepers3d.active ) { continue; }
|
|
// the backend may draw them itself (the gpu culling of the opengl renderer)
|
|
if( walk_queue_sleepers( track ) ) { continue; }
|
|
Render_Sleepers( track );
|
|
}
|
|
if( m_renderpass.draw_mode == rendermode::color ) {
|
|
Render_Timbers( First, Last );
|
|
}
|
|
break;
|
|
}
|
|
case rendermode::shadows: {
|
|
Render_Timbers( First, Last );
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// post-render reset
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::shadows:
|
|
{
|
|
// restore standard face cull mode
|
|
walk_cull_face(true);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void scene_walk::Render(TMemCell *Memcell)
|
|
{
|
|
|
|
::glPushMatrix();
|
|
auto const position = Memcell->location() - m_renderpass.pass_camera.position();
|
|
::glTranslated(position.x, position.y + 0.5, position.z);
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
{
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
case rendermode::pickscenery:
|
|
{
|
|
break;
|
|
}
|
|
case rendermode::reflections:
|
|
case rendermode::pickcontrols:
|
|
{
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
::glPopMatrix();
|
|
}
|
|
|
|
void scene_walk::Render_Alpha(scene::basic_region *Region)
|
|
{
|
|
|
|
// sort the nodes based on their distance to viewer
|
|
std::sort(std::begin(m_cellqueue), std::end(m_cellqueue), [](distancecell_pair const &Left, distancecell_pair const &Right) { return (Left.first) < (Right.first); });
|
|
|
|
Render_Alpha(std::rbegin(m_cellqueue), std::rend(m_cellqueue));
|
|
}
|
|
|
|
void scene_walk::Render_Alpha(cell_sequence::reverse_iterator First, cell_sequence::reverse_iterator Last)
|
|
{
|
|
|
|
// NOTE: this method is launched only during color pass therefore we don't bother with mode test here
|
|
// the cells far off with the tracks alone drawn there have nothing translucent drawn either
|
|
auto const scenery_limit{static_cast<double>(Global.BaseDrawRange) * Global.fDistanceFactor + 250.0};
|
|
bool const far_paths{EditorModeFlag && Global.editor_tracks};
|
|
glm::dvec3 const camera{m_renderpass.pass_camera.position()};
|
|
auto const distant = [&](scene::basic_cell const *Cell) { return editor_far_tracks_only(far_paths, Cell->m_area, camera, scenery_limit); };
|
|
// first pass draws elements which we know are located in section banks, to reduce vbo switching
|
|
{
|
|
auto first{First};
|
|
while (first != Last)
|
|
{
|
|
|
|
auto const *cell = first->second;
|
|
|
|
if (false == cell->m_shapestranslucent.empty() && false == distant(cell))
|
|
{
|
|
// since all shapes of the cell share center point we can optimize out a few calls here
|
|
::glPushMatrix();
|
|
auto const originoffset{cell->m_area.center - m_renderpass.pass_camera.position()};
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
// render
|
|
// NOTE: we can reuse the method used to draw opaque geometry
|
|
for (auto const &shape : cell->m_shapestranslucent)
|
|
{
|
|
Render(shape, false);
|
|
}
|
|
// post-render cleanup
|
|
::glPopMatrix();
|
|
}
|
|
|
|
++first;
|
|
}
|
|
}
|
|
// second pass draws elements with their own vbos
|
|
{
|
|
auto first{First};
|
|
while (first != Last)
|
|
{
|
|
|
|
auto const *cell = first->second;
|
|
gfx::walk_sync::yield();
|
|
if (distant(cell))
|
|
{
|
|
++first;
|
|
continue;
|
|
}
|
|
|
|
// translucent parts of instanced models
|
|
for (auto *instance : cell->m_instancetranslucent)
|
|
{
|
|
Render_Alpha(instance);
|
|
}
|
|
// translucent parts of vehicles
|
|
for (auto *path : cell->m_paths)
|
|
{
|
|
for (auto *dynamic : path->Dynamics)
|
|
{
|
|
Render_Alpha(dynamic);
|
|
}
|
|
}
|
|
|
|
++first;
|
|
}
|
|
}
|
|
// third pass draws the wires;
|
|
// wires use section vbos, but for the time being we want to draw them at the very end
|
|
{
|
|
auto first{First};
|
|
while (first != Last)
|
|
{
|
|
|
|
auto const *cell = first->second;
|
|
|
|
if ((false == cell->m_traction.empty() || (false == cell->m_lines.empty())) && false == distant(cell))
|
|
{
|
|
// since all shapes of the cell share center point we can optimize out a few calls here
|
|
::glPushMatrix();
|
|
auto const originoffset{cell->m_area.center - m_renderpass.pass_camera.position()};
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
walk_material(null_handle);
|
|
// render
|
|
for (auto *traction : cell->m_traction)
|
|
{
|
|
Render_Alpha(traction);
|
|
}
|
|
for (auto &lines : cell->m_lines)
|
|
{
|
|
Render_Alpha(lines);
|
|
}
|
|
// post-render cleanup
|
|
::glPopMatrix();
|
|
}
|
|
|
|
++first;
|
|
}
|
|
}
|
|
}
|
|
|
|
void scene_walk::Render_Alpha(TAnimModel *Instance)
|
|
{
|
|
|
|
if (false == Instance->m_visible) { return; }
|
|
if( false == m_renderpass.pass_camera.visible( Instance->m_area ) ) { return; }
|
|
|
|
double distancesquared;
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::shadows:
|
|
{
|
|
// 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
|
|
distancesquared = glm::length2((Instance->location() - m_renderpass.viewport_camera.position()) / (double)Global.ZoomFactor) / Global.fDistanceFactor;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
distancesquared = glm::length2((Instance->location() - m_renderpass.pass_camera.position()) / (double)Global.ZoomFactor) / Global.fDistanceFactor;
|
|
break;
|
|
}
|
|
}
|
|
if ((distancesquared < Instance->m_rangesquaredmin) || (distancesquared >= Instance->m_rangesquaredmax))
|
|
{
|
|
return;
|
|
}
|
|
// crude way to reject early items too far to affect the output (mostly relevant for shadow passes)
|
|
auto const drawdistancethreshold{ m_renderpass.draw_range + 250 };
|
|
if( distancesquared > sq(drawdistancethreshold) ) {
|
|
return;
|
|
}
|
|
// second stage visibility cull, reject modelstoo far away to be noticeable
|
|
auto const radiussquared { Instance->radius() * Instance->radius() };
|
|
if( radiussquared * Global.ZoomFactor / distancesquared < 0.003 * 0.003 ) {
|
|
return;
|
|
}
|
|
|
|
gfx::walk_sync::model_hold hold{Instance->pModel};
|
|
Instance->RaPrepare();
|
|
if (Instance->pModel)
|
|
{
|
|
auto const &scale = Instance->Scale();
|
|
bool const scaled = ( scale.x != 1.0f || scale.y != 1.0f || scale.z != 1.0f );
|
|
if( scaled ) {
|
|
// scaled instance: build the per-instance transform locally and call
|
|
// the distance-only Render_Alpha so we can inject glScalef before
|
|
// the submodel walk. Mirror of the opaque path in Render(TAnimModel*).
|
|
::glPushMatrix();
|
|
auto const Position = Instance->location() - m_renderpass.pass_camera.position();
|
|
auto const Angle = Instance->vAngle;
|
|
::glTranslated( Position.x, Position.y, Position.z );
|
|
if( Angle.y != 0.0 ) ::glRotated( Angle.y, 0.f, 1.f, 0.f );
|
|
if( Angle.x != 0.0 ) ::glRotated( Angle.x, 1.f, 0.f, 0.f );
|
|
if( Angle.z != 0.0 ) ::glRotated( Angle.z, 0.f, 0.f, 1.f );
|
|
::glScalef( scale.x, scale.y, scale.z );
|
|
Render_Alpha( Instance->pModel, Instance->Material(), distancesquared );
|
|
::glPopMatrix();
|
|
}
|
|
else {
|
|
Render_Alpha(Instance->pModel, Instance->Material(), distancesquared, Instance->location() - m_renderpass.pass_camera.position(), Instance->vAngle);
|
|
}
|
|
}
|
|
}
|
|
|
|
void scene_walk::Render_Alpha(TTraction *Traction)
|
|
{
|
|
glDebug("Render_Alpha TTraction");
|
|
|
|
auto const distancesquared { glm::length2( ( Traction->location() - m_renderpass.pass_camera.position() ) / (double)Global.ZoomFactor ) / Global.fDistanceFactor };
|
|
if ((distancesquared < Traction->m_rangesquaredmin) || (distancesquared >= Traction->m_rangesquaredmax))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (false == Traction->m_visible)
|
|
{
|
|
return;
|
|
}
|
|
// rysuj jesli sa druty i nie zerwana
|
|
if ((Traction->Wires == 0) || (true == TestFlag(Traction->DamageFlag, 128)))
|
|
{
|
|
return;
|
|
}
|
|
// setup
|
|
auto const distance{static_cast<float>(std::sqrt(distancesquared))};
|
|
auto const linealpha = 20.f * Traction->WireThickness / std::max(0.5f * Traction->radius() + 1.f, distance - (0.5f * Traction->radius()));
|
|
|
|
// render
|
|
|
|
// McZapkie-261102: kolor zalezy od materialu i zasniedzenia
|
|
model_ubs.param[0] = glm::vec4(Traction->wire_color(), glm::min(1.0f, linealpha));
|
|
|
|
if (m_renderpass.draw_mode == rendermode::shadows)
|
|
walk_shadow_material(null_handle);
|
|
else
|
|
walk_program( walk_shader::line );
|
|
|
|
walk_draw(Traction->m_geometry);
|
|
|
|
// up close also the solids of a span drawn by the type of the catenary: the wires and ropes in their real thickness and the fittings.
|
|
// they're opaque, so they're drawn without blending and write the depth; otherwise they'd cover one another by the order they're drawn in
|
|
if (auto const solid{catenary_span_solid(*Traction, Global.pCamera.Pos)}; solid.wires != null_handle)
|
|
{
|
|
auto const blending{walk_blending_enabled()};
|
|
if (m_renderpass.draw_mode != rendermode::shadows)
|
|
walk_blending(false);
|
|
model_ubs.param[0] = glm::vec4(Traction->wire_color(), 1.0f);
|
|
walk_draw(solid.wires);
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
if (solid.fittings != null_handle)
|
|
{
|
|
walk_draw(solid.fittings);
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
}
|
|
// the rope of the tensioning device at the end of the span (steel)
|
|
if (solid.rope != null_handle)
|
|
{
|
|
auto const &steel{catenary_rope_metal()};
|
|
model_ubs.param[0] = glm::vec4(steel.color[0], steel.color[1], steel.color[2], 1.0f);
|
|
walk_draw(solid.rope);
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
}
|
|
if (m_renderpass.draw_mode != rendermode::shadows)
|
|
walk_blending(blending);
|
|
}
|
|
|
|
// debug data
|
|
++m_renderpass.draw_stats.traction;
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
}
|
|
|
|
void scene_walk::Render_Alpha(scene::lines_node const &Lines)
|
|
{
|
|
glDebug("Render_Alpha scene::lines_node");
|
|
|
|
auto const &data{Lines.data()};
|
|
|
|
auto const distancesquared { glm::length2( ( data.area.center - m_renderpass.pass_camera.position() ) / (double)Global.ZoomFactor ) / Global.fDistanceFactor };
|
|
if ((distancesquared < data.rangesquared_min) || (distancesquared >= data.rangesquared_max))
|
|
{
|
|
return;
|
|
}
|
|
// setup
|
|
auto const distance{static_cast<float>(std::sqrt(distancesquared))};
|
|
auto const linealpha =
|
|
(data.line_width > 0.f ? 10.f * data.line_width / std::max(0.5f * data.area.radius + 1.f, distance - (0.5f * data.area.radius)) : 1.f); // negative width means the lines are always opague
|
|
|
|
model_ubs.param[0] = glm::vec4(glm::vec3(data.lighting.diffuse * walk_sun_ambient()), glm::min(1.0f, linealpha));
|
|
|
|
if (m_renderpass.draw_mode == rendermode::shadows)
|
|
walk_shadow_material(null_handle);
|
|
else
|
|
walk_program( walk_shader::line );
|
|
walk_draw(data.geometry);
|
|
|
|
++m_renderpass.draw_stats.lines;
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
}
|
|
|
|
// TDynamicObject::renderme, which only the walks read: kept by the walk itself while the passes are walked by several threads at once
|
|
// (walk_sync), where it falls back on the value of the vehicle for a vehicle it didn't set (as when the passes come one after another)
|
|
void scene_walk::set_renderme(TDynamicObject *Dynamic, bool const Value)
|
|
{
|
|
if (gfx::walk_sync::parallel())
|
|
{
|
|
m_renderme[Dynamic] = Value;
|
|
return;
|
|
}
|
|
Dynamic->renderme = Value;
|
|
}
|
|
|
|
bool scene_walk::renderme(TDynamicObject const *Dynamic) const
|
|
{
|
|
if (false == m_renderme.empty())
|
|
{
|
|
auto const lookup{m_renderme.find(Dynamic)};
|
|
if (lookup != m_renderme.end())
|
|
{
|
|
return lookup->second;
|
|
}
|
|
}
|
|
return Dynamic->renderme;
|
|
}
|
|
|
|
void scene_walk::Settle_Renderme(bool const Keep)
|
|
{
|
|
if (Keep)
|
|
{
|
|
for (auto const &[dynamic, value] : m_renderme)
|
|
{
|
|
const_cast<TDynamicObject *>(dynamic)->renderme = value;
|
|
}
|
|
}
|
|
m_renderme.clear();
|
|
}
|
|
|
|
void scene_walk::Release_Deferred()
|
|
{
|
|
if (m_deferredrelease)
|
|
{
|
|
track_sleepers::release_far(m_deferredrelease->first, m_deferredrelease->second);
|
|
m_deferredrelease.reset();
|
|
}
|
|
for (auto *track : m_deferredprefetch)
|
|
{
|
|
if (track->m_sleepers3d.dirty)
|
|
{
|
|
track_sleepers::prefetch(*track);
|
|
}
|
|
}
|
|
m_deferredprefetch.clear();
|
|
}
|
|
|
|
bool scene_walk::Render_Alpha(TDynamicObject *Dynamic)
|
|
{
|
|
if (!Global.render_cab && Global.pCamera.m_owner == Dynamic)
|
|
return false;
|
|
|
|
if (false == renderme(Dynamic))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// setup
|
|
TSubModel::iInstance = (size_t)Dynamic; //żeby nie robić cudzych animacji
|
|
TSubModel::iVariantSeed = Dynamic->variant_seed();
|
|
glm::dvec3 const originoffset = Dynamic->vPosition - m_renderpass.pass_camera.position();
|
|
// lod visibility ranges are defined for base (x 1.0) viewing distance. for render we adjust them for actual range multiplier and zoom
|
|
float squaredistance;
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::shadows:
|
|
default:
|
|
{
|
|
squaredistance = glm::length2(glm::vec3{originoffset} / Global.ZoomFactor);
|
|
break;
|
|
}
|
|
}
|
|
gfx::walk_sync::vehicle_hold hold;
|
|
Dynamic->ABuLittleUpdate(squaredistance); // ustawianie zmiennych submodeli dla wspólnego modelu
|
|
|
|
glm::mat4 future_stack = model_ubs.future;
|
|
|
|
glm::mat4 mv = OpenGLMatrices.data(GL_MODELVIEW);
|
|
model_ubs.future *= glm::translate(mv, glm::vec3(m_motionhistory ? -Dynamic->get_future_movement() : Dynamic->get_future_movement())) * glm::inverse(mv);
|
|
// the velocity it leaves in the colour pass keeps the motion blur on (Render_pass())
|
|
if ((m_renderpass.draw_mode == rendermode::color) && (Dynamic->get_future_movement() != glm::dvec3{0.0}))
|
|
m_vehiclesmoving = true;
|
|
|
|
::glPushMatrix();
|
|
|
|
::glTranslated(originoffset.x, originoffset.y, originoffset.z);
|
|
::glMultMatrixd(glm::value_ptr(Dynamic->mMatrix));
|
|
|
|
if (gfx::vehicle_shade(Dynamic) > 0.0f)
|
|
{
|
|
// change light level based on light level of the occupied track
|
|
walk_sunlight(gfx::vehicle_shade(Dynamic));
|
|
}
|
|
|
|
// render
|
|
if( Dynamic->mdLowPolyInt ) {
|
|
// low poly interior
|
|
model_ubs.cab_interior = 2.f;
|
|
Render_Alpha( Dynamic->mdLowPolyInt, Dynamic->Material(), squaredistance );
|
|
model_ubs.cab_interior = 0.f;
|
|
}
|
|
if( Dynamic->mdModel ) {
|
|
// main model
|
|
Render_Alpha( Dynamic->mdModel, Dynamic->Material(), squaredistance );
|
|
}
|
|
// optional attached models
|
|
for( auto *attachment : Dynamic->mdAttachments ) {
|
|
Render_Alpha( attachment, Dynamic->Material(), squaredistance );
|
|
}
|
|
// optional coupling adapters
|
|
Render_coupler_adapter( Dynamic, squaredistance, end::front, true );
|
|
Render_coupler_adapter( Dynamic, squaredistance, end::rear, true );
|
|
if( Dynamic->mdLoad ) {
|
|
// renderowanie nieprzezroczystego ładunku
|
|
Render_Alpha( Dynamic->mdLoad, Dynamic->Material(), squaredistance, { 0.f, Dynamic->LoadOffset, 0.f }, {} );
|
|
}
|
|
|
|
// post-render cleanup
|
|
if (gfx::vehicle_shade(Dynamic) > 0.0f)
|
|
{
|
|
// restore regular light level
|
|
walk_sunlight();
|
|
}
|
|
|
|
::glPopMatrix();
|
|
|
|
model_ubs.future = future_stack;
|
|
|
|
if (Dynamic->btnOn)
|
|
Dynamic->TurnOff(); // przywrócenie domyślnych pozycji submodeli
|
|
|
|
return true;
|
|
}
|
|
|
|
bool scene_walk::Render_Alpha(TModel3d *Model, material_data const *Material, float const Squaredistance)
|
|
{
|
|
|
|
auto alpha = (Material != nullptr ? Material->textures_alpha : 0x30300030);
|
|
|
|
if (0 == (alpha & Model->iFlags & 0x2F2F002F))
|
|
{
|
|
// nothing to render
|
|
return false;
|
|
}
|
|
|
|
Model->Root->fSquareDist = Squaredistance; // zmienna globalna!
|
|
|
|
// setup
|
|
Model->Root->ReplacableSet((Material != nullptr ? Material->replacable_skins : nullptr), alpha);
|
|
|
|
Model->Root->pRoot = Model;
|
|
|
|
// render
|
|
Render_Alpha(Model->Root);
|
|
|
|
// post-render cleanup
|
|
|
|
return true;
|
|
}
|
|
|
|
bool scene_walk::Render_Alpha(TModel3d *Model, material_data const *Material, float const Squaredistance, glm::dvec3 const &Position, glm::vec3 const &Angle)
|
|
{
|
|
::glPushMatrix();
|
|
::glTranslated(Position.x, Position.y, Position.z);
|
|
if (Angle.y != 0.0)
|
|
::glRotated(Angle.y, 0.f, 1.f, 0.f);
|
|
if (Angle.x != 0.0)
|
|
::glRotated(Angle.x, 1.f, 0.f, 0.f);
|
|
if (Angle.z != 0.0)
|
|
::glRotated(Angle.z, 0.f, 0.f, 1.f);
|
|
|
|
auto const result = Render_Alpha(Model, Material, Squaredistance); // position is effectively camera offset
|
|
|
|
::glPopMatrix();
|
|
|
|
return result;
|
|
}
|
|
|
|
// characters of a text display, laid out in a row. the text can be encoded in utf-8 or in windows-1250
|
|
void scene_walk::Render_Alpha_text(TSubModel *Submodel)
|
|
{
|
|
if (TSubModel::pasText == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
for (auto *p : Submodel->text_letters(*TSubModel::pasText))
|
|
{ // translucent only, for the time being
|
|
Render_Alpha(p);
|
|
if (p->fMatrix)
|
|
::glMultMatrixf(p->fMatrix->readArray()); // move on to the place of the next character
|
|
}
|
|
}
|
|
|
|
void scene_walk::Render_Alpha(TSubModel *Submodel)
|
|
{
|
|
// renderowanie przezroczystych przez DL
|
|
if ((Submodel->iVisible) && (TSubModel::fSquareDist >= Submodel->fSquareMinDist) && (TSubModel::fSquareDist < Submodel->fSquareMaxDist) && (false == m_previewing || Submodel->fVisible > 0.f))
|
|
{
|
|
glm::mat4 future_stack = model_ubs.future;
|
|
|
|
if (Submodel->iFlags & 0xC000)
|
|
{
|
|
::glPushMatrix();
|
|
if (Submodel->fMatrix)
|
|
::glMultMatrixf(Submodel->fMatrix->readArray());
|
|
if (Submodel->b_aAnim != TAnimType::at_None)
|
|
{
|
|
Submodel->RaAnimation(Submodel->b_aAnim);
|
|
|
|
glm::mat4 mv = OpenGLMatrices.data(GL_MODELVIEW);
|
|
model_ubs.future *= (mv * (m_motionhistory ? glm::inverse(Submodel->future_transform) : Submodel->future_transform)) * glm::inverse(mv);
|
|
}
|
|
}
|
|
|
|
if (Submodel->eType < TP_ROTATOR)
|
|
{
|
|
// renderowanie obiektów OpenGL
|
|
if (drawn_in_phase(Submodel, 0x2F))
|
|
{
|
|
// rysuj gdy element przezroczysty
|
|
|
|
// debug data
|
|
++m_renderpass.draw_stats.submodels;
|
|
++m_renderpass.draw_stats.drawcalls;
|
|
|
|
switch (m_renderpass.draw_mode)
|
|
{
|
|
case rendermode::color:
|
|
{
|
|
// material configuration:
|
|
// textures...
|
|
if (Submodel->m_material < 0)
|
|
{ // zmienialne skóry
|
|
walk_material(submodel_material(Submodel), Submodel);
|
|
}
|
|
else
|
|
{
|
|
walk_material(Submodel->m_material, Submodel);
|
|
}
|
|
// ...luminance
|
|
|
|
auto const isemissive { ( Submodel->f4Emision.a > 0.f ) && ( Global.fLuminance < Submodel->fLight ) };
|
|
if (isemissive)
|
|
model_ubs.emission = Submodel->f4Emision.a;
|
|
|
|
// main draw call
|
|
walk_draw(Submodel->m_geometry.handle);
|
|
|
|
model_ubs.emission = 0.0f;
|
|
break;
|
|
}
|
|
case rendermode::shadows:
|
|
{
|
|
// skip if the shadow caster rank is too low for currently set threshold
|
|
// or if the submodel is hidden (colour pass only fades it out, e.g. inactive seasonal variant)
|
|
if( ( walk_material_data( Submodel ).shadow_rank > Global.gfx_shadow_rank_cutoff )
|
|
|| ( Submodel->fVisible <= 0.f ) )
|
|
{
|
|
--m_renderpass.draw_stats.submodels;
|
|
--m_renderpass.draw_stats.drawcalls;
|
|
break;
|
|
}
|
|
|
|
if (Submodel->m_material < 0)
|
|
{ // zmienialne skóry
|
|
walk_shadow_material(submodel_material(Submodel));
|
|
}
|
|
else
|
|
{
|
|
walk_shadow_material(Submodel->m_material);
|
|
}
|
|
walk_draw(Submodel->m_geometry.handle);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ((Submodel->eType == TP_FREESPOTLIGHT) && (false == Submodel->bLightOnly))
|
|
{
|
|
// the point of the light and its glare; a light point marked lightonly: only lights its surroundings (gfx::local_lights)
|
|
// NOTE: we're forced here to redo view angle calculations etc, because this data isn't instanced but stored along with the single mesh
|
|
// TODO: separate instance data from reusable geometry
|
|
auto const &modelview = OpenGLMatrices.data(GL_MODELVIEW);
|
|
auto lightcenter = modelview * glm::mix(glm::vec4(0.f, 0.f, -0.05f, 1.f), glm::vec4(0.f, 0.f, -0.25f, 1.f),
|
|
static_cast<float>(TSubModel::fSquareDist / Submodel->fSquareMaxDist)); // pozycja punktu świecącego względem kamery
|
|
if (Submodel->fLightRadius > 0.f)
|
|
{
|
|
// the light shines from the surface of its sphere: the point is seen on the side of it towards the camera, out of
|
|
// the glass of the lamp its middle may be in
|
|
auto const center{modelview * glm::vec4(0.f, 0.f, 0.f, 1.f)};
|
|
auto const centerdistance{glm::length(glm::vec3{center})};
|
|
lightcenter = (centerdistance > Submodel->fLightRadius ? center - glm::vec4(glm::vec3{center} * (Submodel->fLightRadius / centerdistance), 0.f) : center);
|
|
}
|
|
Submodel->fCosViewAngle = glm::dot(glm::normalize(modelview * glm::vec4(0.f, 0.f, -1.f, 1.f) - lightcenter), glm::normalize(-lightcenter));
|
|
// a point light (FalloffAngle 360) is seen all around
|
|
auto const pointlight{Submodel->fCosFalloffAngle <= -1.f};
|
|
|
|
if (Global.fLuminance < Submodel->fLight || Global.Overcast > 1.0f)
|
|
{
|
|
if (pointlight || (Submodel->fCosViewAngle > Submodel->fCosFalloffAngle))
|
|
{
|
|
// only bother if the viewer is inside the visibility cone
|
|
// luminosity at night is at level of ~0.1, so the overall resulting transparency in clear conditions is ~0.5 at full 'brightness'
|
|
auto glarelevel{std::clamp(std::max<float>(0.6f - Global.fLuminance, // reduce the glare in bright daylight
|
|
Global.Overcast - 1.f), // ensure some glare in rainy/foggy conditions
|
|
0.f, 1.f)};
|
|
// view angle attenuation
|
|
float const anglefactor{pointlight ? 1.f : std::clamp((Submodel->fCosViewAngle - Submodel->fCosFalloffAngle) / (Submodel->fCosHotspotAngle - Submodel->fCosFalloffAngle), 0.f, 1.f)};
|
|
|
|
glarelevel *= anglefactor;
|
|
|
|
if (glarelevel > 0.0f)
|
|
{
|
|
walk_glare(true);
|
|
|
|
::glPushMatrix();
|
|
::glLoadIdentity(); // macierz jedynkowa
|
|
::glTranslatef(lightcenter.x, lightcenter.y, lightcenter.z); // początek układu zostaje bez zmian
|
|
::glRotated(std::atan2(lightcenter.x, lightcenter.z) * 180.0 / M_PI, 0.0, 1.0, 0.0); // jedynie obracamy w pionie o kąt
|
|
|
|
auto const lightcolor = glm::vec3(Submodel->DiffuseOverride.r < 0.f ? // -1 indicates no override
|
|
Submodel->f4Diffuse :
|
|
Submodel->DiffuseOverride);
|
|
|
|
walk_program( walk_shader::billboard );
|
|
walk_texture(0, m_glaretexture);
|
|
model_ubs.param[0] = glm::vec4(glm::vec3(lightcolor), Submodel->fVisible * glarelevel);
|
|
|
|
// main draw call
|
|
// drawn where the light itself was seen in the last frame (an occlusion query of the opengl renderer)
|
|
walk_glare_draw(Submodel, m_billboardgeometry);
|
|
|
|
walk_glare(false);
|
|
|
|
::glPopMatrix();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pointlight || (Submodel->fCosViewAngle > Submodel->fCosFalloffAngle))
|
|
{
|
|
// kąt większy niż maksymalny stożek swiatła
|
|
float lightlevel = 1.f; // TODO, TBD: parameter to control light strength
|
|
// view angle attenuation
|
|
float const anglefactor = pointlight ? 1.f : std::clamp((Submodel->fCosViewAngle - Submodel->fCosFalloffAngle) / (Submodel->fCosHotspotAngle - Submodel->fCosFalloffAngle), 0.f, 1.f);
|
|
lightlevel *= anglefactor;
|
|
|
|
// distance attenuation. NOTE: since it's fixed pipeline with built-in gamma correction we're using linear attenuation
|
|
// we're capping how much effect the distance attenuation can have, otherwise the lights get too tiny at regular distances
|
|
float const distancefactor{std::max(0.5f, (Submodel->fSquareMaxDist - TSubModel::fSquareDist) / Submodel->fSquareMaxDist)};
|
|
auto const pointsize{std::max(3.f, 5.f * distancefactor * anglefactor)};
|
|
// additionally reduce light strength for farther sources in rain or snow
|
|
if (Global.Overcast > 0.75f)
|
|
{
|
|
float const precipitationfactor{std::lerp(std::lerp(1.f, 0.25f, std::clamp(Global.Overcast * 0.75f - 0.5f, 0.f, 1.f)), 1.f, distancefactor)};
|
|
lightlevel *= precipitationfactor;
|
|
}
|
|
|
|
if (lightlevel > 0.f)
|
|
{
|
|
::glPushMatrix();
|
|
::glLoadIdentity();
|
|
::glTranslatef(lightcenter.x, lightcenter.y, lightcenter.z); // początek układu zostaje bez zmian
|
|
|
|
// material configuration:
|
|
// limit impact of dense fog on the lights
|
|
auto const lightrange { std::max<float>( 500, m_fogrange * 2 ) }; // arbitrary, visibility at least 500m
|
|
model_ubs.fog_density = 1.0 / lightrange;
|
|
|
|
// main draw call
|
|
model_ubs.emission = 1.0f;
|
|
|
|
auto lightcolor = glm::vec3(Submodel->DiffuseOverride.r < 0.f ? // -1 indicates no override
|
|
Submodel->f4Diffuse :
|
|
Submodel->DiffuseOverride);
|
|
|
|
walk_program( walk_shader::freespot );
|
|
|
|
if (Global.Overcast > 1.0f)
|
|
{
|
|
// fake fog halo
|
|
float const fogfactor{std::lerp(1.5f, 1.f, std::clamp(Global.fFogEnd / 2000, 0.f, 1.f)) * std::max(1.f, Global.Overcast)};
|
|
model_ubs.param[1].x = pointsize * fogfactor * 4.0f;
|
|
model_ubs.param[0] = glm::vec4(glm::vec3(lightcolor), Submodel->fVisible * std::min(1.f, lightlevel) * 0.5f);
|
|
|
|
walk_draw(Submodel->m_geometry.handle);
|
|
}
|
|
model_ubs.param[1].x = pointsize * 4.0f;
|
|
model_ubs.param[0] = glm::vec4(glm::vec3(lightcolor), Submodel->fVisible * std::min(1.f, lightlevel));
|
|
|
|
walk_light_query(Submodel, true);
|
|
|
|
walk_draw(Submodel->m_geometry.handle);
|
|
|
|
walk_light_query(Submodel, false);
|
|
|
|
// post-draw reset
|
|
model_ubs.emission = 0.0f;
|
|
model_ubs.fog_density = 1.0f / m_fogrange;
|
|
|
|
::glPopMatrix();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Submodel->Child != nullptr)
|
|
{
|
|
if (Submodel->eType == TP_TEXT)
|
|
{ // tekst renderujemy w specjalny sposób, zamiast submodeli z łańcucha Child
|
|
Render_Alpha_text(Submodel);
|
|
}
|
|
else if (Submodel->iAlpha & Submodel->iFlags & 0x002F0000)
|
|
Render_Alpha(Submodel->Child);
|
|
}
|
|
|
|
if (Submodel->iFlags & 0xC000)
|
|
{
|
|
model_ubs.future = future_stack;
|
|
::glPopMatrix();
|
|
}
|
|
}
|
|
/*
|
|
if( Submodel->b_aAnim < at_SecondsJump )
|
|
Submodel->b_aAnim = at_None; // wyłączenie animacji dla kolejnego użycia submodelu
|
|
*/
|
|
if (Submodel->Next != nullptr)
|
|
if (Submodel->iAlpha & Submodel->iFlags & 0x2F000000)
|
|
Render_Alpha(Submodel->Next);
|
|
};
|
|
|
|
} // namespace gfx
|