Output rewritten

hide/view/Graph.hx

@@ -305,10 +305,9 @@ class Graph extends FileView {
 				setAvailableOutputNodes(box, grNode.find(".node").attr("field"));
 			});
 		}
-		for (outputKey in box.getInstance().getOutputInfoKeys()) {
-			var outputInfo = box.getInstance().getOutputInfo(outputKey);
-			var grNode = box.addOutput(editor, outputInfo.name, box.getInstance().getOutputType(outputKey));
-			grNode.find(".node").attr("field", outputKey);
+		for (outputName => outputVar in box.getInstance().getOutputs2()) {
+			var grNode = box.addOutput(editor, outputName, outputVar.type);
+			grNode.find(".node").attr("field", outputName);
 			grNode.on("mousedown", function(e) {
 				e.stopPropagation();
 				var node = grNode.find(".node");
@@ -381,14 +380,11 @@ class Graph extends FileView {
 		}
 	}
 
+	// TODO(ces) : nuke SType from orbit
 	function setAvailableInputNodes(boxOutput : Box, field : String) {
-		var type = boxOutput.getInstance().getOutputType(field);
+		var type = boxOutput.getInstance().getOutputs2()[field].type;
 		var sType : SType;
-		if (type == null) {
-			sType = boxOutput.getInstance().getOutputInfo(field).type;
-		} else {
-			sType = ShaderType.getSType(type);
-		}
+		sType = ShaderType.getSType(type);
 
 		for (box in listOfBoxes) {
 			for (input in box.inputs) {
@@ -403,13 +399,8 @@ class Graph extends FileView {
 		for (box in listOfBoxes) {
 			for (output in box.outputs) {
 				var outputField = output.attr("field");
-				var type = box.getInstance().getOutputType(outputField);
-				var sType : SType;
-				if (type == null) {
-					sType = box.getInstance().getOutputInfo(outputField).type;
-				} else {
-					sType = ShaderType.getSType(type);
-				}
+				var type = box.getInstance().getOutputs2()[outputField].type;
+				var sType = ShaderType.getSType(type);
 				if (boxInput.getInstance().checkTypeAndCompatibilyInput(field, sType)) {
 					output.addClass("nodeMatch");
 				}

hide/view/shadereditor/Box.hx

@@ -166,7 +166,7 @@ class Box {
 		}
 		var nodeCircle = editor.circle(node, width, nodeHeight, NODE_RADIUS, style).addClass("node output-node");
 
-		if (name.length > 0)
+		if (name.length > 0 && name != "output")
 			editor.text(node, width - NODE_TITLE_PADDING - (name.length * 6.75), nodeHeight + 4, name).addClass("title-node");
 
 		outputs.push(nodeCircle);

hide/view/shadereditor/ShaderEditor.hx

@@ -518,21 +518,19 @@ class ShaderEditor extends hide.view.Graph {
 	}
 
 	function generateEdgesFromBox(box : Box) {
-		for (outputKey in box.getInstance().getOutputInfoKeys()) {
-			var output = box.getInstance().getOutput(outputKey);
-			if (output != null) {
-				for (b in listOfBoxes) {
-					for (key in b.getInstance().getInputsKey()) {
-						var input = b.getInstance().getInput(key);
-						if (input != null && input.node.id == box.getId() && input.keyOutput == outputKey) {
-							var nodeFrom = box.getElement().find('[field=${outputKey}]');
-							var nodeTo = b.getElement().find('[field=${key}]');
-							edgeStyle.stroke = nodeFrom.css("fill");
-							createEdgeInEditorGraph({from: box, nodeFrom: nodeFrom, to : b, nodeTo: nodeTo, elt : createCurve(nodeFrom, nodeTo) });
-						}
+		for (outputName => outputVar in box.getInstance().getOutputs2()) {
+			for (b in listOfBoxes) {
+				for (key in b.getInstance().getInputsKey()) {
+					var input = b.getInstance().getInput(key);
+					if (input != null && input.node.id == box.getId() && input.keyOutput == outputName) {
+						var nodeFrom = box.getElement().find('[field=${outputName}]');
+						var nodeTo = b.getElement().find('[field=${key}]');
+						edgeStyle.stroke = nodeFrom.css("fill");
+						createEdgeInEditorGraph({from: box, nodeFrom: nodeFrom, to : b, nodeTo: nodeTo, elt : createCurve(nodeFrom, nodeTo) });
 					}
 				}
 			}
+
 		}
 	}
 

hrt/shgraph/NodeVar.hx

@@ -17,289 +17,24 @@ class NodeVar {
 	}
 
 	public function getTVar() {
-		return node.getOutput(keyOutput);
+		return null;//node.getOutput(keyOutput);
 	}
 
 	public function getType() : Type {
-		return node.getOutputType(keyOutput);
+		return TVoid;//node.getOutputType(keyOutput);
 	}
 
 	public function isEmpty() {
-		return node.getOutputTExpr(keyOutput) == null;
+		return true;//node.getOutputTExpr(keyOutput) == null;
 	}
 
 	public function getVar(?type: Type) : TExpr {
 		var currentType = getType();
 		if (type == null || currentType == type) {
-			return node.getOutputTExpr(keyOutput);
+			return null;//node.getOutputTExpr(keyOutput);
 		}
 
-		switch(currentType) {
-			case TBool:
-				var tExprBool = node.getOutputTExpr(keyOutput);
-				switch(type) {
-					case TVec(size, VBool):
-						if (size == 2) {
-							return {
-								e: TCall({
-									e: TGlobal(Vec2),
-									p: null,
-									t: TFun([
-										{
-											ret: type,
-											args: [
-											{ name: "u", type : TBool },
-											{ name: "v", type : TBool }]
-										}
-									])
-								}, [tExprBool,
-									tExprBool]),
-								p: null,
-								t: type
-							};
-						} else if (size == 3) {
-							return {
-								e: TCall({
-									e: TGlobal(Vec3),
-									p: null,
-									t: TFun([
-										{
-											ret: type,
-											args: [
-											{ name: "x", type : TBool },
-											{ name: "y", type : TBool },
-											{ name: "z", type : TBool }]
-										}
-									])
-								}, [tExprBool,
-									tExprBool,
-									tExprBool]),
-								p: null,
-								t: type
-							};
-						} else {
-							return {
-								e: TCall({
-									e: TGlobal(Vec4),
-									p: null,
-									t: TFun([
-										{
-											ret: type,
-											args: [
-											{ name: "r", type : TBool },
-											{ name: "g", type : TBool },
-											{ name: "b", type : TBool },
-											{ name: "a", type : TBool }]
-										}
-									])
-								}, [tExprBool,
-									tExprBool,
-									tExprBool,
-									tExprBool]),
-								p: null,
-								t: type
-							};
-						}
-					default:
-				};
-			case TFloat:
-				var tExprFloat = node.getOutputTExpr(keyOutput);
-				switch(type) {
-					case TVec(size, VFloat):
-						if (size == 2) {
-							return {
-								e: TCall({
-									e: TGlobal(Vec2),
-									p: null,
-									t: TFun([
-										{
-											ret: type,
-											args: [
-											{ name: "u", type : TFloat },
-											{ name: "v", type : TFloat }]
-										}
-									])
-								}, [tExprFloat,
-									tExprFloat]),
-								p: null,
-								t: type
-							};
-						} else if (size == 3) {
-							return {
-								e: TCall({
-									e: TGlobal(Vec3),
-									p: null,
-									t: TFun([
-										{
-											ret: type,
-											args: [
-											{ name: "x", type : TFloat },
-											{ name: "y", type : TFloat },
-											{ name: "z", type : TFloat }]
-										}
-									])
-								}, [tExprFloat,
-									tExprFloat,
-									tExprFloat]),
-								p: null,
-								t: type
-							};
-						} else {
-							return {
-								e: TCall({
-									e: TGlobal(Vec4),
-									p: null,
-									t: TFun([
-										{
-											ret: type,
-											args: [
-											{ name: "r", type : TFloat },
-											{ name: "g", type : TFloat },
-											{ name: "b", type : TFloat },
-											{ name: "a", type : TFloat }]
-										}
-									])
-								}, [tExprFloat,
-									tExprFloat,
-									tExprFloat,
-									{
-										e: TConst(CFloat(1.0)),
-										p: null,
-										t: TFloat
-									}]),
-								p: null,
-								t: type
-							};
-						}
-					default:
-				};
-			case TVec(sizeCurrentType, VFloat):
-				var tExprFloat = node.getOutputTExpr(keyOutput);
-				if (sizeCurrentType == 2) {
-					switch(type) {
-						case TVec(size, VFloat):
-							if (size == 3) {
-								return {
-									e: TCall({
-										e: TGlobal(Vec3),
-										p: null,
-										t: TFun([
-											{
-												ret: type,
-												args: [
-												{ name: "x", type : TFloat },
-												{ name: "y", type : TFloat },
-												{ name: "z", type : TFloat }]
-											}
-										])
-									}, [{
-											e: TSwiz(tExprFloat, [X]),
-											p: null,
-											t: TVec(1, VFloat)
-										},
-										{
-											e: TSwiz(tExprFloat, [Y]),
-											p: null,
-											t: TVec(1, VFloat)
-										},
-										{
-											e: TConst(CFloat(0.0)),
-											p: null,
-											t: TFloat
-										}]),
-									p: null,
-									t: type
-								};
-							} else if (size == 4) {
-								return {
-									e: TCall({
-										e: TGlobal(Vec4),
-										p: null,
-										t: TFun([
-											{
-												ret: type,
-												args: [
-												{ name: "r", type : TFloat },
-												{ name: "g", type : TFloat },
-												{ name: "b", type : TFloat },
-												{ name: "a", type : TFloat }]
-											}
-										])
-									}, [{
-											e: TSwiz(tExprFloat, [X]),
-											p: null,
-											t: TVec(1, VFloat)
-										},
-										{
-											e: TSwiz(tExprFloat, [Y]),
-											p: null,
-											t: TVec(1, VFloat)
-										},
-										{
-											e: TConst(CFloat(0.0)),
-											p: null,
-											t: TFloat
-										},
-										{
-											e: TConst(CFloat(0.0)),
-											p: null,
-											t: TFloat
-										}]),
-									p: null,
-									t: type
-								};
-							}
-						default:
-					};
-				} else if (sizeCurrentType == 3) {
-					switch(type) {
-						case TVec(size, VFloat):
-							if (size == 4) {
-								return {
-									e: TCall({
-										e: TGlobal(Vec4),
-										p: null,
-										t: TFun([
-											{
-												ret: type,
-												args: [
-												{ name: "r", type : TFloat },
-												{ name: "g", type : TFloat },
-												{ name: "b", type : TFloat },
-												{ name: "a", type : TFloat }]
-											}
-										])
-									}, [{
-											e: TSwiz(tExprFloat, [X]),
-											p: null,
-											t: TVec(1, VFloat)
-										},
-										{
-											e: TSwiz(tExprFloat, [Y]),
-											p: null,
-											t: TVec(1, VFloat)
-										},
-										{
-											e: TSwiz(tExprFloat, [Z]),
-											p: null,
-											t: TVec(1, VFloat)
-										},
-										{
-											e: TConst(CFloat(0.0)),
-											p: null,
-											t: TFloat
-										}]),
-									p: null,
-									t: type
-								};
-							}
-						default:
-					};
-				}
-
-			default:
-		}
-		return node.getOutputTExpr(keyOutput);
+		return null;
 	}
 
 	public function getExpr() : Array<TExpr> {

hrt/shgraph/Operation.hx

@@ -7,7 +7,6 @@ class Operation extends ShaderNodeHxsl {
 	@input("A", true) var a = SType.Number;
 	@input("B", true) var b = SType.Number;
 
-	@output("") var output = SType.Number;
 
 	var operation : Binop;
 
@@ -26,22 +25,22 @@ class Operation extends ShaderNodeHxsl {
 			removeOutput("output");
 	}
 
-	override public function build(key : String) : TExpr {
-
-		return { e: TBinop(OpAssign, {
-						e: TVar(output),
-						p: null,
-						t: output.type
-					}, {
-						e: TBinop(operation,
-							a.getVar(b.getType()),
-							b.getVar(a.getType())),
-						p: null,
-						t: output.type
-					}),
-					p: null,
-					t: output.type
-				};
-	}
+	// override public function build(key : String) : TExpr {
+
+	// 	return { e: TBinop(OpAssign, {
+	// 					e: TVar(output),
+	// 					p: null,
+	// 					t: output.type
+	// 				}, {
+	// 					e: TBinop(operation,
+	// 						a.getVar(b.getType()),
+	// 						b.getVar(a.getType())),
+	// 					p: null,
+	// 					t: output.type
+	// 				}),
+	// 				p: null,
+	// 				t: output.type
+	// 			};
+	// }
 
 }

hrt/shgraph/ParseFieldsMacro.hx

@@ -95,30 +95,6 @@ class ParseFieldsMacro {
 
 							break;
 						} else if (m.name == "output") {
-							hasOutputs = true;
-							var sel = f.name;
-							var get_sel = "get_" + sel;
-							var sfields = macro class {
-								inline function $get_sel() : TVar return getOutput($v{sel});
-							};
-							for( field in sfields.fields )
-								fields.push(field);
-							if (e == null)
-								Context.error('Output ${sel} has not affectation', f.pos);
-							var nameOutput = "";
-							if (m.params.length > 0) {
-								switch(m.params[0].expr) {
-									case EConst(CString(s)):
-										if (s.length > 0)
-											nameOutput = s;
-									default:
-								}
-							}
-							var enumValue = ["ShaderType", "SType", e.toString().split(".").pop()];
-							mapOutputs.push(macro $v{sel} => { name : $v{nameOutput}, type : ${enumValue.toFieldExpr()} });
-							f.kind = FProp("get", "null", TPath({ pack: [], name: "TVar" }));
-							f.meta = saveMeta;
-							outputsList.push(f.name);
 
 							break;
 						}
@@ -141,18 +117,18 @@ class ParseFieldsMacro {
 				fields.push(field);
 		}
 		if (hasOutputs) {
-			fields.push({
+			/*fields.push({
 				name: "outputsInfo",
 				access: [Access.APrivate],
 				kind: FieldType.FVar(macro:Map<String, ShaderNode.OutputInfo>, macro $a{mapOutputs}),
 				pos: Context.currentPos(),
-			});
-			var sfields = macro class {
+			});*/
+			/*var sfields = macro class {
 				override public function getOutputInfo(key : String) : ShaderNode.OutputInfo return outputsInfo.get(key);
 				override public function getOutputInfoKeys() : Array<String> return $v{outputsList};
 			};
 			for( field in sfields.fields )
-				fields.push(field);
+				fields.push(field);*/
 		}
 
 		var thisClass = Context.getLocalClass();

hrt/shgraph/ShaderConst.hx

@@ -6,9 +6,9 @@ class ShaderConst extends ShaderNode {
 
 	@prop() public var name : String = "";
 
-	override public function getOutputType(key : String) : Type {
-		return getOutputTExpr(key).t;
-	}
+	// override public function getOutputType(key : String) : Type {
+	// 	return getOutputTExpr(key).t;
+	// }
 
 	override public function build(key : String) : TExpr {
 		return null;

hrt/shgraph/ShaderFunction.hx

@@ -4,7 +4,6 @@ using hxsl.Ast;
 
 class ShaderFunction extends ShaderNode {
 
-	@output("") var output = SType.Variant;
 
 	var func : TGlobal;
 
@@ -12,46 +11,46 @@ class ShaderFunction extends ShaderNode {
 		this.func = func;
 	}
 
-	override public function build(key : String) : TExpr {
-		var args = [];
-		var varArgs = [];
-
-		for (k in getInputInfoKeys()) {
-			if (getInputInfo(k).hasProperty && getInput(k) == null) {
-				var value : Dynamic = Reflect.field(this, "prop_"+k);
-				if (value == null)
-					value = 0;
-				args.push({ name: k, type: TFloat });
-				varArgs.push(new NodeVar(new hrt.shgraph.nodes.FloatConst(value), "output").getVar());
-			} else {
-				args.push({ name: k, type: getInput(k).getType() });
-				var wantedType = ShaderType.getType(getInputInfo(k).type);
-				varArgs.push(getInput(k).getVar((wantedType != null) ? wantedType : null));
-			}
-		}
-
-		return {
-					p : null,
-					t : output.type,
-					e : TBinop(OpAssign, {
-						e: TVar(output),
-						p: null,
-						t: output.type
-					}, {
-						e: TCall({
-							e: TGlobal(func),
-							p: null,
-							t: TFun([
-								{
-									ret: output.type,
-									args: args
-								}
-							])
-						}, varArgs),
-						p: null,
-						t: output.type
-					})
-				};
-	}
+	// override public function build(key : String) : TExpr {
+	// 	var args = [];
+	// 	var varArgs = [];
+
+	// 	for (k in getInputInfoKeys()) {
+	// 		if (getInputInfo(k).hasProperty && getInput(k) == null) {
+	// 			var value : Dynamic = Reflect.field(this, "prop_"+k);
+	// 			if (value == null)
+	// 				value = 0;
+	// 			args.push({ name: k, type: TFloat });
+	// 			varArgs.push(new NodeVar(new hrt.shgraph.nodes.FloatConst(value), "output").getVar());
+	// 		} else {
+	// 			args.push({ name: k, type: getInput(k).getType() });
+	// 			var wantedType = ShaderType.getType(getInputInfo(k).type);
+	// 			varArgs.push(getInput(k).getVar((wantedType != null) ? wantedType : null));
+	// 		}
+	// 	}
+
+	// 	return {
+	// 				p : null,
+	// 				t : output.type,
+	// 				e : TBinop(OpAssign, {
+	// 					e: TVar(output),
+	// 					p: null,
+	// 					t: output.type
+	// 				}, {
+	// 					e: TCall({
+	// 						e: TGlobal(func),
+	// 						p: null,
+	// 						t: TFun([
+	// 							{
+	// 								ret: output.type,
+	// 								args: args
+	// 							}
+	// 						])
+	// 					}, varArgs),
+	// 					p: null,
+	// 					t: output.type
+	// 				})
+	// 			};
+	// }
 
 }

hrt/shgraph/ShaderGraph.hx

@@ -137,27 +137,20 @@ class ShaderGraph {
 	public function addEdge(edge : Edge) {
 		var node = this.nodes.get(edge.idInput);
 		var output = this.nodes.get(edge.idOutput);
+		if (!output.instance.getOutputs2().exists(edge.nameOutput)) {
+			return false;
+		}
 		node.instance.setInput(edge.nameInput, new NodeVar(output.instance, edge.nameOutput));
 		output.outputs.push(node);
 
 		// pas du tout envie de mourrir
-		var fromGen = output.instance.getShaderDef();
-		var fromName = fromGen.outVars[output.instance.getOutputInfoKeys().indexOf(edge.nameOutput)].name;
 
 		var toGen = node.instance.getShaderDef();
 		var toName = toGen.inVars[node.instance.getInputInfoKeys().indexOf(edge.nameInput)].name;
 
-		var connection : Connection = {from: output, fromName: fromName};
+		var connection : Connection = {from: output, fromName: edge.nameOutput};
 		node.instance.inputs2.set(toName, connection);
 
-		var subShaderIn = Std.downcast(node.instance, hrt.shgraph.nodes.SubGraph);
-		var subShaderOut = Std.downcast(output.instance, hrt.shgraph.nodes.SubGraph);
-		if( @:privateAccess ((subShaderIn != null) && !subShaderIn.inputInfoKeys.contains(edge.nameInput))
-			|| @:privateAccess ((subShaderOut != null) && !subShaderOut.outputInfoKeys.contains(edge.nameOutput))
-		) {
-			removeEdge(edge.idInput, edge.nameInput, false);
-		}
-
 		#if editor
 		if (hasCycle()){
 			removeEdge(edge.idInput, edge.nameInput, false);

hrt/shgraph/ShaderInput.hx

@@ -8,17 +8,16 @@ using hxsl.Ast;
 @color("#0e8826")
 class ShaderInput extends ShaderNode {
 
-	@output() var output = SType.Variant;
 
 	@prop("Variable") public var variable : TVar;
 
-	override public function getOutput(key : String) : TVar {
-		return variable;
-	}
+	// override public function getOutput(key : String) : TVar {
+	// 	return variable;
+	// }
 
-	override public function build(key : String) : TExpr {
-		return null;
-	}
+	// override public function build(key : String) : TExpr {
+	// 	return null;
+	// }
 
 	public static var availableInputs : Array<TVar> = [
 									{ parent: null, id: 0, kind: Input, name: "position", type: TVec(3, VFloat) },

hrt/shgraph/ShaderNode.hx

@@ -27,12 +27,23 @@ class ShaderNode {
 	}
 
 	var inputs : Map<String, NodeVar> = [];
-	var outputs : Map<String, TVar> = [];
+	// var outputs : Map<String, TVar> = [];
 
 	public var inputs2 : Map<String, ShaderGraph.Connection> = [];
 
 	public var outputCompiled : Map<String, Bool> = []; // todo: put with outputs variable
 
+	// TODO(ces) : caching
+	public function getOutputs2() : Map<String, TVar> {
+		var def = getShaderDef();
+		var map : Map<String, TVar> = [];
+		for (tvar in def.outVars) {
+			map.set(tvar.name, tvar);
+		}
+		return map;
+	}
+
+
 	public function setId(id : Int) {
 		this.id = id;
 	}
@@ -60,46 +71,47 @@ class ShaderNode {
 		return inputs.keys().hasNext();
 	}
 
+
 	function addOutput(key : String, t : Type) {
-		outputs.set(key, { parent: null,
+		/*outputs.set(key, { parent: null,
 			id: 0,
 			kind: Local,
 			name: "output_" + id + "_" + key,
 			type: t
-		});
+		});*/
 	}
 
 	function removeOutput(key : String) {
-		outputs.remove(key);
+		/*outputs.remove(key);*/
 	}
 
 	function addOutputTvar(tVar : TVar) {
-		outputs.set(tVar.name, tVar);
+		/*outputs.set(tVar.name, tVar);*/
 	}
 
 	public function computeOutputs() : Void {}
 
-	public function getOutput(key : String) : TVar {
-		return outputs.get(key);
-	}
-
-	public function getOutputType(key : String) : Type {
-		var output = getOutput(key);
-		if (output == null)
-			return null;
-		return output.type;
-	}
-
-	public function getOutputTExpr(key : String) : TExpr {
-		var o = getOutput(key);
-		if (o == null)
-			return null;
-		return {
-			e: TVar(o),
-			p: null,
-			t: o.type
-		};
-	}
+	// public function getOutput(key : String) : TVar {
+	// 	return outputs.get(key);
+	// }
+
+	// public function getOutputType(key : String) : Type {
+	// 	var output = getOutput(key);
+	// 	if (output == null)
+	// 		return null;
+	// 	return output.type;
+	// }
+
+	// public function getOutputTExpr(key : String) : TExpr {
+	// 	var o = getOutput(key);
+	// 	if (o == null)
+	// 		return null;
+	// 	return {
+	// 		e: TVar(o),
+	// 		p: null,
+	// 		t: o.type
+	// 	};
+	// }
 
 	public function build(key : String) : TExpr {
 		throw "Build function not implemented";
@@ -125,13 +137,13 @@ class ShaderNode {
 		return null;
 	}
 
-	public function getOutputInfoKeys() : Array<String> {
-		return [];
-	}
+	// public function getOutputInfoKeys() : Array<String> {
+	// 	return [];
+	// }
 
-	public function getOutputInfo(key : String) : OutputInfo {
-		return null;
-	}
+	// public function getOutputInfo(key : String) : OutputInfo {
+	// 	return null;
+	// }
 
 	public function loadProperties(props : Dynamic) {
 		var fields = Reflect.fields(props);

hrt/shgraph/ShaderParam.hx

@@ -7,7 +7,6 @@ using hxsl.Ast;
 @color("#d6d6d6")
 class ShaderParam extends ShaderNode {
 
-	@output() var output = SType.Variant;
 
 	@prop() public var parameterId : Int;
 	@prop() public var perInstance : Bool;
@@ -33,9 +32,6 @@ class ShaderParam extends ShaderNode {
 			removeOutput("output");
 	}
 
-	override public function getOutput(key : String) : TVar {
-		return variable;
-	}
 
 	override public function loadProperties(props : Dynamic) {
 		parameterId = Reflect.field(props, "parameterId");

hrt/shgraph/nodes/Add.hx

@@ -17,7 +17,7 @@ class Add extends Operation {
 		@sginput var b : Vec4;
 		@sgoutput var output : Vec4;
 		function fragment() {
-			output = a + b;;
+			output = a + b;
 		}
 	}
 

hrt/shgraph/nodes/BoolConst.hx

@@ -9,17 +9,16 @@ using hxsl.Ast;
 @noheader()
 class BoolConst extends ShaderConst {
 
-	@output() var fakeOutput = SType.Bool;
 
 	@prop() var value : Bool = true;
 
-	override public function getOutputTExpr(key : String) : TExpr {
-		return {
-					e: TConst(CBool(value)),
-					p: null,
-					t: TBool
-				};
-	}
+	// override public function getOutputTExpr(key : String) : TExpr {
+	// 	return {
+	// 				e: TConst(CBool(value)),
+	// 				p: null,
+	// 				t: TBool
+	// 			};
+	// }
 
 	override public function build(key : String) : TExpr {
 		return null;

hrt/shgraph/nodes/Color.hx

@@ -9,8 +9,6 @@ using hxsl.Ast;
 @noheader()
 class Color extends ShaderConst {
 
-	@output() var output = SType.Vec4;
-
 	@prop() var r : Float = 0;
 	@prop() var g : Float = 0;
 	@prop() var b : Float = 0;
@@ -20,60 +18,60 @@ class Color extends ShaderConst {
 		addOutput("output", TVec(4, VFloat));
 	}
 
-	override public function getOutputTExpr(key : String) : TExpr {
-		return {
-			e: TVar(output),
-			p: null,
-			t: TVec(4, VFloat)
-		};
-	}
+	// override public function getOutputTExpr(key : String) : TExpr {
+	// 	return {
+	// 		e: TVar(output),
+	// 		p: null,
+	// 		t: TVec(4, VFloat)
+	// 	};
+	// }
 
-	override public function build(key : String) : TExpr {
+	// override public function build(key : String) : TExpr {
 
-		return { e: TBinop(OpAssign, {
-						e: TVar(output),
-						p: null,
-						t: output.type
-					}, {
-						e: TCall({
-							e: TGlobal(Vec4),
-							p: null,
-							t: TFun([
-								{
-									ret: output.type,
-									args: [
-									{ name: "r", type : TFloat },
-									{ name: "g", type : TFloat },
-									{ name: "b", type : TFloat },
-									{ name: "a", type : TFloat }]
-								}
-							])
-						}, [{
-								e: TConst(CFloat(r)),
-								p: null,
-								t: TFloat
-							},
-							{
-								e: TConst(CFloat(g)),
-								p: null,
-								t: TFloat
-							},
-							{
-								e: TConst(CFloat(b)),
-								p: null,
-								t: TFloat
-							},{
-								e: TConst(CFloat(a)),
-								p: null,
-								t: TFloat
-							}]),
-						p: null,
-						t: output.type
-					}),
-					p: null,
-					t: output.type
-				};
-	}
+	// 	return { e: TBinop(OpAssign, {
+	// 					e: TVar(output),
+	// 					p: null,
+	// 					t: output.type
+	// 				}, {
+	// 					e: TCall({
+	// 						e: TGlobal(Vec4),
+	// 						p: null,
+	// 						t: TFun([
+	// 							{
+	// 								ret: output.type,
+	// 								args: [
+	// 								{ name: "r", type : TFloat },
+	// 								{ name: "g", type : TFloat },
+	// 								{ name: "b", type : TFloat },
+	// 								{ name: "a", type : TFloat }]
+	// 							}
+	// 						])
+	// 					}, [{
+	// 							e: TConst(CFloat(r)),
+	// 							p: null,
+	// 							t: TFloat
+	// 						},
+	// 						{
+	// 							e: TConst(CFloat(g)),
+	// 							p: null,
+	// 							t: TFloat
+	// 						},
+	// 						{
+	// 							e: TConst(CFloat(b)),
+	// 							p: null,
+	// 							t: TFloat
+	// 						},{
+	// 							e: TConst(CFloat(a)),
+	// 							p: null,
+	// 							t: TFloat
+	// 						}]),
+	// 					p: null,
+	// 					t: output.type
+	// 				}),
+	// 				p: null,
+	// 				t: output.type
+	// 			};
+	// }
 
 	#if editor
 	override public function getPropertiesHTML(width : Float) : Array<hide.Element> {

hrt/shgraph/nodes/Combine.hx

@@ -15,99 +15,98 @@ class Combine extends ShaderNode {
 	@input("B", false, false) var b = SType.Float;
 	@input("A", false, false) var a = SType.Float;
 
-	@output() var output = SType.Number;
 
 	var components = [X, Y, Z, W];
 	var componentsString = ["r", "g", "b", "a"];
 	var numberOutputs = 0;
 
-	function generateOutputComp(idx : Int) : TExpr {
-		var comp = components[idx];
+	// function generateOutputComp(idx : Int) : TExpr {
+	// 	var comp = components[idx];
 
-		var input = getInput(componentsString[idx]);
-		return {
-					p : null,
-					t : output.type,
-					e : TBinop(OpAssign, {
-						e: TSwiz({
-							e: TVar(output),
-							p: null,
-							t : output.type
-						}, [comp]),
-						p: null,
-						t: TVec(1, VFloat)
-					}, input.getVar())
-				};
-	}
+	// 	var input = getInput(componentsString[idx]);
+	// 	return {
+	// 				p : null,
+	// 				t : output.type,
+	// 				e : TBinop(OpAssign, {
+	// 					e: TSwiz({
+	// 						e: TVar(output),
+	// 						p: null,
+	// 						t : output.type
+	// 					}, [comp]),
+	// 					p: null,
+	// 					t: TVec(1, VFloat)
+	// 				}, input.getVar())
+	// 			};
+	// }
 
-	override public function computeOutputs() {
-		numberOutputs = 0;
-		if (a != null && !a.isEmpty()) {
-			numberOutputs = 4;
-		} else if (b != null && !b.isEmpty()) {
-			numberOutputs = 3;
-		} else if (g != null && !g.isEmpty()) {
-			numberOutputs = 2;
-		} else if (r != null && !r.isEmpty()) {
-			numberOutputs = 1;
-		}
-		if (numberOutputs == 1) {
-			addOutput("output", TFloat);
-		} else {
-			addOutput("output", TVec(numberOutputs, VFloat));
-		}
-	}
+	// override public function computeOutputs() {
+	// 	numberOutputs = 0;
+	// 	if (a != null && !a.isEmpty()) {
+	// 		numberOutputs = 4;
+	// 	} else if (b != null && !b.isEmpty()) {
+	// 		numberOutputs = 3;
+	// 	} else if (g != null && !g.isEmpty()) {
+	// 		numberOutputs = 2;
+	// 	} else if (r != null && !r.isEmpty()) {
+	// 		numberOutputs = 1;
+	// 	}
+	// 	if (numberOutputs == 1) {
+	// 		addOutput("output", TFloat);
+	// 	} else {
+	// 		addOutput("output", TVec(numberOutputs, VFloat));
+	// 	}
+	// }
 
-	override public function build(key : String) : TExpr {
+	// override public function build(key : String) : TExpr {
 
-		var args = [];
-		var valueArgs = [];
-		var opTGlobal : TGlobal = Vec4;
-		if (numberOutputs >= 1) {
-			args.push({ name: "r", type : TFloat });
-			valueArgs.push(r.getVar());
-			opTGlobal = ToFloat;
-		}
-		if (numberOutputs >= 2) {
-			args.push({ name: "g", type : TFloat });
-			valueArgs.push(g.getVar());
-			opTGlobal = Vec2;
-		}
-		if (numberOutputs >= 3) {
-			args.push({ name: "b", type : TFloat });
-			valueArgs.push(b.getVar());
-			opTGlobal = Vec3;
-		}
-		if (numberOutputs >= 4) {
-			args.push({ name: "a", type : TFloat });
-			valueArgs.push(a.getVar());
-			opTGlobal = Vec4;
-		}
+	// 	var args = [];
+	// 	var valueArgs = [];
+	// 	var opTGlobal : TGlobal = Vec4;
+	// 	if (numberOutputs >= 1) {
+	// 		args.push({ name: "r", type : TFloat });
+	// 		valueArgs.push(r.getVar());
+	// 		opTGlobal = ToFloat;
+	// 	}
+	// 	if (numberOutputs >= 2) {
+	// 		args.push({ name: "g", type : TFloat });
+	// 		valueArgs.push(g.getVar());
+	// 		opTGlobal = Vec2;
+	// 	}
+	// 	if (numberOutputs >= 3) {
+	// 		args.push({ name: "b", type : TFloat });
+	// 		valueArgs.push(b.getVar());
+	// 		opTGlobal = Vec3;
+	// 	}
+	// 	if (numberOutputs >= 4) {
+	// 		args.push({ name: "a", type : TFloat });
+	// 		valueArgs.push(a.getVar());
+	// 		opTGlobal = Vec4;
+	// 	}
 
-		return {
-			p : null,
-			t : output.type,
-			e : TBinop(OpAssign, {
-				e: TVar(output),
-				p: null,
-				t : output.type
-			},
-			{
-				e: TCall({
-					e: TGlobal(opTGlobal),
-					p: null,
-					t: TFun([
-						{
-							ret: output.type,
-							args: args
-						}
-					])
-				}, valueArgs
-				),
-				p: null,
-				t: output.type
-			})
-		};
-	}
+	// 	return {
+	// 		p : null,
+	// 		t : output.type,
+	// 		e : TBinop(OpAssign, {
+	// 			e: TVar(output),
+	// 			p: null,
+	// 			t : output.type
+	// 		},
+	// 		{
+	// 			e: TCall({
+	// 				e: TGlobal(opTGlobal),
+	// 				p: null,
+	// 				t: TFun([
+	// 					{
+	// 						ret: output.type,
+	// 						args: args
+	// 					}
+	// 				])
+	// 			}, valueArgs
+	// 			),
+	// 			p: null,
+	// 			t: output.type
+	// 		})
+	// 	};
+	// }
 
 }

hrt/shgraph/nodes/CombineAlpha.hx

@@ -13,48 +13,47 @@ class CombineAlpha extends ShaderNode {
 	@input("RGB") var rgb = SType.Vec3;
 	@input("A", true) var a = SType.Float;
 
-	@output("RGBA") var output = SType.Vec4;
-
-	override public function computeOutputs() {
-
-		addOutput("output", TVec(4, VFloat));
-	}
-
-	override public function build(key : String) : TExpr {
-
-		var args = [];
-		var valueArgs = [];
-		var opTGlobal : TGlobal = Vec4;
-		args.push({ name: "rgb", type : TVec(3, VFloat) });
-		valueArgs.push(rgb.getVar());
-		args.push({ name: "a", type : TFloat });
-		valueArgs.push(a.getVar());
-		opTGlobal = Vec4;
-
-		return {
-			p : null,
-			t : output.type,
-			e : TBinop(OpAssign, {
-				e: TVar(output),
-				p: null,
-				t : output.type
-			},
-			{
-				e: TCall({
-					e: TGlobal(opTGlobal),
-					p: null,
-					t: TFun([
-						{
-							ret: output.type,
-							args: args
-						}
-					])
-				}, valueArgs
-				),
-				p: null,
-				t: output.type
-			})
-		};
-	}
+
+	// override public function computeOutputs() {
+
+	// 	addOutput("output", TVec(4, VFloat));
+	// }
+
+	// override public function build(key : String) : TExpr {
+
+	// 	var args = [];
+	// 	var valueArgs = [];
+	// 	var opTGlobal : TGlobal = Vec4;
+	// 	args.push({ name: "rgb", type : TVec(3, VFloat) });
+	// 	valueArgs.push(rgb.getVar());
+	// 	args.push({ name: "a", type : TFloat });
+	// 	valueArgs.push(a.getVar());
+	// 	opTGlobal = Vec4;
+
+	// 	return {
+	// 		p : null,
+	// 		t : output.type,
+	// 		e : TBinop(OpAssign, {
+	// 			e: TVar(output),
+	// 			p: null,
+	// 			t : output.type
+	// 		},
+	// 		{
+	// 			e: TCall({
+	// 				e: TGlobal(opTGlobal),
+	// 				p: null,
+	// 				t: TFun([
+	// 					{
+	// 						ret: output.type,
+	// 						args: args
+	// 					}
+	// 				])
+	// 			}, valueArgs
+	// 			),
+	// 			p: null,
+	// 			t: output.type
+	// 		})
+	// 	};
+	// }
 
 }

hrt/shgraph/nodes/Cond.hx

@@ -10,7 +10,6 @@ class Cond extends ShaderNode {
 	@input("Left") var leftVar = SType.Number;
 	@input("Right") var rightVar = SType.Number;
 
-	@output("Boolean") var output = SType.Bool;
 
 	@prop() var condition : Binop;
 
@@ -25,36 +24,36 @@ class Cond extends ShaderNode {
 		return true;
 	}
 
-	override public function computeOutputs() {
-		if (leftVar != null && !leftVar.isEmpty() && rightVar != null && !rightVar.isEmpty()) {
-			var type = leftVar.getVar(rightVar.getType()).t;
-			switch(type) {
-				case TVec(s, t):
-					removeOutput("output");
-					throw ShaderException.t("Vector of bools is not supported", this.id); //addOutput("output", TVec(s, VBool));
-				case TFloat:
-					addOutput("output", TBool);
-				default:
-					removeOutput("output");
-			}
-		} else
-			removeOutput("output");
-	}
-
-	override public function build(key : String) : TExpr {
-		return {
-				p : null,
-				t : output.type,
-				e : TBinop(OpAssign, {
-						e: TVar(output),
-						p: null,
-						t: output.type
-					}, {e: TBinop(this.condition,
-							leftVar.getVar(rightVar.getType()),
-							rightVar.getVar(leftVar.getType())),
-						p: null, t: output.type })
-			};
-	}
+	// override public function computeOutputs() {
+	// 	if (leftVar != null && !leftVar.isEmpty() && rightVar != null && !rightVar.isEmpty()) {
+	// 		var type = leftVar.getVar(rightVar.getType()).t;
+	// 		switch(type) {
+	// 			case TVec(s, t):
+	// 				removeOutput("output");
+	// 				throw ShaderException.t("Vector of bools is not supported", this.id); //addOutput("output", TVec(s, VBool));
+	// 			case TFloat:
+	// 				addOutput("output", TBool);
+	// 			default:
+	// 				removeOutput("output");
+	// 		}
+	// 	} else
+	// 		removeOutput("output");
+	// }
+
+	// override public function build(key : String) : TExpr {
+	// 	return {
+	// 			p : null,
+	// 			t : output.type,
+	// 			e : TBinop(OpAssign, {
+	// 					e: TVar(output),
+	// 					p: null,
+	// 					t: output.type
+	// 				}, {e: TBinop(this.condition,
+	// 						leftVar.getVar(rightVar.getType()),
+	// 						rightVar.getVar(leftVar.getType())),
+	// 					p: null, t: output.type })
+	// 		};
+	// }
 
 	var availableConditions = [OpEq, OpNotEq, OpGt, OpGte, OpLt, OpLte, OpAnd, OpOr];
 	var conditionStrings 	= ["==", "!=",    ">",  ">=",  "<",  "<=",  "AND", "OR"];

hrt/shgraph/nodes/FloatConst.hx

@@ -9,7 +9,6 @@ using hxsl.Ast;
 @noheader()
 class FloatConst extends ShaderConst {
 
-	@output() var output = SType.Float;
 
 	@prop() var value : Float = 0.;
 
@@ -18,13 +17,13 @@ class FloatConst extends ShaderConst {
 			this.value = value;
 	}
 
-	override public function getOutputTExpr(key : String) : TExpr {
-		return {
-					e: TConst(CFloat(value)),
-					p: null,
-					t: TFloat
-				};
-	}
+	// override public function getOutputTExpr(key : String) : TExpr {
+	// 	return {
+	// 				e: TConst(CFloat(value)),
+	// 				p: null,
+	// 				t: TFloat
+	// 			};
+	// }
 
 	override public function build(key : String) : TExpr {
 		return null;

hrt/shgraph/nodes/IfCondition.hx

@@ -11,7 +11,6 @@ class IfCondition extends ShaderNode {
 	@input("True") var trueVar = SType.Variant;
 	@input("False") var falseVar = SType.Variant;
 
-	@output() var output = SType.Variant;
 
 	override public function checkValidityInput(key : String, type : ShaderType.SType) : Bool {
 
@@ -35,22 +34,22 @@ class IfCondition extends ShaderNode {
 			removeOutput("output");
 	}
 
-	override public function build(key : String) : TExpr {
-		return {
-			p : null,
-			t: output.type,
-			e : TBinop(OpAssign, {
-					e: TVar(output),
-					p: null,
-					t: output.type
-				}, {
-				e: TIf( condition.getVar(),
-						trueVar.getVar(falseVar.getType()),
-						falseVar.getVar(trueVar.getType())),
-				p: null,
-				t: output.type
-			})
-		};
-	}
+	// override public function build(key : String) : TExpr {
+	// 	return {
+	// 		p : null,
+	// 		t: output.type,
+	// 		e : TBinop(OpAssign, {
+	// 				e: TVar(output),
+	// 				p: null,
+	// 				t: output.type
+	// 			}, {
+	// 			e: TIf( condition.getVar(),
+	// 					trueVar.getVar(falseVar.getType()),
+	// 					falseVar.getVar(trueVar.getType())),
+	// 			p: null,
+	// 			t: output.type
+	// 		})
+	// 	};
+	// }
 
 }

hrt/shgraph/nodes/Sampler.hx

@@ -10,11 +10,7 @@ class Sampler extends ShaderNode {
 	@input("Texture") var texture = SType.Sampler;
 	@input("UV") var uv = SType.Vec2;
 
-	@output("RGBA") var rgba = SType.Vec4;
-	@output("R") var r = SType.Float;
-	@output("G") var g = SType.Float;
-	@output("B") var b = SType.Float;
-	@output("A") var a = SType.Float;
+
 
 	var components = [X, Y, Z, W];
 	var componentsString = ["r", "g", "b", "a"];
@@ -27,72 +23,72 @@ class Sampler extends ShaderNode {
 		addOutput("a", TFloat);
 	}
 
-	override public function build(key : String) : TExpr {
-		if (key == "rgba") {
-			var args = [];
-			var varArgs = [];
+	// override public function build(key : String) : TExpr {
+	// 	if (key == "rgba") {
+	// 		var args = [];
+	// 		var varArgs = [];
 
-			for (k in getInputInfoKeys()) {
-				args.push({ name: k, type: getInput(k).getType() });
-				var wantedType = ShaderType.getType(getInputInfo(k).type);
-				varArgs.push(getInput(k).getVar((wantedType != null) ? wantedType : null));
-			}
+	// 		for (k in getInputInfoKeys()) {
+	// 			args.push({ name: k, type: getInput(k).getType() });
+	// 			var wantedType = ShaderType.getType(getInputInfo(k).type);
+	// 			varArgs.push(getInput(k).getVar((wantedType != null) ? wantedType : null));
+	// 		}
 
-			return {
-						p : null,
-						t : rgba.type,
-						e : TBinop(OpAssign, {
-							e: TVar(rgba),
-							p: null,
-							t: rgba.type
-						}, {
-							e: TCall({
-								e: TGlobal(Texture),
-								p: null,
-								t: TFun([
-									{
-										ret: rgba.type,
-										args: args
-									}
-								])
-							}, varArgs),
-							p: null,
-							t: rgba.type
-						})
-					};
-		} else {
-			var arrayExpr = [];
-			if (!outputCompiled.get("rgba")) {
-				arrayExpr.push({ e : TVarDecl(rgba), t : rgba.type, p : null });
-				arrayExpr.push(build("rgba"));
-				outputCompiled.set("rgba", true);
-			}
-			var compIdx = componentsString.indexOf(key);
-			arrayExpr.push({ e: TBinop(OpAssign, {
-						e: TVar(getOutput(key)),
-						p: null,
-						t: getOutput(key).type
-					}, {e: TSwiz({
-							e: TVar(rgba),
-							p: null,
-							t: rgba.type
-						},
-						[components[compIdx]]),
-						p: null,
-						t: getOutput(key).type }),
-					p: null,
-					t: getOutput(key).type
-				});
-			if (arrayExpr.length > 1) {
-				return {
-					p : null,
-					t : TVoid,
-					e : TBlock(arrayExpr)
-				};
-			} else {
-				return arrayExpr[0];
-			}
-		}
-	}
+	// 		return {
+	// 					p : null,
+	// 					t : rgba.type,
+	// 					e : TBinop(OpAssign, {
+	// 						e: TVar(rgba),
+	// 						p: null,
+	// 						t: rgba.type
+	// 					}, {
+	// 						e: TCall({
+	// 							e: TGlobal(Texture),
+	// 							p: null,
+	// 							t: TFun([
+	// 								{
+	// 									ret: rgba.type,
+	// 									args: args
+	// 								}
+	// 							])
+	// 						}, varArgs),
+	// 						p: null,
+	// 						t: rgba.type
+	// 					})
+	// 				};
+	// 	} else {
+	// 		var arrayExpr = [];
+	// 		if (!outputCompiled.get("rgba")) {
+	// 			arrayExpr.push({ e : TVarDecl(rgba), t : rgba.type, p : null });
+	// 			arrayExpr.push(build("rgba"));
+	// 			outputCompiled.set("rgba", true);
+	// 		}
+	// 		var compIdx = componentsString.indexOf(key);
+	// 		arrayExpr.push({ e: TBinop(OpAssign, {
+	// 					e: TVar(getOutput(key)),
+	// 					p: null,
+	// 					t: getOutput(key).type
+	// 				}, {e: TSwiz({
+	// 						e: TVar(rgba),
+	// 						p: null,
+	// 						t: rgba.type
+	// 					},
+	// 					[components[compIdx]]),
+	// 					p: null,
+	// 					t: getOutput(key).type }),
+	// 				p: null,
+	// 				t: getOutput(key).type
+	// 			});
+	// 		if (arrayExpr.length > 1) {
+	// 			return {
+	// 				p : null,
+	// 				t : TVoid,
+	// 				e : TBlock(arrayExpr)
+	// 			};
+	// 		} else {
+	// 			return arrayExpr[0];
+	// 		}
+	// 	}
+	// }
 
 }

hrt/shgraph/nodes/Split.hx

@@ -9,10 +9,6 @@ class Split extends ShaderNode {
 
 	@input("RGBA") var input = SType.Vec4;
 
-	@output("R") var r = SType.Float;
-	@output("G") var g = SType.Float;
-	@output("B") var b = SType.Float;
-	@output("A") var a = SType.Float;
 
 	var components = [X, Y, Z, W];
 	var componentsString = ["r", "g", "b", "a"];
@@ -24,16 +20,16 @@ class Split extends ShaderNode {
 		addOutput("a", TFloat);
 	}
 
-	override public function build(key : String) : TExpr {
-		var compIdx = componentsString.indexOf(key);
-		return { e: TBinop(OpAssign, {
-					e: TVar(getOutput(key)),
-					p: null,
-					t: getOutput(key).type
-				}, {e: TSwiz(input.getVar(TVec(4, VFloat)), [components[compIdx]]), p: null, t: getOutput(key).type }),
-				p: null,
-				t: getOutput(key).type
-			};
-	}
+	// override public function build(key : String) : TExpr {
+	// 	var compIdx = componentsString.indexOf(key);
+	// 	return { e: TBinop(OpAssign, {
+	// 				e: TVar(getOutput(key)),
+	// 				p: null,
+	// 				t: getOutput(key).type
+	// 			}, {e: TSwiz(input.getVar(TVec(4, VFloat)), [components[compIdx]]), p: null, t: getOutput(key).type }),
+	// 			p: null,
+	// 			t: getOutput(key).type
+	// 		};
+	// }
 
 }

hrt/shgraph/nodes/StripAlpha.hx

@@ -9,41 +9,40 @@ class StripAlpha extends ShaderNode {
 
 	@input("RGBA") var input = SType.Vec4;
 
-	@output("RGB") var rgb = SType.Vec3;
-	@output("A") var a = SType.Float;
+
 
 	override public function computeOutputs() {
 		addOutput("rgb", TVec(3, VFloat));
 		addOutput("a", TFloat);
 	}
 
-	override public function build(key : String) : TExpr {
-        if( key == "a" ) {
-            return { e: TBinop(OpAssign, {
-                    e: TVar(getOutput(key)),
-                    p: null,
-                    t: getOutput(key).type
-                }, {
-                    e: TSwiz(input.getVar(TVec(4, VFloat)), [W]),
-                    p: null,
-                    t: getOutput(key).type
-                }),
-                p: null,
-                t: getOutput(key).type
-            };
-	    }
-        return { e: TBinop(OpAssign, {
-                e: TVar(getOutput(key)),
-                p: null,
-                t: getOutput(key).type
-            }, {
-                e: TSwiz(input.getVar(TVec(4, VFloat)), [X, Y, Z]),
-                p: null,
-                t: getOutput(key).type
-            }),
-            p: null,
-            t: getOutput(key).type
-        };
-    }
+	// override public function build(key : String) : TExpr {
+    //     if( key == "a" ) {
+    //         return { e: TBinop(OpAssign, {
+    //                 e: TVar(getOutput(key)),
+    //                 p: null,
+    //                 t: getOutput(key).type
+    //             }, {
+    //                 e: TSwiz(input.getVar(TVec(4, VFloat)), [W]),
+    //                 p: null,
+    //                 t: getOutput(key).type
+    //             }),
+    //             p: null,
+    //             t: getOutput(key).type
+    //         };
+	//     }
+    //     return { e: TBinop(OpAssign, {
+    //             e: TVar(getOutput(key)),
+    //             p: null,
+    //             t: getOutput(key).type
+    //         }, {
+    //             e: TSwiz(input.getVar(TVec(4, VFloat)), [X, Y, Z]),
+    //             p: null,
+    //             t: getOutput(key).type
+    //         }),
+    //         p: null,
+    //         t: getOutput(key).type
+    //     };
+    // }
 
 }

hrt/shgraph/nodes/SubGraph.hx

@@ -137,13 +137,13 @@ class SubGraph extends ShaderNode {
 		return inputInfoKeys;
 	}
 
-	override public function getOutputInfo(key : String) : ShaderNode.OutputInfo {
-		return outputsInfo.get(key);
-	}
+	// override public function getOutputInfo(key : String) : ShaderNode.OutputInfo {
+	// 	return outputsInfo.get(key);
+	// }
 
-	override public function getOutputInfoKeys() : Array<String> {
-		return outputInfoKeys;
-	}
+	// override public function getOutputInfoKeys() : Array<String> {
+	// 	return outputInfoKeys;
+	// }
 
 	override public function loadProperties(props : Dynamic) {
 		this.pathShaderGraph = Reflect.field(props, "pathShaderGraph");

hrt/shgraph/nodes/UVScroll.hx

@@ -11,7 +11,6 @@ class UVScroll extends ShaderNode {
 	@input("USpeed", true) var uSpeed = SType.Number;
 	@input("VSpeed", true) var vSpeed = SType.Number;
 
-	@output("") var output = SType.Vec2;
 
 	var operation : Binop;
 
@@ -26,84 +25,84 @@ class UVScroll extends ShaderNode {
 			removeOutput("output");
 	}
 
-	override public function build(key : String) : TExpr {
+	// override public function build(key : String) : TExpr {
 
-		var globalTime : TVar = @:privateAccess ShaderGlobalInput.globalInputs.filter(i -> i.name.indexOf("time") != -1)[0];
-		var timeExpr : TExpr = { e: TVar(globalTime), p: null, t: globalTime.type };
+	// 	var globalTime : TVar = @:privateAccess ShaderGlobalInput.globalInputs.filter(i -> i.name.indexOf("time") != -1)[0];
+	// 	var timeExpr : TExpr = { e: TVar(globalTime), p: null, t: globalTime.type };
 
-		return { e: TBinop(OpAssign, {
-						e: TVar(output),
-						p: null,
-						t: output.type
-					}, {
-						// uv % 1 (wrap)
-						e: TCall({
-							e: TGlobal(Mod),
-							p: null,
-							t: TFun([
-								{
-									ret: output.type,
-									args: [
-										{ name: "uv", type : output.type }, 
-										{ name: "mod", type : TFloat }
-									]
-								}
-							])
-						}, [
-							{
-								// uv + speed * time
-								e: TBinop(OpAdd,
-									uv.getVar(),
-									{
-										e: TCall({
-											e: TGlobal(Vec2),
-											p: null,
-											t: TFun([
-												{
-													ret: output.type,
-													args: [
-														{ name: "u", type : TFloat }, 
-														{ name: "v", type : TFloat }
-													]
-												}
-											])
-										}, [
-											// uSpeed * time
-											{
-												e: TBinop(OpMult,
-													uSpeed.getVar(),
-													timeExpr),
-												p: null,
-												t: uSpeed.getType()
-											},
-											// vSpeed * time
-											{
-												e: TBinop(OpMult,
-													vSpeed.getVar(),
-													timeExpr),
-												p: null,
-												t: vSpeed.getType()
-											}
-										]
-										),
-										p: null,
-										t: output.type
-									}),
-								p: null,
-								t: uSpeed.getType()
-							},
-							{
-								e: TConst(CFloat(1)),
-								p: null,
-								t: TFloat
-							}
-						]),
-						p: null,
-						t: output.type
-					}),
-					p: null,
-					t: output.type
-				};
-	}
+	// 	return { e: TBinop(OpAssign, {
+	// 					e: TVar(output),
+	// 					p: null,
+	// 					t: output.type
+	// 				}, {
+	// 					// uv % 1 (wrap)
+	// 					e: TCall({
+	// 						e: TGlobal(Mod),
+	// 						p: null,
+	// 						t: TFun([
+	// 							{
+	// 								ret: output.type,
+	// 								args: [
+	// 									{ name: "uv", type : output.type },
+	// 									{ name: "mod", type : TFloat }
+	// 								]
+	// 							}
+	// 						])
+	// 					}, [
+	// 						{
+	// 							// uv + speed * time
+	// 							e: TBinop(OpAdd,
+	// 								uv.getVar(),
+	// 								{
+	// 									e: TCall({
+	// 										e: TGlobal(Vec2),
+	// 										p: null,
+	// 										t: TFun([
+	// 											{
+	// 												ret: output.type,
+	// 												args: [
+	// 													{ name: "u", type : TFloat },
+	// 													{ name: "v", type : TFloat }
+	// 												]
+	// 											}
+	// 										])
+	// 									}, [
+	// 										// uSpeed * time
+	// 										{
+	// 											e: TBinop(OpMult,
+	// 												uSpeed.getVar(),
+	// 												timeExpr),
+	// 											p: null,
+	// 											t: uSpeed.getType()
+	// 										},
+	// 										// vSpeed * time
+	// 										{
+	// 											e: TBinop(OpMult,
+	// 												vSpeed.getVar(),
+	// 												timeExpr),
+	// 											p: null,
+	// 											t: vSpeed.getType()
+	// 										}
+	// 									]
+	// 									),
+	// 									p: null,
+	// 									t: output.type
+	// 								}),
+	// 							p: null,
+	// 							t: uSpeed.getType()
+	// 						},
+	// 						{
+	// 							e: TConst(CFloat(1)),
+	// 							p: null,
+	// 							t: TFloat
+	// 						}
+	// 					]),
+	// 					p: null,
+	// 					t: output.type
+	// 				}),
+	// 				p: null,
+	// 				t: output.type
+	// 			};
+	// }
 
 }