ShaderNode use buildNode, fixed input conversions

hrt/shgraph/ShaderGraph.hx

@@ -237,12 +237,14 @@ class ShaderGraph {
 	}
 
 	static var nodeCache : Map<String, ShaderData> = [];
-	function getShaderData(cl: Class<TestNewNode>) {
+	public static function getShaderData(cl: Class<ShaderNode>) {
 		var className = Type.getClassName(cl);
 		var data = nodeCache.get(className);
 		if (data == null) {
 			var unser = new hxsl.Serializer();
-			data = @:privateAccess unser.unserialize((cl:Dynamic).SRC);
+			var toUnser = (cl:Dynamic).SRC;
+			if (toUnser == null) throw "Node " + cl + " has no SRC";
+			data = @:privateAccess unser.unserialize(toUnser);
 			nodeCache.set(className, data);
 		}
 		return data;
@@ -266,14 +268,13 @@ class ShaderGraph {
 			if (!nodeOutputs.exists(node)) {
 				var outputs : Map<String, TVar> = [];
 
-				var keys = node.instance.getOutputInfoKeys();
-				for (key in keys) {
-					var info = node.instance.getOutputInfo(key);
-					var type = TVec(4, VFloat);//ShaderType.getType(info.type);
+				var shaderNodeOutputs = node.instance.getOutputs2();
+				for (name => output in shaderNodeOutputs) {
+					var type = output.type;
 					if (type == null) throw "no type";
 					var id = getNewVarId();
 					var output = {id: id, name: getNewVarName(node, id), type: type, kind : Local};
-					outputs.set(key, output);
+					outputs.set(name, output);
 				}
 
 				nodeOutputs.set(node, outputs);
@@ -429,16 +430,15 @@ class ShaderGraph {
 			} else if (Std.downcast(currentNode.instance, ShaderParam) != null) {
 				var inputNode : ShaderParam = cast currentNode.instance;
 
-				var inVar : TVar = {name: inputNode.variable.name, id:getNewVarId(), type: TVec(4, VFloat), kind: Param};
 
 				for (output in outputs) {
+					var inVar : TVar = {name: inputNode.variable.name, id:getNewVarId(), type: output.type, kind: Param};
 					var finalExpr : TExpr = {e: TVarDecl(output, {e: TVar(inVar), p: pos, t: output.type}), p: pos, t: output.type};
 					exprsReverse.push(finalExpr);
+					graphInputVars.push(inVar);
+					var param = getParameter(inputNode.parameterId);
+					inits.push({variable: inVar, value: param.defaultValue});
 				}
-				graphInputVars.push(inVar);
-
-				var param = getParameter(inputNode.parameterId);
-				inits.push({variable: inVar, value: param.defaultValue});
 			} else if (Std.downcast(currentNode.instance, hrt.shgraph.nodes.SubGraph) != null) {
 				var subgraph : hrt.shgraph.nodes.SubGraph = cast currentNode.instance;
 				var shader = new ShaderGraph(subgraph.pathShaderGraph);
@@ -456,7 +456,7 @@ class ShaderGraph {
 				for (inputName => tvar in inputVars) {
 					var trueName = subgraph.getInputInfo(inputName).name;
 					var originalInput = gen.inVars.find((f) -> f.variable.name == trueName).variable;
-					var finalExpr : TExpr = {e: TVarDecl(originalInput, {e: TVar(tvar), p: pos, t: originalInput.type}), p: pos, t: tvar.type};
+					var finalExpr : TExpr = {e: TVarDecl(originalInput, convertToType(originalInput.type, {e: TVar(tvar), p: pos, t: tvar.type})), p: pos, t: originalInput.type};
 					finalExprs.push(finalExpr);
 				}
 
@@ -474,12 +474,13 @@ class ShaderGraph {
 
 				if (Std.downcast(currentNode.instance, hrt.shgraph.nodes.Add) != null) {
 					var unser = new hxsl.Serializer();
-					var shaderData = getShaderData(TestNewNode2);
+					var shaderData = getShaderData(Type.getClass(currentNode.instance));
 					var fn = shaderData.funs[0]; // TODO : spec the function to use for shader node definitions
 					var expr = fn.expr;
 
+					var nodeShaderOutputs = currentNode.instance.getOutputs2();
 					for (outputName => output in outputs) {
-						var outputVar : TVar = shaderData.vars.find((v : TVar) -> v.name == outputName);
+						var outputVar : TVar = nodeShaderOutputs.get(outputName);
 						expr = replaceVar(expr, outputVar, {e: TVar(output), p:pos, t: output.type});
 					}
 

hrt/shgraph/ShaderNode.hx

@@ -5,6 +5,7 @@ using hxsl.Ast;
 typedef InputInfo = { name : String, type : ShaderType.SType, hasProperty : Bool, isRequired : Bool, ?ids : Array<Int>, ?index : Int };
 typedef OutputInfo = { name : String, type : ShaderType.SType, ?id : Int };
 
+@:autoBuild(hrt.shgraph.Macros.buildNode())
 @:autoBuild(hrt.shgraph.ParseFieldsMacro.build())
 @:keepSub
 class ShaderNode {
@@ -20,6 +21,25 @@ class ShaderNode {
 						type: TVec(4, VFloat)
 					}];
 
+	static var output2 : Map<String, Map<String, TVar>> = [];
+	public function getOutputs2() : Map<String, TVar> {
+		var cl = Type.getClass(this);
+		var className = Type.getClassName(cl);
+		var outputs = output2.get(className);
+		if (outputs != null)
+			return outputs;
+		outputs = [];
+		var shData = ShaderGraph.getShaderData(cl);
+		for (shaderVar in shData.vars) {
+			if (shaderVar.qualifiers != null && shaderVar.qualifiers.contains(SgOutput)) {
+				outputs.set(shaderVar.name, shaderVar);
+			}
+		}
+		output2.set(className, outputs);
+
+		return outputs;
+	}
+
 	var inputs : Map<String, NodeVar> = [];
 	var outputs : Map<String, TVar> = [];
 

hrt/shgraph/ShaderOutput.hx

@@ -12,6 +12,12 @@ class ShaderOutput extends ShaderNode {
 
 	@prop("Variable") public var variable : TVar;
 
+	static var SRC = {
+		@sginput var input : Vec4;
+		function fragment() {
+		}
+	}
+
 	var components = [X, Y, Z, W];
 
 	override public function checkValidityInput(key : String, type : ShaderType.SType) : Bool {

hrt/shgraph/ShaderParam.hx

@@ -12,6 +12,12 @@ class ShaderParam extends ShaderNode {
 	@prop() public var parameterId : Int;
 	@prop() public var perInstance : Bool;
 
+	override public function getOutputs2() : Map<String, TVar> {
+		var outputs : Map<String, TVar> = [];
+		outputs.set("output", this.variable);
+
+		return outputs;
+	}
 
 	public var variable : TVar;
 

hrt/shgraph/nodes/Add.hx

@@ -12,4 +12,14 @@ class Add extends Operation {
 		super(OpAdd);
 	}
 
+	static var SRC = {
+		@sginput var a : Vec4;
+		@sginput var b : Vec4;
+		@sgoutput var output : Vec4;
+		function fragment() {
+			var c = a + b;
+			output = c;
+		}
+	}
+
 }

hrt/shgraph/nodes/SubGraph.hx

@@ -10,6 +10,32 @@ class SubGraph extends ShaderNode {
 
 	@prop() public var pathShaderGraph : String;
 
+	override public function getOutputs2() : Map<String, TVar> {
+		// TODO : proper caching with invalidation when subgraph is modified
+		/*var cl = Type.getClass(this);
+		var className = Type.getClassName(cl);
+
+		var outputs = ShaderNode.output2.get(className);
+		if (outputs != null)
+			return outputs;*/
+		outputs = [];
+
+		// big big hack, propery do this in the future
+		// by compiling the subgraph and storing the tvars here
+
+		var shader = new ShaderGraph(pathShaderGraph);
+		var gen = shader.generate2();
+
+		// compatibility hack with prev version
+		var prefixSubGraph = "shgraph_" + id + "_";
+
+		for (i => outVar in gen.outVars) {
+			outputs.set(prefixSubGraph + i, outVar);
+		}
+
+		return outputs;
+	}
+
 	var inputsInfo : Map<String, ShaderNode.InputInfo>;
 	var inputInfoKeys : Array<String> = [];
 	var outputsInfo : Map<String, ShaderNode.OutputInfo>;