Component.h

浏览该文件的文档.

//
// Created by Administrator on 2025/8/25.
//
 
#ifndef COMPONENT_H
#define COMPONENT_H
#include "NameTag.h"
#include "../thirdparty/thirdparty.h"
#include <boost/describe.hpp>
#include "../core/UniformSlots.h"
namespace MQEngine {
    struct StaticMeshInstance
    {
        std::string modelUuid;          // 模型UUID，用于定位模型文件
        std::string meshName;           // 网格体名称，用于从模型中选择特定网格
        FCT::StaticMesh<uint32_t>* mesh; // 实际存储的mesh，默认为nullptr表示未加载
        
        StaticMeshInstance() : mesh(nullptr) {}
        
        StaticMeshInstance(const std::string& uuid, const std::string& name) 
            : modelUuid(uuid), meshName(name), mesh(nullptr)
        {
        }
        friend class boost::serialization::access;
 
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & modelUuid;
            ar & meshName;
        }
    };
    BOOST_DESCRIBE_STRUCT(StaticMeshInstance, (), (modelUuid, meshName))
 
    struct ENGINE_API TickerScriptComponent
    {
        std::string functionName;
 
        TickerScriptComponent() = default;
 
        TickerScriptComponent(const std::string& funcName)
            : functionName(funcName)
        {
        }
 
        friend class boost::serialization::access;
 
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & functionName;
        }
    };
    BOOST_DESCRIBE_STRUCT(TickerScriptComponent, (), (functionName))
 
    struct ENGINE_API OnStartScriptComponent
    {
        std::string functionName;
 
        OnStartScriptComponent() = default;
 
        OnStartScriptComponent(const std::string& funcName)
            : functionName(funcName)
        {
        }
 
        friend class boost::serialization::access;
 
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & functionName;
        }
    };
    BOOST_DESCRIBE_STRUCT(OnStartScriptComponent, (), (functionName))
 
    struct ENGINE_API DirectionalLightComponent
    {
        FCT::Vec3 direction = FCT::Vec3(0.0f, -1.0f, 0.0f);  // 光照方向
        FCT::Vec3 color = FCT::Vec3(1.0f, 1.0f, 1.0f);       // 光照颜色
        float intensity = 1.0f;                              // 光照强度
        bool enabled = true;                                  // 是否启用
        
        DirectionalLightComponent() = default;
        
        DirectionalLightComponent(const FCT::Vec3& dir, const FCT::Vec3& col, float intens, bool enable = true)
            : direction(dir), color(col), intensity(intens), enabled(enable)
        {
        }
        
        friend class boost::serialization::access;
 
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & direction;
            ar & color;
            ar & intensity;
            ar & enabled;
        }
    };
    BOOST_DESCRIBE_STRUCT(DirectionalLightComponent, (), (direction, color, intensity, enabled))
 
    struct ENGINE_API DiffuseTextureComponent
    {
        std::string modelUuid;          
        std::string texturePath;       
        FCT::Image* texture = nullptr;
        DiffuseTextureComponent() = default;
        
        DiffuseTextureComponent(const std::string& uuid, const std::string& path) 
            : modelUuid(uuid), texturePath(path)
        {
        }
        
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & modelUuid;
            ar & texturePath;
        }
    };
    BOOST_DESCRIBE_STRUCT(DiffuseTextureComponent, (), (modelUuid, texturePath))
 
    struct ENGINE_API NormalMapComponent
    {
        std::string modelUuid;
        std::string texturePath;
        FCT::Image* texture = nullptr;
        NormalMapComponent() = default;
 
        NormalMapComponent(const std::string& uuid, const std::string& path)
            : modelUuid(uuid), texturePath(path)
        {
        }
 
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & modelUuid;
            ar & texturePath;
        }
    };
    BOOST_DESCRIBE_STRUCT(NormalMapComponent, (), (modelUuid, texturePath))
 
    struct ENGINE_API ShininessComponent
    {
        float shininess = 32.0f;
        ShininessComponent() = default;
 
        ShininessComponent(float shininess)
            : shininess(shininess)
        {
        }
 
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & shininess;
        }
    };
    BOOST_DESCRIBE_STRUCT(ShininessComponent, (), (shininess))
 
    struct ENGINE_API CacheShininess
    {
        FCT::UniquePtr<FCT::Uniform> uniform;
        bool init = false;
 
        CacheShininess(FCT::Context* ctx)
        {
            uniform = FCT::makeUnique<FCT::Uniform>(ctx, ShininessUniformSlot);
        }
    };
}
 
#endif //COMPONENT_H