x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/VolumeRendering/ComposedVolumeStyle.js

@@ -53,12 +53,14 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/VolumeRendering/X3DComposableVolumeRenderStyleNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DComposableVolumeRenderStyleNode,
-          X3DConstants)
+          X3DConstants,
+          X3DCast)
 {
 "use strict";
 
@@ -67,14 +69,16 @@ function (Fields,
 		X3DComposableVolumeRenderStyleNode .call (this, executionContext);
 
 		this .addType (X3DConstants .ComposedVolumeStyle);
+
+		this .renderStyleNodes = [ ];
 	}
 
 	ComposedVolumeStyle .prototype = Object .assign (Object .create (X3DComposableVolumeRenderStyleNode .prototype),
 	{
 		constructor: ComposedVolumeStyle,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput, "enabled", new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",    new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "enabled",     new Fields .SFBool (true)),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "renderStyle", new Fields .MFNode ()),
 		]),
 		getTypeName: function ()
@@ -89,6 +93,131 @@ function (Fields,
 		{
 			return "renderStyle";
 		},
+		initialize: function ()
+		{
+			X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
+
+			var gl = this .getBrowser () .getContext ();
+
+			if (gl .getVersion () < 2)
+				return;
+
+			this .renderStyle_ .addInterest ("set_renderStyle__", this);
+
+			this .set_renderStyle__ ();
+		},
+		addVolumeData: function (volumeDataNode)
+		{
+			X3DComposableVolumeRenderStyleNode .prototype .addVolumeData .call (this, volumeDataNode);
+
+			var renderStyleNodes = this .renderStyleNodes;
+
+			for (var i = 0, length = renderStyleNodes .length; i < length; ++ i)
+			{
+				var renderStyleNode = renderStyleNodes [i];
+
+				renderStyleNode .addVolumeData (volumeDataNode);
+			}
+		},
+		removeVolumeData: function (volumeDataNode)
+		{
+			X3DComposableVolumeRenderStyleNode .prototype .removeVolumeData .call (this, volumeDataNode);
+
+			for (var i = 0, length = renderStyleNodes .length; i < length; ++ i)
+			{
+				var renderStyleNode = renderStyleNodes [i];
+
+				renderStyleNode .removeVolumeData (volumeDataNode);
+			}
+		},
+		set_renderStyle__: function ()
+		{
+			var renderStyleNodes = this .renderStyleNodes;
+
+			for (var i = 0, length = renderStyleNodes .length; i < length; ++ i)
+			{
+				var renderStyleNode = renderStyleNodes [i];
+
+				renderStyleNode .removeInterest ("addNodeEvent", this);
+
+				this .getVolumeData () .forEach (function (volumeDataNode)
+				{
+					renderStyleNode .removeVolumeData (volumeDataNode);
+				});
+			}
+
+			renderStyleNodes .length = 0;
+
+			for (var i = 0, length = this .renderStyle_ .length; i < length; ++ i)
+			{
+				var renderStyleNode = X3DCast (X3DConstants .X3DComposableVolumeRenderStyleNode, this .renderStyle_ [i]);
+
+				if (renderStyleNode)
+					renderStyleNodes .push (renderStyleNode);
+			}
+
+			for (var i = 0, length = renderStyleNodes .length; i < length; ++ i)
+			{
+				var renderStyleNode = renderStyleNodes [i];
+
+				renderStyleNode .addInterest ("addNodeEvent", this);
+
+				this .getVolumeData () .forEach (function (volumeDataNode)
+				{
+					renderStyleNode .addVolumeData (volumeDataNode);
+				});
+			}
+		},
+		addShaderFields: function (shaderNode)
+		{
+			if (! this .enabled_ .getValue ())
+				return;
+
+			var renderStyleNodes = this .renderStyleNodes;
+
+			for (var i = 0, length = renderStyleNodes .length; i < length; ++ i)
+				renderStyleNodes [i] .addShaderFields (shaderNode);
+		},
+		getUniformsText: function ()
+		{
+			if (! this .enabled_ .getValue ())
+				return "";
+
+			var
+				renderStyleNodes = this .renderStyleNodes,
+				string           = "";
+
+			for (var i = 0, length = renderStyleNodes .length; i < length; ++ i)
+				string += renderStyleNodes [i] .getUniformsText ();
+
+			string += "\n";
+			string += "vec4\n";
+			string += "getComposedStyle_" + this .getId () + " (in vec4 textureColor, in vec3 texCoord)\n";
+			string += "{\n";
+
+			for (var i = 0, length = renderStyleNodes .length; i < length; ++ i)
+				string += renderStyleNodes [i] .getFunctionsText ();
+
+			string += "\n";
+			string += "	return textureColor;\n";
+			string += "}\n";
+
+			return string;
+		},
+		getFunctionsText: function ()
+		{
+			if (! this .enabled_ .getValue ())
+				return "";
+
+			var string = "";
+
+			string += "\n";
+			string += "	// ComposedVolumeStyle\n";
+			string += "\n";
+			string += "	textureColor = getComposedStyle_" + this .getId () + " (textureColor, texCoord);\n";
+
+			return string;
+		}
 	});
 
 	return ComposedVolumeStyle;

