x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/VolumeRendering/ShadedVolumeStyle.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,13 +75,13 @@ function (Fields,
 	{
 		constructor: ShadedVolumeStyle,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput, "enabled", new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "lighting", new Fields .SFBool ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "material", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "shadows", new Fields .SFBool ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceNormals", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .initializeOnly, "phaseFunction", new Fields .SFString ("Henyey-Greenstein")),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "metadata",       new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "enabled",        new Fields .SFBool (true)),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "lighting",       new Fields .SFBool ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "shadows",        new Fields .SFBool ()),
+			new X3DFieldDefinition (X3DConstants .initializeOnly, "phaseFunction",  new Fields .SFString ("Henyey-Greenstein")),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "material",       new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "surfaceNormals", new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -93,6 +95,187 @@ function (Fields,
 		{
 			return "renderStyle";
 		},
+		initialize: function ()
+		{
+			X3DComposableVolumeRenderStyleNode .prototype .initialize .call (this);
+
+			var gl = this .getBrowser () .getContext ();
+
+			if (gl .getVersion () < 2)
+				return;
+
+			this .material_       .addInterest ("set_material__",       this);
+			this .surfaceNormals_ .addInterest ("set_surfaceNormals__", this);
+
+			this .set_material__ ();
+			this .set_surfaceNormals__ ();
+		},
+		set_material__: function ()
+		{
+			if (this .materialNode)
+				this .materialNode .removeInterest ("addNodeEvent", this);
+
+			this .materialNode = X3DCast (X3DConstants .X3DMaterialNode, this .material_);
+
+			if (this .materialNode)
+				this .materialNode .addInterest ("addNodeEvent", this);
+		},
+		set_surfaceNormals__: function ()
+		{
+			this .surfaceNormalsNode = X3DCast (X3DConstants .X3DTexture3DNode, this .surfaceNormals_);
+		},
+		addShaderFields: function (shaderNode)
+		{
+			if (! this .enabled_ .getValue ())
+				return;
+
+			if (this .materialNode)
+			{
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "ambientIntensity_" + this .getId (), this .materialNode .ambientIntensity_ .copy ());
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "diffuseColor_"     + this .getId (), this .materialNode .diffuseColor_     .copy ());
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "specularColor_"    + this .getId (), this .materialNode .specularColor_    .copy ());
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "emissiveColor_"    + this .getId (), this .materialNode .emissiveColor_    .copy ());
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "shininess_"        + this .getId (), this .materialNode .shininess_        .copy ());
+				shaderNode .addUserDefinedField (X3DConstants .inputOutput, "transparency_"     + this .getId (), this .materialNode .transparency_     .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 += "// ShadedVolumeStyle\n";
+			string += "\n";
+			string += "uniform float ambientIntensity_" + this .getId () + ";\n";
+			string += "uniform vec3  diffuseColor_" + this .getId () + ";\n";
+			string += "uniform vec3  specularColor_" + this .getId () + ";\n";
+			string += "uniform vec3  emissiveColor_" + this .getId () + ";\n";
+			string += "uniform float shininess_" + this .getId () + ";\n";
+			string += "uniform float transparency_" + this .getId () + ";\n";
+
+			string += this .getNormalText (this .surfaceNormalsNode);
+
+			string += "\n";
+			string += "float\n";
+			string += "getSpotFactor_" + this .getId () + " (const in float cutOffAngle, const in float beamWidth, const in vec3 L, const in vec3 d)\n";
+			string += "{\n";
+			string += "	float spotAngle = acos (clamp (dot (-L, d), -1.0, 1.0));\n";
+			string += "\n";
+			string += "	if (spotAngle >= cutOffAngle)\n";
+			string += "		return 0.0;\n";
+			string += "	else if (spotAngle <= beamWidth)\n";
+			string += "		return 1.0;\n";
+			string += "\n";
+			string += "	return (spotAngle - cutOffAngle) / (beamWidth - cutOffAngle);\n";
+			string += "}\n";
+
+			string += "\n";
+			string += "vec4\n";
+			string += "getShadedStyle_" + 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 shadedColor   = vec4 (0.0);\n";
+
+			if (this .lighting_ .getValue ())
+			{
+				if (this .materialNode)
+				{
+					string += "	vec3 diffuseFactor = diffuseColor_" + this .getId () + ";\n";
+					string += "	vec3 ambientTerm   = diffuseFactor * ambientIntensity_" + this .getId () + ";\n";
+					string += "\n";
+					string += "	shadedColor .a = originalColor .a * (1.0 - transparency_" + this .getId () + ");\n";
+				}
+				else
+				{
+					string += "	vec3 diffuseFactor = originalColor .rgb;\n";
+					string += "	vec3 ambientTerm   = vec3 (0.0);\n";
+					string += "\n";
+					string += "	shadedColor .a = originalColor .a;\n";
+				}
+
+				string += "\n";
+				string += "	vec3 N = surfaceNormal .xyz;\n";
+				string += "	vec3 V = normalize (-vertex); // normalized vector from point on geometry to viewer's position\n";
+				string += "\n";
+				string += "	for (int i = 0; i < x3d_MaxLights; ++ i)\n";
+				string += "	{\n";
+				string += "		if (i == x3d_NumLights)\n";
+				string += "			break;\n";
+				string += "\n";
+				string += "		x3d_LightSourceParameters light = x3d_LightSource [i];\n";
+				string += "\n";
+				string += "		vec3  vL = light .location - vertex; // Light to fragment\n";
+				string += "		float dL = length (light .matrix * vL);\n";
+				string += "		bool  di = light .type == x3d_DirectionalLight;\n";
+				string += "\n";
+				string += "		if (di || dL <= light .radius)\n";
+				string += "		{\n";
+				string += "			vec3 d = light .direction;\n";
+				string += "			vec3 c = light .attenuation;\n";
+				string += "			vec3 L = di ? -d : normalize (vL);      // Normalized vector from point on geometry to light source i position.\n";
+				string += "			vec3 H = normalize (L + V);             // Specular term\n";
+				string += "\n";
+				string += "			float lightAngle     = max (dot (N, L), 0.0);      // Angle between normal and light ray.\n";
+				string += "			vec3  diffuseTerm    = diffuseFactor * lightAngle;\n";
+				string += "			float specularFactor = shininess_" + this .getId () + " > 0.0 ? pow (max (dot (N, H), 0.0), shininess_" + this .getId () + " * 128.0) : 1.0;\n";
+				string += "			vec3  specularTerm   = light .intensity * specularColor_" + this .getId () + " * specularFactor;\n";
+				string += "\n";
+				string += "			float attenuationFactor     = di ? 1.0 : 1.0 / max (c [0] + c [1] * dL + c [2] * (dL * dL), 1.0);\n";
+				string += "			float spotFactor            = light .type == x3d_SpotLight ? getSpotFactor_" + this .getId () + " (light .cutOffAngle, light .beamWidth, L, d) : 1.0;\n";
+				string += "			float attenuationSpotFactor = attenuationFactor * spotFactor;\n";
+				string += "			vec3  ambientColor          = light .ambientIntensity * ambientTerm;\n";
+				string += "			vec3  diffuseSpecularColor  = light .intensity * (diffuseTerm + specularTerm);\n";
+				string += "\n";
+				string += "			shadedColor .rgb += attenuationSpotFactor * light .color * (ambientColor + diffuseSpecularColor);\n";
+				string += "		}\n";
+				string += "\n";
+				string += "		shadedColor .rgb += emissiveColor_" + this .getId () + ";\n";
+				string += "		shadedColor .rgb  = getFogColor (shadedColor .rgb);\n";
+				string += "	}\n";
+			}
+			else
+			{
+				if (this .materialNode)
+				{
+					string += "	shadedColor .rgb = diffuseColor_" + this .getId () + ";\n";
+					string += "	shadedColor .a   = originalColor .a * (1.0 - transparency_" + this .getId () + ");\n";
+				}
+				else
+				{
+					string += "	shadedColor = originalColor;\n";
+				}
+			}
+
+			string += "\n";
+			string += "	return shadedColor;\n";
+			string += "}\n";
+
+			return string;
+		},
+		getFunctionsText: function ()
+		{
+			if (! this .enabled_ .getValue ())
+				return "";
+
+			var string = "";
+
+			string += "\n";
+			string += "	// ShadedVolumeStyle\n";
+			string += "\n";
+			string += "	textureColor = getShadedStyle_" + this .getId () + " (textureColor, texCoord);\n";
+
+			return string;
+		},
 	});
 
 	return ShadedVolumeStyle;

