kmesh.h

Go to the documentation of this file.

 
#ifndef KMESH_H
#define KMESH_H
 
#include "kexport.h"
#include "kdriver.h"
 
#include <map>
#include <vector>
#include <string>
 
#include "kobject.h"
#include "kbone.h"
// (Skeletal animation is reached through the forward-declared kAnimator
// pointer below — no animation header needed at the mesh-header level.)
#include "kanimator.h"
 
namespace kemena
{
    class kAnimator;

    class KEMENA3D_API kMesh : public kObject
    {
    public:
        kMesh(kObject *parentNode = nullptr);

        ~kMesh();

        void setLoaded(bool newLoaded);

        bool getLoaded();

        void setFileName(kString newFileName);

        kString getFileName();

        void setRefName(kString newRefName);

        kString getRefName();

        void    setPrimitiveType(kString type);

        kString getPrimitiveType() const;

        void setPosition(kVec3 newPosition);
        void setRotation(kQuat newRotation);
        void setScale(kVec3 newScale);

        void reserveBoneData(size_t vertexCount);

        void reserveSpace(size_t vertexCount);

        void setBoneInfoMap(std::map<kString, kBoneInfo> newBoneInfoMap);

        std::map<kString, kBoneInfo> &getBoneInfoMap();

        int &getBoneCount();

        void setBoneCount(int newBoneCount);

        void addIndex(uint32_t index);

        std::vector<uint32_t> getIndices();

        void addVertex(kVec3 vertex);

        std::vector<kVec3> getVertices();

        void addUV(kVec2 uv);

        std::vector<kVec2> getUVs();

        void addVertexColor(kVec3 color);

        std::vector<kVec3> getVertexColors();

        void addNormal(kVec3 normal);

        std::vector<kVec3> getNormals();

        void addTangent(kVec3 tangent);

        std::vector<kVec3> getTangents();

        void addBitangent(kVec3 bitangent);

        std::vector<kVec3> getBitangents();

        void addBoneID(const kIvec4 &boneID);

        void setBoneID(size_t vertexIndex, const kIvec4 &boneID);

        kIvec4 getBoneID(size_t vertexIndex);

        std::vector<kIvec4> getBoneIDs();

        void setBoneIDs(std::vector<kIvec4> newBoneIDs);

        void addWeight(const kVec4 &weight);

        void setWeight(size_t vertexIndex, const kVec4 &weight);

        kVec4 getWeight(size_t vertexIndex);

        std::vector<kVec4> getWeights();

        void setWeights(std::vector<kVec4> newWeights);

        int getVertexCount();

        uint32_t getVertexArrayObject();

        uint32_t getVertexBuffer();

        uint32_t getVertexColorBuffer();

        void setNormalMatrix(kMat4 newNormalMatrix);

        kMat4 getNormalMatrix();

        void computeLocalAABB();

        kAABB getLocalAABB() const;

        kAABB getWorldAABB();

        void generateVbo();

        void generateTangents();

        void calculateNormalMatrix();

        void draw();

        json serialize();

        void deserialize(json data);

        void setVisible(bool newVisible);

        bool getVisible();

        void setCastShadow(bool newCastShadow);

        bool getCastShadow();

        void setReceiveShadow(bool newReceiveShadow);

        bool getReceiveShadow();

        void setVertexBoneData(size_t vertexID, int boneID, float weight);

        void setAnimator(kAnimator *newAnimator);

        kAnimator *getAnimator();

        void setSkinned(bool newSkinned);

        bool getSkinned();
 
    protected:
    private:
        bool loaded = false;
 
        kString fileName;
        kString refName;
        kString primitiveType; 
 
        std::vector<kVec3>     vertices;
        std::vector<uint32_t> indices;
        std::vector<kVec2>     uvs;
        std::vector<kVec3>     vertexColors;
        std::vector<kVec3>     normals;
        std::vector<kVec3>     tangents;
        std::vector<kVec3>     bitangents;
        std::vector<kIvec4>    boneIDs;
        std::vector<kVec4>     weights;
 
        uint32_t vao         = 0; 
        uint32_t indicesEbo  = 0; 
 
        uint32_t vertexBuffer      = 0; 
        uint32_t vertexColorBuffer = 0; 
        uint32_t uvBuffer          = 0; 
        uint32_t normalBuffer      = 0; 
        uint32_t tangentBuffer     = 0; 
        uint32_t bitangentBuffer   = 0; 
        uint32_t boneIDBuffer      = 0; 
        uint32_t weightBuffer      = 0; 
 
        kMat3 normalMatrix; 
 
        kAABB localAABB; 
 
        bool isVisible       = true;  
        bool isCastShadow    = true;  
        bool isReceiveShadow = true;  
 
        std::map<kString, kBoneInfo> boneInfoMap; 
        int boneCount = 0;                       
 
        kAnimator *animator = nullptr; 
        bool isSkinned = false;        
    };
}
 
#endif // KMESH_H