Commit: 8def3866579709b02d3a8ec6a7d77a49385696dd - HotshotOgreIOS (hg)

Commit MetaInfo

• Revision: 8def3866579709b02d3a8ec6a7d77a49385696dd (tree)
• Time: 2024-07-01 01:52:45
• Author: sebastian_bugiu
• Commiter: sebastian_bugiu

Log Message

Moved mMoved and mUpdated to SoA in Transform instead of bools in each PCZSceneNode.

Change Summary

• modified: OgreMain/include/Math/Array/OgreArrayMemoryManager.h
• modified: OgreMain/include/Math/Array/OgreTransform.h
• modified: OgreMain/include/OgreSceneManager.h
• modified: OgreMain/src/Math/Array/OgreNodeArrayMemoryManager.cpp
• modified: OgreMain/src/OgreSceneManager.cpp
• modified: PlugIns/PCZSceneManager/include/OgrePCZSceneNode.h
• modified: PlugIns/PCZSceneManager/src/OgrePCZSceneManager.cpp
• modified: PlugIns/PCZSceneManager/src/OgrePCZSceneNode.cpp

Incremental Difference

diff -r b2744734c847 -r 8def38665797 OgreMain/include/Math/Array/OgreArrayMemoryManager.h
--- a/OgreMain/include/Math/Array/OgreArrayMemoryManager.h	Sat Jun 29 15:48:56 2024 +0200
+++ b/OgreMain/include/Math/Array/OgreArrayMemoryManager.h	Sun Jun 30 18:52:45 2024 +0200
@@ -299,6 +299,10 @@
             WorldMat,
             InheritOrientation,
             InheritScale,
+#ifdef USE_PCZ
+            Moved,
+            Updated,
+#endif
             NumMemoryTypes
         };
 

diff -r b2744734c847 -r 8def38665797 OgreMain/include/Math/Array/OgreTransform.h
--- a/OgreMain/include/Math/Array/OgreTransform.h	Sat Jun 29 15:48:56 2024 +0200
+++ b/OgreMain/include/Math/Array/OgreTransform.h	Sun Jun 30 18:52:45 2024 +0200
@@ -73,6 +73,11 @@
         /// Stores whether this node inherits scale from it's parent.
         /// Ours is mInheritScale[mIndex]
         bool    * RESTRICT_ALIAS mInheritScale;
+        
+#ifdef USE_PCZ
+        bool    * RESTRICT_ALIAS mMoved;
+        bool    * RESTRICT_ALIAS mUpdated;
+#endif
 
         Transform() :
             mIndex( 0 ),
@@ -87,6 +92,10 @@
             mDerivedTransform( 0 ),
             mInheritOrientation( 0 ),
             mInheritScale( 0 )
+#ifdef USE_PCZ
+            , mMoved( 0 )
+            , mUpdated( 0 )
+#endif
         {
         }
 
@@ -138,6 +147,11 @@
 
             mInheritOrientation[mIndex] = inCopy.mInheritOrientation[inCopy.mIndex];
             mInheritScale[mIndex]       = inCopy.mInheritScale[inCopy.mIndex];
