instance.hpp

Go to the documentation of this file.

 
#ifndef FOOLSENGINE_INSTANCE
#define FOOLSENGINE_INSTANCE
 
#include <vector>
#include <string>
 
#include <glm/glm.hpp>
#include <GL/glew.h>
 
namespace ToyMaker {
    enum DefaultInstanceAttributeLocations : int {
        FIXED_MATRIXMODEL=7,
        RUNTIME=-8,
    };

    struct InstanceAttributeDescriptor {
        InstanceAttributeDescriptor(const std::string& name, const GLint layoutLocation, GLuint nComponents, GLenum type=GL_FLOAT) 
        : mName {name}, mLayoutLocation { layoutLocation }, 
            mNComponents {nComponents}, mType {type}, 
            mSize{GetGLTypeSize(type) * nComponents}
        {}

        const std::string mName;

        const GLint mLayoutLocation;

        const GLuint mNComponents;

        const GLenum mType;

        const std::size_t mSize;

        bool operator==(const InstanceAttributeDescriptor& other) const {
            if(
                other.mName == mName 
                && other.mLayoutLocation == mLayoutLocation 
                && other.mNComponents == mNComponents
                && other.mType == mType
                && other.mSize == mSize
            ) return true;
            return false;   
        }
 
    private:
        static std::size_t GetGLTypeSize(GLenum type){
            std::size_t componentSize;
            switch(type) {
                case GL_FLOAT:
                    // fall through
                case GL_INT:
                    // fall through
                case GL_UNSIGNED_INT:
                    componentSize = sizeof(GLfloat);
                    break;
 
                default:
                    assert(false && "Unrecognized or unsupported type");
            }
            return componentSize;
        }
    };

    struct InstanceLayout {
    public:
        InstanceLayout(const std::vector<InstanceAttributeDescriptor>& attributeList) : mAttributeList{attributeList} {}

        std::vector<InstanceAttributeDescriptor> getAttributeList() const {
            return mAttributeList;
        }

        std::size_t computeStride() const {
            std::size_t stride {0};
            for(const auto& attribute: mAttributeList) {
                stride += attribute.mSize;
            }
            return stride;
        }

        std::size_t computeRelativeOffset(std::size_t attributeIndex) const {
            assert(attributeIndex < mAttributeList.size());
            std::size_t baseOffset {0};
            for(std::size_t i{0} ; i < attributeIndex; ++i) {
                baseOffset += mAttributeList[i].mSize;
            }
            return baseOffset;
        }

        bool isSubsetOf(const InstanceLayout& other) const {
            if(mAttributeList.size() > other.mAttributeList.size()) return false;
 
            std::size_t myAttributeIndex {0};
            for(std::size_t i{0}; i < other.mAttributeList.size() && myAttributeIndex < mAttributeList.size(); ++i) {
                if(other.mAttributeList[i] == mAttributeList[myAttributeIndex]) {
                    ++ myAttributeIndex;
                    if(myAttributeIndex == mAttributeList.size()) return true;
                }
            }
 
            return false;
        }
 
    private:
        std::vector<InstanceAttributeDescriptor> mAttributeList;
    };

    class BaseInstanceAllocator {
    public:
        BaseInstanceAllocator(const InstanceLayout& instanceLayout)
        : mInstanceLayout(instanceLayout) 
        {}
 
        BaseInstanceAllocator(BaseInstanceAllocator&& other) = delete;
        BaseInstanceAllocator(const BaseInstanceAllocator& other) = delete;
 
        BaseInstanceAllocator& operator=(BaseInstanceAllocator&& other) = delete;
        BaseInstanceAllocator& operator=(const BaseInstanceAllocator& other) = delete;

        virtual ~BaseInstanceAllocator();

        InstanceLayout getInstanceLayout() const;

        void bind(const InstanceLayout& shaderInstanceLayout);

        void unbind();

        bool isUploaded() { return mUploaded; }
 
    protected:
        virtual void upload() = 0;

        GLuint mVertexBufferIndex {0};
 
    private:
        void unload();

        void _upload();

        void setAttributePointers(const InstanceLayout& shaderInstanceLayout, std::size_t startingOffset = 0);

        InstanceLayout mInstanceLayout;

        bool mUploaded {false};
    };

    static InstanceLayout BuiltinModelMatrixLayout {
        {
            {"modelMatrixCol0", FIXED_MATRIXMODEL, 4, GL_FLOAT},
            {"modelMatrixCol1", FIXED_MATRIXMODEL+1, 4, GL_FLOAT},
            {"modelMatrixCol2", FIXED_MATRIXMODEL+2, 4, GL_FLOAT},
            {"modelMatrixCol3", FIXED_MATRIXMODEL+3, 4, GL_FLOAT},
        }
    };

    class BuiltinModelMatrixAllocator : public BaseInstanceAllocator {
    public:
        BuiltinModelMatrixAllocator(std::vector<glm::mat4> modelMatrices)
        : 
            BaseInstanceAllocator{ BuiltinModelMatrixLayout },
            mModelMatrices{modelMatrices}
        {}
 
    protected:
        virtual void upload() override;
 
    private:
        std::vector<glm::mat4> mModelMatrices;
    };
}
 
#endif