From c4171b7b165db7f9e4ce701199bf323460a25c7e Mon Sep 17 00:00:00 2001
From: FlyAndNotDown <johnkindem@qq.com>
Date: Sun, 30 Mar 2025 12:28:22 +0800
Subject: [PATCH 1/3] feat: update README

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index f8da74f5e..57f1ef023 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 
-<center>
-    <div><img width="800" src=".github/resource/Logo.png" alt="Explosion Logo"/></div>
+<div>
+    <div><img width="400" src=".github/resource/Logo.png" alt="Explosion Logo"/></div>
     <div>
         <a href="https://app.codacy.com/gh/ExplosionEngine/Explosion/dashboard?branch=master">
             <img src="https://img.shields.io/codacy/grade/98afe27fd39b4b39b4c6acd8361e6d02?style=for-the-badge" alt="Codacy Grade"/>
@@ -10,7 +10,7 @@
         </a>
         <img src="https://img.shields.io/github/commit-activity/m/ExplosionEngine/Explosion?style=for-the-badge" alt="Commit Activity"/>
     </div>
-</center>
+</div>
 
 # Introduction
 

From cc6fa61177cf35f0abe0bbb9e07883316423e904 Mon Sep 17 00:00:00 2001
From: FlyAndNotDown <johnkindem@qq.com>
Date: Tue, 1 Apr 2025 21:06:39 +0800
Subject: [PATCH 2/3] feat: material update

---
 .../Source/Common/Include/Common/Concepts.h   |  18 +-
 .../Runtime/Include/Runtime/Asset/Material.h  | 231 +++++++++++-----
 .../Runtime/Include/Runtime/Asset/Mesh.h      |   2 +-
 Engine/Source/Runtime/Src/Asset/Material.cpp  | 257 ++++++++++++------
 4 files changed, 358 insertions(+), 150 deletions(-)

diff --git a/Engine/Source/Common/Include/Common/Concepts.h b/Engine/Source/Common/Include/Common/Concepts.h
index 3e82037d3..593cb4bea 100644
--- a/Engine/Source/Common/Include/Common/Concepts.h
+++ b/Engine/Source/Common/Include/Common/Concepts.h
@@ -14,6 +14,7 @@
 #include <unordered_map>
 #include <set>
 #include <map>
