[Optimziation] cache transforms for bounding boxes (good for quick th…

…read access)

Source/Engine/Culling.cpp

@@ -140,17 +140,13 @@ void FFrustumCullWorkerContext::AllocInputMemoryIfNecessary(size_t sz)
 		SCOPED_CPU_MARKER("AllocMem");
 		vFrustumPlanes.resize(sz);
 		vBoundingBoxLists.resize(sz);
-		vGameObjectPointerLists.resize(sz);
-		vMaterialIDLists.resize(sz);
 	}
 }
 void FFrustumCullWorkerContext::ClearMemory()
 {
 	vFrustumPlanes.clear();
 	vBoundingBoxLists.clear();
-	vGameObjectPointerLists.clear();
 	vCulledBoundingBoxIndexListPerView.clear();
-	vMaterialIDLists.clear();
 	NumValidInputElements = 0;
 }
 
@@ -165,8 +161,6 @@ void FFrustumCullWorkerContext::AddWorkerItem(
 	SCOPED_CPU_MARKER("FFrustumCullWorkerContext::AddWorkerItem()");
 	vFrustumPlanes[i] = FrustumPlaneSet;
 	vBoundingBoxLists[i] = vBoundingBoxList;
-	vGameObjectPointerLists[i] = pGameObjects;
-	vMaterialIDLists[i] = vMaterials;
 }
 
 void FFrustumCullWorkerContext::ProcessWorkItems_SingleThreaded()
@@ -296,19 +290,17 @@ void FFrustumCullWorkerContext::Process(size_t iRangeBegin, size_t iRangeEnd)
 	for (size_t iWork = iRangeBegin; iWork <= iRangeEnd; ++iWork)
 	{
 		{
-			{
-				SCOPED_CPU_MARKER("Clear");
-				vCulledBoundingBoxIndexListPerView[iWork].clear();
-			}
+			SCOPED_CPU_MARKER("Clear");
+			vCulledBoundingBoxIndexListPerView[iWork].clear();
+		}
 
-			SCOPED_CPU_MARKER("CullFrustum");
-			// process bounding box list per frustum
-			for (size_t bb = 0; bb < vBoundingBoxLists[iWork].size(); ++bb)
+		SCOPED_CPU_MARKER("CullFrustum");
+		// process bounding box list per frustum
+		for (size_t bb = 0; bb < vBoundingBoxLists[iWork].size(); ++bb)
+		{
+			if (IsBoundingBoxIntersectingFrustum(vFrustumPlanes[iWork], vBoundingBoxLists[iWork][bb]))
 			{
-				if (IsBoundingBoxIntersectingFrustum(vFrustumPlanes[iWork], vBoundingBoxLists[iWork][bb]))
-				{
-					vCulledBoundingBoxIndexListPerView[iWork].push_back(bb); // grows as we go (no pre-alloc)
-				}
+				vCulledBoundingBoxIndexListPerView[iWork].push_back(bb); // grows as we go (no pre-alloc)
 			}
 		}
 	}
@@ -625,6 +617,7 @@ void SceneBoundingBoxHierarchy::BuildMeshBoundingBox(const GameObject* pObj, siz
 			mMeshBoundingBoxMeshIDMapping[iMesh] = mesh;
 			mMeshBoundingBoxMaterialIDMapping[iMesh] = mat;
 			mMeshBoundingBoxGameObjectPointerMapping[iMesh] = pObj;
+			mMeshTransforms[iMesh] = *mpTransforms.at(pObj->mTransformID);
 			++iMesh;
 			bAtLeastOneMesh = true;
 		}
@@ -669,6 +662,7 @@ void SceneBoundingBoxHierarchy::Clear()
 	mMeshBoundingBoxes.clear();
 	mMeshBoundingBoxMeshIDMapping.clear();
 	mMeshBoundingBoxMaterialIDMapping.clear();
+	mMeshTransforms.clear();
 	mMeshBoundingBoxGameObjectPointerMapping.clear();
 	mGameObjectBoundingBoxGameObjectPointerMapping.clear();
 }
@@ -701,6 +695,7 @@ void SceneBoundingBoxHierarchy::ResizeGameMeshBoxContainer(size_t size)
 	mMeshBoundingBoxes.resize(size);
 	mMeshBoundingBoxMeshIDMapping.resize(size);
 	mMeshBoundingBoxMaterialIDMapping.resize(size);
+	mMeshTransforms.resize(size);
 	mMeshBoundingBoxGameObjectPointerMapping.resize(size);
 }
 

Source/Engine/Culling.h

