Finish automatic binding generation using source generator

Xlinka · Apr 19, 2024 · b7c76c7 · b7c76c7
2 parents bdebf02 + b3b636b
commit b7c76c7
Show file tree

Hide file tree

Showing 40 changed files with 321 additions and 307 deletions.
diff --git a/ProjectObsidian.SourceGenerators/BindingGenerator.cs b/ProjectObsidian.SourceGenerators/BindingGenerator.cs
diff --git a/ProjectObsidian/ProtoFlux/Devices/ViveTrackerBattery.cs b/ProjectObsidian/ProtoFlux/Devices/ViveTrackerBattery.cs
@@ -11,7 +11,7 @@
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.FrooxEngine.Input;
 
-[NodeCategory("Devices")]
+[NodeCategory("Obsidian/Devices")]
 public class ViveTrackerBattery : VoidNode<FrooxEngineContext>
 {
     public ObjectArgument<User> User;

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonAppendToArray.cs b/ProjectObsidian/ProtoFlux/JSON/JsonAppendToArray.cs
@@ -4,18 +4,19 @@
 using ProtoFlux.Runtimes.Execution;
 using FrooxEngine;
 using Elements.Core;
+using FrooxEngine.ProtoFlux;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
     [GenericTypes(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long),
                   typeof(ulong), typeof(float), typeof(double), typeof(string), typeof(Uri), typeof(JToken), typeof(JObject),
                   typeof(JArray))]
