@safe-engine/cocos 2.4.1 → 2.4.3

package/dist/gworld/NodeComp.js

@@ -0,0 +1,337 @@
+import { instantiate } from '../helper/utils';
+import { ExtraDataComp } from '../norender';
+import { Vec2 } from '../polyfills';
+export class NodeComp {
+    entity;
+    instance;
+    parent;
+    children = [];
+    name;
+    _group;
+    _active = true;
+    constructor(instance, entity) {
+        this.entity = entity;
+        this.instance = instance;
+    }
+    get uuid() {
+        return this.entity.id;
+    }
+    get position() {
+        return Vec2(this.instance.getPosition());
+    }
+    set position(val) {
+        this.instance.setPosition(val.x, val.y);
+    }
+    set xy(val) {
+        this.instance.setPosition(val[0], val[1]);
+    }
+    get posX() {
+        return this.instance.getPositionX();
+    }
+    set posX(val) {
+        this.instance.setPositionX(val);
+    }
+    get posY() {
+        return this.instance.getPositionY();
+    }
+    set posY(val) {
+        this.instance.setPositionY(val);
+    }
+    get scale() {
+        return this.instance.getScale();
+    }
+    set scale(val) {
+        this.instance.setScale(val, val);
+    }
+    get scaleX() {
+        return this.instance.getScaleX();
+    }
+    set scaleX(val) {
+        this.instance.setScaleX(val);
+    }
+    get scaleY() {
+        return this.instance.getScaleY();
+    }
+    set scaleY(val) {
+        this.instance.setScaleY(val);
+    }
+    get anchorX() {
+        return this.instance.anchorX;
+    }
+    set anchorX(val) {
+        this.instance.anchorX = val;
+    }
+    get anchorY() {
+        return this.instance.anchorY;
+    }
+    set anchorY(val) {
+        this.instance.anchorY = val;
+    }
+    /**
+     * Returns the angle of the node in degrees. 0 is the default rotation angle. Positive values rotate node clockwise.
+     * @function
+     * @return {Number} The rotation of the node in degrees.
+     */
+    get rotation() {
+        return this.instance.getRotation();
+    }
+    /**
+     *
+     *  Sets the X angle of the node in degrees which performs a horizontal rotational skew.
+     *  (support only in WebGL rendering mode)
+     *  0 is the default rotation angle.
+     *  Positive values rotate node clockwise, and negative values for anti-clockwise.
+     *
+     * @param {Number} degrees The X rotation in degrees which performs a horizontal rotational skew.
+     */
+    set rotation(val) {
+        this.instance.setRotation(val);
+    }
+    get color() {
+        return this.instance.getColor();
+    }
+    set color(val) {
+        this.instance.setColor(val);
+    }
+    get opacity() {
+        return this.instance.getOpacity();
+    }
+    set opacity(val) {
+        this.instance.setOpacity(val);
+    }
+    get active() {
+        if (!cc.sys.isObjectValid(this.instance) || !this._active)
+            return false;
+        let p = this.parent;
+        while (p) {
+            if (!p.active)
+                return false;
+            p = p.parent;
+        }
+        return true;
+    }
+    set active(val) {
+        if (!cc.sys.isObjectValid(this.instance)) {
+            return;
+        }
+        this._active = val;
+        if (this.instance instanceof ccui.Widget) {
+            this.instance.setEnabled(val);
+        }
+        this.instance.setVisible(val);
+    }
+    get group() {
+        return this._group;
+    }
+    set group(val) {
+        this._group = val;
+    }
+    get width() {
+        return this.instance.width;
+    }
+    set width(val) {
+        this.instance.setContentSize(val, this.height);
+    }
+    get height() {
+        return this.instance.height;
+    }
+    set height(val) {
+        this.instance.setContentSize(val, this.width);
+    }
+    get zIndex() {
+        return this.instance.zIndex;
+    }
+    set zIndex(val) {
+        this.instance.zIndex = val;
+    }
+    get childrenCount() {
+        return this.children.length;
+    }
+    destroy() {
+        this.removeFromParent(true);
+    }
+    addComponent(instance) {
+        return this.entity.assign(instance);
+    }
+    getComponent(component) {
+        return this.entity.getComponent(component);
+    }
+    getComponentsInChildren(component) {
+        if (!this.children.length) {
+            return [];
+        }
+        const listHave = this.children.filter((child) => {
+            return child.getComponent(component);
+        });
+        return listHave.map((node) => node.getComponent(component));
+    }
+    getComponentInChildren(component) {
+        return this.getComponentsInChildren(component)[0];
+    }
+    hasComponentInChildren(component) {
+        if (!this.children.length) {
+            return false;
+        }
+        return this.children.some((child) => {
+            return child.getComponent(component);
+        });
+    }
+    getPercent() {
+        if (this.instance instanceof ccui.LoadingBar) {
+            return this.instance.getPercent();
+        }
+        return 0;
+    }
+    setPercent(val) {
+        if (this.instance instanceof ccui.LoadingBar) {
+            return this.instance.setPercent(val);
+        }
+    }
+    setTouchEnabled(enabled) {
+        if (!cc.sys.isObjectValid(this.instance)) {
+            return;
+        }
+        if (this.instance instanceof ccui.Widget) {
+            this.instance.setTouchEnabled(enabled);
+        }
+    }
+    addTouchEventListener(cb) {
+        if (!cc.sys.isObjectValid(this.instance)) {
+            return;
+        }
+        if (this.instance instanceof ccui.Widget) {
+            this.instance.addTouchEventListener(cb);
+        }
+    }
+    convertToNodeSpace(point) {
+        const { x, y } = this.instance.convertToNodeSpace(point);
+        return Vec2(x, y);
+    }
+    convertToNodeSpaceAR(point) {
+        const { x, y } = this.instance.convertToNodeSpaceAR(point);
+        return Vec2(x, y);
+    }
+    convertToWorldSpaceAR(point) {
+        const { x, y } = this.instance.convertToWorldSpaceAR(point);
+        return Vec2(x, y);
+    }
+    getPosition() {
+        return this.instance.getPosition();
+    }
+    setPosition(x, y) {
+        this.instance.setPosition(x, y);
+    }
+    setRotation(deg) {
+        this.instance.setRotation(deg);
+    }
+    getRotation() {
+        return this.instance.getRotation();
+    }
+    setAnchorPoint(point, y) {
+        this.instance.setAnchorPoint(point, y);
+    }
+    getAnchorPoint() {
+        return this.instance.getAnchorPoint();
+    }
+    getBoundingBox() {
+        const box = this.instance.getBoundingBox();
+        box.contains = function (point) {
+            return this.x <= point.x && this.x + this.width >= point.x && this.y <= point.y && this.y + this.height >= point.y;
+        };
+        return box;
+    }
+    getContentSize() {
+        return this.instance.getContentSize();
+    }
+    setContentSize(size, height) {
+        this.instance.setContentSize(size, height);
+        if (this.instance instanceof cc.ClippingNode) {
+            const hw = (size.width || size) * 0.5;
+            const hh = (size.height || height) * 0.5;
+            const stencil = new cc.DrawNode();
+            const rectangle = [cc.p(-hw, -hh), cc.p(hw, -hh), cc.p(hw, hh), cc.p(-hw, hh)];
+            stencil.drawPoly(rectangle, cc.Color.WHITE, 0, cc.Color.WHITE);
+            // stencil.drawDot(cc.p(-height * 0.5, -height * 0.5), height, cc.Color.WHITE);
+            this.instance.stencil = stencil;
+        }
+    }
+    setColor(color) {
+        this.instance.setColor(color);
+    }
+    setScale(scaleX, scaleY) {
+        this.instance.setScale(scaleX, scaleY || scaleX);
+    }
+    runAction(atc) {
+        this.instance.runAction(atc);
+    }
+    stopAllActions() {
+        this.instance.stopAllActions();
+    }
+    pauseAllActionsAndSchedule() {
+        this.instance.pause();
+        this.instance.unscheduleUpdate();
+    }
+    resumeAllActionsAndSchedule() {
+        this.instance.resume();
+        this.instance.scheduleUpdate();
+    }
+    removeFromParent(cleanup) {
+        this.active = false;
+        if (this.parent) {
+            this.parent.children = this.parent.children.filter(({ entity }) => entity.id !== this.entity.id);
+        }
+        if (cleanup) {
+            this.children.forEach((child) => {
+                child.destroy();
+            });
+            this.parent = null;
+            this.entity.destroy();
+            this.stopAllActions();
+            this.instance.removeFromParent(cleanup);
+        }
+        else {
+            this.stopAllActions();
+            this.instance.removeFromParent();
+        }
+    }
+    addChild(child) {
+        child._active = true;
+        child.parent = this;
+        this.children.push(child);
+        this.instance.addChild(child.instance);
+    }
+    removeAllChildren(cleanup) {
+        this.children.forEach((child) => {
+            child.removeFromParent(cleanup);
+        });
+    }
+    getData(key) {
+        const data = this.getComponent(ExtraDataComp);
+        if (!data)
+            throw Error('need add ExtraDataComp to Node');
+        return data.getData(key);
+    }
+    setData(key, value) {
+        const data = this.getComponent(ExtraDataComp);
+        if (!data) {
+            this.addComponent(instantiate(ExtraDataComp, { key, value }));
+        }
+        else {
+            data.setData(key, value);
+        }
+    }
+    removeData(key) {
+        const data = this.getComponent(ExtraDataComp);
+        if (data) {
+            data.removeData(key);
+        }
+    }
+    resolveComponent(component) {
+        if (component.constructor.hasRender) {
+            this.addChild(component.node);
+        }
+        else {
+            this.addComponent(component);
+        }
+    }
+}

