18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-21 21:24:58 +01:00
Files
maszyna/model/AnimModel.h
maj00r 8794c80c58 fix(models): a scenery light that is off no longer shows lit for a moment the first time it comes into view (#407)
* fix(models): a scenery light that is off no longer shows lit for a moment the first time it comes into view

Since d13c27a7 (the light blinking rework) the opacity of a light changes step
by step from its last value, and the opacities start at 1. RaAnimate runs only
for the instances that are drawn, so a model with "lights 0" (a W24 LED
indicator, for one) was drawn lit when it first came into range and faded out
over 0.45 s. Before d13c27a7 the opacity of a plain on/off light was worked out
anew from a timer starting at 0, so a light that is off was off from the first
frame.

Now the first time an instance is animated its lights take their current
state at once, whether it came from the definition or from an event since.
Every later change fades as before. The light threshold modes (ls_Dark,
ls_Home) are untouched. The only other difference from before d13c27a7: a
light that is on no longer fades in the first time it is drawn.

* fix(models): the light opacity step written without an implicit double to float conversion (Sonar S5276)

The sum is still worked out in double and rounded to float once, as the
compound assignment did, so the result is the same to the bit.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-20 03:39:52 +01:00

260 lines
11 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/.
*/
/*
MaSzyna EU07 locomotive simulator
Copyright (C) 2001-2004 Marcin Wozniak and others
*/
#pragma once
#include "utilities/Classes.h"
#include "utilities/Float3d.h"
#include "model/Model3d.h"
#include "vehicle/DynObj.h"
#include "scene/scenenode.h"
const int iMaxNumLights = 8;
float const DefaultDarkThresholdLevel { 0.325f };
// typy stanu świateł
enum TLightState
{
ls_Off = 0, // zgaszone
ls_On = 1, // zapalone
ls_Blink = 2, // migające
ls_Dark = 3, // Ra: zapalajce się automatycznie, gdy zrobi się ciemno
ls_Home = 4, // like ls_dark but off late at night
ls_winter = 5 // turned on when its winter
};
class TAnimVocaloidFrame
{ // ramka animacji typu Vocaloid Motion Data z programu MikuMikuDance
public:
char cBone[15]; // nazwa kości, może być po japońsku
int iFrame; // numer ramki
float3 f3Vector; // przemieszczenie
float4 qAngle; // kwaternion obrotu
char cBezier[64]; // krzywe Béziera do interpolacji dla x,y,z i obrotu
};
class basic_event;
class TAnimContainer : public std::enable_shared_from_this<TAnimContainer>
{ // opakowanie submodelu, określające animację egzemplarza - obsługiwane jako lista
friend TAnimModel;
private:
glm::vec3 vRotateAngles; // dla obrotów Eulera
glm::vec3 vDesiredAngles;
double fRotateSpeed;
glm::dvec3 vTranslation;
glm::dvec3 vTranslateTo;
double fTranslateSpeed; // może tu dać wektor?
float4 qCurrent; // aktualny interpolowany
float4 qStart; // pozycja początkowa (0 dla interpolacji)
float4 qDesired; // pozycja końcowa (1 dla interpolacji)
float fAngleCurrent; // parametr interpolacyjny: 0=start, 1=docelowy
float fAngleSpeed; // zmiana parametru interpolacji w sekundach
public:
TSubModel *pSubModel;
private:
std::shared_ptr<float4x4> mAnim; // macierz do animacji kwaternionowych
// dla kinematyki odwróconej używane są kwaterniony
float fLength; // długość kości dla IK
int iAnim; // animacja: +1-obrót Eulera, +2-przesuw, +4-obrót kwaternionem, +8-IK
//+0x80000000: animacja z eventem, wykonywana poza wyświetlaniem
//+0x100: pierwszy stopień IK - obrócić w stronę pierwszego potomnego (dziecka)
//+0x200: drugi stopień IK - dostosować do pozycji potomnego potomnego (wnuka)
basic_event *evDone; // ewent wykonywany po zakończeniu animacji, np. zapór, obrotnicy
public:
// wyświetlania
TAnimContainer();
bool Init(TSubModel *pNewSubModel);
inline
std::string NameGet() {
return pSubModel ? pSubModel->pName : ""; };
void SetRotateAnim( glm::vec3 vNewRotateAngles, double fNewRotateSpeed);
void SetTranslateAnim( glm::dvec3 vNewTranslate, double fNewSpeed);
// the rotation and the shift set brought to their ends at once, for the editor which shows them with the time stopped
void Finish();
void AnimSetVMD(double fNewSpeed);
void PrepareModel();
void UpdateModel();
void UpdateModelIK();
bool InMovement(); // czy w trakcie animacji?
inline
double AngleGet() {
return vRotateAngles.z; }; // jednak ostatnia, T3D ma inny układ
inline
glm::dvec3 TransGet() {
return glm::dvec3(-vTranslation.x, vTranslation.z, vTranslation.y); }; // zmiana, bo T3D ma inny układ
inline
void WillBeAnimated() {
if (pSubModel)
pSubModel->WillBeAnimated(); };
void EventAssign(basic_event *ev);
inline
basic_event * Event() {
return evDone; };
};
// opakowanie modelu, określające stan egzemplarza
class TAnimModel : public scene::basic_node {
friend opengl_renderer;
friend opengl33_renderer;
friend itemproperties_panel;
public:
// constructors
explicit TAnimModel( scene::node_data const &Nodedata );
// methods
static void AnimUpdate( double dt );
bool Init(std::string const &asName, std::string const &asReplacableTexture);
bool Load(cParser *parser, bool ter = false);
// sets up the instance from the values of a definition which was already taken apart, the way Load(cParser *) does it
// from the text. Name, Texture: as that method gets them ready, lower case model name and forward slashes in both.
// Twin: instance set up for the same model and texture, to take them after instead of locating them again; can be nullptr.
// Angles, Scale: content of the optional blocks of the definition, nullptr for a block which isn't there
void Load( std::string const &Name, std::string const &Texture, TAnimModel const *Twin, glm::vec3 const *Angles, glm::vec3 const *Scale, bool const Transition );
std::shared_ptr<TAnimContainer> AddContainer(std::string const &Name);
std::shared_ptr<TAnimContainer> GetContainer(std::string const &Name = "");
void LightSet( int const n, float const v );
void SkinSet( int const Index, material_handle const Material );
std::optional<std::tuple<float, float, std::optional<glm::vec3> > > LightGet( int const n );
int TerrainCount();
TSubModel * TerrainSquare(int n);
int Flags();
void on_season_update();
inline
material_data const *
Material() const {
return &m_materialdata; }
inline
TModel3d *
Model() const {
return pModel; }
inline
void
Angles( glm::vec3 const &Angles ) {
vAngle = Angles; }
inline
glm::vec3
Angles() const {
return vAngle; }
// per-axis scale, applied between rotation and the submodel-local transform chain.
// (1,1,1) = unchanged. Set by the `scale`/`endscale` scenario directives or the
// optional `scale <factor>` / `scale <x> <y> <z>` token inside a `node model` block.
// Per-axis values let you stretch a model along a single dimension; uniform input
// (single float) broadcasts to all three axes.
inline
void
Scale( glm::vec3 const &Factor ) {
m_scale = glm::vec3(
Factor.x > 0.0f ? Factor.x : 1.0f,
Factor.y > 0.0f ? Factor.y : 1.0f,
Factor.z > 0.0f ? Factor.z : 1.0f ); }
inline
void
Scale( float const Factor ) {
Scale( glm::vec3( Factor ) ); }
inline
glm::vec3 const &
Scale() const {
return m_scale; }
// members
std::list<std::shared_ptr<TAnimContainer>> m_animlist;
// lista animacji z eventem, które muszą być przeliczane również bez wyświetlania
static std::list<std::weak_ptr<TAnimContainer>> acAnimList;
public:
// methods
void RaPrepare(); // ustawienie animacji egzemplarza na wzorcu
// rotation and scale of the instance as a matrix: rotate y * rotate x * rotate z * scale
glm::mat4 const &rotation_scale();
void RaAnimate( unsigned int const Framestamp ); // przeliczenie animacji egzemplarza
// radius() subclass details, calculates node's bounding radius
float radius_() const override;
// serialize() subclass details, sends content of the subclass to provided stream
void serialize_( std::ostream &Output ) const;
// deserialize() subclass details, restores content of the subclass from provided stream
void deserialize_( std::istream &Input );
// export() subclass details, sends basic content of the class in legacy (text) format to provided stream
void export_as_text_( std::ostream &Output ) const;
// checks whether provided token is a legacy (text) format keyword
bool is_keyword( std::string const &Token ) const;
// members
std::shared_ptr<TAnimContainer> pRoot; // pojemniki sterujące, tylko dla aniomowanych submodeli
TModel3d *pModel { nullptr };
glm::vec3 vAngle; // bazowe obroty egzemplarza względem osi
glm::vec3 m_scale { 1.0f, 1.0f, 1.0f }; // per-axis scale (see Scale() accessors above)
// rotation and scale part of the instance transform, cached for the instanced render path.
// rebuilt by rotation_scale() whenever the angles or the scale differ from the ones it was built from
glm::mat4 m_rotationscale { 1.0f };
glm::vec3 m_rotationscaleangles { 0.0f, 0.0f, 0.0f };
glm::vec3 m_rotationscalescale { 1.0f, 1.0f, 1.0f };
bool m_rotationscalevalid { false };
material_data m_materialdata;
std::string asText; // tekst dla wyświetlacza znakowego
std::string m_skintoken; // replacable skin the way the definition of the node gave it, kept for the export
// TODO: wrap into a light state struct, remove fixed element count
int iNumLights { 0 };
std::array<TSubModel *, iMaxNumLights> LightsOn {}; // Ra: te wskaźniki powinny być w ramach TModel3d
std::array<TSubModel *, iMaxNumLights> LightsOff {};
TSubModel *sm_winter_variant {}; // submodel zimowego wariantu
TSubModel *sm_spring_variant {}; // submodel wiosennego wariantu
TSubModel *sm_summer_variant {}; // submodel letniego wariantu
TSubModel *sm_autumn_variant {}; // submodel jesiennego wariantu
std::array<float, iMaxNumLights> lsLights {}; // ls_Off
std::array<glm::vec3, iMaxNumLights> m_lightcolors; // -1 in constructor
std::array<float, iMaxNumLights> m_lighttimers {};
std::array<float, iMaxNumLights> m_lightopacities; // {1} in constructor
float fOnTime { 1.f / 2 };// { 60.f / 45.f / 2 };
float fOffTime { 1.f / 2 };// { 60.f / 45.f / 2 }; // były stałymi, teraz mogą być zmienne dla każdego egzemplarza
// float fTransitionTime { fOnTime * 0.9f }; // time
bool m_transition { true }; // smooth transition between light states
bool m_lightsanimated { false }; // the lights were brought to their state at least once
unsigned int m_framestamp { 0 }; // id of last rendered gfx frame
// true if this instance is eligible for the batched/instanced render path:
// no lights, no submodel animations, no replacable skins, no seasonal variants.
// computed once at end of Load() so the renderer can simply test the flag.
bool m_instanceable { false };
// helper: evaluates current state and updates m_instanceable accordingly.
void update_instanceable_flag();
// helper: assigns the model and the replacable skin to the instance, and binds light and variant submodels of the model
void assign_model( std::string &name, std::string const &texture, bool const ter );
// diagnostic counters (process-wide). Updated inside update_instanceable_flag()
// so the renderer can surface load-time classification stats in the debug overlay.
static int s_instanceable_total; // count of TAnimModel*'s classified instanceable
// bumped whenever an instance loses its instanceable status after it was put in a scene cell (an event adds
// an animation container, or changes a skin); the cells rebuild their lists of instances drawn one by one then
static unsigned int s_instanceable_revoked;
static int s_classified_total; // count of TAnimModel*'s that ran through the classifier
static int s_rejected_no_pmodel;
static int s_rejected_lights;
static int s_rejected_animlist;
static int s_rejected_animated_submodel;
};
class instance_table : public basic_table<TAnimModel> {
};
//---------------------------------------------------------------------------