MaterialGraphNode.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Graph/GraphNode.hpp"
#include "CeresEngine/Math/Vector.hpp"
 
namespace CeresEngine {
 
    class MaterialGraph;
    class MaterialGraphSocket;
 
    class MaterialGraphNode : public GraphNode {
        using super = GraphNode;
 
    public:
        using super::super;
 
    public:
    };
 
    class MaterialGraphOutputNode : public MaterialGraphNode {
        using super = MaterialGraphNode;
 
    public:
        MaterialGraphSocket& baseColor;
        MaterialGraphSocket& normal;
        MaterialGraphSocket& metallic;
        MaterialGraphSocket& roughness;
        MaterialGraphSocket& emissive;
 
    public:
        MaterialGraphOutputNode(MaterialGraph& graph, const UUID& uuid);
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> class MaterialGraphLiteralNode : public MaterialGraphOutputNode {
        using super = MaterialGraphOutputNode;
 
    public:
        T value;
        MaterialGraphSocket& output;
 
    public:
        MaterialGraphLiteralNode(MaterialGraph& graph, const UUID& uuid);
    };
 
    extern template class MaterialGraphLiteralNode<float>;
    extern template class MaterialGraphLiteralNode<Vector2f>;
    extern template class MaterialGraphLiteralNode<Vector3f>;
    extern template class MaterialGraphLiteralNode<Vector4f>;
 
    using MaterialGraphFloatLiteralNode = MaterialGraphLiteralNode<float>;
    using MaterialGraphVector2LiteralNode = MaterialGraphLiteralNode<Vector2f>;
    using MaterialGraphVector3LiteralNode = MaterialGraphLiteralNode<Vector3f>;
    using MaterialGraphVector4LiteralNode = MaterialGraphLiteralNode<Vector4f>;
 
    // ---------------------------------------------------------------------------------------------
 
#define CE_MATERIAL_GRAPH_NUMERIC_TYPES(F) \
    F(Float)                               \
    F(Vector2)                             \
    F(Vector3)                             \
    F(Vector4)
 
    enum class MaterialGraphMathOperation {
        Add,
        Subtract,
        Multiply,
        Divide,
        Max,
        Min,
    };
 
    template<typename T> class MaterialGraphMathNode : public MaterialGraphOutputNode {
        using super = MaterialGraphOutputNode;
 
    public:
        using super::super;
    };
 
#define CE_MATERIAL_GRAPH_MATH_NODE_T(T)            \
    extern template class MaterialGraphMathNode<T>; \
    using MaterialGraph##T##MathNode = MaterialGraphMathNode<T>;
    CE_MATERIAL_GRAPH_NUMERIC_TYPES(CE_MATERIAL_GRAPH_MATH_NODE_T)
#undef CE_MATERIAL_GRAPH_MATH_NODE_T
 
    template<typename T, MaterialGraphMathOperation O> class MaterialGraphBinaryMathNode : public MaterialGraphMathNode<T> {
        using super = MaterialGraphMathNode<T>;
 
    public:
        const MaterialGraphMathOperation operation;
        MaterialGraphSocket& lhs;
        MaterialGraphSocket& rhs;
        MaterialGraphSocket& output;
 
    public:
        MaterialGraphBinaryMathNode(MaterialGraph& graph, const UUID& uuid);
    };
 
#define CE_MATERIAL_GRAPH_MATH_NODE_T(T)                                                                         \
    extern template class MaterialGraphBinaryMathNode<T, MaterialGraphMathOperation::Add>;                       \
    using MaterialGraph##T##AddNode = MaterialGraphBinaryMathNode<T, MaterialGraphMathOperation::Add>;           \
                                                                                                                 \
    extern template class MaterialGraphBinaryMathNode<T, MaterialGraphMathOperation::Subtract>;                  \
    using MaterialGraph##T##SubtractNode = MaterialGraphBinaryMathNode<T, MaterialGraphMathOperation::Subtract>; \
                                                                                                                 \
    extern template class MaterialGraphBinaryMathNode<T, MaterialGraphMathOperation::Multiply>;                  \
    using MaterialGraph##T##MultiplyNode = MaterialGraphBinaryMathNode<T, MaterialGraphMathOperation::Multiply>; \
                                                                                                                 \
    extern template class MaterialGraphBinaryMathNode<T, MaterialGraphMathOperation::Divide>;                    \
    using MaterialGraph##T##DivideNode = MaterialGraphBinaryMathNode<T, MaterialGraphMathOperation::Divide>;
    CE_MATERIAL_GRAPH_NUMERIC_TYPES(CE_MATERIAL_GRAPH_MATH_NODE_T)
#undef CE_MATERIAL_GRAPH_MATH_NODE_T
 
} // namespace CeresEngine