diff options
Diffstat (limited to 'Runtime/Terrain/TreeRenderer.cpp')
| -rw-r--r-- | Runtime/Terrain/TreeRenderer.cpp | 1223 |
1 files changed, 1223 insertions, 0 deletions
diff --git a/Runtime/Terrain/TreeRenderer.cpp b/Runtime/Terrain/TreeRenderer.cpp new file mode 100644 index 0000000..6ebb3f0 --- /dev/null +++ b/Runtime/Terrain/TreeRenderer.cpp @@ -0,0 +1,1223 @@ +#include "UnityPrefix.h" +#include "TreeRenderer.h" + +#if ENABLE_TERRAIN + +#include "TerrainData.h" +#include "PerlinNoise.h" +#include "Wind.h" + +#include "Runtime/Camera/Camera.h" +#include "Runtime/Camera/Light.h" +#include "Runtime/Camera/CameraUtil.h" +#include "Runtime/Camera/IntermediateRenderer.h" +#include "Runtime/Camera/RenderSettings.h" +#include "Runtime/Camera/Shadows.h" +#include "Runtime/Geometry/Intersection.h" +#include "Runtime/Graphics/Transform.h" +#include "Runtime/Graphics/RenderTexture.h" +#include "Runtime/Shaders/Shader.h" +#include "Runtime/Shaders/ShaderNameRegistry.h" +#include "Runtime/Shaders/Material.h" +#include "Runtime/Shaders/MaterialProperties.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "External/shaderlab/Library/properties.h" +#include "Runtime/Input/TimeManager.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Allocator/MemoryMacros.h" + +static ShaderLab::FastPropertyName kTerrainTreeLightDirections[4] = { + ShaderLab::Property("_TerrainTreeLightDirections0"), + ShaderLab::Property("_TerrainTreeLightDirections1"), + ShaderLab::Property("_TerrainTreeLightDirections2"), + ShaderLab::Property("_TerrainTreeLightDirections3"), +}; +static ShaderLab::FastPropertyName kTerrainTreeLightColors[4] = { + ShaderLab::Property("_TerrainTreeLightColors0"), + ShaderLab::Property("_TerrainTreeLightColors1"), + ShaderLab::Property("_TerrainTreeLightColors2"), + ShaderLab::Property("_TerrainTreeLightColors3"), +}; + + +// when we have shadow we need to emit all renderers to let them casting shadows +#define EMIT_ALL_TREE_RENDERERS ENABLE_SHADOWS + + +// -------------------------------------------------------------------------- + + +struct TreeBinaryTree : public NonCopyable +{ + TreeBinaryTree(TreeDatabase* database) + : database(database), mesh(0), sortIndex(0), targetSortIndex(0), visible(0) + { + Assert(database != NULL); + } + + ~TreeBinaryTree() + { + DestroySingleObject(mesh); + } + + TreeDatabase* database; + std::vector<int> instances; + AABB bounds; + Mesh* mesh; + + int sortIndex; + int targetSortIndex; + int visible; + + Plane splittingPlane; + std::vector<int> usedPrototypes; + + std::auto_ptr<TreeBinaryTree> left; + std::auto_ptr<TreeBinaryTree> right; +}; + +class TreeBinaryTreeBuilder +{ +public: + static bool AddLastTree (TreeBinaryTree& binTree, const Vector3f& position, const Vector3f& scale, int minimumInstances) + { + const std::vector<TreeInstance>& instances = binTree.database->GetInstances(); + Assert(!instances.empty()); + const TreeInstance& instance = instances.back(); + + const std::vector<TreeDatabase::Prototype>& prototypes = binTree.database->GetPrototypes(); + + EncapsulateBounds(binTree.bounds, instance, prototypes, position, scale); + + // Leaf node + if (!binTree.left.get()) + { + binTree.sortIndex = -1; + if (binTree.visible != 0) + { + binTree.visible = 0; + DestroySingleObject(binTree.mesh); + binTree.mesh = 0; + } + + if (binTree.instances.empty()) + { + binTree.instances.resize(1); + binTree.instances[0] = instances.size() - 1; + binTree.bounds = CalculateBounds(instances, binTree.instances, prototypes, position, scale); + binTree.usedPrototypes = CalculateSupportedInstances(instances, binTree.instances, prototypes); + + return true; + } + else if (binTree.instances.size() < minimumInstances * 2) + { + binTree.instances.push_back(instances.size() - 1); + EncapsulateBounds(binTree.bounds, instance, prototypes, position, scale); + binTree.usedPrototypes = CalculateSupportedInstances(instances, binTree.instances, prototypes); + return true; + } + else + // Adding will actually fail once all leaves are filled up to minimumInstances * 2. + // Is that what we want? + return false; + } + else + { + const Vector3f pos = Scale(instance.position, scale); + if (binTree.splittingPlane.GetSide (pos)) + return AddLastTree(*binTree.left, position, scale, minimumInstances); + else + return AddLastTree(*binTree.right, position, scale, minimumInstances); + } + } + + static std::auto_ptr<TreeBinaryTree> Build(TreeDatabase& database, const Vector3f& position, const Vector3f& scale, int minimumInstances) + { + std::auto_ptr<TreeBinaryTree> tree(new TreeBinaryTree(&database)); + const std::vector<TreeInstance>& instances = database.GetInstances(); + if (instances.empty()) + return tree; + + tree->instances.resize(instances.size()); + for (int i = 0; i < instances.size(); ++i) + { + tree->instances[i] = i; + } + + Assert(Magnitude(scale) > 0); + Split(*tree, position, scale, minimumInstances); + return tree; + } + +private: + static void Split(TreeBinaryTree& bintree, const Vector3f& position, const Vector3f& scale, int minimumInstances) + { + const std::vector<TreeInstance>& allInstances = bintree.database->GetInstances(); + const std::vector<TreeDatabase::Prototype>& prototypes = bintree.database->GetPrototypes(); + bintree.bounds = CalculateBounds(allInstances, bintree.instances, prototypes, position, scale); + bintree.usedPrototypes = CalculateSupportedInstances(allInstances, bintree.instances, prototypes); + + // Stop splitting when we reach a certain amount of trees + if (bintree.instances.size() <= minimumInstances) + return; + + { + // We need to calculate bounds of position of all instances and then use median position (i.e. center) + // as a splitting point. We can't just use center of bintree.bounds, because it might be shifted sideways + // if bounds of each prototype is shifted and that would result in left or right bintree being empty + // (see case 345094) + AABB posBounds = CalculatePosBounds (allInstances, bintree.instances, position, scale); + + // The extent might be 0,0,0 if all instances are at the same position. In that case just stop subdiving this subtree. + // That will cause this subtree to have more instances than minimumInstances. If that's not we want, then we should + // just split the instances in half by the index. + if (CompareApproximately (posBounds.GetExtent().x, 0.0f) && CompareApproximately (posBounds.GetExtent().z, 0.0f)) + return; + + // Splitting plane is the largest axis + bintree.splittingPlane.SetNormalAndPosition( + posBounds.GetExtent().x > posBounds.GetExtent().z ? Vector3f::xAxis : Vector3f::zAxis, + posBounds.GetCenter() + ); + } + + // Now just queue up the binary tree + std::vector<int> left, right; + for (std::vector<int>::const_iterator it = bintree.instances.begin(), end = bintree.instances.end(); it != end; ++it) + { + if (bintree.splittingPlane.GetSide (Scale(allInstances[*it].position, scale) + position)) + left.push_back(*it); + else + right.push_back(*it); + } + + // Due to numerical errors we might still end up with one of the lists empty (not if the the epsilon for CompareApprox was big enough, + // but that's another story). In that case just don't split this subtree. + if (left.empty() || right.empty()) + return; + + bintree.instances.clear(); + bintree.usedPrototypes.clear(); + bintree.left.reset(new TreeBinaryTree(bintree.database)); + bintree.right.reset(new TreeBinaryTree(bintree.database)); + bintree.left->instances.swap(left); + bintree.right->instances.swap(right); + + Split (*bintree.left, position, scale, minimumInstances); + Split (*bintree.right, position, scale, minimumInstances); + } + + // Build bounds of tree positions for a bunch of trees + static AABB CalculatePosBounds (const std::vector<TreeInstance>& allInstances, const std::vector<int>& instances, const Vector3f& position, const Vector3f& scale) + { + AssertIf(instances.empty()); + AABB bounds(Scale(allInstances[instances[0]].position, scale) + position, Vector3f::zero); + for (std::vector<int>::const_iterator it = instances.begin(), end = instances.end(); it != end; ++it) + bounds.Encapsulate (Scale(allInstances[*it].position, scale) + position); + + return bounds; + } + + // Build bounds for a bunch of trees + static AABB CalculateBounds (const std::vector<TreeInstance>& allInstances, const std::vector<int>& instances, const TreeDatabase::PrototypeVector& prototypes, const Vector3f& position, const Vector3f& scale) + { + AssertIf(instances.empty()); + AABB bounds(Scale(allInstances[instances[0]].position, scale) + position, Vector3f::zero); + for (std::vector<int>::const_iterator it = instances.begin(), end = instances.end(); it != end; ++it) + EncapsulateBounds(bounds, allInstances[*it], prototypes, position, scale); + + return bounds; + } + + // Encapsulate a single tree in the bounds + static void EncapsulateBounds (AABB& bounds, const TreeInstance& instance, const TreeDatabase::PrototypeVector& prototypes, const Vector3f& position, const Vector3f& scale) + { + Vector3f pos = Scale(instance.position, scale) + position; + Vector3f treeScale(instance.widthScale, instance.heightScale, instance.widthScale); + const AABB& pb = prototypes[instance.index].bounds; + bounds.Encapsulate (pos + Scale(treeScale, pb.GetMin())); + bounds.Encapsulate (pos + Scale(treeScale, pb.GetMax())); + } + + + // Calculates an array of indices, for which prototypes are being used in the batch + static std::vector<int> CalculateSupportedInstances (const std::vector<TreeInstance>& allInstances, const std::vector<int>& instances, const TreeDatabase::PrototypeVector& prototypes) + { + std::vector<char> supported(prototypes.size(), 0); + for (std::vector<int>::const_iterator it = instances.begin(), end = instances.end(); it != end; ++it) + supported[allInstances[*it].index] = 1; + + std::vector<int> supportedIndices; + supportedIndices.reserve(prototypes.size()); + for (int i = 0; i < supported.size(); ++i) + { + if (supported[i]) + supportedIndices.push_back(i); + } + + // we do explicit copy because we want to reduce reserved size + return std::vector<int>(supportedIndices.begin(), supportedIndices.end()); + } +}; + +struct TreeInstanceIndexSorter : public std::binary_function<int, int, bool> +{ + const std::vector<TreeInstance>* m_AllInstances; + + TreeInstanceIndexSorter(const std::vector<TreeInstance>& allInstances) + : m_AllInstances(&allInstances) + { } + + bool operator ()(int lhs, int rhs) const + { + return (*m_AllInstances)[lhs].temporaryDistance > (*m_AllInstances)[rhs].temporaryDistance; + } +}; + +class TreeMeshIntermediateRenderer : public MeshIntermediateRenderer +{ +public: + static ForwardLinearAllocator* s_Allocator; + + inline void* operator new( size_t size) + { + Assert(s_Allocator != NULL); + return s_Allocator->allocate(size); + } + + inline void operator delete( void* p) + { + Assert(s_Allocator != NULL); + s_Allocator->deallocate(p); + } + + void Update(int layer, bool shadows, int lightmapIndex, const MaterialPropertyBlock& properties) + { + m_Layer = layer; + m_CastShadows = m_ReceiveShadows = shadows; + SetLightmapIndexIntNoDirty(lightmapIndex); + SetPropertyBlock(properties); + } +}; + +ForwardLinearAllocator* TreeMeshIntermediateRenderer::s_Allocator = NULL; + + +// -------------------------------------------------------------------------- + + + +const int kTreesPerBatch = 500; + +TreeRenderer::TreeRenderer(TreeDatabase& database, const Vector3f& position, int lightmapIndex) +: m_Database(0), m_BillboardMaterial(0), m_TreeBinaryTree(0), m_CloseBillboardMesh(0), m_LightmapIndex(lightmapIndex) +, m_RendererAllocator(8 * 1024, kMemTerrain) +, m_LegacyTreeSceneNodes(kMemTerrain), m_LegacyTreeBoundingBoxes(kMemTerrain), m_TreeIndexToSceneNode(kMemTerrain) +{ + const TreeDatabase::PrototypeVector& prototypes = database.GetPrototypes(); + bool anyValidTrees = false; + for (TreeDatabase::PrototypeVector::const_iterator it = prototypes.begin(), end = prototypes.end(); it != end; ++it) + { + if (!it->materials.empty()) + anyValidTrees = true; + } + + if (!anyValidTrees) + return; + + m_Database = &database; + + m_TerrainSize = database.GetTerrainData().GetHeightmap().GetSize(); + m_Position = position; + m_ImposterRenderTexture.reset(new ImposterRenderTexture(database)); + + // SetupMaterials + Shader* s = GetScriptMapper().FindShader("Hidden/TerrainEngine/BillboardTree"); + if (s == NULL) + { + ErrorString("Unable to find shaders used for the terrain engine. Please include Nature/Terrain/Diffuse shader in Graphics settings."); + s = GetScriptMapper().FindShader("Diffuse"); + } + m_BillboardMaterial = Material::CreateMaterial(*s, Object::kHideAndDontSave); + if (m_BillboardMaterial->HasProperty(ShaderLab::Property("_MainTex"))) + m_BillboardMaterial->SetTexture(ShaderLab::Property("_MainTex"), m_ImposterRenderTexture->GetTexture()); + + if (database.GetInstances().empty() || database.GetPrototypes().empty()) + return; + + + // mircea@ for some reason it doesn't compile on the PS3 if assigned directly... + std::auto_ptr<TreeBinaryTree> TreeBinaryTree = TreeBinaryTreeBuilder::Build(database, m_Position, m_TerrainSize, kTreesPerBatch); + m_TreeBinaryTree = TreeBinaryTree; + +#if ENABLE_THREAD_CHECK_IN_ALLOCS + m_RendererAllocator.SetThreadIDs(Thread::mainThreadId, Thread::mainThreadId); +#endif + + for (int i = 0; i < database.GetInstances().size(); ++i) + { + CreateTreeRenderer(i); + } +} + +TreeRenderer::~TreeRenderer() +{ + CleanupBillboardMeshes(); + + DestroySingleObject(m_BillboardMaterial); + m_BillboardMaterial = 0; + + DeleteTreeRenderers(); +} + + +/// Injects a single tree into the renderer, without requiring a full rebuild of the binary tree. +/// Requires that there is at least one tree in the renderer +void TreeRenderer::InjectTree(const TreeInstance& newTree) +{ + Assert(&newTree == &m_Database->GetInstances().back()); + if (!m_TreeBinaryTree.get() || !TreeBinaryTreeBuilder::AddLastTree(*m_TreeBinaryTree, m_Position, m_TerrainSize, kTreesPerBatch)) + { + // Failed adding the tree (Too many trees in one batch) + + // mircea@ for some reason it doesn't compile on the PS3 if assigned directly... + std::auto_ptr<TreeBinaryTree> TreeBinaryTree = TreeBinaryTreeBuilder::Build(*m_Database, m_Position, m_TerrainSize, kTreesPerBatch); + m_TreeBinaryTree = TreeBinaryTree; + } + CreateTreeRenderer(m_Database->GetInstances().size() - 1); + //@TODO: Cleanup meshes +} + +void TreeRenderer::RemoveTrees(const Vector3f& pos, float radius, int prototypeIndex) +{ + // hack + ReloadTrees(); +} + +void TreeRenderer::ReloadTrees() +{ + ReloadTrees(kTreesPerBatch); +} + +void TreeRenderer::ReloadTrees(int treesPerBatch) +{ + if (m_Database) + { + if (m_Database->GetInstances().empty()) + m_TreeBinaryTree.reset(); + else + { + // mircea@ for some reason it doesn't compile on the PS3 if assigned directly... + std::auto_ptr<TreeBinaryTree> TreeBinaryTree = TreeBinaryTreeBuilder::Build(*m_Database, m_Position, m_TerrainSize, treesPerBatch); + m_TreeBinaryTree = TreeBinaryTree; + } + m_RenderedBatches.clear(); + + DeleteTreeRenderers(); + m_LegacyTreeSceneNodes.resize_uninitialized(0); + m_LegacyTreeBoundingBoxes.resize_uninitialized(0); + m_TreeIndexToSceneNode.resize_uninitialized(0); + for (int i = 0; i < m_Database->GetInstances().size(); ++i) + { + CreateTreeRenderer(i); + } + } +} + +namespace { + // Encapsulate a single tree in the bounds + static void GetBounds (AABB& bounds, const TreeInstance& instance, const TreeDatabase::PrototypeVector& prototypes, const Vector3f& position, const Vector3f& scale) + { + Vector3f pos = Scale(instance.position, scale) + position; + Vector3f treeScale(instance.widthScale, instance.heightScale, instance.widthScale); + const AABB& pb = prototypes[instance.index].bounds; + bounds.SetCenterAndExtent(pos, Scale(treeScale, pb.GetExtent())); + } +} + +static void CalculateTreeBend (const AABB& bounds, float bendFactor, float time, Matrix4x4f& matrix, Vector4f& outWind) +{ + Vector4f force = WindManager::GetInstance().ComputeWindForce(bounds); + + const Vector3f& pos = bounds.GetCenter(); + + Vector3f quaternionAxis(force.z, 0, -force.x); + float magnitude = Magnitude(quaternionAxis); + if (magnitude > 0.00001f) + quaternionAxis = Normalize(quaternionAxis); + else + { + magnitude = 0; + quaternionAxis.z = 1; + } + + Vector2f additionBend( + PerlinNoise::NoiseNormalized(pos.x * 0.22F - time * 4.7F, pos.x * 9.005F) * 0.7f, + PerlinNoise::NoiseNormalized(pos.z * 0.22F - time * 4.3F, pos.z * 9.005F) * 0.5f + ); + + Quaternionf q = EulerToQuaternion(Vector3f(additionBend.x, 0, additionBend.y) * (bendFactor * kDeg2Rad * force.w));; + + float bend = 7 * bendFactor * kDeg2Rad * magnitude; + matrix.SetTRS(Vector3f::zero, AxisAngleToQuaternion(quaternionAxis, bend) * q, Vector3f::one); + outWind = force; +} + +static void RenderMeshIdentityMatrix (Mesh& mesh, Material& material, int layer, Camera& camera, const MaterialPropertyBlock& properties) +{ + Matrix4x4f matrix; + matrix.SetIdentity(); + + IntermediateRenderer* r = AddMeshIntermediateRenderer (matrix, &mesh, &material, layer, true, true, 0, &camera); + r->SetPropertyBlock (properties); +} + +const int kFrustumPlaneCount = 6; + +void TreeRenderer::Render(Camera& camera, const UNITY_VECTOR(kMemRenderer, Light*)& lights, float meshTreeDistance, float billboardTreeDistance, float crossFadeLength, int maximumMeshTrees, int layer) +{ + if (!m_TreeBinaryTree.get() || !m_Database) + return; + + RenderTexture::SetTemporarilyAllowIndieRenderTexture (true); + + // Graphics emulation might have changed, so we check for a change here + bool supportedNow = (RenderTexture::IsEnabled()); + if (supportedNow != m_ImposterRenderTexture->GetSupported()) + { + m_ImposterRenderTexture.reset(new ImposterRenderTexture(*m_Database)); + m_BillboardMaterial->SetTexture(ShaderLab::Property("_MainTex"), m_ImposterRenderTexture->GetTexture()); + } + + // If we don't support render textures or vertex shaders, there will be no + // billboards. + if (!m_ImposterRenderTexture->GetSupported()) + { + billboardTreeDistance = meshTreeDistance; + crossFadeLength = 0.0f; + } + + meshTreeDistance = std::min(billboardTreeDistance, meshTreeDistance); + crossFadeLength = clamp(crossFadeLength, 0.0F, billboardTreeDistance - meshTreeDistance); + m_CrossFadeLength = crossFadeLength; + m_SqrMeshTreeDistance = meshTreeDistance * meshTreeDistance; + m_SqrBillboardTreeDistance = billboardTreeDistance * billboardTreeDistance; + m_SqrCrossFadeEndDistance = (meshTreeDistance + m_CrossFadeLength) * (meshTreeDistance + m_CrossFadeLength); + + Transform& cameraTransform = camera.GetComponent(Transform); + const Vector3f& cameraPos = cameraTransform.GetPosition(); + Vector3f cameraDir = cameraTransform.TransformDirection(Vector3f::zAxis); + + Plane frustum[kFrustumPlaneCount]; + ExtractProjectionPlanes(camera.GetWorldToClipMatrix(), frustum); + + // Mark as becoming invisible + std::vector<TreeBinaryTree*> oldRenderedBatches = m_RenderedBatches; + for (std::vector<TreeBinaryTree*>::iterator it = oldRenderedBatches.begin(), end = oldRenderedBatches.end(); it != end; ++it) + { + TreeBinaryTree* binTree = *it; + + // We need to check if the tree is actually visible here, since it might have been + // pulled away from us while rebuilding the bintree or adding a single tree in the editor + if (binTree->visible == 1) + binTree->visible = -1; + } + m_RenderedBatches.clear(); + + m_FullTrees.clear(); + std::vector<int> billboardsList; + + // Build billboard meshes and stuff + +#if EMIT_ALL_TREE_RENDERERS + // calculate distance to camera: do this when we emit all tree renderers + // because renderer's skewFade will be using it + for (int i = 0; i < m_Database->GetInstances().size(); ++i) + { + TreeInstance& instance = m_Database->GetInstances()[i]; + Vector3f offset = GetPosition(instance) - cameraPos; + offset.y = 0.0F; + instance.temporaryDistance = SqrMagnitude(offset); + } +#endif + + // Collect all batches, billboards and full trees + // batches will be rendered in place + RenderRecurse(m_TreeBinaryTree.get(), frustum, billboardsList, cameraPos); + + // Cleanup the batches that have become invisible + for (std::vector<TreeBinaryTree*>::iterator it = oldRenderedBatches.begin(), end = oldRenderedBatches.end(); it != end; ++it) + { + TreeBinaryTree* binTree = *it; + + if (binTree->visible == -1) + { + DestroySingleObject(binTree->mesh); + binTree->mesh = 0; + binTree->visible = 0; + } + } + +#if !EMIT_ALL_TREE_RENDERERS + // Sort single trees back to front + std::sort(m_FullTrees.begin(), m_FullTrees.end(), TreeInstanceIndexSorter(m_Database->GetInstances())); + + // We are exceeding the mesh tree limit + // Move some trees into billboard list + if (m_FullTrees.size() > maximumMeshTrees) + { + int moveToBillboardCount = m_FullTrees.size() - maximumMeshTrees; + billboardsList.insert(billboardsList.end(), m_FullTrees.begin(), m_FullTrees.begin() + moveToBillboardCount); + m_FullTrees.erase(m_FullTrees.begin(), m_FullTrees.begin() + moveToBillboardCount); + } +#endif + + // Render the close by billboard mesh (Use immediate mode interface instead) + + // Sort billboards back to front + std::sort(billboardsList.begin(), billboardsList.end(), TreeInstanceIndexSorter(m_Database->GetInstances())); + + const int lightCount = std::min<int>(lights.size(), 4); + for (int i = 0; i < lightCount; ++i) + { + const Light* light = lights[i]; + const Transform& lightTransform = light->GetComponent(Transform); + Vector3f forward = RotateVectorByQuat (-lightTransform.GetRotation(), Vector3f::zAxis); + ShaderLab::g_GlobalProperties->SetVector(kTerrainTreeLightDirections[i], -forward.x, -forward.y, -forward.z, 0.0f); + ColorRGBAf color = light->GetColor() * light->GetIntensity(); + color = GammaToActiveColorSpace (color); + ShaderLab::g_GlobalProperties->SetVector(kTerrainTreeLightColors[i], color.GetPtr()); + } + for (int i = lightCount; i < 4; ++i) + ShaderLab::g_GlobalProperties->SetVector(kTerrainTreeLightColors[i], 0.0f, 0.0f, 0.0f, 0.0f); + + GetRenderSettings().SetupAmbient(); + + if (m_ImposterRenderTexture->GetSupported()) + m_ImposterRenderTexture->UpdateImposters (camera); + + // Setup billboard shader properties + UpdateShaderProps(camera); + + // Draw far away trees (only billboards) + for (std::vector<TreeBinaryTree*>::const_iterator it = m_RenderedBatches.begin(), end = m_RenderedBatches.end(); it != end; ++it) + { + RenderMeshIdentityMatrix (*(*it)->mesh, *m_BillboardMaterial, layer, camera, m_PropertyBlock); + } + + // Draw close by trees (billboard part for cross fade) + if (m_ImposterRenderTexture->GetSupported() && !billboardsList.empty()) + { + if (!m_CloseBillboardMesh) + { + m_CloseBillboardMesh = CreateObjectFromCode<Mesh>(kInstantiateOrCreateFromCodeAwakeFromLoad); + m_CloseBillboardMesh->SetHideFlags(Object::kDontSave); + m_CloseBillboardMesh->MarkDynamic(); // will be modified each frame, better use dynamic VBOs + } + GenerateBillboardMesh(*m_CloseBillboardMesh, billboardsList, true); + RenderMeshIdentityMatrix (*m_CloseBillboardMesh, *m_BillboardMaterial, layer, camera, m_PropertyBlock); + } + +#if EMIT_ALL_TREE_RENDERERS + // Draw all remaining trees (mesh part) +#else + // Draw close by trees (mesh part) +#endif + const float currentTime = GetTimeManager ().GetTimeSinceLevelLoad (); + + const ShaderLab::FastPropertyName propertyTerrainEngineBendTree = ShaderLab::Property("_TerrainEngineBendTree"); + const ShaderLab::FastPropertyName propertyColor = ShaderLab::Property("_Color"); + const ShaderLab::FastPropertyName propertyCutoff = ShaderLab::Property("_Cutoff"); + const ShaderLab::FastPropertyName propertyScale = ShaderLab::Property("_Scale"); + const ShaderLab::FastPropertyName propertySquashPlaneNormal = ShaderLab::Property("_SquashPlaneNormal"); + const ShaderLab::FastPropertyName propertySquashAmount = ShaderLab::Property("_SquashAmount"); + const ShaderLab::FastPropertyName propertyWind = ShaderLab::Property("_Wind"); + + float billboardOffsetFactor = 1; + if (m_ImposterRenderTexture->GetSupported()) + { + float tempBillboardAngleFactor; + m_ImposterRenderTexture->GetBillboardParams(tempBillboardAngleFactor, billboardOffsetFactor); + } + + for (std::vector<int>::iterator it = m_FullTrees.begin(), end = m_FullTrees.end(); it != end; ++it) + { + const TreeInstance& instance = m_Database->GetInstances()[*it]; + + const TreeDatabase::Prototype& prototype = m_Database->GetPrototypes()[instance.index]; + Mesh* mesh = prototype.mesh; + if (!mesh) + continue; + + const std::pair<int, int>& indexPair = m_TreeIndexToSceneNode[*it]; + if (indexPair.first == -1 || indexPair.second == 0) + { + continue; + } + + const std::vector<Material*>& materials = prototype.materials; + + float distance = sqrt(instance.temporaryDistance); + float skewFade = 1.0f; + // Skewfade is 1 when it looks like a real full mesh tree + // Skewfade is 0 where we switch to billboard + if (!CompareApproximately(crossFadeLength, 0.0F)) + skewFade = SmoothStep(0, 1, (meshTreeDistance + crossFadeLength - distance) / crossFadeLength); + float squashAmount = Lerp(0.04f, 1.0f, skewFade); + + // Only cast shadows from trees that are at full mesh appearance. + // When they start squashing, just stop casting shadows. + bool shadows = (skewFade >= 1.0f); + + AABB bounds; + GetBounds(bounds, instance, m_Database->GetPrototypes(), m_Position, m_TerrainSize); + + // Tree bending + Matrix4x4f rotate; + Vector4f wind; + CalculateTreeBend(bounds, skewFade * prototype.bendFactor, currentTime, rotate, wind); + + // we need to offset tree squash plane by the same amount as billboard is offsetted + const float centerOffset = prototype.treeWidth * instance.widthScale * 0.5F; + + // that will work as long as the trees are not rotated + // since the forward direction has to be in model space + Vector3f forward = cameraDir; + + ColorRGBAf treeColor = instance.color * instance.lightmapColor; + + int materialCount = std::min<int> (mesh->GetSubMeshCount(), materials.size()); + materialCount = std::min(materialCount, indexPair.second); + + for (int m = 0; m < materialCount; ++m) + { + m_PropertyBlock.Clear(); + m_PropertyBlock.AddPropertyMatrix(propertyTerrainEngineBendTree, rotate); + + ColorRGBAf color = prototype.originalMaterialColors[m] * treeColor; + + // Use the stored inverseAlphaCutoff value, since we're modifying the cutoff value + // in the material by using the property block below + float cutoff = 0.5f / prototype.inverseAlphaCutoff[m]; + + m_PropertyBlock.AddPropertyColor(propertyColor, color); + m_PropertyBlock.AddPropertyFloat(propertyCutoff, cutoff); + m_PropertyBlock.AddPropertyVector(propertyScale, Vector4f(instance.widthScale, instance.heightScale, instance.widthScale, 1)); + + // squash properties + // Position of squash plane has to match billboard plane - we use dual mode for billboard planes (see TerrainBillboardTree in TerrainEngine.cginc) + m_PropertyBlock.AddPropertyVector(propertySquashPlaneNormal, Vector4f(forward.x, forward.y, forward.z, centerOffset * billboardOffsetFactor)); + m_PropertyBlock.AddPropertyFloat(propertySquashAmount, squashAmount); + + m_PropertyBlock.AddPropertyVector(propertyWind, wind); + + SceneNode& sceneNode = m_LegacyTreeSceneNodes[indexPair.first + m]; + TreeMeshIntermediateRenderer* r = static_cast<TreeMeshIntermediateRenderer*>(sceneNode.renderer); + r->Update(layer, shadows, m_LightmapIndex != -1 ? 0xFE : -1, m_PropertyBlock); + sceneNode.layer = layer; + } + } + RenderTexture::SetTemporarilyAllowIndieRenderTexture (false); +} + +void TreeRenderer::CollectTreeRenderers(dynamic_array<SceneNode>& sceneNodes, dynamic_array<AABB>& boundingBoxes) +{ + for (int i = 0; i < m_FullTrees.size(); ++i) + { + const std::pair<int, int>& indexPair = m_TreeIndexToSceneNode[m_FullTrees[i]]; + if (indexPair.first == -1 || indexPair.second == 0) + { + continue; + } + + for (int j = 0; j < indexPair.second; ++j) + { + sceneNodes.push_back(m_LegacyTreeSceneNodes[indexPair.first + j]); + boundingBoxes.push_back(m_LegacyTreeBoundingBoxes[indexPair.first + j]); + } + } +} + + +// -------------------------------------------------------------------------- + + + +namespace +{ + template <class T, class A> + const T* GetData(const std::vector<T,A>& data) + { + return data.empty() ? 0 : &data.front(); + } + + float Calculate2DSqrDistance (const AABB& rkBox, const Vector3f& rkPoint) + { + // compute coordinates of point in box coordinate system + Vector3f kClosest = rkPoint - rkBox.GetCenter(); + kClosest.y = kClosest.z; + Vector3f extent = rkBox.GetExtent(); + extent.y = extent.z; + + // project test point onto box + float fSqrDistance = 0.0f; + float fDelta; + + for (int i = 0; i < 2; ++i) + { + if ( kClosest[i] < -extent[i] ) + { + fDelta = kClosest[i] + extent[i]; + fSqrDistance += fDelta * fDelta; + kClosest[i] = -extent[i]; + } + else if ( kClosest[i] > extent[i] ) + { + fDelta = kClosest[i] - extent[i]; + fSqrDistance += fDelta * fDelta; + kClosest[i] = extent[i]; + } + } + + return fSqrDistance; + } + + namespace SortUtility + { + static Vector3f sortDirections[] = { + Vector3f(-1, 0, 1), Vector3f(0, 0, 1), Vector3f(1, 0, 1), + Vector3f(-1, 0, 0), Vector3f(0, 0, 0), Vector3f(1, 0, 0), + Vector3f(-1, 0, -1), Vector3f(0, 0, -1), Vector3f(1, 0, -1) + }; + + const int insideBoundsDirection = 4; + + /* Because we want to do funky alpha blending instead of alpha cutoff (It looks SO MUCH BETTER) + We need to sort all patches. Now that would be really expensive, so we do a trick. + + We classify each patch by it's direction relative to the camera. + There are 8 potential directions. + 0 1 2 + 3 4 5 + 6 7 8 + + So every frame we check if the direction of the patch has changed and most of the time it doesn't. + Only when it changes do we resort. This lets us skip a lot of sorting. + Patches inside of the bounding volume are constantly being resorted, which is expensive but we can't do much about it! + */ + int CalculateTargetSortIndex (const AABB& bounds, const Vector3f& cameraPos) + { + MinMaxAABB aabb(bounds); + + int sortIndex = 0; + if (cameraPos.x > aabb.GetMax().x) + sortIndex += 2; + else if (cameraPos.x > aabb.GetMin().x) + sortIndex += 1; + + if (cameraPos.z > aabb.GetMax().z) + sortIndex += 0; + else if (cameraPos.z > aabb.GetMin().z) + sortIndex += 3; + else + sortIndex += 6; + + return sortIndex; + } + } + + struct BatchItem + { + int index; + float distance; + }; + + bool operator<(const BatchItem& soi1, const BatchItem& soi2) + { + return soi1.distance < soi2.distance; + } + + // Sorts a single batch by sort index (See SortUtility for more information) + void SortBatch (const TreeBinaryTree& tree, int sortIndex) + { + // Create sort order indices which are later used to build the sorted triangle indices + const std::vector<TreeInstance>& allInstances = tree.database->GetInstances(); + const std::vector<int>& instances = tree.instances; + const int size = instances.size(); + std::vector<BatchItem> sortOrder(size); + for (int i = 0; i < size; ++i) + sortOrder[i].index = i; + + if (sortIndex != SortUtility::insideBoundsDirection) + { + // Build array with distances + const Vector3f& direction = SortUtility::sortDirections[sortIndex]; + for (int i = 0; i < size; ++i) + sortOrder[i].distance = Dot(allInstances[instances[i]].position, direction); + + // Generate the sort order by sorting the sortDistances + std::sort(sortOrder.begin(), sortOrder.end()); + } + + // Build a triangle list from the sort order + UNITY_TEMP_VECTOR(UInt16) triangles(size * 6); + for (int i=0; i < size; ++i) + { + int triIndex = i * 6; + int vertexIndex = sortOrder[i].index * 4; + triangles[triIndex+0] = vertexIndex + 0; + triangles[triIndex+1] = vertexIndex + 1; + triangles[triIndex+2] = vertexIndex + 2; + triangles[triIndex+3] = vertexIndex + 2; + triangles[triIndex+4] = vertexIndex + 1; + triangles[triIndex+5] = vertexIndex + 3; + } + // Apply to mesh + tree.mesh->SetIndicesComplex (GetData(triangles), triangles.size(), 0, kPrimitiveTriangles, Mesh::k16BitIndices | Mesh::kDontSupportSubMeshVertexRanges); + } +} + + +void TreeRenderer::RenderRecurse(TreeBinaryTree* binTree, const Plane* planes, std::vector<int>& closeupBillboards, const Vector3f& cameraPos) +{ + // if we have exactly zero trees, we get null nodes a bit down - not sure why... + if (!binTree) + return; + + float sqrDistance = CalculateSqrDistance(cameraPos, binTree->bounds); + float sqr2DDistance = Calculate2DSqrDistance(binTree->bounds, cameraPos); + if (sqr2DDistance > m_SqrBillboardTreeDistance) + return; + + if (!IntersectAABBFrustumFull (binTree->bounds, planes)) + { +#if EMIT_ALL_TREE_RENDERERS + // we need to queue them as renderers since they might be visible in some shadow map + m_FullTrees.insert(m_FullTrees.end(), binTree->instances.begin(), binTree->instances.end()); +#endif + return; + } + + // Recurse children + if (binTree->instances.empty()) + { + if (binTree->splittingPlane.GetSide(cameraPos)) + { + RenderRecurse(binTree->right.get(), planes, closeupBillboards, cameraPos); + RenderRecurse(binTree->left.get(), planes, closeupBillboards, cameraPos); + } + else + { + RenderRecurse(binTree->left.get(), planes, closeupBillboards, cameraPos); + RenderRecurse(binTree->right.get(), planes, closeupBillboards, cameraPos); + } + } + // Render leaf node + else + { + // Render the trees as one big batch + if (sqr2DDistance > m_SqrCrossFadeEndDistance) + { + binTree->targetSortIndex = SortUtility::CalculateTargetSortIndex(binTree->bounds, cameraPos); + RenderBatch (*binTree, sqrDistance); + + if (binTree->targetSortIndex != binTree->sortIndex) + { + binTree->sortIndex = binTree->targetSortIndex; + SortBatch(*binTree, binTree->sortIndex); + } + } + // Render the trees individually + else + { + for (std::vector<int>::iterator it = binTree->instances.begin(), end = binTree->instances.end(); it != end; ++it) + { + TreeInstance& instance = m_Database->GetInstances()[*it]; + Vector3f position = GetPosition(instance); + Vector3f scale(instance.widthScale, instance.heightScale, instance.widthScale); + AABB treeBounds = m_Database->GetPrototypes()[instance.index].bounds; + treeBounds.SetCenterAndExtent(Scale(treeBounds.GetCenter(), scale) + position, Scale(treeBounds.GetExtent(), scale)); + +#if EMIT_ALL_TREE_RENDERERS + float indivdual2DSqrDistance = instance.temporaryDistance; + if (indivdual2DSqrDistance < m_SqrBillboardTreeDistance) + { + if (indivdual2DSqrDistance > m_SqrCrossFadeEndDistance + && IntersectAABBFrustumFull (treeBounds, planes)) + { + closeupBillboards.push_back(*it); + } + else + { + m_FullTrees.push_back(*it); + } + } +#else + if (!IntersectAABBFrustumFull (treeBounds, planes)) + continue; + + Vector3f offset = position - cameraPos; + offset.y = 0.0F; + float indivdual2DSqrDistance = SqrMagnitude(offset); + instance.temporaryDistance = indivdual2DSqrDistance; + + // Tree is close, render it as a mesh + if (indivdual2DSqrDistance < m_SqrCrossFadeEndDistance) + { + m_FullTrees.push_back(*it); + } + // Tree is still too far away, so render it as a billboard + else if (indivdual2DSqrDistance < m_SqrBillboardTreeDistance) + { + closeupBillboards.push_back(*it); + } +#endif + } + } + } +} + +void TreeRenderer::CleanupBillboardMeshes () +{ + for (std::vector<TreeBinaryTree*>::iterator it = m_RenderedBatches.begin(), end = m_RenderedBatches.end(); it != end; ++it) + { + TreeBinaryTree& binTree = **it; + if (binTree.visible != 0) + { + DestroySingleObject(binTree.mesh); + binTree.mesh = 0; + binTree.visible = 0; + } + } + + m_RenderedBatches.clear(); + + DestroySingleObject(m_CloseBillboardMesh); + m_CloseBillboardMesh = 0; +} + +void TreeRenderer::RenderBatch (TreeBinaryTree& binTree, float sqrDistance) +{ + if (binTree.visible == 0) + { + DestroySingleObject(binTree.mesh); + binTree.mesh = NULL; + + binTree.mesh = CreateObjectFromCode<Mesh>(kInstantiateOrCreateFromCodeAwakeFromLoad); + + binTree.mesh->SetHideFlags(Object::kDontSave); + binTree.mesh->SetName("tree billboard"); + GenerateBillboardMesh (*binTree.mesh, binTree.instances, false); + binTree.sortIndex = -1; + } + + binTree.visible = 1; + + m_RenderedBatches.push_back(&binTree); +} + +void TreeRenderer::UpdateShaderProps(const Camera& cam) +{ + const Transform& cameraTransform = cam.GetComponent(Transform); + const Vector3f& pos = cameraTransform.GetPosition(); + + // we want to get camera orientation from imposter in order to avoid any imprecisions + const Matrix4x4f& cameraMatrix = m_ImposterRenderTexture->getCameraOrientation(); + const Vector3f& right = cameraMatrix.GetAxisX(); + const Vector3f& up = cameraMatrix.GetAxisY(); + const Vector3f& front = cameraMatrix.GetAxisZ(); + + if (m_ImposterRenderTexture->GetSupported()) + { + float billboardAngleFactor, billboardOffsetFactor; + m_ImposterRenderTexture->GetBillboardParams(billboardAngleFactor, billboardOffsetFactor); + + m_PropertyBlock.Clear(); + m_PropertyBlock.AddPropertyVector(ShaderLab::Property("_TreeBillboardCameraRight"), Vector4f(right.x, right.y, right.z, 0.0F)); + m_PropertyBlock.AddPropertyVector(ShaderLab::Property("_TreeBillboardCameraUp"), Vector4f(up.x, up.y, up.z, billboardOffsetFactor)); + m_PropertyBlock.AddPropertyVector(ShaderLab::Property("_TreeBillboardCameraFront"), Vector4f(front.x, front.y, front.z, 0)); + m_PropertyBlock.AddPropertyVector(ShaderLab::Property("_TreeBillboardCameraPos"), Vector4f(pos.x, pos.y, pos.z, billboardAngleFactor)); + m_PropertyBlock.AddPropertyVector(ShaderLab::Property("_TreeBillboardDistances"), Vector4f(m_SqrBillboardTreeDistance,0,0,0)); + } +} + + +Vector3f TreeRenderer::GetPosition (const TreeInstance& instance) const +{ + return Scale(instance.position, m_TerrainSize) + m_Position; +} + +struct TreeBillboardVertex +{ + static const unsigned kFormat = VERTEX_FORMAT4(Vertex, TexCoord0, TexCoord1, Color); + + Vector3f p; + ColorRGBA32 color; + Vector2f uv, size; +}; + +void TreeRenderer::GenerateBillboardMesh(Mesh& mesh, const std::vector<int>& instances, bool buildTriangles) +{ + const std::vector<TreeInstance>& allInstances = m_Database->GetInstances(); + int treeCount = instances.size(); + + mesh.ResizeVertices (4 * treeCount, TreeBillboardVertex::kFormat); + TreeBillboardVertex* pv = (TreeBillboardVertex*)mesh.GetVertexDataPointer (); + bool swizzleColors = mesh.GetVertexColorsSwizzled(); + + AABB bounds; + + // Generate tree billboards + for (int i = 0; i < treeCount; ++i) + { + const TreeInstance& instance = allInstances[instances[i]]; + const TreeDatabase::Prototype& prototype = m_Database->GetPrototypes()[instance.index]; + + const Vector3f position = Scale(instance.position, m_TerrainSize) + m_Position; + ColorRGBAf color = instance.color; + color *= instance.lightmapColor; + + const float halfWidth = prototype.treeWidth * instance.widthScale * 0.5F; + const float halfHeight = prototype.treeHeight * instance.heightScale * 0.5F; + const float centerOffset = prototype.getCenterOffset() * instance.heightScale; + + //const float billboardTop = prototype.treeVisibleHeight * instance.heightScale; + //const float billboardBottom = (prototype.treeHeight - prototype.treeVisibleHeight) * instance.heightScale; + + const float billboardHeight = prototype.getBillboardHeight(); + const float billboardHeightDiff = (billboardHeight - prototype.treeHeight) / 2; + + const float billboardTop = (prototype.treeVisibleHeight + billboardHeightDiff) * instance.heightScale; + const float billboardBottom = (prototype.treeHeight - prototype.treeVisibleHeight + billboardHeightDiff) * instance.heightScale; + + const float billboardHalfHeight2 = prototype.getBillboardHeight() * instance.widthScale * 0.5F; + + // We position billboards at the root of the tree and offset billboard top and bottom differently (see billboardTop and billboardBottom) + // We blend between two modes (for billboard y axis in camera space): + // 1) vertical, which is based on billboardBottom and billboardTop + // 2) horizontal, which is based on billboardHalfHeight2 (the same for top and bottom) + // + // See TerrainBillboardTree in TerrainEngine.cginc for more detailed explanation + int index = i * 4; + pv[index + 0].p = position; + pv[index + 1].p = position; + pv[index + 2].p = position; + pv[index + 3].p = position; + + const Rectf& area = m_ImposterRenderTexture->GetArea(instance.index); + + // we're packing billboardHalfHeight2 into first uvs, and then recompute uvs.y by using formula uvs.y = uvs.y > 0 ? 1 : 0; + pv[index + 0].uv.Set(area.x, -billboardHalfHeight2); + pv[index + 1].uv.Set(area.GetRight(), -billboardHalfHeight2); + pv[index + 2].uv.Set(area.x, billboardHalfHeight2); + pv[index + 3].uv.Set(area.GetRight(), billboardHalfHeight2); + + pv[index + 0].size.Set(-halfWidth, -billboardBottom); + pv[index + 1].size.Set( halfWidth, -billboardBottom); + pv[index + 2].size.Set(-halfWidth, billboardTop); + pv[index + 3].size.Set( halfWidth, billboardTop); + + ColorRGBA32 color32 = (ColorRGBA32)color; + if (swizzleColors) + color32 = SwizzleColorForPlatform(color32); + pv[index + 0].color = pv[index + 1].color = pv[index + 2].color = pv[index + 3].color = color32; + + const Vector3f treeBounds(halfWidth, halfHeight, halfWidth); + const Vector3f treeCenter = position + Vector3f(0, centerOffset, 0); + if (0 == i) + { + bounds.SetCenterAndExtent(treeCenter, treeBounds); + } + else + { + bounds.Encapsulate(treeCenter + treeBounds); + bounds.Encapsulate(treeCenter - treeBounds); + } + } + + mesh.SetBounds(bounds); + mesh.SetChannelsDirty (mesh.GetAvailableChannels (), false); + + if (buildTriangles) + { + UNITY_TEMP_VECTOR(UInt16) triangles(instances.size() * 6); + for (int i = 0; i < instances.size(); ++i) + { + int triIndex = i * 6; + int vertexIndex = i * 4; + triangles[triIndex+0] = vertexIndex + 0; + triangles[triIndex+1] = vertexIndex + 1; + triangles[triIndex+2] = vertexIndex + 2; + triangles[triIndex+3] = vertexIndex + 2; + triangles[triIndex+4] = vertexIndex + 1; + triangles[triIndex+5] = vertexIndex + 3; + } + // Apply to mesh + mesh.SetIndicesComplex (GetData(triangles), triangles.size(), 0, kPrimitiveTriangles, Mesh::k16BitIndices | Mesh::kDontSupportSubMeshVertexRanges); + } +} + +void TreeRenderer::CreateTreeRenderer(int instance) +{ + const TreeInstance& tree = m_Database->GetInstances()[instance]; + + Assert(instance == m_TreeIndexToSceneNode.size()); + std::pair<int, int>& indexPair = m_TreeIndexToSceneNode.push_back(); + + const TreeDatabase::Prototype& prototype = m_Database->GetPrototypes()[tree.index]; + Mesh* mesh = prototype.mesh; + if (mesh == NULL) + { + indexPair.first = -1; + indexPair.second = 0; + return; + } + + const std::vector<Material*>& materials = prototype.materials; + + Matrix4x4f modelview; + modelview.SetTRS(GetPosition(tree), Quaternionf::identity(), Vector3f::one); + + const int materialCount = std::min<int> (mesh->GetSubMeshCount(), materials.size()); + + indexPair.first = m_LegacyTreeSceneNodes.size(); + indexPair.second = materialCount; + + for (int m = 0; m < materialCount; ++m) + { + AABB aabb = mesh->GetBounds(); + aabb.GetCenter().y += aabb.GetExtent().y * tree.heightScale - aabb.GetExtent().y; + aabb.SetCenterAndExtent (aabb.GetCenter(), Vector3f (aabb.GetExtent().x * tree.widthScale, aabb.GetExtent().y * tree.heightScale, aabb.GetExtent().z * tree.widthScale)); + + Assert(TreeMeshIntermediateRenderer::s_Allocator == NULL); + TreeMeshIntermediateRenderer::s_Allocator = &m_RendererAllocator; + TreeMeshIntermediateRenderer* r = new TreeMeshIntermediateRenderer(); + TreeMeshIntermediateRenderer::s_Allocator = NULL; + r->Initialize(modelview, mesh, aabb, materials[m], 0, false, false, m); + + m_LegacyTreeSceneNodes.push_back(SceneNode()); + SceneNode& node = m_LegacyTreeSceneNodes.back(); + node.renderer = r; + node.layer = 0; + + r->GetWorldAABB(m_LegacyTreeBoundingBoxes.push_back()); + } +} + +void TreeRenderer::DeleteTreeRenderers() +{ + Assert(TreeMeshIntermediateRenderer::s_Allocator == NULL); + TreeMeshIntermediateRenderer::s_Allocator = &m_RendererAllocator; + for (int i = 0; i < m_LegacyTreeSceneNodes.size(); ++i) + { + delete m_LegacyTreeSceneNodes[i].renderer; + } + TreeMeshIntermediateRenderer::s_Allocator = NULL; + +#if ENABLE_THREAD_CHECK_IN_ALLOCS + Assert(m_RendererAllocator.m_Allocated == 0); +#endif + m_RendererAllocator.purge(); +} + +#endif // ENABLE_TERRAIN |