implemented basic shader expressions

src/Engine/Material/BRDF.cpp

@@ -1,111 +0,0 @@
-#include "BRDF.h"
-#include <sstream>
-#include <fstream>
-#include <nlohmann/json.hpp>
-
-using namespace Seele;
-using json = nlohmann::json;
-
-List<BRDF*> BRDF::globalBRDFList;
-
-BRDF::BRDF(const char* name) 
-    : name(name)
-{
-    globalBRDFList.add(this);
-}
-
-BRDF::~BRDF() 
-{
-    globalBRDFList.remove(globalBRDFList.find(this));
-}
-
-
-BRDF* BRDF::getBRDFByName(const std::string& name) 
-{
-    for(auto brdf : globalBRDFList)
-    {
-        if(name.compare(brdf->name) == 0)
-        {
-            return brdf;
-        }
-    }
-    return nullptr;
-}
-
-List<BRDF*> BRDF::getBRDFList()
-{
-    return globalBRDFList;
-}
-
-BlinnPhong::BlinnPhong(const char* name) 
-    : BRDF(name)
-{   
-}
-
-BlinnPhong::~BlinnPhong()
-{
-}
-
-void BlinnPhong::generateMaterialCode(std::ofstream& codeStream, json codeJson) 
-{
-    std::stringstream accessorStream;
-
-    auto generateAccessor = [codeJson](std::stringstream& accessorStream, const std::string& key, const std::string& defaultVal)
-    {
-        if(codeJson.contains(key))
-        {
-            for(auto code : codeJson[key].items())
-            {
-                accessorStream << "\t\t" << code.value().get<std::string>() << ";" << std::endl;
-            }
-        }
-        else
-        {
-            accessorStream << "\t\treturn " << defaultVal << ";\n";
-        }
-        
-    };
-    accessorStream << "\tfloat3 getBaseColor(MaterialFragmentParameter input) {\n";
-    generateAccessor(accessorStream, "baseColor", "float3(0.5f, 0.5f, 0.5f)");
-    accessorStream << "\t}\n";
-
-    accessorStream << "\tfloat getMetallic(MaterialFragmentParameter input) {\n";
-    generateAccessor(accessorStream, "metallic", "0.f");
-    accessorStream << "\t}\n";
-    
-    accessorStream << "\tfloat3 getNormal(MaterialFragmentParameter input) {\n";
-    generateAccessor(accessorStream, "normal", "float3(0, 1, 0)");
-    accessorStream << "\t}\n";
-    
-    accessorStream << "\tfloat getSpecular(MaterialFragmentParameter input) {\n";
-    generateAccessor(accessorStream, "specular", "0.f");
-    accessorStream << "\t}\n";
-
-    accessorStream << "\tfloat getRoughness(MaterialFragmentParameter input) {\n";
-    generateAccessor(accessorStream, "roughness", "0.f");
-    accessorStream << "\t}\n";
-
-    accessorStream << "\tfloat getSheen(MaterialFragmentParameter input) {\n";
-    generateAccessor(accessorStream, "sheen", "0.f");
-    accessorStream << "\t}\n";
-    
-    accessorStream << "\tfloat3 getWorldOffset() {\n";
-    generateAccessor(accessorStream, "worldOffset", "0.f");
-    accessorStream << "\t}\n";
-
-    codeStream << accessorStream.str();
-
-    codeStream << "\ttypedef " << name << " BRDF;" << std::endl;
-    codeStream << "\t" << name << " prepare(MaterialFragmentParameter geometry) {" << std::endl;
-    codeStream << "\t\t" << name << " result;" << std::endl;
-    codeStream << "\t\tresult.baseColor = getBaseColor(geometry);" << std::endl;
-    codeStream << "\t\tresult.metallic = getMetallic(geometry);" << std::endl;
-    codeStream << "\t\tresult.normal = getNormal(geometry);" << std::endl;
-    codeStream << "\t\tresult.specular = getSpecular(geometry);" << std::endl;
-    codeStream << "\t\tresult.roughness = getRoughness(geometry);" << std::endl;
-    codeStream << "\t\tresult.sheen = getSheen(geometry);" << std::endl;
-    codeStream << "\t\treturn result;" << std::endl;
-    codeStream << "\t}" << std::endl;
-}
-
-IMPLEMENT_BRDF(BlinnPhong)