package/src/x_ite/Components/VolumeRendering/SilhouetteEnhancementVolumeStyle.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,12 +75,12 @@ function (Fields,
 	{
 		constructor: SilhouetteEnhancementVolumeStyle,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput, "enabled", new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "silhouetteBoundaryOpacity", new Fields .SFFloat (0)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",                  new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "enabled",                   new Fields .SFBool (true)),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "silhouetteRetainedOpacity", new Fields .SFFloat (1)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "silhouetteSharpness", new Fields .SFFloat (0.5)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceNormals", new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "silhouetteBoundaryOpacity", new Fields .SFFloat (0)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "silhouetteSharpness",       new Fields .SFFloat (0.5)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceNormals",            new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -92,6 +94,83 @@ 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, "silhouetteRetainedOpacity_" + this .getId (), this .silhouetteRetainedOpacity_ .copy ());
+			shaderNode .addUserDefinedField (X3DConstants .inputOutput, "silhouetteBoundaryOpacity_" + this .getId (), this .silhouetteBoundaryOpacity_ .copy ());
+			shaderNode .addUserDefinedField (X3DConstants .inputOutput, "silhouetteSharpness_"       + this .getId (), this .silhouetteSharpness_       .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 += "// SilhouetteEnhancementVolumeStyle\n";
+			string += "\n";
+			string += "uniform float silhouetteRetainedOpacity_" + this .getId () + ";\n";
+			string += "uniform float silhouetteBoundaryOpacity_" + this .getId () + ";\n";
+			string += "uniform float silhouetteSharpness_" + this .getId () + ";\n";
+
+			string += this .getNormalText (this .surfaceNormalsNode);
+
+			string += "\n";
+			string += "vec4\n";
+			string += "getSilhouetteEnhancementStyle_" + 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 += "	float silhouetteRetainedOpacity = silhouetteRetainedOpacity_" + this .getId () + ";\n";
+			string += "	float silhouetteBoundaryOpacity = silhouetteBoundaryOpacity_" + this .getId () + ";\n";
+			string += "	float silhouetteSharpness       = silhouetteSharpness_" + this .getId () + ";\n";
+			string += "\n";
+			string += "	return vec4 (originalColor .rgb, originalColor .a * (silhouetteRetainedOpacity + silhouetteBoundaryOpacity * pow (1.0 - abs (dot (surfaceNormal .xyz, normalize (vertex))), silhouetteSharpness)));\n";
+			string += "}\n";
+
+			return string;
+		},
+		getFunctionsText: function ()
+		{
+			if (! this .enabled_ .getValue ())
+				return "";
+
+			var string = "";
+
+			string += "\n";
+			string += "	// SilhouetteEnhancementVolumeStyle\n";
+			string += "\n";
+			string += "	textureColor = getSilhouetteEnhancementStyle_" + this .getId () + " (textureColor, texCoord);\n";
+
+			return string;
+		},
 	});
 
 	return SilhouetteEnhancementVolumeStyle;

