x_ite 8.4.3 → 8.5.3

package/src/x_ite/Components/Lighting/X3DLightNode.js

@@ -135,7 +135,7 @@ X3DLightNode .prototype = Object .assign (Object .create (X3DChildNode .prototyp
          return biasMatrix;
       };
    })(),
-   push: function (renderObject, group)
+   push: function (renderObject, groupNode)
    {
       if (renderObject .isIndependent ())
       {
@@ -155,7 +155,7 @@ X3DLightNode .prototype = Object .assign (Object .create (X3DChildNode .prototyp
          else
          {
             lightContainer .set (this,
-                                 group,
+                                 groupNode,
                                  renderObject .getModelViewMatrix () .get ());
 
             renderObject .getLocalObjects () .push (lightContainer);
@@ -170,10 +170,10 @@ X3DLightNode .prototype = Object .assign (Object .create (X3DChildNode .prototyp
       {
          const lightContainer = renderObject .getLightContainer ();
 
+         lightContainer .modelViewMatrix .pushMatrix (renderObject .getModelViewMatrix () .get ());
+
          if (this ._global .getValue ())
          {
-            lightContainer .getModelViewMatrix () .pushMatrix (renderObject .getModelViewMatrix () .get ());
-
             renderObject .getGlobalObjects () .push (lightContainer);
             renderObject .getLights ()        .push (lightContainer);
 
@@ -181,8 +181,6 @@ X3DLightNode .prototype = Object .assign (Object .create (X3DChildNode .prototyp
          }
          else
          {
-            lightContainer .getModelViewMatrix () .pushMatrix (renderObject .getModelViewMatrix () .get ());
-
             renderObject .getLocalObjects () .push (lightContainer);
             renderObject .getLights ()       .push (lightContainer);
 
@@ -197,10 +195,10 @@ X3DLightNode .prototype = Object .assign (Object .create (X3DChildNode .prototyp
       if (this ._global .getValue ())
          return;
 
+      const lightContainer = renderObject .getLocalObjects () .pop ();
+
       if (renderObject .isIndependent ())
-         this .getBrowser () .getLocalObjects () .push (renderObject .getLocalObjects () .pop ());
-      else
-         renderObject .getLocalObjects () .pop ();
+         this .getBrowser () .getLocalObjects () .push (lightContainer);
 
       renderObject .popLocalShadows ();
 

package/src/x_ite/Components/Navigation/OrthoViewpoint.js

@@ -323,6 +323,8 @@ OrthoViewpoint .prototype = Object .assign (Object .create (X3DViewpointNode .pr
    },
    viewAll: function (bbox)
    {
+      X3DViewpointNode .prototype .viewAll .call (this, bbox);
+
       const
          size   = bbox .size,
          scaleX = size .x / this .getSizeX (),
@@ -333,8 +335,6 @@ OrthoViewpoint .prototype = Object .assign (Object .create (X3DViewpointNode .pr
       this ._fieldOfViewOffset [1] = this .getMinimumY () * scale - this .getMinimumY ();
       this ._fieldOfViewOffset [2] = this .getMaximumX () * scale - this .getMaximumX ();
       this ._fieldOfViewOffset [3] = this .getMaximumY () * scale - this .getMaximumY ();
-
-      X3DViewpointNode .prototype .viewAll .call (this, bbox);
    },
 });
 

package/src/x_ite/Components/Navigation/X3DViewpointNode.js

@@ -125,7 +125,7 @@ X3DViewpointNode .prototype = Object .assign (Object .create (X3DBindableNode .p
       this .easeInEaseOut ._modifiedFraction_changed .addFieldInterest (this .orientationInterpolator      ._set_fraction);
       this .easeInEaseOut ._modifiedFraction_changed .addFieldInterest (this .scaleInterpolator            ._set_fraction);
       this .easeInEaseOut ._modifiedFraction_changed .addFieldInterest (this .scaleOrientationInterpolator ._set_fraction);
-      this .easeInEaseOut ._modifiedFraction_changed .addFieldInterest (this .fieldOfViewScaleInterpolator      ._set_fraction);
+      this .easeInEaseOut ._modifiedFraction_changed .addFieldInterest (this .fieldOfViewScaleInterpolator ._set_fraction);
 
       this .positionInterpolator         ._value_changed .addFieldInterest (this ._positionOffset);
       this .orientationInterpolator      ._value_changed .addFieldInterest (this ._orientationOffset);
@@ -349,6 +349,8 @@ X3DViewpointNode .prototype = Object .assign (Object .create (X3DBindableNode .p
          this ._orientationOffset      = relative .orientation;
          this ._scaleOffset            = relative .scale;
          this ._scaleOrientationOffset = relative .scaleOrientation;
+         this ._nearDistance           = toViewpointNode ._nearDistance;
+         this ._farDistance            = toViewpointNode ._farDistance;
 
          this .setInterpolators (fromViewpointNode, toViewpointNode, relative);
 
@@ -379,6 +381,9 @@ X3DViewpointNode .prototype = Object .assign (Object .create (X3DBindableNode .p
       this ._scaleOrientationOffset = Rotation4 .Identity;
       this ._centerOfRotationOffset = Vector3   .Zero;
       this ._fieldOfViewScale       = 1;
+
+      this .set_nearDistance__ ();
+      this .set_farDistance__ ();
    },
    getRelativeTransformation: (function ()
    {
@@ -537,17 +542,20 @@ X3DViewpointNode .prototype = Object .assign (Object .create (X3DBindableNode .p
    })(),
    viewAll: function (bbox)
    {
+      bbox .multRight (this .modelMatrix .copy () .inverse ());
+
       const
-         center          = bbox .center,
-         direction       = this .getUserPosition () .copy () .subtract (center),
+         direction       = this .getUserPosition () .copy () .subtract (bbox .center) .normalize (),
          distance        = this .getLookAtDistance (bbox),
-         userPosition    = center .copy () .add (direction .normalize () .multiply (distance)),
-         userOrientation = this .getLookAtRotation (userPosition, center);
+         userPosition    = bbox .center .copy () .add (direction .multiply (distance)),
+         userOrientation = this .getLookAtRotation (userPosition, bbox .center);
 
       this ._positionOffset         = userPosition .subtract (this .getPosition ());
       this ._orientationOffset      = this .getOrientation () .copy () .inverse () .multRight (userOrientation);
-      this ._centerOfRotationOffset = center .subtract (this .getCenterOfRotation ());
+      this ._centerOfRotationOffset = bbox .center .copy () .subtract (this .getCenterOfRotation ());
       this ._fieldOfViewScale       = 1;
+      this .nearDistance            = Math .min ((distance - bbox .size .magnitude ()) / 2, 0.125);
+      this .farDistance             = this .nearDistance * this .getMaxFarValue () / 0.125;
    },
    traverse: function (type, renderObject)
    {

package/src/x_ite/Components/Networking/Inline.js

@@ -67,10 +67,10 @@ function Inline (executionContext)
    if (executionContext .getSpecificationVersion () < 4.0)
       this ._global = true;
 
-   this .scene     = this .getBrowser () .getDefaultScene ();
-   this .groupNode = new Group (executionContext);
-
-   this .groupNode .addParent (this);
+   this .scene        = this .getBrowser () .getDefaultScene ();
+   this .groupNode    = new Group (executionContext);
+   this .localObjects = [ ];
+   this .localShadows = false;
 }
 
 Inline .prototype = Object .assign (Object .create (X3DChildNode .prototype),
@@ -225,73 +225,62 @@ Inline .prototype = Object .assign (Object .create (X3DChildNode .prototype),
             else
             {
                const
-                  globalsBegin           = renderObject .getGlobalObjects () .length,
-                  shadowsBegin           = renderObject .getGlobalShadows () .length,
-                  opaqueShapesBegin      = renderObject .getNumOpaqueShapes (),
-                  transparentShapesBegin = renderObject .getNumTransparentShapes ();
-
-               this .groupNode .traverse (type, renderObject);
-
-               const globalsEnd = renderObject .getGlobalObjects () .length;
-
-               if (globalsBegin === globalsEnd)
-                  return;
-
-               const
-                  browser              = this .getBrowser (),
                   globalObjects        = renderObject .getGlobalObjects (),
-                  globalShadow         = renderObject .getGlobalShadows () .at (-1),
-                  opaqueShapesEnd      = renderObject .getNumOpaqueShapes (),
-                  transparentShapesEnd = renderObject .getNumTransparentShapes (),
-                  opaqueShapes         = renderObject .getOpaqueShapes (),
-                  transparentShapes    = renderObject .getTransparentShapes ();
-
-               let
-                  numGlobalLights            = 0,
-                  numGlobalTextureProjectors = 0;
-
-               for (let g = globalsBegin; g < globalsEnd; ++ g)
+                  globalShadows        = renderObject .getGlobalShadows (),
+                  globalsBegin         = globalObjects .length,
+                  shadowsBegin         = globalShadows .length,
+                  localObjects         = this .localObjects,
+                  numLocalObjects      = localObjects .length,
+                  numLights            = localObjects .reduce ((n, c) => n + !!c .lightNode, 0),
+                  numTextureProjectors = localObjects .reduce ((n, c) => n + !!c .textureProjectorNode, 0);
+
+               if (numLocalObjects)
                {
-                  const globalObject = globalObjects [g];
-
-                  globalObject .setGroup (this .groupNode);
-
-                  numGlobalLights            += !!globalObject .lightNode;
-                  numGlobalTextureProjectors += !!globalObject .textureProjectorNode;
-
-                  browser .getLocalObjects () .push (globalObject);
+                  renderObject .getLocalObjects () .push (... localObjects);
+                  renderObject .pushLocalShadows (this .localShadows);
+                  renderObject .getLocalObjectsCount () [1] += numLights;
+                  renderObject .getLocalObjectsCount () [2] += numTextureProjectors;
                }
 
-               for (let i = opaqueShapesBegin; i < opaqueShapesEnd; ++ i)
-               {
-                  const
-                     renderContext = opaqueShapes [i],
-                     localObjects  = renderContext .localObjects;
-
-                  renderContext .shadows           = renderContext .shadows || globalShadow;
-                  renderContext .objectsCount [1] += numGlobalLights;
-                  renderContext .objectsCount [2] += numGlobalTextureProjectors;
+               this .groupNode .traverse (type, renderObject);
 
-                  for (let g = globalsBegin; g < globalsEnd; ++ g)
-                     localObjects .push (globalObjects [g]);
+               if (numLocalObjects)
+               {
+                  if (renderObject .isIndependent ())
+                  {
+                     const browser = this .getBrowser ();
+
+                     for (let i = 0; i < numLocalObjects; ++ i)
+                        browser .getLocalObjects () .push (renderObject .getLocalObjects () .pop ());
+                  }
+                  else
+                  {
+                     for (let i = 0; i < numLocalObjects; ++ i)
+                        renderObject .getLocalObjects () .pop ();
+                  }
+
+                  renderObject .popLocalShadows ();
+                  renderObject .getLocalObjectsCount () [1] -= numLights;
+                  renderObject .getLocalObjectsCount () [2] -= numTextureProjectors;
                }
 
-               for (let i = transparentShapesBegin; i < transparentShapesEnd; ++ i)
+               const numGlobalObjects = globalObjects .length - globalsBegin;
+
+               for (let i = 0; i < numGlobalObjects; ++ i)
                {
-                  const
-                     renderContext = transparentShapes [i],
-                     localObjects  = renderContext .localObjects;
+                  const globalObject = globalObjects [globalsBegin + i];
 
-                  renderContext .shadows           = renderContext .shadows || globalShadow;
-                  renderContext .objectsCount [1] += numGlobalLights;
-                  renderContext .objectsCount [2] += numGlobalTextureProjectors;
+                  globalObject .groupNode = this .groupNode;
+                  globalObject .global    = false;
 
-                  for (let g = globalsBegin; g < globalsEnd; ++ g)
-                     localObjects .push (globalObjects [g]);
+                  localObjects [i] = globalObject;
                }
 
-               renderObject .getGlobalObjects () .length = globalsBegin;
-               renderObject .getGlobalShadows () .length = shadowsBegin;
+               localObjects .length = numGlobalObjects;
+               this .localShadows   = globalShadows .at (-1);
+
+               globalObjects .length = globalsBegin;
+               globalShadows .length = shadowsBegin;
             }
 
             return;

package/src/x_ite/Components/Networking/X3DUrlObject.js

@@ -122,7 +122,7 @@ X3DUrlObject .prototype =
    },
    getCache: function ()
    {
-      return this [_cache];
+      return this [_cache] && this .getBrowser () .getBrowserOption ("Cache");
    },
    requestImmediateLoad: function (cache = true)
    {

package/src/x_ite/Components/PointingDeviceSensor/CylinderSensor.js

@@ -151,7 +151,7 @@ CylinderSensor .prototype = Object .assign (Object .create (X3DDragSensorNode .p
    },
    getAngle: function (rotation)
    {
-      if (Vector3 .dot (rotation .getAxis (), this .cylinder .axis .direction) > 0)
+      if (Vector3 .dot (rotation .getAxis (new Vector3 (0, 0, 0)), this .cylinder .axis .direction) > 0)
          return rotation .angle;
 
       else
@@ -262,7 +262,7 @@ CylinderSensor .prototype = Object .assign (Object .create (X3DDragSensorNode .p
             endVector     = rotation .multVecRot (this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 0, 1))),
             deltaRotation = new Rotation4 (this .startVector, endVector),
             axis          = this ._axisRotation .getValue () .multVecRot (new Vector3 (0, 1, 0)),
-            sign          = axis .dot (deltaRotation .getAxis ()) > 0 ? 1 : -1,
+            sign          = axis .dot (deltaRotation .getAxis (new Vector3 (0, 0, 0))) > 0 ? 1 : -1,
             min           = this ._minAngle .getValue (),
             max           = this ._maxAngle .getValue ();
 

package/src/x_ite/Components/Rendering/X3DLineGeometryNode.js

@@ -110,11 +110,13 @@ X3DLineGeometryNode .prototype = Object .assign (Object .create (X3DGeometryNode
       return function (hitRay, renderObject, invModelViewMatrix, appearanceNode, intersections)
       {
          const
+            browser            = this .getBrowser (),
+            contentScale       = browser .getRenderingProperty ("ContentScale"),
             modelViewMatrix    = renderObject .getModelViewMatrix () .get (),
             viewport           = renderObject .getViewVolume () .getViewport (),
             extents            = bbox .assign (this .getBBox ()) .multRight (modelViewMatrix) .getExtents (min, max),
             linePropertiesNode = appearanceNode .getLineProperties (),
-            lineWidth1_2       = Math .max (1.5, linePropertiesNode && linePropertiesNode .getApplied () ? linePropertiesNode .getLinewidthScaleFactor () / 2 : 1),
+            lineWidth1_2       = Math .max (1.5, linePropertiesNode && linePropertiesNode .getApplied () ? linePropertiesNode .getLinewidthScaleFactor () / 2 : contentScale),
             screenScale1       = renderObject .getViewpoint () .getScreenScale (min, viewport, screenScale1_), // in m/px
             offsets1           = invModelViewMatrix .multDirMatrix (screenScale1 .multiply (lineWidth1_2)),
             screenScale2       = renderObject .getViewpoint () .getScreenScale (max, viewport, screenScale2_), // in m/px
@@ -283,7 +285,7 @@ X3DLineGeometryNode .prototype = Object .assign (Object .create (X3DGeometryNode
                   renderObject        = renderContext .renderObject,
                   viewport            = renderObject .getViewVolume () .getViewport (),
                   projectionMatrix    = renderObject .getProjectionMatrix () .get (),
-                  primitiveMode       = browser .getPrimitiveMode (gl .TRIANGLES),
+                  primitiveMode       = browser .getWireframe () ? gl .TRIANGLES : browser .getPrimitiveMode (gl .TRIANGLES),
                   transformShaderNode = browser .getLineTransformShader ();
 
                modelViewProjectionMatrixArray .set (matrix .assign (renderContext .modelViewMatrix) .multRight (projectionMatrix));
@@ -406,17 +408,9 @@ X3DLineGeometryNode .prototype = Object .assign (Object .create (X3DGeometryNode
                   gl .bindBuffer (gl .ARRAY_BUFFER, null);
                }
 
-               if (browser .getWireframe ())
-               {
-                  for (let i = 0, length = this .vertexCount * 3; i < length; i += 3)
-                     gl .drawArrays (primitiveMode, i, 3);
-               }
-               else
-               {
-                  gl .frontFace (gl .CCW);
-                  gl .enable (gl .CULL_FACE);
-                  gl .drawArrays (primitiveMode, 0, this .vertexCount * 3);
-               }
+               gl .frontFace (gl .CCW);
+               gl .enable (gl .CULL_FACE);
+               gl .drawArrays (primitiveMode, 0, this .vertexCount * 3);
 
                if (blendModeNode)
                   blendModeNode .disable (gl);

package/src/x_ite/Components/Rendering/X3DPointGeometryNode.js

@@ -84,14 +84,16 @@ X3DLineGeometryNode .prototype = Object .assign (Object .create (X3DGeometryNode
       return function (hitRay, renderObject, invModelViewMatrix, appearanceNode, intersections)
       {
          const
+            browser             = this .getBrowser (),
+            contentScale        = browser .getRenderingProperty ("ContentScale"),
             modelViewMatrix     = renderObject .getModelViewMatrix () .get (),
             viewport            = renderObject .getViewVolume () .getViewport (),
             extents             = bbox .assign (this .getBBox ()) .multRight (modelViewMatrix) .getExtents (min, max),
             pointPropertiesNode = appearanceNode .getPointProperties (),
-            pointSize1          = Math .max (1.5, pointPropertiesNode ? pointPropertiesNode .getPointSize (min) / 2 : 1),
+            pointSize1          = Math .max (1.5, pointPropertiesNode ? pointPropertiesNode .getPointSize (min) / 2 : contentScale),
             screenScale1        = renderObject .getViewpoint () .getScreenScale (min, viewport, screenScale1_), // in m/px
             offsets1            = invModelViewMatrix .multDirMatrix (screenScale1 .multiply (pointSize1)),
-            pointSize2          = Math .max (1.5, pointPropertiesNode ? pointPropertiesNode .getPointSize (max) / 2 : 1),
+            pointSize2          = Math .max (1.5, pointPropertiesNode ? pointPropertiesNode .getPointSize (max) / 2 : contentScale),
             screenScale2        = renderObject .getViewpoint () .getScreenScale (max, viewport, screenScale2_), // in m/px
             offsets2            = invModelViewMatrix .multDirMatrix (screenScale2 .multiply (pointSize2));
 

package/src/x_ite/Components/RigidBodyPhysics/RigidBody.js

@@ -52,6 +52,7 @@ import X3DNode              from "../Core/X3DNode.js";
 import X3DConstants         from "../../Base/X3DConstants.js";
 import X3DCast              from "../../Base/X3DCast.js";
 import Vector3              from "../../../standard/Math/Numbers/Vector3.js";
+import Quaternion           from "../../../standard/Math/Numbers/Quaternion.js";
 import Rotation4            from "../../../standard/Math/Numbers/Rotation4.js";
 import Matrix4              from "../../../standard/Math/Numbers/Matrix4.js";
 import Ammo                 from "../../../lib/ammojs/AmmoClass.js";
@@ -465,6 +466,7 @@ RigidBody .prototype = Object .assign (Object .create (X3DNode .prototype),
       var
          transform       = new Ammo .btTransform (),
          position        = new Vector3 (0, 0, 0),
+         quaternion      = new Quaternion (0, 0, 0, 1),
          orientation     = new Rotation4 (0, 0, 1, 0),
          linearVelocity  = new Vector3 (0, 0, 0),
          angularVelocity = new Vector3 (0, 0, 0);
@@ -479,10 +481,10 @@ RigidBody .prototype = Object .assign (Object .create (X3DNode .prototype),
             btLinearVeloctity = this .rigidBody .getLinearVelocity (),
             btAngularVelocity = this .rigidBody .getAngularVelocity ();
 
-         orientation .value .set (btQuaternion .x (), btQuaternion .y (), btQuaternion .z (), btQuaternion .w ());
+         quaternion .set (btQuaternion .x (), btQuaternion .y (), btQuaternion .z (), btQuaternion .w ());
 
          this ._position        = position .set (btOrigin .x (), btOrigin .y (), btOrigin .z ());
-         this ._orientation     = orientation;
+         this ._orientation     = orientation .setQuaternion (quaternion);
          this ._linearVelocity  = linearVelocity .set (btLinearVeloctity .x (), btLinearVeloctity .y (), btLinearVeloctity .z ());
          this ._angularVelocity = angularVelocity .set (btAngularVelocity .x (), btAngularVelocity .y (), btAngularVelocity .z ());
       };

package/src/x_ite/Components/Scripting/Script.js

@@ -153,7 +153,7 @@ Script .prototype = Object .assign (Object .create (X3DScriptNode .prototype),
    {
       this .initialized = false;
 
-      new FileLoader (this) .loadScript (this ._url,
+      new FileLoader (this) .loadDocument (this ._url,
       function (data)
       {
          if (data === null)
@@ -164,7 +164,7 @@ Script .prototype = Object .assign (Object .create (X3DScriptNode .prototype),
          else
          {
             this .setLoadState (X3DConstants .COMPLETE_STATE);
-            this .initialize__ (data);
+            this .initialize__ ($.decodeText (data));
          }
       }
       .bind (this));

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

@@ -176,7 +176,7 @@ ShaderPart .prototype = Object .assign (Object .create (X3DNode .prototype),
                type           = this .getShaderType (),
                options        = ["X3D_" + type] .concat (this .options),
                shaderCompiler = new ShaderCompiler (gl),
-               source         = ShaderSource .getSource (gl, browser, shaderCompiler .process (data), options),
+               source         = ShaderSource .getSource (gl, browser, shaderCompiler .process ($.decodeText (data)), options),
                shader         = gl .createShader (gl [type]);
 
             gl .deleteShader (this .shader);

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

@@ -168,7 +168,6 @@ X3DProgrammableShaderObject .prototype =
       this .x3d_PointPropertiesPointSizeMaxValue    = gl .getUniformLocation (program, "x3d_PointProperties.pointSizeMaxValue");
       this .x3d_PointPropertiesAttenuation          = gl .getUniformLocation (program, "x3d_PointProperties.attenuation");
 
-      this .x3d_LinePropertiesApplied  = gl .getUniformLocation (program, "x3d_LineProperties.applied");
       this .x3d_LinePropertiesLinetype = gl .getUniformLocation (program, "x3d_LineProperties.linetype");
       this .x3d_LineStippleScale       = gl .getUniformLocation (program, "x3d_LineProperties.lineStippleScale");
       this .x3d_LinePropertiesTexture  = gl .getUniformLocation (program, "x3d_LineProperties.texture");
@@ -177,6 +176,7 @@ X3DProgrammableShaderObject .prototype =
       this .x3d_FillPropertiesHatched    = gl .getUniformLocation (program, "x3d_FillProperties.hatched");
       this .x3d_FillPropertiesHatchColor = gl .getUniformLocation (program, "x3d_FillProperties.hatchColor");
       this .x3d_FillPropertiesTexture    = gl .getUniformLocation (program, "x3d_FillProperties.texture");
+      this .x3d_FillPropertiesScale      = gl .getUniformLocation (program, "x3d_FillProperties.scale");
 
       for (let i = 0; i < maxLights; ++ i)
       {
@@ -326,8 +326,6 @@ X3DProgrammableShaderObject .prototype =
        * Fill uniforms with defaults.
        */
 
-      gl .uniform1f (this .x3d_LineStippleScale, browser .getLineStippleScale ());
-
       // Fill special uniforms with default values, textures for units are created in X3DTexturingContext.
 
       gl .uniform1i  (this .x3d_LinePropertiesTexture, browser .getDefaultTexture2DUnit ());

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

@@ -100,6 +100,10 @@ Appearance .prototype = Object .assign (Object .create (X3DAppearanceNode .proto
    {
       X3DAppearanceNode .prototype .initialize .call (this);
 
+      const browser = this .getBrowser ();
+
+      browser .getRenderingProperties () ._ContentScale .addInterest ("set_contentScale__", this);
+
       this ._alphaMode  		.addInterest ("set_alphaMode__",        this);
       this ._alphaCutoff  		.addInterest ("set_alphaCutoff__",      this);
       this ._pointProperties  .addInterest ("set_pointProperties__",  this);
@@ -195,6 +199,11 @@ Appearance .prototype = Object .assign (Object .create (X3DAppearanceNode .proto
    {
       return this .blendModeNode;
    },
+   set_contentScale__: function ()
+   {
+      this .set_pointProperties__ ();
+      this .set_applied__ ();
+   },
    set_alphaMode__: function ()
    {
       this .alphaMode = this .getEnum (AlphaMode, this ._alphaMode .getValue (), AlphaMode .AUTO);
@@ -208,6 +217,14 @@ Appearance .prototype = Object .assign (Object .create (X3DAppearanceNode .proto
    set_pointProperties__: function ()
    {
       this .stylePropertiesNode [0] = X3DCast (X3DConstants .PointProperties, this ._pointProperties);
+
+      if (! this .stylePropertiesNode [0])
+      {
+         const browser = this .getBrowser ();
+
+         if (browser .getRenderingProperty ("ContentScale") !== 1)
+            this .stylePropertiesNode [0] = browser .getDefaultPointProperties ();
+      }
    },
    set_lineProperties__: function ()
    {
@@ -224,9 +241,18 @@ Appearance .prototype = Object .assign (Object .create (X3DAppearanceNode .proto
    set_applied__: function ()
    {
       if (this .linePropertiesNode && this .linePropertiesNode ._applied .getValue ())
+      {
          this .stylePropertiesNode [1] = this .linePropertiesNode;
+      }
       else
-         this .stylePropertiesNode [1] = null;
+      {
+         const browser = this .getBrowser ();
+
+         if (browser .getRenderingProperty ("ContentScale") !== 1)
+            this .stylePropertiesNode [1] = browser .getDefaultLineProperties ();
+         else
+            this .stylePropertiesNode [1] = null;
+      }
    },
    set_fillProperties__: function ()
    {

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

@@ -152,6 +152,7 @@ FillProperties .prototype = Object .assign (Object .create (X3DAppearanceChildNo
             textureUnit = browser .getTexture2DUnit ();
 
          gl .uniform3fv (shaderObject .x3d_FillPropertiesHatchColor, this .hatchColor);
+         gl .uniform1f  (shaderObject .x3d_FillPropertiesScale,      browser .getRenderingProperty ("ContentScale"));
 
          gl .activeTexture (gl .TEXTURE0 + textureUnit);
          gl .bindTexture (gl .TEXTURE_2D, texture .getTexture ());

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

@@ -83,6 +83,10 @@ LineProperties .prototype = Object .assign (Object .create (X3DAppearanceChildNo
    {
       X3DAppearanceChildNode .prototype .initialize .call (this);
 
+      const browser = this .getBrowser ();
+
+      browser .getRenderingProperties () ._ContentScale .addInterest ("set_linewidthScaleFactor__", this);
+
       this ._applied              .addInterest ("set_applied__",              this);
       this ._linetype             .addInterest ("set_linetype__",             this);
       this ._linewidthScaleFactor .addInterest ("set_linewidthScaleFactor__", this);
@@ -126,23 +130,24 @@ LineProperties .prototype = Object .assign (Object .create (X3DAppearanceChildNo
    set_linewidthScaleFactor__: function ()
    {
       const
-         browser = this .getBrowser (),
-         gl      = browser .getContext ();
+         browser      = this .getBrowser (),
+         gl           = browser .getContext (),
+         contentScale = browser .getRenderingProperty ("ContentScale");
 
-      this .linewidthScaleFactor = Math .max (1, this ._linewidthScaleFactor .getValue ());
+      this .linewidthScaleFactor = Math .max (1, this ._linewidthScaleFactor .getValue ()) * contentScale;
       this .transformLines       = gl .HAS_FEATURE_TRANSFORMED_LINES && this .linewidthScaleFactor > 1;
    },
    setShaderUniforms: function (gl, shaderObject)
    {
+      const browser = this .getBrowser ();
+
       if (this .applied)
       {
-         const
-            browser     = this .getBrowser (),
-            textureUnit = browser .getTexture2DUnit ();
+         const textureUnit = browser .getTexture2DUnit ();
 
          gl .lineWidth (this .linewidthScaleFactor);
-         gl .uniform1i (shaderObject .x3d_LinePropertiesApplied,  true);
          gl .uniform1i (shaderObject .x3d_LinePropertiesLinetype, this .linetype);
+         gl .uniform1f (shaderObject .x3d_LineStippleScale,       browser .getLineStippleScale ());
 
          gl .activeTexture (gl .TEXTURE0 + textureUnit);
          gl .bindTexture (gl .TEXTURE_2D, browser .getLinetypeTexture () .getTexture ());
@@ -150,8 +155,9 @@ LineProperties .prototype = Object .assign (Object .create (X3DAppearanceChildNo
       }
       else
       {
-         gl .lineWidth (1);
-         gl .uniform1i (shaderObject .x3d_LinePropertiesApplied, false);
+         gl .lineWidth (browser .getRenderingProperty ("ContentScale"));
+         gl .uniform1i (shaderObject .x3d_LinePropertiesLinetype, 16);
+         gl .uniform1f (shaderObject .x3d_LineStippleScale,       1);
       }
    },
 });