mesh.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "vertexattribute.h"
 
// External includes
#include <gpumesh.h>
#include <memory>
#include <utility/dllexport.h>
#include <rtti/object.h>
#include <rtti/objectptr.h>
#include <nap/numeric.h>
#include <rtti/factory.h>
#include <nap/numeric.h>
 
namespace nap
{
    class RenderService;
    class Core;
 
    enum class EDrawMode : int32
    {
        Points          = 0,                
        Lines           = 1,                
        LineStrip       = 2,                
        Triangles       = 3,                
        TriangleStrip   = 4,                
        TriangleFan     = 5,                
        Unknown         = 0x7FFFFFFF,       
    };
 
 
    enum class ECullMode : int32
    {
        None            = 0,                
        Front           = 1,                
        Back            = 2,                
        FrontAndBack    = 3                 
    };
 
 
    enum class EPolygonMode : int32
    {
        Fill            = 0,                
        Line            = 1,                
        Point           = 2                 
    };
 
 
    // MeshShape
 
    struct NAPAPI MeshShape
    {
        int getNumIndices() const                                       { return mIndices.size(); }
 
        void clearIndices()                                             { mIndices.clear(); }
 
        void reserveIndices(size_t numIndices);
 
        void setIndices(uint32* indices, int numIndices);
 
        const std::vector<uint32>& getIndices() const                   { return mIndices; }
 
        std::vector<uint32>& getIndices()                               { return mIndices; }
 
        void addIndices(uint32* indices, int numIndices);
 
        void addIndex(uint32 index)                                     { mIndices.emplace_back(index); }
 
        uint32& operator[](std::size_t index)                           { return mIndices[index]; }
        
        const uint32& operator[](std::size_t index) const               { return mIndices[index]; }
 
        std::vector<uint32>         mIndices;       
    };
 
 
    // MeshProperties
 
    template<typename VERTEX_ATTRIBUTE_PTR>
    struct MeshProperties
    {
        using VertexAttributeList = std::vector<VERTEX_ATTRIBUTE_PTR>;
 
        int                     mNumVertices = 0;                   
        EMemoryUsage            mUsage = EMemoryUsage::Static;      
        EDrawMode               mDrawMode = EDrawMode::Triangles;   
        ECullMode               mCullMode = ECullMode::Back;        
        EPolygonMode            mPolygonMode = EPolygonMode::Fill;  
        VertexAttributeList     mAttributes;                        
        std::vector<MeshShape>  mShapes;                            
    };
 
    // ObjectPtr based mesh properties, used in serializable Mesh format (json/binary)
    using RTTIMeshProperties = MeshProperties<rtti::ObjectPtr<BaseVertexAttribute>>;
 
 
    // MeshInstance
 
    class NAPAPI MeshInstance
    {
        RTTI_ENABLE()
    public:
        // Default constructor
        MeshInstance(RenderService& renderService);
 
        // destructor
        virtual ~MeshInstance();
 
        bool init(utility::ErrorState& errorState);
 
        void copyMeshProperties(RTTIMeshProperties& meshProperties);
 
        GPUMesh& getGPUMesh() const;
 
        template<typename T>
        VertexAttribute<T>* findAttribute(const std::string& id);
 
        template<typename T>
        const VertexAttribute<T>* findAttribute(const std::string& id) const;
 
        template<typename T>
        VertexAttribute<T>& getAttribute(const std::string& id);
 
        template<typename T>
        const VertexAttribute<T>& getAttribute(const std::string& id) const;
 
        template<typename T>
        VertexAttribute<T>& getOrCreateAttribute(const std::string& id);
 
        void reserveVertices(size_t numVertices);
 
        void setNumVertices(int numVertices)                                    { mProperties.mNumVertices = numVertices; }
 
        int getNumVertices() const                                              { return mProperties.mNumVertices; }
 
        int getNumShapes() const                                                { return mProperties.mShapes.size(); }
 
        void setDrawMode(EDrawMode mode)                                        { mProperties.mDrawMode = mode; }
 
        EDrawMode getDrawMode() const                                           { return mProperties.mDrawMode; }
 
        void setCullMode(ECullMode mode)                                        { mProperties.mCullMode = mode; }
 
        ECullMode getCullMode() const                                           { return mProperties.mCullMode; }
 
        void setPolygonMode(EPolygonMode mode);
 
        EPolygonMode getPolygonMode() const                                     { return mProperties.mPolygonMode; }                            
 
        MeshShape& getShape(int index)                                          { return mProperties.mShapes[index]; }
 