package/src/x_ite/Components/VolumeRendering/ToneMappedVolumeStyle.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: ToneMappedVolumeStyle,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput, "coolColor", new Fields .SFColorRGBA (0, 0, 1, 0)),
-			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, "coolColor",      new Fields .SFColorRGBA (0, 0, 1, 0)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "warmColor",      new Fields .SFColorRGBA (1, 1, 0, 0)),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "surfaceNormals", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "warmColor", new Fields .SFColorRGBA (1, 1, 0, 0)),
 		]),
 		getTypeName: function ()
 		{
@@ -91,6 +93,94 @@ 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, "coolColor_" + this .getId (), this .coolColor_ .copy ());
+			shaderNode .addUserDefinedField (X3DConstants .inputOutput, "warmColor_" + this .getId (), this .warmColor_ .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 += "// ToneMappedVolumeStyle\n";
+			string += "\n";
+			string += "uniform vec4 coolColor_" + this .getId () + ";\n";
+			string += "uniform vec4 warmColor_" + this .getId () + ";\n";
+
+			string += this .getNormalText (this .surfaceNormalsNode);
+
+			string += "\n";
+			string += "vec4\n";
+			string += "getToneMappedStyle_" + 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 += "	vec3 toneColor = vec3 (0.0);\n";
+			string += "	vec3 coolColor = coolColor_" + this .getId () + " .rgb;\n";
+			string += "	vec3 warmColor = warmColor_" + this .getId () + " .rgb;\n";
+			string += "\n";
+			string += "	for (int i = 0; i < x3d_MaxLights; ++ i)\n";
+			string += "	{\n";
+			string += "		if (i == x3d_NumLights)\n";
+			string += "			break;\n";
+			string += "\n";
+			string += "		x3d_LightSourceParameters light = x3d_LightSource [i];\n";
+			string += "\n";
+			string += "		vec3  L           = light .type == x3d_DirectionalLight ? -light .direction : normalize (light .location - vertex);\n";
+			string += "		float colorFactor = (1.0 + dot (L, surfaceNormal .xyz)) * 0.5;\n";
+			string += "\n";
+			string += "		toneColor += mix (warmColor .rgb, coolColor .rgb, colorFactor);\n";
+			string += "	}\n";
+			string += "\n";
+			string += "	return vec4 (toneColor, originalColor .a);\n";
+			string += "}\n";
+
+			return string;
+		},
+		getFunctionsText: function ()
+		{
+			if (! this .enabled_ .getValue ())
+				return "";
+
+			var string = "";
+
+			string += "\n";
+			string += "	// ToneMappedVolumeStyle\n";
+			string += "\n";
+			string += "	textureColor = getToneMappedStyle_" + this .getId () + " (textureColor, texCoord);\n";
+
+			return string;
+		},
 	});
 
 	return ToneMappedVolumeStyle;

