x_ite 4.2.17 → 4.7.7

package/src/x_ite/Components/Shaders/X3DShaderNode.js

@@ -48,13 +48,15 @@
 
 
 define ([
+	"x_ite/Fields",
 	"x_ite/Browser/Core/Shading",
 	"x_ite/Components/Shape/X3DAppearanceChildNode",
 	"x_ite/Bits/X3DConstants",
 	"x_ite/Bits/TraverseType",
 ],
-function (Shading,
-          X3DAppearanceChildNode, 
+function (Fields,
+          Shading,
+          X3DAppearanceChildNode,
           X3DConstants,
           TraverseType)
 {
@@ -65,11 +67,26 @@ function (Shading,
 		X3DAppearanceChildNode .call (this, executionContext);
 
 		this .addType (X3DConstants .X3DShaderNode);
+
+		this .addChildObjects ("activationTime", new Fields .SFTime ());
+
+		this .valid    = false;
+		this .selected = 0;
 	}
 
 	X3DShaderNode .prototype = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
 	{
 		constructor: X3DShaderNode,
+		initialize: function ()
+		{
+			X3DAppearanceChildNode .prototype .initialize .call (this);
+
+			this .activate_ .addInterest ("set_activate__", this);
+		},
+		set_activate__: function ()
+		{
+			this .activationTime_ = this .getBrowser () .getCurrentTime ();
+		},
 		custom: true,
 		setCustom: function (value)
 		{
@@ -79,6 +96,14 @@ function (Shading,
 		{
 			return this .custom;
 		},
+		setValid: function (value)
+		{
+			this .isValid_ = this .valid = value;
+		},
+		getValid: function ()
+		{
+			return this .valid;
+		},
 		setShading: function (shading)
 		{
 			var gl = this .getBrowser () .getContext ();
@@ -107,22 +132,33 @@ function (Shading,
 					this .wireframe     = false;
 					break;
 				}
-			}	
+			}
 		},
-		traverse: function (type, renderObject)
+		select: function ()
 		{
-			switch (type)
+			++ this .selected;
+
+			if (! this .isSelected_ .getValue ())
+				this .isSelected_ = true;
+		},
+		deselect: function ()
+		{
+			-- this .selected;
+
+			if (this .selected === 0)
 			{
-				case TraverseType .DISPLAY:
-					renderObject .getShaders () .set (this .getId (), this);
-					break;
-				default:
-					break;
+				if (this .isSelected_ .getValue ())
+					this .isSelected_ = false;
 			}
 		},
+		traverse: function (type, renderObject)
+		{
+			if (type !== TraverseType .DISPLAY)
+				return;
+
+			renderObject .getShaders () .add (this);
+		},
 	});
 
 	return X3DShaderNode;
 });
-
-

package/src/x_ite/Components/Shaders.js

