Start Graphs

Engine/Source/Fyrion/Core/GraphTypes.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include "String.hpp"
+#include "Fyrion/Resource/ResourceTypes.hpp"
+
+namespace Fyrion
+{
+    struct GraphInput
+    {
+    };
+
+    struct GraphOutput
+    {
+    };
+
+    struct GraphNodeAsset
+    {
+
+    };
+
+    struct GraphNodeLink
+    {
+        RID    inputNode;
+        String inputPin;
+        RID    outputNode;
+        String outputPin;
+    };
+}

Engine/Source/Fyrion/Core/Registry.cpp

@@ -33,6 +33,11 @@ namespace Fyrion
         return m_name;
     }
 
+    void ParamHandler::SetName(const StringView& name)
+    {
+        m_name = name;
+    }
+
     ConstPtr AttributeHandler::GetAttribute(TypeID attributeId) const
     {
         if (auto it = m_attributes.Find(attributeId))
@@ -372,6 +377,11 @@ namespace Fyrion
         return m_functionHandler;
     }
 
+    ParamHandler& FunctionBuilder::GetParam(usize index)
+    {
+        return m_functionHandler.m_params[index];
+    }
+
     void FunctionBuilder::SetFnInvoke(FunctionHandler::FnInvoke fnInvoke)
     {
         m_functionHandler.m_fnInvoke = fnInvoke;

Engine/Source/Fyrion/Core/Registry.hpp

@@ -102,12 +102,13 @@ namespace Fyrion
         Array<AttributeInfo*>                      m_attributeArray{};
     };
 
-    class FY_API ParamHandler
+    class FY_API ParamHandler : public AttributeHandler
     {
     public:
         ParamHandler(usize index, const FieldInfo& fieldInfo);
         const FieldInfo&    GetFieldInfo() const;
         const String&       GetName() const;
+        void  SetName(const StringView& name);
     private:
         FieldInfo   m_fieldInfo{};
         String      m_name{};
@@ -361,6 +362,7 @@ namespace Fyrion
         void        Create(const FunctionHandlerCreation& creation);
 
         FunctionHandler& GetFunctionHandler() const;
+        ParamHandler& GetParam(usize index);
 
         void SetFnInvoke(FunctionHandler::FnInvoke fnInvoke);
         void SetFunctionPointer(VoidPtr functionPointer);
@@ -466,6 +468,18 @@ namespace Fyrion
     };
 
 
