Dont duplicate resources

lib/writeResources.js

@@ -43,15 +43,18 @@ function writeResources(gltf, options) {
     options.separateShaders = defaultValue(options.separateShaders, false);
     options.dataUris = defaultValue(options.dataUris, false);
 
+    // Remember which of the resources have been written, so we can re-use them.
+    const writtenResourceMap = {};
+
     ForEach.image(gltf, function(image, i) {
-        writeImage(gltf, image, i, options);
+        writeImage(gltf, image, i, writtenResourceMap, options);
         ForEach.compressedImage(image, function(compressedImage) {
             writeImage(gltf, compressedImage, i, options);
         });
     });
 
     ForEach.shader(gltf, function(shader, i) {
-        writeShader(gltf, shader, i, options);
+        writeShader(gltf, shader, i, writtenResourceMap, options);
     });
 
     // Buffers need to be written last because images and shaders may write to new buffers
@@ -68,7 +71,7 @@ function writeBuffer(gltf, buffer, i, options) {
     if (defined(options.bufferStorage) && !options.separateBuffers) {
         writeBufferStorage(buffer, options);
     } else {
-        writeResource(gltf, buffer, i, options.separateBuffers, true, '.bin', options);
+        writeResource(gltf, buffer, i, options.separateBuffers, true, '.bin', undefined, options);
     }
 }
 
@@ -79,26 +82,26 @@ function writeBufferStorage(buffer, options) {
     options.bufferStorage.buffer = combinedBuffer;
 }
 
-function writeImage(gltf, image, i, options) {
+function writeImage(gltf, image, i, writtenResourceMap, options) {
     const extension = getImageExtension(image.extras._pipeline.source);
-    writeResource(gltf, image, i, options.separateTextures, options.dataUris, extension, options);
+    writeResource(gltf, image, i, options.separateTextures, options.dataUris, extension, writtenResourceMap, options);
     if (defined(image.bufferView)) {
         // Preserve the image mime type when writing to a buffer view
         image.mimeType = mime.getType(extension);
     }
 }
 
-function writeShader(gltf, shader, i, options) {
-    writeResource(gltf, shader, i, options.separateShaders, options.dataUris, '.glsl', options);
+function writeShader(gltf, shader, i, writtenResourceMap, options) {
+    writeResource(gltf, shader, i, options.separateShaders, options.dataUris, '.glsl', writtenResourceMap, options);
 }
 
-function writeResource(gltf, object, index, separate, dataUris, extension, options) {
+function writeResource(gltf, object, index, separate, dataUris, extension, writtenResourceMap, options) {
     if (separate) {
-        writeFile(gltf, object, index, extension, options);
+        writeFile(gltf, object, index, extension, writtenResourceMap, options);
     } else if (dataUris) {
         writeDataUri(object, extension);
     } else {
-        writeBufferView(gltf, object);
+        writeBufferView(gltf, object, writtenResourceMap);
     }
 }
 
@@ -109,13 +112,26 @@ function writeDataUri(object, extension) {
     object.uri = 'data:' + mimeType + ';base64,' + source.toString('base64');
 }
 
-function writeBufferView(gltf, object) {
+function writeBufferView(gltf, object, writtenResourceMap) {
     delete object.uri;
+
+    // If we've written this resource before, re-use the bufferView
+    const originalPathOrBufferView = defaultValue(object.extras._pipeline.absolutePath, object.bufferView);
+    if (defined(originalPathOrBufferView) && defined(writtenResourceMap[originalPathOrBufferView])) {
+        object.bufferView = writtenResourceMap[originalPathOrBufferView];
+        return;
+    }
+
     let source = object.extras._pipeline.source;
     if (typeof source === 'string') {
         source = Buffer.from(source);
     }
     object.bufferView = addBuffer(gltf, source);
+
+    // Save the bufferView so we can re-use it later
+    if (defined(originalPathOrBufferView)) {
+        writtenResourceMap[originalPathOrBufferView] = object.bufferView;
+    }
 }
 
 function getProgram(gltf, shaderIndex) {
@@ -179,12 +195,26 @@ function getRelativePath(gltf, object, index, extension, options) {
     return relativePath;
 }
 
-function writeFile(gltf, object, index, extension, options) {
+function writeFile(gltf, object, index, extension, writtenResourceMap, options) {
+    const bufferView = object.bufferView;
     delete object.bufferView;
+
+    // If we've written this resource before, re-use the uri
+    const originalPathOrBufferView = defaultValue(object.extras._pipeline.absolutePath, bufferView);
+    if (defined(originalPathOrBufferView) && defined(writtenResourceMap[originalPathOrBufferView])) {
+        object.uri = writtenResourceMap[originalPathOrBufferView];
+        return;
+    }
+
     const source = object.extras._pipeline.source;
     const relativePath = getRelativePath(gltf, object, index, extension, options);
     object.uri = relativePath;
     if (defined(options.separateResources)) {
         options.separateResources[relativePath] = source;
     }
+
+    // Save the uri so we can re-use it later
+    if (defined(originalPathOrBufferView)) {
+        writtenResourceMap[originalPathOrBufferView] = object.uri;
+    }
 }

specs/data/2.0/box-shared-image-references-separate/CesiumTexturedBoxTest0FS.glsl

@@ -0,0 +1,18 @@
+precision highp float;
+varying vec3 v_normal;
+varying vec2 v_texcoord0;
+uniform sampler2D u_diffuse;
+uniform vec4 u_specular;
+uniform float u_shininess;
+void main(void) {
+vec3 normal = normalize(v_normal);
+vec4 color = vec4(0., 0., 0., 0.);
+vec4 diffuse = vec4(0., 0., 0., 1.);
+vec4 specular;
+diffuse = texture2D(u_diffuse, v_texcoord0);
+specular = u_specular;
+diffuse.xyz *= max(dot(normal,vec3(0.,0.,1.)), 0.);
+color.xyz += diffuse.xyz;
+color = vec4(color.rgb * diffuse.a, diffuse.a);
+gl_FragColor = color;
+}

specs/data/2.0/box-shared-image-references-separate/CesiumTexturedBoxTest0VS.glsl

@@ -0,0 +1,15 @@
+precision highp float;
+attribute vec3 a_position;
+attribute vec3 a_normal;
+varying vec3 v_normal;
+uniform mat3 u_normalMatrix;
+uniform mat4 u_modelViewMatrix;
+uniform mat4 u_projectionMatrix;
+attribute vec2 a_texcoord0;
+varying vec2 v_texcoord0;
+void main(void) {
+vec4 pos = u_modelViewMatrix * vec4(a_position,1.0);
+v_normal = u_normalMatrix * a_normal;
+v_texcoord0 = a_texcoord0;
+gl_Position = u_projectionMatrix * pos;
+}