src/Engine/Material/BRDF.h

@@ -1,39 +0,0 @@
-#pragma once
-#include "MinimalEngine.h"
-#include "Containers/List.h"
-#include <nlohmann/json_fwd.hpp>
-
-namespace Seele
-{
-class BRDF
-{
-public:
-    static BRDF* getBRDFByName(const std::string& name);
-    static List<BRDF*> getBRDFList();
-
-    virtual void generateMaterialCode(std::ofstream& codeStream, nlohmann::json codeJson) = 0;
-protected:
-    BRDF(const char* name);
-    virtual ~BRDF();
-    static List<BRDF*> globalBRDFList;
-    const char* name;
-};
-
-#define DECLARE_BRDF(inputClass) \
-    public: \
-    static inputClass staticType;
-
-#define IMPLEMENT_BRDF(inputClass) \
-    inputClass inputClass::staticType( \
-        #inputClass);
-
-class BlinnPhong : public BRDF
-{
-    DECLARE_BRDF(BlinnPhong)
-public:
-    virtual void generateMaterialCode(std::ofstream& codeStream, nlohmann::json codeJson);
-protected:
-    BlinnPhong(const char* name);
-    virtual ~BlinnPhong();
-};
-} // namespace Seele

src/Engine/Material/CMakeLists.txt

@@ -1,7 +1,5 @@
 target_sources(Engine
     PRIVATE
-        BRDF.h
-        BRDF.cpp
         Material.h
         Material.cpp
         MaterialInstance.h
@@ -10,11 +8,10 @@ target_sources(Engine
         MaterialInterface.cpp
         ShaderExpression.h
         ShaderExpression.cpp)
-        
+
 target_sources(Engine
     PUBLIC FILE_SET HEADERS
         FILES
-            BRDF.h
             Material.h
             MaterialInstance.h
             MaterialInterface.h

src/Engine/Material/Material.cpp

@@ -9,10 +9,19 @@ using namespace Seele;
 Gfx::ShaderMap Material::shaderMap;
 std::mutex Material::shaderMapLock;
 
-Material::Material(Gfx::PGraphics graphics, Array<PShaderParameter> parameter, Gfx::PDescriptorLayout layout, uint32 uniformDataSize, uint32 uniformBinding, std::string materialName)
+Material::Material(Gfx::PGraphics graphics, 
+        Array<PShaderParameter> parameter, 
+        Gfx::PDescriptorLayout layout, 
+        uint32 uniformDataSize, 
+        uint32 uniformBinding, 
+        std::string materialName, 
+        Array<PShaderExpression> expressions, 
+        MaterialNode brdf)
     : MaterialInterface(graphics, parameter, uniformDataSize, uniformBinding)
     , layout(layout)
     , materialName(materialName)
+    , codeExpressions(expressions)
+    , brdf(brdf)
 {
 }
 
@@ -89,6 +98,34 @@ void Material::load(ArchiveBuffer& buffer)
     layout->create();
 }
 
+void Material::compile()
+{
+    std::ofstream codeStream("./shaders/generated/"+materialName+".slang");
+    codeStream << "import Material;\n";
+    codeStream << "import BRDF;\n";
+    codeStream << "import MaterialParameter;\n";
+    codeStream << "struct " << materialName << " : IMaterial {\n";
+    for(const auto& parameter : parameters)
+    {
+        parameter->generateDeclaration(codeStream);
+    }
+    codeStream << "\ttypedef " << brdf.profile << " BRDF;\n";
+    codeStream << "\t" << brdf.profile << " prepare(MaterialFragmentParameter input) {\n";
+    codeStream << "\t\t" << brdf.profile << " result;\n";
+    Map<int32, std::string> varState;
+    for(const auto& expr : codeExpressions)
+    {
+        codeStream << expr->evaluate(varState);
+    }
+    for(const auto& [name, exp] : brdf.variables)
+    {
+        codeStream << "\t\tresult." << name << " = " << varState[exp->key] << ";";
+    }
+    codeStream << "\t\treturn result;\n";
+    codeStream << "\t}\n";
+    codeStream << "};\n";
+}
+
 const Gfx::ShaderCollection* Material::getShaders(Gfx::RenderPassType renderPass, VertexInputType* vertexInput) const
 {
     Gfx::ShaderPermutation permutation;

src/Engine/Material/Material.h

@@ -8,7 +8,14 @@ class Material : public MaterialInterface
 {
 public:
     Material() {}
-    Material(Gfx::PGraphics graphics, Array<PShaderParameter> parameter, Gfx::PDescriptorLayout layout, uint32 uniformDataSize, uint32 uniformBinding, std::string materialName);
+    Material(Gfx::PGraphics graphics, 
+        Array<PShaderParameter> parameter, 
+        Gfx::PDescriptorLayout layout, 
+        uint32 uniformDataSize, 
+        uint32 uniformBinding, 
+        std::string materialName, 
+        Array<PShaderExpression> expressions, 
+        MaterialNode brdf);
     virtual ~Material();
     virtual Gfx::PDescriptorSet createDescriptorSet();
     virtual Gfx::PDescriptorLayout getDescriptorLayout() const { return layout; }
@@ -17,6 +24,8 @@ public:
     virtual void save(ArchiveBuffer& buffer) const;
     virtual void load(ArchiveBuffer& buffer);
 
+    void compile();
+
     virtual const Gfx::ShaderCollection* getShaders(Gfx::RenderPassType renderPass, VertexInputType* vertexInput) const;
     virtual Gfx::ShaderCollection& createShaders(Gfx::PGraphics graphics, Gfx::RenderPassType renderPass, VertexInputType* vertexInput);
 private:
@@ -25,6 +34,8 @@ private:
 
     Gfx::PDescriptorLayout layout;
     std::string materialName;
+    Array<PShaderExpression> codeExpressions;
+    MaterialNode brdf;
     // With draw-indirect, we batch vertex data into big vertex buffers
     // Gfx::PVertexDataManager vertexData;
 

src/Engine/Material/MaterialInterface.h

@@ -25,7 +25,7 @@ public:
     virtual Gfx::ShaderCollection& createShaders(Gfx::PGraphics graphics, Gfx::RenderPassType renderPass, VertexInputType* vertexInput) = 0;
 protected:
     Gfx::PGraphics graphics;
-    //For now its simply the collection of parameters, since there is no point for expressions
+    std::string brdfName;
     Array<PShaderParameter> parameters;
     Gfx::PUniformBuffer uniformBuffer;
     uint32 uniformDataSize;

src/Engine/Material/ShaderExpression.cpp

@@ -6,6 +6,16 @@
 
 using namespace Seele;
 
+void ShaderExpression::save(ArchiveBuffer& buffer) const
+{
+    Serialization::save(buffer, key);
+}
+
+void ShaderExpression::load(ArchiveBuffer& buffer)
+{
+    Serialization::load(buffer, key);
+}
+
 ShaderParameter::ShaderParameter(std::string name, uint32 byteOffset, uint32 binding) 
     : name(name)
     , byteOffset(byteOffset)
@@ -17,8 +27,15 @@ ShaderParameter::~ShaderParameter()
 {
 }
 
+std::string ShaderParameter::evaluate(Map<int32, std::string>& varState) const
+{
+    varState[key] = name;
+    return "";
+}
+
 void ShaderParameter::save(ArchiveBuffer& buffer) const
 {
+    ShaderExpression::save(buffer);
     Serialization::save(buffer, name);
     Serialization::save(buffer, byteOffset);
     Serialization::save(buffer, binding);
@@ -26,6 +43,7 @@ void ShaderParameter::save(ArchiveBuffer& buffer) const
 
 void ShaderParameter::load(ArchiveBuffer& buffer)
 {
+    ShaderExpression::load(buffer);
     Serialization::load(buffer, name);
     Serialization::load(buffer, byteOffset);
     Serialization::load(buffer, binding);
@@ -35,6 +53,8 @@ FloatParameter::FloatParameter(std::string name, uint32 byteOffset, uint32 bindi
     : ShaderParameter(name, byteOffset, binding)
     , data(0)
 {
+    output.name = name;
+    output.type = ExpressionType::FLOAT;
 }
 
 FloatParameter::~FloatParameter() 
@@ -58,22 +78,33 @@ void FloatParameter::updateDescriptorSet(Gfx::PDescriptorSet, uint8* dst)
     std::memcpy(dst + byteOffset, &data, sizeof(float));
 }
 
+void FloatParameter::generateDeclaration(std::ofstream& stream) const
+{
+    stream << "\tlayout(offset = " << byteOffset << ") float " << name << ";\n";
+}
+
 VectorParameter::VectorParameter(std::string name, uint32 byteOffset, uint32 binding) 
     : ShaderParameter(name, byteOffset, binding)
     , data()
 {
+    output.name = name;
+    output.type = ExpressionType::FLOAT3;
 }
 
 VectorParameter::~VectorParameter() 
 {
 }
 
-
 void VectorParameter::updateDescriptorSet(Gfx::PDescriptorSet, uint8* dst) 
 {
     std::memcpy(dst + byteOffset, &data, sizeof(Vector));
 }
 
+void VectorParameter::generateDeclaration(std::ofstream& stream) const
+{
+    stream << "\tlayout(offset = " << byteOffset << ") float3 " << name << ";\n";
+}
+
 void VectorParameter::save(ArchiveBuffer& buffer) const
 {
     ShaderParameter::save(buffer);
@@ -88,7 +119,9 @@ void VectorParameter::load(ArchiveBuffer& buffer)
 
 TextureParameter::TextureParameter(std::string name, uint32 byteOffset, uint32 binding) 
     : ShaderParameter(name, byteOffset, binding)
-{   
+{
+    output.name = name;
+    output.type = ExpressionType::TEXTURE;
 }
 
 TextureParameter::~TextureParameter() 
@@ -100,6 +133,11 @@ void TextureParameter::updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, ui
     descriptorSet->updateTexture(binding, data->getTexture());
 }
 
+void TextureParameter::generateDeclaration(std::ofstream& stream) const
+{
+    stream << "\tTexture2D " << name << ";\n";
+}
+
 void TextureParameter::save(ArchiveBuffer& buffer) const
 {
     ShaderParameter::save(buffer);
@@ -117,6 +155,8 @@ void TextureParameter::load(ArchiveBuffer& buffer)
 SamplerParameter::SamplerParameter(std::string name, uint32 byteOffset, uint32 binding) 
     : ShaderParameter(name, byteOffset, binding)
 {
+    output.name = name;
+    output.type = ExpressionType::SAMPLER;
 }
 
 SamplerParameter::~SamplerParameter() 
@@ -129,6 +169,10 @@ void SamplerParameter::updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, ui
     descriptorSet->updateSampler(binding, data);
 }
 
+void SamplerParameter::generateDeclaration(std::ofstream& stream) const
+{
+    stream << "\tSamplerState " << name << ";\n";
+}
 
 void SamplerParameter::save(ArchiveBuffer& buffer) const
 {
@@ -144,6 +188,8 @@ void SamplerParameter::load(ArchiveBuffer& buffer)
 CombinedTextureParameter::CombinedTextureParameter(std::string name, uint32 byteOffset, uint32 binding) 
     : ShaderParameter(name, byteOffset, binding)
 {
+    output.name = name;
+    output.type = ExpressionType::TEXTURE;
 }
 
 CombinedTextureParameter::~CombinedTextureParameter() 
@@ -151,12 +197,16 @@ CombinedTextureParameter::~CombinedTextureParameter()
     
 }
 
-
 void CombinedTextureParameter::updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8*) 
 {
     descriptorSet->updateTexture(binding, data->getTexture(), sampler);
 }
 
+void CombinedTextureParameter::generateDeclaration(std::ofstream& stream) const
+{
+    stream << "\tTexture2D " << name << ";\n";
+}
+
 void CombinedTextureParameter::save(ArchiveBuffer& buffer) const
 {
     ShaderParameter::save(buffer);
@@ -172,6 +222,213 @@ void CombinedTextureParameter::load(ArchiveBuffer& buffer)
     sampler = buffer.getGraphics()->createSamplerState({});
 }
 
+ConstantExpression::ConstantExpression()
+{
+}
+
+ConstantExpression::ConstantExpression(std::string expr, ExpressionType type)
+    : expr(expr)
+{
+    output.name = "cexpr";
+    output.type = type;
+}
+
+ConstantExpression::~ConstantExpression()
+{
+    
+}
+
+std::string ConstantExpression::evaluate(Map<int32, std::string>& varState) const 
+{
+    std::string varName = std::format("const_exp_{}", std::abs(key));
+    varState[key] = varName;
+    return std::format("let {} = {};\n", varName, expr);
+}
+
+void ConstantExpression::save(ArchiveBuffer& buffer) const 
+{
+    ShaderExpression::save(buffer);
+    Serialization::save(buffer, expr);
+}
+
+void ConstantExpression::load(ArchiveBuffer& buffer)
+{
+    ShaderExpression::load(buffer);
+    Serialization::load(buffer, expr);
+}
+
+AddExpression::AddExpression()
+{
+
+}
+
+AddExpression::~AddExpression()
+{
+    
+}
+
+std::string AddExpression::evaluate(Map<int32, std::string>& varState) const 
+{
+    std::string varName = std::format("exp_{}", key);
+    varState[key] = varName;
+    return std::format("let {} = {} + {};\n", varName, varState[inputs.at("lhs").source], varState[inputs.at("rhs").source]);
+}
+
+void AddExpression::save(ArchiveBuffer& buffer) const 
+{
+    ShaderExpression::save(buffer);
+}
+
+void AddExpression::load(ArchiveBuffer& buffer)
+{
+    ShaderExpression::load(buffer);
+}
+
+std::string SubExpression::evaluate(Map<int32, std::string>& varState) const 
+{
+    std::string varName = std::format("exp_{}", key);
+    varState[key] = varName;
+    return std::format("let {} = {} - {};\n", varName, varState[inputs.at("lhs").source], varState[inputs.at("rhs").source]);
+}
+
+void SubExpression::save(ArchiveBuffer& buffer) const 
+{
+    ShaderExpression::save(buffer);
+}
+
+void SubExpression::load(ArchiveBuffer& buffer)
+{
+    ShaderExpression::load(buffer);
+}
+
+std::string MulExpression::evaluate(Map<int32, std::string>& varState) const 
+{
+    std::string varName = std::format("exp_{}", key);
+    varState[key] = varName;
+    return std::format("let {} = mul({}, {});\n", varName, varState[inputs.at("lhs").source], varState[inputs.at("rhs").source]);
+}
+
+void MulExpression::save(ArchiveBuffer& buffer) const 
+{
+    ShaderExpression::save(buffer);
+}
+
+void MulExpression::load(ArchiveBuffer& buffer)
+{
+    ShaderExpression::load(buffer);
+}
+
+std::string SwizzleExpression::evaluate(Map<int32, std::string>& varState) const 
+{
+    std::string varName = std::format("exp_{}", key);
+    std::string swizzle = "";
+    for(uint32 i = 0; i < 4; ++i)
+    {
+        if(comp[i] == -1)
+        {
+            break;
+        }
+        switch (comp[i])
+        {
+        case 0:
+            swizzle += "x";
+            break;
+        case 1:
+            swizzle += "y";
+            break;
+        case 2:
+            swizzle += "z";
+            break;
+        case 3:
+            swizzle += "w";
+        default:
+            throw std::logic_error("invalid component");
+        }
+    }
+    varState[key] = varName;
+    return std::format("let {} = {}.{};\n", varName, varState[inputs.at("target").source], swizzle);
+}
+
+void SwizzleExpression::save(ArchiveBuffer& buffer) const 
+{
+    ShaderExpression::save(buffer);
+    Serialization::save(buffer, comp);
+}
+
+void SwizzleExpression::load(ArchiveBuffer& buffer)
+{
+    ShaderExpression::load(buffer);
+    Serialization::load(buffer, comp);
+}
+
+std::string SampleExpression::evaluate(Map<int32, std::string>& varState) const 
+{
+    std::string varName = std::format("exp_{}", key);
+    varState[key] = varName;
+    return std::format("let {} = {}.Sample({}, {});\n", varName, varState[inputs.at("texture").source], varState[inputs.at("sampler").source], varState[inputs.at("coords").source]);
+}
+
+void SampleExpression::save(ArchiveBuffer& buffer) const 
+{
+    ShaderExpression::save(buffer);
+}
+
+void SampleExpression::load(ArchiveBuffer& buffer)
+{
+    ShaderExpression::load(buffer);
+}
+
+void Serialization::save(ArchiveBuffer& buffer, const PShaderExpression& parameter)
+{
+    Serialization::save(buffer, parameter->getIdentifier());
+    parameter->save(buffer);
+}
+
+void Serialization::load(ArchiveBuffer& buffer, PShaderExpression& parameter)
+{
+    uint64 identifier = 0;
+    Serialization::load(buffer, identifier);
+    switch (identifier)
+    {
+    case FloatParameter::IDENTIFIER:
+        parameter = new FloatParameter();
+        break;
+    case VectorParameter::IDENTIFIER:
+        parameter = new VectorParameter();
+        break;
+    case TextureParameter::IDENTIFIER:
+        parameter = new TextureParameter();
+        break;
+    case SamplerParameter::IDENTIFIER:
+        parameter = new SamplerParameter();
+        break;
+    case CombinedTextureParameter::IDENTIFIER:
+        parameter = new CombinedTextureParameter();
+        break;
+    case ConstantExpression::IDENTIFIER:
+        parameter = new ConstantExpression();
+        break;
+    case AddExpression::IDENTIFIER:
+        parameter = new AddExpression();
+        break;
+    case SubExpression::IDENTIFIER:
+        parameter = new SubExpression();
+        break;
+    case MulExpression::IDENTIFIER:
+        parameter = new MulExpression();
+        break;
+    case SwizzleExpression::IDENTIFIER:
+        parameter = new SwizzleExpression();
+        break;
+    case SampleExpression::IDENTIFIER:
+        parameter = new SampleExpression();
+        break;
+    default:
+        throw std::runtime_error("Unknown Identifier");
+    }
+    parameter->load(buffer);
+}
+
 void Serialization::save(ArchiveBuffer& buffer, const PShaderParameter& parameter)
 {
     Serialization::save(buffer, parameter->getIdentifier());

src/Engine/Material/ShaderExpression.h

@@ -1,21 +1,44 @@
 #pragma once
 #include "MinimalEngine.h"
+#include "Containers/Map.h"
 #include "Math/Math.h"
 #include "Asset/TextureAsset.h"
 
 namespace Seele
 {
+enum class ExpressionType
+{
+    UNKNOWN,
+    FLOAT,
+    FLOAT2,
+    FLOAT3,
+    FLOAT4,
+    TEXTURE,
+    SAMPLER,
+};
 struct ExpressionInput
 {
-
+    int source;
+    ExpressionType type = ExpressionType::UNKNOWN;
 };
 struct ExpressionOutput
 {
-
+    std::string name;
+    ExpressionType type = ExpressionType::UNKNOWN;
 };
+DECLARE_REF(ShaderExpression);
 struct ShaderExpression
 {
+    Map<std::string, ExpressionInput> inputs;
+    ExpressionOutput output;
+    int32 key;
+    virtual uint64 getIdentifier() const = 0;
+    virtual std::string evaluate(Map<int32, std::string>& varState) const = 0;
+    virtual void save(ArchiveBuffer& buffer) const;
+    virtual void load(ArchiveBuffer& buffer);
 };
+DEFINE_REF(ShaderExpression)
+
 DECLARE_NAME_REF(Gfx, DescriptorSet)
 struct ShaderParameter : public ShaderExpression
 {
@@ -27,7 +50,9 @@ struct ShaderParameter : public ShaderExpression
     virtual ~ShaderParameter();
     // update a descriptorset, in case of a uniform buffer, copy the data to the dst + byteOffset
     virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) = 0;
+    virtual void generateDeclaration(std::ofstream& stream) const = 0;
     virtual uint64 getIdentifier() const = 0;
+    virtual std::string evaluate(Map<int32, std::string>& varState) const override;
     virtual void save(ArchiveBuffer& buffer) const;
     virtual void load(ArchiveBuffer& buffer);
 };
@@ -40,6 +65,7 @@ struct FloatParameter : public ShaderParameter
     FloatParameter(std::string name, uint32 byteOffset, uint32 binding);
     virtual ~FloatParameter();
     virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
+    virtual void generateDeclaration(std::ofstream& stream) const override;
     virtual uint64 getIdentifier() const override { return IDENTIFIER; }
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
@@ -53,6 +79,7 @@ struct VectorParameter : public ShaderParameter
     VectorParameter(std::string name, uint32 byteOffset, uint32 binding);
     virtual ~VectorParameter();
     virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
+    virtual void generateDeclaration(std::ofstream& stream) const override;
     virtual uint64 getIdentifier() const override { return IDENTIFIER; }
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
@@ -66,6 +93,7 @@ struct TextureParameter : public ShaderParameter
     TextureParameter(std::string name, uint32 byteOffset, uint32 binding);
     virtual ~TextureParameter();
     virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
+    virtual void generateDeclaration(std::ofstream& stream) const override;
     virtual uint64 getIdentifier() const override { return IDENTIFIER; }
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
@@ -80,6 +108,7 @@ struct SamplerParameter : public ShaderParameter
     SamplerParameter(std::string name, uint32 byteOffset, uint32 binding);
     virtual ~SamplerParameter();
     virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
+    virtual void generateDeclaration(std::ofstream& stream) const override;
     virtual uint64 getIdentifier() const override { return IDENTIFIER; }
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
@@ -94,13 +123,99 @@ struct CombinedTextureParameter : public ShaderParameter
     CombinedTextureParameter(std::string name, uint32 byteOffset, uint32 binding);
     virtual ~CombinedTextureParameter();
     virtual void updateDescriptorSet(Gfx::PDescriptorSet descriptorSet, uint8* dst) override;
+    virtual void generateDeclaration(std::ofstream& stream) const override;
     virtual uint64 getIdentifier() const override { return IDENTIFIER; }
     virtual void save(ArchiveBuffer& buffer) const override;
     virtual void load(ArchiveBuffer& buffer) override;
 };
 DEFINE_REF(CombinedTextureParameter)
+
+
+struct ConstantExpression : public ShaderExpression
+{
+    static constexpr uint64 IDENTIFIER = 0x11;
+    std::string expr;
+    ConstantExpression();
+    ConstantExpression(std::string expr, ExpressionType type);
+    virtual ~ConstantExpression();
+    virtual uint64 getIdentifier() const { return IDENTIFIER; }
+    virtual std::string evaluate(Map<int32, std::string>& varState) const override;
+    virtual void save(ArchiveBuffer& buffer) const override;
+    virtual void load(ArchiveBuffer& buffer) override;
+};
+DEFINE_REF(ConstantExpression)
+struct AddExpression : public ShaderExpression
+{
+    static constexpr uint64 IDENTIFIER = 0x12;
+    AddExpression();
+    virtual ~AddExpression();
+    virtual uint64 getIdentifier() const { return IDENTIFIER; }
+    virtual std::string evaluate(Map<int32, std::string>& varState) const override;
+    virtual void save(ArchiveBuffer& buffer) const override;
+    virtual void load(ArchiveBuffer& buffer) override;
+};
+DEFINE_REF(AddExpression)
+struct SubExpression : public ShaderExpression
+{
+    static constexpr uint64 IDENTIFIER = 0x13;
+    SubExpression() {}
+    virtual ~SubExpression() {}
+    virtual uint64 getIdentifier() const { return IDENTIFIER; }
+    virtual std::string evaluate(Map<int32, std::string>& varState) const override;
+    virtual void save(ArchiveBuffer& buffer) const override;
+    virtual void load(ArchiveBuffer& buffer) override;
+};
+DEFINE_REF(SubExpression)
+struct MulExpression : public ShaderExpression
+{
+    static constexpr uint64 IDENTIFIER = 0x14;
+    MulExpression() {}
+    virtual ~MulExpression() {}
+    virtual uint64 getIdentifier() const { return IDENTIFIER; }
+    virtual std::string evaluate(Map<int32, std::string>& varState) const override;
+    virtual void save(ArchiveBuffer& buffer) const override;
+    virtual void load(ArchiveBuffer& buffer) override;
+};
+DEFINE_REF(MulExpression)
+struct SwizzleExpression : public ShaderExpression
+{
+    static constexpr uint64 IDENTIFIER = 0x15;
+    StaticArray<int32, 4> comp = {-1, -1, -1, -1};
+    SwizzleExpression() {}
+    virtual ~SwizzleExpression() {}
+    virtual uint64 getIdentifier() const { return IDENTIFIER; }
+    virtual std::string evaluate(Map<int32, std::string>& varState) const override;
+    virtual void save(ArchiveBuffer& buffer) const override;
+    virtual void load(ArchiveBuffer& buffer) override;
+};
+DEFINE_REF(SwizzleExpression)
+struct SampleExpression : public ShaderExpression
+{
+    static constexpr uint64 IDENTIFIER = 0x16;
+    SampleExpression() {}
+    virtual ~SampleExpression() {}
+    virtual uint64 getIdentifier() const { return IDENTIFIER; }
+    virtual std::string evaluate(Map<int32, std::string>& varState) const override;
+    virtual void save(ArchiveBuffer& buffer) const override;
+    virtual void load(ArchiveBuffer& buffer) override;
+};
+DEFINE_REF(SampleExpression)
+
+struct MaterialNode
+{
+    std::string profile;
+    Map<std::string, PShaderExpression> variables;
+    MaterialNode() {}
+    virtual ~MaterialNode() {}
+    virtual std::string evaluate() const { return ""; }
+    void save(ArchiveBuffer& buffer) const;
+    void load(ArchiveBuffer& buffer);
+};
+DEFINE_REF(MaterialNode)
 namespace Serialization
 {
+    void save(ArchiveBuffer& buffer, const PShaderExpression& parameter);
+    void load(ArchiveBuffer& buffer, PShaderExpression& parameter);
     void save(ArchiveBuffer& buffer, const PShaderParameter& parameter);
     void load(ArchiveBuffer& buffer, PShaderParameter& parameter);
 } // namespace Serialization