Merge pull request #1253 from DelinWorks/instancing-support

Author: halx99

core/3d/Mesh.cpp

@@ -90,9 +90,61 @@ void Mesh::resetLightUniformValues()
     _spotLightUniformRangeInverseValues.assign(maxSpotLight, 0.0f);
 }
 
+
+
+void Mesh::enableInstancing(bool instance, int count)
+{
+    _instancing = instance;
+    _instanceCount = count;
+}
+
+void Mesh::setInstanceCount(int count) {
+    AXASSERT(_instancing, "Instancing should be enabled on this mesh.");
+
+    _instanceCount = count;
+}
+
+void Mesh::addInstanceChild(Node* child)
+{
+    AX_SAFE_RETAIN(child);
+    _instances.push_back(child);
+    _instanceTransformDirty = true;
+
+    if (_instances.size() > _instanceCount)
+    {
+        _instanceCount *= 2;
+        _instanceTransformBufferDirty = true;
+    }
+}
+
+void Mesh::shrinkToFitInstances()
+{
+    if (_instanceCount > _instances.size())
+    {
+        _instanceCount                = _instances.size();
+        _instanceTransformBufferDirty = true;
+    }
+}
+
+void Mesh::rebuildInstances()
+{
+    _instanceTransformDirty = true;
+}
+
+void Mesh::setDynamicInstancing(bool dynamic)
+{
+    _dynamicInstancing = dynamic;
+}
+
 Mesh::Mesh()
     : _skin(nullptr)
     , _visible(true)
+    , _instancing(false)
+    , _instanceTransformBuffer(nullptr)
+    , _instanceTransformBufferDirty(false)
+    , _instanceCount(0)
+    , _dynamicInstancing(false)
+    , _instanceMatrixCache(nullptr)
     , meshIndexFormat(CustomCommand::IndexFormat::U_SHORT)
     , _meshIndexData(nullptr)
     , _blend(BlendFunc::ALPHA_NON_PREMULTIPLIED)
@@ -103,12 +155,16 @@ Mesh::Mesh()
 Mesh::~Mesh()
 {
     for (auto&& tex : _textures)
-    {
         AX_SAFE_RELEASE(tex.second);
-    }
+
+    for (auto&& ins : _instances)
+        AX_SAFE_RELEASE(ins);
+
     AX_SAFE_RELEASE(_skin);
     AX_SAFE_RELEASE(_meshIndexData);
     AX_SAFE_RELEASE(_material);
+    AX_SAFE_RELEASE(_instanceTransformBuffer);
+    AX_SAFE_DELETE_ARRAY(_instanceMatrixCache);
 }
 
 backend::Buffer* Mesh::getVertexBuffer() const
@@ -343,7 +399,7 @@ void Mesh::setMaterial(Material* material)
                     auto& attributes     = program->getActiveAttributes();
                     auto meshVertexData = _meshIndexData->getMeshVertexData();
                     auto attributeCount = meshVertexData->getMeshVertexAttribCount();
-                    AXASSERT(attributes.size() <= attributeCount, "missing attribute data");
+                    //AXASSERT(attributes.size() <= attributeCount, "missing attribute data");
                 }
 #endif
                 // TODO
