x_ite 5.0.3 → 6.1.0

package/src/x_ite/Components/Grouping/X3DTransformNode.js

@@ -79,10 +79,6 @@ function (X3DTransformMatrix3DNode,
       },
       eventsProcessed: function ()
       {
-         this .setHidden (this ._scale .x === 0 ||
-                          this ._scale .y === 0 ||
-                          this ._scale .z === 0);
-
          this .setTransform (this ._translation      .getValue (),
                              this ._rotation         .getValue (),
                              this ._scale            .getValue (),

package/src/x_ite/Components/HAnim/HAnimHumanoid.js

@@ -255,103 +255,96 @@ function (Fields,
 
          return function (type, renderObject)
          {
-            try
-            {
-               if (type !== TraverseType .CAMERA)
-                  return;
+            if (type !== TraverseType .CAMERA)
+               return;
 
-               if (! this .skinCoordNode)
-                  return;
+            if (! this .skinCoordNode)
+               return;
 
-               var
-                  jointNodes     = this .jointNodes,
-                  skinNormalNode = this .skinNormalNode,
-                  skinCoordNode  = this .skinCoordNode,
-                  restNormalNode = this .restNormalNode,
-                  restCoordNode  = this .restCoordNode;
+            var
+               jointNodes     = this .jointNodes,
+               skinNormalNode = this .skinNormalNode,
+               skinCoordNode  = this .skinCoordNode,
+               restNormalNode = this .restNormalNode,
+               restCoordNode  = this .restCoordNode;
 
-               // Reset skin normals and coords.
+            // Reset skin normals and coords.
 
-               if (skinNormalNode)
-                  skinNormalNode ._vector .assign (restNormalNode ._vector);
+            if (skinNormalNode)
+               skinNormalNode ._vector .assign (restNormalNode ._vector);
 
-               skinCoordNode ._point .assign (restCoordNode ._point);
+            skinCoordNode ._point .assign (restCoordNode ._point);
 
-               // Determine inverse model matrix of humanoid.
+            // Determine inverse model matrix of humanoid.
 
-               invModelMatrix .assign (this .transformNode .getMatrix ()) .multRight (renderObject .getModelViewMatrix () .get ()) .inverse ();
+            invModelMatrix .assign (this .transformNode .getMatrix ()) .multRight (renderObject .getModelViewMatrix () .get ()) .inverse ();
 
-               // Apply joint transformations.
+            // Apply joint transformations.
 
-               for (var j = 0, jointNodesLength = jointNodes .length; j < jointNodesLength; ++ j)
-               {
-                  var
-                     jointNode            = jointNodes [j],
-                     skinCoordIndexLength = jointNode ._skinCoordIndex .length;
+            for (var j = 0, jointNodesLength = jointNodes .length; j < jointNodesLength; ++ j)
+            {
+               var
+                  jointNode            = jointNodes [j],
+                  skinCoordIndexLength = jointNode ._skinCoordIndex .length;
 
-                  if (skinCoordIndexLength === 0)
-                     continue;
+               if (skinCoordIndexLength === 0)
+                  continue;
 
-                  var
-                     jointMatrix    = jointNode .getModelMatrix () .multRight (invModelMatrix),
-                     displacerNodes = jointNode .getDisplacers ();
+               var
+                  jointMatrix    = jointNode .getModelMatrix () .multRight (invModelMatrix),
+                  displacerNodes = jointNode .getDisplacers ();
 
-                  for (var d = 0, displacerNodesLength = displacerNodes .length; d < displacerNodesLength; ++ d)
+               for (var d = 0, displacerNodesLength = displacerNodes .length; d < displacerNodesLength; ++ d)
+               {
+                  var
+                     displacerNode       = displacerNodes [d],
+                     coordIndex          = displacerNode ._coordIndex .getValue (),
+                     coordIndexLength    = displacerNode ._coordIndex .length,
+                     weight              = displacerNode ._weight .getValue (),
+                     displacements       = displacerNode ._displacements .getValue (),
+                     displacementsLength = displacerNode ._displacements .length;
+
+                  for (var i = 0; i < coordIndexLength; ++ i)
                   {
                      var
-                        displacerNode       = displacerNodes [d],
-                        coordIndex          = displacerNode ._coordIndex .getValue (),
-                        coordIndexLength    = displacerNode ._coordIndex .length,
-                        weight              = displacerNode ._weight .getValue (),
-                        displacements       = displacerNode ._displacements .getValue (),
-                        displacementsLength = displacerNode ._displacements .length;
-
-                     for (var i = 0; i < coordIndexLength; ++ i)
-                     {
-                        var
-                           i3           = i * 3,
-                           index        = coordIndex [i],
-                           displacement = i < displacementsLength ? point .set (displacements [i3], displacements [i3 + 1], displacements [i3 + 2]) : point .assign (Vector3 .Zero);
-
-                        skinCoordNode .get1Point (index, skin);
-                        jointMatrix .multDirMatrix (displacement) .multiply (weight) .add (skin);
-                        skinCoordNode .set1Point (index, displacement);
-                     }
+                        i3           = i * 3,
+                        index        = coordIndex [i],
+                        displacement = i < displacementsLength ? point .set (displacements [i3], displacements [i3 + 1], displacements [i3 + 2]) : point .assign (Vector3 .Zero);
+
+                     skinCoordNode .get1Point (index, skin);
+                     jointMatrix .multDirMatrix (displacement) .multiply (weight) .add (skin);
+                     skinCoordNode .set1Point (index, displacement);
                   }
+               }
 
+               var
+                  normalMatrix          = skinNormalNode ? jointMatrix .submatrix .transpose () .inverse () : null,
+                  skinCoordIndex        = jointNode ._skinCoordIndex .getValue (),
+                  skinCoordWeight       = jointNode ._skinCoordWeight .getValue (),
+                  skinCoordWeightLength = jointNode ._skinCoordWeight .length;
+
+               for (var i = 0; i < skinCoordIndexLength; ++ i)
+               {
                   var
-                     normalMatrix          = skinNormalNode ? jointMatrix .submatrix .transpose () .inverse () : null,
-                     skinCoordIndex        = jointNode ._skinCoordIndex .getValue (),
-                     skinCoordWeight       = jointNode ._skinCoordWeight .getValue (),
-                     skinCoordWeightLength = jointNode ._skinCoordWeight .length;
+                     index  = skinCoordIndex [i],
+                     weight = i < skinCoordWeightLength ? skinCoordWeight [i] : 1;
 
-                  for (var i = 0; i < skinCoordIndexLength; ++ i)
+                  if (skinNormalNode)
                   {
-                     var
-                        index  = skinCoordIndex [i],
-                        weight = i < skinCoordWeightLength ? skinCoordWeight [i] : 1;
-
-                     if (skinNormalNode)
-                     {
-                        rest .assign (restNormalNode .get1Vector (index, vector));
-                        skinNormalNode .get1Vector (index, skin);
-                        normalMatrix .multVecMatrix (vector) .subtract (rest) .multiply (weight) .add (skin);
-                        skinNormalNode .set1Vector (index, vector);
-                        // Should the normals be normalzed at end, or let it the shader do?
-                     }
-
-                     //skin += (rest * J - rest) * weight
-                     rest .assign (restCoordNode .get1Point (index, point));
-                     skinCoordNode .get1Point (index, skin);
-                     jointMatrix .multVecMatrix (point) .subtract (rest) .multiply (weight) .add (skin);
-                     skinCoordNode .set1Point (index, point);
+                     rest .assign (restNormalNode .get1Vector (index, vector));
+                     skinNormalNode .get1Vector (index, skin);
+                     normalMatrix .multVecMatrix (vector) .subtract (rest) .multiply (weight) .add (skin);
+                     skinNormalNode .set1Vector (index, vector);
+                     // Should the normals be normalized at end, or let it the shader do?
                   }
+
+                  //skin += (rest * J - rest) * weight
+                  rest .assign (restCoordNode .get1Point (index, point));
+                  skinCoordNode .get1Point (index, skin);
+                  jointMatrix .multVecMatrix (point) .subtract (rest) .multiply (weight) .add (skin);
+                  skinCoordNode .set1Point (index, point);
                }
             }
-            catch (error)
-            {
-               console .error (error);
-            }
          };
       })(),
    });

package/src/x_ite/Components/Interpolation/OrientationInterpolator.js

@@ -119,18 +119,11 @@ function (Fields,
 
          return function (index0, index1, weight)
          {
-            try
-            {
-               // Both values can change in slerp.
-               keyValue0 .assign (this ._keyValue [index0] .getValue ());
-               keyValue1 .assign (this ._keyValue [index1] .getValue ());
+            // Both values can change in slerp.
+            keyValue0 .assign (this ._keyValue [index0] .getValue ());
+            keyValue1 .assign (this ._keyValue [index1] .getValue ());
 
-               this ._value_changed = keyValue0 .slerp (keyValue1, weight);
-            }
-            catch (error)
-            {
-               //console .error (error);
-            }
+            this ._value_changed = keyValue0 .slerp (keyValue1, weight);
          };
       }) (),
    });