package/dist/gworld/NodePool.d.ts

@@ -0,0 +1,9 @@
+import { NodeComp } from "./NodeComp";
+export declare class NodePool {
+    items: NodeComp[];
+    put(node: NodeComp): void;
+    get(): NodeComp;
+    size(): number;
+    clear(): void;
+}
+//# sourceMappingURL=NodePool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NodePool.d.ts","sourceRoot":"","sources":["../../src/gworld/NodePool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,qBAAa,QAAQ;IACnB,KAAK,EAAE,QAAQ,EAAE,CAAK;IAEtB,GAAG,CAAC,IAAI,EAAE,QAAQ;IAQlB,GAAG,IAAI,QAAQ;IAOf,IAAI;IAIJ,KAAK;CAIN"}

package/dist/gworld/NodePool.js

@@ -0,0 +1,23 @@
+export class NodePool {
+    items = [];
+    put(node) {
+        if (node) {
+            node.removeFromParent();
+            node.entity.immortal = true;
+            this.items.push(node);
+        }
+    }
+    get() {
+        const node = this.items.pop();
+        node.entity.immortal = false;
+        node.active = true;
+        return node;
+    }
+    size() {
+        return this.items.length;
+    }
+    clear() {
+        this.items.forEach((node) => node.destroy());
+        this.items.length = 0;
+    }
+}

