ShaderGraph: fix hxd.Res + preview node

bin/style.css

@@ -1353,6 +1353,11 @@ input[type=checkbox]:checked:after {
   margin-bottom: 3px;
   user-select: none;
 }
+.graph-view .heaps-scene svg .properties-group .preview-parent {
+  position: absolute;
+  height: 100px;
+  width: 100px;
+}
 .graph-view .heaps-scene svg .edge {
   stroke-width: 2;
   stroke: #c8c8c8;

bin/style.less

@@ -1529,6 +1529,12 @@ input[type=checkbox] {
 					margin-bottom: 3px;
 					user-select: none;
 				}
+
+				.preview-parent {
+					position: absolute;
+					height: 100px;
+					width: 100px;
+				}
 			}
 
 			.edge {

hide/view/Graph.hx

@@ -225,7 +225,7 @@ class Graph extends FileView {
 
 			for (b in listOfBoxesSelected) {
 				b.setPosition(b.getX() + dx, b.getY() + dy);
-				updatePosition(b.getId(), b.getX(), b.getY());
+				updatePosition(b);
 				// move edges from and to this box
 				for (edge in listOfEdges) {
 					if (edge.from == b || edge.to == b) {
@@ -247,7 +247,7 @@ class Graph extends FileView {
 		}
 	}
 
-	dynamic function updatePosition(id : Int, x : Float, y : Float) { }
+	dynamic function updatePosition(box : Box) { }
 
 	function addBox(p : Point, nodeClass : Class<ShaderNode>, node : ShaderNode) : Box {
 
@@ -343,6 +343,7 @@ class Graph extends FileView {
 				});
 			}
 		}
+
 		box.generateProperties(editor);
 
 		return box;

hide/view/shadereditor/ShaderEditor.hx

@@ -325,6 +325,13 @@ class ShaderEditor extends hide.view.Graph {
 		updateMatrix();
 
 		for (node in shaderGraph.getNodes()) {
+			var shaderPreview = Std.instance(node.instance, hrt.shgraph.nodes.Preview);
+			if (shaderPreview != null) {
+				shaderPreview.config = config;
+				shaderPreview.shaderGraph = shaderGraph;
+				addBox(new Point(node.x, node.y), std.Type.getClass(node.instance), shaderPreview);
+				continue;
+			}
 			var paramNode = Std.instance(node.instance, ShaderParam);
 			if (paramNode != null) {
 				var paramShader = shaderGraph.getParameter(paramNode.parameterId);
@@ -652,7 +659,7 @@ class ShaderEditor extends hide.view.Graph {
 		try {
 			switch (variable.type) {
 				case TSampler2D:
-					shader.setParamValue(variable, hxd.Res.load(value).toTexture());
+					shader.setParamValue(variable, sceneEditor.scene.loadTexture("", value));
 				default:
 					if (variable.name.toLowerCase().indexOf("color") != -1) {
 						shader.setParamValue(variable, Vector.fromArray(value));
@@ -1005,10 +1012,23 @@ class ShaderEditor extends hide.view.Graph {
 		launchCompileShader();
 	}
 
-	override function updatePosition(id : Int, x : Float, y : Float) {
-		shaderGraph.setPosition(id, x, y);
+	override function updatePosition(box : Box) {
+		var previewBox = Std.instance(box.getInstance(), hrt.shgraph.nodes.Preview);
+		if (previewBox != null){
+			previewBox.onMove(gX(box.getX()), gY(box.getY()), transformMatrix[0]);
+		}
+		shaderGraph.setPosition(box.getId(), box.getX(), box.getY());
 	}
 
+	override function updateMatrix() {
+		super.updateMatrix();
+		for (b in listOfBoxes) {
+			var previewBox = Std.instance(b.getInstance(), hrt.shgraph.nodes.Preview);
+			if (previewBox != null){
+				previewBox.onMove(gX(b.getX()), gY(b.getY()), transformMatrix[0]);
+			}
+		}
+	}
 
 	static var _ = FileTree.registerExtension(ShaderEditor,["hlshader"],{ icon : "scribd" });
 

hrt/shgraph/ShaderGraph.hx

@@ -32,6 +32,9 @@ typedef Parameter = {
 
 class ShaderGraph {
 
+	var allVariables : Array<TVar> = [];
+	var allParameters = [];
+	var allParamDefaultValue = [];
 	var current_node_id = 0;
 	var current_param_id = 0;
 	var filepath : String;
@@ -182,11 +185,25 @@ class ShaderGraph {
 		}
 		var build = nodeVar.getExpr();
 		res = res.concat(build);
+
+		var shaderInput = Std.instance(node, ShaderInput);
+		if (shaderInput != null) {
+			var variable = shaderInput.variable;
+			if ((variable.kind == Param || variable.kind == Global || variable.kind == Input) && !alreadyAddVariable(variable)) {
+				allVariables.push(variable);
+			}
+		}
+		var shaderParam = Std.instance(node, ShaderParam);
+		if (shaderParam != null && !alreadyAddVariable(shaderParam.variable)) {
+			allVariables.push(shaderParam.variable);
+			allParameters.push(shaderParam.variable);
+			allParamDefaultValue.push(getParameter(shaderParam.parameterId).defaultValue);
+		}
 		return res;
 	}
 
-	static function alreadyAddVariable(array : Array<TVar>, variable : TVar) {
-		for (v in array) {
+	function alreadyAddVariable(variable : TVar) {
+		for (v in allVariables) {
 			if (v.name == variable.name && v.type == variable.type) {
 				return true;
 			}
@@ -194,11 +211,11 @@ class ShaderGraph {
 		return false;
 	}
 
-	public function compile() : hrt.prefab.ContextShared.ShaderDef {
+	public function compile(?specificOutput : ShaderNode) : hrt.prefab.ContextShared.ShaderDef {
 
-		var allVariables : Array<TVar> = [];
-		var allParameters = [];
-		var allParamDefaultValue = [];
+		allVariables = [];
+		allParameters = [];
+		allParamDefaultValue = [];
 		var content = [];
 
 		for (n in nodes) {
@@ -213,29 +230,33 @@ class ShaderGraph {
 		var outputs : Array<String> = [];
 
 		for (n in nodes) {
-			if (Std.is(n.instance, ShaderInput)) {
-				var variable = Std.instance(n.instance, ShaderInput).variable;
-				if ((variable.kind == Param || variable.kind == Global || variable.kind == Input) && !alreadyAddVariable(allVariables, variable)) {
-					allVariables.push(variable);
+			var shaderNode;
+			var variable;
+			if (specificOutput != null) {
+				if (n.instance != specificOutput) continue;
+				shaderNode = specificOutput;
+				variable = Std.instance(specificOutput, hrt.shgraph.nodes.Preview).variable;
+			} else {
+				var shaderOutput = Std.instance(n.instance, ShaderOutput);
+
+				if (shaderOutput != null) {
+					variable = shaderOutput.variable;
+					shaderNode = n.instance;
+				} else {
+					continue;
 				}
 			}
-			if (Std.is(n.instance, ShaderOutput)) {
-				var variable = Std.instance(n.instance, ShaderOutput).variable;
+			if (shaderNode != null) {
 				if (outputs.indexOf(variable.name) != -1) {
 					throw ShaderException.t("This output already exists", n.id);
 				}
 				outputs.push(variable.name);
-				if ( !alreadyAddVariable(allVariables, variable) ) {
+				if ( !alreadyAddVariable(variable) ) {
 					allVariables.push(variable);
 				}
-				var nodeVar = new NodeVar(n.instance, "input");
+				var nodeVar = new NodeVar(shaderNode, "input");
 				content = content.concat(buildNodeVar(nodeVar));
-			}
-			if (Std.is(n.instance, ShaderParam)) {
-				var shaderParam = Std.instance(n.instance, ShaderParam);
-				allVariables.push(shaderParam.variable);
-				allParameters.push(shaderParam.variable);
-				allParamDefaultValue.push(getParameter(shaderParam.parameterId).defaultValue);
+				if (specificOutput != null) break;
 			}
 		}
 

hrt/shgraph/nodes/Preview.hx

@@ -0,0 +1,127 @@
+package hrt.shgraph.nodes;
+
+import h3d.scene.Mesh;
+import hide.Config;
+using hxsl.Ast;
+
+@name("Preview")
+@description("Preview node, just to debug :)")
+@group("Output")
+@width(100)
+class Preview extends ShaderNode {
+
+	@input("input") var input = SType.Vec4;
+
+	public var variable : TVar;
+
+	override public function build(key : String) : TExpr {
+
+		return {
+				p : null,
+				t : TVoid,
+				e : TBinop(OpAssign, {
+					e: TVar(variable),
+					p: null,
+					t: variable.type
+				}, input.getVar(variable.type))
+			};
+
+	}
+	static var availableOutputs = [];
+
+	#if editor
+	public var shaderGraph : ShaderGraph;
+	var cube : Mesh;
+	var scene : hide.comp.Scene;
+	var saveShader : hxsl.DynamicShader;
+	public var config : Config;
+
+	override public function getPropertiesHTML(width : Float) : Array<hide.Element> {
+		var elements = super.getPropertiesHTML(width);
+		for (c in ShaderNode.availableVariables) {
+			if (c.name == "pixelColor") {
+				this.variable = c;
+			}
+		}
+
+		if (this.variable == null) {
+			throw ShaderException.t("The preview is not available", this.id);
+		}
+		var element = new hide.Element('<div style="width: 100px; height: 90px"><div class="preview-parent" ><div class="node-preview" style="height: 100px" ></div></div></div>');
+
+		scene = new hide.comp.Scene(config, null, element.find(".node-preview"));
+		scene.onReady = function() {
+			//new h3d.scene.CameraController(scene.s3d).loadFromCamera();
+			var prim = new h3d.prim.Cube();
+			prim.addUVs();
+			prim.addNormals();
+			cube = new Mesh(prim, scene.s3d);
+			scene.init();
+			element.find(".node-preview").removeClass("hide-scene-container");
+			scene.resetCamera(cube);
+			onMove();
+			computeOutputs();
+		};
+
+		elements.push(element);
+		return elements;
+	}
+
+	public function onMove(?x : Float, ?y : Float, zoom : Float = 1.) {
+		var top : Float;
+		var left : Float;
+		var preview = new hide.Element(".node-preview");
+		var parent = preview.parent();
+		if (x != null && y != null) {
+			left = x;
+			top = y + 17;
+		} else {
+			var offsetWindow = preview.closest(".heaps-scene").offset();
+			var offset = preview.closest("foreignObject").offset();
+			top = offset.top - offsetWindow.top - 15;
+			left = offset.left - offsetWindow.left;
+		}
+		parent.css("top", top/(zoom*1.001));
+		parent.css("left", left/zoom);
+		parent.css("zoom", zoom);
+	}
+
+	function onResize() {
+		if( cube == null ) return;
+
+	}
+
+	override public function computeOutputs() {
+		if (saveShader != null) {
+			for (m in cube.getMaterials()) {
+				m.mainPass.removeShader(saveShader);
+			}
+		}
+
+		if (scene == null || input == null || input.isEmpty()) return;
+
+		scene.setCurrent();
+		var shaderGraphDef = shaderGraph.compile(this);
+		var shader = new hxsl.DynamicShader(shaderGraphDef.shader);
+		for (init in shaderGraphDef.inits) {
+			var variable = init.variable;
+			var value : Dynamic = init.value;
+			switch (variable.type) {
+				case TSampler2D:
+					shader.setParamValue(variable, scene.loadTexture("", value));
+				default:
+					if (variable.name.toLowerCase().indexOf("color") != -1) {
+						shader.setParamValue(variable, h3d.Vector.fromArray(value));
+					} else {
+						shader.setParamValue(variable, value);
+					}
+			}
+		}
+		for (m in cube.getMaterials()) {
+			m.mainPass.addShader(shader);
+		}
+		saveShader = shader;
+	}
+
+	#end
+}