scale geometric error with tileset

Source/Core/Matrix3.js

@@ -1023,6 +1023,28 @@ define([
         return result;
     };
 
+    var UNIT = new Cartesian3(1, 1, 1);
+    var scaleVector = new Cartesian3();
+
+    /**
+     * Factors rotation matrix from arbitrary Matrix3 by dividing components by scale
+     *
+     * @param {Matrix3} rotation-scale matrix
+     * @param {Matrix3} result rotation matrix with unit scale
+     * @returns {Matrix3} The modified result parameter.
+     */
+    Matrix3.getRotation = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.typeOf.object('matrix', matrix);
+        Check.typeOf.object('result', result);
+        //>>includeEnd('debug');
+
+        var inverseScale = Cartesian3.divideComponents(UNIT, Matrix3.getScale(matrix, scaleVector), scaleVector);
+        result = Matrix3.multiplyByScale(matrix, inverseScale, result);
+
+        return result;
+    };
+
     function computeFrobeniusNorm(matrix) {
         var norm = 0.0;
         for (var i = 0; i < 9; ++i) {

Source/Renderer/UniformState.js

@@ -1254,6 +1254,7 @@ define([
 
             var m = uniformState._normal;
             Matrix4.getRotation(uniformState.inverseModelView, m);
+            Matrix3.getRotation(m, m);
             Matrix3.transpose(m, m);
         }
     }
@@ -1271,15 +1272,13 @@ define([
     function cleanInverseNormal(uniformState) {
         if (uniformState._inverseNormalDirty) {
             uniformState._inverseNormalDirty = false;
-
             Matrix4.getRotation(uniformState.inverseModelView, uniformState._inverseNormal);
         }
     }
 
     function cleanInverseNormal3D(uniformState) {
         if (uniformState._inverseNormal3DDirty) {
             uniformState._inverseNormal3DDirty = false;
-
             Matrix4.getRotation(uniformState.inverseModelView3D, uniformState._inverseNormal3D);
         }
     }

Source/Scene/Cesium3DTile.js

@@ -139,13 +139,15 @@ define([
          * @type {Number}
          * @readonly
          */
-        this.geometricError = header.geometricError;
+        this._geometricError = header.geometricError;
 
-        if (!defined(this.geometricError)) {
-            this.geometricError = defined(parent) ? parent.geometricError : tileset._geometricError;
+        if (!defined(this._geometricError)) {
+            this._geometricError = defined(parent) ? parent.geometricError : tileset._geometricError;
             Cesium3DTile._deprecationWarning('geometricErrorUndefined', 'Required property geometricError is undefined for this tile. Using parent\'s geometric error instead.');
         }
 
+        this.updateGeometricErrorScale();
+
         var refine;
         if (defined(header.refine)) {
             if (header.refine === 'replace' || header.refine === 'add') {
@@ -1114,12 +1116,20 @@ define([
             this._viewerRequestVolume = this.createBoundingVolume(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume);
         }
 
+        this.updateGeometricErrorScale();
+
         // Destroy the debug bounding volumes. They will be generated fresh.
         this._debugBoundingVolume = this._debugBoundingVolume && this._debugBoundingVolume.destroy();
         this._debugContentBoundingVolume = this._debugContentBoundingVolume && this._debugContentBoundingVolume.destroy();
         this._debugViewerRequestVolume = this._debugViewerRequestVolume && this._debugViewerRequestVolume.destroy();
     };
 
+    Cesium3DTile.prototype.updateGeometricErrorScale = function() {
+        var scale = Matrix4.getScale(this.computedTransform, scratchScale);
+        var uniformScale = Cartesian3.maximumComponent(scale);
+        this.geometricError = this._geometricError * uniformScale;
+    };
+
     function applyDebugSettings(tile, tileset, frameState) {
         if (!frameState.passes.render) {
             return;

Specs/Core/Matrix3Spec.js

@@ -639,6 +639,28 @@ defineSuite([
         expect(result).toEqual(expected);
     });
 
+    it('getRotation returns matrix without scale', function() {
+        var matrix = new Matrix3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
+        var result = new Matrix3();
+        var scale = new Cartesian3();
+        var expectedScale = new Cartesian3(1.0, 1.0, 1.0);
+        result = Matrix3.getRotation(matrix, result);
+        var resultScale = Matrix3.getScale(result, scale);
+        expect(resultScale).toEqualEpsilon(expectedScale, CesiumMath.EPSILON14);
+    });
+
+    it('getRotation does not modify rotation matrix', function() {
+        var tmp = new Matrix3();
+        var result = new Matrix3();
+        var rotation = Matrix3.clone(Matrix3.IDENTITY, new Matrix3());
+        Matrix3.multiply(rotation, Matrix3.fromRotationX(1.0, tmp), rotation);
+        Matrix3.multiply(rotation, Matrix3.fromRotationY(2.0, tmp), rotation);
+        Matrix3.multiply(rotation, Matrix3.fromRotationZ(3.0, tmp), rotation);
+        result = Matrix3.getRotation(rotation, result);
+        expect(rotation).toEqualEpsilon(result, CesiumMath.EPSILON14);
+        expect(rotation).not.toBe(result);
+    });
+
     it('transpose works with a result parameter that is an input result parameter', function() {
         var matrix = new Matrix3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
         var expected = new Matrix3(1.0, 4.0, 7.0, 2.0, 5.0, 8.0, 3.0, 6.0, 9.0);