LNXSDK/leenkx/Sources/leenkx/logicnode/LeenkxMessageParserNode.hx

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";
        }
    }

}