Handle 'hard' normal generation

lib/generateNormals.js

@@ -13,15 +13,84 @@ var writeAccessor = require('./writeAccessor');
 
 module.exports = generateNormals;
 
+
+function hardNormals(oldPositions, indices) {
+    // Unpack reused positions and find center
+    var indicesLength = indices.length;
+    var positions = new Array(indicesLength);
+    var normals = new Array(indicesLength);
+    var maxIndex = 0;
+    var index;
+    var i;
+    for (i = 0; i < indicesLength; i++) {
+        index = indices[i];
+        maxIndex = Math.max(maxIndex, index);
+    }
+    var seenIndices = {};
+    var nextIndex = maxIndex + 1;
+    for (i = 0; i < indicesLength; i++) {
+        index = indices[i];
+        var position = oldPositions[index];
+        if (defined(seenIndices[index])) {
+            positions[nextIndex] = position;
+            indices[i] = nextIndex;
+            nextIndex++;
+        } else {
+            positions[index] = position;
+            seenIndices[index] = true;
+        }
+    }
+
+    // Add face normal to each vertex normal
+    for (i = 0; i < indicesLength; i += 3) {
+        var index1 = indices[i];
+        var index2 = indices[i + 1];
+        var index3 = indices[i + 2];
+        var faceNormal = getFaceNormal(positions[index1], positions[index2], positions[index3]);
+        normals[index1] = faceNormal;
+        normals[index2] = faceNormal.clone();
+        normals[index3] = faceNormal.clone();
+    }
+    return {
+        normals : normals,
+        positions : positions
+    };
+}
+
+function softNormals(positions, indices) {
+    // Generate one normal for each position
+    var normalsLength = positions.length;
+    var trianglesLength = indices.length / 3;
+
+    // Initialize the normals to 0
+    var normals = new Array(normalsLength);
+    for (var i  = 0; i < normalsLength; i++) {
+        normals[i] = new Cartesian3();
+    }
+
+    // Add face normal to each vertex normal
+    for (i = 0; i < trianglesLength; ++i) {
+        var index1 = indices[i * 3 + 0];
+        var index2 = indices[i * 3 + 1];
+        var index3 = indices[i * 3 + 2];
+        var faceNormal = getFaceNormal(positions[index1], positions[index2], positions[index3]);
+        Cartesian3.add(normals[index1], faceNormal, normals[index1]);
+        Cartesian3.add(normals[index2], faceNormal, normals[index2]);
+        Cartesian3.add(normals[index3], faceNormal, normals[index3]);
+    }
+
+    return normals
+}
+
 /**
  * Generates normals for primitives if they do not exist.
  *
  * @param gltf
+ * @param {boolean} isHard
  */
-function generateNormals(gltf) {
+function generateNormals(gltf, isHard) {
     var i;
     var j;
-    var index;
     var position;
     var normal;
     var generatedNormals = false;
@@ -37,57 +106,30 @@ function generateNormals(gltf) {
             var indicesAccessor = gltf.accessors[indicesAccessorId];
             var positionAccessor = gltf.accessors[positionAccessorId];
             var indices = readAccessor(gltf, indicesAccessor).data;
-            var oldPositions = readAccessor(gltf, positionAccessor).data;
-
-            // Unpack reused positions and find center
-            var indicesLength = indices.length;
-            var positions = new Array(indicesLength);
-            var normals = new Array(indicesLength);
-            var maxIndex = 0;
-            for (j = 0; j < indicesLength; j++) {
-                index = indices[j];
-                maxIndex = Math.max(maxIndex, index);
-            }
-            var seenIndices = {};
-            var nextIndex = maxIndex + 1;
-            var center = new Cartesian3();
-            for (j = 0; j < indicesLength; j++) {
-                index = indices[j];
-                position = oldPositions[index];
-                if (defined(seenIndices[index])) {
-                    positions[nextIndex] = position;
-                    indices[j] = nextIndex;
-                    nextIndex++;
-                } else {
-                    positions[index] = position;
-                    seenIndices[index] = true;
-                }
-                Cartesian3.add(center, position, center);
-            }
-            Cartesian3.divideByScalar(center, indicesLength, center);
-
-            // Add face normal to each vertex normal
-            for (j = 0; j < indicesLength; j += 3) {
-                var index1 = indices[j];
-                var index2 = indices[j + 1];
-                var index3 = indices[j + 2];
-                var faceNormal = getFaceNormal(positions[index1], positions[index2], positions[index3]);
-                normals[index1] = faceNormal;
-                normals[index2] = faceNormal.clone();
-                normals[index3] = faceNormal.clone();
+            var positions = readAccessor(gltf, positionAccessor).data;
+            var normals;
+
+
+            if (isHard) {
+                var results = hardNormals(positions, indices);
+                normals = results.normals;
+                positions = results.positions;
+            } else {
+                normals = softNormals(positions, indices);
             }
 
             // Normalize the normals
-            for (j = 0; j < indicesLength; ++j) {
+            var normalsLength = normals.length;
+            for (j = 0; j < normalsLength; ++j) {
                 normal = normals[j];
                 Cartesian3.normalize(normal, normal);
             }
 
             // Place positions and normals into a buffer
-            var bufferLength = indicesLength * 3 * 4;
+            var bufferLength = normalsLength * 3 * 4;
             var normalsBuffer = new Buffer(bufferLength);
             var positionBuffer = new Buffer(bufferLength);
-            for (j = 0; j < indicesLength; ++j) {
+            for (j = 0; j < normalsLength; ++j) {
                 normal = normals[j];
                 normalsBuffer.writeFloatLE(normal.x, (j * 3 + 0) * 4);
                 normalsBuffer.writeFloatLE(normal.y, (j * 3 + 1) * 4);
@@ -146,7 +188,7 @@ function generateNormals(gltf) {
                 byteOffset : 0,
                 byteStride : 0,
                 componentType : WebGLConstants.FLOAT,
-                count : indicesLength,
+                count : normalsLength,
                 type : 'VEC3'
             };
             gltf.accessors[normalAccessorId] = normalAccessor;
@@ -156,7 +198,7 @@ function generateNormals(gltf) {
                 byteOffset : 0,
                 byteStride : 0,
                 componentType : WebGLConstants.FLOAT,
-                count : indicesLength,
+                count : positions.length,
                 type : 'VEC3'
             };
             gltf.accessors[positionAccessorId] = positionAccessor;

lib/gltfPipeline.js

@@ -59,10 +59,11 @@ function processJSON(gltf, options, callback) {
 }
 
 function processJSONWithExtras(gltfWithExtras, options, callback) {
+    var hard = defaultValue(options.hardNormals, false);
     var stats = new OptimizationStatistics();
     addDefaults(gltfWithExtras, stats);
     removeUnused(gltfWithExtras, stats);
-    generateNormals(gltfWithExtras);
+    generateNormals(gltfWithExtras, hard);
     if (options.printStats) {
         printStats(stats);
     }