+            
+#ifdef USE_PCZ
+            mMoved[mIndex]              = inCopy.mMoved[inCopy.mIndex];
+            mUpdated[mIndex]            = inCopy.mUpdated[inCopy.mIndex];
+#endif
         }
 
         /** Rebases all the pointers from our SoA structs so that they point to a new location
@@ -174,6 +188,13 @@
                                     newBasePtrs[NodeArrayMemoryManager::InheritOrientation] + diff );
             mInheritScale       = reinterpret_cast<bool*>(
                                     newBasePtrs[NodeArrayMemoryManager::InheritScale] + diff );
+            
+#ifdef USE_PCZ
+            mMoved              = reinterpret_cast<bool*>(
+                                    newBasePtrs[NodeArrayMemoryManager::Moved] + diff );
+            mUpdated            = reinterpret_cast<bool*>(
+                                    newBasePtrs[NodeArrayMemoryManager::Updated] + diff );
+#endif
         }
 
         /** Advances all pointers to the next pack, i.e. if we're processing 4 elements at a time, move to
@@ -192,6 +213,11 @@
             mDerivedTransform   += ARRAY_PACKED_REALS;
             mInheritOrientation += ARRAY_PACKED_REALS;
             mInheritScale       += ARRAY_PACKED_REALS;
+            
+#ifdef USE_PCZ
+            mMoved              += ARRAY_PACKED_REALS;
+            mUpdated            += ARRAY_PACKED_REALS;
+#endif
         }
 
         void advancePack( size_t numAdvance )
@@ -207,6 +233,11 @@
             mDerivedTransform   += ARRAY_PACKED_REALS * numAdvance;
             mInheritOrientation += ARRAY_PACKED_REALS * numAdvance;
             mInheritScale       += ARRAY_PACKED_REALS * numAdvance;
+            
+#ifdef USE_PCZ
+            mMoved              += ARRAY_PACKED_REALS * numAdvance;
+            mUpdated            += ARRAY_PACKED_REALS * numAdvance;
+#endif
         }
     };
 }

diff -r b2744734c847 -r 8def38665797 OgreMain/include/OgreSceneManager.h
--- a/OgreMain/include/OgreSceneManager.h	Sat Jun 29 15:48:56 2024 +0200
+++ b/OgreMain/include/OgreSceneManager.h	Sun Jun 30 18:52:45 2024 +0200
@@ -237,6 +237,24 @@
         {
         }
     };
+    
+#ifdef USE_PCZ
+    struct ResetUpdateFlagsRequest
+    {
+        Transform t;
+        /// Number of nodes to process for each thread. Must be multiple of ARRAY_PACKED_REALS
+        size_t numNodesPerThread;
+        size_t numTotalNodes;
+
+        ResetUpdateFlagsRequest() :
+            numNodesPerThread( 0 ), numTotalNodes( 0 ) {}
+
+        ResetUpdateFlagsRequest( const Transform &_t, size_t _numNodesPerThread, size_t _numTotalNodes ) :
+            t( _t ), numNodesPerThread( _numNodesPerThread ), numTotalNodes( _numTotalNodes )
+        {
+        }
+    };
+#endif
 
     struct InstanceBatchCullRequest
     {
@@ -916,6 +934,9 @@
             PCZ_CULL_FRUSTUM,
             UPDATE_ALL_ANIMATIONS,
             UPDATE_ALL_TRANSFORMS,
+#ifdef USE_PCZ
+            RESET_ALL_UPDATE_FLAGS,
+#endif
             UPDATE_ALL_BONE_TO_TAG_TRANSFORMS,
             UPDATE_ALL_TAG_ON_TAG_TRANSFORMS,
             UPDATE_ALL_BOUNDS,
@@ -935,6 +956,9 @@
         PCZCullFrustumRequest           mCurrentPCZCullFrustumRequest;
         UpdateLodRequest                mUpdateLodRequest;
         UpdateTransformRequest          mUpdateTransformRequest;
+#ifdef USE_PCZ
+        ResetUpdateFlagsRequest         mResetUpdateFlagsRequest;
+#endif
         ObjectMemoryManagerVec const    *mUpdateBoundsRequest;
         InstancingThreadedCullingMethod mInstancingThreadedCullingMethod;
         InstanceBatchCullRequest        mInstanceBatchCullRequest;
@@ -1027,6 +1051,10 @@
             Must be unique for each worker thread
         */
         void updateAllTransformsThread( const UpdateTransformRequest &request, size_t threadIdx );
+        
+#ifdef USE_PCZ
+        void resetAllUpdateFlagsThread( const ResetUpdateFlagsRequest &request, size_t threadIdx );
+#endif
 
         /// @see TagPoint::updateAllTransformsBoneToTag
         void updateAllTransformsBoneToTagThread( const UpdateTransformRequest &request,
@@ -1917,6 +1945,10 @@
             could deadlock in the best of cases).
         */
         void updateAllTransforms();