+#include <variant>
 
 namespace Common {
     template <typename T> concept BaseEqualComparable = requires(const T& lhs, const T& rhs) { { lhs == rhs } -> std::same_as<bool>; { lhs != rhs } -> std::same_as<bool>; };
@@ -64,12 +65,13 @@ namespace Common {
 
 namespace Common {
     // some types can perform operator== compare, but it requires element type also support operator== compare, so we test it further
-    template <typename T> struct EqualComparableTest<std::optional<T>> { static constexpr bool value = BaseEqualComparable<T>; };
-    template <typename T> struct EqualComparableTest<std::vector<T>> { static constexpr bool value = BaseEqualComparable<T>; };
-    template <typename T> struct EqualComparableTest<std::unordered_set<T>> { static constexpr bool value = BaseEqualComparable<T>; };
-    template <typename T> struct EqualComparableTest<std::set<T>> { static constexpr bool value = BaseEqualComparable<T>; };
-    template <typename T, size_t N> struct EqualComparableTest<std::array<T, N>> { static constexpr bool value = BaseEqualComparable<T>; };
-    template <typename K, typename V> struct EqualComparableTest<std::pair<K, V>> { static constexpr bool value = BaseEqualComparable<K> && BaseEqualComparable<V>; };
-    template <typename K, typename V> struct EqualComparableTest<std::unordered_map<K, V>> { static constexpr bool value = BaseEqualComparable<K> && BaseEqualComparable<V>; };
-    template <typename K, typename V> struct EqualComparableTest<std::map<K, V>> { static constexpr bool value = BaseEqualComparable<K> && BaseEqualComparable<V>; };
+    template <typename T> struct EqualComparableTest<std::optional<T>> { static constexpr bool value = EqualComparableTest<T>::value; };
+    template <typename T> struct EqualComparableTest<std::vector<T>> { static constexpr bool value = EqualComparableTest<T>::value; };
+    template <typename T> struct EqualComparableTest<std::unordered_set<T>> { static constexpr bool value = EqualComparableTest<T>::value; };
+    template <typename T> struct EqualComparableTest<std::set<T>> { static constexpr bool value = EqualComparableTest<T>::value; };
+    template <typename T, size_t N> struct EqualComparableTest<std::array<T, N>> { static constexpr bool value = EqualComparableTest<T>::value; };
+    template <typename K, typename V> struct EqualComparableTest<std::pair<K, V>> { static constexpr bool value = std::conjunction_v<EqualComparableTest<K>, EqualComparableTest<V>>; };
+    template <typename K, typename V> struct EqualComparableTest<std::unordered_map<K, V>> { static constexpr bool value = std::conjunction_v<EqualComparableTest<K>, EqualComparableTest<V>>; };
+    template <typename K, typename V> struct EqualComparableTest<std::map<K, V>> { static constexpr bool value = std::conjunction_v<EqualComparableTest<K>, EqualComparableTest<V>>; };
+    template <typename... T> struct EqualComparableTest<std::variant<T...>> { static constexpr bool value = std::conjunction_v<EqualComparableTest<T>...>; };
 }
diff --git a/Engine/Source/Runtime/Include/Runtime/Asset/Material.h b/Engine/Source/Runtime/Include/Runtime/Asset/Material.h
index a2bbba924..356c11762 100644
--- a/Engine/Source/Runtime/Include/Runtime/Asset/Material.h
+++ b/Engine/Source/Runtime/Include/Runtime/Asset/Material.h
@@ -8,8 +8,8 @@
 
 #include <Common/Math/Vector.h>
 #include <Common/Math/Matrix.h>
-
 #include <Runtime/Asset/Asset.h>
+#include <Runtime/Asset/Texture.h>
 #include <Runtime/Meta.h>
 #include <Runtime/Api.h>
 
@@ -21,98 +21,207 @@ namespace Runtime {
         max
     };
 
-    enum class EEnum() MaterialParameterType : uint8_t {
-        tInt,
-        tFloat,
-        tFVec2,
-        tFVec3,
-        tFVec4,
-        tFMat4x4,
-        max
+    struct RUNTIME_API EClass() MaterialBoolVariantField {
+        EClassBody(MaterialBoolVariantField)
+
+        MaterialBoolVariantField();
+
+        EProperty() bool defaultValue;
+        EProperty() uint8_t sortPriority;
     };
 
-    class RUNTIME_API EClass() MaterialParameter {
-        EClassBody(MaterialParameter)
+    struct RUNTIME_API EClass() MaterialRangedUintVariantField {
+        EClassBody(MaterialRangedUintVariantField)
 
-    public:
-        MaterialParameter();
-
-        EFunc() MaterialParameterType GetType() const;
-        EFunc() int32_t GetInt() const;
-        EFunc() float GetFloat() const;
-        EFunc() Common::FVec2 GetFVec2() const;
-        EFunc() Common::FVec3 GetFVec3() const;
-        EFunc() Common::FVec4 GetFVec4() const;
-        EFunc() Common::FMat4x4 GetFMat4x4() const;
-        EFunc() void SetInt(int32_t inValue);
-        EFunc() void SetFloat(float inValue);
-        EFunc() void SetFVec2(const Common::FVec2& inValue);
-        EFunc() void SetFVec3(const Common::FVec3& inValue);
-        EFunc() void SetFVec4(const Common::FVec4& inValue);
-        EFunc() void SetFMat4x4(const Common::FMat4x4& inValue);
+        MaterialRangedUintVariantField();
 
-    private:
-        std::variant<std::monostate, int32_t, float, Common::FVec2, Common::FVec3, Common::FVec4, Common::FMat4x4> parameter;
+        EProperty() uint8_t defaultValue;
+        EProperty() std::pair<uint8_t, uint8_t> range;
+        EProperty() uint8_t sortPriority;
     };
 
-    class RUNTIME_API EClass() IMaterial : public Asset {
-        EPolyClassBody(IMaterial)
+    struct RUNTIME_API EClass() MaterialBoolParameterField {
+        EClassBody(MaterialBoolParameterField)
 
-    public:
-        using ParameterMap = std::unordered_map<std::string, MaterialParameter>;
+        MaterialBoolParameterField();
+
+        EProperty() bool defaultValue;
+        EProperty() uint8_t sortPriority;
+    };
+
+    struct RUNTIME_API EClass() MaterialIntParameterField {
+        EClassBody(MaterialIntParameterField)
+
+        MaterialIntParameterField();
+
+        EProperty() int32_t defaultValue;
+        EProperty() std::optional<std::pair<int32_t, int32_t>> range;
+        EProperty() uint8_t sortPriority;
+    };
+
+    struct RUNTIME_API EClass() MaterialFloatParameterField {
+        EClassBody(MaterialFloatParameterField)
+
+        MaterialFloatParameterField();
+
+        EProperty() float defaultValue;
+        EProperty() std::optional<std::pair<float, float>> range;
+        EProperty() uint8_t sortPriority;
+    };
+
+    struct RUNTIME_API EClass() MaterialFVec2ParameterField {
+        EClassBody(MaterialFVec2ParameterField)
+
+        MaterialFVec2ParameterField();
+
+        EProperty() Common::FVec2 defaultValue;
+        EProperty() std::optional<std::pair<Common::FVec2, Common::FVec2>> range;
+        EProperty() uint8_t sortPriority;
+    };
+
+    struct RUNTIME_API EClass() MaterialFVec3ParameterField {
+        EClassBody(MaterialFVec3ParameterField)
 
-        ~IMaterial() override;
+        MaterialFVec3ParameterField();
 
-        EFunc() virtual MaterialType GetType() const = 0;
-        EFunc() virtual std::string GetSourceCode() const = 0;
-        EFunc() virtual void SetParameter(const std::string& inName, const MaterialParameter& inParameter) = 0;
-        EFunc() virtual ParameterMap& GetParameters() = 0;
-        EFunc() virtual const ParameterMap& GetParameters() const = 0;
+        EProperty() Common::FVec3 defaultValue;
+        EProperty() std::optional<std::pair<Common::FVec3, Common::FVec3>> range;
+        EProperty() uint8_t sortPriority;
+    };
+
+    struct RUNTIME_API EClass() MaterialFVec4ParameterField {
+        EClassBody(MaterialFVec4ParameterField)
+
+        MaterialFVec4ParameterField();
+
+        EProperty() Common::FVec4 defaultValue;
+        EProperty() std::optional<std::pair<Common::FVec4, Common::FVec4>> range;
+        EProperty() uint8_t sortPriority;
+    };
+
+    struct RUNTIME_API EClass() MaterialFMat4x4ParameterField {
+        EClassBody(MaterialFMat4x4ParameterField)
+
+        MaterialFMat4x4ParameterField();
+
+        EProperty() Common::FMat4x4 defaultValue;
+        EProperty() uint8_t sortPriority;
+    };
+
+    struct RUNTIME_API EClass() MaterialTextureParameterField {
+        EClassBody(MaterialTextureParameterField)
+
+        MaterialTextureParameterField();
 
-    protected:
-        explicit IMaterial(Core::Uri inUri);
+        EProperty() AssetPtr<Texture> defaultValue;
+        EProperty() uint8_t sortPriority;
     };
 
-    class RUNTIME_API EClass() Material final : public IMaterial {
+    struct RUNTIME_API EClass() MaterialRenderTargetParameterField {
+        EClassBody(MaterialRenderTargetParameterField)
+
+        MaterialRenderTargetParameterField();
+
+        EProperty() AssetPtr<RenderTarget> defaultValue;
+        EProperty() uint8_t sortPriority;
+    };
+
+    class RUNTIME_API EClass() Material final : public Asset {
         EPolyClassBody(Material)
 
     public:
-        explicit Material(Core::Uri inUri);
-        ~Material() override;
+        using VariantField = std::variant<
+            MaterialBoolVariantField,
+            MaterialRangedUintVariantField
+        >;
+        using VariantFieldMap = std::unordered_map<std::string, VariantField>;
+
+        using ParameterField = std::variant<
+            MaterialBoolParameterField,
+            MaterialIntParameterField,
+            MaterialFloatParameterField,
+            MaterialFVec2ParameterField,
+            MaterialFVec3ParameterField,
+            MaterialFVec4ParameterField,
+            MaterialFMat4x4ParameterField,
+            MaterialTextureParameterField,
+            MaterialRenderTargetParameterField
+        >;
+        using ParameterFieldMap = std::unordered_map<std::string, ParameterField>;
 
-        EFunc() MaterialType GetType() const override;
-        EFunc() std::string GetSourceCode() const override;
-        EFunc() void SetParameter(const std::string& inName, const MaterialParameter& inParameter) override;
-        EFunc() ParameterMap& GetParameters() override;
-        EFunc() const ParameterMap& GetParameters() const override;
+        explicit Material(Core::Uri inUri);
 
+        EFunc() MaterialType GetType() const;
         EFunc() void SetType(MaterialType inType);
-        EFunc() void SetSourceCode(const std::string& inSourceCode);
+        EFunc() const std::string& GetSource() const;
+        EFunc() void SetSource(const std::string& inSource);
+
+        EFunc() bool HasVariantField(const std::string& inName) const;
+        EFunc() VariantField& GetVariantField(const std::string& inName);
+        EFunc() const VariantField& GetVariantField(const std::string& inName) const;
+        EFunc() VariantField* FindVariantField(const std::string& inName);
+        EFunc() const VariantField* FindVariantField(const std::string& inName) const;
+        EFunc() VariantFieldMap& GetVariantFields();
+        EFunc() const VariantFieldMap& GetVariantFields() const;
+        EFunc() VariantField& EmplaceVariantField(const std::string& inName);
+
+        EFunc() bool HasParameterField(const std::string& inName) const;
+        EFunc() ParameterField& GetParameterField(const std::string& inName);
+        EFunc() const ParameterField& GetParameterField(const std::string& inName) const;
+        EFunc() ParameterField* FindParameterField(const std::string& inName);
+        EFunc() const ParameterField* FindParameterField(const std::string& inName) const;
+        EFunc() ParameterFieldMap& GetParameterFields();
+        EFunc() const ParameterFieldMap& GetParameterFields() const;
+        EFunc() ParameterField& EmplaceParameterField(const std::string& inName);
 
     private:
         EProperty() MaterialType type;
-        EProperty() std::string sourceCode;
-        EProperty() ParameterMap parameters;
+        EProperty() std::string source;
+        EProperty() VariantFieldMap variantFields;
+        EProperty() ParameterFieldMap parameterFields;
     };
 
-    class RUNTIME_API EClass() MaterialInstance final : public IMaterial {
+    class RUNTIME_API EClass() MaterialInstance final : public Asset {
         EPolyClassBody(MaterialInstance)
 
     public:
-        explicit MaterialInstance(Core::Uri inUri);
-        ~MaterialInstance() override;
+        using Variant = std::variant<
+            bool,
+            uint8_t
+        >;
+        using VariantMap = std::unordered_map<std::string, Variant>;
+
+        using Parameter = std::variant<
+            bool,
+            int32_t,
+            float,
+            Common::FVec2,
+            Common::FVec3,
+            Common::FVec4,
+            Common::FMat4x4,
+            AssetPtr<Texture>,
+            AssetPtr<RenderTarget>
+        >;
+        using ParameterMap = std::unordered_map<std::string, Parameter>;
 
-        EFunc() MaterialType GetType() const override;
-        EFunc() std::string GetSourceCode() const override;
-        EFunc() void SetParameter(const std::string& inName, const MaterialParameter& inParameter) override;
-        EFunc() ParameterMap& GetParameters() override;
-        EFunc() const ParameterMap& GetParameters() const override;
+        explicit MaterialInstance(Core::Uri inUri);
 
-        EFunc() AssetPtr<Material> GetMaterial() const;
+        EFunc() const AssetPtr<Material>& GetMaterial() const;
         EFunc() void SetMaterial(const AssetPtr<Material>& inMaterial);
 
+        EFunc() bool HasVariant(const std::string& inName) const;
+        EFunc() Variant GetVariant(const std::string& inName) const;
+        EFunc() void SetVariant(const std::string& inName, const Variant& inVariant);
+        EFunc() VariantMap GetVariants() const;
+
+        EFunc() bool HasParameter(const std::string& inName) const;
+        EFunc() Parameter GetParameter(const std::string& inName) const;
+        EFunc() void SetParameter(const std::string& inName, const Parameter& inParameter);
+        EFunc() ParameterMap GetParameters() const;
+
     private:
         EProperty() AssetPtr<Material> material;
+        EProperty() VariantMap variants;
         EProperty() ParameterMap parameters;
     };
 }
diff --git a/Engine/Source/Runtime/Include/Runtime/Asset/Mesh.h b/Engine/Source/Runtime/Include/Runtime/Asset/Mesh.h
index c7a87d467..7a8578421 100644
--- a/Engine/Source/Runtime/Include/Runtime/Asset/Mesh.h
+++ b/Engine/Source/Runtime/Include/Runtime/Asset/Mesh.h
@@ -40,7 +40,7 @@ namespace Runtime {
         ~StaticMesh() override;
 
     private:
-        EProperty() AssetPtr<IMaterial> material;
+        EProperty() AssetPtr<MaterialInstance> material;
         EProperty() std::vector<StaticMeshLOD> lodVec;
     };
 }
diff --git a/Engine/Source/Runtime/Src/Asset/Material.cpp b/Engine/Source/Runtime/Src/Asset/Material.cpp
index 85876cdea..ac6c71059 100644
--- a/Engine/Source/Runtime/Src/Asset/Material.cpp
+++ b/Engine/Source/Runtime/Src/Asset/Material.cpp
@@ -5,178 +5,275 @@
 #include <Runtime/Asset/Material.h>
 
 namespace Runtime {
-    MaterialParameter::MaterialParameter() = default;
+    MaterialBoolVariantField::MaterialBoolVariantField()
+        : defaultValue(false)
+        , sortPriority(0)
+    {
+    }
 
-    MaterialParameterType MaterialParameter::GetType() const
+    MaterialRangedUintVariantField::MaterialRangedUintVariantField()
+        : defaultValue(0)
+        , range(0, 0)
+        , sortPriority(0)
     {
-        constexpr MaterialParameterType vec[] = {
-            MaterialParameterType::max,
-            MaterialParameterType::tInt,
-            MaterialParameterType::tFloat,
-            MaterialParameterType::tFVec2,
-            MaterialParameterType::tFVec3,
-            MaterialParameterType::tFVec4,
-            MaterialParameterType::tFMat4x4
-        };
-        static_assert(sizeof(vec) / sizeof(MaterialParameterType) == std::variant_size_v<decltype(parameter)>);
-        return vec[parameter.index()];
     }
 
-    int32_t MaterialParameter::GetInt() const
+    MaterialBoolParameterField::MaterialBoolParameterField()
+        : defaultValue(false)
+        , sortPriority(0)
     {
-        Assert(GetType() == MaterialParameterType::tInt);
-        return std::get<int32_t>(parameter);
     }
 
-    float MaterialParameter::GetFloat() const
+    MaterialIntParameterField::MaterialIntParameterField()
+        : defaultValue(0)
+        , sortPriority(0)
     {
-        Assert(GetType() == MaterialParameterType::tFloat);
-        return std::get<float>(parameter);
     }
 
-    Common::FVec2 MaterialParameter::GetFVec2() const
+    MaterialFloatParameterField::MaterialFloatParameterField()
+        : defaultValue(0.0f)
+        , sortPriority(0)
     {
-        Assert(GetType() == MaterialParameterType::tFVec2);
-        return std::get<Common::FVec2>(parameter);
     }
 
-    Common::FVec3 MaterialParameter::GetFVec3() const
+    MaterialFVec2ParameterField::MaterialFVec2ParameterField()
+        : defaultValue(Common::FVec2Consts::zero)
+        , sortPriority(0)
     {
-        Assert(GetType() == MaterialParameterType::tFVec3);
-        return std::get<Common::FVec3>(parameter);
     }
 
-    Common::FVec4 MaterialParameter::GetFVec4() const
+    MaterialFVec3ParameterField::MaterialFVec3ParameterField()
+        : defaultValue(Common::FVec3Consts::zero)
+        , sortPriority(0)
     {
-        Assert(GetType() == MaterialParameterType::tFVec4);
-        return std::get<Common::FVec4>(parameter);
     }
 
-    Common::FMat4x4 MaterialParameter::GetFMat4x4() const
+    MaterialFVec4ParameterField::MaterialFVec4ParameterField()
+        : defaultValue(Common::FVec4Consts::zero)
+        , sortPriority(0)
     {
-        Assert(GetType() == MaterialParameterType::tFMat4x4);
-        return std::get<Common::FMat4x4>(parameter);
     }
 
-    void MaterialParameter::SetInt(int32_t inValue)
+    MaterialFMat4x4ParameterField::MaterialFMat4x4ParameterField()
+        : defaultValue(Common::FMat4x4Consts::identity)
+        , sortPriority(0)
     {
-        parameter = inValue;
     }
 
-    void MaterialParameter::SetFloat(float inValue)
+    MaterialTextureParameterField::MaterialTextureParameterField()
+        : sortPriority(0)
     {
-        parameter = inValue;
     }
 
-    void MaterialParameter::SetFVec2(const Common::FVec2& inValue)
+    MaterialRenderTargetParameterField::MaterialRenderTargetParameterField()
+        : sortPriority(0)
     {
-        parameter = inValue;
     }
 
-    void MaterialParameter::SetFVec3(const Common::FVec3& inValue)
+    Material::Material(Core::Uri inUri)
+        : Asset(std::move(inUri))
+        , type(MaterialType::max)
     {
-        parameter = inValue;
     }
 
-    void MaterialParameter::SetFVec4(const Common::FVec4& inValue)
+    MaterialType Material::GetType() const
     {
-        parameter = inValue;
+        return type;
     }
 
-    void MaterialParameter::SetFMat4x4(const Common::FMat4x4& inValue)
+    void Material::SetType(MaterialType inType)
     {
-        parameter = inValue;
+        type = inType;
     }
 
-    IMaterial::IMaterial(Core::Uri inUri)
-        : Asset(std::move(inUri))
+    const std::string& Material::GetSource() const
     {
+        return source;
     }
 
-    IMaterial::~IMaterial() = default;
+    void Material::SetSource(const std::string& inSource)
+    {
+        source = inSource;
+    }
 
-    Material::Material(Core::Uri inUri)
-        : IMaterial(std::move(inUri))
-        , type(MaterialType::max)
+    bool Material::HasVariantField(const std::string& inName) const
     {
+        return variantFields.contains(inName);
     }
 
-    Material::~Material() = default;
+    Material::VariantField& Material::GetVariantField(const std::string& inName)
+    {
+        return variantFields.at(inName);
+    }
 
-    MaterialType Material::GetType() const
+    const Material::VariantField& Material::GetVariantField(const std::string& inName) const
     {
-        return type;
+        return variantFields.at(inName);
     }
 
-    std::string Material::GetSourceCode() const
+    Material::VariantField* Material::FindVariantField(const std::string& inName)
     {
-        return sourceCode;
+        return HasVariantField(inName) ? &variantFields.at(inName) : nullptr;
     }
 
-    void Material::SetParameter(const std::string& inName, const MaterialParameter& inParameter)
+    const Material::VariantField* Material::FindVariantField(const std::string& inName) const
     {
-        parameters[inName] = inParameter;
+        return HasVariantField(inName) ? &variantFields.at(inName) : nullptr;
     }
 
-    void Material::SetType(MaterialType inType)
+    Material::VariantFieldMap& Material::GetVariantFields()
     {
-        type = inType;
+        return variantFields;
     }
 
-    void Material::SetSourceCode(const std::string& inSourceCode)
+    const Material::VariantFieldMap& Material::GetVariantFields() const
     {
-        sourceCode = inSourceCode;
+        return variantFields;
     }
 
-    IMaterial::ParameterMap& Material::GetParameters()
+    Material::VariantField& Material::EmplaceVariantField(const std::string& inName)
     {
-        return parameters;
+        variantFields.emplace(inName, Material::VariantField {});
+        return variantFields.at(inName);
     }
 
-    const IMaterial::ParameterMap& Material::GetParameters() const
+    bool Material::HasParameterField(const std::string& inName) const
     {
-        return parameters;
+        return parameterFields.contains(inName);
     }
 
-    MaterialInstance::MaterialInstance(Core::Uri inUri)
-        : IMaterial(std::move(inUri))
+    Material::ParameterField& Material::GetParameterField(const std::string& inName)
     {
+        return parameterFields.at(inName);
     }
 
-    MaterialInstance::~MaterialInstance() = default;
+    const Material::ParameterField& Material::GetParameterField(const std::string& inName) const
+    {
+        return parameterFields.at(inName);
+    }
 
-    MaterialType MaterialInstance::GetType() const
+    Material::ParameterField* Material::FindParameterField(const std::string& inName)
     {
-        return material->GetType();
+        return HasParameterField(inName) ? &parameterFields.at(inName) : nullptr;
     }
 
-    std::string MaterialInstance::GetSourceCode() const
+    const Material::ParameterField* Material::FindParameterField(const std::string& inName) const
     {
-        return material->GetSourceCode();
+        return HasParameterField(inName) ? &parameterFields.at(inName) : nullptr;
     }
 
-    void MaterialInstance::SetParameter(const std::string& inName, const MaterialParameter& inParameter)
+    Material::ParameterFieldMap& Material::GetParameterFields()
     {
-        parameters[inName] = inParameter;
+        return parameterFields;
     }
 
-    IMaterial::ParameterMap& MaterialInstance::GetParameters()
+    const Material::ParameterFieldMap& Material::GetParameterFields() const
     {
-        return parameters;
+        return parameterFields;
     }
 
-    const IMaterial::ParameterMap& MaterialInstance::GetParameters() const
+    Material::ParameterField& Material::EmplaceParameterField(const std::string& inName)
     {
-        return parameters;
+        parameterFields.emplace(inName, Material::ParameterField {});
+        return parameterFields.at(inName);
     }
 
-    AssetPtr<Material> MaterialInstance::GetMaterial() const
+    MaterialInstance::MaterialInstance(Core::Uri inUri)
+        : Asset(std::move(inUri))
+    {
+    }
+
+    const AssetPtr<Material>& MaterialInstance::GetMaterial() const
     {
         return material;
     }
 
-    void MaterialInstance::SetMaterial(const AssetPtr<Material>& inMaterial) // NOLINT
+    void MaterialInstance::SetMaterial(const AssetPtr<Material>& inMaterial)
     {
         material = inMaterial;
     }
-}
+
+    bool MaterialInstance::HasVariant(const std::string& inName) const
+    {
+        return material->HasVariantField(inName);
+    }
+
+    MaterialInstance::Variant MaterialInstance::GetVariant(const std::string& inName) const
+    {
+        if (variants.contains(inName)) {
+            return variants.at(inName);
+        }
+
+        Variant result;
+        std::visit([&](auto&& variantField) -> void {
+            result = variantField.defaultValue;
+        }, material->GetVariantField(inName));
+        return result;
+    }
+
+    void MaterialInstance::SetVariant(const std::string& inName, const Variant& inVariant)
+    {
+        Assert(inVariant.index() == material->GetVariantField(inName).index());
+        variants[inName] = inVariant;
+    }
+
+    MaterialInstance::VariantMap MaterialInstance::GetVariants() const
+    {
+        VariantMap result;
+        const auto& variantFields = material->GetVariantFields();
+        result.reserve(variantFields.size());
+
+        for (const auto& [name, variantField] : variantFields) {
+            if (variants.contains(name)) {
+                result.emplace(name, variants.at(name));
+            } else {
+                std::visit([&](auto&& field) -> void {
+                    result.emplace(name, field.defaultValue);
+                }, variantField);
+            }
+        }
+        return result;
+    }
+
+    bool MaterialInstance::HasParameter(const std::string& inName) const
+    {
+        return material->HasParameterField(inName);
+    }
+
+    MaterialInstance::Parameter MaterialInstance::GetParameter(const std::string& inName) const
+    {
+        if (parameters.contains(inName)) {
+            return parameters.at(inName);
+        }
+
+        Parameter result;
+        std::visit([&](auto&& parameterField) -> void {
+            result = parameterField.defaultValue;
+        }, material->GetParameterField(inName));
+        return result;
+    }
+
+    void MaterialInstance::SetParameter(const std::string& inName, const Parameter& inParameter)
+    {
+        Assert(inParameter.index() == material->GetParameterField(inName).index());
+        parameters[inName] = inParameter;
+    }
+
+    MaterialInstance::ParameterMap MaterialInstance::GetParameters() const
+    {
+        ParameterMap result;
+        const auto& parameterFields = material->GetParameterFields();
+        result.reserve(parameterFields.size());
+
+        for (const auto& [name, parameterField] : parameterFields) {
+            if (parameters.contains(name)) {
+                result.emplace(name, parameters.at(name));
+            } else {
+                std::visit([&](auto&& parameter) -> void {
+                    result.emplace(name, parameter.defaultValue);
+                }, parameterField);
+            }
+        }
+        return result;
+    }
+} // namespace Runtime

From 0084f6f3a89a31ba8873e37fd6279030125d3101 Mon Sep 17 00:00:00 2001
From: FlyAndNotDown <johnkindem@qq.com>
Date: Sat, 12 Apr 2025 18:16:57 +0800
Subject: [PATCH 3/3] feat: number input basics

---
 Editor/Qml/ENumberInput.qml   | 64 +++++++++++++++++++++++++++++++++++
 Editor/Qml/ETextField.qml     |  7 +++-
 Editor/Qml/EWidgetSamples.qml | 54 +++++++++++++++++++++++++++++
 3 files changed, 124 insertions(+), 1 deletion(-)
 create mode 100644 Editor/Qml/ENumberInput.qml

diff --git a/Editor/Qml/ENumberInput.qml b/Editor/Qml/ENumberInput.qml
new file mode 100644
index 000000000..368158367
--- /dev/null
+++ b/Editor/Qml/ENumberInput.qml
@@ -0,0 +1,64 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Basic
+
+Item {
+    property int value: spinBox.value
+    property int from: spinBox.from
+    property int to: spinBox.to
+    property bool editable: spinBox.editable
+
+    id: root
+    implicitWidth: spinBox.implicitWidth
+    implicitHeight: spinBox.implicitHeight
+
+    SpinBox {
+        id: spinBox
+        implicitHeight: textField.implicitHeight
+        value: root.value
+        editable: root.editable
+        from: root.from
+        to: root.to
+
+        contentItem: ETextField {
+            id: textField
+            implicitWidth: 40
+            text: spinBox.textFromValue(spinBox.value)
+            validator: spinBox.validator
+        }
+
+        down.indicator: Rectangle {
+            id: downIndicator
+            x: 0
+            implicitWidth: 25
+            implicitHeight: textField.implicitHeight
+            radius: 5
+            color: spinBox.down.hovered ? ETheme.secondaryBgColor : ETheme.primaryBgColor
+
+            EIcon {
+                name: 'minus'
+                anchors.centerIn: downIndicator
+            }
+        }
+
+        up.indicator: Rectangle {
+            id: upIndicator
+            x: spinBox.width - width
+            implicitWidth: 25
+            implicitHeight: textField.implicitHeight
+            radius: 5
+            color: spinBox.up.hovered ? ETheme.secondaryBgColor : ETheme.primaryBgColor
+
+            EIcon {
+                name: 'add'
+                anchors.centerIn: upIndicator
+            }
+        }
+
+        background: Rectangle {
+            implicitWidth: 100
+            radius: 5
+            color: ETheme.primaryBgColor
+        }
+    }
+}
diff --git a/Editor/Qml/ETextField.qml b/Editor/Qml/ETextField.qml
index abf79ef6d..d87de0f92 100644
--- a/Editor/Qml/ETextField.qml
+++ b/Editor/Qml/ETextField.qml
@@ -5,7 +5,10 @@ import QtQuick.Controls.Basic
 Item {
     property string placeHolderText: ''
     property int wrapMode: TextInput.NoWrap
-    property string text: ''
+    property string text: textField.text
+    property var validator: null
+
+    signal accepted()
 
     id: root
     implicitWidth: textField.implicitWidth
@@ -24,6 +27,8 @@ Item {
         font.pixelSize: ETheme.contentFontSize
         font.family: ETheme.fontFamily
         wrapMode: root.wrapMode
+        validator: root.validator
+        onAccepted: root.accepted()
 
         background: Rectangle {
             radius: 5
diff --git a/Editor/Qml/EWidgetSamples.qml b/Editor/Qml/EWidgetSamples.qml
index 9c161f50f..b8d56034d 100644
--- a/Editor/Qml/EWidgetSamples.qml
+++ b/Editor/Qml/EWidgetSamples.qml
@@ -350,6 +350,26 @@ Rectangle {
                     }
                 }
 
+                RowLayout {
+                    ETextField {
+                        id: textFieldWithValidator
+                        Layout.preferredWidth: 300
+                        placeHolderText: 'Hello World'
+                        validator: IntValidator {
+                            bottom: 1
+                            top: 10
+                        }
+                        onAccepted: {
+                            console.log('value accepted, value=' + text)
+                        }
+                    }
+
+                    EText {
+                        Layout.leftMargin: 5
+                        text: 'With Validator'
+                    }
+                }
+
                 RowLayout {
                     ETextField {
                         Layout.preferredWidth: 300
@@ -370,6 +390,40 @@ Rectangle {
                     }
                 }
             }
+
+            RowLayout {
+                Layout.leftMargin: 5
+                Layout.topMargin: 35
+                EText {
+                    text: 'NumberInput'
+                    style: EText.Style.Title1
+                }
+            }
+
+            ColumnLayout {
+                Layout.margins: 5
+
+                RowLayout {
+                    ENumberInput {}
+
+                    EText {
+                        Layout.leftMargin: 5
+                        text: 'Default'
+                    }
+                }
+
+                RowLayout {
+                    ENumberInput {
+                        from: 0
+                        to: 10
+                    }
+
+                    EText {
+                        Layout.leftMargin: 5
+                        text: 'Limit 0-10'
+                    }
+                }
+            }
         }
     }
 }