eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-23 14:29:18 +02:00
Code Issues 123 Wiki Activity

Merge remote-tracking branch 'manul-public/master' into manul-staging

Browse Source
This commit is contained in:
WLs50
2025-04-05 14:24:53 +02:00
parent 2a3002e8e4 94e3f38973
commit 0280b40ca5
45 changed files with 875 additions and 477 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
CMakeLists.txt
View File

@@ -457,6 +457,12 @@ endif ()
# add ref/discord-rpc to the project in the same way other dependencies are added
add_subdirectory(ref/discord-rpc)
target_link_libraries(${PROJECT_NAME} discord-rpc)
find_package(OpenAL REQUIRED)
if (TARGET OpenAL::OpenAL)
target_link_libraries(${PROJECT_NAME} OpenAL::OpenAL)

3
Globals.cpp
View File

@@ -395,11 +395,8 @@ global_settings::ConfigParse(cParser &Parser) {
// selected device for audio renderer
Parser.getTokens();
Parser >> AirTemperature;
if (false == DebugModeFlag)
{
AirTemperature = clamp(AirTemperature, -15.f, 45.f);
}
}
else if (token == "scalespeculars")
{
// whether strength of specular highlights should be adjusted (generally needed for

1
Globals.h
View File

@@ -94,6 +94,7 @@ struct global_settings {
float Overcast{ 0.1f }; // NOTE: all this weather stuff should be moved elsewhere
glm::vec3 FogColor = { 0.6f, 0.7f, 0.8f };
float fFogEnd{ 7500 };
float fTurbidity{ 128 };
std::string Season{}; // season of the year, based on simulation date
std::string Weather{ "cloudy:" }; // current weather
std::string Period{}; // time of the day, based on sun position

159
Model3d.cpp
View File

@@ -209,6 +209,21 @@ inline void readMatrix(cParser &parser, float4x4 &matrix)
parser >> matrix(x)[y];
};
template <typename T> void UserdataParse(cParser &parser, gfx::vertex_userdata &vertex)
{
parser.getTokens(4);
union
{
T InType;
float FloatType;
} buf{};
for (int i = 0; i < 4; ++i)
{
parser >> buf.InType;
vertex.data[i] = buf.FloatType;
}
}
std::pair<int, int> TSubModel::Load( cParser &parser, bool dynamic )
{ // Ra: VBO tworzone na poziomie modelu, a nie submodeli
auto token { parser.getToken<std::string>() };
@@ -479,6 +494,13 @@ std::pair<int, int> TSubModel::Load( cParser &parser, bool dynamic )
if (eType < TP_ROTATOR)
{ // wczytywanie wierzchołków
token = parser.getToken<std::string>();
bool has_userdata = false;
if (token == "userdata:")
{
has_userdata = parser.getToken<bool>();
token = parser.getToken<std::string>();
}
if( token == "numindices:" ) // optional block, potentially preceeding vertex list
{
m_geometry.index_count = parser.getToken<int>( false );
@@ -656,11 +678,20 @@ std::pair<int, int> TSubModel::Load( cParser &parser, bool dynamic )
}
}
Vertices.resize( m_geometry.vertex_count ); // in case we had some degenerate triangles along the way
gfx::calculate_indices( Indices, Vertices, transformscalestack );
gfx::calculate_indices( Indices, Vertices, Userdata, transformscalestack );
gfx::calculate_tangents( Vertices, Indices, GL_TRIANGLES );
// update values potentially changed by indexing
m_geometry.index_count = Indices.size();
m_geometry.vertex_count = Vertices.size();
}
if (has_userdata)
{
Userdata.resize(m_geometry.vertex_count);
auto userdata { std::begin( Userdata ) };
for( auto idx = 0; idx < m_geometry.vertex_count; ++idx ) {
auto vertex { userdata + idx };
UserdataParse<float>(parser, *vertex);
}
}
}
else // gdy brak wierzchołków
@@ -1160,25 +1191,45 @@ void TSubModel::RaAnimation(glm::mat4 &m, TAnimType a)
//---------------------------------------------------------------------------
void TSubModel::serialize_geometry( std::ostream &Output, bool const Packed, bool const Indexed ) const {
void TSubModel::serialize_geometry( std::ostream &Output, bool const Packed, bool const Indexed, bool const UserData ) const {
if( Child ) {
Child->serialize_geometry( Output, Packed, Indexed );
Child->serialize_geometry( Output, Packed, Indexed, UserData );
}
if( m_geometry.handle != null_handle ) {
if( Packed ) {
for( auto const &vertex : GfxRenderer->Vertices( m_geometry.handle ) ) {
vertex.serialize_packed( Output, Indexed );
auto vertices = GfxRenderer->Vertices( m_geometry.handle );
auto userdatas = GfxRenderer->UserData( m_geometry.handle );
bool has_userdata = !userdatas.empty();
for( int i = 0; i < vertices.size(); ++i ) {
vertices[i].serialize_packed( Output, Indexed );
if (UserData)
{
if (has_userdata)
userdatas[i].serialize_packed(Output);
else
gfx::vertex_userdata{}.serialize_packed( Output );
}
}
}
else {
for( auto const &vertex : GfxRenderer->Vertices( m_geometry.handle ) ) {
vertex.serialize( Output, Indexed );
auto vertices = GfxRenderer->Vertices( m_geometry.handle );
auto userdatas = GfxRenderer->UserData( m_geometry.handle );
bool has_userdata = !userdatas.empty();
for( int i = 0; i < vertices.size(); ++i ) {
vertices[i].serialize( Output, Indexed );
if (UserData)
{
if (has_userdata)
userdatas[i].serialize(Output);
else
gfx::vertex_userdata{}.serialize( Output );
}
}
}
}
if( Next ) {
Next->serialize_geometry( Output, Packed, Indexed );
Next->serialize_geometry( Output, Packed, Indexed, UserData );
}
};
@@ -1254,7 +1305,7 @@ TSubModel::create_geometry( std::size_t &Indexoffset, std::size_t &Vertexoffset,
eType < TP_ROTATOR ?
eType :
GL_POINTS );
m_geometry.handle = GfxRenderer->Insert( Indices, Vertices, Bank, type );
m_geometry.handle = GfxRenderer->Insert( Indices, Vertices, Userdata, Bank, type );
}
if( m_geometry.handle != 0 ) {
@@ -1653,6 +1704,7 @@ void TModel3d::SaveToBinFile(std::string const &FileName)
sn_utils::ls_uint32(s, MAKE_ID4('E', '3', 'D', '0'));
auto const e3d_spos = s.tellp();
sn_utils::ls_uint32(s, 0);
bool has_any_userdata = Root->HasAnyVertexUserData();
{
sn_utils::ls_uint32(s, MAKE_ID4('S', 'U', 'B', '0'));
@@ -1679,20 +1731,41 @@ void TModel3d::SaveToBinFile(std::string const &FileName)
Root->serialize_indices( s, indexsize );
if (!(Global.iConvertModels & 8)) {
sn_utils::ls_uint32( s, MAKE_ID4( 'V', 'N', 'T', '1' ) );
sn_utils::ls_uint32( s, 8 + m_vertexcount * 20 );
Root->serialize_geometry( s, true, true );
int modeltype = 1;
int vertexsize = 20;
if(has_any_userdata)
{
modeltype |= 4;
vertexsize += 8;
}
sn_utils::ls_uint32( s, MAKE_ID4( 'V', 'N', 'T', '0' + modeltype ) );
sn_utils::ls_uint32( s, 8 + m_vertexcount * vertexsize );
Root->serialize_geometry( s, true, true, has_any_userdata );
}
else {
sn_utils::ls_uint32( s, MAKE_ID4( 'V', 'N', 'T', '2' ) );
sn_utils::ls_uint32( s, 8 + m_vertexcount * 48 );
Root->serialize_geometry( s, false, true );
int modeltype = 2;
int vertexsize = 48;
if(has_any_userdata)
{
modeltype |= 4;
vertexsize += 16;
}
sn_utils::ls_uint32( s, MAKE_ID4( 'V', 'N', 'T', '0' + modeltype ) );
sn_utils::ls_uint32( s, 8 + m_vertexcount * vertexsize );
Root->serialize_geometry( s, false, true, has_any_userdata );
}
}
else {
sn_utils::ls_uint32( s, MAKE_ID4( 'V', 'N', 'T', '0' ) );
sn_utils::ls_uint32( s, 8 + m_vertexcount * 32 );
Root->serialize_geometry( s, false, false );
int modeltype = 0;
int vertexsize = 32;
if(has_any_userdata)
{
modeltype |= 4;
vertexsize += 16;
}
sn_utils::ls_uint32( s, MAKE_ID4( 'V', 'N', 'T', '0' + modeltype ) );
sn_utils::ls_uint32( s, 8 + m_vertexcount * vertexsize );
Root->serialize_geometry( s, false, false, has_any_userdata );
}
if (textures.size())
@@ -1782,6 +1855,7 @@ void TModel3d::deserialize(std::istream &s, size_t size, bool dynamic)
std::streampos end = s.tellg() + (std::streampos)size;
bool hastangents { false };
bool hasuserdata {false};
while (s.tellg() < end)
{
@@ -1825,21 +1899,26 @@ void TModel3d::deserialize(std::istream &s, size_t size, bool dynamic)
return (Left.first) < (Right.first); } );
// once sorted we can grab geometry as it comes, and assign it to the chunks it belongs to
size_t const vertextype { ( ( ( type & 0xFF000000 ) >> 24 ) - '0' ) };
hastangents = ( vertextype > 0 );
hastangents = ( (vertextype & 3) > 0 );
hasuserdata = (vertextype & 4);
for( auto const &submodeloffset : submodeloffsets ) {
auto &submodel { Root[ submodeloffset.second ] };
auto const &submodelgeometry { submodel.m_geometry };
submodel.Vertices.resize( submodelgeometry.vertex_count );
if(hasuserdata)
submodel.Userdata.resize( submodelgeometry.vertex_count );
m_vertexcount += submodelgeometry.vertex_count;
switch( vertextype ) {
switch( vertextype & 3 ) {
case 0: {
// legacy vnt0 format
for( auto &vertex : submodel.Vertices ) {
vertex.deserialize( s, hastangents );
for( int i = 0; i < submodel.Vertices.size(); ++i ) {
submodel.Vertices[i].deserialize( s, hastangents );
if(hasuserdata)
submodel.Userdata[i].deserialize( s );
if( submodel.eType < TP_ROTATOR ) {
// normal vectors debug routine
if( ( false == submodel.m_normalizenormals )
&& ( std::abs( glm::length2( vertex.normal ) - 1.0f ) > 0.01f ) ) {
&& ( std::abs( glm::length2( submodel.Vertices[i].normal ) - 1.0f ) > 0.01f ) ) {
submodel.m_normalizenormals = TSubModel::normalize; // we don't know if uniform scaling would suffice
WriteLog( "Bad model: non-unit normal vector(s) encountered during sub-model geometry deserialization", logtype::model );
}
@@ -1849,15 +1928,19 @@ void TModel3d::deserialize(std::istream &s, size_t size, bool dynamic)
}
case 1: {
// expanded chunk formats
for( auto &vertex : submodel.Vertices ) {
vertex.deserialize_packed( s, hastangents );
for( int i = 0; i < submodel.Vertices.size(); ++i ) {
submodel.Vertices[i].deserialize_packed( s, hastangents );
if(hasuserdata)
submodel.Userdata[i].deserialize_packed( s );
}
break;
}
case 2: {
// expanded chunk formats
for( auto &vertex : submodel.Vertices ) {
vertex.deserialize( s, hastangents );
for( int i = 0; i < submodel.Vertices.size(); ++i ) {
submodel.Vertices[i].deserialize( s, hastangents );
if(hasuserdata)
submodel.Userdata[i].deserialize( s );
}
break;
}
@@ -1988,7 +2071,7 @@ void TModel3d::deserialize(std::istream &s, size_t size, bool dynamic)
if( false == hastangents ) {
gfx::calculate_tangents( Root[i].Vertices, Root[i].Indices, type );
}
Root[i].m_geometry.handle = GfxRenderer->Insert( Root[i].Indices, Root[i].Vertices, m_geometrybank, type );
Root[i].m_geometry.handle = GfxRenderer->Insert( Root[i].Indices, Root[i].Vertices, Root[i].Userdata, m_geometrybank, type );
}
}
@@ -2127,6 +2210,26 @@ void TSubModel::BinInit(TSubModel *s, float4x4 *m, std::vector<std::string> *t,
normalize );
}
}
}
bool TSubModel::HasAnyVertexUserData() const
{
for (const TSubModel *sm = this; sm; sm = sm->Next)
{
if (m_geometry.handle)
{
if (!GfxRenderer->UserData(m_geometry.handle).empty())
return true;
}
else
{
if (!sm->Userdata.empty())
return true;
}
if (sm->Child && sm->Child->HasAnyVertexUserData())
return true;
}
return false;
};
void TModel3d::LoadFromBinFile(std::string const &FileName, bool dynamic)

5
Model3d.h
View File

@@ -85,6 +85,8 @@ public:
public: // chwilowo
TAnimType b_Anim{ TAnimType::at_None };
bool HasAnyVertexUserData() const;
public:
uint32_t iFlags{ 0x0200 }; // bit 9=1: submodel został utworzony a nie ustawiony na wczytany plik
// flagi informacyjne:
@@ -145,6 +147,7 @@ public: // chwilowo
float3 v_TransVector { 0.0f, 0.0f, 0.0f };
geometry_data m_geometry { /*this,*/ { 0, 0 }, 0, 0, 0, 0 };
gfx::vertex_array Vertices;
gfx::userdata_array Userdata;
gfx::index_array Indices;
float m_boundingradius { 0 };
std::uintptr_t iAnimOwner{ 0 }; // roboczy numer egzemplarza, który ustawił animację
@@ -244,7 +247,7 @@ public:
std::vector<std::string>&,
std::vector<std::string>&,
std::vector<float4x4>&);
void serialize_geometry( std::ostream &Output, bool const Packed, bool const Indexed ) const;
void serialize_geometry( std::ostream &Output, bool const Packed, bool const Indexed, bool const UserData ) const;
int index_size() const;
void serialize_indices( std::ostream &Output, int const Size ) const;
// places contained geometry in provided ground node

9
README.md
View File

@@ -25,14 +25,15 @@ List of requirements for compiling executable. For usage/runtime requirements [s
**Note:** There's some issue in our build system. If link error occurs, use `-DGLFW3_LIBRARIES='<path>'` in CMake.
- [GLM](https://glm.g-truc.net/) (0.9.9.0)
- serialport (0.1.1)
- [serialport](https://sigrok.org/wiki/Libserialport) (0.1.1)
- [sndfile](https://github.com/erikd/libsndfile) (1.0.28)
- [LuajIT](http://luajit.org/) (2.0.5)
- [GLEW](http://glew.sourceforge.net/) (2.1.0)
- [LuajIT](http://luajit.org) (2.0.5)
- [GLEW](http://glew.sourceforge.net) (2.1.0)
- [PNG](http://www.libpng.org/pub/png/libpng.html) (1.6.34)
- [OpenAL](https://www.openal.org/) (1.18.2)
- [OpenAL](https://www.openal.org) (1.18.2)
- pthread
- [Python 2.7](https://www.python.org)
- [asio](https://think-async.com/Asio) (1.12)
### **3. OpenGL 3.0.**

88
Track.cpp
View File

@@ -1146,6 +1146,7 @@ void TTrack::create_map_geometry(std::vector<gfx::basic_vertex> &Bank, const gfx
{
if (iCategoryFlag != 1)
return; // only tracks for now
gfx::userdata_array empty_userdata{};
switch (eType)
{
@@ -1154,7 +1155,7 @@ void TTrack::create_map_geometry(std::vector<gfx::basic_vertex> &Bank, const gfx
Segment->render_lines(vertices, 0.5f);
std::copy(vertices.begin(), vertices.end(), std::back_inserter(Bank));
extra_map_geometry = GfxRenderer->Insert(vertices, Extra, GL_LINES);
extra_map_geometry = GfxRenderer->Insert(vertices, empty_userdata, Extra, GL_LINES);
break;
}
@@ -1163,12 +1164,12 @@ void TTrack::create_map_geometry(std::vector<gfx::basic_vertex> &Bank, const gfx
SwitchExtension->Segments[0]->render_lines(vertices, 0.5f);
std::copy(vertices.begin(), vertices.end(), std::back_inserter(Bank));
SwitchExtension->map_geometry[0] = GfxRenderer->Insert(vertices, Extra, GL_LINES);
SwitchExtension->map_geometry[0] = GfxRenderer->Insert(vertices, empty_userdata, Extra, GL_LINES);
vertices.clear();
SwitchExtension->Segments[1]->render_lines(vertices, 0.5f);
std::copy(vertices.begin(), vertices.end(), std::back_inserter(Bank));
SwitchExtension->map_geometry[1] = GfxRenderer->Insert(vertices, Extra, GL_LINES);
SwitchExtension->map_geometry[1] = GfxRenderer->Insert(vertices, empty_userdata, Extra, GL_LINES);
break;
}
default:
@@ -1309,7 +1310,7 @@ glm::vec3 TTrack::get_nearest_point(const glm::dvec3 &point) const
// wypełnianie tablic VBO
void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
gfx::userdata_array empty_userdata;
switch (iCategoryFlag & 15)
{
case 1: // tor
@@ -1329,11 +1330,11 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
gfx::vertex_array vertices;
Segment->RenderLoft(vertices, m_origin, bpts1, iTrapezoid > 0, texturelength);
if( ( Bank != 0 ) && ( true == Geometry2.empty() ) ) {
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
}
if( ( Bank == 0 ) && ( false == Geometry2.empty() ) ) {
// special variant, replace existing data for a turntable track
GfxRenderer->Replace( vertices, Geometry2[ 0 ], GL_TRIANGLE_STRIP );
GfxRenderer->Replace(vertices, empty_userdata, Geometry2[0], GL_TRIANGLE_STRIP);
}
}
if (m_material1)
@@ -1343,18 +1344,18 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
gfx::vertex_array vertices;
if( ( Bank != 0 ) && ( true == Geometry1.empty() ) ) {
Segment->RenderLoft( vertices, m_origin, rpts1, iTrapezoid > 0, texturelength );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear(); // reuse the scratchpad
Segment->RenderLoft( vertices, m_origin, rpts2, iTrapezoid > 0, texturelength );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
}
if( ( Bank == 0 ) && ( false == Geometry1.empty() ) ) {
// special variant, replace existing data for a turntable track
Segment->RenderLoft( vertices, m_origin, rpts1, iTrapezoid > 0, texturelength );
GfxRenderer->Replace( vertices, Geometry1[ 0 ], GL_TRIANGLE_STRIP );
GfxRenderer->Replace(vertices, empty_userdata, Geometry1[0], GL_TRIANGLE_STRIP);
vertices.clear(); // reuse the scratchpad
Segment->RenderLoft( vertices, m_origin, rpts2, iTrapezoid > 0, texturelength );
GfxRenderer->Replace( vertices, Geometry1[ 1 ], GL_TRIANGLE_STRIP );
GfxRenderer->Replace(vertices, empty_userdata, Geometry1[1], GL_TRIANGLE_STRIP);
}
}
break;
@@ -1379,21 +1380,21 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
// composed from two parts: transition from blade to regular rail, and regular rail
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts3, true, texturelength, 1.0, 0, bladelength / 2, { SwitchExtension->fOffset2, SwitchExtension->fOffset2 / 2 } );
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts1, false, texturelength, 1.0, bladelength / 2, bladelength, { SwitchExtension->fOffset2 / 2, 0.f } );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
// fixed parts
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts1, false, texturelength, 1.0, bladelength );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
if( jointlength > 0 ) {
// part of the diverging rail touched by wheels of vehicle going straight
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts1, false, texturelength, 1.0, 0, jointlength );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
// other rail, full length
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts2, false, texturelength );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
if( m_material2 ) {
@@ -1402,15 +1403,15 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
// composed from two parts: transition from blade to regular rail, and regular rail
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts4, true, texturelength, 1.0, 0, bladelength / 2, { -fMaxOffset + SwitchExtension->fOffset1, ( -fMaxOffset + SwitchExtension->fOffset1 ) / 2 } );
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts2, false, texturelength, 1.0, bladelength / 2, bladelength, { ( -fMaxOffset + SwitchExtension->fOffset1 ) / 2, 0.f } );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
// fixed parts
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts2, false, texturelength, 1.0, bladelength );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
// diverging rail, potentially minus part touched by wheels of vehicle going straight
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts1, false, texturelength, 1.0, jointlength );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
}
@@ -1423,22 +1424,22 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
// composed from two parts: transition from blade to regular rail, and regular rail
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts4, true, texturelength, 1.0, 0, bladelength / 2, { -SwitchExtension->fOffset2, -SwitchExtension->fOffset2 / 2 } );
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts2, false, texturelength, 1.0, bladelength / 2, bladelength, { -SwitchExtension->fOffset2 / 2, 0.f } );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
// fixed parts
// prawa szyna za iglicą
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts2, false, texturelength, 1.0, bladelength );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
if( jointlength > 0 ) {
// part of the diverging rail touched by wheels of vehicle going straight
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts2, false, texturelength, 1.0, 0, jointlength );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
// other rail, full length
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts1, false, texturelength );
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
if( m_material2 ) {
@@ -1447,16 +1448,16 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
// composed from two parts: transition from blade to regular rail, and regular rail
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts3, true, texturelength, 1.0, 0, bladelength / 2, { fMaxOffset - SwitchExtension->fOffset1, ( fMaxOffset - SwitchExtension->fOffset1 ) / 2 } );
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts1, false, texturelength, 1.0, bladelength / 2, bladelength, { ( fMaxOffset - SwitchExtension->fOffset1 ) / 2, 0.f } );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
// fixed parts
// lewa szyna za iglicą
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts1, false, texturelength, 1.0, bladelength );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
// diverging rail, potentially minus part touched by wheels of vehicle going straight
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts2, false, texturelength, 1.0, jointlength );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
}
@@ -1465,7 +1466,7 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
if( true == Global.CreateSwitchTrackbeds ) {
gfx::vertex_array vertices;
create_switch_trackbed( vertices );
SwitchExtension->Geometry3 = GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP );
SwitchExtension->Geometry3 = GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP);
vertices.clear();
}
@@ -1488,7 +1489,7 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
auto const texturelength { texture_length( m_material1 ) };
gfx::vertex_array vertices;
Segment->RenderLoft(vertices, m_origin, bpts1, iTrapezoid > 0, texturelength);
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
}
if (m_material2)
{ // pobocze drogi - poziome przy przechyłce (a może krawężnik i chodnik zrobić jak w Midtown Madness 2?)
@@ -1501,13 +1502,13 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
if( ( fTexHeight1 >= 0.0 ) || ( slop != 0.0 ) ) {
// tylko jeśli jest z prawej
Segment->RenderLoft( vertices, m_origin, rpts1, iTrapezoid > 0, texturelength );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
if( ( fTexHeight1 >= 0.0 ) || ( side != 0.0 ) ) {
// tylko jeśli jest z lewej
Segment->RenderLoft( vertices, m_origin, rpts2, iTrapezoid > 0, texturelength );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
}
@@ -1584,22 +1585,22 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
if( ( fTexHeight1 >= 0.0 ) || ( side != 0.0 ) ) {
SwitchExtension->Segments[ 2 ]->RenderLoft( vertices, m_origin, rpts2, true, texturelength, 1.0, 0, 0, {}, &b, render );
if( true == render ) {
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
SwitchExtension->Segments[ 3 ]->RenderLoft( vertices, m_origin, rpts2, true, texturelength, 1.0, 0, 0, {}, &b, render );
if( true == render ) {
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
SwitchExtension->Segments[ 4 ]->RenderLoft( vertices, m_origin, rpts2, true, texturelength, 1.0, 0, 0, {}, &b, render );
if( true == render ) {
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
SwitchExtension->Segments[ 5 ]->RenderLoft( vertices, m_origin, rpts2, true, texturelength, 1.0, 0, 0, {}, &b, render );
if( true == render ) {
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
}
@@ -1609,17 +1610,17 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
if( ( fTexHeight1 >= 0.0 ) || ( side != 0.0 ) ) {
SwitchExtension->Segments[ 2 ]->RenderLoft( vertices, m_origin, rpts2, true, texturelength, 1.0, 0, 0, {}, &b, render ); // z P2 do P4
if( true == render ) {
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts2, true, texturelength, 1.0, 0, 0, {}, &b, render ); // z P4 do P3=P1 (odwrócony)
if( true == render ) {
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts2, true, texturelength, 1.0, 0, 0, {}, &b, render ); // z P1 do P2
if( true == render ) {
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
}
@@ -1674,7 +1675,7 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
cosa0 * u + sina0 * v + 0.5,
-sina0 * u + cosa0 * v + 0.5 } );
}
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_FAN ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_FAN));
}
break;
} // tt_cross
@@ -1693,7 +1694,7 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
{ // tworzenie trójkątów nawierzchni szosy
gfx::vertex_array vertices;
Segment->RenderLoft(vertices, m_origin, bpts1, iTrapezoid > 0, fTexLength);
Geometry1.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry1.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
}
if (m_material2)
{ // pobocze drogi - poziome przy przechyłce (a może krawężnik i chodnik zrobić jak w Midtown Madness 2?)
@@ -1701,10 +1702,10 @@ void TTrack::create_geometry( gfx::geometrybank_handle const &Bank ) {
create_road_side_profile( rpts1, rpts2, bpts1 );
gfx::vertex_array vertices;
Segment->RenderLoft( vertices, m_origin, rpts1, iTrapezoid > 0, fTexLength );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
Segment->RenderLoft( vertices, m_origin, rpts2, iTrapezoid > 0, fTexLength );
Geometry2.emplace_back( GfxRenderer->Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
Geometry2.emplace_back(GfxRenderer->Insert(vertices, empty_userdata, Bank, GL_TRIANGLE_STRIP));
vertices.clear();
}
}
@@ -1931,6 +1932,7 @@ void TTrack::RaAnimListAdd(TTrack *t)
TTrack * TTrack::RaAnimate()
{ // wykonanie rekurencyjne animacji, wywoływane przed wyświetleniem sektora
// zwraca wskaźnik toru wymagającego dalszej animacji
gfx::userdata_array empty_userdata;
if( SwitchExtension->pNextAnim )
SwitchExtension->pNextAnim = SwitchExtension->pNextAnim->RaAnimate();
bool m = true; // animacja trwa
@@ -1982,7 +1984,7 @@ TTrack * TTrack::RaAnimate()
// composed from two parts: transition from blade to regular rail, and regular rail
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts3, true, texturelength, 1.0, 0, bladelength / 2, { SwitchExtension->fOffset2, SwitchExtension->fOffset2 / 2 } );
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts1, false, texturelength, 1.0, bladelength / 2, bladelength, { SwitchExtension->fOffset2 / 2, 0.f } );
GfxRenderer->Replace( vertices, Geometry1[ 0 ], GL_TRIANGLE_STRIP );
GfxRenderer->Replace(vertices, empty_userdata, Geometry1[0], GL_TRIANGLE_STRIP);
vertices.clear();
}
if( m_material2 ) {
@@ -1991,7 +1993,7 @@ TTrack * TTrack::RaAnimate()
// composed from two parts: transition from blade to regular rail, and regular rail
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts4, true, texturelength, 1.0, 0, bladelength / 2, { -fMaxOffset + SwitchExtension->fOffset1, ( -fMaxOffset + SwitchExtension->fOffset1 ) / 2 } );
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts2, false, texturelength, 1.0, bladelength / 2, bladelength, { ( -fMaxOffset + SwitchExtension->fOffset1 ) / 2, 0.f } );
GfxRenderer->Replace( vertices, Geometry2[ 0 ], GL_TRIANGLE_STRIP );
GfxRenderer->Replace(vertices, empty_userdata, Geometry2[0], GL_TRIANGLE_STRIP);
vertices.clear();
}
}
@@ -2002,7 +2004,7 @@ TTrack * TTrack::RaAnimate()
// composed from two parts: transition from blade to regular rail, and regular rail
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts4, true, texturelength, 1.0, 0, bladelength / 2, { -SwitchExtension->fOffset2, -SwitchExtension->fOffset2 / 2 } );
SwitchExtension->Segments[ 0 ]->RenderLoft( vertices, m_origin, rpts2, false, texturelength, 1.0, bladelength / 2, bladelength, { -SwitchExtension->fOffset2 / 2, 0.f } );
GfxRenderer->Replace( vertices, Geometry1[ 0 ], GL_TRIANGLE_STRIP );
GfxRenderer->Replace(vertices, empty_userdata, Geometry1[0], GL_TRIANGLE_STRIP);
vertices.clear();
}
if( m_material2 ) {
@@ -2011,7 +2013,7 @@ TTrack * TTrack::RaAnimate()
// composed from two parts: transition from blade to regular rail, and regular rail
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts3, true, texturelength, 1.0, 0, bladelength / 2, { fMaxOffset - SwitchExtension->fOffset1, ( fMaxOffset - SwitchExtension->fOffset1 ) / 2 } );
SwitchExtension->Segments[ 1 ]->RenderLoft( vertices, m_origin, rpts1, false, texturelength, 1.0, bladelength / 2, bladelength, { ( fMaxOffset - SwitchExtension->fOffset1 ) / 2, 0.f } );
GfxRenderer->Replace( vertices, Geometry2[ 0 ], GL_TRIANGLE_STRIP );
GfxRenderer->Replace(vertices, empty_userdata, Geometry2[0], GL_TRIANGLE_STRIP);
vertices.clear();
}
}

