Update Files

leenkx/Sources/leenkx/logicnode/LeenkxMessageParserNode.hx

@@ -0,0 +1,168 @@
+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 LeenkxMessageParserNode 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;
+
+        api = inputs[1].get();
+
+        /**
+        var buffer = cast(data, Buffer);
+        api = inputs[1].get();
+        if(buffer.endsWith(api) == false){
+            return;
+        }
+        **/
+        var buffer = new Buffer();
+        if(!StringTools.startsWith(data,api)){
+            return;
+        }
+        switch (property0) {
+            case "string":   
+                parsed = data.substr(api.length, data.length);
+                runOutput(0);
+            case "vector":   
+                var vec = data.substr(api.length, data.length);
+                vec = StringTools.replace(vec, "(", "");
+                vec = StringTools.replace(vec, ")", "");
+                vec = StringTools.replace(vec, " ", "");
+                vec = StringTools.trim(vec);
+                var array = vec.split(",").map(Std.parseFloat);
+                parsed = new Vec4( array[0], array[1], array[2], array[3] );
+                runOutput(0);
+            case "float":    
+                var flt:String = data.substr(api.length, data.length);
+                var float = StringTools.trim(flt);
+                parsed = Std.parseFloat(float);
+                runOutput(0);
+            case "integer":  
+                var int:String = data.substr(api.length, data.length);
+                var integer = StringTools.trim(int);
+                parsed = Std.parseInt(integer);
+                runOutput(0);
+            case "boolean":  
+                var boolean:String = data.substr(api.length, data.length);
+                if(boolean == "true"){
+                    parsed = true;
+                } else {
+                    parsed = false;
+                }
+                runOutput(0);
+            case "transform":
+                var tsfm = data.substr(api.length, data.length);
+                tsfm = StringTools.replace(tsfm, "[", "");
+                tsfm = StringTools.replace(tsfm, "]", "");
+                tsfm = StringTools.replace(tsfm, " ", "");
+                tsfm = StringTools.trim(tsfm);
+                var array = tsfm.split(",").map(Std.parseFloat);
+                parsed = new Mat4(
+                    array[0], array[1], array[2], array[3],
+                    array[4], array[5], array[6], array[7],
+                    array[8], array[9], array[10], array[11],
+                    array[12], array[13], array[14], array[15]
+                );
+                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.";
+        }
+        return;
+
+
+
+        switch (property0) {
+            case "string":   
+                var bytes = buffer.readAllAvailableBytes();
+                parsed = bytes.toString().substr(0, bytes.length - api.length);
+                trace(parsed);
+                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";
+        }
+    }
+
+}