@safe-engine/cocos 2.3.4 → 2.3.5

package/dist/dragonbones/db-cocos/CocosSlot.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * The MIT License (MIT)
  *
@@ -28,23 +27,19 @@ export class CocosSlot extends Slot {
     static toString() {
         return '[class dragonBones.CocosSlot]';
     }
+    _ccMeshDirty = false;
     _textureScale;
     _renderDisplay;
+    _geometryData;
+    _geometryBones;
     _onClear() {
         super._onClear();
         this._textureScale = 1.0;
         this._renderDisplay = null;
         // this._updateTransform = cc[0] === '3' ? this._updateTransformV3 : this._updateTransformV4;
     }
-    _initDisplay(value, isRetain) {
-        // tslint:disable-next-line:no-unused-expression
-        value;
-        // tslint:disable-next-line:no-unused-expression
-        isRetain;
-    }
+    _initDisplay() { }
     _disposeDisplay(value, isRelease) {
-        // tslint:disable-next-line:no-unused-expression
-        value;
         if (!isRelease) {
             ;
             value.release();
@@ -55,18 +50,21 @@ export class CocosSlot extends Slot {
     }
     _addDisplay() {
         const container = this._armature.display;
-        container.addChild(this._renderDisplay);
+        container.addChild(this._renderDisplay, this._zOrder);
     }
     _replaceDisplay(value) {
         const container = this._armature.display;
         const prevDisplay = value;
-        container.addChild(this._renderDisplay);
-        // container.swapChildren(this._renderDisplay, prevDisplay);
-        container.removeChild(prevDisplay);
+        if (this._renderDisplay.parent !== container) {
+            container.addChild(this._renderDisplay, prevDisplay.getLocalZOrder());
+        }
+        // container.removeChild(prevDisplay, false);
+        // this._renderDisplay.active = true
+        // prevDisplay.active = false
         this._textureScale = 1.0;
     }
     _removeDisplay() {
-        this._renderDisplay.parent.removeChild(this._renderDisplay);
+        this._renderDisplay.parent.removeChild(this._renderDisplay, false);
     }
     _updateZOrder() {
         if (this._renderDisplay.getLocalZOrder() === this._zOrder) {
@@ -81,20 +79,18 @@ export class CocosSlot extends Slot {
         this._renderDisplay.visible = this._parent.visible && this._visible;
     }
     _updateBlendMode() {
-        if (this._renderDisplay instanceof cc.Sprite) {
+        if (this._childArmature) {
+            const childSlots = this._childArmature.getSlots();
+            for (let i = 0, l = childSlots.length; i < l; i++) {
+                const slot = childSlots[i];
+                slot._blendMode = this._blendMode;
+                slot._updateBlendMode();
+            }
         }
-        // TODO child armature.
     }
     _updateColor() {
-        const alpha = this._colorTransform.alphaMultiplier * this._globalAlpha;
-        this._renderDisplay.alpha = alpha;
-        if (this._renderDisplay instanceof cc.Sprite || this._renderDisplay instanceof Cocos.SimpleMesh) {
-            const color = (Math.round(this._colorTransform.redMultiplier * 0xff) << 16) +
-                (Math.round(this._colorTransform.greenMultiplier * 0xff) << 8) +
-                Math.round(this._colorTransform.blueMultiplier * 0xff);
-            this._renderDisplay.tint = color;
-        }
-        // TODO child armature.
+        const color = cc.color(Math.round(this._colorTransform.redMultiplier * 255), Math.round(this._colorTransform.greenMultiplier * 255), Math.round(this._colorTransform.blueMultiplier * 255), Math.round(this._colorTransform.alphaMultiplier * 255));
+        this._renderDisplay.color = color;
     }
     _updateFrame() {
         let currentTextureData = this._textureData;
@@ -113,16 +109,16 @@ export class CocosSlot extends Slot {
                 }
                 currentTextureData = currentTextureAtlasData.getTexture(currentTextureData.name);
             }
-            const renderTexture = currentTextureData.renderTexture;
+            const renderTexture = currentTextureData.spriteFrame;
             if (renderTexture !== null) {
                 if (this._geometryData) {
                     // Mesh.
                     const data = this._geometryData.data;
                     const intArray = data.intArray;
                     const floatArray = data.floatArray;
-                    const vertexCount = intArray[this._geometryData.offset + BinaryOffset.GeometryVertexCount];
-                    const triangleCount = intArray[this._geometryData.offset + BinaryOffset.GeometryTriangleCount];
-                    let vertexOffset = intArray[this._geometryData.offset + BinaryOffset.GeometryFloatOffset];
+                    const vertexCount = intArray[this._geometryData.offset + BinaryOffset.MeshVertexCount];
+                    const triangleCount = intArray[this._geometryData.offset + BinaryOffset.MeshTriangleCount];
+                    let vertexOffset = intArray[this._geometryData.offset + BinaryOffset.MeshFloatOffset];
                     if (vertexOffset < 0) {
                         vertexOffset += 65536; // Fixed out of bouds bug.
                     }
@@ -136,7 +132,7 @@ export class CocosSlot extends Slot {
                         vertices[i] = floatArray[vertexOffset + i] * scale;
                     }
                     for (let i = 0; i < triangleCount * 3; ++i) {
-                        indices[i] = intArray[this._geometryData.offset + BinaryOffset.GeometryVertexIndices + i];
+                        indices[i] = intArray[this._geometryData.offset + BinaryOffset.MeshVertexIndices + i];
                     }
                     for (let i = 0, l = vertexCount * 2; i < l; i += 2) {
                         const u = floatArray[uvOffset + i];
@@ -151,10 +147,10 @@ export class CocosSlot extends Slot {
                         }
                     }
                     this._textureScale = 1.0;
-                    meshDisplay.texture = renderTexture;
-                    meshDisplay.vertices = vertices;
-                    meshDisplay.uvBuffer.update(uvs);
-                    meshDisplay.geometry.addIndex(indices);
+                    meshDisplay.setTexture(renderTexture);
+                    meshDisplay.setVertices(vertices);
+                    // meshDisplay.uvBuffer.update(uvs)
+                    // meshDisplay.geometry.addIndex(indices)
                     const isSkinned = this._geometryData.weight !== null;
                     const isSurface = this._parent._boneData.type !== BoneType.Bone;
                     if (isSkinned || isSurface) {
@@ -165,6 +161,7 @@ export class CocosSlot extends Slot {
                     // Normal texture.
                     this._textureScale = currentTextureData.parent.scale * this._armature._armatureData.scale;
                     const normalDisplay = this._renderDisplay;
+                    // console.log(normalDisplay, renderTexture)
                     normalDisplay.setSpriteFrame(renderTexture);
                 }
                 this._visibleDirty = true;
@@ -173,7 +170,7 @@ export class CocosSlot extends Slot {
         }
         if (this._geometryData) {
             const meshDisplay = this._renderDisplay;
-            meshDisplay.texture = null;
+            meshDisplay.setTexture(null);
             meshDisplay.x = 0.0;
             meshDisplay.y = 0.0;
             meshDisplay.visible = false;
@@ -194,7 +191,7 @@ export class CocosSlot extends Slot {
         const bones = this._geometryBones;
         const geometryData = this._geometryData;
         const weightData = deformVertices.verticesData.weight;
-        const hasDeform = deformVertices.length > 0 && deformVertices.verticesData.inheritDeform;
+        const hasDeform = deformVertices.vertices.length > 0 && deformVertices.verticesData.inheritDeform;
         // const meshDisplay = (this._renderDisplay.getComponent(cc.Sprite) as any)._sgNode; // as cc.Scale9Sprite;
         const polygonInfo = this._meshDisplay._polygonInfo;
         if (!polygonInfo) {
@@ -295,8 +292,8 @@ export class CocosSlot extends Slot {
         boundsRect.width -= boundsRect.x;
         boundsRect.height -= boundsRect.y;
         polygonInfo.rect = boundsRect;
-        meshDisplay.setContentSize(cc.size(boundsRect.width, boundsRect.height));
-        meshDisplay.setMeshPolygonInfo(polygonInfo);
+        this.meshDisplay.setContentSize(cc.size(boundsRect.width, boundsRect.height));
+        this.meshDisplay.setMeshPolygonInfo(polygonInfo);
         if (weightData !== null) {
             this._identityTransform();
         }

package/dist/dragonbones/db-cocos/CocosTextureAtlasData.d.ts

@@ -47,7 +47,7 @@ export declare class CocosTextureAtlasData extends TextureAtlasData {
  */
 export declare class CocosTextureData extends TextureData {
     static toString(): string;
-    renderTexture: cc.SpriteFrame | null;
+    spriteFrame: cc.SpriteFrame | null;
     protected _onClear(): void;
 }
 //# sourceMappingURL=CocosTextureAtlasData.d.ts.map

package/dist/dragonbones/db-cocos/CocosTextureAtlasData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CocosTextureAtlasData.d.ts","sourceRoot":"","sources":["../../../src/dragonbones/db-cocos/CocosTextureAtlasData.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAc,gBAAgB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEjF,qBAAa,qBAAsB,SAAQ,gBAAgB;WAC3C,QAAQ,IAAI,MAAM;IAIhC,OAAO,CAAC,cAAc,CAA4B;IAElD,SAAS,CAAC,QAAQ,IAAI,IAAI;IAS1B;;OAEG;IACI,aAAa,IAAI,WAAW;IAGnC;;;;OAIG;IACH;;;;OAIG;IACH,IAAW,aAAa,IAAI,EAAE,CAAC,SAAS,GAAG,IAAI,CAE9C;IACD,IAAW,aAAa,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,GAAG,IAAI,EAoDlD;CACF;AACD;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,WAAW;WACjC,QAAQ,IAAI,MAAM;IAIzB,aAAa,EAAE,EAAE,CAAC,WAAW,GAAG,IAAI,CAAO;IAElD,SAAS,CAAC,QAAQ,IAAI,IAAI;CAS3B"}
+{"version":3,"file":"CocosTextureAtlasData.d.ts","sourceRoot":"","sources":["../../../src/dragonbones/db-cocos/CocosTextureAtlasData.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAc,gBAAgB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEjF,qBAAa,qBAAsB,SAAQ,gBAAgB;WAC3C,QAAQ,IAAI,MAAM;IAIhC,OAAO,CAAC,cAAc,CAA4B;IAElD,SAAS,CAAC,QAAQ,IAAI,IAAI;IAS1B;;OAEG;IACI,aAAa,IAAI,WAAW;IAGnC;;;;OAIG;IACH;;;;OAIG;IACH,IAAW,aAAa,IAAI,EAAE,CAAC,SAAS,GAAG,IAAI,CAE9C;IACD,IAAW,aAAa,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,GAAG,IAAI,EAoDlD;CACF;AACD;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,WAAW;WACjC,QAAQ,IAAI,MAAM;IAIzB,WAAW,EAAE,EAAE,CAAC,WAAW,GAAG,IAAI,CAAO;IAEhD,SAAS,CAAC,QAAQ,IAAI,IAAI;CAS3B"}

package/dist/dragonbones/db-cocos/CocosTextureAtlasData.js

@@ -89,7 +89,7 @@ export class CocosTextureAtlasData extends TextureAtlasData {
                 // sprite
                 const spriteFrame = new cc.SpriteFrame(this._renderTexture, rect, textureData.rotated, offset, originSize);
                 // console.log('sf', sf)
-                textureData.renderTexture = spriteFrame;
+                textureData.spriteFrame = spriteFrame;
             }
         }
         else {
@@ -98,7 +98,7 @@ export class CocosTextureAtlasData extends TextureAtlasData {
                 // if (textureData.renderTexture !== null) {
                 //   textureData.renderTexture.destroy();
                 // }
-                textureData.renderTexture = null;
+                textureData.spriteFrame = null;
             }
         }
     }
@@ -110,12 +110,12 @@ export class CocosTextureData extends TextureData {
     static toString() {
         return '[class dragonBones.CocosTextureData]';
     }
-    renderTexture = null; // Initial value.
+    spriteFrame = null; // Initial value.
     _onClear() {
         super._onClear();
-        // if (this.renderTexture !== null) {
-        //   this.renderTexture.destroy();
+        // if (this.spriteFrame !== null) {
+        //   this.spriteFrame.destroy();
         // }
-        this.renderTexture = null;
+        this.spriteFrame = null;
     }
 }

package/dist/dragonbones/db-cocos/SimpleMeshNode.d.ts

@@ -0,0 +1,36 @@
+export declare class SimpleMeshNode extends cc.Node {
+    _texture: any;
+    _vertices: Float32Array | null;
+    _uvs: Float32Array | null;
+    _indices: Uint16Array | null;
+    _gl: WebGLRenderingContext | null;
+    _program: WebGLProgram | null;
+    _vbo: WebGLBuffer | null;
+    _uvbo: WebGLBuffer | null;
+    _ibo: WebGLBuffer | null;
+    _needsUpload: boolean;
+    _alpha: number;
+    _fallbackDraw: cc.DrawNode;
+    _useWebGL: boolean;
+    constructor(texture?: cc.Texture2D, vertices?: Float32Array, uvs?: Float32Array, indices?: Uint16Array);
+    _updateContentSizeFromVertices(): void;
+    setVertices(verts: Float32Array): void;
+    setUVs(uvs: Float32Array): void;
+    setIndices(inds: Uint16Array): void;
+    setTexture(tex: cc.Texture2D): void;
+    setSpriteFrame(renderTexture: any): void;
+    visit(ctx?: unknown): void;
+    _drawMesh(): void;
+    _ensureGL(): void;
+    _computeModelMatrixFromNode(): Float32Array;
+    _drawMeshWebGL(): void;
+    _drawMeshCanvasFallback(): void;
+    setAlpha(a: number): void;
+    static createQuad(x: number, y: number, w: number, h: number, u0: number, v0: number, uw: number, vh: number): {
+        vertices: Float32Array<ArrayBuffer>;
+        uvs: Float32Array<ArrayBuffer>;
+        indices: Uint16Array<ArrayBuffer>;
+    };
+    onExit(): void;
+}
+//# sourceMappingURL=SimpleMeshNode.d.ts.map

package/dist/dragonbones/db-cocos/SimpleMeshNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleMeshNode.d.ts","sourceRoot":"","sources":["../../../src/dragonbones/db-cocos/SimpleMeshNode.ts"],"names":[],"mappings":"AAOA,qBAAa,cAAe,SAAQ,EAAE,CAAC,IAAI;IAEzC,QAAQ,EAAE,GAAG,CAAO;IACpB,SAAS,EAAE,YAAY,GAAG,IAAI,CAAO;IACrC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAO;IAChC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAO;IAGnC,GAAG,EAAE,qBAAqB,GAAG,IAAI,CAAO;IACxC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAO;IACpC,IAAI,EAAE,WAAW,GAAG,IAAI,CAAO;IAC/B,KAAK,EAAE,WAAW,GAAG,IAAI,CAAO;IAChC,IAAI,EAAE,WAAW,GAAG,IAAI,CAAO;IAC/B,YAAY,UAAO;IACnB,MAAM,SAAM;IAGZ,aAAa,EAAE,EAAE,CAAC,QAAQ,CAAO;IACjC,SAAS,UAAO;gBAEJ,OAAO,CAAC,EAAE,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,GAAG,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,WAAW;IAiBtG,8BAA8B,IAAI,IAAI;IAmBtC,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAMtC,MAAM,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI;IAK/B,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAKnC,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,SAAS,GAAG,IAAI;IAGnC,cAAc,CAAC,aAAa,KAAA;IAK5B,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,GAAG,IAAI;IAU1B,SAAS,IAAI,IAAI;IAQjB,SAAS,IAAI,IAAI;IAuEjB,2BAA2B,IAAI,YAAY;IA0D3C,cAAc,IAAI,IAAI;IAkGtB,uBAAuB,IAAI,IAAI;IAuB/B,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAKzB,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;;;;;IAU5G,MAAM,IAAI,IAAI;CAcf"}

package/dist/dragonbones/db-cocos/SimpleMeshNode.js

@@ -0,0 +1,354 @@
+// cc.SimpleMeshNode.ts
+// SimpleMesh as a cc.Node for Cocos2d-html5 (WebGL primary).
+// Converted to ES6/TypeScript class from legacy Cocos-style object literal.
+// Usage:
+//   const node = new SimpleMeshNode(texture, verts, uvs, inds);
+//   node.setPosition(x,y); node.setRotation(angleDeg); node.setScale(s);
+export class SimpleMeshNode extends cc.Node {
+    // public mesh data (Float32Array / Uint16Array)
+    _texture = null;
+    _vertices = null;
+    _uvs = null;
+    _indices = null;
+    // GL internals
+    _gl = null;
+    _program = null;
+    _vbo = null;
+    _uvbo = null;
+    _ibo = null;
+    _needsUpload = true;
+    _alpha = 1.0;
+    // fallback drawnode for Canvas or debug
+    _fallbackDraw = null;
+    _useWebGL = true;
+    constructor(texture, vertices, uvs, indices) {
+        super();
+        super.ctor();
+        this._texture = texture || null;
+        this._vertices = vertices || new Float32Array(0);
+        this._uvs = uvs || new Float32Array(0);
+        this._indices = indices || new Uint16Array(0);
+        this._fallbackDraw = new cc.DrawNode();
+        this._useWebGL = !!cc._renderContext;
+        // size/anchor auto-estimate from vertex bounds (optional)
+        this._updateContentSizeFromVertices();
+    }
+    // helper to estimate contentSize and anchor if needed
+    _updateContentSizeFromVertices() {
+        if (!this._vertices || this._vertices.length < 2)
+            return;
+        let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
+        for (let i = 0; i < this._vertices.length; i += 2) {
+            const x = this._vertices[i], y = this._vertices[i + 1];
+            if (x < minX)
+                minX = x;
+            if (y < minY)
+                minY = y;
+            if (x > maxX)
+                maxX = x;
+            if (y > maxY)
+                maxY = y;
+        }
+        if (minX === Infinity)
+            return;
+        this.setContentSize(maxX - minX, maxY - minY);
+        // set anchor relative to local coordinates (default 0,0), keep at 0,0 for compatibility
+    }
+    setVertices(verts) {
+        this._vertices = verts;
+        this._needsUpload = true;
+        this._updateContentSizeFromVertices();
+    }
+    setUVs(uvs) {
+        this._uvs = uvs;
+        this._needsUpload = true;
+    }
+    setIndices(inds) {
+        this._indices = inds;
+        this._needsUpload = true;
+    }
+    setTexture(tex) {
+        this._texture = tex;
+    }
+    setSpriteFrame(renderTexture) {
+        this._texture = renderTexture._texture;
+    }
+    // override visit to draw mesh at correct point in scene graph
+    visit(ctx) {
+        // normal visit to draw children etc.
+        super.visit(ctx);
+        // draw our mesh after node's transform is applied (so position/rotation/scale are final)
+        // Note: calling AFTER visit ensures it's rendered on top of children; change if you want otherwise.
+        this._drawMesh();
+    }
+    // core drawing function
+    _drawMesh() {
+        if (this._useWebGL && cc._renderContext) {
+            this._drawMeshWebGL();
+        }
+        else {
+            this._drawMeshCanvasFallback();
+        }
+    }
+    _ensureGL() {
+        if (this._gl && this._program)
+            return;
+        const gl = cc._renderContext;
+        if (!gl) {
+            this._useWebGL = false;
+            return;
+        }
+        this._gl = gl;
+        const vsSrc = [
+            'attribute vec2 a_position;',
+            'attribute vec2 a_texcoord;',
+            'uniform mat3 u_model;',
+            'uniform vec2 u_resolution;',
+            'varying vec2 v_uv;',
+            'void main() {',
+            '  vec2 pos = (u_model * vec3(a_position, 1.0)).xy;',
+            '  vec2 zeroToOne = pos / u_resolution;',
+            '  vec2 zeroToTwo = zeroToOne * 2.0;',
+            '  vec2 clipSpace = zeroToTwo - 1.0;',
+            '  gl_Position = vec4(clipSpace * vec2(1.0, -1.0), 0.0, 1.0);',
+            '  v_uv = a_texcoord;',
+            '}',
+        ].join('\n');
+        const fsSrc = [
+            'precision mediump float;',
+            'varying vec2 v_uv;',
+            'uniform sampler2D u_texture;',
+            'uniform float u_alpha;',
+            'void main() {',
+            '  vec4 c = texture2D(u_texture, v_uv);',
+            '  gl_FragColor = vec4(c.rgb, c.a * u_alpha);',
+            '}',
+        ].join('\n');
+        const compileShader = function (gl, src, type) {
+            const s = gl.createShader(type);
+            if (!s)
+                return null;
+            gl.shaderSource(s, src);
+            gl.compileShader(s);
+            if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) {
+                cc.log(`SimpleMesh shader compile error:\n${gl.getShaderInfoLog(s)}`);
+                gl.deleteShader(s);
+                return null;
+            }
+            return s;
+        };
+        const vs = compileShader(gl, vsSrc, gl.VERTEX_SHADER);
+        const fs = compileShader(gl, fsSrc, gl.FRAGMENT_SHADER);
+        if (!vs || !fs)
+            return;
+        const prog = gl.createProgram();
+        if (!prog)
+            return;
+        gl.attachShader(prog, vs);
+        gl.attachShader(prog, fs);
+        gl.linkProgram(prog);
+        if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) {
+            cc.log(`SimpleMesh program link error:\n${gl.getProgramInfoLog(prog)}`);
+            gl.deleteProgram(prog);
+            return;
+        }
+        this._program = prog;
+        // buffers
+        this._vbo = gl.createBuffer();
+        this._uvbo = gl.createBuffer();
+        this._ibo = gl.createBuffer();
+    }
+    // compute model matrix using node's transform: we want map local mesh coords (as-specified) through node's world transform
+    _computeModelMatrixFromNode() {
+        // get node world transform: use node's nodeToWorldAffine / getNodeToParentTransform?
+        // Simpler: use node.getNodeToWorldTransform() if available to get 4x4 matrix,
+        // but to keep it engine-agnostic we build 2D model from node's world position/rotation/scale.
+        const worldRotation = this.getNodeToWorldTransform
+            ? (function () {
+                try {
+                    const t = this.getNodeToWorldTransform();
+                    const a = t.a, b = t.b, c = t.c, d = t.d, tx = t.tx, ty = t.ty;
+                    const rot = (Math.atan2(b, a) * 180) / Math.PI;
+                    const sx = Math.sqrt(a * a + b * b);
+                    const sy = Math.sqrt(c * c + d * d);
+                    return { rot: rot, sx: sx, sy: sy, tx: tx, ty: ty };
+                }
+                catch {
+                    return null;
+                }
+            })()
+            : null;
+        let tx, ty, rotDeg, sx, sy;
+        if (worldRotation) {
+            tx = worldRotation.tx;
+            ty = worldRotation.ty;
+            rotDeg = worldRotation.rot;
+            sx = worldRotation.sx;
+            sy = worldRotation.sy;
+        }
+        else {
+            const worldPt = this.convertToWorldSpaceAR ? this.convertToWorldSpaceAR(cc.p(0, 0)) : { x: 0, y: 0 };
+            tx = worldPt.x;
+            ty = worldPt.y;
+            rotDeg = this.getRotation ? this.getRotation() : this.rotation || 0;
+            sx = this.getScaleX ? this.getScaleX() : this.scaleX || 1;
+            sy = this.getScaleY ? this.getScaleY() : this.scaleY || 1;
+        }
+        const rad = ((rotDeg || 0) * Math.PI) / 180.0;
+        const cos = Math.cos(rad), sin = Math.sin(rad);
+        const a = cos * sx;
+        const b = sin * sx;
+        const c = -sin * sy;
+        const d = cos * sy;
+        const anchor = this.getAnchorPoint ? this.getAnchorPoint() : { x: 0, y: 0 };
+        const aw = anchor.x * this.width;
+        const ah = anchor.y * this.height;
+        const e = tx - (a * aw + c * ah);
+        const f = ty - (b * aw + d * ah);
+        return new Float32Array([a, b, 0, c, d, 0, e, f, 1]);
+    }
+    _drawMeshWebGL() {
+        const gl = cc._renderContext;
+        if (!gl) {
+            this._useWebGL = false;
+            return;
+        }
+        this._ensureGL();
+        if (!this._program)
+            return;
+        if (!this._vertices || !this._uvs || !this._indices)
+            return;
+        if (this._vertices.length / 2 !== this._uvs.length / 2)
+            return;
+        gl.useProgram(this._program);
+        // upload if needed
+        if (this._needsUpload) {
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._vbo);
+            gl.bufferData(gl.ARRAY_BUFFER, this._vertices, gl.DYNAMIC_DRAW);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._uvbo);
+            gl.bufferData(gl.ARRAY_BUFFER, this._uvs, gl.STATIC_DRAW);
+            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._ibo);
+            gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this._indices, gl.STATIC_DRAW);
+            this._needsUpload = false;
+        }
+        else {
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._vbo);
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._uvbo);
+            gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._ibo);
+        }
+        const aPosLoc = gl.getAttribLocation(this._program, 'a_position');
+        const aUVLoc = gl.getAttribLocation(this._program, 'a_texcoord');
+        // vertices
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._vbo);
+        gl.enableVertexAttribArray(aPosLoc);
+        gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, 0, 0);
+        // uvs
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._uvbo);
+        gl.enableVertexAttribArray(aUVLoc);
+        gl.vertexAttribPointer(aUVLoc, 2, gl.FLOAT, false, 0, 0);
+        // bind texture
+        if (this._texture) {
+            gl.activeTexture(gl.TEXTURE0);
+            const webTex = this._texture._webTextureObj || (this._texture.getTexture ? this._texture.getTexture() : null);
+            // console.log(gl.TEXTURE_2D, webTex)
+            if (webTex) {
+                gl.bindTexture(gl.TEXTURE_2D, webTex._webTextureObj);
+            }
+            else {
+                const img = this._texture.getHtmlElementObj ? this._texture.getHtmlElementObj() : this._texture;
+                if (img) {
+                    const tmp = gl.createTexture();
+                    gl.bindTexture(gl.TEXTURE_2D, tmp);
+                    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, img);
+                    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+                    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+                }
+            }
+            const uTexLoc = gl.getUniformLocation(this._program, 'u_texture');
+            gl.uniform1i(uTexLoc, 0);
+        }
+        else {
+            gl.bindTexture(gl.TEXTURE_2D, null);
+        }
+        // resolution
+        const uResLoc = gl.getUniformLocation(this._program, 'u_resolution');
+        const viewAny = cc.view;
+        const sz = viewAny.getFrameSize
+            ? viewAny.getFrameSize()
+            : { width: cc.director.getWinSize().width, height: cc.director.getWinSize().height };
+        gl.uniform2f(uResLoc, sz.width, sz.height);
+        // model matrix from node
+        const uModelLoc = gl.getUniformLocation(this._program, 'u_model');
+        const modelMat = this._computeModelMatrixFromNode();
+        gl.uniformMatrix3fv(uModelLoc, false, modelMat);
+        // alpha
+        const uAlphaLoc = gl.getUniformLocation(this._program, 'u_alpha');
+        gl.uniform1f(uAlphaLoc, this._alpha || 1.0);
+        // blending
+        gl.enable(gl.BLEND);
+        gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+        // draw
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._ibo);
+        gl.drawElements(gl.TRIANGLES, this._indices.length, gl.UNSIGNED_SHORT, 0);
+        // cleanup
+        gl.disableVertexAttribArray(aPosLoc);
+        gl.disableVertexAttribArray(aUVLoc);
+    }
+    // simple canvas fallback: just draw bounding box for visibility
+    _drawMeshCanvasFallback() {
+        if (!this._fallbackDraw.parent) {
+            this.addChild(this._fallbackDraw);
+        }
+        this._fallbackDraw.clear();
+        if (!this._vertices || this._vertices.length < 2)
+            return;
+        let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
+        for (let i = 0; i < this._vertices.length; i += 2) {
+            const x = this._vertices[i], y = this._vertices[i + 1];
+            if (x < minX)
+                minX = x;
+            if (y < minY)
+                minY = y;
+            if (x > maxX)
+                maxX = x;
+            if (y > maxY)
+                maxY = y;
+        }
+        const rect = [cc.p(minX, minY), cc.p(maxX, minY), cc.p(maxX, maxY), cc.p(minX, maxY)];
+        this._fallbackDraw.drawPoly(rect, null, 1, cc.color(255, 0, 0, 255));
+    }
+    // set alpha multiplier
+    setAlpha(a) {
+        this._alpha = a;
+    }
+    // convenience static to create a quad mesh
+    static createQuad(x, y, w, h, u0, v0, uw, vh) {
+        const verts = new Float32Array([x, y, x + w, y, x + w, y + h, x, y + h]);
+        const u1 = u0 + uw, v1 = v0 + vh;
+        const uvs = new Float32Array([u0, v0, u1, v0, u1, v1, u0, v1]);
+        const inds = new Uint16Array([0, 1, 2, 0, 2, 3]);
+        return { vertices: verts, uvs: uvs, indices: inds };
+    }
+    // cleanup GL buffers on exit
+    onExit() {
+        super.onExit();
+        if (this._gl) {
+            try {
+                if (this._vbo)
+                    this._gl.deleteBuffer(this._vbo);
+                if (this._uvbo)
+                    this._gl.deleteBuffer(this._uvbo);
+                if (this._ibo)
+                    this._gl.deleteBuffer(this._ibo);
+                if (this._program)
+                    this._gl.deleteProgram(this._program);
+            }
+            catch (e) {
+                console.log('onExit', e);
+            }
+            this._gl = null;
+        }
+    }
+}

