@galacean/engine 0.0.0-experimental-shaderlab.0 → 0.0.0-experimental-uploadSameBuffer.0

package/dist/browser.js

@@ -6995,7 +6995,8 @@
         _proto._createFontAtlas = function _createFontAtlas() {
             var _this = this, engine = _this._engine;
             var fontAtlas = new FontAtlas(engine);
-            var texture = new Texture2D(engine, 256, 256);
+            var texture = new Texture2D(engine, 256, 256, exports.TextureFormat.R8G8B8A8, false);
+            texture.filterMode = exports.TextureFilterMode.Point;
             fontAtlas.texture = texture;
             fontAtlas.isGCIgnored = texture.isGCIgnored = true;
             this._fontAtlases.push(fontAtlas);
@@ -10824,7 +10825,6 @@
             _this = ShaderPart1.call(this) || this;
             /** @internal */ _this._shaderPassId = 0;
             /** @internal */ _this._renderStateDataMap = {};
-            /** @internal */ _this._shaderProgramPools = [];
             _this._shaderPassId = ShaderPass._shaderPassCounter++;
             if (typeof fragmentSourceOrTags === "string") {
                 _this._name = nameOrVertexSource;
@@ -10878,15 +10878,6 @@
             shaderProgramPool.cache(shaderProgram);
             return shaderProgram;
         };
-        /**
-       * @internal
-       */ _proto._destroy = function _destroy() {
-            var shaderProgramPools = this._shaderProgramPools;
-            for(var i = 0, n = shaderProgramPools.length; i < n; i++){
-                shaderProgramPools[i]._destroy();
-            }
-            shaderProgramPools.length = 0;
-        };
         return ShaderPass;
     }(ShaderPart);
     (function() {
@@ -11509,8 +11500,6 @@
      */ var Shader = /*#__PURE__*/ function() {
         var Shader = function Shader(name1, subShaders) {
             this.name = name1;
-            this._refCount = 0;
-            this._destroyed = false;
             this.name = name1;
             this._subShaders = subShaders;
         };
@@ -11530,46 +11519,20 @@
             for(var i = 0, n = macros.length; i < n; i++){
                 compileMacros.enable(ShaderMacro.getByName(macros[i]));
             }
-            var isValid = false;
             var subShaders = this._subShaders;
             for(var i1 = 0, n1 = subShaders.length; i1 < n1; i1++){
+                var isValid = void 0;
                 var passes = subShaders[i1].passes;
                 for(var j = 0, m = passes.length; j < m; j++){
-                    var shaderProgram = passes[j]._getShaderProgram(engine, compileMacros);
-                    isValid = j === 0 ? shaderProgram.isValid : isValid && shaderProgram.isValid;
-                }
-            }
-            return isValid;
-        };
-        /**
-       * Destroy the shader.
-       * @param force - Whether to force the destruction, if it is false, refCount = 0 can be released successfully.
-       * @returns Whether the release was successful.
-       */ _proto.destroy = function destroy(force) {
-            if (force === void 0) force = false;
-            if (!force && this._refCount !== 0) {
-                return false;
-            }
-            var subShaders = this._subShaders;
-            for(var i = 0, n = subShaders.length; i < n; i++){
-                var passes = subShaders[i].passes;
-                for(var j = 0, m = passes.length; j < m; j++){
-                    passes[j]._destroy();
+                    if (isValid === undefined) {
+                        isValid = passes[j]._getShaderProgram(engine, compileMacros).isValid;
+                    } else {
+                        isValid && (isValid = passes[j]._getShaderProgram(engine, compileMacros).isValid);
+                    }
                 }
+                if (isValid) return true;
             }
-            delete Shader._shaderMap[this.name];
-            this._destroyed = true;
-            return true;
-        };
-        /**
-       * @internal
-       */ _proto._getReferCount = function _getReferCount() {
-            return this._refCount;
-        };
-        /**
-       * @internal
-       */ _proto._addReferCount = function _addReferCount(value) {
-            this._refCount += value;
+            return false;
         };
         Shader.create = function create(nameOrShaderSource, vertexSourceOrShaderPassesOrSubShaders, fragmentSource) {
             var shader;
@@ -11756,14 +11719,6 @@
        */ function get() {
                     return this._subShaders;
                 }
-            },
-            {
-                key: "destroyed",
-                get: /**
-       * Whether it has been destroyed.
-       */ function get() {
-                    return this._destroyed;
-                }
             }
         ]);
         return Shader;
