transformcomponent.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
 
// External Includes
#include "component.h"
 
// Local Includes
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
 
namespace nap
{
    class TransformComponentInstance;
 
    struct TransformProperties
    {
        glm::vec3       mTranslate      = { 0.0f, 0.0f, 0.0f };             
        glm::vec3       mRotate         = { 0.0f, 0.0f, 0.0f };             
        glm::vec3       mScale          = { 1.0f, 1.0f, 1.0f };             
        float           mUniformScale   = 1.0f;                             
    };
 
 
    struct TransformInstanceProperties
    {
        // Default constructor
        TransformInstanceProperties() = default;
 
        // Constructor
        TransformInstanceProperties(const glm::vec3& translate, const glm::quat& rotate, const glm::vec3& scale, float uniformScale) :
            mTranslate(translate), mRotate(rotate), mScale(scale), mUniformScale(uniformScale) {}
 
        glm::vec3       mTranslate      = { 0.0f, 0.0f, 0.0f };             // The translation of this component in units
        glm::quat       mRotate         = { 0.0f, 0.0f, 0.0f, 1.0f };       // The amount of rotation in degrees (yaw, pitch, roll)                                         
        glm::vec3       mScale          = { 1.0f, 1.0f, 1.0f };             // The scale of this component
        float           mUniformScale   = 1.0f;                             // The uniform scale of this component
    };
 
 
    class NAPAPI TransformComponent : public Component
    {
        RTTI_ENABLE(Component)
        DECLARE_COMPONENT(TransformComponent, TransformComponentInstance)
 
    public:
        TransformProperties mProperties;                                    
    };
 
 
    class NAPAPI TransformComponentInstance : public ComponentInstance
    {
        RTTI_ENABLE(ComponentInstance)
    public:
        TransformComponentInstance(EntityInstance& entity, Component& resource) :
            ComponentInstance(entity, resource)
        { }
        
        using ComponentInstance::update;
 
        virtual bool init(utility::ErrorState& errorState);
 
        const glm::mat4x4& getLocalTransform() const;
 
        void setLocalTransform(const glm::mat4x4& matrix);
 
        void overrideLocalTransform(const glm::mat4x4& matrix);
 
        const glm::mat4x4& getGlobalTransform() const;
 
        void setDirty();
 
        bool isDirty() const                            { return mWorldDirty; }
 
        void update(const glm::mat4& parentTransform);
 
        void setTranslate(const glm::vec3& translate);
        
        const glm::vec3& getTranslate() const           { return mTranslate;  }
 
        void setRotate(const glm::quat& rotate);
        
        const glm::quat& getRotate() const              { return mRotate; }
 
        void setScale(const glm::vec3& scale);
        
        const glm::vec3& getScale() const               { return mScale; }
 
        void setUniformScale(float scale);
        
        const float getUniformScale() const             { return mUniformScale; }
 
        TransformInstanceProperties getInstanceProperties() const;
 
        void setInstanceProperties(const TransformInstanceProperties& props);
 
    private:
        mutable bool mWorldDirty  = true;
 
        // Holds if the local matrix has been dirtied
        mutable bool mLocalDirty = true;
 
        // Local / Global Matrices
        mutable glm::mat4x4 mLocalMatrix;                           //< Local  Matrix
        mutable glm::mat4x4 mGlobalMatrix;                          //< Global Matrix
        
        // Local instance properties
        glm::vec3   mTranslate      = glm::vec3(0.0f, 0.0f, 0.0f);
        glm::quat   mRotate         = glm::quat();
        glm::vec3   mScale          = glm::vec3(1.0f, 1.0f, 1.0f);
        float       mUniformScale   = 1.0f;
    };
 
} // nap