18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-20 08:04:57 +01:00
Files
maszyna/world/SleeperModels.cpp

396 lines
16 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 "world/TrackSleepers.h"
#include "world/SleeperRules.h"
#include "world/Track.h"
#include "model/Model3d.h"
#include "model/MdlMngr.h"
#include "rendering/renderer.h"
#include "utilities/Globals.h"
#include "utilities/Logs.h"
#include "utilities/utilities.h"
#include <glm/gtc/type_ptr.hpp>
#include <filesystem>
#include <format>
#include <fstream>
#include <iterator>
#include <mutex>
#include <optional>
namespace track_sleepers {
namespace {
// the models of the beams found so far, by their names and skins and seats
std::map<std::string, beam_model, std::less<>> &known_models() {
static std::map<std::string, beam_model, std::less<>> models;
return models;
}
// the models found and loaded by more than one thread
std::mutex &models_mutex() {
static std::mutex mutex;
return mutex;
}
// whether this thread loads the models it doesn't find
bool &loads_models() {
thread_local bool loads { true };
return loads;
}
// the vertices of the submodel in the space of the model, through its own transform
template <typename Visit>
void vertices_of( TSubModel *Submodel, Visit Visitor ) {
glm::mat4 transform { 1.f };
if( ( Submodel->iFlags & 0xC000 ) && ( Submodel->GetMatrix() != nullptr ) ) {
transform = glm::make_mat4( Submodel->GetMatrix()->readArray() );
}
auto const &vertices { Submodel->m_geometry.handle != null_handle ? GfxRenderer->Vertices( Submodel->m_geometry.handle ) : Submodel->Vertices };
for( auto const &vertex : vertices ) {
Visitor( glm::vec3 { transform * glm::vec4 { vertex.position, 1.f } } );
}
}
// the highest the faces of the submodel reach over the point of the plan of the model, in the space of the model; none where
// no face lies over it
std::optional<float> surface_at( TSubModel *Submodel, float const X, float const Z ) {
glm::mat4 transform { 1.f };
if( ( Submodel->iFlags & 0xC000 ) && ( Submodel->GetMatrix() != nullptr ) ) {
transform = glm::make_mat4( Submodel->GetMatrix()->readArray() );
}
auto const indexed { Submodel->m_geometry.handle != null_handle };
auto const &vertices { indexed ? GfxRenderer->Vertices( Submodel->m_geometry.handle ) : Submodel->Vertices };
auto const &indices { indexed ? GfxRenderer->Indices( Submodel->m_geometry.handle ) : Submodel->Indices };
auto const count { indices.empty() ? vertices.size() : indices.size() };
auto const corner = [ &transform, &vertices, &indices ]( std::size_t const Index ) {
return glm::vec3 { transform * glm::vec4 { vertices[ indices.empty() ? Index : indices[ Index ] ].position, 1.f } }; };
std::optional<float> result;
for( std::size_t index = 0; index + 2 < count; index += 3 ) {
auto const a { corner( index ) };
auto const b { corner( index + 1 ) };
auto const c { corner( index + 2 ) };
auto const area { ( b.x - a.x ) * ( c.z - a.z ) - ( c.x - a.x ) * ( b.z - a.z ) };
if( std::abs( area ) < 1e-9f ) {
continue;
}
auto const u { ( ( X - a.x ) * ( c.z - a.z ) - ( c.x - a.x ) * ( Z - a.z ) ) / area };
auto const v { ( ( b.x - a.x ) * ( Z - a.z ) - ( X - a.x ) * ( b.z - a.z ) ) / area };
if( u < -1e-5f || v < -1e-5f || u + v > 1.f + 1e-5f ) {
continue;
}
auto const height { a.y + u * ( b.y - a.y ) + v * ( c.y - a.y ) };
result = ( result ? std::max( *result, height ) : height );
}
return result;
}
// whether the model is put together from the parts of a timber, all of them at its top level, with the submodels besides them;
// the fastenings of the rails among its parts where it has them
void find_parts( beam_model &Model ) {
// a timber put together from its parts, with a part between the ends stretched and repeated to the length
Model.stretchable = true;
for( int part = 0; part < part_count; ++part ) {
Model.parts[ part ] = Model.model->GetFromName( part_names[ part ] );
Model.stretchable = Model.stretchable && ( part >= timber_parts || Model.parts[ part ] != nullptr );
}
if( false == Model.stretchable ) {
return;
}
// a part is drawn with the other submodels of the top level hidden, so the parts of the timber are there too
auto toplevel { 0 };
for( auto *submodel { Model.model->Root }; submodel != nullptr; submodel = submodel->Next ) {
auto const found { std::ranges::find( Model.parts, submodel ) };
if( found == Model.parts.end() ) {
Model.others.push_back( submodel );
}
else if( found - Model.parts.begin() < timber_parts ) {
++toplevel;
}
}
if( toplevel < timber_parts ) {
ErrorLog( "Bad sleepers3d: model \"" + Model.name + "\" has its parts begin, main and end below its top level, it's drawn whole" );
Model.stretchable = false;
Model.others.clear();
}
}
// the span of the model along x, of its parts or of the whole of it, and how high it reaches; the fastenings measured apart, not
// counted in the span and the height of the timber
float measure( beam_model &Model ) {
auto top { std::numeric_limits<float>::lowest() };
Model.span = { std::numeric_limits<float>::max(), std::numeric_limits<float>::lowest() };
if( Model.stretchable ) {
for( int part = 0; part < part_count; ++part ) {
if( Model.parts[ part ] == nullptr ) {
continue;
}
glm::vec2 span { std::numeric_limits<float>::max(), std::numeric_limits<float>::lowest() };
glm::vec2 heights { std::numeric_limits<float>::max(), std::numeric_limits<float>::lowest() };
auto const timber { part < timber_parts };
vertices_of( Model.parts[ part ], [ &span, &heights, &top, timber ]( glm::vec3 const &Position ) {
span = { std::min( span.x, Position.x ), std::max( span.y, Position.x ) };
heights = { std::min( heights.x, Position.y ), std::max( heights.y, Position.y ) };
if( timber ) {
top = std::max( top, Position.y );
} } );
Model.spans[ part ] = span;
Model.heights[ part ] = heights;
if( timber ) {
Model.span = { std::min( Model.span.x, span.x ), std::max( Model.span.y, span.y ) };
}
}
Model.stretchable = Model.spans[ part_main ].y > Model.spans[ part_main ].x;
}
else {
// a whole model, measured on its most detailed submodels, the others being the same beam seen from further
Model.parts = {};
for( auto *submodel { Model.model->Root }; submodel != nullptr; submodel = submodel->Next ) {
if( submodel->fSquareMinDist > 0.f ) {
continue;
}
vertices_of( submodel, [ &Model, &top ]( glm::vec3 const &Position ) {
Model.span = { std::min( Model.span.x, Position.x ), std::max( Model.span.y, Position.x ) };
top = std::max( top, Position.y ); } );
}
}
return top;
}
// the distances the levels of detail of the model are seen from, each once, the nearest first
void find_bands( beam_model &Model ) {
// the levels of detail, by the distances they're seen from
for( auto *submodel { Model.model->Root }; submodel != nullptr; submodel = submodel->Next ) {
if( std::ranges::find( Model.bands, submodel->fSquareMinDist ) == Model.bands.end() ) {
Model.bands.push_back( submodel->fSquareMinDist );
}
}
std::ranges::sort( Model.bands );
}
// where the rails sit in the model: on the seat of the sleeper, below the fastenings sticking up over it, or on the plate of the
// fastening; and how far over it the blades slide on the slide plates of the chairs
void find_seat( beam_model &Model, float const Seat, float const Top ) {
Model.bed = Top;
Model.seat = ( Seat >= 0.f ? Seat : Top );
if( false == Model.fastened() ) {
return;
}
if( Seat < 0.f ) {
Model.seat = std::max( Top, surface_at( Model.parts[ part_plate ], 0.f, 0.f ).value_or( Top ) );
}
for( auto const part : { part_chair, part_slide } ) {
if( Model.parts[ part ] != nullptr ) {
Model.slide = std::max( Model.slide, surface_at( Model.parts[ part ], static_cast<float>( -slide_probe ), 0.f ).value_or( Model.seat ) - Model.seat );
}
}
}
// the model of the name and skin loaded into its entry, measured and logged; null when it can't be loaded or has no beam along x
beam_model const *load_model( beam_model &Model, std::string const &Name, std::string const &Skin, float const Seat ) {
Model.name = Name;
Model.skinname = Skin;
Model.model = TModelsManager::GetModel( Name, false );
if( Model.model == nullptr ) {
ErrorLog( "Bad sleepers3d: model \"" + Name + "\" failed to load" );
return nullptr;
}
if( false == Skin.empty() ) {
Model.skin = GfxRenderer->Fetch_Material( Skin );
}
find_parts( Model );
auto const top { measure( Model ) };
find_bands( Model );
find_seat( Model, Seat, top );
if( Model.length() < 0.5f ) {
ErrorLog( "Bad sleepers3d: model \"" + Name + "\" has no beam along x" );
Model.model = nullptr;
return nullptr;
}
WriteLog(
"sleepers3d: model \"" + Name + "\"" + ( Model.stretchable ? std::string { " of parts" } : std::string { " whole" } )
+ ", " + to_string( Model.span.x, 3 ) + ".." + to_string( Model.span.y, 3 )
+ ( Model.stretchable ?
", main " + to_string( Model.spans[ part_main ].x, 3 ) + ".." + to_string( Model.spans[ part_main ].y, 3 ) :
std::string {} )
+ ( Model.fastened() ?
std::string { ", fastenings plate" } + ( Model.parts[ part_chair ] != nullptr ? " chair" : "" ) + ( Model.parts[ part_check ] != nullptr ? " check" : "" ) + ( Model.parts[ part_slide ] != nullptr ? " slide" : "" ) :
std::string {} )
+ ", seat " + to_string( Model.seat, 3 )
+ ( Model.slide > 0.f ? ", slide " + to_string( Model.slide, 3 ) : std::string {} ) );
return &Model;
}
// the model of the beams of the name and skin, loaded and measured on the first use; null when it can't be loaded. the feet of
// the rails go to the given seat in it, or to its top where the seat is below zero
beam_model const *find_model( std::string const &Name, std::string const &Skinname, float const Seat ) {
if( Name.empty() ) {
return nullptr;
}
auto const Skin { Skinname == "none" ? std::string {} : Skinname };
auto const key { std::format( "{}|{}|{}", Name, Skin, std::to_string( Seat ) ) };
std::scoped_lock const lock { models_mutex() };
auto &models { known_models() };
auto found { models.find( key ) };
if( found == models.end() && false == loads_models() ) {
// loaded for it before a layout is asked for of the thread, for all the tracks, so it's none it could load
return nullptr;
}
if( found == models.end() ) {
return load_model( models[ key ], Name, Skin, Seat );
}
return ( found->second.model != nullptr ? &found->second : nullptr );
}
} // namespace
void models_loaded( bool const Loaded ) {
loads_models() = Loaded;
}
beam_model const *timber_model() {
return find_model( Global.Sleepers3D, std::string {}, -1.f );
}
beam_model const *plain_model() {
return find_model( Global.Sleepers3DPlain, Global.Sleepers3DPlainSkin, Global.Sleepers3DPlainSeat );
}
beam_model const *timber_model( TTrack const &Track ) {
if( false == Track.m_timber_model_name.empty() ) {
if( auto const *model { find_model( Track.m_timber_model_name, Track.m_timber_skin_name, -1.f ) }; model != nullptr ) {
return model;
}
}
return timber_model();
}
beam_model const *timber_model( TTrack const &Track, std::vector<beam> const &Beams ) {
if( false == Track.m_timber_model_name.empty() ) {
return timber_model( Track );
}
std::vector<std::pair<TTrack const *, std::size_t>> panels;
for( auto const &beam : Beams ) {
if( beam.plain || beam.panel == nullptr ) {
continue;
}
auto found { std::find_if( panels.begin(), panels.end(), [&]( auto const &Panel ) { return Panel.first == beam.panel; } ) };
if( found == panels.end() ) {
panels.emplace_back( beam.panel, 0 );
found = std::prev( panels.end() );
}
++found->second;
}
auto const most { std::max_element( panels.begin(), panels.end(), []( auto const &Left, auto const &Right ) { return Left.second < Right.second; } ) };
return ( most != panels.end() ? timber_model( *most->first ) : timber_model( Track ) );
}
beam_model const *plain_model( TTrack const &Track ) {
if( Track.m_sleeper_enabled && false == Track.m_sleeper_model_name.empty() ) {
// the sleepers of the track drawn as they are in the model, their tops at the feet of the rails
if( auto const *model { find_model( Track.m_sleeper_model_name, Track.m_sleeper_skin_name, -1.f ) }; model != nullptr ) {
return model;
}
}
return plain_model();
}
double plain_length( TTrack const &Track ) {
if( auto const *model { plain_model( Track ) }; model != nullptr ) {
return model->length();
}
return 2.0 * ( 0.5 * std::abs( Track.fTrackWidth ) + rail_reach + beam_overhang );
}
namespace {
// the model of sleepers or timbers of the file added to those found, once by its name, what goes wrong left in the error
void add_pack_model( std::filesystem::directory_entry const &Entry, std::filesystem::path const &Root, std::error_code &Error, std::vector<pack_model> &Models ) {
namespace fs = std::filesystem;
if( false == Entry.is_regular_file( Error ) ) {
return;
}
auto const extension { ToLower( Entry.path().extension().string() ) };
if( extension != ".t3d" && extension != ".e3d" ) {
return;
}
auto name { ToLower( fs::relative( Entry.path(), Root, Error ).replace_extension().generic_string() ) };
if( Error || name.empty() ) {
return;
}
if( name.find( "podklad" ) == std::string::npos && name.find( "podrozjazd" ) == std::string::npos
&& name.find( "sleeper" ) == std::string::npos && name.find( "timber" ) == std::string::npos ) {
return;
}
// a timber model has the parts it's put together from, told by their names in the file
std::ifstream file { Entry.path(), std::ios::binary };
std::string const content { std::istreambuf_iterator<char>( file ), std::istreambuf_iterator<char>() };
auto const has = [ &extension, &content ]( std::string const &Part ) {
return (
extension == ".t3d" ?
content.find( "Name: " + Part + "\n" ) != std::string::npos || content.find( "Name: " + Part + " " ) != std::string::npos
|| content.find( "Name: " + Part + "\r" ) != std::string::npos :
content.find( std::string { '\0' } + Part + '\0' ) != std::string::npos ); };
auto const timber { has( "begin" ) && has( "main" ) && has( "end" ) };
if( std::ranges::none_of( Models, [ &name ]( pack_model const &Model ) { return Model.name == name; } ) ) {
Models.emplace_back( std::move( name ), timber );
}
}
} // namespace
std::vector<pack_model> const &pack_models() {
static std::vector<pack_model> models;
static auto scanned { false };
if( scanned ) {
return models;
}
scanned = true;
namespace fs = std::filesystem;
std::error_code error;
auto const root { fs::path { paths::models } };
fs::recursive_directory_iterator entry { root, fs::directory_options::follow_directory_symlink | fs::directory_options::skip_permission_denied, error };
fs::recursive_directory_iterator const end;
while( entry != end ) {
if( error ) {
break;
}
add_pack_model( *entry, root, error, models );
entry.increment( error );
}
std::ranges::sort( models, []( pack_model const &Left, pack_model const &Right ) {
return ( Left.timber != Right.timber ? Left.timber : Left.name < Right.name ); } );
return models;
}
} // namespace track_sleepers