@@ -151,10 +151,6 @@ struct FFrustumCullWorkerContext : public FThreadWorkerContext
 	// store the index of the surviving bounding box in a list, per view frustum
 	/*out*/ std::vector<IndexList_t> vCulledBoundingBoxIndexListPerView; 
 	// Hot Data ------------------------------------------------------------------------------------------------------------
-
-	// Cold Data : used after culling
-	/*in */ std::vector<std::vector<const GameObject*>> vGameObjectPointerLists; // Associates BoundingBoxes with pGameObjects
-	/*in */ std::vector<std::vector<MaterialID>>        vMaterialIDLists; // Associates BoundingBoxes with MaterialIDs
 
 	//std::vector<int> vLightMovementTypeID; // index to access light type vectors: [0]:static, [1]:stationary, [2]:dynamic
 

Source/Engine/Scene/Scene.cpp

@@ -624,32 +624,35 @@ void Scene::GatherFrustumCullParameters(const FSceneView& SceneView, FSceneShado
 			mFrustumCullWorkerContext.AddWorkerItem(FrustumPlanesets[i], BVH.mMeshBoundingBoxes, BVH.mMeshBoundingBoxGameObjectPointerMapping, i);
 #else
 		{
-			SCOPED_CPU_MARKER("DispatchWorkers");
 			mFrustumCullWorkerContext.AllocInputMemoryIfNecessary(FrustumPlanesets.size());
 			mFrustumCullWorkerContext.NumValidInputElements = FrustumPlanesets.size();
+
 			const std::vector<std::pair<size_t, size_t>> vRanges = PartitionWorkItemsIntoRanges(FrustumPlanesets.size(), UpdateWorkerThreadPool.GetThreadPoolSize()+1);
-			size_t currRange = 0;
-			for (const std::pair<size_t, size_t>& Range : vRanges)
 			{
-				if (currRange == 0)
+				SCOPED_CPU_MARKER("DispatchWorkers");
+				size_t currRange = 0;
+				for (const std::pair<size_t, size_t>& Range : vRanges)
 				{
-					++currRange; // skip the first range, and do it on this thread after dispatches
-					continue;
+					if (currRange == 0)
+					{
+						++currRange; // skip the first range, and do it on this thread after dispatches
+						continue;
+					}
+					const size_t& iBegin = Range.first;
+					const size_t& iEnd = Range.second; // inclusive
+					assert(iBegin <= iEnd); // ensure work context bounds
+					UpdateWorkerThreadPool.AddTask([Range, &FrustumPlanesets, &BVH, this]()
+						{
+							SCOPED_CPU_MARKER_C("UpdateWorker", 0xFF0000FF);
+							for (size_t i = Range.first; i <= Range.second; ++i)
+								mFrustumCullWorkerContext.AddWorkerItem(FrustumPlanesets[i]
+									, BVH.mMeshBoundingBoxes
+									, BVH.mMeshBoundingBoxGameObjectPointerMapping
+									, BVH.mMeshBoundingBoxMaterialIDMapping
+									, i
+								);
+						});
 				}
-				const size_t& iBegin = Range.first;
-				const size_t& iEnd = Range.second; // inclusive
-				assert(iBegin <= iEnd); // ensure work context bounds
-				UpdateWorkerThreadPool.AddTask([Range, &FrustumPlanesets, &BVH, this]()
-				{
-					SCOPED_CPU_MARKER_C("UpdateWorker", 0xFF0000FF);
-					for (size_t i = Range.first; i <= Range.second; ++i)
-						mFrustumCullWorkerContext.AddWorkerItem(FrustumPlanesets[i]
-							, BVH.mMeshBoundingBoxes
-							, BVH.mMeshBoundingBoxGameObjectPointerMapping
-							, BVH.mMeshBoundingBoxMaterialIDMapping
-							, i
-						);
-				});
 			}
 
 			for (size_t i = vRanges[0].first; i <= vRanges[0].second; ++i)
@@ -861,60 +864,10 @@ static void MarkInstanceDataStale(std::unordered_map < MaterialID, std::unordere
 		}
 	}
 }
