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

package/dist/main.js

@@ -2036,7 +2036,8 @@ var Logger = {
     _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);
@@ -5979,7 +5980,6 @@ var ShaderFactory = /*#__PURE__*/ function() {
         _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;
@@ -6033,15 +6033,6 @@ var ShaderFactory = /*#__PURE__*/ function() {
         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() {
@@ -6672,8 +6663,6 @@ __decorate([
  */ var Shader = /*#__PURE__*/ function() {
     function Shader(name, subShaders) {
         this.name = name;
-        this._refCount = 0;
-        this._destroyed = false;
         this.name = name;
         this._subShaders = subShaders;
     }
@@ -6693,46 +6682,20 @@ __decorate([
         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;
@@ -6919,14 +6882,6 @@ __decorate([
    */ function get() {
                 return this._subShaders;
             }
-        },
-        {
-            key: "destroyed",
-            get: /**
-   * Whether it has been destroyed.
-   */ function get() {
-                return this._destroyed;
-            }
         }
     ]);
     return Shader;
@@ -8055,6 +8010,9 @@ SimpleSpriteAssembler = __decorate([
 __decorate([
     assignmentClone
 ], SpriteMask.prototype, "influenceLayers", void 0);
+__decorate([
+    ignoreClone
+], SpriteMask.prototype, "_verticesData", void 0);
 __decorate([
     ignoreClone
 ], SpriteMask.prototype, "_sprite", void 0);
@@ -9187,7 +9145,7 @@ var BlendShapeFrameDirty;
             if (!material) {
                 continue;
             }
-            if (material.destroyed || material.shader.destroyed) {
+            if (material.destroyed) {
                 material = this.engine._meshMagentaMaterial;
             }
             var renderData = meshRenderDataPool.getFromPool();
@@ -10842,6 +10800,10 @@ var VertexElementIndex;
                 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);
@@ -10879,6 +10841,7 @@ var PrimitiveType;
     PrimitiveType[PrimitiveType["Torus"] = 4] = "Torus";
     PrimitiveType[PrimitiveType["Cone"] = 5] = "Cone";
     PrimitiveType[PrimitiveType["Capsule"] = 6] = "Capsule";
+    PrimitiveType[PrimitiveType["CCSphere"] = 7] = "CCSphere";
 })(PrimitiveType || (PrimitiveType = {}));
 /**
  * @internal
@@ -10900,6 +10863,19 @@ var PrimitiveType;
     }
     return SphereRestoreInfo;
 }(PrimitiveRestoreInfo);
+/**
+ * @internal
+ */ var SubdivisionSurfaceSphereRestoreInfo = /*#__PURE__*/ function(PrimitiveRestoreInfo) {
+    _inherits(SubdivisionSurfaceSphereRestoreInfo, PrimitiveRestoreInfo);
+    function SubdivisionSurfaceSphereRestoreInfo(radius, step, vertexBuffer, noLongerAccessible) {
+        var _this;
+        _this = PrimitiveRestoreInfo.call(this, 7, vertexBuffer, noLongerAccessible) || this;
+        _this.radius = radius;
+        _this.step = step;
+        return _this;
+    }
+    return SubdivisionSurfaceSphereRestoreInfo;
+}(PrimitiveRestoreInfo);
 /**
  * @internal
  */ var CuboidRestoreInfo = /*#__PURE__*/ function(PrimitiveRestoreInfo) {
@@ -11014,6 +10990,24 @@ var PrimitiveType;
         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
@@ -11143,6 +11137,90 @@ var PrimitiveType;
     };
     /**
    * @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 = engineMath.MathUtil.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;
@@ -11203,6 +11281,135 @@ var PrimitiveType;
     };
     /**
    * @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 engineMath.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 engineMath.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;
@@ -11832,6 +12039,68 @@ var PrimitiveType;
 (function() {
     PrimitiveMesh._tempVec30 = new engineMath.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
@@ -12340,8 +12609,8 @@ var Basic2DBatcher = /*#__PURE__*/ function() {
         }
         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();
@@ -16403,7 +16672,6 @@ __decorate([
         if (this._destroyed) return;
         ReferResource1.prototype._addReferCount.call(this, value);
         this.shaderData._addReferCount(value);
-        this._shader._addReferCount(value);
     };
     /**
    * @override
@@ -16431,12 +16699,6 @@ __decorate([
                 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;
@@ -16700,24 +16962,6 @@ var unlitVs = "#define GLSLIFY 1\n#include <common>\n#include <common_vert>\n#in
    */ _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) {
@@ -19025,7 +19269,6 @@ ShaderPool.init();
                 shaderProgramPools.length = length;
             }
             shaderProgramPools[index] = pool = new ShaderProgramPool();
-            shaderPass._shaderProgramPools.push(pool);
         }
         return pool;
     };
@@ -23747,12 +23990,6 @@ var BaseMaterial = /*#__PURE__*/ function(Material1) {
                 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;
@@ -27612,7 +27849,7 @@ exports.ParticleStopMode = void 0;
         if (!material) {
             return;
         }
-        if (material.destroyed || material.shader.destroyed) {
+        if (material.destroyed) {
             material = this.engine._particleMagentaMaterial;
         }
         var renderData = this._engine._renderDataPool.getFromPool();