forked from LeenkxTeam/LNXSDK
133 lines
4.5 KiB
Haxe
133 lines
4.5 KiB
Haxe
package leenkx.logicnode;
|
|
import leenkx.network.Buffer;
|
|
import haxe.io.Bytes;
|
|
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();
|
|
if (api == null) api = "";
|
|
|
|
var buffer:Buffer;
|
|
if (Std.isOfType(data, Buffer)) {
|
|
buffer = cast data;
|
|
} else {
|
|
var rawBytes:Bytes;
|
|
try {
|
|
rawBytes = haxe.crypto.Base64.decode(Std.string(data));
|
|
} catch(e) {
|
|
trace("Base64 decode failed: " + e);
|
|
return;
|
|
}
|
|
buffer = new Buffer();
|
|
buffer.writeBytes(rawBytes);
|
|
}
|
|
|
|
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 readBytes = buffer.readUntil(api);
|
|
if (readBytes == null) return;
|
|
var bytes = new haxe.io.BytesInput(readBytes);
|
|
var vec = new Vec4();
|
|
vec.x = bytes.readFloat();
|
|
vec.y = bytes.readFloat();
|
|
vec.z = bytes.readFloat();
|
|
vec.w = bytes.readFloat();
|
|
parsed = vec;
|
|
runOutput(0);
|
|
case "float":
|
|
var readBytes = buffer.readUntil(api);
|
|
if (readBytes == null) return;
|
|
var bytes = new haxe.io.BytesInput(readBytes);
|
|
var float: Float = bytes.readFloat();
|
|
parsed = float;
|
|
runOutput(0);
|
|
case "integer":
|
|
var readBytes = buffer.readUntil(api);
|
|
if (readBytes == null) return;
|
|
var bytes = new haxe.io.BytesInput(readBytes);
|
|
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 readBytes = buffer.readUntil(api);
|
|
if (readBytes == null) return;
|
|
var bytes = new haxe.io.BytesInput(readBytes);
|
|
var loc: Vec4 = new Vec4();
|
|
var rot: Quat = new Quat();
|
|
var scl: Vec4 = new Vec4();
|
|
try {
|
|
loc.x = bytes.readFloat();
|
|
loc.y = bytes.readFloat();
|
|
loc.z = bytes.readFloat();
|
|
loc.w = bytes.readFloat();
|
|
rot.x = bytes.readFloat();
|
|
rot.y = bytes.readFloat();
|
|
rot.z = bytes.readFloat();
|
|
rot.w = bytes.readFloat();
|
|
scl.x = bytes.readFloat();
|
|
scl.y = bytes.readFloat();
|
|
scl.z = bytes.readFloat();
|
|
scl.w = bytes.readFloat();
|
|
} catch(e: Dynamic) {
|
|
trace("readFloat error: " + e);
|
|
return;
|
|
}
|
|
var transform = Mat4.identity();
|
|
parsed = transform.compose(loc, rot, scl);
|
|
runOutput(0);
|
|
case "rotation":
|
|
var readBytes = buffer.readUntil(api);
|
|
if (readBytes == null) return;
|
|
var bytes = new haxe.io.BytesInput(readBytes);
|
|
var rot = new Quat();
|
|
rot.x = bytes.readFloat();
|
|
rot.y = bytes.readFloat();
|
|
rot.z = bytes.readFloat();
|
|
rot.w = 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";
|
|
}
|
|
}
|
|
|
|
} |