-static void CollectInstanceData(
-	  std::unordered_map<MaterialID, std::unordered_map<MeshID, FSceneView::FMeshInstanceData>>& MaterialMeshInstanceDataLookup
-	, const std::vector<const GameObject*>& MeshBoundingBoxGameObjectPointers
-	, const std::vector<MeshID           >& MeshBoundingBoxMeshIDMapping
-	, const std::vector<MaterialID       >& mMeshBoundingBoxMaterialIDMapping
-	, const std::vector<size_t           >& CulledBoundingBoxIndexList_Msh
-	, size_t iBegin
-	, size_t iEnd
-	, const DirectX::XMMATRIX matViewProj
-	, const DirectX::XMMATRIX matViewProjHistory
-	, const std::vector<Transform*>& mpTransforms
-	, const ModelLookup_t& mModels
-)
-{
-	SCOPED_CPU_MARKER("CollectInstanceData");
-	for (size_t i = iBegin; i < iEnd; ++i)
-	{
-		const size_t BBIndex = CulledBoundingBoxIndexList_Msh[i];
-		assert(BBIndex < MeshBoundingBoxMeshIDMapping.size());
-		MeshID meshID = MeshBoundingBoxMeshIDMapping[BBIndex];
-
-		// read game object data
-		const GameObject* pGameObject = MeshBoundingBoxGameObjectPointers[BBIndex];
-		Transform* const& pTF = mpTransforms.at(pGameObject->mTransformID);
-		const XMMATRIX matWorld = pTF->matWorldTransformation();
-		const XMMATRIX matWorldHistory = pTF->matWorldTransformationPrev();
-		const XMMATRIX matNormal = pTF->NormalMatrix(matWorld);
-
-		MaterialID matID = mMeshBoundingBoxMaterialIDMapping[BBIndex];
-
-		{
-			//SCOPED_CPU_MARKER("WriteMap");
-			// 
-			// record instance data
-			FSceneView::FMeshInstanceData& d = MaterialMeshInstanceDataLookup[matID][meshID];
-
-			// if we're seeing this materia/mesh combo the first time, 
-			// allocate some memory for instance data, enough for 1 batch
-			if (d.InstanceData.empty() || d.InstanceData.size() == d.NumValidData)
-			{
-				SCOPED_CPU_MARKER("MemAlloc");
-				d.InstanceData.resize(d.InstanceData.empty() ? MAX_INSTANCE_COUNT__SCENE_MESHES : d.InstanceData.size() * 2);
-			}
 
-			d.InstanceData[d.NumValidData++] = { matWorld, matWorld * matViewProj, matWorldHistory * matViewProjHistory, matNormal };
-		}
-	}
-
-}
 void Scene::BatchInstanceData_SceneMeshes(
 	  std::vector<MeshRenderCommand_t>* pMeshRenderCommands
 	, std::unordered_map < MaterialID, std::unordered_map<MeshID, FSceneView::FMeshInstanceData>>& MaterialMeshInstanceDataLookup
-	, const std::vector<const GameObject*>& MeshBoundingBoxGameObjectPointers
-	, const std::vector<MaterialID>& MeshBoundingBoxMaterialIDs
 	, const std::vector<size_t>& CulledBoundingBoxIndexList_Msh
 	, const DirectX::XMMATRIX& matViewProj
 	, const DirectX::XMMATRIX& matViewProjHistory
@@ -925,18 +878,43 @@ void Scene::BatchInstanceData_SceneMeshes(
 #if RENDER_INSTANCED_SCENE_MESHES
 	MarkInstanceDataStale(MaterialMeshInstanceDataLookup);
 
-	CollectInstanceData(MaterialMeshInstanceDataLookup
-		, MeshBoundingBoxGameObjectPointers
-		, mBoundingBoxHierarchy.mMeshBoundingBoxMeshIDMapping
-		, MeshBoundingBoxMaterialIDs
-		, CulledBoundingBoxIndexList_Msh
-		, 0
-		, CulledBoundingBoxIndexList_Msh.size()
-		, matViewProj
-		, matViewProjHistory
-		, mpTransforms
-		, mModels
-	);
+	{
+		SCOPED_CPU_MARKER("CollectInstanceData");
+		const std::vector<MeshID>& MeshBB_MeshID = mBoundingBoxHierarchy.mMeshBoundingBoxMeshIDMapping;
+		const std::vector<MaterialID>& MeshBB_MatID = mBoundingBoxHierarchy.mMeshBoundingBoxMaterialIDMapping;
+		const std::vector<Transform>& MeshBB_Transforms = mBoundingBoxHierarchy.mMeshTransforms;
+
+		const size_t iBegin = 0;
+		const size_t iEnd = CulledBoundingBoxIndexList_Msh.size();
+		for (size_t i = iBegin; i < iEnd; ++i)
+		{
+			const size_t BBIndex = CulledBoundingBoxIndexList_Msh[i];
+			assert(BBIndex < MeshBB_MeshID.size());
+			MeshID meshID = MeshBB_MeshID[BBIndex];
+
+			// read game object data
+			const Transform& tf = MeshBB_Transforms[BBIndex];
+			const XMMATRIX matWorld = tf.matWorldTransformation();
+			const XMMATRIX matWorldHistory = tf.matWorldTransformationPrev();
+			const XMMATRIX matNormal = tf.NormalMatrix(matWorld);
+
+			MaterialID matID = MeshBB_MatID[BBIndex];
+			{
+				// record instance data
+				FSceneView::FMeshInstanceData& d = MaterialMeshInstanceDataLookup[matID][meshID];
+
+				// if we're seeing this materia/mesh combo the first time, 
+				// allocate some memory for instance data, enough for 1 batch
+				if (d.InstanceData.empty() || d.InstanceData.size() == d.NumValidData)
+				{
+					SCOPED_CPU_MARKER("MemAlloc");
+					d.InstanceData.resize(d.InstanceData.empty() ? MAX_INSTANCE_COUNT__SCENE_MESHES : d.InstanceData.size() * 2);
+				}
+
+				d.InstanceData[d.NumValidData++] = { matWorld, matWorld * matViewProj, matWorldHistory * matViewProjHistory, matNormal };
+			}
+		}
+	}
 
 	int NumInstancedRenderCommands = 0;
 	{
@@ -1074,10 +1052,11 @@ void Scene::BatchInstanceData_ShadowMeshes(size_t iFrustum, FSceneShadowView::FS
 			assert(BBIndex < mBoundingBoxHierarchy.mMeshBoundingBoxMeshIDMapping.size());
 			MeshID meshID = mBoundingBoxHierarchy.mMeshBoundingBoxMeshIDMapping[BBIndex];
 
-			const GameObject* pGameObject = mFrustumCullWorkerContext.vGameObjectPointerLists[iFrustum][BBIndex];
-			Transform* const& pTF = mpTransforms.at(pGameObject->mTransformID);
-
-			XMMATRIX matWorld = pTF->matWorldTransformation();
+
+			const GameObject* pGameObject = mBoundingBoxHierarchy.mMeshBoundingBoxGameObjectPointerMapping[BBIndex];
+
+			Transform const TF = mBoundingBoxHierarchy.mMeshTransforms[BBIndex];
+			XMMATRIX matWorld = TF.matWorldTransformation();
 
 			FSceneShadowView::FShadowView::FShadowMeshInstanceData& d = pShadowView->ShadowMeshInstanceDataLookup[meshID];
 
@@ -1190,8 +1169,6 @@ void Scene::BatchInstanceData(FSceneView& SceneView, ThreadPool& UpdateWorkerThr
 			SCOPED_CPU_MARKER_C("UpdateWorker", 0xFF0000FF);
 			BatchInstanceData_SceneMeshes(&SceneView.meshRenderCommands
 				, SceneView.MaterialMeshInstanceDataLookup
-				, mFrustumCullWorkerContext.vGameObjectPointerLists[0]
-				, mFrustumCullWorkerContext.vMaterialIDLists[0]
 				, mFrustumCullWorkerContext.vCulledBoundingBoxIndexListPerView[0]
 				, SceneView.viewProj
 				, SceneView.viewProjPrev

Source/Engine/Scene/Scene.h

@@ -269,7 +269,8 @@ class SceneBoundingBoxHierarchy
 	std::vector<FBoundingBox>      mMeshBoundingBoxes;
 	std::vector<MeshID>            mMeshBoundingBoxMeshIDMapping;
 	std::vector<MaterialID>        mMeshBoundingBoxMaterialIDMapping;
-	std::vector<const GameObject*> mMeshBoundingBoxGameObjectPointerMapping; 
+	std::vector<Transform>         mMeshTransforms;
+	std::vector<const GameObject*> mMeshBoundingBoxGameObjectPointerMapping;
 	//------------------------------------------------------
 
 	// scene data container references
@@ -353,8 +354,6 @@ class Scene
 	void BatchInstanceData_SceneMeshes(
 		  std::vector<MeshRenderCommand_t>* pMeshRenderCommands
 		, std::unordered_map < MaterialID, std::unordered_map<MeshID, FSceneView::FMeshInstanceData>>& MaterialMeshInstanceDataLookup
-		, const std::vector<const GameObject*>& MeshBoundingBoxGameObjectPointers
-		, const std::vector<MaterialID>& MeshBoundingBoxMaterialIDs
 		, const std::vector<size_t>& CulledBoundingBoxIndexList_Msh
 		, const DirectX::XMMATRIX& matViewProj
 		, const DirectX::XMMATRIX& matViewProjHistory