package/src/x_ite/Components/Interpolation/X3DInterpolatorNode.js

@@ -107,7 +107,7 @@ function (X3DChildNode,
                if (fraction <= key [0])
                   return this .interpolate (0, 1, 0);
 
-               const index1 = Algorithm .upperBound (key, 0, length, fraction, Algorithm .less);
+               const index1 = Algorithm .upperBound (key, 0, length, fraction);
 
                if (index1 !== length)
                {

package/src/x_ite/Components/Layout/LayoutGroup.js

@@ -131,15 +131,10 @@ function (Fields,
       },
       getMatrix: function ()
       {
-         try
-         {
-            if (this .layoutNode)
-               this .matrix .assign (this .modelViewMatrix) .inverse () .multLeft (this .screenMatrix);
-            else
-               this .matrix .identity ();
-         }
-         catch (error)
-         { }
+         if (this .layoutNode)
+            this .matrix .assign (this .modelViewMatrix) .inverse () .multLeft (this .screenMatrix);
+         else
+            this .matrix .identity ();
 
          return this .matrix;
       },

package/src/x_ite/Components/Layout/ScreenFontStyle.js

@@ -104,7 +104,7 @@ function (Fields,
       },
       getScale: function ()
       {
-         return this ._pointSize .getValue () * this .getBrowser () .getPointSize ();
+         return this ._pointSize .getValue () * this .getBrowser () .getPixelPerPoint ();
       },
    });
 