@@ -12879,6 +12834,9 @@
     __decorate$1([
         assignmentClone
     ], SpriteMask.prototype, "influenceLayers", void 0);
+    __decorate$1([
+        ignoreClone
+    ], SpriteMask.prototype, "_verticesData", void 0);
     __decorate$1([
         ignoreClone
     ], SpriteMask.prototype, "_sprite", void 0);
@@ -13993,7 +13951,7 @@
                 if (!material) {
                     continue;
                 }
-                if (material.destroyed || material.shader.destroyed) {
+                if (material.destroyed) {
                     material = this.engine._meshMagentaMaterial;
                 }
                 var renderData = meshRenderDataPool.getFromPool();
@@ -15644,6 +15602,10 @@
                     var sphereInfo = primitiveInfo;
                     PrimitiveMesh._setSphereData(this.resource, sphereInfo.radius, sphereInfo.segments, sphereInfo.noLongerAccessible, true, sphereInfo.vertexBuffer);
                     break;
+                case 7:
+                    var CCSphereInfo = primitiveInfo;
+                    PrimitiveMesh._setSubdivisionSurfaceSphereData(this.resource, CCSphereInfo.radius, CCSphereInfo.step, CCSphereInfo.noLongerAccessible, true, CCSphereInfo.vertexBuffer);
+                    break;
                 case 1:
                     var cuboidInfo = primitiveInfo;
                     PrimitiveMesh._setCuboidData(this.resource, cuboidInfo.width, cuboidInfo.height, cuboidInfo.depth, cuboidInfo.noLongerAccessible, true, cuboidInfo.vertexBuffer);
@@ -15681,6 +15643,7 @@
         PrimitiveType[PrimitiveType["Torus"] = 4] = "Torus";
         PrimitiveType[PrimitiveType["Cone"] = 5] = "Cone";
         PrimitiveType[PrimitiveType["Capsule"] = 6] = "Capsule";
+        PrimitiveType[PrimitiveType["CCSphere"] = 7] = "CCSphere";
     })(PrimitiveType || (PrimitiveType = {}));
     /**
      * @internal
@@ -15702,6 +15665,19 @@
         _inherits$2(SphereRestoreInfo, PrimitiveRestoreInfo);
         return SphereRestoreInfo;
     }(PrimitiveRestoreInfo);
+    /**
+     * @internal
+     */ var SubdivisionSurfaceSphereRestoreInfo = /*#__PURE__*/ function(PrimitiveRestoreInfo) {
+        var SubdivisionSurfaceSphereRestoreInfo = function SubdivisionSurfaceSphereRestoreInfo(radius, step, vertexBuffer, noLongerAccessible) {
+            var _this;
+            _this = PrimitiveRestoreInfo.call(this, 7, vertexBuffer, noLongerAccessible) || this;
+            _this.radius = radius;
+            _this.step = step;
+            return _this;
+        };
+        _inherits$2(SubdivisionSurfaceSphereRestoreInfo, PrimitiveRestoreInfo);
+        return SubdivisionSurfaceSphereRestoreInfo;
+    }(PrimitiveRestoreInfo);
     /**
      * @internal
      */ var CuboidRestoreInfo = /*#__PURE__*/ function(PrimitiveRestoreInfo) {
@@ -15815,6 +15791,24 @@
             return sphereMesh;
         };
         /**
+       * Create a sphere mesh by implementing Catmull-Clark Surface Subdivision Algorithm.
+       * Max step is limited to 6.
+       * @param engine - Engine
+       * @param radius - Sphere radius
+       * @param step - Number of subdiv steps
+       * @param noLongerAccessible - No longer access the vertices of the mesh after creation
+       * @returns Sphere model mesh
+       */ PrimitiveMesh.createSubdivisionSurfaceSphere = function createSubdivisionSurfaceSphere(engine, radius, step, noLongerAccessible) {
+            if (radius === void 0) radius = 0.5;
+            if (step === void 0) step = 3;
+            if (noLongerAccessible === void 0) noLongerAccessible = true;
+            var sphereMesh = new ModelMesh(engine);
+            PrimitiveMesh._setSubdivisionSurfaceSphereData(sphereMesh, radius, step, noLongerAccessible, false);
+            var vertexBuffer = sphereMesh.vertexBufferBindings[0].buffer;
+            engine.resourceManager.addContentRestorer(new PrimitiveMeshRestorer(sphereMesh, new SubdivisionSurfaceSphereRestoreInfo(radius, step, vertexBuffer, noLongerAccessible)));
+            return sphereMesh;
+        };
+        /**
        * Create a cuboid mesh.
        * @param engine - Engine
        * @param width - Cuboid width
@@ -15944,6 +15938,90 @@
         };
         /**
        * @internal
+       */ PrimitiveMesh._setSubdivisionSurfaceSphereData = function _setSubdivisionSurfaceSphereData(sphereMesh, radius, step, noLongerAccessible, isRestoreMode, restoreVertexBuffer) {
+            // Max step is limited to 6. Because 7 step will generate a single mesh with over 98306 vertices
+            step = MathUtil$1.clamp(Math.floor(step), 1, 6);
+            var positions = new Float32Array(3 * (6 * Math.pow(4, step) + 2));
+            var cells = new Float32Array(24 * Math.pow(4, step));
+            PrimitiveMesh._subdiveCatmullClark(step, positions, cells);
+            var positionCount = positions.length / 3;
+            var cellsCount = cells.length / 4;
+            var poleOffset = positionCount + Math.pow(2, step + 1) - 1;
+            // 16 extra vertices for pole uv
+            // 2 vertices at each pole are idle
+            var vertexCount = poleOffset + 16;
+            var vertices = new Float32Array(vertexCount * 8);
+            var indices = PrimitiveMesh._generateIndices(sphereMesh.engine, positionCount, cellsCount * 6);
+            var seamCount = 0;
+            var seamVertices = {};
+            // Get normals, uvs, and scale to radius
+            for(var i = 0; i < positionCount; i++){
+                var offset = 3 * i;
+                var x = positions[offset];
+                var y = positions[offset + 1];
+                var z = positions[offset + 2];
+                var reciprocalLength = 1 / Math.sqrt(x * x + y * y + z * z);
+                x *= reciprocalLength;
+                y *= reciprocalLength;
+                z *= reciprocalLength;
+                offset = 8 * i;
+                vertices[offset] = x * radius;
+                vertices[offset + 1] = y * radius;
+                vertices[offset + 2] = z * radius;
+                vertices[offset + 3] = x;
+                vertices[offset + 4] = y;
+                vertices[offset + 5] = z;
+                vertices[offset + 6] = (Math.PI - Math.atan2(z, x)) / (2 * Math.PI);
+                vertices[offset + 7] = Math.acos(y) / Math.PI;
+                if (vertices[offset + 6] === 0) {
+                    // Generate seam vertex
+                    var seamOffset = 8 * (positionCount + seamCount++);
+                    vertices.set(vertices.subarray(offset, offset + 8), seamOffset);
+                    vertices[seamOffset + 6] = 1.0;
+                    // Cache seam vertex
+                    seamVertices[offset / 8] = seamOffset / 8;
+                }
+            }
+            // Get indices
+            var offset1 = 0;
+            this._spherePoleIdx = 0;
+            for(var i1 = 0; i1 < cellsCount; i1++){
+                var idx = 4 * i1;
+                var indexA = cells[idx];
+                var indexB = cells[idx + 1];
+                var indexC = cells[idx + 2];
+                var indexD = cells[idx + 3];
+                // Handle seam by replacing vertex index to seam vertex index if necessary
+                var floatIndexA = 8 * indexA;
+                var floatIndexB = 8 * indexB;
+                var floatIndexC = 8 * indexC;
+                var floatIndexD = 8 * indexD;
+                // If center Z is negative
+                if (vertices[floatIndexA + 2] + vertices[floatIndexB + 2] + vertices[floatIndexC + 2] < 0) {
+                    vertices[floatIndexA + 6] === 0 && (indexA = seamVertices[indexA]);
+                    vertices[floatIndexB + 6] === 0 && (indexB = seamVertices[indexB]);
+                    vertices[floatIndexC + 6] === 0 && (indexC = seamVertices[indexC]);
+                    vertices[floatIndexD + 6] === 0 && (indexD = seamVertices[indexD]);
+                }
+                indices[offset1] = indexA;
+                indices[offset1 + 1] = indexB;
+                indices[offset1 + 2] = indexC;
+                this._generateAndReplacePoleUV(indices, vertices, offset1, poleOffset);
+                indices[offset1 + 3] = indexA;
+                indices[offset1 + 4] = indexC;
+                indices[offset1 + 5] = indexD;
+                this._generateAndReplacePoleUV(indices, vertices, offset1 + 3, poleOffset);
+                offset1 += 6;
+            }
+            if (!isRestoreMode) {
+                var bounds = sphereMesh.bounds;
+                bounds.min.set(-radius, -radius, -radius);
+                bounds.max.set(radius, radius, radius);
+            }
+            PrimitiveMesh._initialize(sphereMesh, vertices, indices, noLongerAccessible, isRestoreMode, restoreVertexBuffer);
+        };
+        /**
+       * @internal
        */ PrimitiveMesh._setSphereData = function _setSphereData(sphereMesh, radius, segments, noLongerAccessible, isRestoreMode, restoreVertexBuffer) {
             segments = Math.max(2, Math.floor(segments));
             var count = segments + 1;
@@ -16004,6 +16082,135 @@
         };
         /**
        * @internal
+       */ PrimitiveMesh._subdiveCatmullClark = function _subdiveCatmullClark(step, positions, cells) {
+            var edges = new Map();
+            var faces = new Array();
+            positions.set(PrimitiveMesh._sphereSeedPositions);
+            cells.set(PrimitiveMesh._sphereSeedCells);
+            for(var i = 0; i < step; i++){
+                var cellCount = 6 * Math.pow(4, i);
+                var positionCount = 4 * cellCount + 2;
+                edges.clear();
+                faces.length = 0;
+                // Get cell face's facePoint
+                for(var j = 0; j < cellCount; j++){
+                    var face = faces[j] = {
+                        facePoint: new Vector3(),
+                        adjacentEdges: new Array(4)
+                    };
+                    // Get cell's edgePoint
+                    for(var k = 0; k < 4; k++){
+                        var offset = 3 * cells[4 * j + k];
+                        face.facePoint.x += 0.25 * positions[offset];
+                        face.facePoint.y += 0.25 * positions[offset + 1];
+                        face.facePoint.z += 0.25 * positions[offset + 2];
+                    }
+                    // Get cell edges
+                    for(var k1 = 0; k1 < 4; k1++){
+                        var vertexIdxA = cells[4 * j + k1];
+                        var vertexIdxB = cells[4 * j + (k1 + 1) % 4];
+                        var edgeIdxKey = Math.min(vertexIdxA, vertexIdxB) * positionCount + Math.max(vertexIdxA, vertexIdxB);
+                        if (!edges.has(edgeIdxKey)) {
+                            var edge = {
+                                edgePoint: new Vector3(),
+                                edgePointIndex: undefined
+                            };
+                            var offsetA = 3 * vertexIdxA;
+                            var offsetB = 3 * vertexIdxB;
+                            edge.edgePoint.set(0.25 * (positions[offsetA] + positions[offsetB]), 0.25 * (positions[offsetA + 1] + positions[offsetB + 1]), 0.25 * (positions[offsetA + 2] + positions[offsetB + 2]));
+                            edges.set(edgeIdxKey, edge);
+                        }
+                        var edge1 = edges.get(edgeIdxKey);
+                        face.adjacentEdges[k1] = edge1;
+                        var edgePoint = edge1.edgePoint;
+                        var facePoint = face.facePoint;
+                        edgePoint.x += 0.25 * facePoint.x;
+                        edgePoint.y += 0.25 * facePoint.y;
+                        edgePoint.z += 0.25 * facePoint.z;
+                    }
+                }
+                var prePointCount = cellCount + 2;
+                var edgePointOffset = prePointCount + cellCount;
+                var pointIdx = 0;
+                this._sphereEdgeIdx = 0;
+                var preCells = cells.slice(0, 4 * cellCount);
+                // Get New positions, which consists of updated positions of existing points, face points and edge points
+                for(var j1 = 0; j1 < cellCount; j1++){
+                    // Add face point to new positions
+                    var face1 = faces[j1];
+                    face1.facePoint.copyToArray(positions, 3 * (prePointCount + j1));
+                    // Get the face point index
+                    var ic = prePointCount + j1;
+                    var id = void 0, ib = void 0, temp = void 0;
+                    //  ia -- id -- ia
+                    //  |     |     |
+                    //  ib -- ic -- ib
+                    //  |     |     |
+                    //  ia -- id -- ia
+                    for(var k2 = 0; k2 < 4; k2++){
+                        // Get the updated existing point index
+                        var ia = preCells[pointIdx++];
+                        // ib and id share four edge points in one cell
+                        switch(k2){
+                            case 0:
+                                {
+                                    var edgeB = face1.adjacentEdges[k2 % 4];
+                                    var edgeD = face1.adjacentEdges[(k2 + 3) % 4];
+                                    ib = this._calculateEdgeIndex(positions, edgeB, edgePointOffset);
+                                    id = this._calculateEdgeIndex(positions, edgeD, edgePointOffset);
+                                    temp = id;
+                                    break;
+                                }
+                            case 1:
+                            case 2:
+                                {
+                                    var edgeB1 = face1.adjacentEdges[k2 % 4];
+                                    id = ib;
+                                    ib = this._calculateEdgeIndex(positions, edgeB1, edgePointOffset);
+                                    break;
+                                }
+                            case 3:
+                                {
+                                    id = ib;
+                                    ib = temp;
+                                    break;
+                                }
+                        }
+                        var idx = 4 * (4 * j1 + k2);
+                        cells[idx] = ia;
+                        cells[idx + 1] = ib;
+                        cells[idx + 2] = ic;
+                        cells[idx + 3] = id;
+                    }
+                }
+            }
+        };
+        /**
+       * Duplicate vertices at the poles and adjust their UV coordinates.
+       */ PrimitiveMesh._generateAndReplacePoleUV = function _generateAndReplacePoleUV(indices, vertices, idx, poleOffset) {
+            var v = vertices[8 * indices[idx] + 7];
+            if (v === 0 || v === 1) {
+                var offset = 8 * indices[idx];
+                var addedOffset = 8 * (poleOffset + this._spherePoleIdx);
+                vertices.set(vertices.subarray(offset, offset + 8), addedOffset);
+                vertices[addedOffset + 6] = 0.5 * (vertices[offset + 6] + vertices[8 * indices[idx + 1] + 6] + vertices[8 * indices[idx + 2] + 6] - 0.5);
+                indices[idx] = poleOffset + this._spherePoleIdx++;
+            }
+        };
+        /**
+       * Get edge point index for subdivision surface sphere.
+       */ PrimitiveMesh._calculateEdgeIndex = function _calculateEdgeIndex(positions, edge, offset) {
+            if (edge.edgePointIndex !== undefined) {
+                return edge.edgePointIndex;
+            } else {
+                edge.edgePoint.copyToArray(positions, 3 * (offset + PrimitiveMesh._sphereEdgeIdx));
+                var index = offset + PrimitiveMesh._sphereEdgeIdx++;
+                edge.edgePointIndex = index;
+                return index;
+            }
+        };
+        /**
+       * @internal
        */ PrimitiveMesh._setCuboidData = function _setCuboidData(cuboidMesh, width, height, depth, noLongerAccessible, isRestoreMode, restoreVertexBuffer) {
             var halfWidth = width / 2;
             var halfHeight = height / 2;
@@ -16628,6 +16835,68 @@
     (function() {
         PrimitiveMesh._tempVec30 = new Vector3();
     })();
+    (function() {
+        PrimitiveMesh._sphereSeedPositions = new Float32Array([
+            -1,
+            1,
+            1,
+            -1,
+            -1,
+            1,
+            1,
+            -1,
+            1,
+            1,
+            1,
+            1,
+            1,
+            -1,
+            -1,
+            1,
+            1,
+            -1,
+            -1,
+            -1,
+            -1,
+            -1,
+            1,
+            -1
+        ]);
+    })();
+    (function() {
+        PrimitiveMesh._sphereSeedCells = new Float32Array([
+            0,
+            1,
+            2,
+            3,
+            3,
+            2,
+            4,
+            5,
+            5,
+            4,
+            6,
+            7,
+            7,
+            0,
+            3,
+            5,
+            7,
+            6,
+            1,
+            0,
+            6,
+            4,
+            2,
+            1
+        ]);
+    })();
+    (function() {
+        PrimitiveMesh._sphereEdgeIdx = 0;
+    })();
+    (function() {
+        PrimitiveMesh._spherePoleIdx = 0;
+    })();
     /**
      * Mesh skin data, equal glTF skins define
      */ var Skin = /*#__PURE__*/ function(EngineObject1) {
@@ -17133,8 +17402,8 @@
             }
             mesh.addSubMesh(this._getSubMeshFromPool(vertexStartIndex, vertexCount));
             batchedQueue[curMeshIndex] = preElement;
-            this._vertexBuffers[_flushId].setData(vertices, 0, 0, vertexIndex);
-            this._indiceBuffers[_flushId].setData(indices, 0, 0, indiceIndex);
+            this._vertexBuffers[_flushId].setData(vertices, 0, 0, vertexIndex, exports.SetDataOptions.Discard);
+            this._indiceBuffers[_flushId].setData(indices, 0, 0, indiceIndex, exports.SetDataOptions.Discard);
         };
         _proto._getSubMeshFromPool = function _getSubMeshFromPool(start, count) {
             var subMesh = this._subMeshPool.getFromPool();
@@ -21148,7 +21417,6 @@
             if (this._destroyed) return;
             ReferResource1.prototype._addReferCount.call(this, value);
             this.shaderData._addReferCount(value);
-            this._shader._addReferCount(value);
         };
         /**
        * @override
@@ -21176,12 +21444,6 @@
                     return this._shader;
                 },
                 set: function set(value) {
-                    var refCount = this._getReferCount();
-                    if (refCount > 0) {
-                        var _this__shader;
-                        (_this__shader = this._shader) == null ? void 0 : _this__shader._addReferCount(-refCount);
-                        value._addReferCount(refCount);
-                    }
                     this._shader = value;
                     var renderStates = this._renderStates;
                     var lastStatesCount = renderStates.length;
@@ -21417,24 +21679,6 @@
        */ _proto.cache = function cache(shaderProgram) {
             this._lastQueryMap[this._lastQueryKey] = shaderProgram;
         };