+    template <usize I, typename Owner>
+    class NativeParamHandler : public NativeAttributeBuilder<NativeParamHandler<I, Owner>>
+    {
+    public:
+        NativeParamHandler(ParamHandler& paramHandler) : NativeAttributeBuilder<NativeParamHandler>(paramHandler), m_paramHandler(paramHandler)
+        {
+        }
+    private:
+        ParamHandler& m_paramHandler;
+    };
+
+
     template<typename Owner, typename ...Args>
     class NativeConstructorHandler
     {
@@ -608,14 +622,28 @@ namespace Fyrion
     class NativeFunctionHandler : public NativeAttributeBuilder<NativeFunctionHandler<fp, Return, Args...>>
     {
     public:
-        NativeFunctionHandler(FunctionBuilder& functionBuilder) :
-            NativeAttributeBuilder<NativeFunctionHandler<fp, Return, Args...>>(functionBuilder.GetFunctionHandler())
+        NativeFunctionHandler(FunctionBuilder functionBuilder) :
+            NativeAttributeBuilder<NativeFunctionHandler>(functionBuilder.GetFunctionHandler()),
+            m_functionBuilder(functionBuilder)
         {
             functionBuilder.SetFnInvoke(InvokeImpl);
             functionBuilder.SetFunctionPointer(reinterpret_cast<VoidPtr>(&FunctionImpl));
         }
 
+        template <usize I>
+        auto Param(const StringView& name = "")
+        {
+            ParamHandler& paramHandler = m_functionBuilder.GetParam(I);
+            if (!name.Empty())
+            {
+                paramHandler.SetName(name);
+            }
+            return NativeParamHandler<I, NativeFunctionHandler>(paramHandler);
+        }
+
     private:
+        FunctionBuilder m_functionBuilder;
+
         static void InvokeImpl(const FunctionHandler* handler, VoidPtr instance, VoidPtr  ret, VoidPtr* params)
         {
             u32 i{sizeof...(Args)};

Engine/Source/Fyrion/Resource/ResourceGraph.cpp

@@ -0,0 +1,9 @@
+#include "ResourceGraph.hpp"
+
+namespace Fyrion
+{
+    void RegisterResourceGraphTypes()
+    {
+
+    }
+}

Engine/Source/Fyrion/Resource/ResourceGraph.hpp

@@ -0,0 +1,14 @@
+#pragma once
+#include "Fyrion/Common.hpp"
+
+namespace Fyrion
+{
+    struct ResourceGraphOutput;
+    struct ResourceGraphNode;
+
+    struct ResourceGraphAsset
+    {
+        constexpr static u32 Nodes = 0;
+        constexpr static u32 Links = 1;
+    };
+}

Engine/Source/Fyrion/TypeRegister.cpp

@@ -4,13 +4,15 @@ namespace Fyrion
 {
     void RegisterCoreTypes();
     void RegisterResourceTypes();
+    void RegisterResourceGraphTypes();
     void RegisterSceneType();
     void RegisterGraphicsTypes();
 
     void TypeRegister()
     {
         RegisterCoreTypes();
         RegisterResourceTypes();
+        RegisterResourceGraphTypes();
         RegisterSceneType();
         RegisterGraphicsTypes();
     }

Engine/Test/Fyrion/Core/ReflectionTest.cpp

@@ -362,13 +362,25 @@ namespace
 	{
 		Engine::Init();
 		{
-			Registry::Function<&GlobalSum>("GlobalSum").Attribute<TestAttribute>();
+			auto func = Registry::Function<&GlobalSum>("GlobalSum");
+			func.Attribute<TestAttribute>();
+			func.Param<0>("a").Attribute<TestAttribute>();
+			func.Param<1>("b").Attribute<TestAttribute>();
 		}
 
 		{
 			FunctionHandler* function = Registry::FindFunctionByName("GlobalSum");
 			CHECK(function);
 
+			auto paramsInfo = function->GetParams();
+			CHECK(paramsInfo.Size() == 2);
+			CHECK(paramsInfo[0].GetName() == "a");
+			CHECK(paramsInfo[0].HasAttribute<TestAttribute>());
+			CHECK(paramsInfo[0].GetAttribute<TestAttribute>() != nullptr);
+			CHECK(paramsInfo[1].GetName() == "b");
+			CHECK(paramsInfo[1].HasAttribute<TestAttribute>());
+			CHECK(paramsInfo[1].GetAttribute<TestAttribute>() != nullptr);
+
 			i32 ret{}, a{10}, b{20};
 			VoidPtr params[2]{&a, &b};
 			function->Invoke(nullptr, &ret, params);

Engine/Test/Fyrion/Resource/ResourceGraphTests.cpp

@@ -0,0 +1,63 @@
+#include "doctest.h"
+#include "Fyrion/Engine.hpp"
+#include "Fyrion/Core/GraphTypes.hpp"
+#include "Fyrion/Core/Registry.hpp"
+#include "Fyrion/Core/String.hpp"
+#include "Fyrion/Resource/ResourceGraph.hpp"
+
+using namespace Fyrion;
+
+namespace
+{
+    struct TestOutputNode
+    {
+        String stringValue;
+        i32    intValue{};
+
+        static void RegisterType(NativeTypeHandler<TestOutputNode>& type)
+        {
+            type.Field<&TestOutputNode::stringValue>("stringValue");
+            type.Field<&TestOutputNode::intValue>("intValue");
+            type.Attribute<ResourceGraphOutput>();
+        }
+    };
+
+
+    void SumValue(i32 vl1, i32 vl2, i32& out)
+    {
+        out = vl1 + vl2;
+    }
+
+    void ConcatString(const String& vl1, const String& vl2, String& out)
+    {
+        out = vl1 + vl2;
+    }
+
+    void RegisterTypes()
+    {
+        Registry::Type<TestOutputNode>();
+
+        auto sumValue = Registry::Function<SumValue>("SumValue");
+        sumValue.Param<0>("vl1").Attribute<GraphInput>();
+        sumValue.Param<1>("vl2").Attribute<GraphInput>();
+        sumValue.Param<2>("out").Attribute<GraphInput>();
+        sumValue.Attribute<ResourceGraphNode>();
+
+
+        auto concatString = Registry::Function<ConcatString>("ConcatString");
+        concatString.Param<0>("vl1").Attribute<GraphInput>();
+        concatString.Param<1>("vl2").Attribute<GraphInput>();
+        concatString.Param<2>("out").Attribute<GraphInput>();
+        concatString.Attribute<ResourceGraphNode>();
+    }
+
+
+    TEST_CASE("Resource::ResourceGraphBasics")
+    {
+        Engine::Init();
+        {
+            RegisterTypes();
+        }
+        Engine::Destroy();
+    }
+}