checkout some files

dist/preview release/loaders/babylon.glTFFileLoader.d.ts

@@ -3,8 +3,6 @@ declare module BABYLON {
     interface IGLTFLoaderData {
         json: Object;
         bin: ArrayBufferView;
-<<<<<<< HEAD
-=======
     }
     interface IGLTFLoader {
         importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onsuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onerror: () => void) => void;
@@ -40,30 +38,11 @@ declare module BABYLON.GLTF1 {
         SHORT = 5122,
         UNSIGNED_SHORT = 5123,
         FLOAT = 5126,
->>>>>>> upstream/master
     }
-    interface IGLTFLoader {
-        importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onsuccess?: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onerror?: () => void) => boolean;
-        loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onsuccess: () => void, onerror: () => void) => boolean;
+    enum EShaderType {
+        FRAGMENT = 35632,
+        VERTEX = 35633,
     }
-<<<<<<< HEAD
-    class GLTFFileLoader implements ISceneLoaderPluginAsync {
-        static GLTFLoaderV1: IGLTFLoader;
-        static GLTFLoaderV2: IGLTFLoader;
-        static HomogeneousCoordinates: boolean;
-        static IncrementalLoading: boolean;
-        extensions: ISceneLoaderPluginExtensions;
-        importMeshAsync(meshesNames: any, scene: Scene, data: any, rootUrl: string, onSuccess?: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onError?: () => void): boolean;
-        loadAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string, onSuccess: () => void, onError: () => void): boolean;
-        private static _parse(data);
-        private _getLoader(loaderData);
-        private static _parseBinary(data);
-        private static _parseV1(binaryReader);
-        private static _parseV2(binaryReader);
-        private static _parseVersion(version);
-        private static _compareVersion(a, b);
-        private static _decodeBufferToText(view);
-=======
     enum EParameterType {
         BYTE = 5120,
         UNSIGNED_BYTE = 5121,
@@ -540,7 +519,6 @@ declare module BABYLON.GLTF1 {
         loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError: () => void): boolean;
         loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: () => void): boolean;
         private _loadTexture(gltfRuntime, id, material, propertyPath, onError);
->>>>>>> upstream/master
     }
 }
 

dist/preview release/loaders/babylon.glTFFileLoader.js