@@ -52,10 +52,10 @@ define ([
 	"x_ite/Components/Shaders/FloatVertexAttribute",
 	"x_ite/Components/Shaders/Matrix3VertexAttribute",
 	"x_ite/Components/Shaders/Matrix4VertexAttribute",
-//	"x_ite/Components/Shaders/PackagedShader",
-//	"x_ite/Components/Shaders/ProgramShader",
+	"x_ite/Components/Shaders/PackagedShader",
+	"x_ite/Components/Shaders/ProgramShader",
 	"x_ite/Components/Shaders/ShaderPart",
-//	"x_ite/Components/Shaders/ShaderProgram",
+	"x_ite/Components/Shaders/ShaderProgram",
 	"x_ite/Components/Shaders/X3DProgrammableShaderObject",
 	"x_ite/Components/Shaders/X3DShaderNode",
 	"x_ite/Components/Shaders/X3DVertexAttributeNode",
@@ -65,41 +65,38 @@ function (SupportedNodes,
           FloatVertexAttribute,
           Matrix3VertexAttribute,
           Matrix4VertexAttribute,
-//          PackagedShader,
-//          ProgramShader,
+          PackagedShader,
+          ProgramShader,
           ShaderPart,
-//          ShaderProgram,
+          ShaderProgram,
           X3DProgrammableShaderObject,
           X3DShaderNode,
           X3DVertexAttributeNode)
 {
 "use strict";
 
-	var Types =
+	const Types =
 	{
 		ComposedShader:         ComposedShader,
 		FloatVertexAttribute:   FloatVertexAttribute,
 		Matrix3VertexAttribute: Matrix3VertexAttribute,
 		Matrix4VertexAttribute: Matrix4VertexAttribute,
-//		PackagedShader:         PackagedShader,
-//		ProgramShader:          ProgramShader,
+		PackagedShader:         PackagedShader,
+		ProgramShader:          ProgramShader,
 		ShaderPart:             ShaderPart,
-//		ShaderProgram:          ShaderProgram,
+		ShaderProgram:          ShaderProgram,
 	};
 
-	var AbstractTypes =
+	const AbstractTypes =
 	{
 		X3DProgrammableShaderObject: X3DProgrammableShaderObject,
 		X3DShaderNode:               X3DShaderNode,
 		X3DVertexAttributeNode:      X3DVertexAttributeNode,
 	};
-	
-	for (var typeName in Types)
-		SupportedNodes .addType (typeName, Types [typeName]); 
 
-	for (var typeName in AbstractTypes)
-		SupportedNodes .addAbstractType (typeName, AbstractTypes [typeName]); 
+	for (const typeName in Types)
+		SupportedNodes .addType (typeName, Types [typeName]);
 
-	return Types;
+	for (const typeName in AbstractTypes)
+		SupportedNodes .addAbstractType (typeName, AbstractTypes [typeName]);
 });
-

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

@@ -54,13 +54,15 @@ define ([
 	"x_ite/Components/Shape/X3DAppearanceNode",
 	"x_ite/Bits/X3DCast",
 	"x_ite/Bits/X3DConstants",
+	"x_ite/Browser/Shape/AlphaMode",
 ],
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
           X3DAppearanceNode,
           X3DCast,
-          X3DConstants)
+          X3DConstants,
+			 AlphaMode)
 {
 "use strict";
 
@@ -70,8 +72,9 @@ function (Fields,
 
 		this .addType (X3DConstants .Appearance);
 
-		this .linePropertiesNode   = null;
+		this .stylePropertiesNode  = [ ];
 		this .materialNode         = null;
+		this .backMaterialNode     = null;
 		this .textureNode          = null;
 		this .textureTransformNode = null;
 		this .shaderNodes          = [ ];
@@ -84,9 +87,13 @@ function (Fields,
 		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 ()),
@@ -110,36 +117,40 @@ function (Fields,
 
 			this .isLive () .addInterest ("set_live__", 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 .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 ()
+		getAlphaMode: function ()
 		{
-			return this .textureTransformNode;
+			return this .alphaMode;
 		},
 		set_live__: function ()
 		{
@@ -158,9 +169,44 @@ function (Fields,
 					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 .linePropertiesNode = X3DCast (X3DConstants .LineProperties, this .lineProperties_);
+			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 ()
 		{
@@ -169,10 +215,34 @@ function (Fields,
 
 			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 ()
 		{
@@ -183,15 +253,11 @@ function (Fields,
 
 			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;
 
@@ -199,23 +265,26 @@ function (Fields,
 		},
 		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);
 				}
 			}
 
@@ -223,32 +292,48 @@ function (Fields,
 		},
 		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)
-				this .shaderNode = this .getBrowser () .getDefaultShader ();
+			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 ()
 		{
@@ -257,47 +342,38 @@ function (Fields,
 		set_blendMode__: function ()
 		{
 			this .blendModeNode = X3DCast (X3DConstants .BlendMode, this .blendMode_);
-
-			this .set_transparent__ ();
 		},
 		set_transparent__: function ()
 		{
-			this .transparent_ = (this .materialNode && this .materialNode .transparent_ .getValue ()) ||
-			                     (this .textureNode  && this .textureNode  .transparent_ .getValue () ||
-			                      this .blendModeNode);
+			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);
-
-			this .shaderNode .traverse (type, renderObject);
-		},
-		enable: function (gl, context)
-		{
-			var browser = context .renderer .getBrowser ();
-
-			context .linePropertiesNode   = this .linePropertiesNode;
-			context .materialNode         = this .materialNode;
-			context .textureNode          = this .textureNode;
-			context .textureTransformNode = this .textureTransformNode;
-
-			if (context .shadow)
-				context .shaderNode = browser .getShadowShader ();
-			else
-				context .shaderNode = this .shaderNode;
+			if (this .textureNode)
+				this .textureNode .traverse (type, renderObject);
 
-			if (this .blendModeNode)
-				this .blendModeNode .enable (gl);
-		},
-		disable: function (gl, context)
-		{
-			if (this .blendModeNode)
-				this .blendModeNode .disable (gl);
+			if (this .shaderNode)
+				this .shaderNode .traverse (type, renderObject);
 		},
 	});
 
 	return Appearance;
 });
-
-

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

@@ -57,7 +57,7 @@ define ([
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DAppearanceChildNode, 
+          X3DAppearanceChildNode,
           X3DConstants)
 {
 "use strict";
@@ -67,6 +67,12 @@ function (Fields,
 		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 = Object .assign (Object .create (X3DAppearanceChildNode .prototype),
@@ -76,8 +82,8 @@ function (Fields,
 			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 ()
 		{
@@ -91,9 +97,62 @@ function (Fields,
 		{
 			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

@@ -57,7 +57,7 @@ define ([
 function (Fields,
           X3DFieldDefinition,
           FieldDefinitionArray,
-          X3DAppearanceChildNode, 
+          X3DAppearanceChildNode,
           X3DConstants)
 {
 "use strict";
@@ -94,21 +94,43 @@ function (Fields,
 		{
 			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;
 });
-
-