Merge branch 'OGRECave:master' into master

mosfet80 · web-flow · commit bde8551b5e2d · 2025-02-28T12:49:20.000+01:00
diff --git a/OgreMain/include/OgreAutoParamDataSource.h b/OgreMain/include/OgreAutoParamDataSource.h
@@ -163,8 +163,10 @@ namespace Ogre {
         size_t getBoneMatrixCount(void) const;
         OGRE_DEPRECATED size_t getWorldMatrixCount(void) const { return getBoneMatrixCount(); }
         const Affine3& getViewMatrix(void) const;
+        Affine3 getViewMatrix(const Camera* cam) const;
         const Matrix4& getViewProjectionMatrix(void) const;
         const Matrix4& getProjectionMatrix(void) const;
+        Matrix4 getProjectionMatrix(const Camera* cam) const;
         const Matrix4& getWorldViewProjMatrix(void) const;
         const Affine3& getWorldViewMatrix(void) const;
         const Affine3& getInverseWorldMatrix(void) const;
diff --git a/OgreMain/src/OgreAutoParamDataSource.cpp b/OgreMain/src/OgreAutoParamDataSource.cpp
@@ -306,21 +306,26 @@ namespace Ogre {
         return mWorldMatrixArray + int(MeshManager::getBonesUseObjectSpace());
     }
     //-----------------------------------------------------------------------------
-    const Affine3& AutoParamDataSource::getViewMatrix(void) const
+    Affine3 AutoParamDataSource::getViewMatrix(const Camera* cam) const
     {
-        if (mViewMatrixDirty)
+        Affine3 view;
+        if (mCurrentRenderable && mCurrentRenderable->getUseIdentityView())
+            view = Affine3::IDENTITY;
+        else
         {
-            if (mCurrentRenderable && mCurrentRenderable->getUseIdentityView())
-                mViewMatrix = Affine3::IDENTITY;
-            else
+            view = cam->getViewMatrix(true);
+            if (mCameraRelativeRendering)
             {
-                mViewMatrix = mCurrentCamera->getViewMatrix(true);
-                if (mCameraRelativeRendering)
-                {
-                    mViewMatrix.setTrans(Vector3::ZERO);
-                }
-
+                view.setTrans(Vector3::ZERO);
             }
+        }
+        return view;
+    }
+    const Affine3& AutoParamDataSource::getViewMatrix(void) const
+    {
+        if (mViewMatrixDirty)
+        {
+            mViewMatrix = getViewMatrix(mCurrentCamera);
             mViewMatrixDirty = false;
         }
         return mViewMatrix;
@@ -336,31 +341,40 @@ namespace Ogre {
         return mViewProjMatrix;
     }
     //-----------------------------------------------------------------------------
+    Matrix4 AutoParamDataSource::getProjectionMatrix(const Camera* cam) const
+    {
+        Matrix4 proj;
+
+        // NB use API-independent projection matrix since GPU programs
+        // bypass the API-specific handedness and use right-handed coords
+        if (mCurrentRenderable && mCurrentRenderable->getUseIdentityProjection())
+        {
+            // Use identity projection matrix, still need to take RS depth into account.
+            RenderSystem* rs = Root::getSingleton().getRenderSystem();
+            rs->_convertProjectionMatrix(Matrix4::IDENTITY, proj, true);
+        }
+        else
+        {
+            proj = mCurrentCamera->getProjectionMatrixWithRSDepth();
+        }
+
+        if (mCurrentRenderTarget && mCurrentRenderTarget->requiresTextureFlipping())
+        {
+            // Because we're not using setProjectionMatrix, this needs to be done here
+            // Invert transformed y
+            proj[1][0] = -proj[1][0];
+            proj[1][1] = -proj[1][1];
+            proj[1][2] = -proj[1][2];
+            proj[1][3] = -proj[1][3];
+        }
+
+        return proj;
+    }
     const Matrix4& AutoParamDataSource::getProjectionMatrix(void) const
     {
         if (mProjMatrixDirty)
         {
-            // NB use API-independent projection matrix since GPU programs
-            // bypass the API-specific handedness and use right-handed coords
-            if (mCurrentRenderable && mCurrentRenderable->getUseIdentityProjection())
-            {
-                // Use identity projection matrix, still need to take RS depth into account.
-                RenderSystem* rs = Root::getSingleton().getRenderSystem();
-                rs->_convertProjectionMatrix(Matrix4::IDENTITY, mProjectionMatrix, true);
-            }
-            else
-            {
-                mProjectionMatrix = mCurrentCamera->getProjectionMatrixWithRSDepth();
-            }
-            if (mCurrentRenderTarget && mCurrentRenderTarget->requiresTextureFlipping())
-            {
-                // Because we're not using setProjectionMatrix, this needs to be done here
-                // Invert transformed y
-                mProjectionMatrix[1][0] = -mProjectionMatrix[1][0];
-                mProjectionMatrix[1][1] = -mProjectionMatrix[1][1];
-                mProjectionMatrix[1][2] = -mProjectionMatrix[1][2];
-                mProjectionMatrix[1][3] = -mProjectionMatrix[1][3];
-            }
+            mProjectionMatrix = getProjectionMatrix(mCurrentCamera);
             mProjMatrixDirty = false;
         }
         return mProjectionMatrix;
diff --git a/Samples/Media/materials/programs/GLSL/SampleLib_InstancedViewports.glsl b/Samples/Media/materials/programs/GLSL/SampleLib_InstancedViewports.glsl
@@ -29,36 +29,22 @@ furnished to do so, subject to the following conditions:
 // Transform the output position to the current "monitor"
 //-----------------------------------------------------------------------------
 
+#ifdef OGRE_VERTEX_SHADER
 void SGX_InstancedViewportsTransform(
     in vec4 i_position,
-    in mat4 i_worldViewMatrix,
-    in mat4 i_projectionMatrix,
-    in vec4 i_viewportOffsetMatrixR0,
-    in vec4 i_viewportOffsetMatrixR1,
-    in vec4 i_viewportOffsetMatrixR2,
-    in vec4 i_viewportOffsetMatrixR3,
-    in vec2 i_monitorsCount,
+    in mat4 viewportOffsetArray[NUM_MONITORS],
     in vec4 i_monitorIndex,
     out vec4 o_position)
 {
-    o_position = mul(i_worldViewMatrix, i_position);
-    mat4 viewportOffset = mtxFromRows(i_viewportOffsetMatrixR0,
-                                      i_viewportOffsetMatrixR1,
-                                      i_viewportOffsetMatrixR2,
-                                      i_viewportOffsetMatrixR3);
-
-    o_position = mul(viewportOffset, o_position);
-    o_position = mul(i_projectionMatrix, o_position);
-
-    vec2 monitorIndexNorm = i_monitorIndex.xy - ((i_monitorsCount - 1.0)/2.0);
-    o_position.xy =
-        (o_position.xy + (o_position.w * monitorIndexNorm)*2.0) / i_monitorsCount;
+    mat4 viewportOffset = viewportOffsetArray[int(i_monitorIndex.z)];
+    o_position = mul(viewportOffset, i_position);
 }
+#endif
 
 //-----------------------------------------------------------------------------
 // Discard any pixel that is outside the bounds of the current "monitor"
 //-----------------------------------------------------------------------------
-
+#ifdef OGRE_FRAGMENT_SHADER
 void SGX_InstancedViewportsDiscardOutOfBounds(
     in vec2 i_monitorsCount,
     in vec4 i_monitorIndex,
@@ -72,8 +58,8 @@ void SGX_InstancedViewportsDiscardOutOfBounds(
     float maxM = max(boxedXY.x,boxedXY.y);
     if (maxM >= 0.5)
     {
-#ifdef OGRE_FRAGMENT_SHADER
+
         discard;
-#endif
     }
 }
+#endif
diff --git a/Samples/ShaderSystem/include/OgreShaderExInstancedViewports.h b/Samples/ShaderSystem/include/OgreShaderExInstancedViewports.h
@@ -82,66 +82,22 @@ class ShaderExInstancedViewports : public SubRenderState
 
     /** Set the monitors count. */
     void                    setMonitorsCount        (const Vector2 monitorsCount);
-    
-    /** Return the monitors count. */
-    Vector2                 getMonitorsCount        () const { return mMonitorsCount; }
+
+    void setParameter(const String& name, const Any& value) override;
 
     static String Type;
 
 // Protected methods.
 protected:
-    
+    bool createCpuSubPrograms(ProgramSet* programSet) override;
 
-    /** 
-    @see SubRenderState::resolveParameters.
-    */
-    bool            resolveParameters       (ProgramSet* programSet) override;
+    UniformParameterPtr     mPSInMonitorsCount;
+    UniformParameterPtr     mVSInMatrixArray;
 
-    /** 
-    @see SubRenderState::resolveDependencies.
-    */
-    bool            resolveDependencies     (ProgramSet* programSet) override;
-
-    /** 
-    @see SubRenderState::addFunctionInvocations.
-    */
-    bool            addFunctionInvocations  (ProgramSet* programSet) override;
-
-    /** 
-    Internal method that adds related vertex shader functions invocations.
-    */
-    bool            addVSInvocations                (Function* vsMain, const int groupOrder);
-
-
-    /** 
-    Internal method that adds related pixel shader functions invocations.
-    */
-    bool            addPSInvocations                (Function* psMain, const int groupOrder);
-
-
-// Attributes.
-protected:  
-    ParameterPtr            mVSInPosition;      // Vertex shader original input position in projective space.
-    ParameterPtr            mVSOriginalOutPositionProjectiveSpace;      // Vertex shader original output position in projective space.
-    ParameterPtr            mVSOutPositionProjectiveSpace;      // Vertex shader output texcord position in projective space.
-    ParameterPtr            mPSInPositionProjectiveSpace;       // Pixel shader input position in projective space.
-    UniformParameterPtr     mVSInMonitorsCount;                 // Vertex shader uniform monitors count.        
-    UniformParameterPtr     mPSInMonitorsCount;                 // Pixel shader uniform monitors count.     
-    ParameterPtr            mVSInMonitorIndex;                  // Vertex shader uniform monitor index.     
-    ParameterPtr            mVSOutMonitorIndex;                 // Vertex shader output monitor index.      
-    ParameterPtr            mPSInMonitorIndex;                  // Pixel shader input monitor index.    
-
-    ParameterPtr            mVSInViewportOffsetMatrixR0;    
-    ParameterPtr            mVSInViewportOffsetMatrixR1;    
-    ParameterPtr            mVSInViewportOffsetMatrixR2;    
-    ParameterPtr            mVSInViewportOffsetMatrixR3;    
-
-    UniformParameterPtr     mWorldViewMatrix;                       // world & view parameter.
-    UniformParameterPtr     mProjectionMatrix;                      // projection parameter.
-
-    Vector2                 mMonitorsCount;
+    Vector2                 mViewportGrid;
     bool                    mMonitorsCountChanged;
 
+    std::vector<Camera*>    mCameras;
 };
 
 
diff --git a/Samples/ShaderSystem/src/OgreShaderExInstancedViewports.cpp b/Samples/ShaderSystem/src/OgreShaderExInstancedViewports.cpp
diff --git a/Samples/ShaderSystem/src/ShaderSystem.cpp b/Samples/ShaderSystem/src/ShaderSystem.cpp
