gauge animation precision fix, visualization fix for turntable animations, mouse control repeat rate tweak, rudimentary framebuffer implementation

Button.cpp

@@ -14,13 +14,6 @@ http://mozilla.org/MPL/2.0/.
 #include "Console.h"
 #include "logs.h"
 
-TButton::TButton()
-{
-    iFeedbackBit = 0;
-    bData = NULL;
-    Clear();
-};
-
 void TButton::Clear(int i)
 {
     pModelOn = nullptr;

Button.h

@@ -36,7 +36,7 @@ class TButton
         play( PSound Sound );
 
   public:
-    TButton();
+    TButton() = default;
     void Clear(int const i = -1);
     inline void FeedbackBitSet(int const i) {
         iFeedbackBit = 1 << i; };

Gauge.cpp

@@ -180,7 +180,7 @@ void TGauge::DecValue(double fNewDesired)
 void
 TGauge::UpdateValue( double fNewDesired, PSound Fallbacksound ) {
 
-    if( static_cast<int>( std::round( ( fDesiredValue - fOffset ) / fScale ) ) == static_cast<int>( fNewDesired ) ) {
+    if( static_cast<int>( std::round( 100.0 * ( fDesiredValue - fOffset ) / fScale ) ) == static_cast<int>( 100.0 * fNewDesired ) ) {
         return;
     }
     fDesiredValue = fNewDesired * fScale + fOffset;

Globals.cpp

@@ -87,6 +87,7 @@ float Global::Overcast { 0.1f }; // NOTE: all this weather stuff should be moved
 opengl_light Global::DayLight;
 int Global::DynamicLightCount { 3 };
 bool Global::ScaleSpecularValues { true };
+bool Global::RenderShadows { false };
 bool Global::bRollFix = true; // czy wykonać przeliczanie przechyłki
 bool Global::bJoinEvents = false; // czy grupować eventy o tych samych nazwach
 int Global::iHiddenEvents = 1; // czy łączyć eventy z torami poprzez nazwę toru
@@ -544,6 +545,11 @@ void Global::ConfigParse(cParser &Parser)
             Parser.getTokens();
             Parser >> Global::ScaleSpecularValues;
         }
+        else if( token == "shadows" ) {
+            // shadow render toggle
+            Parser.getTokens();
+            Parser >> Global::RenderShadows;
+        }
         else if (token == "smoothtraction")
         {
             // podwójna jasność ambient

Globals.h

@@ -226,6 +226,7 @@ class Global
     static opengl_light DayLight;
     static int DynamicLightCount;
     static bool ScaleSpecularValues;
+    static bool RenderShadows;
 
     static int iSlowMotion;
     static TDynamicObject *changeDynObj;

Track.cpp

@@ -1267,31 +1267,32 @@ void TTrack::create_geometry( geometrybank_handle const &Bank ) {
                 }
                 vertex_array vertices;
                 Segment->RenderLoft(vertices, origin, bpts1, iTrapezoid ? -4 : 4, fTexLength);
+                if( ( Bank != 0 ) && ( true == Geometry2.empty() ) ) {
+                    Geometry2.emplace_back( GfxRenderer.Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
+                }
                 if( ( Bank == 0 ) && ( false == Geometry2.empty() ) ) {
                     // special variant, replace existing data for a turntable track
                     GfxRenderer.Replace( vertices, Geometry2[ 0 ] );
                 }
-                else {
-                    Geometry2.emplace_back( GfxRenderer.Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
-                }
             }
             if (TextureID1)
             { // szyny - generujemy dwie, najwyżej rysować się będzie jedną
                 vertex_array vertices;
+                if( ( Bank != 0 ) && ( true == Geometry1.empty() ) ) {
+                    Segment->RenderLoft( vertices, origin, rpts1, iTrapezoid ? -nnumPts : nnumPts, fTexLength );
+                    Geometry1.emplace_back( GfxRenderer.Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
+                    vertices.clear(); // reuse the scratchpad
+                    Segment->RenderLoft( vertices, origin, rpts2, iTrapezoid ? -nnumPts : nnumPts, fTexLength );
+                    Geometry1.emplace_back( GfxRenderer.Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
+                }
                 if( ( Bank == 0 ) && ( false == Geometry1.empty() ) ) {
+                    // special variant, replace existing data for a turntable track
                     Segment->RenderLoft( vertices, origin, rpts1, iTrapezoid ? -nnumPts : nnumPts, fTexLength );
                     GfxRenderer.Replace( vertices, Geometry1[ 0 ] );
                     vertices.clear(); // reuse the scratchpad
                     Segment->RenderLoft( vertices, origin, rpts2, iTrapezoid ? -nnumPts : nnumPts, fTexLength );
                     GfxRenderer.Replace( vertices, Geometry1[ 1 ] );
                 }
-                else {
-                    Segment->RenderLoft( vertices, origin, rpts1, iTrapezoid ? -nnumPts : nnumPts, fTexLength );
-                    Geometry1.emplace_back( GfxRenderer.Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
-                    vertices.clear(); // reuse the scratchpad
-                    Segment->RenderLoft( vertices, origin, rpts2, iTrapezoid ? -nnumPts : nnumPts, fTexLength );
-                    Geometry1.emplace_back( GfxRenderer.Insert( vertices, Bank, GL_TRIANGLE_STRIP ) );
-                }
             }
             break;
         case tt_Switch: // dla zwrotnicy dwa razy szyny

mouseinput.cpp

@@ -125,9 +125,11 @@ mouse_input::button( int const Button, int const Action ) {
                     // TODO: pass correct entity id once the missing systems are in place
                     m_relay.post( mousecommand, 0, 0, Action, 0 );
                     m_updateaccumulator = 0.0; // prevent potential command repeat right after issuing one
+/*
                     if( mousecommand == user_command::mastercontrollerincrease ) {
                         m_updateaccumulator -= 0.15; // extra pause on first increase of master controller
                     }
+*/
                     switch( mousecommand ) {
                         case user_command::mastercontrollerincrease:
                         case user_command::mastercontrollerdecrease:

renderer.cpp

@@ -120,10 +120,9 @@ opengl_renderer::Init( GLFWwindow *Window ) {
         m_lights.emplace_back( light );
     }
 #ifdef EU07_USE_PICKING_FRAMEBUFFER
+    // pick buffer resources
     if( true == m_framebuffersupport ) {
-        // try to create the pick buffer. RGBA8 2D texture, 24 bit depth texture, 1024x512
+        // try to create the pick buffer. RGBA8 2D texture, 24 bit depth texture, 1024x1024 (height of 512 would suffice but, eh)
-        int const width { 1024 };
-        int const height { 512 };
         // texture
         ::glGenTextures( 1, &m_picktexture );
         ::glBindTexture( GL_TEXTURE_2D, m_picktexture );
@@ -131,18 +130,17 @@ opengl_renderer::Init( GLFWwindow *Window ) {
         ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
         ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
         ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
-        ::glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL );
+        ::glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, m_pickbuffersize, m_pickbuffersize, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL );
         // depth buffer
         ::glGenRenderbuffersEXT( 1, &m_pickdepthbuffer );
         ::glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_pickdepthbuffer );
-        ::glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, width, height );
+        ::glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, m_pickbuffersize, m_pickbuffersize );
-        // create and set up the framebuffer
+        // create and assemble the framebuffer
         ::glGenFramebuffersEXT( 1, &m_pickframebuffer );
         ::glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_pickframebuffer );
         ::glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_picktexture, 0 );
         ::glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_pickdepthbuffer );
-        //-------------------------
+        // check if we got it working
-        //Does the GPU support current FBO configuration?
         GLenum status = ::glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );
         if( status == GL_FRAMEBUFFER_COMPLETE_EXT ) {
             WriteLog( "Picking framebuffer setup complete" );
@@ -154,6 +152,41 @@ opengl_renderer::Init( GLFWwindow *Window ) {
         ::glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ); // switch back to primary render target for now
     }
 #endif
+    // shadowmap resources
+    if( ( true == Global::RenderShadows )
+     && ( true == m_framebuffersupport ) ) {
+        // texture:
+        ::glGenTextures( 1, &m_shadowtexture );
+        ::glBindTexture( GL_TEXTURE_2D, m_shadowtexture );
+        ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+        ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+        ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+        ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+        // enable shadow comparison: true (ie not in shadow) if r<=texture...
+        ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE );
+        ::glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL );
+        // ...shadow comparison should generate an INTENSITY result
+        ::glTexParameteri( GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY );
+        ::glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, m_shadowbuffersize, m_shadowbuffersize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL );
+        // create and assemble the framebuffer
+        ::glGenFramebuffersEXT( 1, &m_shadowframebuffer );
+        ::glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_shadowframebuffer );
+        ::glDrawBuffer( GL_NONE ); // we won't be rendering colour data, so can skip the colour attachment
+        ::glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, m_shadowtexture, 0 );
+        // check if we got it working
+        GLenum status = ::glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );
+        if( status == GL_FRAMEBUFFER_COMPLETE_EXT ) {
+            WriteLog( "Shadows framebuffer setup complete" );
+        }
+        else {
+            ErrorLog( "Shadows framebuffer setup failed" );
+            m_framebuffersupport = false;
+            Global::RenderShadows = false;
+        }
+        ::glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ); // switch back to primary render target for now
+        ::glDrawBuffer( GL_BACK );
+    }
+
     ::glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
     // preload some common textures
     WriteLog( "Loading common gfx data..." );