package/src/x_ite/Components/VolumeRendering/EdgeEnhancementVolumeStyle.js

@@ -53,12 +53,14 @@ define ([
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/VolumeRendering/X3DComposableVolumeRenderStyleNode",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DComposableVolumeRenderStyleNode,
-          X3DConstants)
+          X3DConstants,
+          X3DCast)
 {
 "use strict";
 
@@ -73,11 +75,11 @@ function (Fields,
 	{
 		constructor: EdgeEnhancementVolumeStyle,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput, "edgeColor", new Fields .SFColorRGBA (0, 0, 0, 1)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "enabled", new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",          new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "enabled",           new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "edgeColor",         new Fields .SFColorRGBA (0, 0, 0, 1)),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "gradientThreshold", new Fields .SFFloat (0.4)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceNormals", new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceNormals",    new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -91,6 +93,85 @@ function (Fields,
 		{
 			return "renderStyle";
 		},
+		initialize: function ()
+		{
+			X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
+
+			var gl = this .getBrowser () .getContext ();
+
+			if (gl .getVersion () < 2)
+				return;
+
+			this .surfaceNormals_ .addInterest ("set_surfaceNormals__", this);
+
+			this .set_surfaceNormals__ ();
+		},
+		set_surfaceNormals__: function ()
+		{
+			this .surfaceNormalsNode = X3DCast (X3DConstants .X3DTexture3DNode, this .surfaceNormals_);
+		},
+		addShaderFields: function (shaderNode)
+		{
+			if (! this .enabled_ .getValue ())
+				return;
+
+			shaderNode .addUserDefinedField (X3DConstants .inputOutput, "edgeColor_"         + this .getId (), this .edgeColor_         .copy ());
+			shaderNode .addUserDefinedField (X3DConstants .inputOutput, "gradientThreshold_" + this .getId (), this .gradientThreshold_ .copy ());
+
+			if (this .surfaceNormalsNode)
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "surfaceNormals_" + this .getId (), new Fields .SFNode (this .surfaceNormalsNode));
+		},
+		getUniformsText: function ()
+		{
+			if (! this .enabled_ .getValue ())
+				return "";
+
+			var string = "";
+
+			string += "\n";
+			string += "// EdgeEnhancementVolumeStyle\n";
+			string += "\n";
+			string += "uniform vec4  edgeColor_" + this .getId () + ";\n";
+			string += "uniform float gradientThreshold_" + this .getId () + ";\n";
+
+			string += this .getNormalText (this .surfaceNormalsNode);
+
+			string += "\n";
+			string += "vec4\n";
+			string += "getEdgeEnhacementStyle_" + this .getId () + " (in vec4 originalColor, in vec3 texCoord)\n";
+			string += "{\n";
+			string += "	vec4 surfaceNormal = getNormal_" + this .getId () + " (texCoord);\n";
+			string += "\n";
+			string += "	if (surfaceNormal .w == 0.0)\n";
+			string += "		return vec4 (0.0);\n";
+			string += "\n";
+			string += "	vec4  edgeColor         = edgeColor_" + this .getId () + ";\n";
+			string += "	float gradientThreshold = gradientThreshold_" + this .getId () + ";\n";
+			string += "\n";
+			string += "	float angle = abs (dot (surfaceNormal .xyz, normalize (vertex)));\n";
+			string += "\n";
+			string += "	if (angle >= cos (gradientThreshold))\n";
+			string += "		return originalColor;\n";
+			string += "	else\n";
+			string += "		return vec4 (mix (edgeColor .rgb, originalColor.rgb, angle), originalColor .a);\n";
+			string += "}\n";
+
+			return string;
+		},
+		getFunctionsText: function ()
+		{
+			if (! this .enabled_ .getValue ())
+				return "";
+
+			var string = "";
+
+			string += "\n";
+			string += "	// EdgeEnhancementVolumeStyle\n";
+			string += "\n";
+			string += "	textureColor = getEdgeEnhacementStyle_" + this .getId () + " (textureColor, texCoord);\n";
+
+			return string;
+		},
 	});
 
 	return EdgeEnhancementVolumeStyle;