-    public class JsonAppendToArrayNode<T> : ObjectFunctionNode<ExecutionContext, JArray>
+    public class JsonAppendToArrayNode<T> : ObjectFunctionNode<FrooxEngineContext, JArray>
     {
         public readonly ObjectInput<JArray> Array;
         public readonly ObjectInput<T> Object;
-        protected override JArray Compute(ExecutionContext context)
+        protected override JArray Compute(FrooxEngineContext context)
         {
             var array = Array.Evaluate(context);
             var obj = Object.Evaluate(context);

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonCountArrayChildrenNode.cs b/ProjectObsidian/ProtoFlux/JSON/JsonCountArrayChildrenNode.cs
@@ -1,15 +1,16 @@
-using Newtonsoft.Json.Linq;
+using FrooxEngine.ProtoFlux;
+using Newtonsoft.Json.Linq;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
-    public class JsonCountArrayChildrenNode : ValueFunctionNode<ExecutionContext, int>
+    public class JsonCountArrayChildrenNode : ValueFunctionNode<FrooxEngineContext, int>
     {
         public readonly ObjectInput<JArray> Input;
 
-        protected override int Compute(ExecutionContext context)
+        protected override int Compute(FrooxEngineContext context)
         {
             var input = Input.Evaluate(context);
             return input?.Count ?? -1;

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonCountObjectChildrenNode.cs b/ProjectObsidian/ProtoFlux/JSON/JsonCountObjectChildrenNode.cs
@@ -1,15 +1,16 @@
-using Newtonsoft.Json.Linq;
+using FrooxEngine.ProtoFlux;
+using Newtonsoft.Json.Linq;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
-    public class JsonCountObjectChildrenNode : ValueFunctionNode<ExecutionContext, int>
+    public class JsonCountObjectChildrenNode : ValueFunctionNode<FrooxEngineContext, int>
     {
         public readonly ObjectInput<JObject> Input;
 
-        protected override int Compute(ExecutionContext context)
+        protected override int Compute(FrooxEngineContext context)
         {
             var input = Input.Evaluate(context);
             return input?.Count ?? -1;

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonEmpty.cs b/ProjectObsidian/ProtoFlux/JSON/JsonEmpty.cs
@@ -1,30 +1,31 @@
-using Newtonsoft.Json.Linq;
+using FrooxEngine.ProtoFlux;
+using Newtonsoft.Json.Linq;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
-    public class JsonEmptyObjectNode : ObjectFunctionNode<ExecutionContext, JObject>
+    public class JsonEmptyObjectNode : ObjectFunctionNode<FrooxEngineContext, JObject>
     {
-        protected override JObject Compute(ExecutionContext context)
+        protected override JObject Compute(FrooxEngineContext context)
         {
             return new JObject();
         }
     }
 
     [NodeCategory("Obsidian/Json")]
-    public class JsonEmptyArrayNode : ObjectFunctionNode<ExecutionContext, JArray>
+    public class JsonEmptyArrayNode : ObjectFunctionNode<FrooxEngineContext, JArray>
     {
-        protected override JArray Compute(ExecutionContext context)
+        protected override JArray Compute(FrooxEngineContext context)
         {
             return new JArray();
         }
     }
     [NodeCategory("Obsidian/Json")]
-    public class JsonNullValueNode : ObjectFunctionNode<ExecutionContext, JToken>
+    public class JsonNullValueNode : ObjectFunctionNode<FrooxEngineContext, JToken>
     {
-        protected override JToken Compute(ExecutionContext context)
+        protected override JToken Compute(FrooxEngineContext context)
         {
             return JValue.CreateNull();
         }

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonGetFromArrayNode.cs b/ProjectObsidian/ProtoFlux/JSON/JsonGetFromArrayNode.cs
@@ -4,20 +4,21 @@
 using ProtoFlux.Runtimes.Execution;
 using Elements.Core;
 using FrooxEngine;
+using FrooxEngine.ProtoFlux;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
     [GenericTypes(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long),
                   typeof(ulong), typeof(float), typeof(double), typeof(string), typeof(Uri), typeof(JToken), typeof(JObject),
                   typeof(JArray))]
-    public class JsonGetFromArrayNode<T> : ObjectFunctionNode<ExecutionContext, T>
+    public class JsonGetFromArrayNode<T> : ObjectFunctionNode<FrooxEngineContext, T>
     {
         public readonly ObjectInput<JArray> Input;
         public readonly ObjectInput<int> Index;
 
 
-        protected override T Compute(ExecutionContext context)
+        protected override T Compute(FrooxEngineContext context)
         {
             var input = Input.Evaluate(context);
             var index = Index.Evaluate(context);

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonGetFromObject.cs b/ProjectObsidian/ProtoFlux/JSON/JsonGetFromObject.cs
@@ -4,19 +4,20 @@
 using ProtoFlux.Runtimes.Execution;
 using Elements.Core;
 using FrooxEngine;
+using FrooxEngine.ProtoFlux;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
     [GenericTypes(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long),
                   typeof(ulong), typeof(float), typeof(double), typeof(string), typeof(Uri), typeof(JToken), typeof(JObject),
                   typeof(JArray))]
-    public class JsonGetFromObjectNode<T> : ObjectFunctionNode<ExecutionContext, T>
+    public class JsonGetFromObjectNode<T> : ObjectFunctionNode<FrooxEngineContext, T>
     {
         public readonly ObjectInput<JObject> Input;
         public readonly ObjectInput<string> Tag;
 
-        protected override T Compute(ExecutionContext context)
+        protected override T Compute(FrooxEngineContext context)
         {
             var input = Input.Evaluate(context);
             var tag = Tag.Evaluate(context);

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonInsertToArrayNode.cs b/ProjectObsidian/ProtoFlux/JSON/JsonInsertToArrayNode.cs
@@ -4,20 +4,21 @@
 using ProtoFlux.Runtimes.Execution;
 using Elements.Core;
 using FrooxEngine;
+using FrooxEngine.ProtoFlux;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
     [GenericTypes(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long),
                   typeof(ulong), typeof(float), typeof(double), typeof(string), typeof(Uri), typeof(JToken), typeof(JObject),
                   typeof(JArray))]
-    public class JsonInsertToArrayNode<T> : ObjectFunctionNode<ExecutionContext, JArray>
+    public class JsonInsertToArrayNode<T> : ObjectFunctionNode<FrooxEngineContext, JArray>
     {
         public readonly ObjectInput<JArray> Array;
         public readonly ObjectInput<T> Object;
         public readonly ObjectInput<int> Index;
 
-        protected override JArray Compute(ExecutionContext context)
+        protected override JArray Compute(FrooxEngineContext context)
         {
             var array = Array.Evaluate(context);
             var obj = Object.Evaluate(context);
@@ -28,7 +29,7 @@ protected override JArray Compute(ExecutionContext context)
             try
             {
                 var output = (JArray)array.DeepClone();
-                JToken token = obj is JToken jToken ? jToken : new JValue(obj);
+                var token = obj is JToken jToken ? jToken : new JValue(obj);
                 output.Insert(index, token);
                 return output;
             }

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonParseStringArray.cs b/ProjectObsidian/ProtoFlux/JSON/JsonParseStringArray.cs
@@ -1,16 +1,17 @@
 using System;
+using FrooxEngine.ProtoFlux;
 using Newtonsoft.Json.Linq;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
-    public class JsonParseStringArrayNode : ObjectFunctionNode<ExecutionContext, JArray>
+    public class JsonParseStringArrayNode : ObjectFunctionNode<FrooxEngineContext, JArray>
     {
         public readonly ObjectInput<string> Input;
 
-        protected override JArray Compute(ExecutionContext context)
+        protected override JArray Compute(FrooxEngineContext context)
         {
             var input = Input.Evaluate(context);
             if (string.IsNullOrEmpty(input))

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonParseStringNode.cs b/ProjectObsidian/ProtoFlux/JSON/JsonParseStringNode.cs
@@ -1,17 +1,18 @@
 using System;
+using FrooxEngine.ProtoFlux;
 using Newtonsoft.Json.Linq;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
-    public class JsonParseStringNode : ObjectFunctionNode<ExecutionContext, JObject>
+    public class JsonParseStringNode : ObjectFunctionNode<FrooxEngineContext, JObject>
     {
         public readonly ObjectInput<string> Input;
 
 
-        protected override JObject Compute(ExecutionContext context)
+        protected override JObject Compute(FrooxEngineContext context)
         {
             var input = Input.Evaluate(context);
             if (string.IsNullOrEmpty(input))

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonQuickGetObject.cs b/ProjectObsidian/ProtoFlux/JSON/JsonQuickGetObject.cs
@@ -4,18 +4,19 @@
 using ProtoFlux.Runtimes.Execution;
 using Elements.Core;
 using FrooxEngine;
+using FrooxEngine.ProtoFlux;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
     [GenericTypes(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint), typeof(long),
                   typeof(ulong), typeof(float), typeof(double), typeof(string), typeof(Uri), typeof(JToken), typeof(JObject),
                   typeof(JArray))]
-    public class JsonQuickGetFromObjectNode<T> : ObjectFunctionNode<ExecutionContext, T>
+    public class JsonQuickGetFromObjectNode<T> : ObjectFunctionNode<FrooxEngineContext, T>
     {
         public readonly ObjectInput<string> Input;
         public readonly ObjectInput<string> Tag;
-        protected override T Compute(ExecutionContext context)
+        protected override T Compute(FrooxEngineContext context)
         {
             var input = Input.Evaluate(context);
             var tag = Tag.Evaluate(context);

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonRemoveFromArrayNode.cs b/ProjectObsidian/ProtoFlux/JSON/JsonRemoveFromArrayNode.cs
@@ -1,18 +1,19 @@
 using System;
+using FrooxEngine.ProtoFlux;
 using Newtonsoft.Json.Linq;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
-    public class JsonRemoveFromArrayNode : ObjectFunctionNode<ExecutionContext, JArray>
+    public class JsonRemoveFromArrayNode : ObjectFunctionNode<FrooxEngineContext, JArray>
     {
         public readonly ObjectInput<JArray> Array;
         public readonly ObjectInput<int> Index;
 
 
-        protected override JArray Compute(ExecutionContext context)
+        protected override JArray Compute(FrooxEngineContext context)
         {
             var array = Array.Evaluate(context);
             var index = Index.Evaluate(context);

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonRemoveFromObjectNode.cs b/ProjectObsidian/ProtoFlux/JSON/JsonRemoveFromObjectNode.cs
@@ -1,18 +1,19 @@
 using System;
+using FrooxEngine.ProtoFlux;
 using Newtonsoft.Json.Linq;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json
 {
     [NodeCategory("Obsidian/Json")]
-    public class JsonRemoveFromObjectNode : ObjectFunctionNode<ExecutionContext, JObject>
+    public class JsonRemoveFromObjectNode : ObjectFunctionNode<FrooxEngineContext, JObject>
     {
         public readonly ObjectInput<JObject> Input;
         public readonly ObjectInput<string> Tag;
 
 
-        protected override JObject Compute(ExecutionContext context)
+        protected override JObject Compute(FrooxEngineContext context)
         {
             var input = Input.Evaluate(context);
             if (input == null) return null;

diff --git a/ProjectObsidian/ProtoFlux/JSON/JsonToStringNode.cs b/ProjectObsidian/ProtoFlux/JSON/JsonToStringNode.cs
@@ -1,5 +1,6 @@
 using System;
 using FrooxEngine;
+using FrooxEngine.ProtoFlux;
 using Newtonsoft.Json.Linq;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
@@ -8,11 +9,11 @@ namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Json;
 
 [NodeCategory("Obsidian/Json")]
 [GenericTypes(typeof(JToken), typeof(JObject), typeof(JArray))]
-public class JsonToStringNode<T> : ObjectFunctionNode<ExecutionContext, string> where T : JToken
+public class JsonToStringNode<T> : ObjectFunctionNode<FrooxEngineContext, string>
 {
     public readonly ObjectInput<T> Input;
 
-    protected override string Compute(ExecutionContext context)
+    protected override string Compute(FrooxEngineContext context)
     {
         var input = Input.Evaluate(context);
         return input?.ToString();

diff --git a/ProjectObsidian/ProtoFlux/Math/Constants/EpsilonDouble.cs b/ProjectObsidian/ProtoFlux/Math/Constants/EpsilonDouble.cs
@@ -1,12 +1,15 @@
 using Elements.Core;
+using FrooxEngine.ProtoFlux;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 
-[NodeCategory("LogiX/NeosPlus/Math/Constants")]
+namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Math.Constants;
+
+[NodeCategory("Obsidian/Math/Constants")]
 [NodeName("Epsilon Double")]
-public class EpsilonDouble : ValueFunctionNode<ExecutionContext, double>
+public class EpsilonDouble : ValueFunctionNode<FrooxEngineContext, double>
 {
-    protected override double Compute(ExecutionContext context)
+    protected override double Compute(FrooxEngineContext context)
     {
         return MathX.DOUBLE_EPSILON;
     }

diff --git a/ProjectObsidian/ProtoFlux/Math/Constants/EpsilonFloat.cs b/ProjectObsidian/ProtoFlux/Math/Constants/EpsilonFloat.cs
@@ -1,12 +1,15 @@
 using Elements.Core;
+using FrooxEngine.ProtoFlux;
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 
-[NodeCategory("Protoflux/Obsidian/Math/Constants")]
+namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Math.Constants;
+
+[NodeCategory("Obsidian/Math/Constants")]
 [NodeName("Epsilon Float")]
-public class EpsilonFloat : ValueFunctionNode<ExecutionContext, float>
+public class EpsilonFloat : ValueFunctionNode<FrooxEngineContext, float>
 {
-    protected override float Compute(ExecutionContext context)
+    protected override float Compute(FrooxEngineContext context)
     {
         return MathX.FLOAT_EPSILON;
     }

diff --git a/ProjectObsidian/ProtoFlux/Math/Physics/CentripetalForceCalculationNode.cs b/ProjectObsidian/ProtoFlux/Math/Physics/CentripetalForceCalculationNode.cs
@@ -4,16 +4,18 @@
 using ProtoFlux.Runtimes.Execution;
 using ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Math.Physics;
 using System;
+using FrooxEngine.ProtoFlux;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Math.Physics
 {
-    public class CentripetalForceCalculationNode : ValueFunctionNode<ExecutionContext, float>
+    [NodeCategory("Obsidian/Math/Physics")]
+    public class CentripetalForceCalculationNode : ValueFunctionNode<FrooxEngineContext, float>
     {
         public ValueInput<float> Mass;
         public ValueInput<float> Velocity;
         public ValueInput<float> Radius;
 
-        protected override float Compute(ExecutionContext context)
+        protected override float Compute(FrooxEngineContext context)
         {
             try
             {

diff --git a/ProjectObsidian/ProtoFlux/Math/Physics/DragCalculationNode.cs b/ProjectObsidian/ProtoFlux/Math/Physics/DragCalculationNode.cs
@@ -3,18 +3,19 @@
 using ProtoFlux.Core;
 using ProtoFlux.Runtimes.Execution;
 using System;
+using FrooxEngine.ProtoFlux;
 
 namespace ProtoFlux.Runtimes.Execution.Nodes.Obsidian.Math.Physics
 {
     [NodeCategory("Obsidian/Math/Physics")]
-    public class DragCalculationNode : ValueFunctionNode<ExecutionContext, float3>
+    public class DragCalculationNode : ValueFunctionNode<FrooxEngineContext, float3>
     {
         public ValueInput<float> FluidDensity;        // rho
         public ValueInput<float3> ObjectVelocity;     // v
         public ValueInput<float> DragCoefficient;     // Cd
         public ValueInput<float> CrossSectionalArea;  // A
 
-        protected override float3 Compute(ExecutionContext context)
+        protected override float3 Compute(FrooxEngineContext context)
         {
             float rho = FluidDensity.Evaluate(context);
             float3 v = ObjectVelocity.Evaluate(context);