SceneObject.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Entity/Entity.hpp"
#include "CeresEngine/Math/Angle.hpp"
#include "CeresEngine/Math/Matrix.hpp"
#include "CeresEngine/Math/Quaternion.hpp"
#include "CeresEngine/Math/Transform.hpp"
#include "CeresEngine/Math/Vector.hpp"
 
namespace CeresEngine {
 
    struct CE_SCRIPT_EXPORT() TransformComponent final : public Component<TransformComponent> {
        CE_REFLECTABLE_STRUCT
        struct Accessor;
 
        CE_SCRIPT_EXPORT()
        Vector3 position = Vector3(0.0);
 
        CE_SCRIPT_EXPORT()
        Quaternion rotation = Quaternion(Vector3(0.0));
 
        CE_SCRIPT_EXPORT()
        Vector3 scale = Vector3(1.0);
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA(position);
            CE_REFL_DATA(rotation);
            CE_REFL_DATA(scale);
        }
    };
 
    struct CE_SCRIPT_EXPORT() TransformComponent::Accessor : public Component<TransformComponent>::Accessor {
        using Component<TransformComponent>::Accessor::Accessor;
 
    public: // Local space
        [[nodiscard]] const Vector3& getPosition() const noexcept;
 
        void setPosition(const Vector3& position) noexcept;
 
        [[nodiscard]] const Quaternion& getRotation() const noexcept;
 
        void setRotation(const Quaternion& rotation) noexcept;
 
        [[nodiscard]] const Vector3& getScale() const noexcept;
 
        void setScale(const Vector3& scale) noexcept;
 
        [[nodiscard]] Transform getTransform() const noexcept;
 
        void setTransform(const Transform& transform) noexcept;
 
        [[nodiscard]] Transform getInverseTransform() const noexcept;
 
        [[nodiscard]] Vector3 getDirection() const noexcept {
            const Matrix3 rotationMatrix = transpose(Matrix3(getRotation()));
            return normalize(rotationMatrix[2]); // front-facing vector.
        }
 
    public: // World space
        [[nodiscard]] Vector3 getWorldPosition() const noexcept;
 
        void setWorldPosition(const Vector3& position) noexcept;
 
        [[nodiscard]] Quaternion getWorldRotation() const noexcept;
 
        void setWorldRotation(const Quaternion& rotation) noexcept;
 
        [[nodiscard]] Vector3 getWorldScale() const noexcept;
 
        void setWorldScale(const Vector3& scale) noexcept;
 
        [[nodiscard]] Transform getWorldTransform() const noexcept;
 
        void setWorldTransform(const Transform& transform) noexcept;
 
        [[nodiscard]] Transform getInverseWorldTransform() const noexcept;
 
        [[nodiscard]] Vector3 getWorldDirection() const noexcept { return getWorldTransform().getDirection(); }
 
    public: // Apply transformations
        void move(const Vector3& distance);
 
        void move(const Vector3& direction, double distance);
 
        void rotate(const Quaternion& quaternion);
 
        void rotate(const Vector3& axis, const Radian& angle);
 
        void roll(const Radian& angle);
 
        void yaw(const Radian& angle);
 
        void pitch(const Radian& angle);
 
        void turn(const Radian& angle);
 
        void scale(const Vector3& factor);
 
        void scale(double factor);
 
        void transform(const Transform& transform);
 
    public: // Look at
        CE_SCRIPT_EXPORT()
        void lookAt(const Vector3& point) noexcept;
 
        CE_SCRIPT_EXPORT()
        void lookAt(const SceneObject& entity) noexcept;
 
    public: // Rotation
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Radian getLocalPitch() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setLocalPitch(const Radian& pitch) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Radian getLocalYaw() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setLocalYaw(const Radian& yaw) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Radian getLocalRoll() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setLocalRoll(const Radian& roll) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Radian getWorldPitch() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setWorldPitch(const Radian& pitch) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Radian getWorldYaw() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setWorldYaw(const Radian& yaw) noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Radian getWorldRoll() const noexcept;
 
        CE_SCRIPT_EXPORT()
        void setWorldRoll(const Radian& roll) noexcept;
 
    public: // Coordinate Transformation
        [[nodiscard]] Vector3 toWorld(const Vector3& localVector) const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 toLocal(const Vector3& worldVector) const noexcept;
 
    public: // Facing direction vectors
        [[nodiscard]] Facing getFacing() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getFront() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getBack() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getUp() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getDown() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getRight() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getLeft() const noexcept;
 
        [[nodiscard]] Facing getWorldFacing() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getWorldFront() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getWorldBack() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getWorldUp() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getWorldDown() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getWorldRight() const noexcept;
 
        [[nodiscard]] CE_SCRIPT_EXPORT()
        Vector3 getWorldLeft() const noexcept;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) {
            CE_REFL_DATA_GETSET(position, getPosition, setPosition);
            CE_REFL_DATA_GETSET(rotation, getRotation, setRotation);
            CE_REFL_DATA_GETSET(scale, getScale, setScale);
 
            CE_REFL_DATA_GETSET(worldPosition, getWorldPosition, setWorldPosition);
            CE_REFL_DATA_GETSET(worldRotation, getWorldRotation, setWorldRotation);
            CE_REFL_DATA_GETSET(worldScale, getWorldScale, setWorldScale);
 
            CE_REFL_DATA_GETSET(transform, getTransform, setTransform);
            CE_REFL_DATA_GET(inverseTransform, getInverseTransform);
            CE_REFL_DATA_GETSET(worldTransform, getWorldTransform, setWorldTransform);
            CE_REFL_DATA_GET(inverseWorldTransform, getInverseWorldTransform);
 
            CE_REFL_DATA_GET(front, getFront);
            CE_REFL_DATA_GET(back, getBack);
            CE_REFL_DATA_GET(up, getUp);
            CE_REFL_DATA_GET(down, getDown);
            CE_REFL_DATA_GET(right, getRight);
            CE_REFL_DATA_GET(left, getLeft);
        }
    };
 
    template<typename... Cs> class TSceneObject : public EntityObject<TransformComponent, Cs...> {
    public:
        using CeresEngine::EntityObject<TransformComponent, Cs...>::EntityObject;
 
    public:
        static inline constexpr Facing facingConvention = ::CeresEngine::facingConvention<double>;
    };
    extern template class TSceneObject<>;
 
    using SceneObject = TSceneObject<>;
 
} // namespace CeresEngine
 
CE_EXTERN_COMPONENT(CeresEngine::TransformComponent);
 
CE_REFLECT_HASH(CeresEngine::TransformComponent);
 
CE_ENTITY_OBJECT_HASH(CeresEngine::SceneObject);