Removed dependecy from SgInput/output

hrt/shgraph/Macros.hx

@@ -20,7 +20,6 @@ class Macros {
 						try {
 							var c = Context.getLocalClass();
 
-							trace("=========================");
 							// function map(e: haxe.macro.Expr) {
 							// 	switch(e) {
 							// 		case EMeta("sginput", args, e):
@@ -30,13 +29,35 @@ class Macros {
 
 							// expr.map()
 
+							var inVars : Array<String> = [];
+							var outVars : Array<String> = [];
+
 							function iter(e: haxe.macro.Expr) : Void {
 								switch(e.expr) {
 									case EMeta(meta, subexpr):
-										if (meta.name == "sginput")
-											trace("sginput", subexpr);
-										else if (meta.name == "sgoutput")
-											trace("sgoutput", subexpr);
+										switch (meta.name) {
+											case "sginput":
+												switch(subexpr.expr) {
+													case EVars(vars):
+														for (v in vars) {
+															inVars.push(v.name);
+														}
+														e.expr = subexpr.expr;
+													default:
+														throw "sginput must be used with variables only";
+												}
+											case "sgoutput":
+												switch(subexpr.expr) {
+													case EVars(vars):
+														for (v in vars) {
+															outVars.push(v.name);
+														}
+														e.expr = subexpr.expr;
+													default:
+														throw "sgoutput must be used with variables only";
+												}
+											default:
+										}
 									default:
 								}
 							}
@@ -65,6 +86,27 @@ class Macros {
 								name : ":keep",
 								pos : pos,
 							});
+
+							function makeField(name: String, arr: Array<String>) : Field
+							{
+								return {
+									name: name,
+									access: [APublic, AStatic],
+									kind: FVar(macro : Array<String>, macro $v{arr}),
+									pos: f.pos,
+									meta: [{
+											name : ":keep",
+											pos : pos,}
+									],
+								};
+							}
+
+							var inVarField : Field = makeField("_inVars", inVars);
+							var outVarField : Field = makeField("_outVars", outVars);
+
+							fields.push(inVarField);
+							fields.push(outVarField);
+
 						} catch( e : hxsl.Ast.Error ) {
 							fields.remove(f);
 							Context.error(e.msg, e.pos);

hrt/shgraph/ShaderGlobalInput.hx

@@ -20,10 +20,10 @@ class ShaderGlobalInput extends ShaderNode {
 		var pos : Position = {file: "", min: 0, max: 0};
 
 		var inVar : TVar = variable;
-		var output : TVar = {name: "output", id:1, type: this.variable.type, kind: Local, qualifiers: [SgOutput]};
+		var output : TVar = {name: "output", id:1, type: this.variable.type, kind: Local, qualifiers: []};
 		var finalExpr : TExpr = {e: TBinop(OpAssign, {e:TVar(output), p:pos, t:output.type}, {e: TVar(inVar), p: pos, t: output.type}), p: pos, t: output.type};
 
-		return {expr: finalExpr, inVars: [], outVars:[output], externVars: [inVar, output], inits: []};
+		return {expr: finalExpr, inVars: [], outVars:[{v: output, internal: false}], externVars: [inVar], inits: []};
 	}
 
 	override public function loadProperties(props : Dynamic) {

hrt/shgraph/ShaderGraph.hx

@@ -8,9 +8,9 @@ using Lambda;
 
 typedef ShaderNodeDef = {
 	expr: TExpr,
-	inVars: Array<TVar>, // Variables that shows up as input of a node
-	outVars: Array<TVar>, // Variables that shows up as outputs of a node
-	externVars: Array<TVar>, // All the external variables of a shader, including sginput/sgoutputs
+	inVars: Array<{v: TVar, internal: Bool}>, // If internal = true, don't show input in ui
+	outVars: Array<{v: TVar, internal: Bool}>,
+	externVars: Array<TVar>, // other external variables like globals and stuff
 	inits: Array<{variable: TVar, value: Dynamic}>, // Default values for some variables
 };
 
@@ -158,7 +158,7 @@ class ShaderGraph {
 		if (!outputs.exists(outputName)) {
 			var def = output.instance.getShaderDef();
 			if(edge.outputId != null && def.outVars.length > edge.outputId) {
-				outputName = def.outVars[edge.outputId].name;
+				outputName = def.outVars[edge.outputId].v.name;
 			}
 			else {
 				return false;
@@ -168,7 +168,7 @@ class ShaderGraph {
 		if (!inputs.exists(inputName)) {
 			var def = node.instance.getShaderDef();
 			if (edge.inputId != null && def.inVars.length > edge.inputId) {
-				inputName = def.inVars[edge.inputId].name;
+				inputName = def.inVars[edge.inputId].v.name;
 			}
 			else {
 				return false;
@@ -260,11 +260,11 @@ class ShaderGraph {
 
 				var def = node.instance.getShaderDef();
 				for (output in def.outVars) {
-					var type = output.type;
+					var type = output.v.type;
 					if (type == null) throw "no type";
 					var id = getNewVarId();
 					var outVar = {id: id, name: getNewVarName(node, id), type: type, kind : Local};
-					outputs.set(output.name, outVar);
+					outputs.set(output.v.name, outVar);
 				}
 
 				nodeOutputs.set(node, outputs);
@@ -304,8 +304,8 @@ class ShaderGraph {
 			nodeHasOutputs.set(connection.from, true);
 		}
 
-		var graphInputVars : Array<TVar> = [];
-		var graphOutputVars : Array<TVar> = [];
+		var graphInputVars  = [];
+		var graphOutputVars  = [];
 		var externs : Array<TVar> = [];
 
 		var nodeToExplore : Array<Node> = [];
@@ -407,68 +407,64 @@ class ShaderGraph {
 				var expr = def.expr;
 
 				var outputDecls : Array<TVar> = [];
-				for (nodeVar in def.externVars) {
-					if (nodeVar.qualifiers != null) {
-						if (nodeVar.qualifiers.has(SgInput)) {
-							var connection = currentNode.instance.connections.get(nodeVar.name);
-
-							var replacement : TExpr = null;
-
-							if (connection != null) {
-								var outputs = getOutputs(connection.from);
-								var outputVar = outputs[connection.fromName];
-								if (outputVar == null) throw "null tvar";
-								replacement = convertToType(nodeVar.type,  {e: TVar(outputVar), p:pos, t: outputVar.type});
-							}
-							else {
-								var shParam = Std.downcast(currentNode.instance, ShaderParam);
-								if (shParam != null) {
-									var outVar = outputs["output"];
-									var id = getNewVarId();
-									outVar.id = id;
-									outVar.name = nodeVar.name;
-									outVar.type = nodeVar.type;
-									outVar.kind = Param;
-									outVar.qualifiers = [SgInput];
-									graphInputVars.push(outVar);
-									externs.push(outVar);
-									var param = getParameter(shParam.parameterId);
-									inits.push({variable: outVar, value: param.defaultValue});
-									continue;
-								}
-								else {
-									// default parameter if no connection
-									// TODO : Handle default values for non Float/Vec vars
-									replacement = convertToType(nodeVar.type, {e: TConst(CFloat(0.0)), p: pos, t:TFloat});
-								}
-							}
-
-							expr = replaceVar(expr, nodeVar, replacement);
 
-						}
-						else if (nodeVar.qualifiers.has(SgOutput)) {
-							var outputVar : TVar = outputs.get(nodeVar.name);
-							// Kinda of a hack : skip decl writing for shaderParams
-							var shParam = Std.downcast(currentNode.instance, ShaderParam);
-							if (shParam != null) {
-								continue;
-							}
-							if (outputVar == null) {
-								externs.push(nodeVar);
-							} else {
-								expr = replaceVar(expr, nodeVar, {e: TVar(outputVar), p:pos, t: nodeVar.type});
-								outputDecls.push(outputVar);
-							}
+				for (nodeVar in def.inVars) {
+					var connection = currentNode.instance.connections.get(nodeVar.v.name);
+
+					var replacement : TExpr = null;
+
+					if (connection != null) {
+						var outputs = getOutputs(connection.from);
+						var outputVar = outputs[connection.fromName];
+						if (outputVar == null) throw "null tvar";
+						replacement = convertToType(nodeVar.v.type,  {e: TVar(outputVar), p:pos, t: outputVar.type});
+					}
+					else {
+						var shParam = Std.downcast(currentNode.instance, ShaderParam);
+						if (shParam != null) {
+							var outVar = outputs["output"];
+							var id = getNewVarId();
+							outVar.id = id;
+							outVar.name = nodeVar.v.name;
+							outVar.type = nodeVar.v.type;
+							outVar.kind = Param;
+							outVar.qualifiers = [];
+							graphInputVars.push({v: outVar, internal: false});
+							externs.push(outVar);
+							var param = getParameter(shParam.parameterId);
+							inits.push({variable: outVar, value: param.defaultValue});
+							continue;
 						}
 						else {
-							externs.pushUnique(nodeVar);
+							// default parameter if no connection
+							// TODO : Handle default values for non Float/Vec vars
+							replacement = convertToType(nodeVar.v.type, {e: TConst(CFloat(0.0)), p: pos, t:TFloat});
 						}
 					}
-					else {
-						externs.pushUnique(nodeVar);
+
+					expr = replaceVar(expr, nodeVar.v, replacement);
+				}
+
+				for (nodeVar in def.outVars) {
+					var outputVar : TVar = outputs.get(nodeVar.v.name);
+					// Kinda of a hack : skip decl writing for shaderParams
+					var shParam = Std.downcast(currentNode.instance, ShaderParam);
+					if (shParam != null) {
+						continue;
+					}
+					if (outputVar == null) {
+						externs.push(nodeVar.v);
+					} else {
+						expr = replaceVar(expr, nodeVar.v, {e: TVar(outputVar), p:pos, t: nodeVar.v.type});
+						outputDecls.push(outputVar);
+						graphOutputVars.push({v: nodeVar.v, internal: false});
 					}
 				}
 
+				for (nodeVar in def.externVars) {
+					externs.pushUnique(nodeVar);
+				}
+
 				if (expr != null)
 					exprsReverse.push(expr);
 
@@ -663,7 +659,7 @@ class ShaderGraph {
 				var def = n.instance.getShaderDef();
 				var inputId = null;
 				for (i => inVar in def.inVars) {
-					if (inVar.name == inputName) {
+					if (inVar.v.name == inputName) {
 						inputId = i;
 						break;
 					}
@@ -672,7 +668,7 @@ class ShaderGraph {
 				var def = connection.from.instance.getShaderDef();
 				var outputId = null;
 				for (i => outVar in def.outVars) {
-					if (outVar.name == connection.fromName) {
+					if (outVar.v.name == connection.fromName) {
 						outputId = i;
 						break;
 					}

hrt/shgraph/ShaderInput.hx

@@ -23,11 +23,11 @@ class ShaderInput extends ShaderNode {
 		var pos : Position = {file: "", min: 0, max: 0};
 
 		var inVar : TVar = variable;
-		var output : TVar = {name: "output", id:1, type: this.variable.type, kind: Local, qualifiers: [SgOutput]};
+		var output : TVar = {name: "output", id:1, type: this.variable.type, kind: Local, qualifiers: []};
 		var finalExpr : TExpr = {e: TBinop(OpAssign, {e:TVar(output), p:pos, t:output.type}, {e: TVar(inVar), p: pos, t: output.type}), p: pos, t: output.type};
 
 
-		return {expr: finalExpr, inVars: [], outVars:[output], externVars: [inVar, output], inits: []};
+		return {expr: finalExpr, inVars: [], outVars:[{v:output, internal: false}], externVars: [inVar], inits: []};
 	}
 
 	public static var availableInputs : Array<TVar> = [

hrt/shgraph/ShaderNode.hx

@@ -38,7 +38,8 @@ class ShaderNode {
 		var def = getShaderDef();
 		var map : Map<String, TVar> = [];
 		for (tvar in def.outVars) {
-			map.set(tvar.name, tvar);
+			if (!tvar.internal)
+				map.set(tvar.v.name, tvar.v);
 		}
 		return map;
 	}
@@ -48,7 +49,8 @@ class ShaderNode {
 		var def = getShaderDef();
 		var map : Map<String, TVar> = [];
 		for (tvar in def.inVars) {
-			map.set(tvar.name, tvar);
+			if (!tvar.internal)
+				map.set(tvar.v.name, tvar.v);
 		}
 		return map;
 	}

hrt/shgraph/ShaderNodeHxsl.hx

@@ -21,23 +21,22 @@ class ShaderNodeHxsl extends ShaderNode {
 			var externVars = [];
 
 			for (tvar in data.vars) {
-				if (tvar.qualifiers != null) {
 					var input = false;
 					var output = false;
-					if (tvar.qualifiers.contains(SgInput)) {
-						inVars.push(tvar);
+					var classInVars : Array<String> = cast (cl:Dynamic)._inVars;
+					if (classInVars.contains(tvar.name)) {
+						inVars.push({v:tvar, internal: false});
 						// TODO : handle default values
 						input = true;
 					}
-					if (tvar.qualifiers.contains(SgOutput)) {
-						outVars.push(tvar);
+					var classOutVars : Array<String> = cast (cl:Dynamic)._outVars;
+					if (classOutVars.contains(tvar.name)) {
+						outVars.push({v: tvar, internal: false});
 						output = true;
 					}
 					if (input && output) {
 						throw "Variable is both sginput and sgoutput";
 					}
-					externVars.push(tvar);
-				}
 			}
 
 			def = {expr: expr, inVars: inVars, outVars: outVars, externVars: externVars, inits: []};

hrt/shgraph/ShaderOutput.hx

@@ -16,14 +16,14 @@ class ShaderOutput extends ShaderNode {
 	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
-		var inVar : TVar = {name: "input", id:0, type: this.variable.type, kind: Param, qualifiers: [SgInput]};
-		var output : TVar = {name: variable.name, id:1, type: this.variable.type, kind: Local, qualifiers: [SgOutput]};
+		var inVar : TVar = {name: "input", id:0, type: this.variable.type, kind: Param, qualifiers: []};
+		var output : TVar = {name: variable.name, id:1, type: this.variable.type, kind: Local, qualifiers: []};
 		var finalExpr : TExpr = {e: TBinop(OpAssign, {e:TVar(output), p:pos, t:output.type}, {e: TVar(inVar), p: pos, t: output.type}), p: pos, t: output.type};
 
 		//var param = getParameter(inputNode.parameterId);
 		//inits.push({variable: inVar, value: param.defaultValue});
 
-		return {expr: finalExpr, inVars: [inVar], outVars:[], externVars: [inVar, output], inits: []};
+		return {expr: finalExpr, inVars: [{v: inVar, internal: false}], outVars:[], externVars: [output], inits: []};
 	}
 
 	/*override public function checkValidityInput(key : String, type : hxsl.Ast.Type) : Bool {

hrt/shgraph/ShaderParam.hx

@@ -15,16 +15,16 @@ class ShaderParam extends ShaderNode {
 	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
-		var qual = [SgInput];
+		var qual = [];
 		if (this.variable.type == TSampler2D) {
 			qual.push(Sampler(this.variable.name));
 		}
 		var inVar : TVar = {name: this.variable.name, id:0, type: this.variable.type, kind: Param, qualifiers: qual};
-		var output : TVar = {name: "output", id:1, type: this.variable.type, kind: Local, qualifiers: [SgOutput]};
+		var output : TVar = {name: "output", id:1, type: this.variable.type, kind: Local, qualifiers: []};
 		//var finalExpr : TExpr = {e: TBinop(OpAssign, {e:TVar(output), p:pos, t:output.type}, {e: TVar(inVar), p: pos, t: output.type}), p: pos, t: output.type};
 
 
-		return {expr: null, inVars: [], outVars:[output], externVars: [inVar, output], inits: []};
+		return {expr: null, inVars: [{v:inVar, internal: true}], outVars:[{v:output, internal: false}], externVars: [], inits: []};
 	}
 
 	public var variable : TVar;

hrt/shgraph/nodes/BoolConst.hx

@@ -15,10 +15,10 @@ class BoolConst extends ShaderConst {
 	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
-		var output : TVar = {name: "output", id:1, type: TBool, kind: Local, qualifiers: [SgOutput]};
+		var output : TVar = {name: "output", id:1, type: TBool, kind: Local, qualifiers: []};
 		var finalExpr : TExpr = {e: TBinop(OpAssign, {e:TVar(output), p:pos, t:output.type}, {e: TConst(CBool(value)), p: pos, t: output.type}), p: pos, t: output.type};
 
-		return {expr: finalExpr, inVars: [], outVars:[output], externVars: [output], inits: []};
+		return {expr: finalExpr, inVars: [], outVars:[{v: output, internal: false}], externVars: [], inits: []};
 	}
 
 	#if editor

hrt/shgraph/nodes/Color.hx

@@ -29,7 +29,7 @@ class Color extends ShaderConst {
 	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
-		var output : TVar = {name: "output", id:1, type: TVec(4, VFloat), kind: Local, qualifiers: [SgOutput]};
+		var output : TVar = {name: "output", id:1, type: TVec(4, VFloat), kind: Local, qualifiers: []};
 		var finalExpr : TExpr =
 		{ e: TBinop(OpAssign, {
 				e: TVar(output),
@@ -74,7 +74,7 @@ class Color extends ShaderConst {
 			p: null,
 			t: output.type
 		};
-		return {expr: finalExpr, inVars: [], outVars:[output], externVars: [output], inits: []};
+		return {expr: finalExpr, inVars: [], outVars:[{v: output, internal: false}], externVars: [], inits: []};
 	}
 
 	// override public function build(key : String) : TExpr {

hrt/shgraph/nodes/FloatConst.hx

@@ -12,10 +12,10 @@ class FloatConst extends ShaderConst {
 	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
-		var output : TVar = {name: "output", id:1, type: TFloat, kind: Local, qualifiers: [SgOutput]};
+		var output : TVar = {name: "output", id:1, type: TFloat, kind: Local, qualifiers: []};
 		var finalExpr : TExpr = {e: TBinop(OpAssign, {e:TVar(output), p:pos, t:output.type}, {e: TConst(CFloat(value)), p: pos, t: output.type}), p: pos, t: output.type};
 
-		return {expr: finalExpr, inVars: [], outVars:[output], externVars: [output], inits: []};
+		return {expr: finalExpr, inVars: [], outVars:[{v: output, internal: false}], externVars: [], inits: []};
 	}
 
 	@prop() var value : Float = 0.;

hrt/shgraph/nodes/Preview.hx

@@ -14,14 +14,14 @@ class Preview extends ShaderNode {
 	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
-		var inVar : TVar = {name: "input", id:0, type: TVec(4, VFloat), kind: Param, qualifiers: [SgInput]};
-		var output : TVar = {name: "pixelColor", id:1, type: TVec(4, VFloat), kind: Local, qualifiers: [SgOutput]};
+		var inVar : TVar = {name: "input", id:0, type: TVec(4, VFloat), kind: Param, qualifiers: []};
+		var output : TVar = {name: "pixelColor", id:1, type: TVec(4, VFloat), kind: Local, qualifiers: []};
 		var finalExpr : TExpr = {e: TBinop(OpAssign, {e:TVar(output), p:pos, t:output.type}, {e: TVar(inVar), p: pos, t: output.type}), p: pos, t: output.type};
 
 		//var param = getParameter(inputNode.parameterId);
 		//inits.push({variable: inVar, value: param.defaultValue});
 
-		return {expr: finalExpr, inVars: [inVar], outVars:[], externVars: [inVar, output], inits: []};
+		return {expr: finalExpr, inVars: [{v: inVar, internal: false}], outVars:[], externVars: [output], inits: []};
 	}
 
 	// @input("Input") var input = SType.Vec4;

hrt/shgraph/nodes/SubGraph.hx

@@ -14,16 +14,16 @@ class SubGraph extends ShaderNode {
 		var shader = new ShaderGraph(pathShaderGraph);
 		var gen = shader.generate2();
 
-		for (tvar in gen.externVars) {
-			if (tvar.qualifiers != null) {
-				if (tvar.qualifiers.contains(SgInput)) {
-					gen.inVars.push(tvar);
-				}
-				if (tvar.qualifiers.contains(SgOutput)) {
-					gen.outVars.push(tvar);
-				}
-			}
-		}
+		// for (tvar in gen.externVars) {
+		// 	if (tvar.qualifiers != null) {
+		// 		if (tvar.qualifiers.contains(SgInput)) {
+		// 			gen.inVars.push(tvar);
+		// 		}
+		// 		if (tvar.qualifiers.contains(SgOutput)) {
+		// 			gen.outVars.push(tvar);
+		// 		}
+		// 	}
+		// }
 
 		return gen;
 	}