        const MeshShape& getShape(int index) const                              { return mProperties.mShapes[index]; }
 
        MeshShape& createShape();
 
        void setUsage(EMemoryUsage inUsage)                                     { mProperties.mUsage = inUsage; }
 
        EMemoryUsage getUsage() const                                           { return mProperties.mUsage; }
 
        bool update(utility::ErrorState& errorState);
 
        bool update(nap::BaseVertexAttribute& attribute, utility::ErrorState& errorState);
 
    protected:
        bool initGPUData(utility::ErrorState& errorState);
 
    private:
        RenderService&                                          mRenderService;         
        MeshProperties<std::unique_ptr<BaseVertexAttribute>>    mProperties;            
        std::unique_ptr<GPUMesh>                                mGPUMesh;               
        bool                                                    mInitialized = false;   
    };
 
 
    // IMesh
 
    class IMesh : public Resource
    {
        RTTI_ENABLE(Resource)
    public:
        virtual MeshInstance& getMeshInstance() = 0;
 
        virtual const MeshInstance& getMeshInstance() const = 0;
    };
 
 
    // Mesh
 
    class Mesh : public IMesh
    {
        RTTI_ENABLE(IMesh)
    public:
        Mesh() = default;
 
        Mesh(Core& core);
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual MeshInstance& getMeshInstance() override;
 
        virtual const MeshInstance& getMeshInstance() const override;
 
        template<typename T>
        const VertexAttribute<T>* FindAttribute(const std::string& id) const;
 
        template<typename T>
        const VertexAttribute<T>& GetAttribute(const std::string& id) const;
 
        RTTIMeshProperties  mProperties;                
 
    private:
        std::unique_ptr<MeshInstance> mMeshInstance;    
        RenderService* mRenderService = nullptr;        
    };
 
 
    // Template definitions
 
    template<typename T>
    nap::VertexAttribute<T>* nap::MeshInstance::findAttribute(const std::string& id)
    {
        for (auto& attribute : mProperties.mAttributes)
            if (attribute->mAttributeID == id)
                return rtti_cast<VertexAttribute<T>>(attribute.get());
        return nullptr;
    }
 
    template<typename T>
    const VertexAttribute<T>* nap::MeshInstance::findAttribute(const std::string& id) const
    {
        for (auto& attribute : mProperties.mAttributes)
        {
            if (attribute->mAttributeID == id)
            {
                assert(attribute->get_type().is_derived_from(RTTI_OF(VertexAttribute<T>)));
                return static_cast<VertexAttribute<T>*>(attribute.get());
            }
        }
        return nullptr;
    }
 
    template<typename T>
    nap::VertexAttribute<T>& nap::MeshInstance::getAttribute(const std::string& id)
    {
        VertexAttribute<T>* attribute = findAttribute<T>(id);
        assert(attribute != nullptr);
        return *attribute;
    }
 
    template<typename T>
    const VertexAttribute<T>& nap::MeshInstance::getAttribute(const std::string& id) const
    {
        const VertexAttribute<T>* attribute = findAttribute<T>(id);
        assert(attribute != nullptr);
        return *attribute;
    }
 
    template<typename T>
    nap::VertexAttribute<T>& nap::MeshInstance::getOrCreateAttribute(const std::string& id)
    {
        for (auto& attribute : mProperties.mAttributes)
        {
            if (attribute->mAttributeID == id)
            {
                VertexAttribute<T>* result = rtti_cast<VertexAttribute<T>>(attribute.get());
                assert(result != nullptr); // Attribute found, but has wrong type!
                return *result;
            }
        }
 
        std::unique_ptr<VertexAttribute<T>> new_attribute = std::make_unique<VertexAttribute<T>>();
        new_attribute->mAttributeID = id;
        VertexAttribute<T>* result = new_attribute.get();
        mProperties.mAttributes.emplace_back(std::move(new_attribute));
 
        return *result;
    }
 
    template<typename T>
    const VertexAttribute<T>* nap::Mesh::FindAttribute(const std::string& id) const
    {
        for (auto& attribute : mProperties.mAttributes)
            if (attribute->mAttributeID == id)
                return static_cast<VertexAttribute<T>*>(attribute.get());
 
        return nullptr;
    }
 
 
    template<typename T>
    const VertexAttribute<T>& nap::Mesh::GetAttribute(const std::string& id) const
    {
        const VertexAttribute<T>* attribute = FindAttribute<T>(id);
        assert(attribute != nullptr);
        return *attribute;
    }
}