4
Traction.cpp
View File

@@ -342,7 +342,9 @@ TTraction::create_geometry( gfx::geometrybank_handle const &Bank ) {
}
auto const elementcount = vertices.size() / 2;
m_geometry = GfxRenderer->Insert( vertices, Bank, GL_LINES );
gfx::userdata_array empty_userdata{};
m_geometry = GfxRenderer->Insert( vertices, empty_userdata, Bank, GL_LINES );
return elementcount;
}

41
Train.cpp
View File

@@ -254,6 +254,8 @@ TTrain::commandhandler_map const TTrain::m_commandhandlers = {
{ user_command::autosandboxactivate, &TTrain::OnCommand_autosandboxactivate },
{ user_command::autosandboxdeactivate, &TTrain::OnCommand_autosandboxdeactivate },
{ user_command::epbrakecontroltoggle, &TTrain::OnCommand_epbrakecontroltoggle },
{ user_command::epbrakecontrolenable, &TTrain::OnCommand_epbrakecontrolenable },
{ user_command::epbrakecontroldisable, &TTrain::OnCommand_epbrakecontroldisable },
{ user_command::trainbrakeoperationmodeincrease, &TTrain::OnCommand_trainbrakeoperationmodeincrease },
{ user_command::trainbrakeoperationmodedecrease, &TTrain::OnCommand_trainbrakeoperationmodedecrease },
{ user_command::brakeactingspeedincrease, &TTrain::OnCommand_brakeactingspeedincrease },
@@ -1983,6 +1985,34 @@ void TTrain::OnCommand_autosandboxdeactivate(TTrain *Train, command_data const &
}
};
void TTrain::OnCommand_epbrakecontrolenable( TTrain *Train, command_data const &Command ) {
auto const istoggle{ ( static_cast<int>( Train->ggEPFuseButton.type() ) & static_cast<int>( TGaugeType::toggle ) ) != 0 };
if( Command.action == GLFW_PRESS ) {
// command only works for bistable switch
if(istoggle) {
if( Train->mvOccupied->EpFuseSwitch( true ) ) {
// audio feedback
if( Train->dsbPneumaticSwitch ) {
Train->dsbPneumaticSwitch->play();
}
Train->ggEPFuseButton.UpdateValue(1.0f, Train->dsbSwitch);
};
}
}
}
void TTrain::OnCommand_epbrakecontroldisable( TTrain *Train, command_data const &Command ) {
auto const istoggle{ ( static_cast<int>( Train->ggEPFuseButton.type() ) & static_cast<int>( TGaugeType::toggle ) ) != 0 };
if( Command.action == GLFW_PRESS ) {
// command only works for bistable switch
if(istoggle) {
if( Train->mvOccupied->EpFuseSwitch( false ) ) {
Train->ggEPFuseButton.UpdateValue(0.0f, Train->dsbSwitch);
};
}
}
}
void TTrain::OnCommand_epbrakecontroltoggle( TTrain *Train, command_data const &Command ) {
if( Command.action == GLFW_REPEAT ) { return; }
@@ -7629,6 +7659,7 @@ bool TTrain::Update( double const Deltatime )
else
btAKLVents.Turn(false);
if( true == lowvoltagepower ) {
// McZapkie-141102: SHP i czuwak, TODO: sygnalizacja kabinowa
if( mvOccupied->SecuritySystem.is_vigilance_blinking() ) {
@@ -8580,6 +8611,16 @@ TTrain::update_sounds( double const Deltatime ) {
}
}
// dzwiek wiatru rozbijajacego sie o szyby w kabinie
if (rsWindSound)
{
if (!FreeFlyModeFlag && !Global.CabWindowOpen && DynamicObject->GetVelocity() > 0.5)
update_sounds_resonancenoise(*rsWindSound);
else
rsWindSound->stop(FreeFlyModeFlag);
}
// dzwiek rezonansu (taki drugi runningnoise w sumie)
if (rsResonanceNoise)
{

5
Train.h
View File

@@ -278,6 +278,8 @@ class TTrain {
static void OnCommand_autosandboxactivate(TTrain *Train, command_data const &Command);
static void OnCommand_autosandboxdeactivate(TTrain *Train, command_data const &Command);
static void OnCommand_epbrakecontroltoggle( TTrain *Train, command_data const &Command );
static void OnCommand_epbrakecontrolenable( TTrain *Train, command_data const &Command );
static void OnCommand_epbrakecontroldisable( TTrain *Train, command_data const &Command );
static void OnCommand_trainbrakeoperationmodeincrease(TTrain *Train, command_data const &Command);
static void OnCommand_trainbrakeoperationmodedecrease(TTrain *Train, command_data const &Command);
static void OnCommand_brakeactingspeedincrease( TTrain *Train, command_data const &Command );
@@ -816,7 +818,8 @@ public: // reszta może by?publiczna
rsBrake,
rsFadeSound,
rsRunningNoise,
rsResonanceNoise, rsWindSound,
rsResonanceNoise,
rsWindSound,
rsHuntingNoise,
m_rainsound;
sound_source m_radiosound { sound_placement::internal, 2 * EU07_SOUND_CABCONTROLSCUTOFFRANGE }; // cached template for radio messages

3
application.cpp
View File

@@ -29,6 +29,9 @@ http://mozilla.org/MPL/2.0/.
#include "Timer.h"
#include "dictionary.h"
#include "version_info.h"
#include "ref/discord-rpc/include/discord_rpc.h"
#include <chrono>
#include "translation.h"
#if WITH_DISCORD_RPC
#include <discord_rpc.h>

294
driverkeyboardinput.cpp
View File

@@ -24,265 +24,267 @@ void
driverkeyboard_input::default_bindings() {
m_bindingsetups = {
{ user_command::aidriverenable, GLFW_KEY_Q | keymodifier::shift },
{ user_command::aidriverdisable, GLFW_KEY_Q },
{ user_command::aidriverenable, {GLFW_KEY_Q | keymodifier::shift, ""} },
{ user_command::aidriverdisable, {GLFW_KEY_Q, ""} },
// jointcontrollerset,
{ user_command::mastercontrollerincrease, GLFW_KEY_KP_ADD },
{ user_command::mastercontrollerincreasefast, GLFW_KEY_KP_ADD | keymodifier::shift },
{ user_command::mastercontrollerdecrease, GLFW_KEY_KP_SUBTRACT },
{ user_command::mastercontrollerdecreasefast, GLFW_KEY_KP_SUBTRACT | keymodifier::shift },
{ user_command::mastercontrollerincrease, {GLFW_KEY_KP_ADD, ""} },
{ user_command::mastercontrollerincreasefast, {GLFW_KEY_KP_ADD | keymodifier::shift, ""} },
{ user_command::mastercontrollerdecrease, {GLFW_KEY_KP_SUBTRACT, ""} },
{ user_command::mastercontrollerdecreasefast, {GLFW_KEY_KP_SUBTRACT | keymodifier::shift, ""} },
// mastercontrollerset,
{ user_command::secondcontrollerincrease, GLFW_KEY_KP_DIVIDE },
{ user_command::secondcontrollerincreasefast, GLFW_KEY_KP_DIVIDE | keymodifier::shift },
{ user_command::secondcontrollerdecrease, GLFW_KEY_KP_MULTIPLY },
{ user_command::secondcontrollerdecreasefast, GLFW_KEY_KP_MULTIPLY | keymodifier::shift },
{ user_command::secondcontrollerincrease, {GLFW_KEY_KP_DIVIDE, ""} },
{ user_command::secondcontrollerincreasefast, {GLFW_KEY_KP_DIVIDE | keymodifier::shift, ""} },
{ user_command::secondcontrollerdecrease, {GLFW_KEY_KP_MULTIPLY, ""} },
{ user_command::secondcontrollerdecreasefast, {GLFW_KEY_KP_MULTIPLY | keymodifier::shift, ""} },
// secondcontrollerset,
{ user_command::mucurrentindicatorothersourceactivate, GLFW_KEY_Z | keymodifier::shift },
{ user_command::independentbrakeincrease, GLFW_KEY_KP_1 },
{ user_command::independentbrakeincreasefast, GLFW_KEY_KP_1 | keymodifier::shift },
{ user_command::independentbrakedecrease, GLFW_KEY_KP_7 },
{ user_command::independentbrakedecreasefast, GLFW_KEY_KP_7 | keymodifier::shift },
{ user_command::mucurrentindicatorothersourceactivate, {GLFW_KEY_Z | keymodifier::shift, ""} },
{ user_command::independentbrakeincrease, {GLFW_KEY_KP_1, ""} },
{ user_command::independentbrakeincreasefast, {GLFW_KEY_KP_1 | keymodifier::shift, ""} },
{ user_command::independentbrakedecrease, {GLFW_KEY_KP_7, ""} },
{ user_command::independentbrakedecreasefast, {GLFW_KEY_KP_7 | keymodifier::shift, ""} },
// independentbrakeset,
{ user_command::independentbrakebailoff, GLFW_KEY_KP_4 },
{ user_command::independentbrakebailoff, {GLFW_KEY_KP_4, ""} },
// universalbrakebutton1,
// universalbrakebutton2,
// universalbrakebutton3,
{ user_command::trainbrakeincrease, GLFW_KEY_KP_3 },
{ user_command::trainbrakedecrease, GLFW_KEY_KP_9 },
{ user_command::trainbrakeincrease, {GLFW_KEY_KP_3, ""} },
{ user_command::trainbrakedecrease, {GLFW_KEY_KP_9, ""} },
// trainbrakeset,
{ user_command::trainbrakecharging, GLFW_KEY_KP_DECIMAL },
{ user_command::trainbrakerelease, GLFW_KEY_KP_6 },
{ user_command::trainbrakefirstservice, GLFW_KEY_KP_8 },
{ user_command::trainbrakeservice, GLFW_KEY_KP_5 },
{ user_command::trainbrakefullservice, GLFW_KEY_KP_2 },
{ user_command::trainbrakehandleoff, GLFW_KEY_KP_5 | keymodifier::control },
{ user_command::trainbrakeemergency, GLFW_KEY_KP_0 },
{ user_command::trainbrakebasepressureincrease, GLFW_KEY_KP_3 | keymodifier::control },
{ user_command::trainbrakebasepressuredecrease, GLFW_KEY_KP_9 | keymodifier::control },
{ user_command::trainbrakebasepressurereset, GLFW_KEY_KP_6 | keymodifier::control },
{ user_command::trainbrakeoperationtoggle, GLFW_KEY_KP_4 | keymodifier::control },
{ user_command::manualbrakeincrease, GLFW_KEY_KP_1 | keymodifier::control },
{ user_command::manualbrakedecrease, GLFW_KEY_KP_7 | keymodifier::control },
{ user_command::alarmchaintoggle, GLFW_KEY_B | keymodifier::shift | keymodifier::control },
{ user_command::trainbrakecharging, {GLFW_KEY_KP_DECIMAL, ""} },
{ user_command::trainbrakerelease, {GLFW_KEY_KP_6, ""} },
{ user_command::trainbrakefirstservice, {GLFW_KEY_KP_8, ""} },
{ user_command::trainbrakeservice, {GLFW_KEY_KP_5, ""} },
{ user_command::trainbrakefullservice, {GLFW_KEY_KP_2, ""} },
{ user_command::trainbrakehandleoff, {GLFW_KEY_KP_5 | keymodifier::control, ""} },
{ user_command::trainbrakeemergency, {GLFW_KEY_KP_0, ""} },
{ user_command::trainbrakebasepressureincrease, {GLFW_KEY_KP_3 | keymodifier::control, ""} },
{ user_command::trainbrakebasepressuredecrease, {GLFW_KEY_KP_9 | keymodifier::control, ""} },
{ user_command::trainbrakebasepressurereset, {GLFW_KEY_KP_6 | keymodifier::control, ""} },
{ user_command::trainbrakeoperationtoggle, {GLFW_KEY_KP_4 | keymodifier::control, ""} },
{ user_command::manualbrakeincrease, {GLFW_KEY_KP_1 | keymodifier::control, ""} },
{ user_command::manualbrakedecrease, {GLFW_KEY_KP_7 | keymodifier::control, ""} },
{ user_command::alarmchaintoggle, {GLFW_KEY_B | keymodifier::shift | keymodifier::control, ""} },
// alarmchainenable,
// alarmchaindisable,
{ user_command::wheelspinbrakeactivate, GLFW_KEY_KP_ENTER },
{ user_command::sandboxactivate, GLFW_KEY_S | keymodifier::shift },
{ user_command::wheelspinbrakeactivate, {GLFW_KEY_KP_ENTER, ""} },
{ user_command::sandboxactivate, {GLFW_KEY_S | keymodifier::shift, ""} },
// autosandboxtoggle,
// autosandboxactivate,
// autosandboxdeactivate,
{ user_command::reverserincrease, GLFW_KEY_D },
{ user_command::reverserdecrease, GLFW_KEY_R },
{ user_command::reverserincrease, {GLFW_KEY_D, ""} },
{ user_command::reverserdecrease, {GLFW_KEY_R, ""} },
// reverserforwardhigh,
// reverserforward,
// reverserneutral,
// reverserbackward,
{ user_command::waterpumpbreakertoggle, GLFW_KEY_W | keymodifier::control },
{ user_command::waterpumpbreakertoggle, {GLFW_KEY_W | keymodifier::control, ""} },
// waterpumpbreakerclose,
// waterpumpbreakeropen,
{ user_command::waterpumptoggle, GLFW_KEY_W },
{ user_command::waterpumptoggle, {GLFW_KEY_W, ""} },
// waterpumpenable,
// waterpumpdisable,
{ user_command::waterheaterbreakertoggle, GLFW_KEY_W | keymodifier::control | keymodifier::shift },
{ user_command::waterheaterbreakertoggle, {GLFW_KEY_W | keymodifier::control | keymodifier::shift, ""} },
// waterheaterbreakerclose,
// waterheaterbreakeropen,
{ user_command::waterheatertoggle, GLFW_KEY_W | keymodifier::shift },
{ user_command::waterheatertoggle, {GLFW_KEY_W | keymodifier::shift, ""} },
// waterheaterenable,
// waterheaterdisable,
{ user_command::watercircuitslinktoggle, GLFW_KEY_H | keymodifier::shift },
{ user_command::watercircuitslinktoggle, {GLFW_KEY_H | keymodifier::shift, ""} },
// watercircuitslinkenable,
// watercircuitslinkdisable,
{ user_command::fuelpumptoggle, GLFW_KEY_F },
{ user_command::fuelpumptoggle, {GLFW_KEY_F, ""} },
// fuelpumpenable,
// fuelpumpdisable,
{ user_command::oilpumptoggle, GLFW_KEY_F | keymodifier::shift },
{ user_command::oilpumptoggle, {GLFW_KEY_F | keymodifier::shift, ""} },
// oilpumpenable,
// oilpumpdisable,
{ user_command::linebreakertoggle, GLFW_KEY_M },
{ user_command::linebreakertoggle, {GLFW_KEY_M, ""} },
// linebreakeropen,
// linebreakerclose,
{ user_command::convertertoggle, GLFW_KEY_X },
{ user_command::convertertoggle, {GLFW_KEY_X, ""} },
// converterenable,
// converterdisable,
{ user_command::convertertogglelocal, GLFW_KEY_X | keymodifier::shift },
{ user_command::converteroverloadrelayreset, GLFW_KEY_N | keymodifier::control },
{ user_command::compressortoggle, GLFW_KEY_C },
{ user_command::convertertogglelocal, {GLFW_KEY_X | keymodifier::shift, ""} },
{ user_command::converteroverloadrelayreset, {GLFW_KEY_N | keymodifier::control, ""} },
{ user_command::compressortoggle, {GLFW_KEY_C, ""} },
// compressorenable,
// compressordisable,
{ user_command::compressortogglelocal, GLFW_KEY_C | keymodifier::shift },
{ user_command::compressortogglelocal, {GLFW_KEY_C | keymodifier::shift, ""} },
// compressorpresetactivatenext,
// compressorpresetactivateprevious,
// compressorpresetactivatedefault,
{ user_command::motoroverloadrelaythresholdtoggle, GLFW_KEY_F | keymodifier::control },
{ user_command::motoroverloadrelaythresholdtoggle, {GLFW_KEY_F | keymodifier::control, ""} },
// motoroverloadrelaythresholdsetlow,
// motoroverloadrelaythresholdsethigh,
{ user_command::motoroverloadrelayreset, GLFW_KEY_N },
{ user_command::motoroverloadrelayreset, {GLFW_KEY_N, ""} },
// universalrelayreset1,
// universalrelayreset2,
// universalrelayreset3,
{ user_command::notchingrelaytoggle, GLFW_KEY_G },
{ user_command::epbrakecontroltoggle, GLFW_KEY_Z | keymodifier::control },
{ user_command::trainbrakeoperationmodeincrease, GLFW_KEY_KP_2 | keymodifier::control },
{ user_command::trainbrakeoperationmodedecrease, GLFW_KEY_KP_8 | keymodifier::control },
{ user_command::brakeactingspeedincrease, GLFW_KEY_B | keymodifier::shift },
{ user_command::brakeactingspeeddecrease, GLFW_KEY_B },
{ user_command::notchingrelaytoggle, {GLFW_KEY_G, ""} },
{ user_command::epbrakecontroltoggle, {GLFW_KEY_Z | keymodifier::control, ""} },
// epbrakecontrolenable
// epbrakecontroldisable
{ user_command::trainbrakeoperationmodeincrease, {GLFW_KEY_KP_2 | keymodifier::control, ""} },
{ user_command::trainbrakeoperationmodedecrease, {GLFW_KEY_KP_8 | keymodifier::control, ""} },
{ user_command::brakeactingspeedincrease, {GLFW_KEY_B | keymodifier::shift, ""} },
{ user_command::brakeactingspeeddecrease, {GLFW_KEY_B, ""} },
// brakeactingspeedsetcargo,
// brakeactingspeedsetpassenger,
// brakeactingspeedsetrapid,
{ user_command::brakeloadcompensationincrease, GLFW_KEY_H | keymodifier::shift | keymodifier::control },
{ user_command::brakeloadcompensationdecrease, GLFW_KEY_H | keymodifier::control },
{ user_command::mubrakingindicatortoggle, GLFW_KEY_L | keymodifier::shift },
{ user_command::alerteracknowledge, GLFW_KEY_SPACE },
{ user_command::hornlowactivate, GLFW_KEY_A },
{ user_command::hornhighactivate, GLFW_KEY_S },
{ user_command::whistleactivate, GLFW_KEY_Z },
{ user_command::radiotoggle, GLFW_KEY_R | keymodifier::control },
{ user_command::brakeloadcompensationincrease, {GLFW_KEY_H | keymodifier::shift | keymodifier::control, ""} },
{ user_command::brakeloadcompensationdecrease, {GLFW_KEY_H | keymodifier::control, ""} },
{ user_command::mubrakingindicatortoggle, {GLFW_KEY_L | keymodifier::shift, ""} },
{ user_command::alerteracknowledge, {GLFW_KEY_SPACE, ""} },
{ user_command::hornlowactivate, {GLFW_KEY_A, ""} },
{ user_command::hornhighactivate, {GLFW_KEY_S, ""} },
{ user_command::whistleactivate, {GLFW_KEY_Z, ""} },
{ user_command::radiotoggle, {GLFW_KEY_R | keymodifier::control, ""} },
// radioenable
// radiodisable
{ user_command::radiochannelincrease, GLFW_KEY_EQUAL },
{ user_command::radiochanneldecrease, GLFW_KEY_MINUS },
{ user_command::radiochannelincrease, {GLFW_KEY_EQUAL, ""} },
{ user_command::radiochanneldecrease, {GLFW_KEY_MINUS, ""} },
// radiochannelset
{ user_command::radiostopsend, GLFW_KEY_PAUSE | keymodifier::shift | keymodifier::control },
{ user_command::radiostopsend, {GLFW_KEY_PAUSE | keymodifier::shift | keymodifier::control, ""} },
// radiostopenable
// radiostopdisable
{ user_command::radiostoptest, GLFW_KEY_R | keymodifier::shift | keymodifier::control },
{ user_command::radiocall3send, GLFW_KEY_BACKSPACE },
{ user_command::radiostoptest, {GLFW_KEY_R | keymodifier::shift | keymodifier::control, ""} },
{ user_command::radiocall3send, {GLFW_KEY_BACKSPACE, ""} },
// radiovolumeincrease,
// radiovolumedecrease,
// radiovolumeset,
{ user_command::cabchangeforward, GLFW_KEY_HOME },
{ user_command::cabchangebackward, GLFW_KEY_END },
{ user_command::cabchangeforward, {GLFW_KEY_HOME, ""} },
{ user_command::cabchangebackward, {GLFW_KEY_END, ""} },
// viewturn,
// movehorizontal,
// movehorizontalfast,
// movevertical,
// moveverticalfast,
{ user_command::moveleft, GLFW_KEY_LEFT },
{ user_command::moveright, GLFW_KEY_RIGHT },
{ user_command::moveforward, GLFW_KEY_UP },
{ user_command::moveback, GLFW_KEY_DOWN },
{ user_command::moveup, GLFW_KEY_PAGE_UP },
{ user_command::movedown, GLFW_KEY_PAGE_DOWN },
{ user_command::nearestcarcouplingincrease, GLFW_KEY_INSERT },
{ user_command::nearestcarcouplingdisconnect, GLFW_KEY_DELETE },
{ user_command::nearestcarcoupleradapterattach, GLFW_KEY_INSERT | keymodifier::control },
{ user_command::nearestcarcoupleradapterremove, GLFW_KEY_DELETE | keymodifier::control },
{ user_command::occupiedcarcouplingdisconnect, GLFW_KEY_DELETE | keymodifier::shift },
{ user_command::doortoggleleft, GLFW_KEY_COMMA },
{ user_command::doortoggleright, GLFW_KEY_PERIOD },
{ user_command::doorpermitleft, GLFW_KEY_COMMA | keymodifier::shift },
{ user_command::doorpermitright, GLFW_KEY_PERIOD | keymodifier::shift },
{ user_command::doorpermitpresetactivatenext, GLFW_KEY_PERIOD | keymodifier::shift | keymodifier::control },
{ user_command::doorpermitpresetactivateprevious, GLFW_KEY_COMMA | keymodifier::shift | keymodifier::control },
{ user_command::moveleft, {GLFW_KEY_LEFT, "Move left"} },
{ user_command::moveright, {GLFW_KEY_RIGHT, "Move right"} },
{ user_command::moveforward, {GLFW_KEY_UP, "Move forwards"} },
{ user_command::moveback, {GLFW_KEY_DOWN, "Move backwards"} },
{ user_command::moveup, {GLFW_KEY_PAGE_UP, "Move up"} },
{ user_command::movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} },
{ user_command::nearestcarcouplingincrease, {GLFW_KEY_INSERT, ""} },
{ user_command::nearestcarcouplingdisconnect, {GLFW_KEY_DELETE, ""} },
{ user_command::nearestcarcoupleradapterattach, {GLFW_KEY_INSERT | keymodifier::control, ""} },
{ user_command::nearestcarcoupleradapterremove, {GLFW_KEY_DELETE | keymodifier::control, ""} },
{ user_command::occupiedcarcouplingdisconnect, {GLFW_KEY_DELETE | keymodifier::shift, ""} },
{ user_command::doortoggleleft, {GLFW_KEY_COMMA, ""} },
{ user_command::doortoggleright, {GLFW_KEY_PERIOD, ""} },
{ user_command::doorpermitleft, {GLFW_KEY_COMMA | keymodifier::shift, ""} },
{ user_command::doorpermitright, {GLFW_KEY_PERIOD | keymodifier::shift, ""} },
{ user_command::doorpermitpresetactivatenext, {GLFW_KEY_PERIOD | keymodifier::shift | keymodifier::control, ""} },
{ user_command::doorpermitpresetactivateprevious, {GLFW_KEY_COMMA | keymodifier::shift | keymodifier::control, ""} },
// dooropenleft,
// dooropenright,
{ user_command::dooropenall, GLFW_KEY_SLASH | keymodifier::shift },
{ user_command::dooropenall, {GLFW_KEY_SLASH | keymodifier::shift, ""} },
// doorcloseleft,
// doorcloseright,
{ user_command::doorcloseall, GLFW_KEY_SLASH | keymodifier::control },
{ user_command::doorcloseall, {GLFW_KEY_SLASH | keymodifier::control, ""} },
// doorsteptoggle,
{ user_command::doormodetoggle, GLFW_KEY_SLASH | keymodifier::shift | keymodifier::control },
{ user_command::doormodetoggle, {GLFW_KEY_SLASH | keymodifier::shift | keymodifier::control, ""} },
// mirrorstoggle,
{ user_command::departureannounce, GLFW_KEY_SLASH },
{ user_command::doorlocktoggle, GLFW_KEY_S | keymodifier::control },
{ user_command::pantographcompressorvalvetoggle, GLFW_KEY_V | keymodifier::control },
{ user_command::departureannounce, {GLFW_KEY_SLASH, ""} },
{ user_command::doorlocktoggle, {GLFW_KEY_S | keymodifier::control, ""} },
{ user_command::pantographcompressorvalvetoggle, {GLFW_KEY_V | keymodifier::control, ""} },
// pantographcompressorvalveenable,
// pantographcompressorvalvedisable,
{ user_command::pantographcompressoractivate, GLFW_KEY_V | keymodifier::shift },
{ user_command::pantographtogglefront, GLFW_KEY_P },
{ user_command::pantographtogglerear, GLFW_KEY_O },
{ user_command::pantographcompressoractivate, {GLFW_KEY_V | keymodifier::shift, ""} },
{ user_command::pantographtogglefront, {GLFW_KEY_P, ""} },
{ user_command::pantographtogglerear, {GLFW_KEY_O, ""} },
// pantographraisefront,
// pantographraiserear,
// pantographlowerfront,
// pantographlowerrear,
{ user_command::pantographlowerall, GLFW_KEY_P | keymodifier::control },
{ user_command::pantographselectnext, GLFW_KEY_P | keymodifier::shift },
{ user_command::pantographselectprevious, GLFW_KEY_O | keymodifier::shift },
{ user_command::pantographtoggleselected, GLFW_KEY_O | keymodifier::shift | keymodifier::control },
{ user_command::pantographlowerall, {GLFW_KEY_P | keymodifier::control, ""} },
{ user_command::pantographselectnext, {GLFW_KEY_P | keymodifier::shift, ""} },
{ user_command::pantographselectprevious, {GLFW_KEY_O | keymodifier::shift, ""} },
{ user_command::pantographtoggleselected, {GLFW_KEY_O | keymodifier::shift | keymodifier::control, ""} },
// pantographraiseselected,
// pantographlowerselected,
// pantographvalvesupdate,
// pantographvalvesoff,
{ user_command::heatingtoggle, GLFW_KEY_H },
{ user_command::heatingtoggle, {GLFW_KEY_H, ""} },
// heatingenable,
// heatingdisable,
{ user_command::lightspresetactivatenext, GLFW_KEY_T | keymodifier::shift },
{ user_command::lightspresetactivateprevious, GLFW_KEY_T },
{ user_command::headlighttoggleleft, GLFW_KEY_Y },
{ user_command::lightspresetactivatenext, {GLFW_KEY_T | keymodifier::shift, ""} },
{ user_command::lightspresetactivateprevious, {GLFW_KEY_T, ""} },
{ user_command::headlighttoggleleft, {GLFW_KEY_Y, ""} },
// headlightenableleft,
// headlightdisableleft,
{ user_command::headlighttoggleright, GLFW_KEY_I },
{ user_command::headlighttoggleright, {GLFW_KEY_I, ""} },
// headlightenableright,
// headlightdisableright,
{ user_command::headlighttoggleupper, GLFW_KEY_U },
{ user_command::headlighttoggleupper, {GLFW_KEY_U, ""} },
// headlightenableupper,
// headlightdisableupper,
{ user_command::redmarkertoggleleft, GLFW_KEY_Y | keymodifier::shift },
{ user_command::redmarkertoggleleft, {GLFW_KEY_Y | keymodifier::shift, ""} },
// redmarkerenableleft,
// redmarkerdisableleft,
{ user_command::redmarkertoggleright, GLFW_KEY_I | keymodifier::shift },
{ user_command::redmarkertoggleright, {GLFW_KEY_I | keymodifier::shift, ""} },
// redmarkerenableright,
// redmarkerdisableright,
{ user_command::headlighttogglerearleft, GLFW_KEY_Y | keymodifier::control },
{ user_command::headlighttogglerearleft, {GLFW_KEY_Y | keymodifier::control, ""} },
// headlightenablerearleft
// headlightdisablerearleft
{ user_command::headlighttogglerearright, GLFW_KEY_I | keymodifier::control },
{ user_command::headlighttogglerearright, {GLFW_KEY_I | keymodifier::control, ""} },
// headlightenablerearright
// headlightdisablerearright
{ user_command::headlighttogglerearupper, GLFW_KEY_U | keymodifier::control },
{ user_command::headlighttogglerearupper, {GLFW_KEY_U | keymodifier::control, ""} },
// headlightenablerearupper
// headlightdisablerearupper
{ user_command::redmarkertogglerearleft, GLFW_KEY_Y | keymodifier::control | keymodifier::shift },
{ user_command::redmarkertogglerearleft, {GLFW_KEY_Y | keymodifier::control | keymodifier::shift, ""} },
// redmarkerenablerearleft
// redmarkerdisablerearleft
{ user_command::redmarkertogglerearright, GLFW_KEY_I | keymodifier::control | keymodifier::shift },
{ user_command::redmarkertogglerearright, {GLFW_KEY_I | keymodifier::control | keymodifier::shift, ""} },
// redmarkerenablerearright
// redmarkerdisablerearright
{ user_command::redmarkerstoggle, GLFW_KEY_E | keymodifier::shift },
{ user_command::endsignalstoggle, GLFW_KEY_E },
{ user_command::headlightsdimtoggle, GLFW_KEY_L | keymodifier::control },
{ user_command::redmarkerstoggle, {GLFW_KEY_E | keymodifier::shift, ""} },
{ user_command::endsignalstoggle, {GLFW_KEY_E, ""} },
{ user_command::headlightsdimtoggle, {GLFW_KEY_L | keymodifier::control, ""} },
// headlightsdimenable,
// headlightsdimdisable,
{ user_command::motorconnectorsopen, GLFW_KEY_L },
{ user_command::motorconnectorsopen, {GLFW_KEY_L, ""} },
// motorconnectorsclose,
{ user_command::motordisconnect, GLFW_KEY_E | keymodifier::control },
{ user_command::interiorlighttoggle, GLFW_KEY_APOSTROPHE },
{ user_command::motordisconnect, {GLFW_KEY_E | keymodifier::control, ""} },
{ user_command::interiorlighttoggle, {GLFW_KEY_APOSTROPHE, ""} },
// interiorlightenable,
// interiorlightdisable,
{ user_command::interiorlightdimtoggle, GLFW_KEY_APOSTROPHE | keymodifier::control },
{ user_command::interiorlightdimtoggle, {GLFW_KEY_APOSTROPHE | keymodifier::control, ""} },
// interiorlightdimenable,
// interiorlightdimdisable,
// compartmentlightstoggle,
// compartmentlightsenable,
// compartmentlightsdisable,
{ user_command::instrumentlighttoggle, GLFW_KEY_SEMICOLON },
{ user_command::instrumentlighttoggle, {GLFW_KEY_SEMICOLON, ""} },
// instrumentlightenable,
// instrumentlightdisable,
{ user_command::dashboardlighttoggle, GLFW_KEY_SEMICOLON | keymodifier::shift },
{ user_command::dashboardlighttoggle, {GLFW_KEY_SEMICOLON | keymodifier::shift, ""} },
// dashboardlightenable
// dashboardlightdisable
{ user_command::timetablelighttoggle, GLFW_KEY_APOSTROPHE | keymodifier::shift },
{ user_command::timetablelighttoggle, {GLFW_KEY_APOSTROPHE | keymodifier::shift, ""} },
// timetablelightenable
// timetablelightdisable
{ user_command::generictoggle0, GLFW_KEY_0 },
{ user_command::generictoggle1, GLFW_KEY_1 },
{ user_command::generictoggle2, GLFW_KEY_2 },
{ user_command::generictoggle3, GLFW_KEY_3 },
{ user_command::generictoggle4, GLFW_KEY_4 },
{ user_command::generictoggle5, GLFW_KEY_5 },
{ user_command::generictoggle6, GLFW_KEY_6 },
{ user_command::generictoggle7, GLFW_KEY_7 },
{ user_command::generictoggle8, GLFW_KEY_8 },
{ user_command::generictoggle9, GLFW_KEY_9 },
{ user_command::batterytoggle, GLFW_KEY_J },
{ user_command::generictoggle0, {GLFW_KEY_0, ""} },
{ user_command::generictoggle1, {GLFW_KEY_1, ""} },
{ user_command::generictoggle2, {GLFW_KEY_2, ""} },
{ user_command::generictoggle3, {GLFW_KEY_3, ""} },
{ user_command::generictoggle4, {GLFW_KEY_4, ""} },
{ user_command::generictoggle5, {GLFW_KEY_5, ""} },
{ user_command::generictoggle6, {GLFW_KEY_6, ""} },
{ user_command::generictoggle7, {GLFW_KEY_7, ""} },
{ user_command::generictoggle8, {GLFW_KEY_8, ""} },
{ user_command::generictoggle9, {GLFW_KEY_9, ""} },
{ user_command::batterytoggle, {GLFW_KEY_J, ""} },
// batteryenable,
// batterydisable,
// cabactivationtoggle,
// cabactivationenable,
// cabactivationdisable,
{ user_command::motorblowerstogglefront, GLFW_KEY_N | keymodifier::shift },
{ user_command::motorblowerstogglerear, GLFW_KEY_M | keymodifier::shift },
{ user_command::motorblowersdisableall, GLFW_KEY_M | keymodifier::control },
{ user_command::motorblowerstogglefront, {GLFW_KEY_N | keymodifier::shift, ""} },
{ user_command::motorblowerstogglerear, {GLFW_KEY_M | keymodifier::shift, ""} },
{ user_command::motorblowersdisableall, {GLFW_KEY_M | keymodifier::control, ""} },
// coolingfanstoggle,
// tempomattoggle,
// springbraketoggle,
@@ -308,14 +310,14 @@ driverkeyboard_input::default_bindings() {
// speedcontrolbutton8,
// speedcontrolbutton9,
// admin_timejump,
{ user_command::timejumplarge, GLFW_KEY_F1 | keymodifier::control },
{ user_command::timejumpsmall, GLFW_KEY_F1 | keymodifier::shift },
{ user_command::timejumplarge, {GLFW_KEY_F1 | keymodifier::control, "Big time jump (Debug Mode only)"} },
{ user_command::timejumpsmall, {GLFW_KEY_F1 | keymodifier::shift, "Small time jump (Debug Mode only)"} },
// admin_vehiclemove,
{ user_command::vehiclemoveforwards, GLFW_KEY_LEFT_BRACKET | keymodifier::control },
{ user_command::vehiclemovebackwards, GLFW_KEY_RIGHT_BRACKET | keymodifier::control },
{ user_command::vehicleboost, GLFW_KEY_TAB | keymodifier::control },
{ user_command::debugtoggle, GLFW_KEY_F12 | keymodifier::control | keymodifier::shift },
{ user_command::pausetoggle, GLFW_KEY_ESCAPE }
{ user_command::vehiclemoveforwards, {GLFW_KEY_LEFT_BRACKET | keymodifier::control, "Move the train forwards (Debug Mode only)"} },
{ user_command::vehiclemovebackwards, {GLFW_KEY_RIGHT_BRACKET | keymodifier::control, "Move the train backwards (Debug Mode only)"} },
{ user_command::vehicleboost, {GLFW_KEY_TAB | keymodifier::control, "Boost the train (Debug Mode only)"} },
{ user_command::debugtoggle, {GLFW_KEY_F12 | keymodifier::control | keymodifier::shift, "Toggle Debug Mode"} },
{ user_command::pausetoggle, {GLFW_KEY_ESCAPE, "Pause the game"} }
};
}

10
drivermouseinput.cpp
View File

@@ -281,8 +281,8 @@ drivermouse_input::move( double Mousex, double Mousey ) {
void
drivermouse_input::scroll( double const Xoffset, double const Yoffset ) {
if( Global.ctrlState || m_buttons[1] == GLFW_PRESS ) {
// ctrl + scroll wheel or holding right mouse button + scroll wheel adjusts fov
if( Global.ctrlState ) {
// ctrl + scroll wheel adjusts fov
Global.FieldOfView = clamp( static_cast<float>( Global.FieldOfView - Yoffset * 20.0 / Timer::subsystem.mainloop_total.average() ), 15.0f, 75.0f );
}
else {
@@ -638,6 +638,12 @@ drivermouse_input::default_bindings() {
{ "epbrake_bt:",{
user_command::epbrakecontroltoggle,
user_command::none } },
{ "epbrakeon_bt:",{
user_command::epbrakecontrolenable,
user_command::none } },
{ "epbrakeoff_bt:",{
user_command::epbrakecontroldisable,
user_command::none } },
{ "sand_bt:", {
user_command::sandboxactivate,
user_command::none } },

26
driveruipanels.cpp
View File

@@ -485,11 +485,13 @@ timetable_panel::render() {
| ImGuiWindowFlags_NoCollapse
| ( size.x > 0 ? ImGuiWindowFlags_NoResize : 0 );
// HACK: Make sure the timetable window is of correct width when using a larger font size.
float horizontalScale = Global.ui_fontsize / 13;
if( size.x > 0 ) {
ImGui::SetNextWindowSize( ImVec2S( size.x, size.y ) );
ImGui::SetNextWindowSize( ImVec2S( size.x * horizontalScale, size.y ) );
}
if( size_min.x > 0 ) {
ImGui::SetNextWindowSizeConstraints( ImVec2S( size_min.x, size_min.y ), ImVec2S( size_max.x, size_max.y ) );
ImGui::SetNextWindowSizeConstraints( ImVec2S( size_min.x * horizontalScale, size_min.y ), ImVec2S( size_max.x * horizontalScale, size_max.y ) );
}
auto const panelname { (
title.empty() ?
@@ -657,11 +659,25 @@ debug_panel::render_section_scenario() {
{
auto fogrange = std::log( Global.fFogEnd );
if( ImGui::SliderFloat(
( to_string( std::exp( fogrange ), 0, 5 ) + " m###fogend" ).c_str(), &fogrange, std::log( 10.0f ), std::log( 25000.0f ), "Fog distance" ) ) {
( to_string( std::exp( fogrange ), 0, 5 ) + " m###fogend" ).c_str(), &fogrange, std::log( 10.0f ), std::log( 50000.0f ), "Fog distance" ) ) {
command_relay relay;
relay.post(
user_command::setweather,
clamp( std::exp( fogrange ), 10.0f, 25000.0f ),
clamp( std::exp( fogrange ), 10.0f, 50000.0f ),
Global.Overcast,
GLFW_PRESS, 0 );
}
}
{
auto Airtemperature = Global.AirTemperature;
if (ImGui::SliderFloat(
(to_string(Airtemperature, 1) + " deg C###Airtemperature").c_str(),
&Airtemperature, -35.0f, 40.0f, "Air Temperature"))
{
command_relay relay;
relay.post(
user_command::settemperature,
clamp(Airtemperature, -35.0f, 40.0f),
Global.Overcast,
GLFW_PRESS, 0 );
}
@@ -1286,7 +1302,7 @@ debug_panel::update_section_scenario( std::vector<text_line> &Output ) {
Output.emplace_back( textline, Global.UITextColor );
// current luminance level
textline = "Light level: " + to_string( Global.fLuminance, 3 ) + ( Global.FakeLight ? "(*)" : "" );
textline = "Light level: " + to_string( Global.fLuminance, 3 ) + ( Global.FakeLight ? "(*)" : "" )+ to_string(Global.SunAngle,2);
textline +=
"\nWind: azimuth "
+ to_string( simulation::Environment.wind_azimuth(), 0 ) // ma być azymut, czyli 0 na północy i rośnie na wschód

12
editorkeyboardinput.cpp
View File

@@ -25,12 +25,12 @@ void
editorkeyboard_input::default_bindings() {
m_bindingsetups = {
{ user_command::moveleft, GLFW_KEY_LEFT },
{ user_command::moveright, GLFW_KEY_RIGHT },
{ user_command::moveforward, GLFW_KEY_UP },
{ user_command::moveback, GLFW_KEY_DOWN },
{ user_command::moveup, GLFW_KEY_PAGE_UP },
{ user_command::movedown, GLFW_KEY_PAGE_DOWN },
{ user_command::moveleft, {GLFW_KEY_LEFT, "Move left"} },
{ user_command::moveright, {GLFW_KEY_RIGHT, "Move right"} },
{ user_command::moveforward, {GLFW_KEY_UP, "Move forwards"} },
{ user_command::moveback, {GLFW_KEY_DOWN, "Move backwards"} },
{ user_command::moveup, {GLFW_KEY_PAGE_UP, "Move up"} },
{ user_command::movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} },
};
}

111
geometrybank.cpp
View File

@@ -9,6 +9,7 @@ http://mozilla.org/MPL/2.0/.
#include "stdafx.h"
#include "geometrybank.h"
#include "vertex.h"
#include "sn_utils.h"
#include "Logs.h"
@@ -16,6 +17,26 @@ http://mozilla.org/MPL/2.0/.
namespace gfx {
basic_vertex basic_vertex::convert(world_vertex const &world, glm::dvec3 const& origin)
{
basic_vertex vertex{};
vertex.position = static_cast<glm::vec3>(world.position - origin);
vertex.normal = world.normal;
vertex.texture = world.texture;
return vertex;
}
world_vertex basic_vertex::to_world(const glm::dvec3 &origin) const
{
world_vertex vertex{};
vertex.position = static_cast<glm::dvec3>(position) + origin;
vertex.normal = normal;
vertex.texture = texture;
return vertex;
}
void
basic_vertex::serialize( std::ostream &s, bool const Tangent ) const {
@@ -183,13 +204,17 @@ void calculate_tangents(vertex_array &vertices, index_array const &indices, int
}
}
void calculate_indices( index_array &Indices, vertex_array &Vertices, float tolerancescale ) {
void calculate_indices( index_array &Indices, vertex_array &Vertices, userdata_array &Userdata, float tolerancescale ) {
Indices.resize( Vertices.size() );
std::iota( std::begin( Indices ), std::end( Indices ), 0 );
// gather instances of used vertices, replace the original vertex bank with it after you're done
vertex_array indexedvertices;
vertex_array indexedvertices{};
userdata_array indexeduserdata{};
indexedvertices.reserve( std::max<size_t>( 100, Vertices.size() / 3 ) ); // optimistic guesstimate, but should reduce re-allocation somewhat
bool has_userdata = !Userdata.empty();
if (has_userdata)
indexeduserdata.reserve(std::max<size_t>(100, Userdata.size() / 3));
auto const matchtolerance { 1e-5f * tolerancescale };
for( auto idx = 0; idx < Indices.size(); ++idx ) {
if( Indices[ idx ] < idx ) {
@@ -200,31 +225,38 @@ void calculate_indices( index_array &Indices, vertex_array &Vertices, float tole
Indices[ idx ] = indexedvertices.size();
// see if there's any pointers in the remaining index subrange to similar enough vertices
// if found, remap these to use our current vertex instead
auto vertex { Vertices[ idx ] };
const auto& vertex { Vertices[ idx ] };
const auto* userdata{ has_userdata ? &Userdata[idx] : nullptr };
auto matchiter { std::cbegin( Vertices ) + idx };
auto matchuserdata = userdata;
for( auto matchidx = idx + 1; matchidx < Indices.size() && matchidx < idx + Global.iConvertIndexRange; ++matchidx ) {
++matchiter;
++matchuserdata;
if( ( glm::all( glm::epsilonEqual( vertex.position, matchiter->position, matchtolerance ) ) )
&& ( glm::all( glm::epsilonEqual( vertex.normal, matchiter->normal, matchtolerance ) ) )
&& ( glm::all( glm::epsilonEqual( vertex.texture, matchiter->texture, matchtolerance ) ) ) ) {
&& ( glm::all( glm::epsilonEqual( vertex.texture, matchiter->texture, matchtolerance ) ) )
&& ( !userdata || glm::all( glm::epsilonEqual( userdata->data, matchuserdata->data, matchtolerance ) ) ) ) {
Indices[ matchidx ] = Indices[ idx ];
}
}
indexedvertices.emplace_back( vertex );
if(userdata)
indexeduserdata.emplace_back( *userdata );
}
// done indexing, swap the source vertex bank with the processed one
Vertices.swap( indexedvertices );
Userdata.swap( indexeduserdata );
}
// generic geometry bank class, allows storage, update and drawing of geometry chunks
// creates a new geometry chunk of specified type from supplied data. returns: handle to the chunk or NULL
gfx::geometry_handle
geometry_bank::create( gfx::vertex_array &Vertices, unsigned int const Type ) {
geometry_bank::create( gfx::vertex_array &Vertices, userdata_array &Userdata, unsigned int const Type ) {
if( true == Vertices.empty() ) { return { 0, 0 }; }
if(Vertices.empty()) { return { 0, 0 }; }
m_chunks.emplace_back( Vertices, Type );
m_chunks.emplace_back( Vertices, Userdata, Type );
// NOTE: handle is effectively (index into chunk array + 1) this leaves value of 0 to serve as error/empty handle indication
gfx::geometry_handle chunkhandle { 0, static_cast<std::uint32_t>(m_chunks.size()) };
// template method implementation
@@ -235,11 +267,11 @@ geometry_bank::create( gfx::vertex_array &Vertices, unsigned int const Type ) {
// creates a new indexed geometry chunk of specified type from supplied data. returns: handle to the chunk or NULL
gfx::geometry_handle
geometry_bank::create( gfx::index_array &Indices, gfx::vertex_array &Vertices, unsigned int const Type ) {
geometry_bank::create( gfx::index_array &Indices, gfx::vertex_array &Vertices, userdata_array &Userdata, unsigned int const Type ) {
if( true == Vertices.empty() ) { return { 0, 0 }; }
if(Vertices.empty()) { return { 0, 0 }; }
m_chunks.emplace_back( Indices, Vertices, Type );
m_chunks.emplace_back( Indices, Vertices, Userdata, Type );
// NOTE: handle is effectively (index into chunk array + 1) this leaves value of 0 to serve as error/empty handle indication
gfx::geometry_handle chunkhandle { 0, static_cast<std::uint32_t>(m_chunks.size()) };
// template method implementation
@@ -250,7 +282,7 @@ geometry_bank::create( gfx::index_array &Indices, gfx::vertex_array &Vertices, u
// replaces data of specified chunk with the supplied vertex data, starting from specified offset
bool
geometry_bank::replace( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, std::size_t const Offset ) {
geometry_bank::replace( gfx::vertex_array &Vertices, userdata_array &Userdata, gfx::geometry_handle const &Geometry, std::size_t const Offset ) {
if( ( Geometry.chunk == 0 ) || ( Geometry.chunk > m_chunks.size() ) ) { return false; }
@@ -260,13 +292,16 @@ geometry_bank::replace( gfx::vertex_array &Vertices, gfx::geometry_handle const
&& ( Vertices.size() == chunk.vertices.size() ) ) {
// check first if we can get away with a simple swap...
chunk.vertices.swap( Vertices );
chunk.userdata.swap( Userdata );
}
else {
// ...otherwise we need to do some legwork
// NOTE: if the offset is larger than existing size of the chunk, it'll bridge the gap with 'blank' vertices
// TBD: we could bail out with an error instead if such request occurs
chunk.vertices.resize( Offset + Vertices.size(), gfx::basic_vertex() );
chunk.userdata.resize( Offset + Userdata.size(), gfx::vertex_userdata() );
chunk.vertices.insert( std::end( chunk.vertices ), std::begin( Vertices ), std::end( Vertices ) );
chunk.userdata.insert( std::end( chunk.userdata ), std::begin( Userdata ), std::end( Userdata ) );
}
// template method implementation
replace_( Geometry );
@@ -276,11 +311,11 @@ geometry_bank::replace( gfx::vertex_array &Vertices, gfx::geometry_handle const
// adds supplied vertex data at the end of specified chunk
bool
geometry_bank::append( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry ) {
geometry_bank::append( gfx::vertex_array &Vertices, userdata_array &Userdata, gfx::geometry_handle const &Geometry ) {
if( ( Geometry.chunk == 0 ) || ( Geometry.chunk > m_chunks.size() ) ) { return false; }
return replace( Vertices, Geometry, gfx::geometry_bank::chunk( Geometry ).vertices.size() );
return replace( Vertices, Userdata, Geometry, gfx::geometry_bank::chunk( Geometry ).vertices.size() );
}
// draws geometry stored in specified chunk
@@ -311,6 +346,13 @@ geometry_bank::vertices( gfx::geometry_handle const &Geometry ) const {
return geometry_bank::chunk( Geometry ).vertices;
}
// provides direct access to vertex user data of specfied chunk
userdata_array const &
geometry_bank::userdata( gfx::geometry_handle const &Geometry ) const {
return geometry_bank::chunk( Geometry ).userdata;
}
// geometry bank manager, holds collection of geometry banks
// performs a resource sweep
@@ -331,9 +373,9 @@ geometrybank_manager::register_bank(std::unique_ptr<geometry_bank> bank) {
// creates a new geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
geometrybank_manager::create_chunk(vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) {
geometrybank_manager::create_chunk(vertex_array &Vertices, userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type ) {
auto const newchunkhandle = bank( Geometry ).first->create( Vertices, Type );
auto const newchunkhandle = bank( Geometry ).first->create( Vertices, Userdata, Type );
if( newchunkhandle.chunk != 0 ) { return { Geometry.bank, newchunkhandle.chunk }; }
else { return { 0, 0 }; }
@@ -341,9 +383,9 @@ geometrybank_manager::create_chunk(vertex_array &Vertices, gfx::geometrybank_han
// creates a new indexed geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
geometrybank_manager::create_chunk( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, unsigned int const Type ) {
geometrybank_manager::create_chunk( gfx::index_array &Indices, gfx::vertex_array &Vertices, userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, unsigned int const Type ) {
auto const newchunkhandle = bank( Geometry ).first->create( Indices, Vertices, Type );
auto const newchunkhandle = bank( Geometry ).first->create( Indices, Vertices, Userdata, Type );
if( newchunkhandle.chunk != 0 ) { return { Geometry.bank, newchunkhandle.chunk }; }
else { return { 0, 0 }; }
@@ -351,16 +393,16 @@ geometrybank_manager::create_chunk( gfx::index_array &Indices, gfx::vertex_array
// replaces data of specified chunk with the supplied vertex data, starting from specified offset
bool
geometrybank_manager::replace( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, std::size_t const Offset ) {
geometrybank_manager::replace( gfx::vertex_array &Vertices, userdata_array &Userdata, gfx::geometry_handle const &Geometry, std::size_t const Offset ) {
return bank( Geometry ).first->replace( Vertices, Geometry, Offset );
return bank( Geometry ).first->replace( Vertices, Userdata, Geometry, Offset );
}
// adds supplied vertex data at the end of specified chunk
bool
geometrybank_manager::append( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry ) {
geometrybank_manager::append( gfx::vertex_array &Vertices, userdata_array &Userdata, gfx::geometry_handle const &Geometry ) {
return bank( Geometry ).first->append( Vertices, Geometry );
return bank( Geometry ).first->append( Vertices, Userdata, Geometry );
}
// draws geometry stored in specified chunk
void
@@ -388,4 +430,31 @@ geometrybank_manager::vertices( gfx::geometry_handle const &Geometry ) const {
return bank( Geometry ).first->vertices( Geometry );
}
// provides direct access to vertex user data of specfied chunk
gfx::userdata_array const &
geometrybank_manager::userdata( gfx::geometry_handle const &Geometry ) const {
return bank( Geometry ).first->userdata( Geometry );
}
void vertex_userdata::serialize(std::ostream &s) const
{
sn_utils::s_vec4(s, data);
}
void vertex_userdata::deserialize(std::istream &s)
{
data = sn_utils::d_vec4(s);
}
void vertex_userdata::serialize_packed(std::ostream &s) const
{
sn_utils::ls_uint64(s, glm::packHalf4x16(data));
}
void vertex_userdata::deserialize_packed(std::istream &s)
{
data = glm::unpackHalf4x16(sn_utils::ld_uint64(s));
}
} // namespace gfx

42
geometrybank.h
View File

@@ -11,6 +11,8 @@ http://mozilla.org/MPL/2.0/.
#include "ResourceManager.h"
struct world_vertex;
namespace gfx {
struct basic_vertex {
@@ -24,12 +26,22 @@ struct basic_vertex {
basic_vertex( glm::vec3 Position, glm::vec3 Normal, glm::vec2 Texture ) :
position( Position ), normal( Normal ), texture( Texture )
{}
static basic_vertex convert(world_vertex const &world, glm::dvec3 const &origin);
world_vertex to_world(glm::dvec3 const &origin = glm::dvec3(0.)) const;
void serialize( std::ostream&, bool const Tangent = false ) const;
void deserialize( std::istream&, bool const Tangent = false );
void serialize_packed( std::ostream&, bool const Tangent = false ) const;
void deserialize_packed( std::istream&, bool const Tangent = false );
};
struct vertex_userdata{
glm::vec4 data; // user data (for color or additional uv channels, not subject to post-processing)
void serialize( std::ostream& ) const;
void deserialize( std::istream& );
void serialize_packed( std::ostream& ) const;
void deserialize_packed( std::istream& );
};
// data streams carried in a vertex
enum stream {
none = 0x0,
@@ -50,10 +62,11 @@ struct stream_units {
using basic_index = std::uint32_t;
using vertex_array = std::vector<basic_vertex>;
using userdata_array = std::vector<vertex_userdata>;
using index_array = std::vector<basic_index>;
void calculate_tangents( vertex_array &vertices, index_array const &indices, int const type );
void calculate_indices( index_array &Indices, vertex_array &Vertices, float tolerancescale = 1.0f );
void calculate_indices( index_array &Indices, vertex_array &Vertices, userdata_array &Userdata, float tolerancescale = 1.0f );
// generic geometry bank class, allows storage, update and drawing of geometry chunks
@@ -97,13 +110,13 @@ public:
// methods:
// creates a new geometry chunk of specified type from supplied data. returns: handle to the chunk or NULL
auto create( gfx::vertex_array &Vertices, unsigned int const Type ) -> gfx::geometry_handle;
auto create( gfx::vertex_array &Vertices, gfx::userdata_array& Userdata, unsigned int const Type ) -> gfx::geometry_handle;
// creates a new indexed geometry chunk of specified type from supplied data. returns: handle to the chunk or NULL
auto create( gfx::index_array &Indices, gfx::vertex_array &Vertices, unsigned int const Type ) -> gfx::geometry_handle;
auto create( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::userdata_array& Userdata, unsigned int const Type ) -> gfx::geometry_handle;
// replaces vertex data of specified chunk with the supplied data, starting from specified offset
auto replace( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, std::size_t const Offset = 0 ) -> bool;
auto replace( gfx::vertex_array &Vertices, gfx::userdata_array& Userdata, gfx::geometry_handle const &Geometry, std::size_t const Offset = 0 ) -> bool;
// adds supplied vertex data at the end of specified chunk
auto append( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry ) -> bool;
auto append( gfx::vertex_array &Vertices, gfx::userdata_array& Userdata, gfx::geometry_handle const &Geometry ) -> bool;
// draws geometry stored in specified chunk
auto draw( gfx::geometry_handle const &Geometry, gfx::stream_units const &Units, unsigned int const Streams = basic_streams ) -> std::size_t;
// draws geometry stored in supplied list of chunks
@@ -119,6 +132,8 @@ public:
auto indices( gfx::geometry_handle const &Geometry ) const -> gfx::index_array const &;
// provides direct access to vertex data of specfied chunk
auto vertices( gfx::geometry_handle const &Geometry ) const -> gfx::vertex_array const &;
// provides direct access to vertex user data of specfied chunk
auto userdata( gfx::geometry_handle const &Geometry ) const -> gfx::userdata_array const &;
protected:
// types:
@@ -126,17 +141,20 @@ protected:
unsigned int type; // kind of geometry used by the chunk
gfx::vertex_array vertices; // geometry data
gfx::index_array indices; // index data
gfx::userdata_array userdata;
// NOTE: constructor doesn't copy provided geometry data, but moves it
geometry_chunk( gfx::vertex_array &Vertices, unsigned int Type ) :
geometry_chunk( gfx::vertex_array &Vertices, gfx::userdata_array& Userdata, unsigned int Type ) :
type( Type )
{
vertices.swap( Vertices );
userdata.swap( Userdata );
}
// NOTE: constructor doesn't copy provided geometry data, but moves it
geometry_chunk( gfx::index_array &Indices, gfx::vertex_array &Vertices, unsigned int Type ) :
geometry_chunk( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::userdata_array& Userdata, unsigned int Type ) :
type( Type )
{
vertices.swap( Vertices );
userdata.swap( Userdata );
indices.swap( Indices );
}
};
@@ -181,13 +199,13 @@ public:
// registers a new geometry bank. returns: handle to the bank
auto register_bank(std::unique_ptr<geometry_bank> bank) -> gfx::geometrybank_handle;
// creates a new geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
auto create_chunk( gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) -> gfx::geometry_handle;
auto create_chunk( gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type ) -> gfx::geometry_handle;
// creates a new indexed geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
auto create_chunk( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, unsigned int const Type ) -> gfx::geometry_handle;
auto create_chunk( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, unsigned int const Type ) -> gfx::geometry_handle;
// replaces data of specified chunk with the supplied vertex data, starting from specified offset
auto replace( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, std::size_t const Offset = 0 ) -> bool;
auto replace( gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, std::size_t const Offset = 0 ) -> bool;
// adds supplied vertex data at the end of specified chunk
auto append( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry ) -> bool;
auto append( gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry ) -> bool;
// draws geometry stored in specified chunk
void draw( gfx::geometry_handle const &Geometry, unsigned int const Streams = basic_streams );
template <typename Iterator_>
@@ -199,6 +217,8 @@ public:
auto indices( gfx::geometry_handle const &Geometry ) const -> gfx::index_array const &;
// provides direct access to vertex data of specfied chunk
auto vertices( gfx::geometry_handle const &Geometry ) const -> gfx::vertex_array const &;
// provides direct access to vertex data of specfied chunk
auto userdata( gfx::geometry_handle const &Geometry ) const -> gfx::userdata_array const &;
// sets target texture unit for the texture data stream
auto units() -> gfx::stream_units & { return m_units; }
// provides access to primitives count

2
gl/vao.cpp
View File

@@ -66,7 +66,7 @@ void gl::vao::bind()
glEnableVertexAttribArray(param.attrib);
}
for (size_t i = params.size(); i < 4; i++)
for (size_t i = params.size(); i < 5; i++)
glDisableVertexAttribArray(i);
if (ebo)

50
keyboardinput.cpp
View File

@@ -122,6 +122,7 @@ bool
keyboard_input::recall_bindings() {
cParser bindingparser( "eu07_input-keyboard.ini", cParser::buffer_FILE );
bindingparser.skipComments = false;
if( false == bindingparser.ok() ) {
return false;
}
@@ -147,6 +148,7 @@ keyboard_input::recall_bindings() {
std::string bindingentry;
bindingparser >> bindingentry;
cParser entryparser( bindingentry );
entryparser.skipComments = false;
if( true == entryparser.getTokens( 1, true, "\n\r\t " ) ) {
std::string commandname;
@@ -158,15 +160,30 @@ keyboard_input::recall_bindings() {
WriteLog( "Keyboard binding defined for unknown command, \"" + commandname + "\"" );
}
else {
int binding{ 0 };
int keycode = 0;
std::string description = "";
bool descriptionStarted = false;
while( entryparser.getTokens( 1, true, "\n\r\t " ) ) {
std::string bindingkeyname;
entryparser >> bindingkeyname;
if( bindingkeyname == "shift" ) { binding |= keymodifier::shift; }
else if( bindingkeyname == "ctrl" ) { binding |= keymodifier::control; }
else if( bindingkeyname == "none" ) { binding = 0; }
// Parse command description, starting with "//".
// TODO: At some point, rewind this and add translation keys instead for multilingual support.
// This can't be done now as by default this would destroy all command descriptions,
// which are used by Starter.
// Do this when szczawik's Starter becomes deprecated or implements command descriptions in some other way.
if (descriptionStarted) {
if (description.size() > 0) {
description += " ";
}
description += bindingkeyname;
} else if (bindingkeyname == "//") {
descriptionStarted = true;
} else {
if( bindingkeyname == "shift" ) { keycode |= keymodifier::shift; }
else if( bindingkeyname == "ctrl" ) { keycode |= keymodifier::control; }
else if( bindingkeyname == "none" ) { keycode = 0; }
else {
// regular key, convert it to glfw key code
auto const keylookup = nametokeymap.find( bindingkeyname );
@@ -177,17 +194,17 @@ keyboard_input::recall_bindings() {
else {
// replace any existing binding, preserve modifiers
// (protection from cases where there's more than one key listed in the entry)
binding = keylookup->second | ( binding & 0xffff0000 );
keycode = keylookup->second | ( keycode & 0xffff0000 );
}
}
}
if( ( binding & 0xffff ) != 0 ) {
std::tuple<int, std::string> binding{keycode, description};
m_bindingsetups.insert_or_assign(lookup->second, binding);
}
}
}
}
}
return true;
}
@@ -202,20 +219,25 @@ void keyboard_input::dump_bindings()
return;
}
for (const std::pair<user_command, int> &binding : m_bindingsetups) {
for (const std::pair<user_command, std::tuple<int, std::string>> &binding : m_bindingsetups) {
stream << simulation::Commands_descriptions[static_cast<std::size_t>(binding.first)].name << ' ';
auto it = keytonamemap.find(binding.second & 0xFFFF);
int keycode = std::get<int>(binding.second);
auto it = keytonamemap.find(keycode & 0xFFFF);
if (it != keytonamemap.end()) {
if (binding.second & keymodifier::control)
if (keycode & keymodifier::control)
stream << "ctrl ";
if (binding.second & keymodifier::shift)
if (keycode & keymodifier::shift)
stream << "shift ";
stream << it->second << "\r\n";
stream << it->second;
} else {
stream << "none\r\n";
stream << "none";
}
std::string description = std::get<std::string>(binding.second);
if (description.size() > 0)
stream << " // " << description << "\r\n";
}
}
@@ -295,7 +317,7 @@ keyboard_input::bind() {
for( auto const &bindingsetup : m_bindingsetups ) {
m_bindings[ bindingsetup.second ] = bindingsetup.first;
m_bindings[ std::get<int>(bindingsetup.second) ] = bindingsetup.first;
}
// cache movement key bindings

2
keyboardinput.h
View File

@@ -31,7 +31,7 @@ class keyboard_input {
public:
// types
using bindingsetup_sequence = std::map<user_command, int>;
using bindingsetup_sequence = std::map<user_command, std::tuple<int, std::string>>;
enum keymodifier : int {

27
launcher/keymapper.cpp
View File

@@ -21,8 +21,15 @@ bool ui::keymapper_panel::key(int key)
key |= keyboard_input::keymodifier::shift;
if (Global.ctrlState)
key |= keyboard_input::keymodifier::control;
// F10 unbinds the key.
if (it->second.compare("f10") == 0)
key = 0;
keyboard.bindings().insert_or_assign(bind_active, key);
// Replace the binding with a new key.
auto it2 = keyboard.bindings().find(bind_active);
if (it2 != keyboard.bindings().end()) {
it2->second = std::tuple<int, std::string>(key, std::get<std::string>(it2->second));
}
bind_active = user_command::none;
keyboard.bind();
@@ -45,18 +52,26 @@ void ui::keymapper_panel::render()
if (ImGui::Button(STR_C("Save")))
keyboard.dump_bindings();
for (const std::pair<user_command, int> &binding : keyboard.bindings()) {
for (const std::pair<user_command, std::tuple<int, std::string>> &binding : keyboard.bindings()) {
// Binding ID
ImGui::AlignTextToFramePadding();
ImGui::Text(simulation::Commands_descriptions[static_cast<std::size_t>(binding.first)].name.c_str());
// Binding description
std::string description = std::get<std::string>(binding.second);
ImGui::SameLine(260);
ImGui::Text((description.size() > 0 ? description : "(No description)").c_str());
// Binding key button
int keycode = std::get<int>(binding.second);
std::string label;
if (binding.second & keyboard_input::keymodifier::control)
if (keycode & keyboard_input::keymodifier::control)
label += "ctrl + ";
if (binding.second & keyboard_input::keymodifier::shift)
if (keycode & keyboard_input::keymodifier::shift)
label += "shift + ";
auto it = keyboard.keytonamemap.find(binding.second & 0xFFFF);
auto it = keyboard.keytonamemap.find(keycode & 0xFFFF);
if (it != keyboard.keytonamemap.end())
label += it->second;
@@ -64,7 +79,7 @@ void ui::keymapper_panel::render()
bool styles_pushed = false;
if (bind_active == binding.first) {
label = "?";
label = "Press key (F10 to unbind)";
ImVec4 active_col = ImGui::GetStyleColorVec4(ImGuiCol_ButtonActive);
ImGui::PushStyleColor(ImGuiCol_Button, active_col);
styles_pushed = true;

8
launcher/textures_scanner.cpp
View File

@@ -95,7 +95,7 @@ void ui::vehicles_bank::parse_category_entry(const std::string &param)
std::string mini;
std::getline(stream, mini, ',');
category_icons.emplace(ctx_type, "textures/mini/" + ToLower(mini));
category_icons.emplace(ctx_type, "textures/mini/" + ToLower(mini) + ".bmp");
}
void ui::vehicles_bank::parse_controllable_entry(const std::string &target, const std::string &param)
@@ -122,12 +122,12 @@ void ui::vehicles_bank::parse_texture_info(const std::string &target, const std:
set.meta = meta;
if (!mini.empty())
group_icons.emplace(mini, std::move(deferred_image("textures/mini/" + ToLower(mini))));
group_icons.emplace(mini, std::move(deferred_image("textures/mini/" + ToLower(mini) + ".bmp")));
if (!miniplus.empty())
set.mini = std::move(deferred_image("textures/mini/" + ToLower(miniplus)));
set.mini = std::move(deferred_image("textures/mini/" + ToLower(miniplus) + ".bmp"));
else if (!mini.empty())
set.mini = std::move(deferred_image("textures/mini/" + ToLower(mini)));
set.mini = std::move(deferred_image("textures/mini/" + ToLower(mini) + ".bmp"));
set.skin = ToLower(target);
erase_extension(set.skin);

2
launcher/vehicle_picker.h
View File

@@ -19,7 +19,7 @@ private:
std::shared_ptr<const vehicle_desc> selected_vehicle;
const std::string *selected_group = nullptr;
const skin_set *selected_skinset = nullptr;
bool display_by_groups = false;
bool display_by_groups = true;
deferred_image placeholder_mini;
std::array<char, 128> search_query = { 0 };

22
nullrenderer.h
View File

@@ -66,28 +66,25 @@ public:
gfx::geometrybank_handle
Create_Bank() override { return m_geometry.register_bank(std::make_unique<null_geometrybank>()); }
// creates a new indexed geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
Insert( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) override { return m_geometry.create_chunk( Indices, Vertices, Geometry, Type ); }
gfx::geometry_handle Insert(gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type) override {
return m_geometry.create_chunk( Indices, Vertices, Userdata, Geometry, Type ); }
// creates a new geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
Insert( gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) override {
gfx::geometry_handle Insert(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type) override {
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
return m_geometry.create_chunk(Vertices, Geometry, Type);
return m_geometry.create_chunk(Vertices, Userdata, Geometry, Type);
}
// replaces data of specified chunk with the supplied vertex data, starting from specified offset
bool
Replace( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type, std::size_t const Offset = 0 ) override {
bool Replace(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type, const std::size_t Offset = 0) override {
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
return m_geometry.replace(Vertices, Geometry, Offset);
return m_geometry.replace(Vertices, Userdata, Geometry, Offset);
}
// adds supplied vertex data at the end of specified chunk
bool
Append( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type ) override {
bool Append(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type) override {
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
return m_geometry.append(Vertices, Geometry);
return m_geometry.append(Vertices, Userdata, Geometry);
}
// provides direct access to index data of specfied chunk
gfx::index_array const &
@@ -95,6 +92,9 @@ public:
// provides direct access to vertex data of specfied chunk
gfx::vertex_array const &
Vertices( gfx::geometry_handle const &Geometry ) const override { return m_geometry.vertices(Geometry); }
// provides direct access to vertex data of specfied chunk
gfx::userdata_array const &
UserData( gfx::geometry_handle const &Geometry ) const override { return m_geometry.userdata(Geometry); }
// material methods
material_handle
Fetch_Material( std::string const &Filename, bool const Loadnow = true ) override {

27
opengl33geometrybank.cpp
View File

@@ -53,6 +53,7 @@ void opengl33_vaogeometrybank::setup_buffer()
vertexcount{ 0 },
indexcount{ 0 };
auto chunkiterator = m_chunks.cbegin();
bool has_userdata{ false };
for( auto &chunkrecord : m_chunkrecords ) {
// fill records for all chunks, based on the chunk data
chunkrecord.is_good = false; // if we're re-creating buffer, chunks might've been uploaded in the old one
@@ -61,7 +62,9 @@ void opengl33_vaogeometrybank::setup_buffer()
vertexcount += chunkrecord.vertex_count;
chunkrecord.index_offset = indexcount;
chunkrecord.index_count = chunkiterator->indices.size();
chunkrecord.has_userdata = !chunkiterator->userdata.empty();
indexcount += chunkrecord.index_count;
has_userdata |= chunkrecord.has_userdata;
++chunkiterator;
}
// the odds for all created chunks to get replaced with empty ones are quite low, but the possibility does exist
@@ -89,25 +92,33 @@ void opengl33_vaogeometrybank::setup_buffer()
m_vertexbuffer.emplace();
// NOTE: we're using static_draw since it's generally true for all we have implemented at the moment
// TODO: allow to specify usage hint at the object creation, and pass it here
m_vertexbuffer->allocate( gl::buffer::ARRAY_BUFFER, vertexcount * sizeof( gfx::basic_vertex ), GL_STATIC_DRAW );
const int vertex_size = has_userdata ? sizeof( gfx::basic_vertex ) + sizeof(gfx::vertex_userdata) : sizeof(gfx::basic_vertex);
m_vertexbuffer->allocate( gl::buffer::ARRAY_BUFFER, static_cast<int>(vertexcount * vertex_size), GL_STATIC_DRAW );
if( ::glGetError() == GL_OUT_OF_MEMORY ) {
ErrorLog( "openGL error: out of memory; failed to create a geometry buffer" );
throw std::bad_alloc();
}
m_vertex_count = static_cast<int>(vertexcount);
setup_attrib();
if(has_userdata)
setup_userdata();
}
void
opengl33_vaogeometrybank::setup_attrib(size_t offset)
{
m_vao->setup_attrib( *m_vertexbuffer, 0, 3, GL_FLOAT, sizeof( basic_vertex ), 0 * sizeof( float ) + offset * sizeof( basic_vertex ) );
m_vao->setup_attrib( *m_vertexbuffer, 0, 3, GL_FLOAT, sizeof( basic_vertex ), offsetof(basic_vertex, position) + offset * sizeof( basic_vertex ) );
// NOTE: normal and color streams share the data
m_vao->setup_attrib( *m_vertexbuffer, 1, 3, GL_FLOAT, sizeof( basic_vertex ), 3 * sizeof( float ) + offset * sizeof( basic_vertex ) );
m_vao->setup_attrib( *m_vertexbuffer, 2, 2, GL_FLOAT, sizeof( basic_vertex ), 6 * sizeof( float ) + offset * sizeof( basic_vertex ) );
m_vao->setup_attrib( *m_vertexbuffer, 3, 4, GL_FLOAT, sizeof( basic_vertex ), 8 * sizeof( float ) + offset * sizeof( basic_vertex ) );
m_vao->setup_attrib( *m_vertexbuffer, 1, 3, GL_FLOAT, sizeof( basic_vertex ), offsetof(basic_vertex, normal) + offset * sizeof( basic_vertex ) );
m_vao->setup_attrib( *m_vertexbuffer, 2, 2, GL_FLOAT, sizeof( basic_vertex ), offsetof(basic_vertex, texture) + offset * sizeof( basic_vertex ) );
m_vao->setup_attrib( *m_vertexbuffer, 3, 4, GL_FLOAT, sizeof( basic_vertex ), offsetof(basic_vertex, tangent) + offset * sizeof( basic_vertex ) );
}
void opengl33_vaogeometrybank::setup_userdata(size_t offset) {
const size_t offset_evaluated = m_vertex_count * sizeof(basic_vertex) + offset * sizeof( vertex_userdata );
m_vao->setup_attrib( *m_vertexbuffer, 4, 4, GL_FLOAT, sizeof( vertex_userdata ), offsetof(vertex_userdata, data) + offset_evaluated );}
// draw() subclass details
// NOTE: units and stream parameters are unused, but they're part of (legacy) interface
// TBD: specialized bank/manager pair without the cruft?
@@ -122,13 +133,17 @@ opengl33_vaogeometrybank::draw_( gfx::geometry_handle const &Geometry, gfx::stre
return 0;
auto const &chunk = gfx::geometry_bank::chunk( Geometry );
if( false == chunkrecord.is_good ) {
if( !chunkrecord.is_good ) {
m_vao->bind();
// we may potentially need to upload new buffer data before we can draw it
if( chunkrecord.index_count > 0 ) {
m_indexbuffer->upload( gl::buffer::ELEMENT_ARRAY_BUFFER, chunk.indices.data(), chunkrecord.index_offset * sizeof( gfx::basic_index ), chunkrecord.index_count * sizeof( gfx::basic_index ) );
}
m_vertexbuffer->upload( gl::buffer::ARRAY_BUFFER, chunk.vertices.data(), chunkrecord.vertex_offset * sizeof( gfx::basic_vertex ), chunkrecord.vertex_count * sizeof( gfx::basic_vertex ) );
if(chunkrecord.has_userdata)
m_vertexbuffer->upload(gl::buffer::ARRAY_BUFFER, chunk.userdata.data(),
static_cast<int>(m_vertex_count * sizeof(gfx::basic_vertex) + chunkrecord.vertex_offset * sizeof(gfx::vertex_userdata)),
static_cast<int>(chunkrecord.vertex_count * sizeof(gfx::vertex_userdata)));
chunkrecord.is_good = true;
}
// render

4
opengl33geometrybank.h
View File

@@ -37,6 +37,7 @@ private:
std::size_t vertex_count{ 0 }; // size of the chunk in the last established buffer
std::size_t index_offset{ 0 };
std::size_t index_count{ 0 };
bool has_userdata{ false };
bool is_good{ false }; // true if local content of the chunk matches the data on the opengl end
};
@@ -59,6 +60,8 @@ private:
setup_buffer();
void
setup_attrib(size_t offset = 0);
void
setup_userdata(size_t offset = 0);
void
delete_buffer();
@@ -67,6 +70,7 @@ private:
std::optional<gl::buffer> m_indexbuffer; // index buffer data on the opengl end
std::optional<gl::vao> m_vao;
chunkrecord_sequence m_chunkrecords; // helper data for all stored geometry chunks, in matching order
int m_vertex_count;
};
} // namespace gfx

25
opengl33renderer.cpp
View File

@@ -113,7 +113,8 @@ bool opengl33_renderer::Init(GLFWwindow *Window)
gfx::vertex_array billboard_array{
{{-size, size, 0.f}, glm::vec3(), {1.f, 1.f}}, {{size, size, 0.f}, glm::vec3(), {0.f, 1.f}}, {{-size, -size, 0.f}, glm::vec3(), {1.f, 0.f}}, {{size, -size, 0.f}, glm::vec3(), {0.f, 0.f}}};
m_billboardgeometry = m_geometry.create_chunk(billboard_array, geometrybank, GL_TRIANGLE_STRIP);
gfx::userdata_array userdata{};
m_billboardgeometry = m_geometry.create_chunk(billboard_array, userdata, geometrybank, GL_TRIANGLE_STRIP);
m_empty_vao = std::make_unique<gl::vao>();
try
@@ -1967,34 +1968,34 @@ gfx::geometrybank_handle opengl33_renderer::Create_Bank()
}
// creates a new indexed geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle opengl33_renderer::Insert( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type )
gfx::geometry_handle opengl33_renderer::Insert(gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type)
{
// NOTE: we expect indexed geometry to come with calculated tangents
return m_geometry.create_chunk( Indices, Vertices, Geometry, Type );
return m_geometry.create_chunk( Indices, Vertices, Userdata, Geometry, Type );
}
// creates a new geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle opengl33_renderer::Insert(gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type)
gfx::geometry_handle opengl33_renderer::Insert(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type)
{
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
return m_geometry.create_chunk(Vertices, Geometry, Type);
return m_geometry.create_chunk(Vertices, Userdata, Geometry, Type);
}
// replaces data of specified chunk with the supplied vertex data, starting from specified offset
bool opengl33_renderer::Replace(gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type, std::size_t const Offset)
bool opengl33_renderer::Replace(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type, const std::size_t Offset)
{
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
return m_geometry.replace(Vertices, Geometry, Offset);
return m_geometry.replace(Vertices, Userdata, Geometry, Offset);
}
// adds supplied vertex data at the end of specified chunk
bool opengl33_renderer::Append(gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type)
bool opengl33_renderer::Append(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type)
{
gfx::calculate_tangents(Vertices, gfx::index_array(), Type);
return m_geometry.append(Vertices, Geometry);
return m_geometry.append(Vertices, Userdata, Geometry);
}
// provides direct access to index data of specfied chunk
@@ -2009,6 +2010,11 @@ gfx::vertex_array const &opengl33_renderer::Vertices(gfx::geometry_handle const
return m_geometry.vertices(Geometry);
}
gfx::userdata_array const &opengl33_renderer::UserData(const gfx::geometry_handle &Geometry) const
{
return m_geometry.userdata(Geometry);
}
// material methods
material_handle opengl33_renderer::Fetch_Material(std::string const &Filename, bool const Loadnow)
{
@@ -4865,3 +4871,4 @@ void opengl33_renderer::opengl33_imgui_renderer::Render()
gl::buffer::unbind(gl::buffer::ARRAY_BUFFER);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
}

15
opengl33renderer.h
View File

@@ -58,23 +58,22 @@ class opengl33_renderer : public gfx_renderer {
gfx::geometrybank_handle
Create_Bank() override;
// creates a new indexed geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
Insert( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) override;
gfx::geometry_handle Insert(gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type) override;
// creates a new geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
Insert( gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) override;
gfx::geometry_handle Insert(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type) override;
// replaces data of specified chunk with the supplied vertex data, starting from specified offset
bool
Replace( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type, std::size_t const Offset = 0 ) override;
bool Replace(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type, const std::size_t Offset = 0) override;
// adds supplied vertex data at the end of specified chunk
bool
Append( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type ) override;
bool Append(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type) override;
// provides direct access to index data of specfied chunk
gfx::index_array const &
Indices( gfx::geometry_handle const &Geometry ) const override;
// provides direct access to vertex data of specfied chunk
gfx::vertex_array const &
Vertices( gfx::geometry_handle const &Geometry ) const override;
// provides direct access to vertex data of specfied chunk
gfx::userdata_array const &
UserData( gfx::geometry_handle const &Geometry ) const override;
// material methods
material_handle
Fetch_Material( std::string const &Filename, bool const Loadnow = true ) override;

8
openglgeometrybank.cpp
View File

@@ -227,7 +227,7 @@ void
opengl_vbogeometrybank::bind_streams( gfx::stream_units const &Units, unsigned int const Streams, size_t offset ) {
if( Streams & gfx::stream::position ) {
::glVertexPointer( 3, GL_FLOAT, sizeof( gfx::basic_vertex ), reinterpret_cast<void const *>( sizeof( gfx::basic_vertex ) * offset ) );
::glVertexPointer( 3, GL_FLOAT, sizeof( gfx::basic_vertex ), reinterpret_cast<void const *>( offsetof(gfx::basic_vertex, position) + sizeof( gfx::basic_vertex ) * offset ) );
::glEnableClientState( GL_VERTEX_ARRAY );
}
else {
@@ -235,14 +235,14 @@ opengl_vbogeometrybank::bind_streams( gfx::stream_units const &Units, unsigned i
}
// NOTE: normal and color streams share the data, making them effectively mutually exclusive
if( Streams & gfx::stream::normal ) {
::glNormalPointer( GL_FLOAT, sizeof( gfx::basic_vertex ), reinterpret_cast<void const *>( 12 + sizeof( gfx::basic_vertex ) * offset ) );
::glNormalPointer( GL_FLOAT, sizeof( gfx::basic_vertex ), reinterpret_cast<void const *>( offsetof(gfx::basic_vertex, normal) + sizeof( gfx::basic_vertex ) * offset ) );
::glEnableClientState( GL_NORMAL_ARRAY );
}
else {
::glDisableClientState( GL_NORMAL_ARRAY );
}
if( Streams & gfx::stream::color ) {
::glColorPointer( 3, GL_FLOAT, sizeof( gfx::basic_vertex ), reinterpret_cast<void const *>( 12 + sizeof( gfx::basic_vertex ) * offset ) );
::glColorPointer( 3, GL_FLOAT, sizeof( gfx::basic_vertex ), reinterpret_cast<void const *>( offsetof(gfx::basic_vertex, normal) + sizeof( gfx::basic_vertex ) * offset ) );
::glEnableClientState( GL_COLOR_ARRAY );
}
else {
@@ -251,7 +251,7 @@ opengl_vbogeometrybank::bind_streams( gfx::stream_units const &Units, unsigned i
if( Streams & gfx::stream::texture ) {
for( auto unit : Units.texture ) {
::glClientActiveTexture( GL_TEXTURE0 + unit );
::glTexCoordPointer( 2, GL_FLOAT, sizeof( gfx::basic_vertex ), reinterpret_cast<void const *>( 24 + sizeof( gfx::basic_vertex ) * offset ) );
::glTexCoordPointer( 2, GL_FLOAT, sizeof( gfx::basic_vertex ), reinterpret_cast<void const *>( offsetof(gfx::basic_vertex, texture) + sizeof( gfx::basic_vertex ) * offset ) );
::glEnableClientState( GL_TEXTURE_COORD_ARRAY );
}
m_activetexturearrays = Units.texture;

33
openglrenderer.cpp
View File

@@ -308,7 +308,8 @@ opengl_renderer::Init( GLFWwindow *Window ) {
{ { size, size, 0.f }, glm::vec3(), { 0.f, 1.f } },
{ { -size, -size, 0.f }, glm::vec3(), { 1.f, 0.f } },
{ { size, -size, 0.f }, glm::vec3(), { 0.f, 0.f } } };
m_billboardgeometry = m_geometry.create_chunk(billboard_array, geometrybank, GL_TRIANGLE_STRIP);
gfx::userdata_array userdata{};
m_billboardgeometry = m_geometry.create_chunk(billboard_array, userdata, geometrybank, GL_TRIANGLE_STRIP);
// prepare debug mode objects
//m_quadric = ::gluNewQuadric();
//::gluQuadricNormals( m_quadric, GLU_FLAT );
@@ -1691,31 +1692,31 @@ opengl_renderer::Create_Bank() {
}
// creates a new indexed geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
opengl_renderer::Insert( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) {
gfx::geometry_handle opengl_renderer::Insert(gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type)
{
return m_geometry.create_chunk( Indices, Vertices, Geometry, Type );
return m_geometry.create_chunk( Indices, Vertices, Userdata, Geometry, Type );
}
// creates a new geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
opengl_renderer::Insert( gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) {
gfx::geometry_handle opengl_renderer::Insert(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type)
{
return m_geometry.create_chunk( Vertices, Geometry, Type );
return m_geometry.create_chunk( Vertices, Userdata, Geometry, Type );
}
// replaces data of specified chunk with the supplied vertex data, starting from specified offset
bool
opengl_renderer::Replace( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type, std::size_t const Offset ) {
bool opengl_renderer::Replace(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type, const std::size_t Offset)
{
return m_geometry.replace( Vertices, Geometry, Offset );
return m_geometry.replace( Vertices, Userdata, Geometry, Offset );
}
// adds supplied vertex data at the end of specified chunk
bool
opengl_renderer::Append( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type ) {
bool opengl_renderer::Append(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type)
{
return m_geometry.append( Vertices, Geometry );
return m_geometry.append( Vertices, Userdata, Geometry );
}
// provides direct access to vertex data of specfied chunk
@@ -1732,6 +1733,11 @@ opengl_renderer::Vertices( gfx::geometry_handle const &Geometry ) const {
return m_geometry.vertices( Geometry );
}
gfx::userdata_array const &opengl_renderer::UserData(const gfx::geometry_handle &Geometry) const
{
return m_geometry.userdata( Geometry );
}
// material methods
material_handle
opengl_renderer::Fetch_Material( std::string const &Filename, bool const Loadnow ) {
@@ -4539,3 +4545,4 @@ void opengl_renderer::opengl_imgui_renderer::Render()
gl::buffer::unbind(gl::buffer::ARRAY_BUFFER);
ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
}

15
openglrenderer.h
View File

@@ -58,23 +58,22 @@ public:
gfx::geometrybank_handle
Create_Bank() override;
// creates a new indexed geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
Insert( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) override;
gfx::geometry_handle Insert(gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type) override;
// creates a new geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
gfx::geometry_handle
Insert( gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) override;
gfx::geometry_handle Insert(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type) override;
// replaces data of specified chunk with the supplied vertex data, starting from specified offset
bool
Replace( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type, std::size_t const Offset = 0 ) override;
bool Replace(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type, const std::size_t Offset = 0) override;
// adds supplied vertex data at the end of specified chunk
bool
Append( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type ) override;
bool Append(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type) override;
// provides direct access to index data of specfied chunk
gfx::index_array const &
Indices( gfx::geometry_handle const &Geometry ) const override;
// provides direct access to vertex data of specfied chunk
gfx::vertex_array const &
Vertices( gfx::geometry_handle const &Geometry ) const override;
// provides direct access to vertex data of specfied chunk
gfx::userdata_array const &
UserData( gfx::geometry_handle const &Geometry ) const override;
// material methods
material_handle
Fetch_Material( std::string const &Filename, bool const Loadnow = true ) override;

2
parser.cpp
View File

@@ -203,7 +203,7 @@ std::string cParser::readToken( bool ToLower, const char *Break ) {
token += c;
if( findQuotes( token ) ) // do glue together words enclosed in quotes
continue;
if( trimComments( token ) ) // don't glue together words separated with comment
if( skipComments && trimComments( token ) ) // don't glue together words separated with comment
break;
}
if( c == '\n' ) {

3
parser.h
View File

@@ -91,6 +91,8 @@ class cParser //: public std::stringstream
// returns number of currently processed line in main file, -1 if inside include
int LineMain() const;
bool expandIncludes = true;
bool allowRandomIncludes = false;
bool skipComments = true;
private:
// methods:
@@ -118,7 +120,6 @@ class cParser //: public std::stringstream
std::shared_ptr<cParser> mIncludeParser; // child class to handle include directives.
std::vector<std::string> parameters; // parameter list for included file.
std::deque<std::string> tokens;
bool allowRandomIncludes = false;
};

10
renderer.h
View File

@@ -41,17 +41,19 @@ public:
// creates a new geometry bank. returns: handle to the bank or NULL
virtual auto Create_Bank() -> gfx::geometrybank_handle = 0;
// creates a new indexed geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
virtual auto Insert( gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) -> gfx::geometry_handle = 0;
virtual auto Insert(gfx::index_array &Indices, gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type) -> gfx::geometry_handle = 0;
// creates a new geometry chunk of specified type from supplied data, in specified bank. returns: handle to the chunk or NULL
virtual auto Insert( gfx::vertex_array &Vertices, gfx::geometrybank_handle const &Geometry, int const Type ) -> gfx::geometry_handle = 0;
virtual auto Insert(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometrybank_handle const &Geometry, int const Type) -> gfx::geometry_handle = 0;
// replaces data of specified chunk with the supplied vertex data, starting from specified offset
virtual auto Replace( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type, std::size_t const Offset = 0 ) -> bool = 0;
virtual auto Replace(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type, const std::size_t Offset = 0) -> bool = 0;
// adds supplied vertex data at the end of specified chunk
virtual auto Append( gfx::vertex_array &Vertices, gfx::geometry_handle const &Geometry, int const Type ) -> bool = 0;
virtual auto Append(gfx::vertex_array &Vertices, gfx::userdata_array &Userdata, gfx::geometry_handle const &Geometry, int const Type) -> bool = 0;
// provides direct access to index data of specfied chunk
virtual auto Indices( gfx::geometry_handle const &Geometry ) const->gfx::index_array const & = 0;
// provides direct access to vertex data of specfied chunk
virtual auto Vertices( gfx::geometry_handle const &Geometry ) const ->gfx::vertex_array const & = 0;
// provides direct access to vertex user data of specfied chunk
virtual auto UserData( gfx::geometry_handle const &Geometry ) const ->gfx::userdata_array const & = 0;
// material methods
virtual auto Fetch_Material( std::string const &Filename, bool const Loadnow = true ) -> material_handle = 0;
virtual void Bind_Material( material_handle const Material, TSubModel const *sm = nullptr, lighting_data const *lighting = nullptr ) = 0;

10
scene.cpp
View File

@@ -26,7 +26,7 @@ namespace scene {
std::string const EU07_FILEEXTENSION_REGION { ".sbt" };
std::uint32_t const EU07_FILEHEADER { MAKE_ID4( 'E','U','0','7' ) };
std::uint32_t const EU07_FILEVERSION_REGION { MAKE_ID4( 'S', 'B', 'T', 1 ) };
std::uint32_t const EU07_FILEVERSION_REGION { MAKE_ID4( 'S', 'B', 'T', '2' ) };
// potentially activates event handler with the same name as provided node, and within handler activation range
void
@@ -962,10 +962,11 @@ basic_section::create_geometry() {
void basic_section::create_map_geometry(const gfx::geometrybank_handle handle)
{
std::vector<gfx::basic_vertex> lines;
gfx::userdata_array userdata{};
for (auto &cell : m_cells)
cell.create_map_geometry(lines, handle);
m_map_geometryhandle = GfxRenderer->Insert(lines, handle, GL_LINES);
m_map_geometryhandle = GfxRenderer->Insert(lines, userdata, handle, GL_LINES);
}
void basic_section::get_map_active_paths(map_colored_paths &handles)
@@ -1727,15 +1728,16 @@ void basic_region::create_map_geometry()
void basic_region::update_poi_geometry()
{
std::vector<gfx::basic_vertex> vertices;
gfx::userdata_array userdata;
for (const auto sem : map::Objects.entries)
vertices.push_back(std::move(sem->vertex()));
if (!m_map_poipoints) {
gfx::geometrybank_handle poibank = GfxRenderer->Create_Bank();
m_map_poipoints = GfxRenderer->Insert(vertices, poibank, GL_POINTS);
m_map_poipoints = GfxRenderer->Insert(vertices, userdata, poibank, GL_POINTS);
}
else {
GfxRenderer->Replace(vertices, m_map_poipoints, GL_POINTS);
GfxRenderer->Replace(vertices, userdata, m_map_poipoints, GL_POINTS);
}
}

74
scenenode.cpp
View File

@@ -62,12 +62,14 @@ void
shape_node::shapenode_data::serialize( std::ostream &Output ) const {
// bounding area
area.serialize( Output );
bool has_userdata = !userdata.empty();
// visibility
sn_utils::ls_float64( Output, rangesquared_min );
sn_utils::ls_float64( Output, rangesquared_max );
sn_utils::s_bool( Output, visible );
// material
sn_utils::s_bool( Output, translucent );
sn_utils::s_bool( Output, has_userdata );
// NOTE: material handle is created dynamically on load
sn_utils::s_str(
Output,
@@ -80,12 +82,12 @@ shape_node::shapenode_data::serialize( std::ostream &Output ) const {
// NOTE: geometry handle is created dynamically on load
// vertex count, followed by vertex data
sn_utils::ls_uint32( Output, vertices.size() );
for( auto const &vertex : vertices ) {
gfx::basic_vertex(
glm::vec3{ vertex.position - origin },
vertex.normal,
vertex.texture )
.serialize( Output );
for( int i = 0; i < vertices.size(); ++i ) {
gfx::basic_vertex::convert(vertices[i], origin)
.serialize( Output, false );
if(has_userdata){
userdata[i].serialize(Output);
}
}
}
@@ -100,6 +102,7 @@ shape_node::shapenode_data::deserialize( std::istream &Input ) {
visible = sn_utils::d_bool( Input );
// material
translucent = sn_utils::d_bool( Input );
bool has_userdata = sn_utils::d_bool( Input );
auto const materialname { sn_utils::d_str( Input ) };
if( false == materialname.empty() ) {
material = GfxRenderer->Fetch_Material( materialname );
@@ -110,12 +113,14 @@ shape_node::shapenode_data::deserialize( std::istream &Input ) {
// NOTE: geometry handle is acquired during geometry creation
// vertex data
vertices.resize( sn_utils::ld_uint32( Input ) );
if(has_userdata)
userdata.resize(vertices.size());
gfx::basic_vertex localvertex;
for( auto &vertex : vertices ) {
localvertex.deserialize( Input );
vertex.position = origin + glm::dvec3{ localvertex.position };
vertex.normal = localvertex.normal;
vertex.texture = localvertex.texture;
for( int i = 0; i < vertices.size(); ++i ) {
localvertex.deserialize( Input, false );
vertices[i] = localvertex.to_world(origin);
if(has_userdata)
userdata[i].deserialize( Input );
}
}
@@ -352,29 +357,53 @@ shape_node::convert( TSubModel const *Submodel ) {
int vertexcount { 0 };
std::vector<world_vertex> importedvertices;
gfx::userdata_array importeduserdata;
if(!GfxRenderer->Indices(Submodel->m_geometry.handle).empty()){
const auto& vertices = GfxRenderer->Vertices(Submodel->m_geometry.handle);
const auto& userdatas = GfxRenderer->UserData(Submodel->m_geometry.handle);
bool has_userdata = !userdatas.empty();
world_vertex vertex;
for(const auto index : GfxRenderer->Indices(Submodel->m_geometry.handle)){
vertex = vertices[index].to_world();
importedvertices.emplace_back(vertex);
if (has_userdata)
importeduserdata.emplace_back(userdatas[index]);
}
}
else{
world_vertex vertex, vertex1, vertex2;
for( auto const &sourcevertex : GfxRenderer->Vertices( Submodel->m_geometry.handle ) ) {
vertex.position = sourcevertex.position;
vertex.normal = sourcevertex.normal;
vertex.texture = sourcevertex.texture;
if( vertexcount == 0 ) { vertex1 = vertex; }
else if( vertexcount == 1 ) { vertex2 = vertex; }
gfx::vertex_userdata userdata, userdata1, userdata2;
const auto& vertices = GfxRenderer->Vertices(Submodel->m_geometry.handle);
const auto& userdatas = GfxRenderer->UserData(Submodel->m_geometry.handle);
bool has_userdata = !userdatas.empty();
for( int i = 0; i < vertices.size(); ++i ) {
vertex = vertices[i].to_world();
if( has_userdata ) userdata = userdatas[i];
if( vertexcount == 0 ) { vertex1 = vertex; userdata1 = userdata; }
else if( vertexcount == 1 ) { vertex2 = vertex; userdata2 = userdata; }
else if( vertexcount >= 2 ) {
if( false == degenerate( vertex1.position, vertex2.position, vertex.position ) ) {
if( !degenerate( vertex1.position, vertex2.position, vertex.position ) ) {
importedvertices.emplace_back( vertex1 );
importedvertices.emplace_back( vertex2 );
importedvertices.emplace_back( vertex );
if( has_userdata ) {
importeduserdata.emplace_back( userdata1 );
importeduserdata.emplace_back( userdata2 );
importeduserdata.emplace_back( userdata );
}
}
// start a new triangle
vertexcount = -1;
}
++vertexcount;
}
}
if( true == importedvertices.empty() ) { return *this; }
// assign imported geometry to the node...
m_data.vertices.swap( importedvertices );
m_data.userdata.swap( importeduserdata );
// ...and calculate center...
for( auto const &vertex : m_data.vertices ) {
m_data.area.center += vertex.position;
@@ -423,12 +452,9 @@ shape_node::create_geometry( gfx::geometrybank_handle const &Bank ) {
gfx::vertex_array vertices; vertices.reserve( m_data.vertices.size() );
for( auto const &vertex : m_data.vertices ) {
vertices.emplace_back(
vertex.position - m_data.origin,
vertex.normal,
vertex.texture );
vertices.emplace_back(gfx::basic_vertex::convert(vertex, m_data.origin));
}
m_data.geometry = GfxRenderer->Insert( vertices, Bank, GL_TRIANGLES );
m_data.geometry = GfxRenderer->Insert(vertices, m_data.userdata, Bank, GL_TRIANGLES);
std::vector<world_vertex>().swap( m_data.vertices ); // hipster shrink_to_fit
}
@@ -657,7 +683,7 @@ lines_node::create_geometry( gfx::geometrybank_handle const &Bank ) {
vertex.normal,
vertex.texture );
}
m_data.geometry = GfxRenderer->Insert( vertices, Bank, GL_LINES );
m_data.geometry = GfxRenderer->Insert( vertices, m_data.userdata, Bank, GL_LINES );
std::vector<world_vertex>().swap( m_data.vertices ); // hipster shrink_to_fit
}

2
scenenode.h
View File

@@ -96,6 +96,7 @@ public:
glm::highp_dvec3 origin; // world position of the relative coordinate system origin
gfx::geometry_handle geometry { 0, 0 }; // relative origin-centered chunk of geometry held by gfx renderer
std::vector<world_vertex> vertices; // world space source data of the geometry
gfx::userdata_array userdata;
// methods:
// sends content of the struct to provided stream
void
@@ -191,6 +192,7 @@ public:
glm::dvec3 origin; // world position of the relative coordinate system origin
gfx::geometry_handle geometry { 0, 0 }; // relative origin-centered chunk of geometry held by gfx renderer
std::vector<world_vertex> vertices; // world space source data of the geometry
gfx::userdata_array userdata;
// methods:
// sends content of the struct to provided stream
void

2
shaders/color.frag
View File

@@ -12,7 +12,7 @@ layout(location = 1) out vec4 out_motion;
void main()
{
vec3 col = pow(f_color.rgb, vec3(2.2));
vec3 col = clamp(pow(f_color.rgb, vec3(2.2)),0, 1);
#if POSTFX_ENABLED
out_color = vec4(apply_fog(col), 1.0f);
#else

3
shaders/vertex.vert
View File

@@ -2,6 +2,7 @@ layout(location = 0) in vec3 v_vert;
layout(location = 1) in vec3 v_normal;
layout(location = 2) in vec2 v_coord;
layout(location = 3) in vec4 v_tangent;
layout(location = 4) in vec4 v_userdata;
#include <common>
@@ -18,6 +19,7 @@ out vec4 f_clip_future_pos;
//out vec3 TangentLightPos;
//out vec3 TangentViewPos;
out vec3 TangentFragPos;
out vec4 UserData;
void main()
{
@@ -43,4 +45,5 @@ void main()
// TangentLightPos = TBN * f_light_pos.xyz;
// TangentViewPos = TBN * vec3(0.0, 0.0, 0.0);
TangentFragPos = TBN * f_pos.xyz;
UserData = v_userdata;
}

2
simulation.cpp
View File

@@ -339,6 +339,8 @@ void state_manager::process_commands() {
if (commanddata.command == user_command::settemperature) {
Global.AirTemperature = commanddata.param1;
Global.Overcast = commanddata.param2;
simulation::Environment.compute_weather();
}
if (commanddata.command == user_command::insertmodel) {

32
simulationenvironment.cpp
View File

@@ -66,9 +66,23 @@ world_environment::compute_weather() {
Global.Overcast <= 0.50 ? "scattered:" :
Global.Overcast <= 0.90 ? "broken:" :
Global.Overcast <= 1.00 ? "overcast:" :
( Global.Season != "winter:" ?
"rain:" :
(Global.AirTemperature > 1 ? "rain:" :
"snow:" ) );
Global.fTurbidity = (
Global.Overcast <= 0.10 ? 3 :
Global.Overcast <= 0.20 ? 4 :
Global.Overcast <= 0.30 ? 5 :
Global.Overcast <= 0.40 ? 5 :
Global.Overcast <= 0.50 ? 5 :
Global.Overcast <= 0.60 ? 5 :
Global.Overcast <= 0.70 ? 6 :
Global.Overcast <= 0.80 ? 7 :
Global.Overcast <= 0.90 ? 8 :
Global.Overcast > 0.90 ? 9 :
9
);
}
void
@@ -120,7 +134,9 @@ world_environment::update() {
float keylightintensity;
glm::vec3 keylightcolor;
if( moonlightlevel > sunlightlevel ) {
Global.SunAngle = m_sun.getAngle();
if ((moonlightlevel > sunlightlevel) && (Global.SunAngle <(-20)))
{
// rare situations when the moon is brighter than the sun, typically at night
Global.SunAngle = m_moon.getAngle();
Global.DayLight.position = m_moon.getDirection();
@@ -139,10 +155,10 @@ world_environment::update() {
keylightintensity = sunlightlevel;
m_lightintensity = 1.0f;
// include 'golden hour' effect in twilight lighting
float const duskfactor = 1.0f - clamp( Global.SunAngle, 0.0f, 18.0f ) / 18.0f;
float const duskfactor = 1.25f - clamp( Global.SunAngle, 0.0f, 18.0f ) / 18.0f;
keylightcolor = interpolate(
glm::vec3( 255.0f / 255.0f, 242.0f / 255.0f, 231.0f / 255.0f ),
glm::vec3( 235.0f / 255.0f, 140.0f / 255.0f, 36.0f / 255.0f ),
glm::vec3( 235.0f / 255.0f, 120.0f / 255.0f, 36.0f / 255.0f ),
duskfactor );
}
// ...retrieve current sky colour and brightness...
@@ -174,9 +190,9 @@ world_environment::update() {
// update the fog. setting it to match the average colour of the sky dome is cheap
// but quite effective way to make the distant items blend with background better
Global.FogColor =
interpolate( m_skydome.GetAverageColor(), m_skydome.GetAverageHorizonColor(), 0.25f )
* clamp<float>( Global.fLuminance, 0.25f, 1.f );
Global.FogColor = ((m_skydome.GetAverageHorizonColor()) * keylightcolor) *
clamp<float>(Global.fLuminance, 0.0f, 1.f);
// weather-related simulation factors
Global.FrictionWeatherFactor = (

20
skydome.cpp
View File

@@ -10,8 +10,8 @@
// by A. J. Preetham Peter Shirley Brian Smits (University of Utah)
float CSkyDome::m_distributionluminance[ 5 ][ 2 ] = { // Perez distributions
{ 0.17872f , -1.46303f }, // a = darkening or brightening of the horizon
{ -0.35540f , 0.42749f }, // b = luminance gradient near the horizon,
{ 0.17872f , -1.66303f }, // a = darkening or brightening of the horizon
{ -0.35540f , 0.42750f }, // b = luminance gradient near the horizon,
{ -0.02266f , 5.32505f }, // c = relative intensity of the circumsolar region
{ 0.12064f , -2.57705f }, // d = width of the circumsolar region
{ -0.06696f , 0.37027f } // e = relative backscattered light
@@ -48,8 +48,8 @@ CSkyDome::CSkyDome (int const Tesselation) :
m_tesselation( Tesselation ) {
// SetSunPosition( Math3D::vector3(75.0f, 0.0f, 0.0f) );
SetTurbidity( 3.0f );
SetExposure( true, 20.0f );
SetTurbidity( Global.fTurbidity );
SetExposure( true, 10.0f );
SetOvercastFactor( 0.05f );
Generate();
}
@@ -109,7 +109,7 @@ void CSkyDome::Generate() {
}
void CSkyDome::Update( glm::vec3 const &Sun ) {
SetTurbidity(Global.fTurbidity);
if( true == SetSunPosition( Sun ) ) {
// build colors if there's a change in sun position
RebuildColors();
@@ -134,7 +134,7 @@ bool CSkyDome::SetSunPosition( glm::vec3 const &Direction ) {
void CSkyDome::SetTurbidity( float const Turbidity ) {
m_turbidity = clamp( Turbidity, 1.f, 4.f );
m_turbidity = clamp( Turbidity, 1.f, 128.f );
}
void CSkyDome::SetExposure( bool const Linearexposure, float const Expfactor ) {
@@ -296,20 +296,20 @@ void CSkyDome::RebuildColors() {
color.y = 0.65f * color.z;
}
// simple gradient, darkening towards the top
color *= clamp( ( 1.25f - vertex.y ), 0.f, 1.f );
// color *= ( 1.25f - vertex.y );
color *= clamp( ( 1.0f - vertex.y ), 0.f, 1.f );
//color *= ( 0.25f - vertex.y );
// gamma correction
color = glm::pow( color, gammacorrection );
m_colours[ i ] = color;
averagecolor += color;
if( ( m_vertices.size() - i ) <= ( m_tesselation * 3 + 3 ) ) {
if( ( m_vertices.size() - i ) <= ( m_tesselation * 10 + 10 ) ) {
// calculate horizon colour from the bottom band of tris
averagehorizoncolor += color;
}
}
m_averagecolour = glm::max( glm::vec3(), averagecolor / static_cast<float>( m_vertices.size() ) );
m_averagehorizoncolour = glm::max( glm::vec3(), averagehorizoncolor / static_cast<float>( m_tesselation * 3 + 3 ) );
m_averagehorizoncolour = glm::max( glm::vec3(), averagehorizoncolor / static_cast<float>( m_tesselation * 10 + 10 ) );
m_dirty = true;
}

3
widgets/map.cpp
View File

@@ -621,7 +621,8 @@ void ui::obstacle_insert_window::render_content()
std::vector<gfx::basic_vertex> vertices;
vertices.emplace_back(std::move(obstacle->vertex()));
GfxRenderer->Append(vertices, simulation::Region->get_map_poi_geometry(), GL_POINTS);
gfx::userdata_array userdata{};
GfxRenderer->Append(vertices, userdata, simulation::Region->get_map_poi_geometry(), GL_POINTS);
map::Objects.entries.push_back(std::move(obstacle));