@@ -387,6 +443,56 @@ void Mesh::draw(Renderer* renderer,
     if (isTransparent)
         flags |= Node::FLAGS_RENDER_AS_3D;
 
+    if (_instancing && _instanceCount > 0)
+    {
+        if (!_instanceTransformBuffer || _instanceTransformBufferDirty)
+        {
+            AX_SAFE_RELEASE(_instanceTransformBuffer);
+
+            _instanceTransformBuffer = backend::Device::getInstance()->newBuffer(
+                _instanceCount * 64, backend::BufferType::VERTEX, backend::BufferUsage::DYNAMIC);
+
+            _instanceMatrixCache = new float[_instanceCount * 16];
+            for (int i = 0; i < _instanceCount; i++)
+            {
+                _instanceMatrixCache[i * 16 + 0]  = 1.0f;
+                _instanceMatrixCache[i * 16 + 1]  = 0.0f;
+                _instanceMatrixCache[i * 16 + 2]  = 0.0f;
+                _instanceMatrixCache[i * 16 + 3]  = 0.0f;
+                _instanceMatrixCache[i * 16 + 4]  = 0.0f;
+                _instanceMatrixCache[i * 16 + 5]  = 1.0f;
+                _instanceMatrixCache[i * 16 + 6]  = 0.0f;
+                _instanceMatrixCache[i * 16 + 7]  = 0.0f;
+                _instanceMatrixCache[i * 16 + 8]  = 0.0f;
+                _instanceMatrixCache[i * 16 + 9]  = 0.0f;
+                _instanceMatrixCache[i * 16 + 10] = 1.0f;
+                _instanceMatrixCache[i * 16 + 11] = 0.0f;
+                _instanceMatrixCache[i * 16 + 12] = 0.0f;
+                _instanceMatrixCache[i * 16 + 13] = 0.0f;
+                _instanceMatrixCache[i * 16 + 14] = 0.0f;
+                _instanceMatrixCache[i * 16 + 15] = 1.0f;
+            }
+
+            // Fill the buffer with identity matrix.
+            _instanceTransformBuffer->updateData(_instanceMatrixCache, _instanceCount * 64);
+
+            _instanceTransformBufferDirty = false;
+        }
+
+        if (_instanceTransformDirty || _dynamicInstancing)
+        {
+            _instanceTransformDirty = false;
+
+            int memOffset = 0;
+            for (auto& _ : _instances)
+            {
+                auto& mat = _->getNodeToParentTransform();
+                std::copy(mat.m, mat.m + 16, _instanceMatrixCache + 16 * memOffset++);
+            }
+            _instanceTransformBuffer->updateSubData(_instanceMatrixCache, 0, _instanceCount * 64);
+        }
+    }
+
     // TODO
     //     _meshCommand.init(globalZ,
     //                       _material,
@@ -428,6 +534,13 @@ void Mesh::draw(Renderer* renderer,
         command.setTransparent(isTransparent);
         command.set3D(!_material->isForce2DQueue());
         command.setWireframe(wireframe);
+        if (_instancing && _instances.size() > 0)
+        {
+            command.setDrawType(CustomCommand::DrawType::ELEMENT_INSTANCE);
+            command.setInstanceBuffer(_instanceTransformBuffer, _instances.size());
+        }
+        else if (_instancing)
+            return;
     }
 
     _meshIndexData->setPrimitiveType(_material->_drawPrimitive);

core/3d/Mesh.h

@@ -35,6 +35,7 @@
 #include "math/Math.h"
 #include "renderer/MeshCommand.h"
 #include "renderer/CustomCommand.h"
+#include "renderer/backend/Backend.h"
 
 NS_AX_BEGIN
 
@@ -242,6 +243,36 @@ class AX_DLL Mesh : public Ref
 
     std::string getTextureFileName() { return _texFile; }
 
+    void setInstanceCount(int count = 0);
+
+    /** Enables instancing for this Mesh Renderer, keep in mind that
+     a special vertex shader has to be used, make sure that your shader
+     has a mat4 attribute set on the location of total vertex attributes +1
+     */
+    void enableInstancing(bool instance, int count = 0);
+
+    /** Set this to true and instancing objects within this mesh renderer
+    will be recalculated each frame, use it when you plan to move objects,
+    Otherwise, transforms will be built once for better performance.
+    * to update transforms on demand use `rebuildInstances()` */
+    void setDynamicInstancing(bool dynamic);
+
+    /** Adds a child to use it's transformations for instancing.
+    * The child is in the space of this Node, keep in mind that
+    the node isn't added to the scene graph, it is instead retained
+    and it's parent is set to this node, updates and actions will not run.
+    * the reason for this is performance.
+    *
+    * @param child, The child to use for instancing.
+    */
+    void addInstanceChild(Node* child);
+
+    /** shrinks the instance transform buffer after many steps of expansion to increase performance. */
+    void shrinkToFitInstances();
+
+    /** rebuilds the instance transform buffer next frame. */
+    void rebuildInstances();
+
     Mesh();
     virtual ~Mesh();
 
@@ -254,6 +285,15 @@ class AX_DLL Mesh : public Ref
     MeshSkin* _skin;                                      // skin
     bool _visible;                                        // is the submesh visible
 
+    bool _instancing;
+    backend::Buffer* _instanceTransformBuffer;
+    bool _instanceTransformDirty;
+    bool _instanceTransformBufferDirty;
+    int _instanceCount;
+    std::vector<Node*> _instances;
+    float* _instanceMatrixCache;
+    bool _dynamicInstancing;
+
     CustomCommand::IndexFormat meshIndexFormat;
 
     std::string _name;

core/3d/MeshMaterial.cpp

@@ -40,6 +40,7 @@ MeshMaterialCache* MeshMaterialCache::_cacheInstance = nullptr;
 
 std::unordered_map<std::string, MeshMaterial*> MeshMaterial::_materials;
 MeshMaterial* MeshMaterial::_unLitMaterial         = nullptr;
+MeshMaterial* MeshMaterial::_unLitInstanceMaterial = nullptr;
 MeshMaterial* MeshMaterial::_unLitNoTexMaterial    = nullptr;
 MeshMaterial* MeshMaterial::_vertexLitMaterial     = nullptr;
 MeshMaterial* MeshMaterial::_diffuseMaterial       = nullptr;
@@ -55,6 +56,7 @@ MeshMaterial* MeshMaterial::_quadTextureMaterial = nullptr;
 MeshMaterial* MeshMaterial::_quadColorMaterial = nullptr;
 
 backend::ProgramState* MeshMaterial::_unLitMaterialProgState         = nullptr;
+backend::ProgramState* MeshMaterial::_unLitInstanceMaterialProgState = nullptr;
 backend::ProgramState* MeshMaterial::_unLitNoTexMaterialProgState    = nullptr;
 backend::ProgramState* MeshMaterial::_vertexLitMaterialProgState     = nullptr;
 backend::ProgramState* MeshMaterial::_diffuseMaterialProgState       = nullptr;
@@ -103,6 +105,14 @@ void MeshMaterial::createBuiltInMaterial()
         _unLitMaterial->_type = MeshMaterial::MaterialType::UNLIT;
     }
 