package/src/x_ite/Components/Layout/ScreenGroup.js

@@ -54,10 +54,7 @@ define ([
    "x_ite/Components/Grouping/X3DGroupingNode",
    "x_ite/Base/X3DConstants",
    "x_ite/Rendering/TraverseType",
-   "standard/Math/Numbers/Vector3",
-   "standard/Math/Numbers/Vector4",
    "standard/Math/Numbers/Matrix4",
-   "standard/Math/Geometry/ViewVolume",
 ],
 function (Fields,
           X3DFieldDefinition,
@@ -65,10 +62,7 @@ function (Fields,
           X3DGroupingNode,
           X3DConstants,
           TraverseType,
-          Vector3,
-          Vector4,
-          Matrix4,
-          ViewVolume)
+          Matrix4,)
 {
 "use strict";
 
@@ -114,86 +108,28 @@ function (Fields,
       {
          return this .matrix;
       },
-      scale: (function ()
-      {
-         var
-            x            = new Vector4 (0, 0, 0, 0),
-            y            = new Vector4 (0, 0, 0, 0),
-            z            = new Vector4 (0, 0, 0, 0),
-            screenPoint  = new Vector3 (0, 0, 0),
-            screenMatrix = new Matrix4 ();
-
-         return function (renderObject)
-         {
-            // throws domain error
-
-            var
-               modelViewMatrix  = renderObject .getModelViewMatrix () .get (),
-               projectionMatrix = renderObject .getProjectionMatrix () .get (),
-               viewport         = renderObject .getViewVolume () .getViewport ();
-
-            // Determine screenMatrix.
-            // Same as in ScreenText.
-
-            var screenScale = renderObject .getViewpoint () .getScreenScale (modelViewMatrix .origin, viewport); // in meter/pixel
-
-            x .set (modelViewMatrix [ 0], modelViewMatrix [ 1], modelViewMatrix [ 2], modelViewMatrix [ 3]);
-            y .set (modelViewMatrix [ 4], modelViewMatrix [ 5], modelViewMatrix [ 6], modelViewMatrix [ 7]);
-            z .set (modelViewMatrix [ 8], modelViewMatrix [ 9], modelViewMatrix [10], modelViewMatrix [11]);
-
-            x .normalize () .multiply (screenScale .x);
-            y .normalize () .multiply (screenScale .y);
-            z .normalize () .multiply (screenScale .z);
-
-            screenMatrix .set (x .x, x .y, x .z, x .w,
-                               y .x, y .y, y .z, y .w,
-                               z .x, z .y, z .z, z .w,
-                               modelViewMatrix [12], modelViewMatrix [13], modelViewMatrix [14], modelViewMatrix [15]);
-
-            // Snap to whole pixel.
-
-            ViewVolume .projectPoint (Vector3 .Zero, screenMatrix, projectionMatrix, viewport, screenPoint);
-
-            screenPoint .x = Math .round (screenPoint .x);
-            screenPoint .y = Math .round (screenPoint .y);
-
-            ViewVolume .unProjectPoint (screenPoint .x, screenPoint .y, screenPoint .z, screenMatrix, projectionMatrix, viewport, screenPoint);
-
-            screenPoint .z = 0;
-            screenMatrix .translate (screenPoint);
-
-            // Assign relative matrix.
-
-            this .matrix .assign (modelViewMatrix) .inverse () .multLeft (screenMatrix);
-         };
-      })(),
       traverse: function (type, renderObject)
       {
-         try
+         switch (type)
          {
-            switch (type)
-            {
-               case TraverseType .CAMERA:
-               case TraverseType .PICKING:
-               case TraverseType .SHADOW: // ???
-                  // No clone support for shadow, generated cube map texture and bbox
-                  break;
-               default:
-                  this .scale (renderObject);
-                  break;
-            }
+            case TraverseType .CAMERA:
+            case TraverseType .PICKING:
+            case TraverseType .SHADOW: // ???
+               // No clone support for shadow, generated cube map texture and bbox
+               break;
+            default:
+               this .getBrowser () .getScreenScaleMatrix (renderObject, this .matrix);
+               break;
+         }
 
-            var modelViewMatrix = renderObject .getModelViewMatrix ();
+         const modelViewMatrix = renderObject .getModelViewMatrix ();
 
-            modelViewMatrix .push ();
-            modelViewMatrix .multLeft (this .matrix);
+         modelViewMatrix .push ();
+         modelViewMatrix .multLeft (this .matrix);
 
-            X3DGroupingNode .prototype .traverse .call (this, type, renderObject);
+         X3DGroupingNode .prototype .traverse .call (this, type, renderObject);
 
-            modelViewMatrix .pop ();
-         }
-         catch (error)
-         { }
+         modelViewMatrix .pop ();
       },
    });
 

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

