Fix tiles rotation that was no longer applied in tile maps (#4315)

Extensions/TileMap/helper/dts/render/TileMapPixiHelper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileMapPixiHelper.d.ts","sourceRoot":"","sources":["../../src/render/TileMapPixiHelper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAEL,eAAe,EAEhB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC;AAGpC,qBAAa,iBAAiB;IAC5B;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,EACpD,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,GACnE,gBAAgB,GAAG,IAAI;IA6F1B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,iBAAiB,CACtB,kBAAkB,EAAE,GAAG,EACvB,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,gBAAgB,EAC9B,WAAW,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,EACxC,UAAU,EAAE,MAAM,GACjB,IAAI;IAiFP;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAC5B,YAAY,EAAE,IAAI,CAAC,QAAQ,EAC3B,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,OAAO,EACpB,YAAY,EAAE,OAAO,EACrB,cAAc,EAAE,KAAK,EACrB,SAAS,EAAE,OAAO,EAClB,WAAW,EAAE,KAAK,GACjB,IAAI;CAiER"}
+{"version":3,"file":"TileMapPixiHelper.d.ts","sourceRoot":"","sources":["../../src/render/TileMapPixiHelper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAEL,eAAe,EAEhB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC;AAGpC,qBAAa,iBAAiB;IAC5B;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,EACpD,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,GACnE,gBAAgB,GAAG,IAAI;IA6F1B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,iBAAiB,CACtB,kBAAkB,EAAE,GAAG,EACvB,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,gBAAgB,EAC9B,WAAW,EAAE,OAAO,GAAG,SAAS,GAAG,KAAK,EACxC,UAAU,EAAE,MAAM,GACjB,IAAI;IAgFP;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAC5B,YAAY,EAAE,IAAI,CAAC,QAAQ,EAC3B,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,OAAO,EACpB,YAAY,EAAE,OAAO,EACrB,cAAc,EAAE,KAAK,EACrB,SAAS,EAAE,OAAO,EAClB,WAAW,EAAE,KAAK,GACjB,IAAI;CAiER"}

Extensions/TileMap/helper/dts/render/TileTextureCache.d.ts

@@ -19,23 +19,29 @@ export declare class TileTextureCache {
     flippedDiagonally: boolean,
     texture: PIXI.Texture
   ): void;
+  /**
+   * Return the texture to use for the tile with the specified id.
+   *
+   * @param tileId The tile identifier
+   * @returns The texture for the given tile identifier.
+   */
+  findTileTexture(tileId: integer): PIXI.Texture | undefined;
   /**
    * Return the texture to use for the tile with the specified uid, which can contains
    * information about rotation in bits 32, 31 and 30
    * (see https://doc.mapeditor.org/en/stable/reference/tmx-map-format/).
    *
-   * @param tileId The tile identifier
    * @param flippedHorizontally true if the tile is flipped horizontally.
    * @param flippedVertically true if the tile is flipped vertically.
    * @param flippedDiagonally true if the tile is flipped diagonally.
-   * @returns The texture for the given tile identifier and orientation.
+   * @returns the rotation "D8" number used by Pixi.
+   * @see https://pixijs.io/examples/#/textures/texture-rotate.js
    */
-  findTileTexture(
-    tileId: integer,
+  getPixiRotate(
     flippedHorizontally: boolean,
     flippedVertically: boolean,
     flippedDiagonally: boolean
-  ): PIXI.Texture | undefined;
+  ): number;
   /**
    * @return the Tiled tile global uniq identifier.
    */

Extensions/TileMap/helper/dts/render/TileTextureCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileTextureCache.d.ts","sourceRoot":"","sources":["../../src/render/TileTextureCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,OAAO,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC;AAEpC;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAc;IAC7D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAc;IAC3D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAc;IAE3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;;IAMvD,UAAU,CACR,MAAM,EAAE,OAAO,EACf,mBAAmB,EAAE,OAAO,EAC5B,iBAAiB,EAAE,OAAO,EAC1B,iBAAiB,EAAE,OAAO,EAC1B,OAAO,EAAE,IAAI,CAAC,OAAO,GACpB,IAAI;IAUP;;;;;;;;;;OAUG;IACH,eAAe,CACb,MAAM,EAAE,OAAO,EACf,mBAAmB,EAAE,OAAO,EAC5B,iBAAiB,EAAE,OAAO,EAC1B,iBAAiB,EAAE,OAAO,GACzB,IAAI,CAAC,OAAO,GAAG,SAAS;IA8D3B;;OAEG;IACH,OAAO,CAAC,YAAY;CAkBrB"}
+{"version":3,"file":"TileTextureCache.d.ts","sourceRoot":"","sources":["../../src/render/TileTextureCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,OAAO,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC;AAEpC;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAc;IAC7D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAc;IAC3D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAc;IAE3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;;IAMvD,UAAU,CACR,MAAM,EAAE,OAAO,EACf,mBAAmB,EAAE,OAAO,EAC5B,iBAAiB,EAAE,OAAO,EAC1B,iBAAiB,EAAE,OAAO,EAC1B,OAAO,EAAE,IAAI,CAAC,OAAO,GACpB,IAAI;IAUP;;;;;OAKG;IACH,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC,OAAO,GAAG,SAAS;IAI1D;;;;;;;;;;OAUG;IACH,aAAa,CACX,mBAAmB,EAAE,OAAO,EAC5B,iBAAiB,EAAE,OAAO,EAC1B,iBAAiB,EAAE,OAAO,GACzB,MAAM;IAwBT;;OAEG;IACH,OAAO,CAAC,YAAY;CAkBrB"}

SharedLibs/TileMapHelper/src/render/TileMapPixiHelper.ts

@@ -137,7 +137,7 @@ export class PixiTileMapHelper {
     layerIndex: number
   ): void {
     // The extension doesn't handle the Pixi sub-namespace very well.
-    const pixiTileMap = untypedPixiTileMap as PIXI.tilemap.CompositeRectTileLayer;
+    const pixiTileMap = untypedPixiTileMap as PIXI.tilemap.CompositeTilemap;
     if (!pixiTileMap) return;
     pixiTileMap.clear();
 
@@ -152,17 +152,18 @@ export class PixiTileMapHelper {
       if (layer instanceof EditableObjectLayer) {
         const objectLayer = layer as EditableObjectLayer;
         for (const object of objectLayer.objects) {
-          const texture = textureCache.findTileTexture(
-            object.getTileId(),
-            object.isFlippedHorizontally(),
-            object.isFlippedVertically(),
-            object.isFlippedDiagonally()
-          );
+          const texture = textureCache.findTileTexture(object.getTileId());
           if (texture) {
-            pixiTileMap.addFrame(
+            const rotate = textureCache.getPixiRotate(
+              object.isFlippedHorizontally(),
+              object.isFlippedVertically(),
+              object.isFlippedDiagonally()
+            );
+            pixiTileMap.tile(
               texture,
               object.x,
-              object.y - objectLayer.tileMap.getTileHeight()
+              object.y - objectLayer.tileMap.getTileHeight(),
+              { rotate }
             );
           }
         }
@@ -183,21 +184,19 @@ export class PixiTileMapHelper {
             if (tileId === undefined) {
               continue;
             }
-            const tileTexture = textureCache.findTileTexture(
-              tileId,
-              tileLayer.isFlippedHorizontally(x, y),
-              tileLayer.isFlippedVertically(x, y),
-              tileLayer.isFlippedDiagonally(x, y)
-            );
+            const tileTexture = textureCache.findTileTexture(tileId);
             if (!tileTexture) {
               console.warn(`Unknown tile id: ${tileId} at (${x}, ${y})`);
               continue;
             }
-            const pixiTilemapFrame = pixiTileMap.addFrame(
-              tileTexture,
-              xPos,
-              yPos
+            const rotate = textureCache.getPixiRotate(
+              tileLayer.isFlippedHorizontally(x, y),
+              tileLayer.isFlippedVertically(x, y),
+              tileLayer.isFlippedDiagonally(x, y)
             );
+            const pixiTilemapFrame = pixiTileMap.tile(tileTexture, xPos, yPos, {
+              rotate,
+            });
 
             const tileDefinition = tileLayer.tileMap.getTileDefinition(tileId);
 

SharedLibs/TileMapHelper/src/render/TileTextureCache.ts

@@ -35,52 +35,32 @@ export class TileTextureCache {
     this._textures.set(globalTileUid, texture);
   }
 
+  /**
+   * Return the texture to use for the tile with the specified id.
+   *
+   * @param tileId The tile identifier
+   * @returns The texture for the given tile identifier.
+   */
+  findTileTexture(tileId: integer): PIXI.Texture | undefined {
+    return this._textures.get(tileId);
+  }
+
   /**
    * Return the texture to use for the tile with the specified uid, which can contains
    * information about rotation in bits 32, 31 and 30
    * (see https://doc.mapeditor.org/en/stable/reference/tmx-map-format/).
    *
-   * @param tileId The tile identifier
    * @param flippedHorizontally true if the tile is flipped horizontally.
    * @param flippedVertically true if the tile is flipped vertically.
    * @param flippedDiagonally true if the tile is flipped diagonally.
-   * @returns The texture for the given tile identifier and orientation.
+   * @returns the rotation "D8" number used by Pixi.
+   * @see https://pixijs.io/examples/#/textures/texture-rotate.js
    */
-  findTileTexture(
-    tileId: integer,
+  getPixiRotate(
     flippedHorizontally: boolean,
     flippedVertically: boolean,
     flippedDiagonally: boolean
-  ): PIXI.Texture | undefined {
-    let globalTileUid = this._getGlobalId(
-      tileId,
-      flippedHorizontally,
-      flippedVertically,
-      flippedDiagonally
-    );
-
-    if (this._textures.has(globalTileUid)) {
-      return this._textures.get(globalTileUid);
-    }
-    // If the texture is not in the cache, it's potentially because its ID
-    // is a flipped/rotated version of another ID.
-    const unflippedTexture = this._textures.get(tileId);
-    // If the tile still can't be found in the cache, it means the ID we got
-    // is invalid.
-    if (!unflippedTexture) return undefined;
-
-    // Clone the unflipped texture and save it in the cache
-    const frame = unflippedTexture.frame.clone();
-    const orig = unflippedTexture.orig.clone();
-    if (flippedDiagonally) {
-      const width = orig.width;
-      orig.width = orig.height;
-      orig.height = width;
-    }
-    const trim = orig.clone();
-
-    // Get the rotation "D8" number.
-    // See https://pixijs.io/examples/#/textures/texture-rotate.js
+  ): number {
     let rotate = 0;
     if (flippedDiagonally) {
       rotate = 10;
@@ -101,16 +81,7 @@ export class TileTextureCache {
         rotate = 4;
       }
     }
-
-    const flippedTexture = new PIXI.Texture(
-      unflippedTexture.baseTexture,
-      frame,
-      orig,
-      trim,
-      rotate
-    );
-    this._textures.set(globalTileUid, flippedTexture);
-    return flippedTexture;
+    return rotate;
   }
 
   /**

SharedLibs/TileMapHelper/types/global-pixi-tilemap.d.ts

@@ -1,29 +1,23 @@
 // https://github.com/pixijs/tilemap
 
 import {
-    CanvasTileRenderer,
-    CompositeRectTileLayer,
-    GraphicsLayer,
-    IMultiTextureOptions,
-    MultiTextureResource,
-    RectTileGeom,
-    RectTileLayer,
-    RectTileShader,
-    TileRenderer,
-    ZLayer,
+  CanvasTileRenderer,
+  CompositeTilemap,
+  Tilemap,
+  TilemapGeometry,
+  TilemapShader,
+  TileRenderer,
+  settings,
   } from './pixi-tilemap';
   
 declare module 'pixi.js' {
   export namespace tilemap {
-      export { CanvasTileRenderer };
-      export { CompositeRectTileLayer };
-      export { GraphicsLayer };
-      export { IMultiTextureOptions };
-      export { MultiTextureResource };
-      export { RectTileGeom };
-      export { RectTileLayer };
-      export { RectTileShader };
-      export { TileRenderer };
-      export { ZLayer };
+    export { CanvasTileRenderer };
+    export { CompositeTilemap };
+    export { Tilemap };
+    export { TilemapGeometry };
+    export { TilemapShader };
+    export { TileRenderer };
+    export { settings };
   }
 }

SharedLibs/TileMapHelper/types/pixi-tilemap.d.ts

@@ -1,193 +1,271 @@
 import PIXI = GlobalPIXIModule.PIXI;
 
 export declare class CanvasTileRenderer {
-    renderer: PIXI.Renderer;
+    renderer: PIXI.AbstractRenderer;
     tileAnim: number[];
     dontUseTransform: boolean;
-    constructor(renderer: PIXI.Renderer);
-}
-
-export declare class CompositeRectTileLayer extends PIXI.Container {
-    constructor(zIndex?: number, bitmaps?: Array<PIXI.Texture>, texPerChild?: number);
-    z: number;
-    // @ts-ignore Maybe it's a compatibility issue with the PIXI version we are using
-    zIndex: number;
-    modificationMarker: number;
-    shadowColor: Float32Array;
-    _globalMat: PIXI.Matrix;
-    _lastLayer: RectTileLayer;
-    texPerChild: number;
-    tileAnim: number[];
-    initialize(zIndex?: number, bitmaps?: Array<PIXI.Texture>, texPerChild?: number): void;
-    setBitmaps(bitmaps: Array<PIXI.Texture>): void;
-    clear(): void;
-    addRect(textureIndex: number, u: number, v: number, x: number, y: number, tileWidth: number, tileHeight: number, animX?: number, animY?: number, rotate?: number, animWidth?: number, animHeight?: number): this;
+    constructor(renderer: PIXI.AbstractRenderer);
+  }
+  
+  declare abstract class CanvasRenderer extends PIXI.AbstractRenderer {}
+  
+  declare class CompositeTilemap extends PIXI.Container {
+    readonly texturesPerTilemap: number;
+    tileAnim: [number, number];
+    protected lastModifiedTilemap: Tilemap;
+    private modificationMarker;
+    private shadowColor;
+    private _globalMat;
+    constructor(tileset?: Array<PIXI.BaseTexture>);
+    tileset(tileTextures: Array<PIXI.BaseTexture>): this;
+    clear(): this;
     tileRotate(rotate: number): this;
     tileAnimX(offset: number, count: number): this;
     tileAnimY(offset: number, count: number): this;
-    addFrame(texture_: PIXI.Texture | String | number, x: number, y: number, animX?: number, animY?: number, animWidth?: number, animHeight?: number): this;
-    renderCanvas(renderer: any): void;
+    tile(
+      tileTexture: PIXI.Texture | string | number,
+      x: number,
+      y: number,
+      options?: {
+        u?: number;
+        v?: number;
+        tileWidth?: number;
+        tileHeight?: number;
+        animX?: number;
+        animY?: number;
+        rotate?: number;
+        animCountX?: number;
+        animCountY?: number;
+        alpha?: number;
+      }
+    ): this;
+    renderCanvas(renderer: CanvasRenderer): void;
     render(renderer: PIXI.Renderer): void;
     isModified(anim: boolean): boolean;
     clearModify(): void;
-}
-
-export declare const Constant: {
-    maxTextures: number;
-    bufferSize: number;
-    boundSize: number;
-    boundCountPerBuffer: number;
+    addFrame(
+      texture: PIXI.Texture | string | number,
+      x: number,
+      y: number,
+      animX?: number,
+      animY?: number,
+      animWidth?: number,
+      animHeight?: number,
+      alpha?: number
+    ): this;
+    addRect(
+      textureIndex: number,
+      u: number,
+      v: number,
+      x: number,
+      y: number,
+      tileWidth: number,
+      tileHeight: number,
+      animX?: number,
+      animY?: number,
+      rotate?: number,
+      animWidth?: number,
+      animHeight?: number
+    ): this;
+    setBitmaps: (tileTextures: Array<PIXI.BaseTexture>) => this;
+    get texPerChild(): number;
+  }
+  export { CompositeTilemap as CompositeRectTileLayer };
+  export { CompositeTilemap };
+  
+  export declare const Constant: {
+    TEXTURES_PER_TILEMAP: number;
+    TEXTILE_DIMEN: number;
+    TEXTILE_UNITS: number;
+    TEXTILE_SCALE_MODE: PIXI.SCALE_MODES;
     use32bitIndex: boolean;
-    SCALE_MODE: PIXI.SCALE_MODES;
     DO_CLEAR: boolean;
-};
-
-export declare function fillSamplers(shader: TilemapShader, maxTextures: number): void;
-
-export declare function generateFragmentSrc(maxTextures: number, fragmentSrc: string): string;
-
-export declare function generateSampleSrc(maxTextures: number): string;
-
-export declare class GraphicsLayer extends PIXI.Graphics {
-    constructor(zIndex: number);
-    renderCanvas(renderer: any): void;
-    isModified(anim: boolean): boolean;
-    clearModify(): void;
-}
-
-export declare interface IMultiTextureOptions {
+    maxTextures: number;
+    boundSize: number;
     boundCountPerBuffer: number;
-    boundSize: number;
-    bufferSize: number;
-    DO_CLEAR?: boolean;
-}
-
-export declare class MultiTextureResource extends PIXI.Resource {
-    constructor(options: IMultiTextureOptions);
-    DO_CLEAR: boolean;
-    boundSize: number;
-    _clearBuffer: Uint8Array;
-    bind(baseTexture: PIXI.BaseTexture): void;
-    baseTex: PIXI.BaseTexture;
-    boundSprites: Array<PIXI.Sprite>;
-    dirties: Array<number>;
-    setTexture(ind: number, texture: PIXI.Texture): void;
-    upload(renderer: PIXI.Renderer, texture: PIXI.BaseTexture, glTexture: PIXI.GLTexture): boolean;
-}
-
-export declare const pixi_tilemap: {
+  };
+  
+  export declare function fillSamplers(
+    shader: TilemapShader,
+    maxTextures: number
+  ): void;
+  
+  export declare function generateFragmentSrc(
+    maxTextures: number,
+    fragmentSrc: string
+  ): string;
+  
+  export declare const pixi_tilemap: {
     CanvasTileRenderer: typeof CanvasTileRenderer;
-    CompositeRectTileLayer: typeof CompositeRectTileLayer;
+    CompositeRectTileLayer: typeof CompositeTilemap;
+    CompositeTilemap: typeof CompositeTilemap;
     Constant: {
-        maxTextures: number;
-        bufferSize: number;
-        boundSize: number;
-        boundCountPerBuffer: number;
-        use32bitIndex: boolean;
-        SCALE_MODE: PIXI.SCALE_MODES;
-        DO_CLEAR: boolean;
+      TEXTURES_PER_TILEMAP: number;
+      TEXTILE_DIMEN: number;
+      TEXTILE_UNITS: number;
+      TEXTILE_SCALE_MODE: PIXI.SCALE_MODES;
+      use32bitIndex: boolean;
+      DO_CLEAR: boolean;
+      maxTextures: number;
+      boundSize: number;
+      boundCountPerBuffer: number;
     };
-    GraphicsLayer: typeof GraphicsLayer;
-    MultiTextureResource: typeof MultiTextureResource;
-    RectTileLayer: typeof RectTileLayer;
+    TextileResource: typeof TextileResource;
+    MultiTextureResource: typeof TextileResource;
+    RectTileLayer: typeof Tilemap;
+    Tilemap: typeof Tilemap;
     TilemapShader: typeof TilemapShader;
-    RectTileShader: typeof RectTileShader;
-    RectTileGeom: typeof RectTileGeom;
+    TilemapGeometry: typeof TilemapGeometry;
+    RectTileShader: typeof TilemapShader;
+    RectTileGeom: typeof TilemapGeometry;
     TileRenderer: typeof TileRenderer;
-    ZLayer: typeof ZLayer;
-};
-
-export declare const POINT_STRUCT_SIZE = 12;
-
-export declare class RectTileGeom extends PIXI.Geometry {
-    vertSize: number;
-    vertPerQuad: number;
-    stride: number;
-    lastTimeAccess: number;
-    constructor();
-    buf: PIXI.Buffer;
-}
-
-export declare class RectTileLayer extends PIXI.Container {
-    constructor(zIndex: number, texture: PIXI.Texture | Array<PIXI.Texture>);
-    // @ts-ignore Maybe it's a compatibility issue with the PIXI version we are using
-    zIndex: number;
-    modificationMarker: number;
-    _$_localBounds: PIXI.Bounds;
+  };
+  
+  export declare const POINT_STRUCT_SIZE: number;
+  
+  export declare const settings: {
+    TEXTURES_PER_TILEMAP: number;
+    TEXTILE_DIMEN: number;
+    TEXTILE_UNITS: number;
+    TEXTILE_SCALE_MODE: PIXI.SCALE_MODES;
+    use32bitIndex: boolean;
+    DO_CLEAR: boolean;
+    maxTextures: number;
+    boundSize: number;
+    boundCountPerBuffer: number;
+  };
+  
+  export declare interface TextileOptions {
+    TEXTILE_DIMEN: number;
+    TEXTILE_UNITS: number;
+    DO_CLEAR?: boolean;
+  }
+  
+  export declare class TextileResource extends PIXI.Resource {
+    baseTexture: PIXI.BaseTexture;
+    private readonly doClear;
+    private readonly tileDimen;
+    private readonly tiles;
+    private _clearBuffer;
+    constructor(options?: TextileOptions);
+    tile(index: number, texture: PIXI.BaseTexture): void;
+    bind(baseTexture: PIXI.BaseTexture): void;
+    upload(
+      renderer: PIXI.Renderer,
+      texture: PIXI.BaseTexture,
+      glTexture: PIXI.GLTexture
+    ): boolean;
+  }
+  
+  declare class Tilemap extends PIXI.Container {
     shadowColor: Float32Array;
     _globalMat: PIXI.Matrix;
-    pointsBuf: Array<number>;
-    hasAnim: boolean;
-    textures: Array<PIXI.Texture>;
+    tileAnim: [number, number];
+    modificationMarker: number;
     offsetX: number;
     offsetY: number;
     compositeParent: boolean;
-    initialize(zIndex: number, textures: PIXI.Texture | Array<PIXI.Texture>): void;
-    clear(): void;
-    addFrame(texture_: PIXI.Texture | String | number, x: number, y: number, animX: number, animY: number): boolean;
-    addRect(textureIndex: number, u: number, v: number, x: number, y: number, tileWidth: number, tileHeight: number, animX?: number, animY?: number, rotate?: number, animCountX?: number, animCountY?: number): this;
+    protected tileset: Array<PIXI.BaseTexture>;
+    protected readonly tilemapBounds: PIXI.Bounds;
+    protected hasAnimatedTile: boolean;
+    private pointsBuf;
+    constructor(tileset: PIXI.BaseTexture | Array<PIXI.BaseTexture>);
+    getTileset(): Array<PIXI.BaseTexture>;
+    setTileset(tileset?: PIXI.BaseTexture | Array<PIXI.BaseTexture>): this;
+    clear(): this;
+    tile(
+      tileTexture: number | string | PIXI.Texture | PIXI.BaseTexture,
+      x: number,
+      y: number,
+      options?: {
+        u?: number;
+        v?: number;
+        tileWidth?: number;
+        tileHeight?: number;
+        animX?: number;
+        animY?: number;
+        rotate?: number;
+        animCountX?: number;
+        animCountY?: number;
+        alpha?: number;
+      }
+    ): this;
     tileRotate(rotate: number): void;
     tileAnimX(offset: number, count: number): void;
     tileAnimY(offset: number, count: number): void;
-    renderCanvas(renderer: any): void;
-    renderCanvasCore(renderer: any): void;
-    vbId: number;
-    vb: RectTileGeom;
-    vbBuffer: ArrayBuffer;
-    vbArray: Float32Array;
-    vbInts: Uint32Array;
-    destroyVb(): void;
+    tileAlpha(alpha: number): void;
+    renderCanvas(renderer: CanvasRenderer): void;
+    renderCanvasCore(renderer: CanvasRenderer): void;
+    private vbId;
+    private vb;
+    private vbBuffer;
+    private vbArray;
+    private vbInts;
+    private destroyVb;
     render(renderer: PIXI.Renderer): void;
     renderWebGLCore(renderer: PIXI.Renderer, plugin: TileRenderer): void;
     isModified(anim: boolean): boolean;
     clearModify(): void;
     protected _calculateBounds(): void;
     getLocalBounds(rect?: PIXI.Rectangle): PIXI.Rectangle;
-    destroy(options?: any): void;
-}
-
-export declare class RectTileShader extends TilemapShader {
-    constructor(maxTextures: number);
-}
-
-export declare abstract class TilemapShader extends PIXI.Shader {
+    destroy(options?: PIXI.IDestroyOptions): void;
+    addFrame(
+      texture: PIXI.Texture | string | number,
+      x: number,
+      y: number,
+      animX: number,
+      animY: number
+    ): boolean;
+    addRect(
+      textureIndex: number,
+      u: number,
+      v: number,
+      x: number,
+      y: number,
+      tileWidth: number,
+      tileHeight: number,
+      animX?: number,
+      animY?: number,
+      rotate?: number,
+      animCountX?: number,
+      animCountY?: number,
+      alpha?: number
+    ): this;
+  }
+  export { Tilemap as RectTileLayer };
+  export { Tilemap };
+  
+  export declare class TilemapGeometry extends PIXI.Geometry {
+    vertSize: number;
+    vertPerQuad: number;
+    stride: number;
+    lastTimeAccess: number;
+    constructor();
+    buf: any;
+  }
+  
+  export declare class TilemapShader extends PIXI.Shader {
     maxTextures: number;
-    constructor(maxTextures: number, shaderVert: string, shaderFrag: string);
-}
-
-export declare class TileRenderer extends PIXI.ObjectRenderer {
-    renderer: PIXI.Renderer;
-    gl: WebGLRenderingContext;
-    sn: number;
-    indexBuffer: PIXI.Buffer;
-    ibLen: number;
+    constructor(maxTextures: number);
+  }
+  
+  export declare class TileRenderer extends PIXI.ObjectRenderer {
+    readonly renderer: PIXI.Renderer;
     tileAnim: number[];
-    texLoc: Array<number>;
-    rectShader: RectTileShader;
-    texResources: Array<MultiTextureResource>;
+    private ibLen;
+    private indexBuffer;
+    private shader;
+    private textiles;
     constructor(renderer: PIXI.Renderer);
-    initBounds(): void;
-    bindTexturesWithoutRT(renderer: PIXI.Renderer, shader: TilemapShader, textures: Array<PIXI.Texture>): void;
-    bindTextures(renderer: PIXI.Renderer, shader: TilemapShader, textures: Array<PIXI.Texture>): void;
+    bindTileTextures(
+      renderer: PIXI.Renderer,
+      textures: Array<PIXI.BaseTexture>
+    ): void;
     start(): void;
-    createVb(): RectTileGeom;
-    checkIndexBuffer(size: number, vb?: RectTileGeom): void;
+    createVb(): TilemapGeometry;
     getShader(): TilemapShader;
     destroy(): void;
-}
-
-export declare class ZLayer extends PIXI.Container {
-    constructor(tilemap: PIXI.Container, zIndex: number);
-    tilemap: any;
-    z: number;
-    // @ts-ignore Maybe it's a compatibility issue with the PIXI version we are using
-    zIndex: number;
-    _previousLayers: number;
-    canvasBuffer: HTMLCanvasElement;
-    _tempRender: any;
-    _lastAnimationFrame: number;
-    layerTransform: PIXI.Matrix;
-    clear(): void;
-    cacheIfDirty(): void;
-    renderCanvas(renderer: any): void;
-}
+    checkIndexBuffer(size: number, _vb?: TilemapGeometry): void;
+    private makeTextiles;
+  }
+