+    program                         = backend::Program::getBuiltinProgram(backend::ProgramType::POSITION_TEXTURE_3D_INSTANCE);
+    _unLitInstanceMaterialProgState = new backend::ProgramState(program);
+    _unLitInstanceMaterial  = new MeshMaterial();
+    if (_unLitInstanceMaterial && _unLitInstanceMaterial->initWithProgramState(_unLitInstanceMaterialProgState))
+    {
+        _unLitInstanceMaterial->_type = MeshMaterial::MaterialType::UNLIT_INSTANCE;
+    }
+
     program                      = backend::Program::getBuiltinProgram(backend::ProgramType::POSITION_3D);
     _unLitNoTexMaterialProgState = new backend::ProgramState(program);
     _unLitNoTexMaterial          = new MeshMaterial();
@@ -230,6 +240,10 @@ MeshMaterial* MeshMaterial::createBuiltInMaterial(MaterialType type, bool skinne
         material = skinned ? _unLitMaterialSkin : _unLitMaterial;
         break;
 
+    case MeshMaterial::MaterialType::UNLIT_INSTANCE:
+        material = skinned ? /* TODO: implement instanced hardware skinning */ nullptr : _unLitInstanceMaterial;
+        break;
+
     case MeshMaterial::MaterialType::UNLIT_NOTEX:
         material = _unLitNoTexMaterial;
         break;

core/3d/MeshMaterial.h

@@ -58,6 +58,7 @@ class AX_DLL MeshMaterial : public Material
     {
         // Built in materials
         UNLIT,           // unlit material
+        UNLIT_INSTANCE,  // unlit instance material
         UNLIT_NOTEX,     // unlit material (without texture)
         VERTEX_LIT,      // vertex lit
         DIFFUSE,         // diffuse (pixel lighting)
@@ -70,6 +71,18 @@ class AX_DLL MeshMaterial : public Material
         CUSTOM,  // Create from a material file
     };
 
+    /**
+     * Instanced Material types, there are mainly two types of materials. Built-in materials and Custom materials.
+     */
+    enum class InstanceMaterialType
+    {
+        NO_INSTANCING,  // disabled instancing
+        UNLIT_INSTANCE,  // unlit instance material
+
+        // Custom material
+        CUSTOM,  // Create from a material file
+    };
+
     /**
      * Get material type
      * @return Material type
@@ -124,6 +137,7 @@ class AX_DLL MeshMaterial : public Material
     MaterialType _type;
     static std::unordered_map<std::string, MeshMaterial*> _materials;  // cached material
     static MeshMaterial* _unLitMaterial;
+    static MeshMaterial* _unLitInstanceMaterial;
     static MeshMaterial* _unLitNoTexMaterial;
     static MeshMaterial* _vertexLitMaterial;
     static MeshMaterial* _diffuseMaterial;
@@ -139,6 +153,7 @@ class AX_DLL MeshMaterial : public Material
     static MeshMaterial* _quadColorMaterial;
 
     static backend::ProgramState* _unLitMaterialProgState;
+    static backend::ProgramState* _unLitInstanceMaterialProgState;
     static backend::ProgramState* _unLitNoTexMaterialProgState;
     static backend::ProgramState* _vertexLitMaterialProgState;
     static backend::ProgramState* _diffuseMaterialProgState;

core/3d/MeshRenderer.cpp

@@ -692,6 +692,63 @@ void MeshRenderer::setModelTexture(std::string_view modelPath, std::string_view
     }
 }
 
+void MeshRenderer::enableInstancing(MeshMaterial::InstanceMaterialType instanceMat, int count)
+{
+    switch (instanceMat)
+    {
+    case MeshMaterial::InstanceMaterialType::UNLIT_INSTANCE:
+    {
+        auto mat = MeshMaterial::createBuiltInMaterial(MeshMaterial::MaterialType::UNLIT_INSTANCE, false);
+        enableInstancing(mat, count);
+    }
+    }
+}
+
+void MeshRenderer::enableInstancing(MeshMaterial* instanceMat, int count)
+{
+    for (auto&& mesh : _meshes)
+    {
+        mesh->enableInstancing(true, MAX(1, count));
+        mesh->setMaterial(instanceMat);
+    }
+}
+
+void MeshRenderer::disableInstancing()
+{
+    for (auto&& mesh : _meshes)
+        mesh->enableInstancing(false, 0);
+}
+
+void MeshRenderer::setDynamicInstancing(bool dynamic)
+{
+    for (auto&& mesh : _meshes)
+        mesh->setDynamicInstancing(dynamic);
+}
+
+void MeshRenderer::addInstanceChild(Node* child, bool active)
+{
+    for (auto&& mesh : _meshes)
+    {
+        mesh->addInstanceChild(child);
+        if (active)
+            addChild(child);
+        else
+            child->setParent(this);
+    }
+}
+
+void MeshRenderer::shrinkToFitInstances()
+{
+    for (auto&& mesh : _meshes)
+        mesh->shrinkToFitInstances();
+}
+
+void MeshRenderer::rebuildInstances()
+{
+    for (auto&& mesh : _meshes)
+        mesh->rebuildInstances();
+}
+
 void MeshRenderer::setTexture(std::string_view texFile)
 {
     auto tex = _director->getTextureCache()->addImage(texFile);