@@ -133,51 +133,43 @@ function (Fields,
       },
       renderShadowMap: function (renderObject)
       {
-         try
-         {
-            if (! this .shadowBuffer)
-               return;
+         if (! this .shadowBuffer)
+            return;
 
-            const
-               lightNode            = this .lightNode,
-               cameraSpaceMatrix    = renderObject .getCameraSpaceMatrix () .get (),
-               modelMatrix          = this .modelMatrix .assign (this .modelViewMatrix .get ()) .multRight (cameraSpaceMatrix),
-               invLightSpaceMatrix  = this .invLightSpaceMatrix .assign (lightNode .getGlobal () ? modelMatrix : Matrix4 .Identity);
+         const
+            lightNode            = this .lightNode,
+            cameraSpaceMatrix    = renderObject .getCameraSpaceMatrix () .get (),
+            modelMatrix          = this .modelMatrix .assign (this .modelViewMatrix .get ()) .multRight (cameraSpaceMatrix),
+            invLightSpaceMatrix  = this .invLightSpaceMatrix .assign (lightNode .getGlobal () ? modelMatrix : Matrix4 .Identity);
 
-            invLightSpaceMatrix .rotate (this .rotation .setFromToVec (Vector3 .zAxis, this .direction .assign (lightNode .getDirection ()) .negate ()));
-            invLightSpaceMatrix .inverse ();
+         invLightSpaceMatrix .rotate (this .rotation .setFromToVec (Vector3 .zAxis, this .direction .assign (lightNode .getDirection ()) .negate ()));
+         invLightSpaceMatrix .inverse ();
 
-            const
-               groupBBox        = this .groupNode .getSubBBox (this .bbox, true), // Group bbox.
-               lightBBox        = groupBBox .multRight (invLightSpaceMatrix),     // Group bbox from the perspective of the light.
-               shadowMapSize    = lightNode .getShadowMapSize (),
-               viewport         = this .viewport .set (0, 0, shadowMapSize, shadowMapSize),
-               projectionMatrix = Camera .orthoBox (lightBBox, this .projectionMatrix);
+         const
+            groupBBox        = this .groupNode .getSubBBox (this .bbox, true), // Group bbox.
+            lightBBox        = groupBBox .multRight (invLightSpaceMatrix),     // Group bbox from the perspective of the light.
+            shadowMapSize    = lightNode .getShadowMapSize (),
+            viewport         = this .viewport .set (0, 0, shadowMapSize, shadowMapSize),
+            projectionMatrix = Camera .orthoBox (lightBBox, this .projectionMatrix);
 
-            this .shadowBuffer .bind ();
+         this .shadowBuffer .bind ();
 
-            renderObject .getViewVolumes      () .push (this .viewVolume .set (projectionMatrix, viewport, viewport));
-            renderObject .getProjectionMatrix () .pushMatrix (projectionMatrix);
-            renderObject .getModelViewMatrix  () .pushMatrix (invLightSpaceMatrix);
+         renderObject .getViewVolumes      () .push (this .viewVolume .set (projectionMatrix, viewport, viewport));
+         renderObject .getProjectionMatrix () .pushMatrix (projectionMatrix);
+         renderObject .getModelViewMatrix  () .pushMatrix (invLightSpaceMatrix);
 
-            renderObject .render (TraverseType .SHADOW, X3DGroupingNode .prototype .traverse, this .groupNode);
+         renderObject .render (TraverseType .SHADOW, X3DGroupingNode .prototype .traverse, this .groupNode);
 
-            renderObject .getModelViewMatrix  () .pop ();
-            renderObject .getProjectionMatrix () .pop ();
-            renderObject .getViewVolumes      () .pop ();
+         renderObject .getModelViewMatrix  () .pop ();
+         renderObject .getProjectionMatrix () .pop ();
+         renderObject .getViewVolumes      () .pop ();
 
-            this .shadowBuffer .unbind ();
+         this .shadowBuffer .unbind ();
 
-            if (! lightNode .getGlobal ())
-               invLightSpaceMatrix .multLeft (modelMatrix .inverse ());
+         if (! lightNode .getGlobal ())
+            invLightSpaceMatrix .multLeft (modelMatrix .inverse ());
 
-            this .invLightSpaceProjectionMatrix .assign (invLightSpaceMatrix) .multRight (projectionMatrix) .multRight (lightNode .getBiasMatrix ());
-         }
-         catch (error)
-         {
-            // Catch error from matrix inverse.
-            console .error (error);
-         }
+         this .invLightSpaceProjectionMatrix .assign (invLightSpaceMatrix) .multRight (projectionMatrix) .multRight (lightNode .getBiasMatrix ());
       },
       setGlobalVariables: function (renderObject)
       {
@@ -224,7 +216,7 @@ function (Fields,
             {
                gl .activeTexture (gl .TEXTURE0 + this .textureUnit);
 
-               if (gl .getVersion () >= 2 || browser .getExtension ("WEBGL_depth_texture"))
+               if (gl .getVersion () >= 2 || gl .getExtension ("WEBGL_depth_texture"))
                   gl .bindTexture (gl .TEXTURE_2D, this .shadowBuffer .getDepthTexture ());
                else
                   gl .bindTexture (gl .TEXTURE_2D, this .shadowBuffer .getColorTexture ());

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

@@ -146,14 +146,7 @@ function (Fields,
          this .lightNode = lightNode;
          this .groupNode = groupNode;
 
-         try
-         {
-            this .matrixArray .set (modelViewMatrix .submatrix .inverse ());
-         }
-         catch (error)
-         {
-            this .matrixArray .set (Matrix3 .Identity);
-         }
+         this .matrixArray .set (modelViewMatrix .submatrix .inverse ());
 
          this .modelViewMatrix .pushMatrix (modelViewMatrix);
 
@@ -169,55 +162,47 @@ function (Fields,
       },
       renderShadowMap: function (renderObject)
       {
-         try
-         {
-            if (! this .shadowBuffer)
-               return;
+         if (! this .shadowBuffer)
+            return;
 
-            const
-               lightNode           = this .lightNode,
-               cameraSpaceMatrix   = renderObject .getCameraSpaceMatrix () .get (),
-               modelMatrix         = this .modelMatrix .assign (this .modelViewMatrix .get ()) .multRight (cameraSpaceMatrix),
-               invLightSpaceMatrix = this .invLightSpaceMatrix .assign (lightNode .getGlobal () ? modelMatrix : Matrix4 .Identity);
+         const
+            lightNode           = this .lightNode,
+            cameraSpaceMatrix   = renderObject .getCameraSpaceMatrix () .get (),
+            modelMatrix         = this .modelMatrix .assign (this .modelViewMatrix .get ()) .multRight (cameraSpaceMatrix),
+            invLightSpaceMatrix = this .invLightSpaceMatrix .assign (lightNode .getGlobal () ? modelMatrix : Matrix4 .Identity);
 
-            invLightSpaceMatrix .translate (lightNode .getLocation ());
-            invLightSpaceMatrix .inverse ();
+         invLightSpaceMatrix .translate (lightNode .getLocation ());
+         invLightSpaceMatrix .inverse ();
 
-            const shadowMapSize  = lightNode .getShadowMapSize ();
+         const shadowMapSize  = lightNode .getShadowMapSize ();
 
-            this .shadowBuffer .bind ();
+         this .shadowBuffer .bind ();
 
-            for (let i = 0; i < 6; ++ i)
-            {
-               const
-                  v                = viewports [i],
-                  viewport         = this .viewport .set (v [0] * shadowMapSize, v [1] * shadowMapSize, v [2] * shadowMapSize, v [3] * shadowMapSize),
-                  projectionMatrix = Camera .perspective2 (Algorithm .radians (90), 0.125, 10000, viewport [2], viewport [3], this .projectionMatrix); // Use higher far value for better precision.
+         for (let i = 0; i < 6; ++ i)
+         {
+            const
+               v                = viewports [i],
+               viewport         = this .viewport .set (v [0] * shadowMapSize, v [1] * shadowMapSize, v [2] * shadowMapSize, v [3] * shadowMapSize),
+               projectionMatrix = Camera .perspective2 (Algorithm .radians (90), 0.125, 10000, viewport [2], viewport [3], this .projectionMatrix); // Use higher far value for better precision.
 
-               renderObject .getViewVolumes      () .push (this .viewVolume .set (projectionMatrix, viewport, viewport));
-               renderObject .getProjectionMatrix () .pushMatrix (this .projectionMatrix);
-               renderObject .getModelViewMatrix  () .pushMatrix (orientationMatrices [i]);
-               renderObject .getModelViewMatrix  () .multLeft (invLightSpaceMatrix);
+            renderObject .getViewVolumes      () .push (this .viewVolume .set (projectionMatrix, viewport, viewport));
+            renderObject .getProjectionMatrix () .pushMatrix (this .projectionMatrix);
+            renderObject .getModelViewMatrix  () .pushMatrix (orientationMatrices [i]);
+            renderObject .getModelViewMatrix  () .multLeft (invLightSpaceMatrix);
 
-               renderObject .render (TraverseType .SHADOW, X3DGroupingNode .prototype .traverse, this .groupNode);
+            renderObject .render (TraverseType .SHADOW, X3DGroupingNode .prototype .traverse, this .groupNode);
 
-               renderObject .getModelViewMatrix  () .pop ();
-               renderObject .getProjectionMatrix () .pop ();
-               renderObject .getViewVolumes () .pop ();
-            }
+            renderObject .getModelViewMatrix  () .pop ();
+            renderObject .getProjectionMatrix () .pop ();
+            renderObject .getViewVolumes () .pop ();
+         }
 
-            this .shadowBuffer .unbind ();
+         this .shadowBuffer .unbind ();
 
-            if (! lightNode .getGlobal ())
-               invLightSpaceMatrix .multLeft (modelMatrix .inverse ());
+         if (! lightNode .getGlobal ())
+            invLightSpaceMatrix .multLeft (modelMatrix .inverse ());
 
-            this .invLightSpaceProjectionMatrix .assign (invLightSpaceMatrix);
-         }
-         catch (error)
-         {
-            // Catch error from matrix inverse.
-            console .error (error);
-         }
+         this .invLightSpaceProjectionMatrix .assign (invLightSpaceMatrix);
       },
       setGlobalVariables: function (renderObject)
       {
@@ -268,7 +253,7 @@ function (Fields,
             {
                gl .activeTexture (gl .TEXTURE0 + this .textureUnit);
 
-               if (gl .getVersion () >= 2 || browser .getExtension ("WEBGL_depth_texture"))
+               if (gl .getVersion () >= 2 || gl .getExtension ("WEBGL_depth_texture"))
                   gl .bindTexture (gl .TEXTURE_2D, this .shadowBuffer .getDepthTexture ());
                else
                   gl .bindTexture (gl .TEXTURE_2D, this .shadowBuffer .getColorTexture ());