package/dist/gworld/EnhancedComponent.d.ts

@@ -0,0 +1,22 @@
+import { Constructor } from 'entityx-ts';
+import { BaseComponentProps } from '../safex';
+import { NodeComp } from './NodeComp';
+export declare class EnhancedComponent<Props = object, N extends NodeComp<any> = NodeComp<any>> {
+    static hasRender: boolean;
+    props: Props;
+    node: N;
+    enabled: boolean;
+    constructor(data?: BaseComponentProps<EnhancedComponent> & Props);
+    init(data?: Props): void;
+    addComponent<T extends EnhancedComponent>(instance: T): T;
+    getComponent<T extends EnhancedComponent>(component: Constructor<T>): T;
+    schedule(callback: (arg: any) => void, interval: number, repeat?: number, delay?: number): void;
+    unschedule(callback: (arg: any) => void): void;
+    unscheduleAllCallbacks(): void;
+    scheduleOnce(callback: (arg: any) => void, delay: number, key?: string): void;
+    getComponentsInChildren<T extends ComponentType>(component: Constructor<T>): T[];
+    getComponentInChildren<T extends ComponentType>(component: Constructor<T>): T;
+    isEqual(other: EnhancedComponent): boolean;
+}
+export type ComponentType = EnhancedComponent | NodeComp;
+//# sourceMappingURL=EnhancedComponent.d.ts.map