package/dist/gworld/Scene.d.ts

@@ -0,0 +1,5 @@
+import { EnhancedComponent } from './EnhancedComponent';
+export declare class SceneComponent extends EnhancedComponent {
+    render(): this;
+}
+//# sourceMappingURL=Scene.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../src/gworld/Scene.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAGvD,qBAAa,cAAe,SAAQ,iBAAiB;IACnD,MAAM;CASP"}

package/dist/gworld/Scene.js

@@ -0,0 +1,14 @@
+import { GameWorld } from '.';
+import { EnhancedComponent } from './EnhancedComponent';
+import { NodeComp } from './NodeComp';
+export class SceneComponent extends EnhancedComponent {
+    render() {
+        const world = GameWorld.Instance;
+        world.entities.reset();
+        const root = world.entities.create();
+        const node = root.assign(new NodeComp(cc.director.getRunningScene(), root));
+        const sceneComponent = root.assign(this);
+        sceneComponent.node = node;
+        return sceneComponent;
+    }
+}

package/dist/gworld/decorator.d.ts

@@ -0,0 +1,8 @@
+import { EnhancedComponent, NodeComp } from '.';
+export declare class NoRenderComponentX<Props = object, C extends cc.Node = cc.Node> extends EnhancedComponent<Props, NodeComp<C>> {
+    static hasRender: boolean;
+}
+export declare class ComponentX<Props = object, C extends cc.Node = cc.Node> extends EnhancedComponent<Props, NodeComp<C>> {
+    render?(): this;
+}
+//# sourceMappingURL=decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../src/gworld/decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAa,QAAQ,EAAE,MAAM,GAAG,CAAA;AAE1D,qBAAa,kBAAkB,CAAC,KAAK,GAAG,MAAM,EAAE,CAAC,SAAS,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,CAAE,SAAQ,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACxH,MAAM,CAAC,SAAS,UAAQ;CACzB;AAED,qBAAa,UAAU,CAAC,KAAK,GAAG,MAAM,EAAE,CAAC,SAAS,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,IAAI,CAAE,SAAQ,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IAChH,MAAM,CAAC;CAMR"}