@@ -12,220 +12,6 @@ var BABYLON;
             var loaderData = GLTFFileLoader._parse(data);
             var loader = this._getLoader(loaderData);
             if (!loader) {
-<<<<<<< HEAD
-                return false;
-            }
-            return loader.importMeshAsync(meshesNames, scene, loaderData, rootUrl, onSuccess, onError);
-        };
-        GLTFFileLoader.prototype.loadAsync = function (scene, data, rootUrl, onSuccess, onError) {
-            var loaderData = GLTFFileLoader._parse(data);
-            var loader = this._getLoader(loaderData);
-            if (!loader) {
-                return false;
-            }
-            return loader.loadAsync(scene, loaderData, rootUrl, onSuccess, onError);
-        };
-        GLTFFileLoader._parse = function (data) {
-            if (data instanceof ArrayBuffer) {
-                return GLTFFileLoader._parseBinary(data);
-            }
-            return {
-                json: JSON.parse(data),
-                bin: null
-            };
-        };
-        GLTFFileLoader.prototype._getLoader = function (loaderData) {
-            var loaderVersion = { major: 2, minor: 0 };
-            var asset = loaderData.json.asset || {};
-            var version = GLTFFileLoader._parseVersion(asset.version);
-            if (!version) {
-                BABYLON.Tools.Error("Invalid version");
-                return null;
-            }
-            var minVersion = GLTFFileLoader._parseVersion(asset.minVersion);
-            if (minVersion) {
-                if (GLTFFileLoader._compareVersion(minVersion, loaderVersion) > 0) {
-                    BABYLON.Tools.Error("Incompatible version");
-                    return null;
-                }
-            }
-            var loaders = {
-                1: GLTFFileLoader.GLTFLoaderV1,
-                2: GLTFFileLoader.GLTFLoaderV2
-            };
-            var loader = loaders[version.major];
-            if (loader === undefined) {
-                BABYLON.Tools.Error("Unsupported version");
-                return null;
-            }
-            if (loader === null) {
-                BABYLON.Tools.Error("v" + version.major + " loader is not available");
-                return null;
-            }
-            return loader;
-        };
-        GLTFFileLoader._parseBinary = function (data) {
-            var Binary = {
-                Magic: 0x46546C67
-            };
-            var binaryReader = new BinaryReader(data);
-            var magic = binaryReader.readUint32();
-            if (magic !== Binary.Magic) {
-                BABYLON.Tools.Error("Unexpected magic: " + magic);
-                return null;
-            }
-            var version = binaryReader.readUint32();
-            switch (version) {
-                case 1: return GLTFFileLoader._parseV1(binaryReader);
-                case 2: return GLTFFileLoader._parseV2(binaryReader);
-            }
-            BABYLON.Tools.Error("Unsupported version: " + version);
-            return null;
-        };
-        GLTFFileLoader._parseV1 = function (binaryReader) {
-            var ContentFormat = {
-                JSON: 0
-            };
-            var length = binaryReader.readUint32();
-            if (length != binaryReader.getLength()) {
-                BABYLON.Tools.Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength());
-                return null;
-            }
-            var contentLength = binaryReader.readUint32();
-            var contentFormat = binaryReader.readUint32();
-            var content;
-            switch (contentFormat) {
-                case ContentFormat.JSON:
-                    content = JSON.parse(GLTFFileLoader._decodeBufferToText(binaryReader.readUint8Array(contentLength)));
-                    break;
-                default:
-                    BABYLON.Tools.Error("Unexpected content format: " + contentFormat);
-                    return null;
-            }
-            var bytesRemaining = binaryReader.getLength() - binaryReader.getPosition();
-            var body = binaryReader.readUint8Array(bytesRemaining);
-            return {
-                json: content,
-                bin: body
-            };
-        };
-        GLTFFileLoader._parseV2 = function (binaryReader) {
-            var ChunkFormat = {
-                JSON: 0x4E4F534A,
-                BIN: 0x004E4942
-            };
-            var length = binaryReader.readUint32();
-            if (length !== binaryReader.getLength()) {
-                BABYLON.Tools.Error("Length in header does not match actual data length: " + length + " != " + binaryReader.getLength());
-                return null;
-            }
-            // JSON chunk
-            var chunkLength = binaryReader.readUint32();
-            var chunkFormat = binaryReader.readUint32();
-            if (chunkFormat !== ChunkFormat.JSON) {
-                BABYLON.Tools.Error("First chunk format is not JSON");
-                return null;
-            }
-            var json = JSON.parse(GLTFFileLoader._decodeBufferToText(binaryReader.readUint8Array(chunkLength)));
-            // Look for BIN chunk
-            var bin = null;
-            while (binaryReader.getPosition() < binaryReader.getLength()) {
-                chunkLength = binaryReader.readUint32();
-                chunkFormat = binaryReader.readUint32();
-                switch (chunkFormat) {
-                    case ChunkFormat.JSON:
-                        BABYLON.Tools.Error("Unexpected JSON chunk");
-                        return null;
-                    case ChunkFormat.BIN:
-                        bin = binaryReader.readUint8Array(chunkLength);
-                        break;
-                    default:
-                        // ignore unrecognized chunkFormat
-                        binaryReader.skipBytes(chunkLength);
-                        break;
-                }
-            }
-            return {
-                json: json,
-                bin: bin
-            };
-        };
-        GLTFFileLoader._parseVersion = function (version) {
-            if (!version) {
-                return null;
-            }
-            var parts = version.split(".");
-            if (parts.length === 0) {
-                return null;
-            }
-            var major = parseInt(parts[0]);
-            if (major > 1 && parts.length != 2) {
-                return null;
-            }
-            var minor = parseInt(parts[1]);
-            return {
-                major: major,
-                minor: parseInt(parts[0])
-            };
-        };
-        GLTFFileLoader._compareVersion = function (a, b) {
-            if (a.major > b.major)
-                return 1;
-            if (a.major < b.major)
-                return -1;
-            if (a.minor > b.minor)
-                return 1;
-            if (a.minor < b.minor)
-                return -1;
-            return 0;
-        };
-        GLTFFileLoader._decodeBufferToText = function (view) {
-            var result = "";
-            var length = view.byteLength;
-            for (var i = 0; i < length; ++i) {
-                result += String.fromCharCode(view[i]);
-            }
-            return result;
-        };
-        return GLTFFileLoader;
-    }());
-    GLTFFileLoader.GLTFLoaderV1 = null;
-    GLTFFileLoader.GLTFLoaderV2 = null;
-    GLTFFileLoader.HomogeneousCoordinates = false;
-    GLTFFileLoader.IncrementalLoading = true;
-    BABYLON.GLTFFileLoader = GLTFFileLoader;
-    var BinaryReader = (function () {
-        function BinaryReader(arrayBuffer) {
-            this._arrayBuffer = arrayBuffer;
-            this._dataView = new DataView(arrayBuffer);
-            this._byteOffset = 0;
-        }
-        BinaryReader.prototype.getPosition = function () {
-            return this._byteOffset;
-        };
-        BinaryReader.prototype.getLength = function () {
-            return this._arrayBuffer.byteLength;
-        };
-        BinaryReader.prototype.readUint32 = function () {
-            var value = this._dataView.getUint32(this._byteOffset, true);
-            this._byteOffset += 4;
-            return value;
-        };
-        BinaryReader.prototype.readUint8Array = function (length) {
-            var value = new Uint8Array(this._arrayBuffer, this._byteOffset, length);
-            this._byteOffset += length;
-            return value;
-        };
-        BinaryReader.prototype.skipBytes = function (length) {
-            this._byteOffset += length;
-        };
-        return BinaryReader;
-    }());
-    BABYLON.SceneLoader.RegisterPlugin(new GLTFFileLoader());
-})(BABYLON || (BABYLON = {}));
-
-//# sourceMappingURL=babylon.glTFFileLoader.js.map
-=======
                 onError();
                 return;
             }
@@ -4027,4 +3813,3 @@ var BABYLON;
 })(BABYLON || (BABYLON = {}));
 
 //# sourceMappingURL=babylon.glTFMaterialsPbrSpecularGlossinessExtension.js.map
->>>>>>> upstream/master