kobject.h

Go to the documentation of this file.

 
#ifndef KOBJECT_H
#define KOBJECT_H
 
#include "kexport.h"
#include "kdriver.h"
 
#include <iostream>
#include <string>
#include <vector>
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
#include <nlohmann/json.hpp>
 
#include "kdatatype.h"
#include "kmaterial.h"
#include "kscriptmanager.h"
#include "kphysicsobject.h"
#include "kcharactercontroller.h"
#include "knavmesh.h"
#include "kparticle.h"
#include "kaudiosource.h"
 
using json = nlohmann::json;
 
namespace kemena
{
    class KEMENA3D_API kObject
    {
    public:
        kObject(kObject *parentNode = nullptr);

        virtual ~kObject();

        kObject *getParent();

        void setParent(kObject *newParent);

        void detachFromParent();

        void setParentKeepTransform(kObject *newParent);

        std::vector<kObject *> getChildren();

        std::vector<kScript>& getScripts();

        void addScript(const kScript& script);

        void removeScript(const kString& uuid);
 
        // --- Particles -------------------------------------------------------

        std::vector<kParticle>& getParticles();

        void addParticle(const kParticle& particle);

        void removeParticle(const kString& uuid);
 
        // --- Audio sources ---------------------------------------------------

        std::vector<kAudioSource>& getAudioSources();

        void addAudioSource(const kAudioSource& source);

        void removeAudioSource(const kString& uuid);
 
        // --- Audio listener --------------------------------------------------

        std::vector<kAudioListener>& getAudioListeners();

        void addAudioListener(const kAudioListener& listener);

        void removeAudioListener(const kString& uuid);
 
        // --- Physics descriptor (editor-side config) -------------------------

        bool getHasPhysicsDesc() const;

        void setHasPhysicsDesc(bool val);

        kPhysicsObjectDesc& getPhysicsDesc();
 
        // --- Character controller descriptor (editor-side config) ------------

        bool getHasCharacterDesc() const;

        void setHasCharacterDesc(bool val);

        kCharacterControllerDesc& getCharacterDesc();
 
        // --- Navigation surface descriptor (editor-side config) -------------

        bool getHasNavMeshDesc() const;

        void setHasNavMeshDesc(bool val);

        kNavMeshDesc& getNavMeshDesc();

        kNodeType getType();

        void setType(kNodeType newType);

        bool getActive();

        void setActive(bool newActive);

        bool getStatic();

        void setStatic(bool newStatic);

        bool getDebugMode();

        void setDebugMode(bool newMode);

        unsigned int getId();

        void setId(unsigned int newId);

        kString getUuid();

        void setUuid(kString newUuid);

        kString getName();

        void setName(kString newName);

        kString getPrefabRef() const;

        void setPrefabRef(const kString &ref);

        kString getTemplateUuid() const;

        void setTemplateUuid(const kString &uuid);

        kVec3 getPosition();

        virtual void setPosition(kVec3 newPosition);

        kQuat getRotation();

        kVec3 getRotationEuler();

        virtual void setRotation(kQuat newRotation);

        kVec3 getScale();

        virtual void setScale(kVec3 newScale);

        kVec3 calculateRight();

        kVec3 calculateForward();

        kVec3 calculateUp();

        void rotate(kVec3 rotationAxis, float angularSpeed);

        kVec3 getGlobalPosition();

        kQuat getGlobalRotation();

        kVec3 getGlobalScale();

        void setMaterial(kMaterial *newMaterial, bool setChildren = true);

        kMaterial *getMaterial();

        void    setMaterialUuid(const kString &uuid) { materialUuid = uuid; }

        kString getMaterialUuid() const              { return materialUuid; }

        void setImportChild(bool v) { importChild = v; }

        bool getImportChild() const { return importChild; }

        void calculateModelMatrix();

        kMat4 getModelMatrixWorld();

        kMat4 getModelMatrixLocal();

        virtual void draw();

        virtual json serialize();

        virtual void deserialize(json data);
 
        // --- Physics ---------------------------------------------------------

        void attachPhysics(kPhysicsObject *physicsObj);

        void detachPhysics();

        kPhysicsObject *getPhysicsObject();

        void syncFromPhysics();
 
        // --- Character controller -------------------------------------------

        void attachCharacter(kCharacterController *character);

        void detachCharacter();

        kCharacterController *getCharacterController();

        void syncFromCharacter();
 
    protected:
    private:
        kObject *parent = nullptr;
        std::vector<kObject *> children;
 
        bool isActive   = true;
        bool isStatic   = false;
        bool debugMode  = false;
 
        kNodeType type = NODE_TYPE_OBJECT;
        unsigned int id = 0;
        kString uuid;
        kString name;
 
        kString prefabRef;     
        kString templateUuid;  
 
        kVec3 position = kVec3(0.0f, 0.0f, 0.0f);
        kQuat rotation = kQuat(kVec3(0.0f, 0.0f, 0.0f));
        kVec3 scale    = kVec3(1.0f, 1.0f, 1.0f);
 
        kMat4 localTransform = kMat4(1.0f); 
        kMat4 worldTransform = kMat4(1.0f); 
 
        kMaterial       *material      = nullptr;
        kString          materialUuid;  
        bool             importChild   = false; 
        kPhysicsObject  *physicsObject = nullptr;
 
        uint32_t iconVAO = 0;          
        uint32_t iconVertexBuffer = 0; 
        float iconVertices[12] =
        {
            -0.5f, -0.5f, 0.0f,
             0.5f, -0.5f, 0.0f,
            -0.5f,  0.5f, 0.0f,
             0.5f,  0.5f, 0.0f,
        };
 
        std::vector<kScript>       scripts;
        std::vector<kParticle>     particles;
        std::vector<kAudioSource>  audioSources;
        std::vector<kAudioListener>audioListeners;
 
        bool               hasPhysicsDesc = false;
        kPhysicsObjectDesc physicsDesc;
 
        bool                     hasCharacterDesc = false;
        kCharacterControllerDesc characterDesc;
        kCharacterController     *characterController = nullptr; 
 
        bool         hasNavMeshDesc = false;
        kNavMeshDesc navMeshDesc;
    };
}
 
#endif // KOBJECT_H