package/dist/gworld/EnhancedComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnhancedComponent.d.ts","sourceRoot":"","sources":["../../src/gworld/EnhancedComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAExC,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,qBAAa,iBAAiB,CAAC,KAAK,GAAG,MAAM,EAAE,CAAC,SAAS,QAAQ,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC;IACpF,MAAM,CAAC,SAAS,UAAO;IACvB,KAAK,EAAE,KAAK,CAAY;IACxB,IAAI,EAAE,CAAC,CAAA;IACP,OAAO,UAAO;gBACF,IAAI,CAAC,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,GAAG,KAAK;IAGhE,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK;IASjB,YAAY,CAAC,CAAC,SAAS,iBAAiB,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC;IAGzD,YAAY,CAAC,CAAC,SAAS,iBAAiB,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC;IAGvE,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,MAAgC,EAAE,KAAK,SAAI;IAG5G,UAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI;IAGvC,sBAAsB;IAGtB,YAAY,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;IAGtE,uBAAuB,CAAC,CAAC,SAAS,aAAa,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;IAGhF,sBAAsB,CAAC,CAAC,SAAS,aAAa,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC;IAG7E,OAAO,CAAC,KAAK,EAAE,iBAAiB;CAGjC;AAED,MAAM,MAAM,aAAa,GAAG,iBAAiB,GAAG,QAAQ,CAAA"}