@@ -205,7 +238,9 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
 
             // TODO: run shadowmap pass before color
 
-//            ::glViewport( 0, 0, Global::ScreenWidth, Global::ScreenHeight );
+#ifdef EU07_USE_PICKING_FRAMEBUFFER
+            ::glViewport( 0, 0, Global::ScreenWidth, Global::ScreenHeight );
+#endif
             if( World.InitPerformed() ) {
                 auto const skydomecolour = World.Environment.m_skydome.GetAverageColor();
                 ::glClearColor( skydomecolour.x, skydomecolour.y, skydomecolour.z, 0.0f ); // kolor nieba
@@ -234,9 +269,33 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
             break;
         }
 
+        case rendermode::shadows: {
+
+#ifdef EU07_USE_PICKING_FRAMEBUFFER
+            ::glViewport( 0, 0, m_pickbuffersize, m_pickbuffersize ); // TODO: separate shadow buffer
+#endif
+            ::glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
+            ::glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+            if( World.InitPerformed() ) {
+                // setup
+                m_renderpass.draw_range = 500.0f; // 1.5km square centered around camera
+                Render_projection();
+                Render_camera();
+                ::glDepthFunc( GL_LEQUAL );
+                // render
+                // opaque parts...
+                Render_setup();
+                Render( &World.Ground );
+            }
+            break;
+        }
+
         case rendermode::pickcontrols: {
 
-//            ::glViewport( 0, 0, 1024, 512 );
+#ifdef EU07_USE_PICKING_FRAMEBUFFER
+            ::glViewport( 0, 0, m_pickbuffersize, m_pickbuffersize );
+#endif
             ::glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
             ::glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
@@ -259,7 +318,9 @@ opengl_renderer::Render_pass( rendermode const Mode ) {
 
         case rendermode::pickscenery: {
 
-//            ::glViewport( 0, 0, 1024, 512 );
+#ifdef EU07_USE_PICKING_FRAMEBUFFER
+            ::glViewport( 0, 0, m_pickbuffersize, m_pickbuffersize );
+#endif
             ::glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
             ::glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
@@ -319,6 +380,12 @@ opengl_renderer::Render_projection() {
 */
         case rendermode::shadows: {
             // TODO: set parallel projection
+            ::gluPerspective(
+                Global::FieldOfView,
+                1.f,
+//                std::max( 1.0f, (float)Global::ScreenWidth ) / std::max( 1.0f, (float)Global::ScreenHeight ),
+                2.f,
+                m_renderpass.draw_range * Global::fDistanceFactor );
             break;
         }
 
@@ -346,7 +413,7 @@ opengl_renderer::Render_camera() {
             break;
         }
         case rendermode::shadows: {
-            m_renderpass.camera.position() = Global::pCameraPosition - glm::dvec3{ Global::DayLight.direction * 750.f };
+            m_renderpass.camera.position() = Global::pCameraPosition - glm::dvec3{ Global::DayLight.direction * 250.f };
             m_renderpass.camera.position().y = std::max( 50.0, m_renderpass.camera.position().y ); // prevent shadow source from dipping too low
             viewmatrix = glm::lookAt(
                 m_renderpass.camera.position(),
@@ -1258,6 +1325,9 @@ opengl_renderer::Render( TSubModel *Submodel ) {
                 // rysuj gdy element nieprzezroczysty
                 switch( m_renderpass.draw_mode ) {
                     case rendermode::color: {
+// NOTE: code disabled as normalization marking doesn't take into account scaling propagation down hierarchy chains
+// for the time being we'll do with enforced worst-case scaling method, when speculars are enabled
+#ifdef EU07_USE_OPTIMIZED_NORMALIZATION
                         switch( Submodel->m_normalizenormals ) {
                             case TSubModel::normalize: {
                                 ::glEnable( GL_NORMALIZE ); break; }
@@ -1266,6 +1336,11 @@ opengl_renderer::Render( TSubModel *Submodel ) {
                             default: {
                                 break; }
                         }
+#else
+                        if( true == m_renderspecular ) {
+                            ::glEnable( GL_NORMALIZE );
+                        }
+#endif
                         // material configuration:
                         // textures...
                         if( Submodel->TextureID < 0 ) { // zmienialne skóry
@@ -1280,6 +1355,7 @@ opengl_renderer::Render( TSubModel *Submodel ) {
                         if( ( true == m_renderspecular ) && ( Global::DayLight.specular.a > 0.01f ) ) {
                             // specular strength in legacy models is set uniformly to 150, 150, 150 so we scale it down for opaque elements
                             ::glMaterialfv( GL_FRONT, GL_SPECULAR, glm::value_ptr( Submodel->f4Specular * Global::DayLight.specular.a * m_specularopaquescalefactor ) );
+                            ::glEnable( GL_RESCALE_NORMAL );
                         }
                         // ...luminance
                         if( Global::fLuminance < Submodel->fLight ) {
@@ -1298,6 +1374,7 @@ opengl_renderer::Render( TSubModel *Submodel ) {
                             // restore default (lack of) brightness
                             ::glMaterialfv( GL_FRONT, GL_EMISSION, glm::value_ptr( colors::none ) );
                         }
+#ifdef EU07_USE_OPTIMIZED_NORMALIZATION
                         switch( Submodel->m_normalizenormals ) {
                             case TSubModel::normalize: {
                                 ::glDisable( GL_NORMALIZE ); break; }
@@ -1306,6 +1383,11 @@ opengl_renderer::Render( TSubModel *Submodel ) {
                             default: {
                                 break; }
                         }
+#else
+                        if( true == m_renderspecular ) {
+                            ::glDisable( GL_NORMALIZE );
+                        }
+#endif
                         break;
                     }
                     case rendermode::shadows:
@@ -1800,6 +1882,9 @@ opengl_renderer::Render_Alpha( TSubModel *Submodel ) {
             // renderowanie obiektów OpenGL
             if( Submodel->iAlpha & Submodel->iFlags & 0x2F ) // rysuj gdy element przezroczysty
             {
+// NOTE: code disabled as normalization marking doesn't take into account scaling propagation down hierarchy chains
+// for the time being we'll do with enforced worst-case scaling method, when speculars are enabled
+#ifdef EU07_USE_OPTIMIZED_NORMALIZATION
                 switch( Submodel->m_normalizenormals ) {
                     case TSubModel::normalize: {
                         ::glEnable( GL_NORMALIZE ); break; }
@@ -1808,6 +1893,11 @@ opengl_renderer::Render_Alpha( TSubModel *Submodel ) {
                     default: {
                         break; }
                 }
+#else
+                if( true == m_renderspecular ) {
+                    ::glEnable( GL_NORMALIZE );
+                }
+#endif
                 // textures...
                 if( Submodel->TextureID < 0 ) { // zmienialne skóry
                     Bind( Submodel->ReplacableSkinId[ -Submodel->TextureID ] );
@@ -1838,6 +1928,7 @@ opengl_renderer::Render_Alpha( TSubModel *Submodel ) {
                     // restore default (lack of) brightness
                     ::glMaterialfv( GL_FRONT, GL_EMISSION, glm::value_ptr( colors::none ) );
                 }
+#ifdef EU07_USE_OPTIMIZED_NORMALIZATION
                 switch( Submodel->m_normalizenormals ) {
                     case TSubModel::normalize: {
                         ::glDisable( GL_NORMALIZE ); break; }
@@ -1846,6 +1937,11 @@ opengl_renderer::Render_Alpha( TSubModel *Submodel ) {
                     default: {
                         break; }
                 }
+#else
+                if( true == m_renderspecular ) {
+                    ::glDisable( GL_NORMALIZE );
+                }
+#endif
             }
         }
         else if( Submodel->eType == TP_FREESPOTLIGHT ) {
@@ -1954,12 +2050,14 @@ opengl_renderer::Update_Pick_Control() {
     glm::dvec2 mousepos;
     glfwGetCursorPos( m_window, &mousepos.x, &mousepos.y );
     mousepos.y = Global::ScreenHeight - mousepos.y; // cursor coordinates are flipped compared to opengl
-/*
+
+#ifdef EU07_USE_PICKING_FRAMEBUFFER
     glm::ivec2 pickbufferpos {
-        mousepos.x * 1024.0f / Global::ScreenWidth,
+        mousepos.x * m_pickbuffersize / Global::ScreenWidth,
-        mousepos.y *  512.0f / Global::ScreenHeight };
+        mousepos.y * m_pickbuffersize / Global::ScreenHeight };
-*/
+#else
     glm::ivec2 pickbufferpos{ mousepos };
+#endif
      
     unsigned char pickreadout[4];
     ::glReadPixels( pickbufferpos.x, pickbufferpos.y, 1, 1, GL_BGRA, GL_UNSIGNED_BYTE, pickreadout );
@@ -1998,12 +2096,14 @@ opengl_renderer::Update_Pick_Node() {
     glm::dvec2 mousepos;
     glfwGetCursorPos( m_window, &mousepos.x, &mousepos.y );
     mousepos.y = Global::ScreenHeight - mousepos.y; // cursor coordinates are flipped compared to opengl
-/*
+
+#ifdef EU07_USE_PICKING_FRAMEBUFFER
     glm::ivec2 pickbufferpos {
-        mousepos.x * 1024.0f / Global::ScreenWidth,
+        mousepos.x * m_pickbuffersize / Global::ScreenWidth,
-        mousepos.y *  512.0f / Global::ScreenHeight };
+        mousepos.y * m_pickbuffersize / Global::ScreenHeight };
-*/
+#else
     glm::ivec2 pickbufferpos{ mousepos };
+#endif
      
     unsigned char pickreadout[4];
     ::glReadPixels( pickbufferpos.x, pickbufferpos.y, 1, 1, GL_BGRA, GL_UNSIGNED_BYTE, pickreadout );
@@ -2198,15 +2298,13 @@ opengl_renderer::Init_caps() {
     WriteLog( "Supported extensions:" +  std::string((char *)glGetString( GL_EXTENSIONS )) );
 
     WriteLog( std::string("Render path: ") + ( Global::bUseVBO ? "VBO" : "Display lists" ) );
-#ifdef EU07_USE_PICKING_FRAMEBUFFER
     if( GLEW_EXT_framebuffer_object ) {
         m_framebuffersupport = true;
         WriteLog( "Framebuffer objects enabled" );
     }
     else {
-        WriteLog( "Framebuffer objects not supported, resorting to back buffer rendering" );
+        WriteLog( "Framebuffer objects not supported, resorting to back buffer rendering where possible" );
     }
-#endif
     if( Global::iMultisampling )
         WriteLog( "Using multisampling x" + std::to_string( 1 << Global::iMultisampling ) );
     // ograniczenie maksymalnego rozmiaru tekstur - parametr dla skalowania tekstur

renderer.h

@@ -254,7 +254,11 @@ private:
     GLuint m_pickframebuffer { 0 }; // TODO: refactor pick framebuffer stuff into an object
     GLuint m_picktexture { 0 };
     GLuint m_pickdepthbuffer { 0 };
+    int m_pickbuffersize { 1024 }; // size of (square) textures bound with the pick framebuffer
 #endif
+    GLuint m_shadowframebuffer { 0 };
+    GLuint m_shadowtexture { 0 };
+    int m_shadowbuffersize { 2048 };
     GLUquadricObj *m_quadric { nullptr }; // helper object for drawing debug mode scene elements
 
     geometry_handle m_billboardgeometry { 0, 0 };

version.h

@@ -1,5 +1,5 @@
 #pragma once
 
 #define VERSION_MAJOR 17
-#define VERSION_MINOR 715
+#define VERSION_MINOR 717
 #define VERSION_REVISION 0