Update Files

leenkx/Sources/leenkx/logicnode/NetworkMessageParserNode.hx

@@ -0,0 +1,100 @@
+package leenkx.logicnode;
+import leenkx.network.Connect;
+import leenkx.network.Buffer;
+import haxe.io.Bytes;
+import iron.object.Object;
+import iron.math.Vec4;
+import iron.math.Quat;
+import iron.math.Mat4;
+
+
+class NetworkMessageParserNode extends LogicNode {
+    public var property0: String;
+    public var api: String;
+    public var parsed: Dynamic;
+
+    public function new(tree:LogicTree) {
+        super(tree);
+    }
+
+    override function run(from:Int) {
+        var data: Dynamic = inputs[2].get();
+        if (data == null) return;
+
+        var buffer = cast(data, Buffer);
+        api = inputs[1].get();
+        if(buffer.endsWith(api) == false){
+            return;
+        }
+
+        switch (property0) {
+            case "string":   
+                var bytes = buffer.readAllAvailableBytes();
+                parsed = bytes.toString().substr(0, bytes.length - api.length);
+                runOutput(0);
+            case "vector":   
+                var bytes = new haxe.io.BytesInput(buffer.readUntil(api));
+                var vec = new Vec4();
+                for (f in Reflect.fields(vec)) {
+                    Reflect.setField(vec, f, bytes.readFloat());
+                }
+                parsed = vec;
+                runOutput(0);
+            case "float":    
+                var bytes = new haxe.io.BytesInput(buffer.readUntil(api));
+                var float: Float = bytes.readFloat();
+                parsed = float;
+                runOutput(0);
+            case "integer":  
+                var bytes = new haxe.io.BytesInput(buffer.readUntil(api));
+                var integer: Int = bytes.readInt32();
+                parsed = integer;
+                runOutput(0);
+            case "boolean":  
+                var bytes = buffer.readAllAvailableBytes();
+                var boolean = bytes.toString().substr(0, bytes.length - api.length);
+                if(boolean == "true"){
+                    parsed = true;
+                } else {
+                    parsed = false;
+                }
+                runOutput(0);
+            case "transform":
+                var bytes = new haxe.io.BytesInput(buffer.readUntil(api));
+                var loc: Vec4 = new Vec4();
+                var rot: Quat = new Quat();
+                var scl: Vec4 = new Vec4();
+                for (f in Reflect.fields(loc)) {
+                    Reflect.setField(loc, f, bytes.readFloat());
+                }
+                for (f in Reflect.fields(rot)) {
+                    Reflect.setField(rot, f, bytes.readFloat());
+                }
+                for (f in Reflect.fields(scl)) {
+                    Reflect.setField(scl, f, bytes.readFloat());
+                }
+                var transform = Mat4.identity();   
+                parsed = transform.compose(loc, rot, scl);
+                runOutput(0);
+            case "rotation": 
+                var bytes = new haxe.io.BytesInput(buffer.readUntil(api));
+                var rot = new Quat();
+                for (f in Reflect.fields(rot)) {
+                    Reflect.setField(rot, f, bytes.readFloat());
+                }
+                parsed = rot;
+                runOutput(0);
+            default: throw "Failed to parse data.";
+        }
+
+    }
+
+    override function get(from: Int): Dynamic {
+        return switch (from) {
+          case 1: api;
+          case 2: parsed;
+          default: throw "Unreachable";
+        }
+    }
+
+}