package/src/x_ite/Components/VolumeRendering/VolumeData.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,18 +79,22 @@ function (Fields,
 		X3DVolumeDataNode .call (this, executionContext);
 
 		this .addType (X3DConstants .VolumeData);
-	}
+
+		this .renderStyleNode = null;
+  }
 
 	VolumeData .prototype = Object .assign (Object .create (X3DVolumeDataNode .prototype),
 	{
 		constructor: VolumeData,
 		fieldDefinitions: new FieldDefinitionArray ([
-			new X3DFieldDefinition (X3DConstants .inputOutput, "dimensions", new Fields .SFVec3f (1, 1, 1)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata", new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "renderStyle", new Fields .SFNode ()),
-			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,    "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 .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput,    "voxels",      new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -92,6 +108,135 @@ function (Fields,
 		{
 			return "children";
 		},
+		initialize: function ()
+		{
+			X3DVolumeDataNode .prototype .initialize .call (this);
+
+			var gl = this .getBrowser () .getContext ();
+
+			if (gl .getVersion () < 2)
+				return;
+
+			this .renderStyle_ .addInterest ("set_renderStyle__", this);
+			this .voxels_      .addInterest ("set_voxels__",      this);
+			this .voxels_      .addFieldInterest (this .getAppearance () .texture_);
+
+			this .renderStyle_ .addInterest ("update", this);
+
+			this .getAppearance () .texture_   = this .voxels_;
+
+			this .set_renderStyle__ ();
+			this .set_voxels__ ();
+
+			this .update ();
+		},
+		set_renderStyle__: function ()
+		{
+			if (this .renderStyleNode)
+			{
+				this .renderStyleNode .removeInterest ("update", this);
+				this .renderStyleNode .removeVolumeData (this);
+			}
+
+			this .renderStyleNode = X3DCast (X3DConstants .X3DVolumeRenderStyleNode, this .renderStyle_);
+
+			if (this .renderStyleNode)
+			{
+				this .renderStyleNode .addInterest ("update", this);
+				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 ();
+
+			if (this .renderStyleNode)
+			{
+				styleUniforms  += this .renderStyleNode .getUniformsText (),
+				styleFunctions += this .renderStyleNode .getFunctionsText ();
+			}
+
+			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);
+
+			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);
+
+			if (this .renderStyleNode)
+				this .renderStyleNode .addShaderFields (shaderNode);
+
+			return shaderNode;
+		},
 	});
 
 	return VolumeData;