Material.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 "MaterialModel.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
 
#include "CeresEngine/Resource/Resource.hpp"
 
namespace CeresEngine {
 
    class Material : public TResource<Material> {
        CE_META_CLASS_FRIEND(Material);
        using super = TResource<Material>;
 
    public:
        using super::super;
    };
 
    class PBRMaterial : public TResource<PBRMaterial, Material> {
        CE_META_CLASS_FRIEND(PBRMaterial);
        using super = TResource<PBRMaterial, Material>;
 
    private:
        PBRMaterialModel mModel;
 
    public:
        Event<void(const PBRMaterialModel&)> didChangeModel;
 
    public:
        using super::super;
 
        explicit PBRMaterial(const PBRMaterialModel& model) { setModel(model); }
        explicit PBRMaterial(ResourceData& resourceData, const PBRMaterialModel& model) : super(resourceData) { setModel(model); }
 
    public:
#define CE_MATERIAL_MODEL_PROPERTY_ACCESSOR(NAME, FIELD, TYPE)                                                      \
    [[nodiscard]] inline const TYPE##MaterialProperty& get##NAME() const { return mModel.FIELD; }                   \
    [[nodiscard]] inline TYPE get##NAME##Value() { return mModel.FIELD.value; }                                     \
    [[nodiscard]] inline const HTexture& get##NAME##Texture() { return mModel.FIELD.texture; }                      \
    [[nodiscard]] inline const GPUSamplerDescriptor& get##NAME##Sampler() { return mModel.FIELD.sampler; }          \
    [[nodiscard]] inline const MaterialPropertySwizzle<TYPE>& get##NAME##Swizzle() { return mModel.FIELD.swizzle; } \
                                                                                                                    \
    inline void set##NAME(const TYPE##MaterialProperty& value) {                                                    \
        mModel.FIELD = value;                                                                                       \
        markAsDirty();                                                                                              \
        didChangeModel(mModel);                                                                                     \
    }                                                                                                               \
                                                                                                                    \
    inline void set##NAME(const TYPE& value) {                                                                      \
        mModel.FIELD = TYPE##MaterialProperty(value);                                                               \
        markAsDirty();                                                                                              \
        didChangeModel(mModel);                                                                                     \
    }                                                                                                               \
                                                                                                                    \
    inline void set##NAME##Value(const TYPE& value) {                                                               \
        mModel.FIELD.value = value;                                                                                 \
        markAsDirty();                                                                                              \
        didChangeModel(mModel);                                                                                     \
    }                                                                                                               \
                                                                                                                    \
    inline void set##NAME##Texture(const HTexture& texture) {                                                       \
        mModel.FIELD.texture = texture;                                                                             \
        markAsDirty();                                                                                              \
        didChangeModel(mModel);                                                                                     \
    }                                                                                                               \
                                                                                                                    \
    inline void set##NAME##Sampler(const GPUSamplerDescriptor& sampler) {                                           \
        mModel.FIELD.sampler = sampler;                                                                             \
        markAsDirty();                                                                                              \
        didChangeModel(mModel);                                                                                     \
    }                                                                                                               \
                                                                                                                    \
    inline void set##NAME##Swizzle(const MaterialPropertySwizzle<TYPE>& swizzle) {                                  \
        mModel.FIELD.swizzle = swizzle;                                                                             \
        markAsDirty();                                                                                              \
        didChangeModel(mModel);                                                                                     \
    }                                                                                                               \
                                                                                                                    \
    inline void set##NAME(const HTexture& texture, const TYPE& value = TYPE(1)) {                                   \
        mModel.FIELD.texture = texture;                                                                             \
        mModel.FIELD.value = value;                                                                                 \
        markAsDirty();                                                                                              \
        didChangeModel(mModel);                                                                                     \
    }
 
        CE_MATERIAL_MODEL_PROPERTY_ACCESSOR(BaseColor, baseColor, Color)
        CE_MATERIAL_MODEL_PROPERTY_ACCESSOR(Roughness, roughness, Double)
        CE_MATERIAL_MODEL_PROPERTY_ACCESSOR(Metallic, metallic, Double)
        CE_MATERIAL_MODEL_PROPERTY_ACCESSOR(Normal, normal, Vector3)
        CE_MATERIAL_MODEL_PROPERTY_ACCESSOR(Emission, emission, Color)
        CE_MATERIAL_MODEL_PROPERTY_ACCESSOR(Displacement, displacement, Vector3)
        CE_MATERIAL_MODEL_PROPERTY_ACCESSOR(AmbientOcclusion, ambientOcclusion, Double)
 
        [[nodiscard]] MaterialNormalMapSpace getNormalMapType() const { return mModel.normalMapSpace; }
 
        void setNormalMapSpace(const MaterialNormalMapSpace normalMapSpace) {
            mModel.normalMapSpace = normalMapSpace;
            markAsDirty();
        }
 
    public:
        template<typename Func> decltype(auto) changeModel(Func&& func) {
            func(mModel);
            markAsDirty();
            didChangeModel(mModel);
        }
 
        [[nodiscard]] const PBRMaterialModel& getModel() const { return mModel; }
 
        void setModel(const PBRMaterialModel& model) {
            mModel = model;
            markAsDirty();
            didChangeModel(mModel);
        }
    };
 
    class ShaderMaterial : public TResource<ShaderMaterial, Material> {
        CE_META_CLASS_FRIEND(ShaderMaterial);
        using super = TResource<ShaderMaterial, Material>;
 
    private:
        HShader mShader;
 
    public:
        explicit ShaderMaterial(const HShader& shader);
 
    public:
        [[nodiscard]] const HShader& getShader() const { return mShader; }
 
        void setShader(const HShader& shader);
    };
 
} // namespace CeresEngine