18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-21 05:04:58 +01:00
Files
maszyna/rendering/common/locallights.cpp
pawelw 3710f87fc5 feat(gl46): street lamps of the scenery light their surroundings (#371)
* 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
2026-11-20 04:25:18 +01:00

748 lines
30 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/.
*/
#include "stdafx.h"
#include "rendering/common/locallights.h"
#include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <limits>
#include <string_view>
#include <unordered_set>
#include "utilities/Globals.h"
#include "rendering/common/skyocclusion.h"
#include "utilities/utilities.h"
#include "scene/scene.h"
#include "model/AnimModel.h"
#include "model/Model3d.h"
#include "vehicle/DynObj.h"
#include "vehicle/Train.h"
#include "simulation/simulation.h"
#include "rendering/geometrybank.h"
namespace
{
// a light ends where its contribution falls under this. it is above the limit of the culling of the clusters, as there are
// many more of these lights than headlights, and each of them lights only its surroundings
float const LIGHT_THRESHOLD{0.01f};
// no light of a model reaches farther than this, metres
float const LIGHT_RANGE_MAX{60.f};
// the self-illumination threshold of the lamps of scenery models (Light_On, ls_Dark) and full darkness: between them
// the lights of models and compartments fade in, as they would be lost in the daylight anyway
float const LIGHT_DUSK_LUMINANCE{0.325f};
float const LIGHT_DAY_LUMINANCE{1.0f};
// lights of the occupied cab, at most
std::size_t const CAB_LIGHTS_MAX{16};
// the cone of the light of a glowing point of a street lamp (gfx_lights_stars), shining downwards: the half angles where it ends
// and where it is at its full brightness, degrees, and the radius of the sphere it shines from, metres
float const LAMP_POINT_OUTER_ANGLE{80.f};
float const LAMP_POINT_INNER_ANGLE{55.f};
float const LAMP_POINT_RADIUS{0.2f};
// a light point whose axis is at most this far from straight down (the cosine of the angle) is a lamp lighting the ground under it;
// one shining more sideways is a signal or a headlight, left as its model has it
float const LAMP_DOWN_COS{0.7f};
glm::vec3 to_linear(glm::vec3 const &Color)
{
return glm::pow(glm::max(Color, glm::vec3{0.f}), glm::vec3{2.2f});
}
float max_component(glm::vec3 const &Color)
{
return std::max(Color.r, std::max(Color.g, Color.b));
}
// distance at which a light of the colour falls under the threshold with the square of the distance
float light_range(glm::vec3 const &Color)
{
return std::min(std::sqrt(max_component(Color) / LIGHT_THRESHOLD), LIGHT_RANGE_MAX);
}
// how far from the camera the lights are gathered from: gfx_lights_range, or gfx_lights_lamps_range when it's farther, which
// only the lamps of the scenery go as far as (gather_vehicle()). none with gfx_lights_range 0
float gather_range()
{
return (Global.gfx_lights_range > 0.f ? std::max(Global.gfx_lights_range, Global.gfx_lights_lamps_range) : 0.f);
}
// whether Name is one of the names separated with | in List
bool is_listed(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 (List.substr(start, end - start) == Name)
{
return true;
}
start = end + 1;
}
return false;
}
// a smt_Stars submodel whose glowing points are the lamp of a street light (gfx_lights_stars)
bool is_lamp_points(TSubModel const &Submodel)
{
return (Submodel.eType == TP_STARS) && (false == Global.gfx_lights_stars.empty()) && is_listed(ToLower(Submodel.pName), Global.gfx_lights_stars);
}
// the axis of the cone of a light point, in the world
glm::vec3 light_axis(glm::mat4 const &Transform, glm::dmat4 const &Placement)
{
auto const axis{glm::vec3{glm::dmat3{Placement} * glm::dvec3{-glm::vec3{Transform[2]}}}};
return (glm::length2(axis) > 0.f ? glm::normalize(axis) : glm::vec3{0.f, -1.f, 0.f});
}
// whether a light with the axis shines downwards, the way a lamp lights the ground under it
bool shines_down(glm::vec3 const &Axis)
{
return (Axis.y <= -LAMP_DOWN_COS);
}
// the cosines of the outer and inner half angles of the cone of a light, the outer one widened to gfx_lights_freespot_mincone when
// Widen. the inner one is above the outer one, as some models have them the wrong way round
glm::vec2 light_cone(float const Cosouter, float const Cosinner, bool const Widen)
{
auto cosouter{std::clamp(Cosouter, -1.f, 0.999f)};
auto cosinner{std::clamp(std::max(Cosinner, cosouter + 0.05f), cosouter + 0.001f, 1.f)};
if (Widen && (Global.gfx_lights_freespot_mincone > 0.f))
{
if (auto const minouter{std::cos(glm::radians(Global.gfx_lights_freespot_mincone))}; minouter < cosouter)
{
cosouter = minouter;
cosinner = std::min(cosinner, std::cos(glm::radians(Global.gfx_lights_freespot_mincone * 0.6f)));
}
}
return {cosouter, cosinner};
}
// model space transform of the parent of the submodel, from the static transforms of the submodels above it; false if the
// submodel is not in the tree
bool find_parent_transform(TSubModel const *Submodel, TSubModel const *Target, glm::mat4 const &Parent, glm::mat4 &Result)
{
for (auto const *submodel{Submodel}; submodel != nullptr; submodel = submodel->Next)
{
if (submodel == Target)
{
Result = Parent;
return true;
}
auto transform{Parent};
if ((submodel->iFlags & 0xC000) && (submodel->fMatrix != nullptr))
{
transform *= glm::make_mat4(submodel->fMatrix->readArray());
}
if (find_parent_transform(submodel->Child, Target, transform, Result))
{
return true;
}
}
return false;
}
// bounds of the geometry of the submodel, of its children and, with Siblings, of the submodels after it, in the space of Transform
void extend_bounds(TSubModel const *Submodel, glm::mat4 const &Transform, gfx::geometrybank_manager const &Geometry, bool const Siblings, glm::vec3 &Min, glm::vec3 &Max,
bool &Lightpoints)
{
for (auto const *submodel{Submodel}; submodel != nullptr; submodel = (Siblings ? submodel->Next : nullptr))
{
auto transform{Transform};
if ((submodel->iFlags & 0xC000) && (submodel->fMatrix != nullptr))
{
transform *= glm::make_mat4(submodel->fMatrix->readArray());
}
if (submodel->eType == TP_FREESPOTLIGHT)
{
Lightpoints = true;
}
else if ((submodel->eType < TP_ROTATOR) && (submodel->m_geometry.handle != null_handle))
{
for (auto const &vertex : Geometry.vertices(submodel->m_geometry.handle))
{
auto const point{glm::vec3{transform * glm::vec4{vertex.position, 1.f}}};
Min = glm::min(Min, point);
Max = glm::max(Max, point);
}
}
extend_bounds(submodel->Child, transform, Geometry, true, Min, Max, Lightpoints);
}
}
} // namespace
void gfx::local_lights::gather(glm::dvec3 const &Camera, scene::basic_region &Region, gfx::geometrybank_manager const &Geometry, unsigned int const Framestamp)
{
auto const start{std::chrono::steady_clock::now()};
m_lights.clear();
m_cablights.clear();
m_cablampon = false;
m_scenerycount = m_vehiclecount = m_compartmentcount = 0;
m_walkgeometry = &Geometry;
// the editor adds, moves and removes instances in the cells. it can also do it in the frame it is turned off in
auto const rebuild{EditorModeFlag || m_editorseen};
m_editorseen = EditorModeFlag;
if (Global.gfx_lights_clustered)
{
if (Global.gfx_lights_cab)
{
gather_cab_lights(Geometry);
}
// lamps are lost in the daylight; this also spares the work of gathering them in the middle of the day
auto const darkness{1.f - glm::smoothstep(LIGHT_DUSK_LUMINANCE, LIGHT_DAY_LUMINANCE, static_cast<float>(Global.fLuminance))};
auto const range{gather_range()};
if ((darkness > 0.f) && (range > 0.f) && Global.gfx_lights_scenery)
{
auto const freespotbrightness{Global.gfx_lights_freespot_intensity * darkness};
// sections of the region within the range, the same way the render picks them
auto const camerax{static_cast<int>(std::floor(Camera.x / scene::EU07_SECTIONSIZE + scene::EU07_REGIONSIDESECTIONCOUNT / 2))};
auto const cameraz{static_cast<int>(std::floor(Camera.z / scene::EU07_SECTIONSIZE + scene::EU07_REGIONSIDESECTIONCOUNT / 2))};
auto const reach{static_cast<int>(std::ceil(range / scene::EU07_SECTIONSIZE))};
for (int row = std::max(0, cameraz - reach); row <= std::min(scene::EU07_REGIONSIDESECTIONCOUNT - 1, cameraz + reach); ++row)
{
for (int column = std::max(0, camerax - reach); column <= std::min(scene::EU07_REGIONSIDESECTIONCOUNT - 1, camerax + reach); ++column)
{
auto *section{Region.m_sections[row * scene::EU07_REGIONSIDESECTIONCOUNT + column]};
if (section == nullptr)
{
continue;
}
for (auto &cell : section->m_cells)
{
if ((false == cell.m_active) || (glm::length(cell.m_area.center - Camera) > range + cell.m_area.radius))
{
continue;
}
for (auto *instance : cell_instances(cell, rebuild).instances)
{
gather_instance(instance, Camera, freespotbrightness, Framestamp);
}
}
}
}
}
if ((darkness > 0.f) && (range > 0.f) && Global.gfx_lights_vehicles)
{
auto const freespotbrightness{Global.gfx_lights_freespot_intensity * darkness};
auto const compartmentbrightness{Global.gfx_lights_compartment_intensity * darkness};
for (auto *vehicle : simulation::Vehicles.sequence())
{
if (glm::length(vehicle->GetPosition() - Camera) > range + vehicle->radius())
{
continue;
}
gather_vehicle(vehicle, Camera, Geometry, freespotbrightness, compartmentbrightness);
}
}
// the most important lights first: when the light buffer or the list of a cluster fills up, the others are left out
std::sort(std::begin(m_lights), std::end(m_lights), [&Camera](light const &Left, light const &Right) {
return glm::length2(Left.position - Camera) / std::max(max_component(Left.color), 1e-6f) < glm::length2(Right.position - Camera) / std::max(max_component(Right.color), 1e-6f);
});
}
auto const elapsed{std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count()};
m_gathertime = (m_gathertime == 0.0 ? elapsed : m_gathertime * 0.95 + elapsed * 0.05);
}
void gfx::local_lights::reset()
{
m_lights.clear();
m_cablights.clear();
m_cablampon = false;
m_modellights.clear();
m_cells.clear();
m_sections.clear();
m_models.clear();
m_scenerycount = m_vehiclecount = m_compartmentcount = m_placed = m_dropped = 0;
}
void gfx::local_lights::gather_instance(TAnimModel *Instance, glm::dvec3 const &Camera, float const Brightness, unsigned int const Framestamp)
{
if ((false == Instance->m_visible) || (Instance->pModel == nullptr))
{
return;
}
auto const offset{Instance->location() - Camera};
if (glm::length(offset) > gather_range() + Instance->radius())
{
return;
}
// the same distance the render picks the lods and the range of the instance by
auto const distancesquared{glm::length2(offset / static_cast<double>(Global.ZoomFactor)) / Global.fDistanceFactor};
if ((distancesquared < Instance->m_rangesquaredmin) || (distancesquared >= Instance->m_rangesquaredmax))
{
return;
}
Instance->RaAnimate(Framestamp);
Instance->RaPrepare();
TSubModel::fSquareDist = static_cast<float>(distancesquared);
auto const count{m_lights.size()};
auto const placement{glm::translate(glm::dmat4{1.0}, Instance->location()) * glm::dmat4{Instance->rotation_scale()}};
m_walkowner = Instance;
walk(Instance->pModel->Root, glm::mat4{1.f}, placement, Brightness);
m_walkowner = nullptr;
m_scenerycount += static_cast<std::uint32_t>(m_lights.size() - count);
}
void gfx::local_lights::gather_vehicle(TDynamicObject *Vehicle, glm::dvec3 const &Camera, gfx::geometrybank_manager const &Geometry, float const Freespotbrightness,
float const Compartmentbrightness)
{
// the vehicles light within gfx_lights_range, only the lamps of the scenery may be gathered from farther
if (glm::length(Vehicle->GetPosition() - Camera) > Global.gfx_lights_range + Vehicle->radius())
{
return;
}
if ((false == Global.render_cab) && (Global.pCamera.m_owner == Vehicle))
{
// the render leaves the vehicle out as well
return;
}
// light points: the models with any are gone through after the setup the render makes before it draws the vehicle
std::array<TModel3d *, 2> models{Vehicle->mdModel, Vehicle->mdLowPolyInt};
auto const haslightpoints = [this](TModel3d *Model) { return (Model != nullptr) && has_light_points(Model); };
if (std::any_of(std::begin(models), std::end(models), haslightpoints) || std::any_of(std::begin(Vehicle->mdAttachments), std::end(Vehicle->mdAttachments), haslightpoints))
{
TSubModel::iInstance = reinterpret_cast<std::uintptr_t>(Vehicle);
TSubModel::iVariantSeed = Vehicle->variant_seed();
auto const squaredistance{glm::length2(glm::vec3{Vehicle->vPosition - Camera} / Global.ZoomFactor)};
Vehicle->ABuLittleUpdate(squaredistance);
auto const placement{glm::translate(glm::dmat4{1.0}, Vehicle->vPosition) * Vehicle->mMatrix};
auto const count{m_lights.size()};
auto const walkmodel = [&](TModel3d *Model) {
if (haslightpoints(Model))
{
TSubModel::fSquareDist = squaredistance;
walk(Model->Root, glm::mat4{1.f}, placement, Freespotbrightness);
}
};
walkmodel(Vehicle->mdModel);
for (auto *attachment : Vehicle->mdAttachments)
{
walkmodel(attachment);
}
walkmodel(Vehicle->mdLowPolyInt);
m_vehiclecount += static_cast<std::uint32_t>(m_lights.size() - count);
if (Vehicle->btnOn)
{
Vehicle->TurnOff(); // the state of the shared model goes back to the default, as after the render
}
}
// lit compartments, the way TDynamicObject::Update() works out their self-illumination: cab sections come first and are lit at
// the level of their lamp, the others at the level of the compartment lights
if ((Vehicle->mdLowPolyInt != nullptr) && (Compartmentbrightness > 0.f))
{
auto const owncab{m_cablampon && (simulation::Train != nullptr) && (simulation::Train->Dynamic() == Vehicle)};
auto cabsection{true};
for (auto const &section : Vehicle->Sections)
{
auto const &name{section.compartment->pName};
cabsection &= (name.size() >= 4) && name.starts_with("cab");
auto const level{section.light_level * (cabsection ? 1.f : Vehicle->MoverParameters->CompartmentLights.intensity)};
if ((level <= 0.f) || (Global.fLuminance > section.compartment->fLight) || (section.compartment->iVisible == 0))
{
continue;
}
if (cabsection && owncab)
{
// the lamp of the occupied cab is a light of its own
continue;
}
auto const &data{this->section(Vehicle->mdLowPolyInt, section.compartment, Geometry)};
if (data.has_light_points || (data.extent == glm::vec3{0.f}))
{
continue;
}
light compartmentlight;
compartmentlight.position = Vehicle->GetWorldPosition(glm::dvec3{data.center});
compartmentlight.color = to_linear(Vehicle->InteriorLight) * (level * Compartmentbrightness);
// the light goes out of the windows a little; there are no shadows to keep it in, so it doesn't reach far
compartmentlight.range = std::clamp(glm::length(data.extent) * 1.5f, 2.f, std::min(light_range(compartmentlight.color), 15.f));
m_lights.emplace_back(compartmentlight);
++m_compartmentcount;
}
}
}
void gfx::local_lights::gather_cab_lights(gfx::geometrybank_manager const &Geometry)
{
// the cab is drawn, Render_cab() conditions
if (FreeFlyModeFlag || (false == Global.render_cab) || (simulation::Train == nullptr))
{
return;
}
auto const *train{simulation::Train};
auto const *vehicle{train->Dynamic()};
if ((vehicle == nullptr) || (false == vehicle->bDisplayCab) || (vehicle->mdKabina == nullptr) || (vehicle->mdKabina == vehicle->mdModel))
{
return;
}
auto const &bounds{model_bounds(vehicle->mdKabina, Geometry)};
if (bounds.extent == glm::vec3{0.f})
{
return;
}
// as bright as the ambient light the lamp used to add to the cab: lost in the daylight
auto const luminance{Global.fLuminance * gfx::vehicle_light_level(vehicle)};
auto const daylight{std::clamp(1.25f - static_cast<float>(luminance), 0.f, 1.f)};
auto const lightpoints{has_light_points(vehicle->mdKabina)};
if (lightpoints && (daylight > 0.f))
{
// the light points of the cab model, in its space, the way Render_cab() sets it up. they are switched by the visibility of
// the submodels they're in (the lamp of the cab under i-cablight:, the lights of the desk under i-dashboardlight:, ...)
TSubModel::iInstance = reinterpret_cast<std::uintptr_t>(vehicle);
TSubModel::iVariantSeed = vehicle->variant_seed();
TSubModel::fSquareDist = 0.f;
auto const count{m_lights.size()};
m_walkcab = true;
walk(vehicle->mdKabina->Root, glm::mat4{1.f}, glm::dmat4{1.0}, Global.gfx_lights_freespot_intensity * daylight);
m_walkcab = false;
// within the cab: without shadows (gfx.lights.shadows) the light goes through its walls
auto const reach{std::max(2.f * glm::length(bounds.extent), 2.5f)};
auto const rotation{glm::dmat3{vehicle->mMatrix}};
for (auto idx{count}; idx < m_lights.size(); ++idx)
{
cab_light cablight;
cablight.source = m_lights[idx];
cablight.local = glm::vec3{m_lights[idx].position};
cablight.local_direction = m_lights[idx].direction;
cablight.source.position = vehicle->GetWorldPosition(m_lights[idx].position);
auto const direction{glm::vec3{rotation * glm::dvec3{m_lights[idx].direction}}};
cablight.source.direction = (glm::length2(direction) > 0.f ? glm::normalize(direction) : glm::vec3{0.f, -1.f, 0.f});
cablight.source.range = std::min(cablight.source.range, reach);
m_cablights.emplace_back(cablight);
}
m_lights.resize(count);
}
// the lamp of a cab model without light points of its own: under the ceiling, in the middle of the cab, at the level of its
// switch (off, dimmed, with or without the 110 V)
auto const cablevel{std::max(vehicle->InteriorLightLevel, 0.f) * daylight};
if ((false == lightpoints) && (cablevel > 0.f))
{
auto const lamp{glm::vec3{bounds.center.x, std::max(bounds.center.y, bounds.center.y + bounds.extent.y - 0.25f), bounds.center.z}};
cab_light cablight;
cablight.local = lamp;
cablight.source.position = vehicle->GetWorldPosition(glm::dvec3{lamp});
cablight.source.color = to_linear(vehicle->InteriorLight) * (cablevel * Global.gfx_lights_cab_intensity);
// within the cab: without shadows (gfx.lights.shadows) the lamp would light the track below and the body of the vehicle around it
cablight.source.range = std::clamp(glm::length(bounds.extent) * 1.25f, 2.5f, 8.f);
cablight.source.part = vehicle;
if (max_component(cablight.source.color) > 0.f)
{
m_cablights.emplace_back(cablight);
}
}
// the brightest first: the first ones get the shadow maps, the brightest lights the probe of the cab
std::stable_sort(std::begin(m_cablights), std::end(m_cablights), [](cab_light const &Left, cab_light const &Right) { return max_component(Left.source.color) > max_component(Right.source.color); });
if (m_cablights.size() > CAB_LIGHTS_MAX)
{
m_cablights.resize(CAB_LIGHTS_MAX);
}
m_cablampvehicle = vehicle;
m_cablampon = (false == m_cablights.empty());
}
float gfx::local_lights::walk_min_distance(TSubModel const &Submodel) const
{
// a lamp of the scenery lights also closer than its glare is seen from (gfx_lights_points_near)
auto const lampnear{(m_walkowner != nullptr) && Global.gfx_lights_points_near && ((Submodel.eType == TP_FREESPOTLIGHT) || is_lamp_points(Submodel))};
return (lampnear ? 0.f : Submodel.fSquareMinDist);
}
void gfx::local_lights::walk(TSubModel *Submodel, glm::mat4 const &Transform, glm::dmat4 const &Placement, float const Brightness)
{
// visibility, lod ranges, transforms and animations as in opengl46_renderer::Render_Alpha(TSubModel *)
for (auto *submodel{Submodel}; submodel != nullptr; submodel = submodel->Next)
{
if (auto const mindistance{walk_min_distance(*submodel)}; (submodel->iVisible == 0) || (TSubModel::fSquareDist < mindistance) || (TSubModel::fSquareDist >= submodel->fSquareMaxDist))
{
continue;
}
auto transform{Transform};
if (submodel->iFlags & 0xC000)
{
if (submodel->fMatrix != nullptr)
{
transform *= glm::make_mat4(submodel->fMatrix->readArray());
}
if (submodel->b_aAnim != TAnimType::at_None)
{
submodel->RaAnimation(transform, submodel->b_aAnim);
}
}
// closer than its glare is seen from only a lamp shining downwards lights, not a signal
if ((TSubModel::fSquareDist < submodel->fSquareMinDist) && (submodel->eType == TP_FREESPOTLIGHT) && (false == shines_down(light_axis(transform, Placement))))
{
continue;
}
if (submodel->eType == TP_FREESPOTLIGHT)
{
add_light_point(*submodel, transform, Placement, Brightness);
}
else if ((m_walkowner != nullptr) && is_lamp_points(*submodel))
{
add_lamp_points(*submodel, transform, Placement, Brightness);
}
if (submodel->Child != nullptr)
{
walk(submodel->Child, transform, Placement, Brightness);
}
}
}
void gfx::local_lights::add_light_point(TSubModel const &Submodel, glm::mat4 const &Transform, glm::dmat4 const &Placement, float Brightness)
{
if (m_walkcab)
{
// the lights of the cab: switched with the submodels they're in, whatever the self-illumination threshold
if ((Submodel.f4Emision.a <= 0.f) || (Submodel.fVisible <= 0.f))
{
return;
}
}
// lit points: with self-illumination, past its threshold. the compartments of vehicles set it with their lights
else if ((Submodel.f4Emision.a <= 0.f) || (Global.fLuminance >= Submodel.fLight) || (Submodel.fVisible <= 0.f))
{
return;
}
auto const diffuse{Submodel.DiffuseOverride.r < 0.f ? // -1 indicates no override
glm::vec3{Submodel.f4Diffuse} :
Submodel.DiffuseOverride};
auto const direction{light_axis(Transform, Placement)};
// a lamp of the scenery shining downwards: brighter by gfx_lights_lamps_gain, its cone widened to gfx_lights_freespot_mincone
auto const lamp{(m_walkowner != nullptr) && shines_down(direction)};
auto const gain{lamp ? Global.gfx_lights_lamps_gain : 1.f};
auto const lightcolor{to_linear(diffuse) * (Brightness * gain * Submodel.fHotspotPower * Submodel.fVisible * std::min(Submodel.f4Emision.a, 1.f))};
if (max_component(lightcolor) <= LIGHT_THRESHOLD)
{
return;
}
light lightpoint;
lightpoint.position = glm::dvec3{Placement * glm::dvec4{glm::dvec3{Transform[3]}, 1.0}};
lightpoint.direction = direction;
lightpoint.color = lightcolor;
// the cone of the glare: where the point is seen from is where it shines. the glare goes from no brightness at the falloff
// angle to full at the hotspot angle, which some models have the wrong way round
auto const cone{light_cone(Submodel.fCosFalloffAngle, Submodel.fCosHotspotAngle, lamp)};
lightpoint.cos_outer = cone.x;
lightpoint.cos_inner = cone.y;
lightpoint.range = light_range(lightcolor);
lightpoint.radius = Submodel.fLightRadius;
lightpoint.soft_falloff = Submodel.bSoftFalloff;
lightpoint.cast_shadows = Submodel.bCastShadows;
lightpoint.shade_self = Submodel.bShadeSelf;
if (m_walkowner != nullptr)
{
lightpoint.owner = m_walkowner;
lightpoint.part = &Submodel;
}
else if (m_walkcab)
{
// the light of the cab, its shadow map kept by it
lightpoint.part = &Submodel;
}
m_lights.emplace_back(lightpoint);
}
void gfx::local_lights::add_lamp_points(TSubModel const &Submodel, glm::mat4 const &Transform, glm::dmat4 const &Placement, float const Brightness)
{
// lit as the render draws them: past the self-illumination threshold
if ((m_walkgeometry == nullptr) || (Submodel.m_geometry.handle == null_handle) || (Global.fLuminance >= Submodel.fLight))
{
return;
}
auto const cone{light_cone(std::cos(glm::radians(LAMP_POINT_OUTER_ANGLE)), std::cos(glm::radians(LAMP_POINT_INNER_ANGLE)), true)};
for (auto const &vertex : m_walkgeometry->vertices(Submodel.m_geometry.handle))
{
// a glowing point keeps its colour in its normal; one without any takes the colour of the submodel
auto const pointcolor{max_component(vertex.normal) > 0.f ? vertex.normal : glm::vec3{Submodel.f4Diffuse}};
auto const lightcolor{to_linear(pointcolor) * (Brightness * Global.gfx_lights_lamps_gain)};
if (max_component(lightcolor) <= LIGHT_THRESHOLD)
{
continue;
}
light lightpoint;
lightpoint.position = glm::dvec3{Placement * glm::dvec4{glm::dvec3{Transform * glm::vec4{vertex.position, 1.f}}, 1.0}};
lightpoint.direction = glm::vec3{0.f, -1.f, 0.f};
lightpoint.color = lightcolor;
lightpoint.cos_outer = cone.x;
lightpoint.cos_inner = cone.y;
lightpoint.range = light_range(lightcolor);
lightpoint.radius = LAMP_POINT_RADIUS;
lightpoint.soft_falloff = true;
// the point names the lamp from frame to frame (the shadow maps of the lamps)
lightpoint.owner = m_walkowner;
lightpoint.part = &vertex;
m_lights.emplace_back(lightpoint);
}
}
bool gfx::local_lights::has_light_points(TModel3d *Model)
{
auto lookup{m_modellights.find(Model)};
if (lookup != m_modellights.end())
{
return lookup->second;
}
auto found{false};
std::vector<TSubModel const *> pending{Model->Root};
while ((false == found) && (false == pending.empty()))
{
auto const *submodel{pending.back()};
pending.pop_back();
for (; submodel != nullptr; submodel = submodel->Next)
{
if ((submodel->eType == TP_FREESPOTLIGHT) || is_lamp_points(*submodel))
{
found = true;
break;
}
if (submodel->Child != nullptr)
{
pending.emplace_back(submodel->Child);
}
}
}
m_modellights.emplace(Model, found);
return found;
}
void gfx::local_lights::add_lit_instances(std::vector<TAnimModel *> const &Instances, std::unordered_set<TAnimModel const *> &Added, std::vector<TAnimModel *> &Lit)
{
for (auto *instance : Instances)
{
if ((instance->pModel != nullptr) && has_light_points(instance->pModel) && Added.insert(instance).second)
{
Lit.emplace_back(instance);
}
}
}
gfx::local_lights::cell_data const &gfx::local_lights::cell_instances(scene::basic_cell &Cell, bool const Rebuild)
{
// light points are drawn in the translucent phase, so the instances which have them are on the translucent list of the cell.
// the glowing points of the lamps (smt_Stars) are drawn with the opaque ones, so a lamp made of them can be on the opaque list only
auto &instances{Cell.m_instancetranslucent};
auto &opaque{Cell.m_instancesopaque};
auto &data{m_cells[&Cell]};
if (Rebuild || (data.source_size != instances.size()) || (data.source_data != static_cast<void const *>(instances.data())) || (data.opaque_size != opaque.size()) ||
(data.opaque_data != static_cast<void const *>(opaque.data())))
{
data.instances.clear();
std::unordered_set<TAnimModel const *> added;
add_lit_instances(instances, added, data.instances);
add_lit_instances(opaque, added, data.instances);
data.source_size = instances.size();
data.source_data = instances.data();
data.opaque_size = opaque.size();
data.opaque_data = opaque.data();
}
return data;
}
gfx::local_lights::section_data const &gfx::local_lights::section(TModel3d *Model, TSubModel *Section, gfx::geometrybank_manager const &Geometry)
{
auto lookup{m_sections.find(Section)};
if (lookup != m_sections.end())
{
return lookup->second;
}
section_data data;
glm::mat4 transform{1.f};
if (find_parent_transform(Model->Root, Section, glm::mat4{1.f}, transform))
{
glm::vec3 min{std::numeric_limits<float>::max()};
glm::vec3 max{std::numeric_limits<float>::lowest()};
extend_bounds(Section, transform, Geometry, false, min, max, data.has_light_points);
if (min.x <= max.x)
{
data.center = 0.5f * (min + max);
data.extent = 0.5f * (max - min);
}
}
return m_sections.emplace(Section, data).first->second;
}
gfx::local_lights::section_data const &gfx::local_lights::model_bounds(TModel3d *Model, gfx::geometrybank_manager const &Geometry)
{
auto lookup{m_models.find(Model)};
if (lookup != m_models.end())
{
return lookup->second;
}
section_data data;
glm::vec3 min{std::numeric_limits<float>::max()};
glm::vec3 max{std::numeric_limits<float>::lowest()};
extend_bounds(Model->Root, glm::mat4{1.f}, Geometry, true, min, max, data.has_light_points);
if (min.x <= max.x)
{
data.center = 0.5f * (min + max);
data.extent = 0.5f * (max - min);
}
return m_models.emplace(Model, data).first->second;
}
bool gfx::local_lights::cab_bounds(TModel3d *Cab, gfx::geometrybank_manager const &Geometry, glm::vec3 &Center, glm::vec3 &Extent)
{
if (Cab == nullptr)
{
return false;
}
auto const &bounds{model_bounds(Cab, Geometry)};
Center = bounds.center;
Extent = bounds.extent;
return (bounds.extent != glm::vec3{0.f});
}
std::string gfx::local_lights::info() const
{
return "local lights: " + std::to_string(m_lights.size()) + " (scenery " + std::to_string(m_scenerycount) + ", vehicles " + std::to_string(m_vehiclecount) + ", compartments " +
std::to_string(m_compartmentcount) + ")" + (m_cablampon ? " + cab lights " + std::to_string(m_cablights.size()) : "") + ", placed " + std::to_string(m_placed) + ", over capacity " + std::to_string(m_dropped) +
", gather " + to_string(m_gathertime, 2) + " ms";
}
void gfx::local_lights::draw_debug_ui()
{
ImGui::TextUnformatted("local lights (need clustered lights)");
ImGui::Checkbox("light points of scenery models", &Global.gfx_lights_scenery);
ImGui::Checkbox("light points and compartments of vehicles", &Global.gfx_lights_vehicles);
ImGui::Checkbox("cab lamp as a light (or the light points of the cab model)", &Global.gfx_lights_cab);
ImGui::SliderFloat("light point brightness", &Global.gfx_lights_freespot_intensity, 0.f, 50.f);
ImGui::SliderFloat("compartment brightness", &Global.gfx_lights_compartment_intensity, 0.f, 10.f);
ImGui::SliderFloat("cab lamp brightness", &Global.gfx_lights_cab_intensity, 0.f, 10.f);
ImGui::SliderFloat("cab ambient kept", &Global.gfx_lights_cab_bounce, 0.f, 1.f);
ImGui::SliderFloat("range, m", &Global.gfx_lights_range, 0.f, 1000.f);
ImGui::Text("gathered %u: scenery %u, vehicles %u, compartments %u, cab %u", static_cast<unsigned>(m_lights.size()), m_scenerycount, m_vehiclecount, m_compartmentcount,
static_cast<unsigned>(m_cablights.size()));
ImGui::Text("in the light buffer %u, over capacity %u", m_placed, m_dropped);
ImGui::Text("gather %.2f ms (cpu)", m_gathertime);
}