package/dist/gworld/decorator.js

@@ -0,0 +1,12 @@
+import { EnhancedComponent, GameWorld } from '.';
+export class NoRenderComponentX extends EnhancedComponent {
+    static hasRender = false;
+}
+export class ComponentX extends EnhancedComponent {
+    render() {
+        const world = GameWorld.Instance;
+        const root = world.entities.create();
+        const comp = root.assign(this);
+        return comp;
+    }
+}

package/dist/gworld/index.d.ts

@@ -0,0 +1,8 @@
+import { Constructor, System, World } from 'entityx-ts';
+export declare class GameWorld extends World {
+    listUpdate: (System | Constructor<System>)[];
+    update(dt: number): void;
+    private static _instance;
+    static get Instance(): GameWorld;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gworld/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvD,qBAAa,SAAU,SAAQ,KAAK;IAClC,UAAU,EAAE,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,CAAK;IACjD,MAAM,CAAC,EAAE,EAAE,MAAM;IAMjB,OAAO,CAAC,MAAM,CAAC,SAAS,CAAW;IAEnC,WAAkB,QAAQ,cAGzB;CACF"}

package/dist/gworld/index.js

@@ -0,0 +1,14 @@
+import { World } from 'entityx-ts';
+export class GameWorld extends World {
+    listUpdate = [];
+    update(dt) {
+        this.listUpdate.forEach((system) => {
+            this.systems.update(system, dt);
+        });
+    }
+    static _instance;
+    static get Instance() {
+        // Do you need arguments? Make it a regular static method instead.
+        return this._instance || (this._instance = new this());
+    }
+}

package/dist/render/RenderSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderSystem.d.ts","sourceRoot":"","sources":["../../src/render/RenderSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAoC,MAAM,EAAE,MAAM,YAAY,CAAA;AAKnF,oBAAY,WAAW;IACrB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,KAAK,IAAA;IACL,MAAM,IAAA;IACN,IAAI,IAAA;IACJ,SAAS,IAAA;CACV;AA4CD,qBAAa,YAAa,YAAW,MAAM;IACzC,SAAS,CAAC,aAAa,EAAE,YAAY;IAWrC,OAAO,CAAC,eAAe,CAKtB;IAED,OAAO,CAAC,iBAAiB,CAgBxB;IAED,OAAO,CAAC,eAAe,CAatB;IAED,OAAO,CAAC,mBAAmB,CAQ1B;IAED,OAAO,CAAC,iBAAiB,CAKxB;IAED,OAAO,CAAC,aAAa,CAKpB;IAED,OAAO,CAAC,iBAAiB,CAUxB;IAED,OAAO,CAAC,iBAAiB,CAKxB;CAKF"}
+{"version":3,"file":"RenderSystem.d.ts","sourceRoot":"","sources":["../../src/render/RenderSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAoC,MAAM,EAAE,MAAM,YAAY,CAAA;AAMnF,oBAAY,WAAW;IACrB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,KAAK,IAAA;IACL,MAAM,IAAA;IACN,IAAI,IAAA;IACJ,SAAS,IAAA;CACV;AAED,qBAAa,YAAa,YAAW,MAAM;IACzC,SAAS,CAAC,aAAa,EAAE,YAAY;IAWrC,OAAO,CAAC,eAAe,CAKtB;IAED,OAAO,CAAC,iBAAiB,CAgBxB;IAED,OAAO,CAAC,eAAe,CAatB;IAED,OAAO,CAAC,mBAAmB,CAQ1B;IAED,OAAO,CAAC,iBAAiB,CAKxB;IAED,OAAO,CAAC,aAAa,CAKpB;IAED,OAAO,CAAC,iBAAiB,CAUxB;IAED,OAAO,CAAC,iBAAiB,CAKxB;CAKF"}

package/dist/render/RenderSystem.js

@@ -1,6 +1,7 @@
 import { EventTypes } from 'entityx-ts';
 import { NodeComp } from '../core/NodeComp';
 import { GraphicsRender, MaskRender, MotionStreakComp, NodeRender, ParticleComp, SpriteRender, TiledMap } from './RenderComponent';
+import { createTiledSprite } from './TiledSprite';
 export var SpriteTypes;
 (function (SpriteTypes) {
     SpriteTypes[SpriteTypes["SIMPLE"] = 0] = "SIMPLE";
@@ -10,41 +11,6 @@ export var SpriteTypes;
     SpriteTypes[SpriteTypes["MESH"] = 4] = "MESH";
     SpriteTypes[SpriteTypes["ANIMATION"] = 5] = "ANIMATION";
 })(SpriteTypes || (SpriteTypes = {}));
-function createTiledSprite(src, totalW, totalH) {
-    // tạo sprite từ input
-    const tileSprite = new cc.Sprite(src);
-    // lấy kích thước gốc của texture
-    const frame = tileSprite.getSpriteFrame();
-    const tileW = frame ? frame.getRect().width : tileSprite.getContentSize().width;
-    const tileH = frame ? frame.getRect().height : tileSprite.getContentSize().height;
-    // tạo renderTexture với kích thước cần phủ
-    const { width, height } = cc.winSize;
-    const rt = new cc.RenderTexture(width, height);
-    rt.beginWithClear(0, 0, 0, 0);
-    const drawSprite = new cc.Sprite(tileSprite.getTexture());
-    // if (frame) {
-    //   drawSprite.setSpriteFrame(frame)
-    // }
-    drawSprite.setAnchorPoint(0, 0);
-    // số tile theo trục x,y
-    const cols = Math.ceil(totalW / tileW);
-    const rows = Math.ceil(totalH / tileH);
-    for (let r = 0; r < rows; r++) {
-        for (let c = 0; c < cols; c++) {
-            const s = new cc.Sprite(frame);
-            s.setFlippedY(true);
-            s.setAnchorPoint(0, 0);
-            s.setPosition(c * tileW, r * tileH);
-            s.visit(rt);
-        }
-    }
-    rt.end();
-    const finalSprite = rt.sprite;
-    // finalSprite.setFlippedY(true) // RenderTexture bị lật
-    finalSprite.setAnchorPoint(0, 0);
-    finalSprite.setContentSize(cc.size(totalW, totalH));
-    return new cc.Sprite(finalSprite.texture);
-}
 export class RenderSystem {
     configure(event_manager) {
         event_manager.subscribe(EventTypes.ComponentAdded, NodeRender, this.onAddNodeRender);

package/dist/render/TiledSprite.d.ts

@@ -0,0 +1,12 @@
+export declare class TiledSpriteNode extends cc.Sprite {
+    _program: cc.GLProgram;
+    _tileScaleLoc: WebGLUniformLocation;
+    _texSizeLoc: WebGLUniformLocation;
+    _texLoc: WebGLUniformLocation;
+    constructor(file: any);
+    initShader(): void;
+    updateShaderUniforms(): void;
+    setContentSize(w: any, h: any): void;
+}
+export declare function createTiledSprite(src: string, totalW: number, totalH: number): cc.Sprite;
+//# sourceMappingURL=TiledSprite.d.ts.map

package/dist/render/TiledSprite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TiledSprite.d.ts","sourceRoot":"","sources":["../../src/render/TiledSprite.ts"],"names":[],"mappings":"AAEA,qBAAa,eAAgB,SAAQ,EAAE,CAAC,MAAM;IAC5C,QAAQ,EAAE,EAAE,CAAC,SAAS,CAAA;IACtB,aAAa,EAAE,oBAAoB,CAAA;IACnC,WAAW,EAAE,oBAAoB,CAAA;IACjC,OAAO,EAAE,oBAAoB,CAAA;gBAEjB,IAAI,KAAA;IAMhB,UAAU;IAqBV,oBAAoB;IAgBpB,cAAc,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;CAIpB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,aAmC5E"}

package/dist/render/TiledSprite.js

@@ -0,0 +1,83 @@
+import { tieldFsh, tiledVsh } from './shader';
+export class TiledSpriteNode extends cc.Sprite {
+    _program;
+    _tileScaleLoc;
+    _texSizeLoc;
+    _texLoc;
+    constructor(file) {
+        super(file);
+        this.ctor();
+        this.initShader();
+    }
+    initShader() {
+        const program = new cc.GLProgram();
+        program.initWithVertexShaderByteArray(tiledVsh, tieldFsh);
+        program.addAttribute(cc.ATTRIBUTE_NAME_POSITION, cc.VERTEX_ATTRIB_POSITION);
+        program.addAttribute(cc.ATTRIBUTE_NAME_COLOR, cc.VERTEX_ATTRIB_COLOR);
+        program.addAttribute(cc.ATTRIBUTE_NAME_TEX_COORD, cc.VERTEX_ATTRIB_TEX_COORDS);
+        program.link();
+        program.updateUniforms();
+        program.use();
+        this._program = program;
+        this.setShaderProgram(program);
+        // Lưu lại uniform location để update nhanh
+        this._tileScaleLoc = program.getUniformLocationForName('u_tileScale');
+        this._texSizeLoc = program.getUniformLocationForName('u_texSize');
+        this._texLoc = program.getUniformLocationForName('u_texture');
+        this.scheduleUpdate();
+    }
+    updateShaderUniforms() {
+        if (!this._program || !this.texture || !this.texture.isLoaded())
+            return;
+        const texW = this.texture.width;
+        const texH = this.texture.height;
+        const size = this.getContentSize();
+        const scaleX = size.width / texW;
+        const scaleY = size.height / texH;
+        this._program.use();
+        this._program.setUniformLocationWith2f(this._tileScaleLoc, scaleX, scaleY);
+        this._program.setUniformLocationWith2f(this._texSizeLoc, texW, texH);
+        this._program.setUniformLocationWith1i(this._texLoc, 0);
+    }
+    setContentSize(w, h) {
+        super.setContentSize(w, h);
+        this.updateShaderUniforms();
+    }
+}
+export function createTiledSprite(src, totalW, totalH) {
+    // tạo sprite từ input
+    const tileSprite = new cc.Sprite(src);
+    // lấy kích thước gốc của texture
+    const tileW = tileSprite.texture.width;
+    const tileH = tileSprite.texture.height;
+    const program = new cc.GLProgram();
+    program.initWithString(tiledVsh, tieldFsh);
+    // program.initWithVertexShaderByteArray(vert, frag);
+    program.addAttribute(cc.ATTRIBUTE_NAME_POSITION, cc.VERTEX_ATTRIB_POSITION);
+    program.addAttribute(cc.ATTRIBUTE_NAME_COLOR, cc.VERTEX_ATTRIB_COLOR);
+    program.addAttribute(cc.ATTRIBUTE_NAME_TEX_COORD, cc.VERTEX_ATTRIB_TEX_COORDS);
+    if (!program.link()) {
+        console.error('Failed to link shader program');
+        return;
+    }
+    program.updateUniforms();
+    program.setUniformLocationWith1i(program.getUniformLocationForName('u_texture'), 0);
+    const tileScaleLoc = program.getUniformLocationForName('u_tileScale');
+    const texSizeLoc = program.getUniformLocationForName('u_texSize');
+    const scaleX = totalW / tileW;
+    const scaleY = totalH / tileH;
+    if (tileSprite.texture._textureLoaded)
+        afterLoaded();
+    else
+        tileSprite.texture.addLoadedEventListener(afterLoaded);
+    function afterLoaded() {
+        // program.use()
+        program.setUniformLocationWith2f(texSizeLoc, tileW, tileH);
+        program.setUniformLocationWith2f(tileScaleLoc, scaleX, scaleY);
+        tileSprite.setShaderProgram(program);
+        // nếu dùng batch node hoặc spriteframe atlas, đảm bảo texture unit đúng
+    }
+    // tileSprite.setContentSize(totalW, totalH)
+    tileSprite.setScale(scaleX, scaleY);
+    return tileSprite;
+}

package/dist/render/shader.d.ts

@@ -0,0 +1,3 @@
+export declare const tieldFsh = "\n#ifdef GL_ES\nprecision mediump float;\n#endif\n\nvarying vec2 v_texCoord;\nvarying vec4 v_fragmentColor;\n\nuniform sampler2D u_texture;\nuniform vec2 u_tileScale;\nuniform vec2 u_texSize;\n\nvoid main()\n{\n    // scale UV to tile space\n    vec2 uv = v_texCoord * u_tileScale;\n\n    // wrap using fract\n    vec2 uvw = fract(uv);\n\n    // avoid linear-filter seams: push UVs slightly away from exact 0.0/1.0 edges\n    // compute texel size in uv-space\n    vec2 texel = 1.0 / u_texSize;\n\n    // shrink usable range slightly to avoid sampling border when linear filter is used\n    // the factor 1.0 - 2.0*texel moves the uv into [texel, 1-texel]\n    uvw = uvw * (1.0 - 2.0 * texel) + texel;\n\n    vec4 color = texture2D(u_texture, uvw);\n\n    gl_FragColor = color * v_fragmentColor;\n}\n";
+export declare const tiledVsh = "\nattribute vec4 a_position;\nattribute vec2 a_texCoord;\nattribute vec4 a_color;\n\n#ifdef GL_ES\nvarying mediump vec2 v_texCoord;\nvarying lowp vec4 v_fragmentColor;\n#else\nvarying vec2 v_texCoord;\nvarying vec4 v_fragmentColor;\n#endif\n\nvoid main() {\n    gl_Position = CC_PMatrix * a_position;\n    v_texCoord = a_texCoord;\n    v_fragmentColor = a_color;\n}\n";
+//# sourceMappingURL=shader.d.ts.map

package/dist/render/shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../src/render/shader.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,qyBAgCpB,CAAA;AACD,eAAO,MAAM,QAAQ,oXAkBpB,CAAA"}

package/dist/render/shader.js

@@ -0,0 +1,52 @@
+export const tieldFsh = `
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+varying vec2 v_texCoord;
+varying vec4 v_fragmentColor;
+
+uniform sampler2D u_texture;
+uniform vec2 u_tileScale;
+uniform vec2 u_texSize;
+
+void main()
+{
+    // scale UV to tile space
+    vec2 uv = v_texCoord * u_tileScale;
+
+    // wrap using fract
+    vec2 uvw = fract(uv);
+
+    // avoid linear-filter seams: push UVs slightly away from exact 0.0/1.0 edges
+    // compute texel size in uv-space
+    vec2 texel = 1.0 / u_texSize;
+
+    // shrink usable range slightly to avoid sampling border when linear filter is used
+    // the factor 1.0 - 2.0*texel moves the uv into [texel, 1-texel]
+    uvw = uvw * (1.0 - 2.0 * texel) + texel;
+
+    vec4 color = texture2D(u_texture, uvw);
+
+    gl_FragColor = color * v_fragmentColor;
+}
+`;
+export const tiledVsh = `
+attribute vec4 a_position;
+attribute vec2 a_texCoord;
+attribute vec4 a_color;
+
+#ifdef GL_ES
+varying mediump vec2 v_texCoord;
+varying lowp vec4 v_fragmentColor;
+#else
+varying vec2 v_texCoord;
+varying vec4 v_fragmentColor;
+#endif
+
+void main() {
+    gl_Position = CC_PMatrix * a_position;
+    v_texCoord = a_texCoord;
+    v_fragmentColor = a_color;
+}
+`;