x_ite 4.0.5 → 4.7.5

package/src/x_ite/Components/Shape/Appearance.js

@@ -48,21 +48,21 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Shape/X3DAppearanceNode",
 	"x_ite/Bits/X3DCast",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Browser/Shape/AlphaMode",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DAppearanceNode,
           X3DCast,
-          X3DConstants)
+          X3DConstants,
+			 AlphaMode)
 {
 "use strict";
 
@@ -72,25 +72,32 @@ function ($,
 
 		this .addType (X3DConstants .Appearance);
 
-		this .linePropertiesNode   = null;
+		this .stylePropertiesNode  = [ ];
 		this .materialNode         = null;
+		this .backMaterialNode     = null;
 		this .textureNode          = null;
 		this .textureTransformNode = null;
 		this .shaderNodes          = [ ];
 		this .shaderNode           = null;
+		this .blendModeNode        = null;
 	}
 
-	Appearance .prototype = $.extend (Object .create (X3DAppearanceNode .prototype),
+	Appearance .prototype = Object .assign (Object .create (X3DAppearanceNode .prototype),
 	{
 		constructor: Appearance,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",         new Fields .SFNode ()),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "fillProperties",   new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "alphaMode",        new Fields .SFString ("AUTO")),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "alphaCutoff",      new Fields .SFFloat (0.5)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "pointProperties",  new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "lineProperties",   new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "fillProperties",   new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "material",         new Fields .SFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "backMaterial",     new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "texture",          new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "textureTransform", new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "shaders",          new Fields .MFNode ()),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "blendMode",        new Fields .SFNode ()),
 		]),
 		getTypeName: function ()
 		{
@@ -110,51 +117,97 @@ function ($,
 
 			this .isLive () .addInterest ("set_live__", this);
 
-			this .lineProperties_   .addInterest ("set_lineProperties__", this);
-			this .material_         .addInterest ("set_material__", this);
-			this .texture_          .addInterest ("set_texture__", this);
+			this .alphaMode_  		.addInterest ("set_alphaMode__",        this);
+			this .alphaCutoff_  		.addInterest ("set_alphaCutoff__",      this);
+			this .pointProperties_  .addInterest ("set_pointProperties__",  this);
+			this .lineProperties_   .addInterest ("set_lineProperties__",   this);
+			this .fillProperties_   .addInterest ("set_fillProperties__",   this);
+			this .material_         .addInterest ("set_material__",         this);
+			this .backMaterial_     .addInterest ("set_backMaterial__",     this);
+			this .texture_          .addInterest ("set_texture__",          this);
 			this .textureTransform_ .addInterest ("set_textureTransform__", this);
-			this .shaders_          .addInterest ("set_shaders__", this);
+			this .shaders_          .addInterest ("set_shaders__",          this);
+			this .blendMode_        .addInterest ("set_blendMode__",        this);
+
+			this .alphaMode_      .addInterest ("set_transparent__", this);
+			this .fillProperties_ .addInterest ("set_transparent__", this);
+			this .material_       .addInterest ("set_transparent__", this);
+			this .texture_        .addInterest ("set_transparent__", this);
+			this .blendMode_      .addInterest ("set_transparent__", this);
 
+			this .set_live__ ();
+			this .set_alphaMode__ ();
+			this .set_pointProperties__ ();
 			this .set_lineProperties__ ();
+			this .set_fillProperties__ ();
 			this .set_material__ ();
+			this .set_backMaterial__ ();
 			this .set_texture__ ();
 			this .set_textureTransform__ ();
 			this .set_shaders__ ();
+			this .set_blendMode__ ();
+			this .set_transparent__ ();
 		},
-		getLineProperties: function ()
-		{
-			return this .linePropertiesNode;
-		},
-		getMaterial: function ()
-		{
-			return this .materialNode;
-		},
-		getTexture: function ()
-		{
-			return this .textureNode;
-		},
-		getTextureTransform: function ()
-		{
-			return this .textureTransformNode;
-		},
-		set_lineProperties__: function ()
+		getAlphaMode: function ()
 		{
-			this .linePropertiesNode = X3DCast (X3DConstants .LineProperties, this .lineProperties_);
+			return this .alphaMode;
 		},
 		set_live__: function ()
 		{
 			if (this .isLive () .getValue ())
 			{
+				this .getBrowser () .getBrowserOptions () .Shading_ .addInterest ("set_shading__", this);
+
 				if (this .shaderNode)
 					this .getBrowser () .addShader (this .shaderNode);
 			}
 			else
 			{
+				this .getBrowser () .getBrowserOptions () .Shading_ .removeInterest ("set_shading__", this);
+
 				if (this .shaderNode)
-				this .getBrowser () .removeShader (this .shaderNode);
+					this .getBrowser () .removeShader (this .shaderNode);
 			}
 		},
+		set_alphaMode__: function ()
+		{
+			this .alphaMode = AlphaMode [this .alphaMode_ .getValue ()] || AlphaMode .AUTO;
+
+			this .set_alphaCutoff__ ();
+		},
+		set_alphaCutoff__: function ()
+		{
+			this .alphaCutoff = this .alphaMode === AlphaMode .MASK ? this .alphaCutoff_ .getValue () : 0;
+		},
+		set_pointProperties__: function ()
+		{
+			this .stylePropertiesNode [0] = X3DCast (X3DConstants .PointProperties, this .pointProperties_);
+
+			if (! this .stylePropertiesNode [0])
+				this .stylePropertiesNode [0] = this .getBrowser () .getDefaultPointProperties ();
+		},
+		set_lineProperties__: function ()
+		{
+			this .stylePropertiesNode [1] = X3DCast (X3DConstants .LineProperties, this .lineProperties_);
+
+			if (! this .stylePropertiesNode [1])
+				this .stylePropertiesNode [1] = this .getBrowser () .getDefaultLineProperties ();
+		},
+		set_fillProperties__: function ()
+		{
+			if (this .stylePropertiesNode [2])
+				this .stylePropertiesNode [2] .transparent_ .removeInterest ("set_transparent__", this);
+
+			this .stylePropertiesNode [2] = X3DCast (X3DConstants .FillProperties, this .fillProperties_);
+
+			if (! this .stylePropertiesNode [2])
+				this .stylePropertiesNode [2] = this .getBrowser () .getDefaultFillProperties ();
+
+			if (this .stylePropertiesNode [2])
+				this .stylePropertiesNode [2] .transparent_ .addInterest ("set_transparent__", this);
+
+			this .stylePropertiesNode [3] = this .stylePropertiesNode [2];
+		},
 		set_material__: function ()
 		{
 			if (this .materialNode)
@@ -162,10 +215,34 @@ function ($,
 
 			this .materialNode = X3DCast (X3DConstants .X3DMaterialNode, this .material_);
 
+			if (! this .materialNode)
+				this .materialNode = this .getBrowser () .getDefaultMaterial ();
+
 			if (this .materialNode)
 				this .materialNode .transparent_ .addInterest ("set_transparent__", this);
-			
-			this .set_transparent__ ();
+
+			// Depreciated TwoSidedMaterial handling.
+
+			if (this .materialNode .getTypeName () === "TwoSidedMaterial")
+			{
+				console .warn ("TwoSidedMaterial is depreciated, please use Appearance backMaterial.");
+				this .set_backMaterial__ ();
+			}
+		},
+		set_backMaterial__: function ()
+		{
+			if (this .backMaterialNode)
+				this .backMaterialNode .transparent_ .removeInterest ("set_transparent__", this);
+
+			this .backMaterialNode = X3DCast (X3DConstants .X3DOneSidedMaterialNode, this .backMaterial_);
+
+			if (this .backMaterialNode)
+				this .backMaterialNode .transparent_ .addInterest ("set_transparent__", this);
+
+			// Depreciated TwoSidedMaterial handling.
+
+			if (!this .backMaterialNode && this .materialNode .getTypeName () === "TwoSidedMaterial")
+				this .backMaterialNode = this .materialNode;
 		},
 		set_texture__: function ()
 		{
@@ -176,15 +253,11 @@ function ($,
 
 			if (this .textureNode)
 				this .textureNode .transparent_ .addInterest ("set_transparent__", this);
-
-			this .generatedCubeMapTexture = X3DCast (X3DConstants .GeneratedCubeMapTexture, this .texture_);
-
-			this .set_transparent__ ();
 		},
 		set_textureTransform__: function ()
 		{
 			this .textureTransformNode = X3DCast (X3DConstants .X3DTextureTransformNode, this .textureTransform_);
-			
+
 			if (this .textureTransformNode)
 				return;
 
@@ -192,23 +265,26 @@ function ($,
 		},
 		set_shaders__: function ()
 		{
-			var
-				shaders     = this .shaders_ .getValue (),
-				shaderNodes = this .shaderNodes;
+			const shaderNodes = this .shaderNodes;
+
+			for (const shaderNode of shaderNodes)
+			{
+				shaderNode .isValid_        .removeInterest ("set_shader__", this);
+				shaderNode .activationTime_ .removeInterest ("set_shader__", this);
+			}
 
-			for (var i = 0, length = shaderNodes .length; i < length; ++ i)
-				shaderNodes [i] .isValid_ .removeInterest ("set_shader__", this);
-		
 			shaderNodes .length = 0;
-		
-			for (var i = 0, length = shaders .length; i < length; ++ i)
+
+			for (const node of this .shaders_)
 			{
-				var shaderNode = X3DCast (X3DConstants .X3DShaderNode, shaders [i]);
-		
+				const shaderNode = X3DCast (X3DConstants .X3DShaderNode, node);
+
 				if (shaderNode)
 				{
 					shaderNodes .push (shaderNode);
-					shaderNode .isValid_ .addInterest ("set_shader__", this);
+
+					shaderNode .isValid_        .addInterest ("set_shader__", this);
+					shaderNode .activationTime_ .addInterest ("set_shader__", this);
 				}
 			}
 
@@ -216,54 +292,88 @@ function ($,
 		},
 		set_shader__: function ()
 		{
-			var shaderNodes = this .shaderNodes;
+			const shaderNodes = this .shaderNodes;
 
 			if (this .shaderNode)
+			{
 				this .getBrowser () .removeShader (this .shaderNode);
+				this .shaderNode .deselect ();
+			}
 
 			this .shaderNode = null;
 
-			for (var i = 0, length = shaderNodes .length; i < length; ++ i)
+			for (const shaderNode of shaderNodes)
 			{
-				if (shaderNodes [i] .isValid_ .getValue ())
+				if (shaderNode .isValid_ .getValue ())
 				{
-					this .shaderNode = shaderNodes [i];
-					break;
+					if (shaderNode .activationTime_ .getValue () === this .getBrowser () .getCurrentTime ())
+					{
+						this .shaderNode = shaderNode;
+						break;
+					}
+				}
+			}
+
+			if (!this .shaderNode)
+			{
+				for (const shaderNode of shaderNodes)
+				{
+					if (shaderNode .isValid_ .getValue ())
+					{
+						this .shaderNode = shaderNode;
+						break;
+					}
 				}
 			}
 
 			if (this .isLive () .getValue ())
 			{
 				if (this .shaderNode)
+				{
 					this .getBrowser () .addShader (this .shaderNode);
+					this .shaderNode .select ();
+				}
 			}
-
-			this .set_transparent__ ();
+		},
+		set_shading__: function ()
+		{
+			this .set_shader__ ();
+		},
+		set_blendMode__: function ()
+		{
+			this .blendModeNode = X3DCast (X3DConstants .BlendMode, this .blendMode_);
 		},
 		set_transparent__: function ()
 		{
-			this .transparent_ = (this .materialNode && this .materialNode .transparent_ .getValue ()) ||
-			                     (this .textureNode  && this .textureNode  .transparent_ .getValue ());
+			switch (this .alphaMode)
+			{
+				case AlphaMode .AUTO:
+					this .setTransparent (Boolean (this .stylePropertiesNode [3] .getTransparent () ||
+												 (this .materialNode && this .materialNode .getTransparent ()) ||
+												 (this .backMaterialNode && this .backMaterialNode .getTransparent ()) ||
+												 (this .textureNode && this .textureNode .getTransparent ()) ||
+												 this .blendModeNode));
+					break;
+				case AlphaMode .OPAQUE:
+					this .setTransparent (false);
+					break;
+				case AlphaMode .MASK:
+					this .setTransparent (false);
+					break;
+				case AlphaMode .BLEND:
+					this .setTransparent (true);
+					break;
+			}
 		},
 		traverse: function (type, renderObject)
 		{
-			if (this .generatedCubeMapTexture)
-				this .generatedCubeMapTexture .traverse (type, renderObject);
+			if (this .textureNode)
+				this .textureNode .traverse (type, renderObject);
 
 			if (this .shaderNode)
 				this .shaderNode .traverse (type, renderObject);
 		},
-		display: function (context)
-		{
-			context .linePropertiesNode   = this .linePropertiesNode;
-			context .materialNode         = this .materialNode;
-			context .textureNode          = this .textureNode;
-			context .textureTransformNode = this .textureTransformNode;
-			context .shaderNode           = this .shaderNode || context .renderer .getBrowser () .getDefaultShader ();
-		},
 	});
 
 	return Appearance;
 });
-
-

package/src/x_ite/Components/Shape/FillProperties.js

@@ -48,18 +48,16 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Shape/X3DAppearanceChildNode",
 	"x_ite/Bits/X3DConstants",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DAppearanceChildNode, 
+          X3DAppearanceChildNode,
           X3DConstants)
 {
 "use strict";
@@ -69,17 +67,23 @@ function ($,
 		X3DAppearanceChildNode .call (this, executionContext);
 
 		this .addType (X3DConstants .FillProperties);
+
+		this .addChildObjects ("transparent", new Fields .SFBool ());
+
+		this .transparent_ .setAccessType (X3DConstants .outputOnly);
+
+		this .hatchColor = new Float32Array (3);
 	}
 
-	FillProperties .prototype = $.extend (Object .create (X3DAppearanceChildNode .prototype),
+	FillProperties .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
 	{
 		constructor: FillProperties,
 		fieldDefinitions: new FieldDefinitionArray ([
 			new X3DFieldDefinition (X3DConstants .inputOutput, "metadata",   new Fields .SFNode ()),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "filled",     new Fields .SFBool (true)),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "hatched",    new Fields .SFBool (true)),
-			new X3DFieldDefinition (X3DConstants .inputOutput, "hatchStyle", new Fields .SFInt32 (1)),
 			new X3DFieldDefinition (X3DConstants .inputOutput, "hatchColor", new Fields .SFColor (1, 1, 1)),
+			new X3DFieldDefinition (X3DConstants .inputOutput, "hatchStyle", new Fields .SFInt32 (1)),
 		]),
 		getTypeName: function ()
 		{
@@ -93,9 +97,62 @@ function ($,
 		{
 			return "fillProperties";
 		},
+		initialize: function ()
+		{
+			X3DAppearanceChildNode .prototype .initialize .call (this);
+
+			this .filled_     .addInterest ("set_filled__",     this);
+			this .hatched_    .addInterest ("set_hatched__",    this);
+			this .hatchColor_ .addInterest ("set_hatchColor__", this);
+
+			this .set_filled__ ();
+			this .set_hatched__ ();
+			this .set_hatchColor__ ();
+		},
+		set_filled__: function ()
+		{
+			this .filled = this .filled_ .getValue ();
+
+			this .setTransparent (! this .filled);
+		},
+		set_hatched__: function ()
+		{
+			this .hatched = this .hatched_ .getValue ();
+		},
+		set_hatchColor__: function ()
+		{
+			this .hatchColor [0] = this .hatchColor_ [0];
+			this .hatchColor [1] = this .hatchColor_ [1];
+			this .hatchColor [2] = this .hatchColor_ [2];
+		},
+		setTransparent: function (value)
+		{
+			if (value !== this .transparent_ .getValue ())
+				this .transparent_ = value;
+		},
+		getTransparent: function ()
+		{
+			return this .transparent_ .getValue ();
+		},
+		setShaderUniforms: function (gl, shaderObject)
+		{
+			const hatched = this .hatched;
+
+			gl .uniform1i (shaderObject .x3d_FillPropertiesFilled,  this .filled);
+			gl .uniform1i (shaderObject .x3d_FillPropertiesHatched, hatched);
+
+			if (hatched)
+			{
+				const
+					browser = shaderObject .getBrowser (),
+					texture = browser .getHatchStyle (this .hatchStyle_ .getValue ());
+
+				gl .uniform3fv (shaderObject .x3d_FillPropertiesHatchColor, this .hatchColor);
+				gl .activeTexture (gl .TEXTURE0 + browser .getHatchStyleUnit ());
+				gl .bindTexture (gl .TEXTURE_2D, texture .getTexture ());
+			}
+		},
 	});
 
 	return FillProperties;
 });
-
-

package/src/x_ite/Components/Shape/LineProperties.js

@@ -48,18 +48,16 @@
 
 
 define ([
-	"jquery",
 	"x_ite/Fields",
 	"x_ite/Basic/X3DFieldDefinition",
 	"x_ite/Basic/FieldDefinitionArray",
 	"x_ite/Components/Shape/X3DAppearanceChildNode",
 	"x_ite/Bits/X3DConstants",
 ],
-function ($,
-          Fields,
+function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DAppearanceChildNode, 
+          X3DAppearanceChildNode,
           X3DConstants)
 {
 "use strict";
@@ -71,7 +69,7 @@ function ($,
 		this .addType (X3DConstants .LineProperties);
 	}
 
-	LineProperties .prototype = $.extend (Object .create (X3DAppearanceChildNode .prototype),
+	LineProperties .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
 	{
 		constructor: LineProperties,
 		fieldDefinitions: new FieldDefinitionArray ([
@@ -96,21 +94,43 @@ function ($,
 		{
 			X3DAppearanceChildNode .prototype .initialize .call (this);
 
+			this .applied_              .addInterest ("set_applied__",              this);
 			this .linewidthScaleFactor_ .addInterest ("set_linewidthScaleFactor__", this);
 
+			this .set_applied__ ();
 			this .set_linewidthScaleFactor__ ();
 		},
-		getLinewidthScaleFactor: function ()
+		set_applied__: function ()
 		{
-			return this .linewidthScaleFactor;
+			this .applied = this .applied_ .getValue ();
 		},
 		set_linewidthScaleFactor__: function ()
 		{
 			this .linewidthScaleFactor = Math .max (1, this .linewidthScaleFactor_ .getValue ());
 		},
+		setShaderUniforms: function (gl, shaderObject)
+		{
+			if (this .applied)
+			{
+				const
+					browser = shaderObject .getBrowser (),
+					texture = browser .getLinetype (this .linetype_ .getValue ());
+
+				gl .lineWidth (this .linewidthScaleFactor);
+				gl .uniform1i (shaderObject .x3d_LinePropertiesApplied,              true);
+				gl .uniform1f (shaderObject .x3d_LinePropertiesLinewidthScaleFactor, this .linewidthScaleFactor);
+
+				gl .activeTexture (gl .TEXTURE0 + browser .getLinetypeUnit ());
+				gl .bindTexture (gl .TEXTURE_2D, texture .getTexture ());
+			}
+			else
+			{
+				gl .lineWidth (1);
+				gl .uniform1i (shaderObject .x3d_LinePropertiesApplied,              false);
+				gl .uniform1f (shaderObject .x3d_LinePropertiesLinewidthScaleFactor, 1);
+			}
+		},
 	});
 
 	return LineProperties;
 });
-
-