+        
+#ifdef USE_PCZ
+        void resetAllUpdateFlags();
+#endif
 
         /** Updates all TagPoints, both TagPoints that are children of bones, and TagPoints that
             are children of other TagPoints.

diff -r b2744734c847 -r 8def38665797 OgreMain/src/Math/Array/OgreNodeArrayMemoryManager.cpp
--- a/OgreMain/src/Math/Array/OgreNodeArrayMemoryManager.cpp	Sat Jun 29 15:48:56 2024 +0200
+++ b/OgreMain/src/Math/Array/OgreNodeArrayMemoryManager.cpp	Sun Jun 30 18:52:45 2024 +0200
@@ -49,6 +49,10 @@
         16 * sizeof( Ogre::Real ),      //ArrayMemoryManager::WorldMat
         sizeof( bool ),                 //ArrayMemoryManager::InheritOrientation
         sizeof( bool )                  //ArrayMemoryManager::InheritScale
+#ifdef USE_PCZ
+        , sizeof( bool )                //ArrayMemoryManager::Moved
+        , sizeof( bool )                //ArrayMemoryManager::Updated
+#endif
     };
     const CleanupRoutines NodeArrayMemoryManager::NodeInitRoutines[NumMemoryTypes] =
     {
@@ -63,6 +67,10 @@
         0,                          //ArrayMemoryManager::WorldMat
         0,                          //ArrayMemoryManager::InheritOrientation
         0                           //ArrayMemoryManager::InheritScale
+#ifdef USE_PCZ
+        , 0                         //ArrayMemoryManager::Moved
+        , 0                         //ArrayMemoryManager::Updated
+#endif
     };
     const CleanupRoutines NodeArrayMemoryManager::NodeCleanupRoutines[NumMemoryTypes] =
     {
@@ -77,6 +85,10 @@
         cleanerFlat,                    //ArrayMemoryManager::WorldMat
         cleanerFlat,                    //ArrayMemoryManager::InheritOrientation
         cleanerFlat                     //ArrayMemoryManager::InheritScale
+#ifdef USE_PCZ
+        , cleanerFlat                   //ArrayMemoryManager::Moved
+        , cleanerFlat                   //ArrayMemoryManager::Updated
+#endif
     };
     //-----------------------------------------------------------------------------------
     NodeArrayMemoryManager::NodeArrayMemoryManager( uint16 depthLevel, size_t hintMaxNodes,
@@ -132,6 +144,13 @@
                                                 nextSlotBase * mElementsMemSizes[InheritOrientation] );
         outTransform.mInheritScale      = reinterpret_cast<bool*>( mMemoryPools[InheritScale] +
                                                 nextSlotBase * mElementsMemSizes[InheritScale] );
+        
+#ifdef USE_PCZ
+        outTransform.mMoved             = reinterpret_cast<bool*>( mMemoryPools[Moved] +
+                                                     nextSlotBase * mElementsMemSizes[Moved] );
+        outTransform.mUpdated           = reinterpret_cast<bool*>( mMemoryPools[Updated] +
+                                                     nextSlotBase * mElementsMemSizes[Updated] );
+#endif
 
         //Set default values
         outTransform.mParents[nextSlotIdx] = mDummyNode;
@@ -145,6 +164,10 @@
         outTransform.mDerivedTransform[nextSlotIdx] = Matrix4::IDENTITY;
         outTransform.mInheritOrientation[nextSlotIdx]   = true;
         outTransform.mInheritScale[nextSlotIdx]         = true;
+#ifdef USE_PCZ
+        outTransform.mMoved[nextSlotIdx]                = true;
+        outTransform.mUpdated[nextSlotIdx]              = false;
+#endif
     }
     //-----------------------------------------------------------------------------------
     void NodeArrayMemoryManager::destroyNode( Transform &inOutTransform )
@@ -175,6 +198,11 @@
         outTransform.mDerivedTransform  = reinterpret_cast<Matrix4*>( mMemoryPools[WorldMat] );
         outTransform.mInheritOrientation= reinterpret_cast<bool*>( mMemoryPools[InheritOrientation] );
         outTransform.mInheritScale      = reinterpret_cast<bool*>( mMemoryPools[InheritScale] );
+        
+#ifdef USE_PCZ
+        outTransform.mMoved             = reinterpret_cast<bool*>( mMemoryPools[Moved] );
+        outTransform.mUpdated           = reinterpret_cast<bool*>( mMemoryPools[Updated] );
+#endif
 
         return mUsedMemory;
     }

diff -r b2744734c847 -r 8def38665797 OgreMain/src/OgreSceneManager.cpp
--- a/OgreMain/src/OgreSceneManager.cpp	Sat Jun 29 15:48:56 2024 +0200
+++ b/OgreMain/src/OgreSceneManager.cpp	Sun Jun 30 18:52:45 2024 +0200
@@ -2095,6 +2095,75 @@
         ++itor;
     }
 }
+#ifdef USE_PCZ
+//-----------------------------------------------------------------------
+void SceneManager::resetAllUpdateFlagsThread( const ResetUpdateFlagsRequest &request, size_t threadIdx )
+{
+    Transform t( request.t );
+    const size_t toAdvance = std::min( threadIdx * request.numNodesPerThread,
+                                        request.numTotalNodes );
+
+    //Prevent going out of bounds (usually in the last threadIdx, or
+    //when there are less nodes than ARRAY_PACKED_REALS
+    const size_t numNodes = std::min( request.numNodesPerThread, request.numTotalNodes - toAdvance );
+    t.advancePack( toAdvance / ARRAY_PACKED_REALS );
+
+    for( size_t i=0; i<numNodes; i += ARRAY_PACKED_REALS )
+    {
+        
+        t.mMoved[0] = true;
+        t.mMoved[1] = true;
+        t.mMoved[2] = true;
+        t.mMoved[3] = true;
+        
+        t.mUpdated[0] = false;
+        t.mUpdated[1] = false;
+        t.mUpdated[2] = false;
+        t.mUpdated[3] = false;
+
+        t.advancePack();
+    }
+}
+//-----------------------------------------------------------------------
+void SceneManager::resetAllUpdateFlags()
+{
+    mRequestType = RESET_ALL_UPDATE_FLAGS;
+    NodeMemoryManagerVec::const_iterator it = mNodeMemoryManagerUpdateList.begin();
+    NodeMemoryManagerVec::const_iterator en = mNodeMemoryManagerUpdateList.end();
+
+    while( it != en )
+    {
+        NodeMemoryManager *nodeMemoryManager = *it;
+        const size_t numDepths = nodeMemoryManager->getNumDepths();
+
+        size_t start = nodeMemoryManager->getMemoryManagerType() == SCENE_STATIC ?
+                                                    mStaticMinDepthLevelDirty : 0;
+
+        //Start from the zeroth level (root) unless static (start from first dirty)
+        for( size_t i=start; i<numDepths; ++i )
+        {
+            Transform t;
+            const size_t numNodes = nodeMemoryManager->getFirstNode( t, i );
+
+            //nodesPerThread must be multiple of ARRAY_PACKED_REALS
+            size_t nodesPerThread = ( numNodes + (mNumWorkerThreads-1) ) / mNumWorkerThreads;
+            nodesPerThread        = ( (nodesPerThread + ARRAY_PACKED_REALS - 1) / ARRAY_PACKED_REALS ) *
+                                    ARRAY_PACKED_REALS;
+
+            if( numNodes )
+            {
+                //Send them to worker threads. We need to go depth by depth because
+                //we may depend on parents which could be processed by different threads.
+                mResetUpdateFlagsRequest = ResetUpdateFlagsRequest( t, nodesPerThread, numNodes );
+                fireWorkerThreadsAndWait();
+                //Node::updateAllTransforms( numNodes, t );
+            }
+        }
+
+        ++it;
+    }
+}
+#endif
 //-----------------------------------------------------------------------
 void SceneManager::updateAllTagPoints()
 {
@@ -2825,6 +2894,9 @@
     highLevelCull();
     _applySceneAnimations();
     updateAllTransforms();
+#ifdef USE_PCZ
+    resetAllUpdateFlags();
+#endif
     updateAllAnimations();
     updateAllTagPoints();
 #ifdef OGRE_LEGACY_ANIMATIONS
@@ -5364,6 +5436,11 @@
         case UPDATE_ALL_TRANSFORMS:
             updateAllTransformsThread( mUpdateTransformRequest, threadIdx );
             break;
+#ifdef USE_PCZ
+        case RESET_ALL_UPDATE_FLAGS:
+            resetAllUpdateFlagsThread( mResetUpdateFlagsRequest, threadIdx );
+            break;
+#endif
         case UPDATE_ALL_BONE_TO_TAG_TRANSFORMS:
             updateAllTransformsBoneToTagThread( mUpdateTransformRequest, threadIdx );
             break;

diff -r b2744734c847 -r 8def38665797 PlugIns/PCZSceneManager/include/OgrePCZSceneNode.h
--- a/PlugIns/PCZSceneManager/include/OgrePCZSceneNode.h	Sat Jun 29 15:48:56 2024 +0200
+++ b/PlugIns/PCZSceneManager/include/OgrePCZSceneNode.h	Sun Jun 30 18:52:45 2024 +0200
@@ -120,11 +120,11 @@
         void        updateZoneData(void);
         void        enable(bool yesno) {mEnabled = yesno;}
         bool        isEnabled(void) {return mEnabled;}
-        bool        isMoved(void) {return mMoved;}
-        void        setMoved(bool value) {mMoved = value;}
+        bool        isMoved(void) const;
+        void        setMoved(bool value);
         void        nodeUpdated(const Node*);
-        void        setUpdated( bool updated ) { mUpdated = updated; }
-        bool        isUpdated() { return mUpdated; }
+        void        setUpdated( bool updated );
+        bool        isUpdated() const;
     protected:
         mutable Vector3 mNewPosition; 
         PCZone *        mHomeZone;
@@ -136,8 +136,8 @@
         PCZCamera*      mLastVisibleFromCamera;
         ZoneDataMap     mZoneData;
         bool            mEnabled;
-        mutable bool    mMoved;
-        bool            mUpdated; // Only once per frame.
+//        mutable bool    mMoved;
+//        mutable bool    mUpdated; // Only once per frame.
     };
 }
 

diff -r b2744734c847 -r 8def38665797 PlugIns/PCZSceneManager/src/OgrePCZSceneManager.cpp
--- a/PlugIns/PCZSceneManager/src/OgrePCZSceneManager.cpp	Sat Jun 29 15:48:56 2024 +0200
+++ b/PlugIns/PCZSceneManager/src/OgrePCZSceneManager.cpp	Sun Jun 30 18:52:45 2024 +0200
@@ -552,7 +552,7 @@
             return;
         }
         // TODO ugly workaround to not update multiple times per frame.
-        _resetPCZSceneNodes();
+//        _resetPCZSceneNodes();
         // First do the standard scene graph update
         SceneManager::updateSceneGraph();
         // Update the portal positions
@@ -561,7 +561,8 @@
         // check for portal zone-related changes (portals intersecting other portals)
         _updatePortalZoneData();
         // mark nodes dirty base on portals that changed.
-        _dirtyNodeByMovingPortals();
+        // TODO is it faster to just dirty up everything instead of actually checking? Does this make sense for Octree based zones?
+//        _dirtyNodeByMovingPortals();
         // update all scene nodes
         _updatePCZSceneNodes();
         // calculate zones affected by each light

diff -r b2744734c847 -r 8def38665797 PlugIns/PCZSceneManager/src/OgrePCZSceneNode.cpp
--- a/PlugIns/PCZSceneManager/src/OgrePCZSceneNode.cpp	Sat Jun 29 15:48:56 2024 +0200
+++ b/PlugIns/PCZSceneManager/src/OgrePCZSceneNode.cpp	Sun Jun 30 18:52:45 2024 +0200
@@ -45,6 +45,12 @@
 #include "OgreSceneNode.h"
 #include "OgrePCZone.h"
 
+#if OGRE_DEBUG_MODE >= OGRE_DEBUG_MEDIUM
+    #define CACHED_TRANSFORM_OUT_OF_DATE() this->_setCachedTransformOutOfDate()
+#else
+    #define CACHED_TRANSFORM_OUT_OF_DATE() ((void)0)
+#endif
+
 namespace Ogre
 {
     PCZSceneNode::PCZSceneNode( IdType id, SceneManager* creator, NodeMemoryManager *nodeMemoryManager,
@@ -55,8 +61,7 @@
         mAllowedToVisit(true),
         mLastVisibleFrame(0),
         mLastVisibleFromCamera(0),
-        mEnabled(true),
-        mMoved(false)
+        mEnabled(true)
     {
         setListener( this );
     }
@@ -298,12 +303,37 @@
     
     void PCZSceneNode::nodeUpdated(const Node*)
     {
-        if ( !mUpdated )
+        if ( !isUpdated() )
         {
             mPrevPosition = mNewPosition;
             mNewPosition = _getDerivedPosition(); // TODO make sure that the position has been updated before any calls here.
-            mMoved = true;
-            mUpdated = true;
+            setMoved( true );
+            setUpdated( true );
         }
     }
+    
+    //-----------------------------------------------------------------------
+    void PCZSceneNode::setMoved(bool moved)
+    {
+        mTransform.mMoved[mTransform.mIndex] = moved;
+//        CACHED_TRANSFORM_OUT_OF_DATE();
+    }
+    //-----------------------------------------------------------------------
+    bool PCZSceneNode::isMoved(void) const
+    {
+//        OGRE_ASSERT_MEDIUM( !mCachedTransformOutOfDate );
+        return mTransform.mMoved[mTransform.mIndex];
+    }
+    //-----------------------------------------------------------------------
+    void PCZSceneNode::setUpdated(bool updated)
+    {
+        mTransform.mUpdated[mTransform.mIndex] = updated;
+//        CACHED_TRANSFORM_OUT_OF_DATE();
+    }
+    //-----------------------------------------------------------------------
+    bool PCZSceneNode::isUpdated(void) const
+    {
+//        OGRE_ASSERT_MEDIUM( !mCachedTransformOutOfDate );
+        return mTransform.mUpdated[mTransform.mIndex];
+    }
 }