-        /**
-       * @internal
-       */ _proto._destroy = function _destroy() {
-            this._recursiveDestroy(0, this._cacheMap);
-            this._cacheMap = Object.create(null);
-        };
-        _proto._recursiveDestroy = function _recursiveDestroy(hierarchy, cacheMap) {
-            if (hierarchy === this._cacheHierarchyDepth - 1) {
-                for(var k in cacheMap){
-                    cacheMap[k].destroy();
-                }
-                return;
-            }
-            ++hierarchy;
-            for(var k1 in cacheMap){
-                this._recursiveDestroy(hierarchy, cacheMap[k1]);
-            }
-        };
         _proto._resizeCacheMapHierarchy = function _resizeCacheMapHierarchy(cacheMap, hierarchy, currentHierarchy, increaseHierarchy) {
             // Only expand but not shrink
             if (hierarchy == currentHierarchy - 1) {
@@ -23730,7 +23974,6 @@
                     shaderProgramPools.length = length;
                 }
                 shaderProgramPools[index] = pool = new ShaderProgramPool();
-                shaderPass._shaderProgramPools.push(pool);
             }
             return pool;
         };
@@ -28414,12 +28657,6 @@
                     return this._shader;
                 },
                 set: function set(value) {
-                    var refCount = this._getReferCount();
-                    if (refCount > 0) {
-                        var _this__shader;
-                        (_this__shader = this._shader) == null ? void 0 : _this__shader._addReferCount(-refCount);
-                        value._addReferCount(refCount);
-                    }
                     this._shader = value;
                     var renderStates = this._renderStates;
                     var lastStatesCount = renderStates.length;
@@ -32223,7 +32460,7 @@
             if (!material) {
                 return;
             }
-            if (material.destroyed || material.shader.destroyed) {
+            if (material.destroyed) {
                 material = this.engine._particleMagentaMaterial;
             }
             var renderData = this._engine._renderDataPool.getFromPool();
@@ -42938,26 +43175,31 @@
         var _proto = SpriteLoader.prototype;
         _proto.load = function load(item, resourceManager) {
             var _this = this;
-            return new AssetPromise(function(resolve, reject) {
-                _this.request(item.url, _extends({}, item, {
-                    type: "json"
-                })).then(function(data) {
-                    if (data.belongToAtlas) {
-                        resourceManager // @ts-ignore
-                        .getResourceByRef(data.belongToAtlas).then(function(atlas) {
-                            resolve(atlas.getSprite(data.fullPath));
-                        }).catch(reject);
-                    } else if (data.texture) {
-                        resourceManager // @ts-ignore
-                        .getResourceByRef(data.texture).then(function(texture) {
-                            resolve(new Sprite(resourceManager.engine, texture, data.region, data.pivot, data.border));
-                        }).catch(reject);
-                    } else {
-                        resolve(new Sprite(resourceManager.engine, null, data.region, data.pivot, data.border));
-                    }
-                }).catch(reject);
+            return this.request(item.url, _extends({}, item, {
+                type: "json"
+            })).then(function(data) {
+                return data.belongToAtlas ? _this._loadFromAtlas(resourceManager, data) : _this._loadFromTexture(resourceManager, data);
             });
         };
+        _proto._loadFromAtlas = function _loadFromAtlas(resourceManager, data) {
+            var _this = this;
+            return resourceManager // @ts-ignore
+            .getResourceByRef(data.belongToAtlas).then(function(atlas) {
+                return atlas.getSprite(data.fullPath) || _this._loadFromTexture(resourceManager, data);
+            });
+        };
+        _proto._loadFromTexture = function _loadFromTexture(resourceManager, data) {
+            if (data.texture) {
+                return resourceManager // @ts-ignore
+                .getResourceByRef(data.texture).then(function(texture) {
+                    return new Sprite(resourceManager.engine, texture, data.region, data.pivot, data.border);
+                });
+            } else {
+                return new AssetPromise(function(resolve) {
+                    resolve(new Sprite(resourceManager.engine, null, data.region, data.pivot, data.border));
+                });
+            }
+        };
         return SpriteLoader;
     }(Loader);
     SpriteLoader = __decorate([
@@ -43733,7 +43975,7 @@
     ], GALACEAN_animation_event);
 
     //@ts-ignore
-    var version = "0.0.0-experimental-shaderlab.0";
+    var version = "0.0.0-experimental-uploadSameBuffer.0";
     console.log("Galacean engine version: " + version);
     for(var key in CoreObjects){
         Loader.registerClass(key, CoreObjects[key]);