Gltf 2.0

Source/Scene/ModelAnimationCache.js

@@ -1,24 +1,28 @@
 /*global define*/
 define([
         '../Core/Cartesian3',
+        '../Core/ComponentDatatype',
         '../Core/defaultValue',
         '../Core/defined',
         '../Core/LinearSpline',
         '../Core/Matrix4',
         '../Core/Quaternion',
         '../Core/QuaternionSpline',
         '../Core/WebGLConstants',
-        './getBinaryAccessor'
+        '../ThirdParty/GltfPipeline/getAccessorByteStride',
+        '../ThirdParty/GltfPipeline/numberOfComponentsForType',
     ], function(
         Cartesian3,
+        ComponentDatatype,
         defaultValue,
         defined,
         LinearSpline,
         Matrix4,
         Quaternion,
         QuaternionSpline,
         WebGLConstants,
-        getBinaryAccessor) {
+        getAccessorByteStride,
+        numberOfComponentsForType) {
     'use strict';
 
     /**
@@ -36,7 +40,7 @@ define([
         var buffer = buffers[bufferView.buffer];
 
         var byteOffset = bufferView.byteOffset + accessor.byteOffset;
-        var byteLength = accessor.count * getBinaryAccessor(accessor).componentsPerAttribute;
+        var byteLength = accessor.count * numberOfComponentsForType(accessor.type);
 
         // buffer.path will be undefined when animations are embedded.
         return model.cacheKey + '//' + defaultValue(buffer.path, '') + '/' + byteOffset + '/' + byteLength;
@@ -45,50 +49,40 @@ define([
     var cachedAnimationParameters = {
     };
 
-    var axisScratch = new Cartesian3();
-
     ModelAnimationCache.getAnimationParameterValues = function(model, accessor) {
         var key = getAccessorKey(model, accessor);
         var values = cachedAnimationParameters[key];
 
         if (!defined(values)) {
             // Cache miss
-            var loadResources = model._loadResources;
             var gltf = model.gltf;
-            var hasAxisAngle = (parseFloat(gltf.asset.version) < 1.0);
 
+            var buffers = gltf.buffers;
             var bufferViews = gltf.bufferViews;
 
             var bufferView = bufferViews[accessor.bufferView];
+            var bufferId = bufferView.buffer;
+            var buffer = buffers[bufferId];
+            var source = buffer.extras._pipeline.source;
 
             var componentType = accessor.componentType;
             var type = accessor.type;
+            var numberOfComponents = numberOfComponentsForType(type);
             var count = accessor.count;
-
-            // Convert typed array to Cesium types
-            var buffer = loadResources.getBuffer(bufferView);
-            var typedArray = getBinaryAccessor(accessor).createArrayBufferView(buffer.buffer, buffer.byteOffset + accessor.byteOffset, count);
-            var i;
-
-            if ((componentType === WebGLConstants.FLOAT) && (type === 'SCALAR')) {
-                values = typedArray;
-            }
-            else if ((componentType === WebGLConstants.FLOAT) && (type === 'VEC3')) {
-                values = new Array(count);
-                for (i = 0; i < count; ++i) {
-                    values[i] = Cartesian3.fromArray(typedArray, 3 * i);
-                }
-            } else if ((componentType === WebGLConstants.FLOAT) && (type === 'VEC4')) {
-                values = new Array(count);
-                for (i = 0; i < count; ++i) {
-                    var byteOffset = 4 * i;
-                    if (hasAxisAngle) {
-                        values[i] = Quaternion.fromAxisAngle(Cartesian3.fromArray(typedArray, byteOffset, axisScratch), typedArray[byteOffset + 3]);
-                    }
-                    else {
-                        values[i] = Quaternion.unpack(typedArray, byteOffset);
-                    }
+            var byteStride = getAccessorByteStride(accessor);
+
+            values = new Array(count);
+            var byteOffset = bufferView.byteOffset + accessor.byteOffset;
+            for (var i = 0; i < count; i++) {
+                var typedArrayView = ComponentDatatype.createArrayBufferView(componentType, source.buffer, byteOffset, numberOfComponents);
+                if (type === 'SCALAR') {
+                    values[i] = typedArrayView[0];
+                } else if (type === 'VEC3') {
+                    values[i] = Cartesian3.fromArray(typedArrayView);
+                } else if (type === 'VEC4') {
+                    values[i] = Quaternion.unpack(typedArrayView);
                 }
+                byteOffset += byteStride;
             }
             // GLTF_SPEC: Support more parameter types when glTF supports targeting materials. https://github.com/KhronosGroup/glTF/issues/142
 
@@ -117,30 +111,26 @@ define([
     };
  // END GLTF_SPEC
 
-    ModelAnimationCache.getAnimationSpline = function(model, animationName, animation, samplerName, sampler, parameterValues) {
+    ModelAnimationCache.getAnimationSpline = function(model, animationName, animation, samplerName, sampler, input, path, output) {
         var key = getAnimationSplineKey(model, animationName, samplerName);
         var spline = cachedAnimationSplines[key];
 
         if (!defined(spline)) {
-            var times = parameterValues[sampler.input];
-            var accessor = model.gltf.accessors[animation.parameters[sampler.output]];
-            var controlPoints = parameterValues[sampler.output];
+            var times = input;
+            var controlPoints = output;
 
 // GLTF_SPEC: https://github.com/KhronosGroup/glTF/issues/185
             if ((times.length === 1) && (controlPoints.length === 1)) {
                 spline = new ConstantSpline(controlPoints[0]);
             } else {
 // END GLTF_SPEC
-                var componentType = accessor.componentType;
-                var type = accessor.type;
-
                 if (sampler.interpolation === 'LINEAR') {
-                    if ((componentType === WebGLConstants.FLOAT) && (type === 'VEC3')) {
+                    if (path === 'translation' || path === 'scale') {
                         spline = new LinearSpline({
                             times : times,
                             points : controlPoints
                         });
-                    } else if ((componentType === WebGLConstants.FLOAT) && (type === 'VEC4')) {
+                    } else if (path === 'rotation') {
                         spline = new QuaternionSpline({
                             times : times,
                             points : controlPoints
@@ -169,23 +159,30 @@ define([
 
         if (!defined(matrices)) {
             // Cache miss
-
-            var loadResources = model._loadResources;
             var gltf = model.gltf;
+            var buffers = gltf.buffers;
             var bufferViews = gltf.bufferViews;
 
-            var bufferView = bufferViews[accessor.bufferView];
+            var bufferViewId = accessor.bufferView;
+            var bufferView = bufferViews[bufferViewId];
+            var bufferId = bufferView.buffer;
+            var buffer = buffers[bufferId];
+            var source = buffer.extras._pipeline.source;
 
             var componentType = accessor.componentType;
             var type = accessor.type;
             var count = accessor.count;
-            var buffer = loadResources.getBuffer(bufferView);
-            var typedArray = getBinaryAccessor(accessor).createArrayBufferView(buffer.buffer, buffer.byteOffset + accessor.byteOffset, count);
-            matrices =  new Array(count);
+            var byteStride = getAccessorByteStride(accessor);
+            var byteOffset = bufferView.byteOffset + accessor.byteOffset;
+            var numberOfComponents = numberOfComponentsForType(type);
+
+            matrices = new Array(count);
 
             if ((componentType === WebGLConstants.FLOAT) && (type === 'MAT4')) {
                 for (var i = 0; i < count; ++i) {
-                    matrices[i] = Matrix4.fromArray(typedArray, 16 * i);
+                    var typedArrayView = ComponentDatatype.createArrayBufferView(componentType, source.buffer, byteOffset, numberOfComponents);
+                    matrices[i] = Matrix4.fromArray(typedArrayView);
+                    byteOffset += byteStride;
                 }
             }
 

Source/Scene/ModelAnimationCollection.js

@@ -213,7 +213,6 @@ define([
             options.name = animationIds[i];
             scheduledAnimations.push(this.add(options));
         }
-
         return scheduledAnimations;
     };
 

Source/Scene/getAttributeOrUniformBySemantic.js

@@ -1,5 +1,8 @@
 /*global define*/
-define([], function() {
+define([
+        '../Core/defined'
+    ], function(
+        defined) {
     'use strict';
 
     /**
@@ -9,6 +12,7 @@ define([], function() {
      */
     function getAttributeOrUniformBySemantic(gltf, semantic) {
         var techniques = gltf.techniques;
+        var parameter;
         for (var techniqueName in techniques) {
             if (techniques.hasOwnProperty(techniqueName)) {
                 var technique = techniques[techniqueName];
@@ -17,14 +21,16 @@ define([], function() {
                 var uniforms = technique.uniforms;
                 for (var attributeName in attributes) {
                     if (attributes.hasOwnProperty(attributeName)) {
-                        if (parameters[attributes[attributeName]].semantic === semantic) {
+                        parameter = parameters[attributes[attributeName]];
+                        if (defined(parameter) && parameter.semantic === semantic) {
                             return attributeName;
                         }
                     }
                 }
                 for (var uniformName in uniforms) {
                     if (uniforms.hasOwnProperty(uniformName)) {
-                        if (parameters[uniforms[uniformName]].semantic === semantic) {
+                        parameter = parameters[uniforms[uniformName]];
+                        if (defined(parameter) && parameter.semantic === semantic) {
                             return uniformName;
                         }
                     }