Added multiple shadergraph domains

hide/view/Graph.hx

@@ -56,6 +56,9 @@ class Graph extends FileView {
 	// used for deleting
 	var currentEdge : Edge;
 
+	// aaaaaa
+	var domain : hrt.shgraph.ShaderGraph.Domain;
+
 	override function onDisplay() {
 		element.html('
 			<div class="flex vertical" >
@@ -262,7 +265,7 @@ class Graph extends FileView {
 		});
 		listOfBoxes.push(box);
 
-		for (inputName => inputVar in box.getInstance().getInputs2()) {
+		for (inputName => inputVar in box.getInstance().getInputs2(domain)) {
 			var defaultValue = null;
 			/*if (inputInfo.hasProperty) {
 				defaultValue = Reflect.field(box.getInstance(), 'prop_${inputName => inputVar}');
@@ -299,7 +302,7 @@ class Graph extends FileView {
 				setAvailableOutputNodes(box, grNode.find(".node").attr("field"));
 			});
 		}
-		for (outputName => outputVar in box.getInstance().getOutputs2()) {
+		for (outputName => outputVar in box.getInstance().getOutputs2(domain)) {
 			var grNode = box.addOutput(editor, outputName, outputVar.type);
 			grNode.find(".node").attr("field", outputName);
 			grNode.on("mousedown", function(e) {
@@ -376,7 +379,7 @@ class Graph extends FileView {
 
 	// TODO(ces) : nuke SType from orbit
 	function setAvailableInputNodes(boxOutput : Box, field : String) {
-		var type = boxOutput.getInstance().getOutputs2()[field].type;
+		var type = boxOutput.getInstance().getOutputs2(domain)[field].type;
 		var sType : SType;
 
 		for (box in listOfBoxes) {
@@ -392,7 +395,7 @@ class Graph extends FileView {
 		for (box in listOfBoxes) {
 			for (output in box.outputs) {
 				var outputField = output.attr("field");
-				var type = box.getInstance().getOutputs2()[outputField].type;
+				var type = box.getInstance().getOutputs2(domain)[outputField].type;
 				var sType = ShaderType.getSType(type);
 				if (boxInput.getInstance().checkTypeAndCompatibilyInput(field, type)) {
 					output.addClass("nodeMatch");

hide/view/shadereditor/ShaderEditor.hx

@@ -30,6 +30,8 @@ typedef SavedClipboard = {
 class ShaderEditor extends hide.view.Graph {
 
 	var parametersList : JQuery;
+	var domainSelection : JQuery;
+
 	var draggedParamId : Int;
 
 	var addMenu : JQuery;
@@ -45,6 +47,7 @@ class ShaderEditor extends hide.view.Graph {
 	var obj : h3d.scene.Object;
 	var prefabObj : hrt.prefab.Prefab;
 	var shaderGraph : ShaderGraph;
+	var currentGraph : Graph;
 
 	var lastSnapshot : haxe.Json;
 
@@ -60,6 +63,8 @@ class ShaderEditor extends hide.view.Graph {
 	override function onDisplay() {
 		super.onDisplay();
 		shaderGraph = new ShaderGraph(state.path);
+		domain = Fragment;
+
 		addMenu = null;
 
 		element.find("#rightPanel").html('
@@ -71,7 +76,9 @@ class ShaderEditor extends hide.view.Graph {
 							</div>
 							<div class="options-block hide-block">
 								<input id="createParameter" type="button" value="Add parameter" />
+								<select id="domainSelection"></select>
 								<input id="launchCompileShader" type="button" value="Compile shader" />
+
 								<input id="saveShader" type="button" value="Save" />
 								<div>
 									<input id="changeModel" type="button" value="Change Model" />
@@ -91,7 +98,7 @@ class ShaderEditor extends hide.view.Graph {
 						</div>)');
 		parent.on("drop", function(e) {
 			var posCursor = new Point(lX(ide.mouseX - 25), lY(ide.mouseY - 10));
-			var node = Std.downcast(shaderGraph.addNode(posCursor.x, posCursor.y, ShaderParam), ShaderParam);
+			var node = Std.downcast(currentGraph.addNode(posCursor.x, posCursor.y, ShaderParam), ShaderParam);
 			node.parameterId = draggedParamId;
 			var paramShader = shaderGraph.getParameter(draggedParamId);
 			node.variable = paramShader.variable;
@@ -113,6 +120,19 @@ class ShaderEditor extends hide.view.Graph {
 			lightsAreOn == true;
 		}
 
+		domainSelection = element.find("#domainSelection");
+		for (domain in haxe.EnumTools.getConstructors(hrt.shgraph.ShaderGraph.Domain)) {
+			domainSelection.append('<option value="$domain">$domain</option>');
+		};
+
+		domainSelection.val(haxe.EnumTools.EnumValueTools.getName(domain));
+
+		domainSelection.on("change", (e) -> {
+			var domainString : String = domainSelection.val();
+			var domain = haxe.EnumTools.createByName(hrt.shgraph.ShaderGraph.Domain, domainString);
+			setDomain(domain);
+		});
+
 		var def = new hrt.prefab.Library();
 		new hrt.prefab.RenderProps(def).name = "renderer";
 		defaultLight = new hrt.prefab.Light(def);
@@ -367,7 +387,7 @@ class ShaderEditor extends hide.view.Graph {
 	}
 
 	override function save() {
-		var content = shaderGraph.save();
+		var content = shaderGraph.saveToText();
 		currentSign = ide.makeSignature(content);
 		sys.io.File.saveContent(getPath(), content);
 		super.save();
@@ -459,10 +479,17 @@ class ShaderEditor extends hide.view.Graph {
 		saveDisplayState("useDefaultLights", lightsAreOn);
 	}
 
+	function setDomain(domain: hrt.shgraph.ShaderGraph.Domain) {
+		this.domain = domain;
+		refreshShaderGraph(true);
+	}
+
 	function refreshShaderGraph(readyEvent : Bool = true) {
 		listOfBoxes = [];
 		listOfEdges = [];
 
+		currentGraph = shaderGraph.getGraph(domain);
+
 		var saveToggleParams = new Map<Int, Bool>();
 		for (pElt in parametersList.find(".parameter").elements()) {
 			saveToggleParams.set(Std.parseInt(pElt.get()[0].id.split("_")[1]), pElt.find(".content").css("display") != "none");
@@ -472,7 +499,7 @@ class ShaderEditor extends hide.view.Graph {
 
 		updateMatrix();
 
-		for (node in shaderGraph.getNodes()) {
+		for (node in currentGraph.getNodes()) {
 			var shaderPreview = Std.downcast(node.instance, hrt.shgraph.nodes.Preview);
 			if (shaderPreview != null) {
 				shaderPreview.config = config;
@@ -902,7 +929,7 @@ class ShaderEditor extends hide.view.Graph {
 			currentShader = newShader;
 			currentShaderDef = shaderGraphDef;//{shader: shaderGraphDef, inits:[]};
 
-			for (node in shaderGraph.getNodes()) {
+			for (node in currentGraph.getNodes()) {
 				var preview = Std.downcast(node.instance, hrt.shgraph.nodes.Preview);
 				if (preview != null) {
 					preview.config = config;
@@ -1015,7 +1042,7 @@ class ShaderEditor extends hide.view.Graph {
 	function addNode(p : Point, nodeClass : Class<ShaderNode>) {
 		beforeChange();
 
-		var node = shaderGraph.addNode(p.x, p.y, nodeClass);
+		var node = currentGraph.addNode(p.x, p.y, nodeClass);
 		afterChange();
 
 		initSpecifics(node);
@@ -1056,7 +1083,7 @@ class ShaderEditor extends hide.view.Graph {
 		}
 		try {
 			beforeChange();
-			if (shaderGraph.addEdge({ outputNodeId: startLinkBox.getId(), nameOutput: startLinkNode.attr("field"), inputNodeId: endLinkBox.getId(), nameInput: endLinkNode.attr("field") })) {
+			if (currentGraph.addEdge({ outputNodeId: startLinkBox.getId(), nameOutput: startLinkNode.attr("field"), inputNodeId: endLinkBox.getId(), nameInput: endLinkNode.attr("field") })) {
 				afterChange();
 				createEdgeInEditorGraph(newEdge);
 				currentLink.removeClass("draft");
@@ -1328,11 +1355,11 @@ class ShaderEditor extends hide.view.Graph {
 	}
 
 	function beforeChange() {
-		lastSnapshot = haxe.Json.parse(shaderGraph.save());
+		lastSnapshot = haxe.Json.parse(shaderGraph.saveToText());
 	}
 
 	function afterChange() {
-		var newVal = haxe.Json.parse(shaderGraph.save());
+		var newVal = haxe.Json.parse(shaderGraph.saveToText());
 		var oldVal = lastSnapshot;
 		undo.change(Custom(function(undo) {
 			if (undo)
@@ -1344,7 +1371,7 @@ class ShaderEditor extends hide.view.Graph {
 	}
 
 	function removeShaderGraphEdge(edge : Graph.Edge) {
-		shaderGraph.removeEdge(edge.to.getId(), edge.nodeTo.attr("field"));
+		currentGraph.removeEdge(edge.to.getId(), edge.nodeTo.attr("field"));
 	}
 
 	function removeEdgeSubGraphUpdate(edge : Graph.Edge) {
@@ -1453,14 +1480,14 @@ class ShaderEditor extends hide.view.Graph {
 				instancedBoxes.push(null);
 				continue;
 			}
-			var node = shaderGraph.addNode(offset.x + n.pos.x, offset.y + n.pos.y, n.nodeType);
+			var node = currentGraph.addNode(offset.x + n.pos.x, offset.y + n.pos.y, n.nodeType);
 			node.loadProperties(n.props);
 			initSpecifics(node);
 			var shaderParam = Std.downcast(node, ShaderParam);
 			if( shaderParam != null ) {
-				var paramShader = shaderGraph.getParameter(shaderParam.parameterId);
+				var paramShader = currentGraph.getParameter(shaderParam.parameterId);
 				if( paramShader == null ) {
-					shaderGraph.removeNode(node.id);
+					currentGraph.removeNode(node.id);
 					instancedBoxes.push(null);
 					continue;
 				}
@@ -1481,7 +1508,7 @@ class ShaderEditor extends hide.view.Graph {
 				inputNodeId: instancedBoxes[edge.toIdx].getId(),
 				nameInput: edge.toName,
 			}
-			if( !shaderGraph.addEdge(toCreate) ) {
+			if( !currentGraph.addEdge(toCreate) ) {
 				error("A pasted edge creates a cycle");
 			}
 		}
@@ -1550,7 +1577,7 @@ class ShaderEditor extends hide.view.Graph {
 				if (!isSubShader) removeEdgeSubGraphUpdate(edge);
 			}
 		}
-		shaderGraph.removeNode(box.getId());
+		currentGraph.removeNode(box.getId());
 		if( trackChanges )
 			afterChange();
 		box.dispose();
@@ -1573,7 +1600,7 @@ class ShaderEditor extends hide.view.Graph {
 		/*if (previewBox != null){
 			previewBox.onMove(gX(box.getX()), gY(box.getY()), transformMatrix[0]);
 		}*/
-		shaderGraph.setPosition(box.getId(), box.getX(), box.getY());
+		currentGraph.setPosition(box.getId(), box.getX(), box.getY());
 	}
 
 	override function updateMatrix() {

hrt/shgraph/ShaderGlobalInput.hx

@@ -16,7 +16,7 @@ class ShaderGlobalInput extends ShaderNode {
 										{ parent: null, id: 0, kind: Global, name: "global.modelView", type: TMat4 },
 										{ parent: null, id: 0, kind: Global, name: "global.modelViewInverse", type: TMat4 } ];
 
-	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override function getShaderDef(domain: ShaderGraph.Domain):hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
 		var inVar : TVar = globalInputs[variableIdx];

hrt/shgraph/ShaderGraph.hx

@@ -48,17 +48,16 @@ typedef Parameter = {
 	index : Int
 };
 
+enum Domain {
+	Vertex;
+	Fragment;
+}
+
 class ShaderGraph {
 
-	var allParameters = [];
-	var allParamDefaultValue = [];
-	var current_node_id = 0;
-	var current_param_id = 0;
 	var filepath : String;
-	var nodes : Map<Int, Node> = [];
+	var graphs : Array<Graph>;
 
-	public var parametersAvailable : Map<Int, Parameter> = [];
-	public var parametersKeys : Array<Int> = [];
 
 	public function new(filepath : String) {
 		if (filepath == null) return;
@@ -80,21 +79,151 @@ class ShaderGraph {
 		}
 
 		load(json);
-
 	}
 
-	public function load(json : Dynamic) {
-		nodes = [];
+	public function load(json : Dynamic) : Void {
+
+		graphs = [];
+
 		parametersAvailable = [];
 		parametersKeys = [];
-		generate(Reflect.getProperty(json, "nodes"), Reflect.getProperty(json, "edges"), Reflect.getProperty(json, "parameters"));
+
+		loadParameters(json.parameters ?? []);
+		for (domain in haxe.EnumTools.getConstructors(Domain)) {
+			var graph = new Graph(this, haxe.EnumTools.createByName(Domain, domain));
+			var graphJson = Reflect.getProperty(json, domain);
+			if (graphJson != null) {
+				graph.load(graphJson);
+			}
+
+			graphs.push(graph);
+		}
 	}
-	public function checkParameterOrder() {
-		parametersKeys.sort((x,y) -> Reflect.compare(parametersAvailable.get(x).index, parametersAvailable.get(y).index));
+
+	public function saveToDynamic() : Dynamic {
+		var json : Dynamic = {};
+
+		json.parameters = [
+			for (p in parametersAvailable) { id : p.id, name : p.name, type : [p.type.getName(), p.type.getParameters().toString()], defaultValue : p.defaultValue, index : p.index }
+		];
+
+		for (graph in graphs) {
+			var serName = EnumValueTools.getName(graph.domain);
+			Reflect.setField(json, serName, graph.saveToDynamic());
+		}
+
+		return json;
+	}
+
+	public function saveToText() : String {
+		return haxe.Json.stringify(saveToDynamic(), "\t");
+	}
+
+	public function compile2(?specificOutput: ShaderNode) : hrt.prefab.ContextShared.ShaderDef {
+		var start = haxe.Timer.stamp();
+
+		var gens : Array<ShaderNodeDef> = [];
+		var inits : Array<{variable: TVar, value: Dynamic}>= [];
+
+		var shaderData : ShaderData = {
+			name: "",
+			vars: [],
+			funs: [],
+		};
+
+
+		for (i => graph in graphs) {
+			var gen = graph.generate2(specificOutput);
+			gens.push(gen);
+
+			shaderData.vars.append(gen.externVars);
+			for (v in gen.inVars)
+				shaderData.vars.pushUnique(v.v);
+			for (v in gen.outVars)
+				shaderData.vars.pushUnique(v.v);
+
+			var functionName : String = EnumValueTools.getName(graph.domain).toLowerCase();
+
+			shaderData.funs.push({
+				ret : TVoid, kind : Fragment,
+				ref : {
+					name : functionName,
+					id : i,
+					kind : Function,
+					type : TFun([{ ret : TVoid, args : [] }])
+				},
+				expr : gen.expr,
+				args : []
+			});
+
+			for (init in gen.inits) {
+				inits.pushUnique(init);
+			}
+		}
+
+		var shared = new SharedShader("");
+		@:privateAccess shared.data = shaderData;
+		@:privateAccess shared.initialize();
+
+		var time = haxe.Timer.stamp() - start;
+		trace("Shader compile2 in " + time * 1000 + " ms");
+
+		return {shader : shared, inits: inits};
+	}
+
+	public function makeInstance(ctx: hrt.prefab.ContextShared) : hxsl.DynamicShader {
+		var def = compile2();
+		var s = new hxsl.DynamicShader(def.shader);
+		for (init in def.inits)
+			setParamValue(ctx, s, init.variable, init.value);
+		return s;
+	}
+
+	static function setParamValue(ctx: hrt.prefab.ContextShared, shader : hxsl.DynamicShader, variable : hxsl.Ast.TVar, value : Dynamic) {
+		try {
+			switch (variable.type) {
+				case TSampler2D:
+					var t = ctx.loadTexture(value);
+					t.wrap = Repeat;
+					shader.setParamValue(variable, t);
+				case TVec(size, _):
+					shader.setParamValue(variable, h3d.Vector.fromArray(value));
+				default:
+					shader.setParamValue(variable, value);
+			}
+		} catch (e : Dynamic) {
+			// The parameter is not used
+		}
 	}
 
-	public function generate(nodes : Array<Node>, edges : Array<Edge>, parameters : Array<Parameter>) {
+	var allParameters = [];
+	var current_param_id = 0;
+	public var parametersAvailable : Map<Int, Parameter> = [];
+	public var parametersKeys : Array<Int> = [];
 
+	function generateParameter(name : String, type : Type) : TVar {
+		return {
+				parent: null,
+				id: 0,
+				kind:Param,
+				name: name,
+				type: type
+			};
+	}
+
+	public function getParameter(id : Int) {
+		return parametersAvailable.get(id);
+	}
+
+	public function addParameter(type : Type) {
+		var name = "Param_" + current_param_id;
+		parametersAvailable.set(current_param_id, {id: current_param_id, name : name, type : type, defaultValue : null, variable : generateParameter(name, type), index : parametersKeys.length});
+		parametersKeys.push(current_param_id);
+		current_param_id++;
+		return current_param_id-1;
+	}
+
+	function loadParameters(parameters: Array<Dynamic>) {
 		for (p in parameters) {
 			var typeString : Array<Dynamic> = Reflect.field(p, "type");
 			if (Std.isOfType(typeString, Array)) {
@@ -111,6 +240,84 @@ class ShaderGraph {
 			current_param_id = p.id + 1;
 		}
 		checkParameterOrder();
+	}
+
+	public function checkParameterOrder() {
+		parametersKeys.sort((x,y) -> Reflect.compare(parametersAvailable.get(x).index, parametersAvailable.get(y).index));
+	}
+
+
+	public function setParameterTitle(id : Int, newName : String) {
+		var p = parametersAvailable.get(id);
+		if (p != null) {
+			if (newName != null) {
+				for (p in parametersAvailable) {
+					if (p.name == newName) {
+						return false;
+					}
+				}
+				p.name = newName;
+				p.variable = generateParameter(newName, p.type);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public function setParameterDefaultValue(id : Int, newDefaultValue : Dynamic) : Bool {
+		var p = parametersAvailable.get(id);
+		if (p != null) {
+			if (newDefaultValue != null) {
+				p.defaultValue = newDefaultValue;
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public function removeParameter(id : Int) {
+		parametersAvailable.remove(id);
+		parametersKeys.remove(id);
+		checkParameterIndex();
+	}
+
+	public function checkParameterIndex() {
+		for (k in parametersKeys) {
+			var oldParam = parametersAvailable.get(k);
+			oldParam.index = parametersKeys.indexOf(k);
+			parametersAvailable.set(k, oldParam);
+		}
+	}
+
+	public function getGraph(domain: Domain) {
+		return graphs[domain.getIndex()];
+	}
+}
+
+class Graph {
+
+	var allParamDefaultValue = [];
+	var current_node_id = 0;
+	var nodes : Map<Int, Node> = [];
+
+	public var parent : ShaderGraph = null;
+
+	public var domain : Domain = Fragment;
+
+
+	public function new(parent: ShaderGraph, domain: Domain) {
+		this.parent = parent;
+		this.domain = domain;
+	}
+
+	public function load(json : Dynamic) {
+		nodes = [];
+		generate(Reflect.getProperty(json, "nodes"), Reflect.getProperty(json, "edges"));
+	}
+
+	public function generate(nodes : Array<Node>, edges : Array<Edge>) {
+
+
 
 		for (n in nodes) {
 			n.outputs = [];
@@ -148,15 +355,15 @@ class ShaderGraph {
 		var node = this.nodes.get(edge.inputNodeId);
 		var output = this.nodes.get(edge.outputNodeId);
 
-		var inputs = node.instance.getInputs2();
-		var outputs = output.instance.getOutputs2();
+		var inputs = node.instance.getInputs2(domain);
+		var outputs = output.instance.getOutputs2(domain);
 
 		var inputName = edge.nameInput;
 		var outputName = edge.nameOutput;
 
 		// Patch I/O if name have changed
 		if (!outputs.exists(outputName)) {
-			var def = output.instance.getShaderDef();
+			var def = output.instance.getShaderDef(domain);
 			if(edge.outputId != null && def.outVars.length > edge.outputId) {
 				outputName = def.outVars[edge.outputId].v.name;
 			}
@@ -166,7 +373,7 @@ class ShaderGraph {
 		}
 
 		if (!inputs.exists(inputName)) {
-			var def = node.instance.getShaderDef();
+			var def = node.instance.getShaderDef(domain);
 			if (edge.inputId != null && def.inVars.length > edge.inputId) {
 				inputName = def.inVars[edge.inputId].v.name;
 			}
@@ -231,15 +438,7 @@ class ShaderGraph {
 		return this.nodes.get(id);
 	}
 
-	function generateParameter(name : String, type : Type) : TVar {
-		return {
-				parent: null,
-				id: 0,
-				kind:Param,
-				name: name,
-				type: type
-			};
-	}
+
 
 	public function generate2(?specificOutput: ShaderNode) : ShaderNodeDef {
 
@@ -258,7 +457,7 @@ class ShaderGraph {
 			if (!nodeOutputs.exists(node)) {
 				var outputs : Map<String, TVar> = [];
 
-				var def = node.instance.getShaderDef();
+				var def = node.instance.getShaderDef(domain);
 				for (output in def.outVars) {
 					if (output.internal)
 						continue;
@@ -408,7 +607,7 @@ class ShaderGraph {
 			var outputs = getOutputs(currentNode);
 
 			{
-				var def = currentNode.instance.getShaderDef();
+				var def = currentNode.instance.getShaderDef(domain);
 				var expr = def.expr;
 
 				var outputDecls : Array<TVar> = [];
@@ -489,75 +688,8 @@ class ShaderGraph {
 		};
 	}
 
-	public function compile2(?specificOutput: ShaderNode) : hrt.prefab.ContextShared.ShaderDef {
-		var start = haxe.Timer.stamp();
-
-		var gen = generate2(specificOutput);
-
-		var shaderData : ShaderData = {
-			name: "",
-			vars: [],
-			funs: [],
-		};
-
-		shaderData.vars.append(gen.externVars);
-		for (v in gen.inVars)
-			shaderData.vars.push(v.v);
-		for (v in gen.outVars)
-			shaderData.vars.push(v.v);
-
-
-
-		shaderData.funs.push({
-			ret : TVoid, kind : Fragment,
-			ref : {
-				name : "fragment",
-				id : 0,
-				kind : Function,
-				type : TFun([{ ret : TVoid, args : [] }])
-			},
-			expr : gen.expr,
-			args : []
-		});
-
-
-		var shared = new SharedShader("");
-		@:privateAccess shared.data = shaderData;
-		@:privateAccess shared.initialize();
-
-		var time = haxe.Timer.stamp() - start;
-		trace("Shader compile2 in " + time * 1000 + " ms");
-
-		return {shader : shared, inits: gen.inits};
-	}
-
 	public function getParameter(id : Int) {
-		return parametersAvailable.get(id);
-	}
-
-	public function makeInstance(ctx: hrt.prefab.ContextShared) : hxsl.DynamicShader {
-		var def = compile2();
-		var s = new hxsl.DynamicShader(def.shader);
-		for (init in def.inits)
-			setParamValue(ctx, s, init.variable, init.value);
-		return s;
-	}
-
-	static function setParamValue(ctx: hrt.prefab.ContextShared, shader : hxsl.DynamicShader, variable : hxsl.Ast.TVar, value : Dynamic) {
-		try {
-			switch (variable.type) {
-				case TSampler2D:
-					var t = ctx.loadTexture(value);
-					t.wrap = Repeat;
-					shader.setParamValue(variable, t);
-				case TVec(size, _):
-					shader.setParamValue(variable, h3d.Vector.fromArray(value));
-				default:
-					shader.setParamValue(variable, value);
-			}
-		} catch (e : Dynamic) {
-			// The parameter is not used
-		}
+		return parent.getParameter(id);
 	}
 
 
@@ -607,65 +739,15 @@ class ShaderGraph {
 		return counter != nbNodes;
 	}
 
-	public function addParameter(type : Type) {
-		var name = "Param_" + current_param_id;
-		parametersAvailable.set(current_param_id, {id: current_param_id, name : name, type : type, defaultValue : null, variable : generateParameter(name, type), index : parametersKeys.length});
-		parametersKeys.push(current_param_id);
-		current_param_id++;
-		return current_param_id-1;
-	}
-
-	public function setParameterTitle(id : Int, newName : String) {
-		var p = parametersAvailable.get(id);
-		if (p != null) {
-			if (newName != null) {
-				for (p in parametersAvailable) {
-					if (p.name == newName) {
-						return false;
-					}
-				}
-				p.name = newName;
-				p.variable = generateParameter(newName, p.type);
-				return true;
-			}
-		}
-		return false;
-	}
-
-	public function setParameterDefaultValue(id : Int, newDefaultValue : Dynamic) : Bool {
-		var p = parametersAvailable.get(id);
-		if (p != null) {
-			if (newDefaultValue != null) {
-				p.defaultValue = newDefaultValue;
-				return true;
-			}
-		}
-		return false;
-	}
-
-	public function removeParameter(id : Int) {
-		parametersAvailable.remove(id);
-		parametersKeys.remove(id);
-		checkParameterIndex();
-	}
-
-	public function checkParameterIndex() {
-		for (k in parametersKeys) {
-			var oldParam = parametersAvailable.get(k);
-			oldParam.index = parametersKeys.indexOf(k);
-			parametersAvailable.set(k, oldParam);
-		}
-	}
-
 	public function removeNode(idNode : Int) {
 		this.nodes.remove(idNode);
 	}
 
-	public function save() {
+	public function saveToDynamic() : Dynamic {
 		var edgesJson : Array<Edge> = [];
 		for (n in nodes) {
 			for (inputName => connection in n.instance.connections) {
-				var def = n.instance.getShaderDef();
+				var def = n.instance.getShaderDef(domain);
 				var inputId = null;
 				for (i => inVar in def.inVars) {
 					if (inVar.v.name == inputName) {
@@ -674,7 +756,7 @@ class ShaderGraph {
 					}
 				}
 
-				var def = connection.from.instance.getShaderDef();
+				var def = connection.from.instance.getShaderDef(domain);
 				var outputId = null;
 				for (i => outVar in def.outVars) {
 					if (outVar.v.name == connection.fromName) {
@@ -686,15 +768,12 @@ class ShaderGraph {
 				edgesJson.push({ outputNodeId: connection.from.id, nameOutput: connection.fromName, inputNodeId: n.id, nameInput: inputName, inputId: inputId, outputId: outputId });
 			}
 		}
-		var json = haxe.Json.stringify({
+		var json = {
 			nodes: [
 				for (n in nodes) { x : Std.int(n.x), y : Std.int(n.y), id: n.id, type: n.type, properties : n.instance.savePropertiesNode() }
 			],
-			edges: edgesJson,
-			parameters: [
-				for (p in parametersAvailable) { id : p.id, name : p.name, type : [p.type.getName(), p.type.getParameters().toString()], defaultValue : p.defaultValue, index : p.index }
-			]
-		}, "\t");
+			edges: edgesJson
+		};
 
 		return json;
 	}

hrt/shgraph/ShaderInput.hx

@@ -19,7 +19,7 @@ class ShaderInput extends ShaderNode {
 	// 	return null;
 	// }
 
-	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override function getShaderDef(domain: ShaderGraph.Domain):hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
 		var inVar : TVar = variable;

hrt/shgraph/ShaderNode.hx

@@ -21,7 +21,7 @@ class ShaderNode {
 					}];
 
 
-	public function getShaderDef() : ShaderGraph.ShaderNodeDef {
+	public function getShaderDef(domain: ShaderGraph.Domain) : ShaderGraph.ShaderNodeDef {
 		throw "getShaderDef is not defined for class " + Type.getClassName(Type.getClass(this));
 		return {expr: null, inVars: [], outVars: [], inits: [], externVars: []};
 	}
@@ -34,8 +34,8 @@ class ShaderNode {
 	public var outputCompiled : Map<String, Bool> = []; // todo: put with outputs variable
 
 	// TODO(ces) : caching
-	public function getOutputs2() : Map<String, TVar> {
-		var def = getShaderDef();
+	public function getOutputs2(domain: ShaderGraph.Domain) : Map<String, TVar> {
+		var def = getShaderDef(domain);
 		var map : Map<String, TVar> = [];
 		for (tvar in def.outVars) {
 			if (!tvar.internal)
@@ -45,8 +45,8 @@ class ShaderNode {
 	}
 
 	// TODO(ces) : caching
-	public function getInputs2() : Map<String, TVar> {
-		var def = getShaderDef();
+	public function getInputs2(domain: ShaderGraph.Domain) : Map<String, TVar> {
+		var def = getShaderDef(domain);
 		var map : Map<String, TVar> = [];
 		for (tvar in def.inVars) {
 			if (!tvar.internal)

hrt/shgraph/ShaderNodeHxsl.hx

@@ -5,7 +5,7 @@ class ShaderNodeHxsl extends ShaderNode {
 
 	static var nodeCache : Map<String, ShaderGraph.ShaderNodeDef> = [];
 
-	override public function getShaderDef() : ShaderGraph.ShaderNodeDef {
+	override public function getShaderDef(domain: ShaderGraph.Domain) : ShaderGraph.ShaderNodeDef {
 		var cl = Type.getClass(this);
 		var className = Type.getClassName(cl);
 		var def = nodeCache.get(className);

hrt/shgraph/ShaderOutput.hx

@@ -13,7 +13,7 @@ class ShaderOutput extends ShaderNode {
 	var components = [X, Y, Z, W];
 
 
-	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override function getShaderDef(domain: ShaderGraph.Domain):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: []};

hrt/shgraph/ShaderParam.hx

@@ -12,7 +12,7 @@ class ShaderParam extends ShaderNode {
 	@prop() public var perInstance : Bool;
 
 
-	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override function getShaderDef(domain: ShaderGraph.Domain):hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
 		var qual = [];

hrt/shgraph/nodes/BoolConst.hx

@@ -12,7 +12,7 @@ class BoolConst extends ShaderConst {
 
 	@prop() var value : Bool = true;
 
-	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override function getShaderDef(domain: ShaderGraph.Domain):hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
 		var output : TVar = {name: "output", id:1, type: TBool, kind: Local, qualifiers: []};

hrt/shgraph/nodes/Color.hx

@@ -26,7 +26,7 @@ class Color extends ShaderConst {
 	// 	};
 	// }
 
-	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override function getShaderDef(domain: ShaderGraph.Domain):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: []};

hrt/shgraph/nodes/FloatConst.hx

@@ -9,7 +9,7 @@ using hxsl.Ast;
 @noheader()
 class FloatConst extends ShaderConst {
 
-	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override function getShaderDef(domain: ShaderGraph.Domain):hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var pos : Position = {file: "", min: 0, max: 0};
 
 		var output : TVar = {name: "output", id:1, type: TFloat, kind: Local, qualifiers: []};

hrt/shgraph/nodes/Preview.hx

@@ -11,7 +11,7 @@ using hxsl.Ast;
 @noheader()
 class Preview extends ShaderNode {
 
-	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override function getShaderDef(domain: ShaderGraph.Domain):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: []};

hrt/shgraph/nodes/SubGraph.hx

@@ -10,9 +10,10 @@ class SubGraph extends ShaderNode {
 
 	@prop() public var pathShaderGraph : String;
 
-	override public function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override public function getShaderDef(domain: ShaderGraph.Domain):hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		var shader = new ShaderGraph(pathShaderGraph);
-		var gen = shader.generate2();
+		var gen = shader.getGraph(domain).generate2();
+
 		// for (tvar in gen.externVars) {
 		// 	if (tvar.qualifiers != null) {
 		// 		if (tvar.qualifiers.contains(SgInput)) {

hrt/shgraph/nodes/Text.hx

@@ -12,7 +12,7 @@ class Text extends ShaderNode {
 
 	@prop() var text : String = "";
 
-	override function getShaderDef():hrt.shgraph.ShaderGraph.ShaderNodeDef {
+	override function getShaderDef(domain: ShaderGraph.Domain):hrt.shgraph.ShaderGraph.ShaderNodeDef {
 		return {expr: null, inVars: [], outVars: [], inits: [], externVars: []};
 	}