package/src/x_ite/Components/VolumeRendering/IsoSurfaceVolumeData.js

@@ -52,13 +52,25 @@ define ([
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/VolumeRendering/X3DVolumeDataNode",
+	"x_ite/Components/Shaders/ComposedShader",
+	"x_ite/Components/Shaders/ShaderPart",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Bits/X3DCast",
+	"text!x_ite/Browser/VolumeRendering/VolumeStyle.vs",
+	"text!x_ite/Browser/VolumeRendering/VolumeStyle.fs",
+	"x_ite/DEBUG",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DVolumeDataNode,
-          X3DConstants)
+          ComposedShader,
+          ShaderPart,
+          X3DConstants,
+          X3DCast,
+          vs,
+          fs,
+          DEBUG)
 {
 "use strict";
 
@@ -67,22 +79,26 @@ function (Fields,
 		X3DVolumeDataNode .call (this, executionContext);
 
 		this .addType (X3DConstants .IsoSurfaceVolumeData);
+
+		this .renderStyleNodes = [ ];
 	}
 
 	IsoSurfaceVolumeData .prototype = Object .assign (Object .create (X3DVolumeDataNode .prototype),
 	{
 		constructor: IsoSurfaceVolumeData,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput, "contourStepSize", new Fields .SFFloat (0)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "dimensions", new Fields .SFVec3f (1, 1, 1)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "gradients", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "renderStyle", new Fields .MFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceTolerance", new Fields .SFFloat (0)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceValues", new Fields .MFFloat ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "voxels", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxCenter", new Fields .SFVec3f (0, 0, 0)),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxSize", new Fields .SFVec3f (-1, -1, -1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",         new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "dimensions",       new Fields .SFVec3f (1, 1, 1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "contourStepSize",  new Fields .SFFloat (0)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "surfaceValues",    new Fields .MFFloat ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "surfaceTolerance", new Fields .SFFloat (0)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "visible",          new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "bboxDisplay",      new Fields .SFBool ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxCenter",       new Fields .SFVec3f (0, 0, 0)),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "bboxSize",         new Fields .SFVec3f (-1, -1, -1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "renderStyle",      new Fields .MFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "gradients",        new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "voxels",           new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -96,6 +112,288 @@ function (Fields,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DVolumeDataNode .prototype .initialize .call (this);
+
+			var gl = this .getBrowser () .getContext ();
+
+			if (gl .getVersion () < 2)
+				return;
+
+			this .gradients_          .addInterest ("set_gradients__",   this);
+			this .renderStyle_        .addInterest ("set_renderStyle__", this);
+			this .voxels_             .addFieldInterest (this .getAppearance () .texture_);
+
+			this .contourStepSize_    .addInterest ("update", this);
+			this .surfaceValues_      .addInterest ("update", this);
+			this .surfaceTolerance_   .addInterest ("update", this);
+			this .renderStyle_        .addInterest ("update", this);
+
+			this .getAppearance () .texture_ = this .voxels_;
+
+			this .set_gradients__ ();
+			this .set_renderStyle__ ();
+			this .set_voxels__ ();
+
+			this .update ();
+		},
+		set_gradients__: function ()
+		{
+			this .gradientsNode = X3DCast (X3DConstants .X3DTexture3DNode, this .gradients_);
+		},
+		set_renderStyle__: function ()
+		{
+			var renderStyleNodes = this .renderStyleNodes;
+
+			for (var i = 0, length = renderStyleNodes .length; i < length; ++ i)
+			{
+				var renderStyleNode = renderStyleNodes [i];
+
+				renderStyleNode .removeInterest ("update", this);
+				renderStyleNode .removeVolumeData (this);
+			}
+
+			renderStyleNodes .length = 0;
+
+			for (var i = 0, length = this .renderStyle_ .length; i < length; ++ i)
+			{
+				var renderStyleNode = X3DCast (X3DConstants .X3DComposableVolumeRenderStyleNode, this .renderStyle_ [i]);
+
+				if (renderStyleNode)
+					renderStyleNodes .push (renderStyleNode);
+			}
+
+			for (var i = 0, length = renderStyleNodes .length; i < length; ++ i)
+			{
+				var renderStyleNode = renderStyleNodes [i];
+
+				renderStyleNode .addInterest ("update", this);
+				renderStyleNode .addVolumeData (this);
+			}
+		},
+		set_voxels__: function ()
+		{
+			if (this .voxelsNode)
+				this .voxelsNode .removeInterest ("set_textureSize__", this);
+
+			this .voxelsNode = X3DCast (X3DConstants .X3DTexture3DNode, this .voxels_);
+
+			if (this .voxelsNode)
+			{
+				this .voxelsNode .addInterest ("set_textureSize__", this);
+
+				this .set_textureSize__ ();
+			}
+		},
+		set_textureSize__: function ()
+		{
+			try
+			{
+				var textureSize = this .getShader () .getField ("x3d_TextureSize");
+
+				textureSize .x = this .voxelsNode .getWidth ();
+				textureSize .y = this .voxelsNode .getHeight ();
+				textureSize .z = this .voxelsNode .getDepth ();
+			}
+			catch (error)
+			{
+				if (DEBUG)
+					console .log (error .message);
+			}
+		},
+		update: function ()
+		{
+			this .setShader (this .createShader (vs, fs));
+		},
+		createShader: function (vs, fs)
+		{
+			// if (DEBUG)
+			// 	console .log ("Creating VolumeData Shader ...");
+
+			var
+				opacityMapVolumeStyle = this .getBrowser () .getDefaultVolumeStyle (),
+				styleUniforms         = opacityMapVolumeStyle .getUniformsText (),
+				styleFunctions        = opacityMapVolumeStyle .getFunctionsText ();
+
+			styleUniforms  += "\n";
+			styleUniforms  += "uniform float surfaceValues [" + this .surfaceValues_ .length + "];\n";
+			styleUniforms  += "uniform float surfaceTolerance;\n";
+
+			for (var i = 0, length = this .renderStyleNodes .length; i < length; ++ i)
+				styleUniforms  += this .renderStyleNodes [i] .getUniformsText ();
+
+			styleFunctions += "\n";
+			styleFunctions += "	// IsoSurfaceVolumeData\n";
+			styleFunctions += "\n";
+
+			if (this .gradientsNode)
+			{
+				styleUniforms += "\n";
+				styleUniforms += "uniform sampler3D gradients;\n";
+
+				styleFunctions += "	if (length (texture (gradients, texCoord) .xyz * 2.0 - 1.0) < surfaceTolerance)\n";
+				styleFunctions += "		discard;\n";
+			}
+			else
+			{
+				styleUniforms += "\n";
+				styleUniforms += "vec4\n";
+				styleUniforms += "getNormal (in vec3 texCoord)\n";
+				styleUniforms += "{\n";
+				styleUniforms += "	vec4  offset = vec4 (1.0 / x3d_TextureSize, 0.0);\n";
+				styleUniforms += "	float i0     = texture (x3d_Texture3D [0], texCoord + offset .xww) .r;\n";
+				styleUniforms += "	float i1     = texture (x3d_Texture3D [0], texCoord - offset .xww) .r;\n";
+				styleUniforms += "	float i2     = texture (x3d_Texture3D [0], texCoord + offset .wyw) .r;\n";
+				styleUniforms += "	float i3     = texture (x3d_Texture3D [0], texCoord - offset .wyw) .r;\n";
+				styleUniforms += "	float i4     = texture (x3d_Texture3D [0], texCoord + offset .wwz) .r;\n";
+				styleUniforms += "	float i5     = texture (x3d_Texture3D [0], texCoord - offset .wwz) .r;\n";
+				styleUniforms += "	vec3  n      = vec3 (i1 - i0, i3 - i2, i5 - i4);\n";
+				styleUniforms += "\n";
+				styleUniforms += "	return vec4 (normalize (x3d_TextureNormalMatrix * n), length (n));\n";
+				styleUniforms += "}\n";
+
+				styleFunctions += "	if (getNormal (texCoord) .w < surfaceTolerance)\n";
+				styleFunctions += "		discard;\n";
+			}
+
+			styleFunctions += "\n";
+			styleFunctions += "	float intensity = textureColor .r;\n";
+			styleFunctions += "\n";
+
+			if (this .surfaceValues_ .length === 1)
+			{
+				var contourStepSize = Math .abs (this .contourStepSize_ .getValue ());
+
+				if (contourStepSize === 0)
+				{
+					styleFunctions += "	if (intensity > surfaceValues [0])\n";
+					styleFunctions += "	{\n";
+					styleFunctions += "		textureColor = vec4 (vec3 (surfaceValues [0]), 1.0);\n";
+
+					if (this .renderStyleNodes .length)
+					{
+						styleFunctions += this .renderStyleNodes [0] .getFunctionsText ();
+					}
+
+					styleFunctions += "	}\n";
+					styleFunctions += "	else\n";
+					styleFunctions += "	{\n";
+					styleFunctions += "		discard;\n";
+					styleFunctions += "	}\n";
+					styleFunctions += "\n";
+				}
+				else
+				{
+					var surfaceValues = [ ];
+
+					for (var v = this .surfaceValues_ [0] - contourStepSize; v > 0; v -= contourStepSize)
+						surfaceValues .unshift (v);
+
+					surfaceValues .push (this .surfaceValues_ [0]);
+
+					for (var v = this .surfaceValues_ [0] + contourStepSize; v < 1; v += contourStepSize)
+						surfaceValues .push (v);
+
+					styleFunctions += "	if (false)\n";
+					styleFunctions += "	{ }\n";
+
+					for (var i = surfaceValues_ .length - 1; i >= 0; -- i)
+					{
+						styleFunctions += "	else if (intensity > " + surfaceValues [i] + ")\n";
+						styleFunctions += "	{\n";
+						styleFunctions += "		textureColor = vec4 (vec3 (" + surfaceValues [i] + "), 1.0);\n";
+
+						if (this .renderStyleNodes .length)
+						{
+							styleFunctions += this .renderStyleNodes [0] .getFunctionsText ();
+						}
+
+						styleFunctions += "	}\n";
+					}
+
+					styleFunctions += "	else\n";
+					styleFunctions += "	{\n";
+					styleFunctions += "		discard;\n";
+					styleFunctions += "	}\n";
+					styleFunctions += "\n";
+				}
+			}
+			else
+			{
+				styleFunctions += "	if (false)\n";
+				styleFunctions += "	{ }\n";
+
+				for (var i = this .surfaceValues_ .length - 1; i >= 0; -- i)
+				{
+					styleFunctions += "	else if (intensity > surfaceValues [" + i + "])\n";
+					styleFunctions += "	{\n";
+					styleFunctions += "		textureColor = vec4 (vec3 (surfaceValues [" + i + "]), 1.0);\n";
+
+					if (this .renderStyleNodes .length)
+					{
+						var r = Math .min (i, this .renderStyleNodes .length - 1);
+
+						styleFunctions += this .renderStyleNodes [r] .getFunctionsText ();
+					}
+
+					styleFunctions += "	}\n";
+				}
+
+				styleFunctions += "	else\n";
+				styleFunctions += "	{\n";
+				styleFunctions += "		discard;\n";
+				styleFunctions += "	}\n";
+				styleFunctions += "\n";
+			}
+
+			fs = fs .replace (/\/\/ VOLUME_STYLES_UNIFORMS\n/,  styleUniforms);
+			fs = fs .replace (/\/\/ VOLUME_STYLES_FUNCTIONS\n/, styleFunctions);
+
+			// if (DEBUG)
+			// 	this .getBrowser () .print (fs);
+
+			var vertexShader = new ShaderPart (this .getExecutionContext ());
+			vertexShader .setName ("VolumeDataVertexShader");
+			vertexShader .url_ .push ("data:x-shader/x-vertex," + vs);
+			vertexShader .setup ();
+
+			var fragmentShader = new ShaderPart (this .getExecutionContext ());
+			fragmentShader .setName ("VolumeDataFragmentShader");
+			fragmentShader .type_ = "FRAGMENT";
+			fragmentShader .url_ .push ("data:x-shader/x-fragment," + fs);
+			fragmentShader .setup ();
+
+			var shaderNode = new ComposedShader (this .getExecutionContext ());
+			shaderNode .setName ("VolumeDataShader");
+			shaderNode .language_ = "GLSL";
+			shaderNode .parts_ .push (vertexShader);
+			shaderNode .parts_ .push (fragmentShader);
+
+			shaderNode .addUserDefinedField (X3DConstants .inputOutput, "surfaceValues",    this .surfaceValues_    .copy ());
+			shaderNode .addUserDefinedField (X3DConstants .inputOutput, "surfaceTolerance", this .surfaceTolerance_ .copy ());
+
+			if (this .gradientsNode)
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "grandients", new Fields .SFNode (this .gradientsNode));
+
+			if (this .voxelsNode)
+			{
+				var textureSize = new Fields .SFVec3f (this .voxelsNode .getWidth (), this .voxelsNode .getHeight (), this .voxelsNode .getDepth ());
+
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "x3d_TextureSize", textureSize);
+			}
+			else
+			{
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "x3d_TextureSize", new Fields .SFVec3f ());
+			}
+
+			opacityMapVolumeStyle .addShaderFields (shaderNode);
+
+			for (var i = 0, length = this .renderStyleNodes .length; i < length; ++ i)
+				this .renderStyleNodes [i] .addShaderFields (shaderNode);
+
+			return shaderNode;
+		},
 	});
 
 	return IsoSurfaceVolumeData;