angry-pixel 1.0.7 → 1.1.0

package/lib/physics/collision-old/CollisionData.d.ts

@@ -0,0 +1,8 @@
+import { Vector2 } from "../../math/Vector2";
+export declare class CollisionData {
+    private _penetration;
+    private _displacementDirection;
+    constructor(penetration: number, displacementDirection: Vector2);
+    get penetration(): number;
+    get displacementDirection(): Vector2;
+}

package/lib/physics/collision-old/CollisionManager.d.ts

@@ -0,0 +1,30 @@
+import { Rectangle } from "../../math/Rectangle";
+import { ICollider } from "./collider/ICollider";
+import { CollisionData } from "./CollisionData";
+import { ICollisionResolver } from "./resolver/ICollisionResolver";
+export interface Collision {
+    localCollider: ICollider;
+    remoteCollider: ICollider;
+    collisionData: CollisionData;
+}
+export declare class CollisionManager {
+    private colliders;
+    private quadTree;
+    private bounds;
+    private fixedQuadTree;
+    private resolver;
+    private collisions;
+    private minBounds;
+    private maxBounds;
+    private newBounds;
+    constructor(resolver: ICollisionResolver, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
+    addCollider(collider: ICollider): void;
+    removeCollider(collider: ICollider): void;
+    getFrameCollisionsForCollider(collider: ICollider): Collision[];
+    refreshCollisionsForCollider(collider: ICollider): Collision[];
+    update(): void;
+    private updateNewBounds;
+    private updateCollisions;
+    private broadPhase;
+    private narrowPhase;
+}

package/lib/physics/collision-old/QuadTree.d.ts

@@ -0,0 +1,32 @@
+import { Rectangle } from "../../math/Rectangle";
+import { ICollider } from "./collider/ICollider";
+export declare const DEFAULT_MAX_COLLIDERS: number;
+export declare const DEFAULT_MAX_LEVELS: number;
+export declare class QuadTree {
+    private _bounds;
+    private _quadrants;
+    private readonly maxLevels;
+    private readonly maxColliders;
+    private readonly level;
+    private colliders;
+    private readonly sw;
+    private readonly se;
+    private readonly nw;
+    private readonly ne;
+    private center;
+    private childrenWidth;
+    private childrenHeight;
+    private quadrantsForCollider;
+    constructor(level: number, bounds: Rectangle, maxLevels?: number, maxColliders?: number);
+    get bounds(): Rectangle;
+    get quadrants(): QuadTree[];
+    updateBounds(bounds: Rectangle): void;
+    clearColliders(): void;
+    clearQuadrants(): void;
+    addCollider(collider: ICollider): void;
+    retrieve(collider: ICollider): ICollider[];
+    private splitQuad;
+    private getChildrenQuadrantForCollider;
+    private insertColliderIntoChildrenQuads;
+    private updateCache;
+}

package/lib/physics/collision-old/collider/ICollider.d.ts

@@ -0,0 +1,14 @@
+import { GameObject } from "../../../core/GameObject";
+import { Vector2 } from "../../../math/Vector2";
+import { Shape } from "../shape/Shape";
+export interface ICollider {
+    position: Vector2;
+    readonly shape: Shape;
+    readonly gameObject: GameObject;
+    readonly physics: boolean;
+    readonly bottomLeftQuadVertex: Vector2;
+    readonly bottomRightQuadVertex: Vector2;
+    readonly topLeftQuadVertex: Vector2;
+    readonly topRightQuadVertex: Vector2;
+    readonly updateCollisions: boolean;
+}

package/lib/physics/collision-old/collider/RectangleCollider.d.ts

@@ -0,0 +1,32 @@
+import { GameObject } from "../../../core/GameObject";
+import { Vector2 } from "../../../math/Vector2";
+import { Rectangle } from "../shape/Rectangle";
+import { ICollider } from "./ICollider";
+export declare class RectangleCollider implements ICollider {
+    readonly gameObject: GameObject;
+    readonly shape: Rectangle;
+    readonly physics: boolean;
+    readonly updateCollisions: boolean;
+    private _position;
+    private _width;
+    private _height;
+    private _angle;
+    private _quadVertices;
+    private _quadMaxBounds;
+    private _quadMinBounds;
+    constructor(position: Vector2, width: number, height: number, physics: boolean, gameObject: GameObject, angle?: number, updateCollisions?: boolean);
+    set position(coordinates: Vector2);
+    get position(): Vector2;
+    set width(width: number);
+    get width(): number;
+    set height(height: number);
+    get height(): number;
+    get angle(): number;
+    set angle(angle: number);
+    get bottomLeftQuadVertex(): Vector2;
+    get bottomRightQuadVertex(): Vector2;
+    get topLeftQuadVertex(): Vector2;
+    get topRightQuadVertex(): Vector2;
+    private updateShape;
+    private updateQuadVertices;
+}

package/lib/physics/collision-old/resolver/AABBResolver.d.ts

@@ -0,0 +1,14 @@
+import { CollisionData } from "../CollisionData";
+import { Shape } from "../shape/Shape";
+import { ICollisionResolver } from "./ICollisionResolver";
+export declare class AABBResolver implements ICollisionResolver {
+    private shapeARect;
+    private shapeBRect;
+    private overlapX;
+    private overlapY;
+    private minOverlap;
+    private displaceDirection;
+    getCollisionData(shapeA: Shape, shapeB: Shape): CollisionData | null;
+    private setShapeRect;
+    private preventContainment;
+}

package/lib/physics/collision-old/resolver/ICollisionResolver.d.ts

@@ -0,0 +1,5 @@
+import { CollisionData } from "../CollisionData";
+import { Shape } from "../shape/Shape";
+export interface ICollisionResolver {
+    getCollisionData(shapeA: Shape, shapeB: Shape): CollisionData | null;
+}

package/lib/physics/collision-old/resolver/SatResolver.d.ts

@@ -0,0 +1,14 @@
+import { Shape } from "../shape/Shape";
+import { CollisionData } from "../CollisionData";
+import { ICollisionResolver } from "./ICollisionResolver";
+export declare class SatResolver implements ICollisionResolver {
+    private axes;
+    private projA;
+    private projB;
+    private currentOverlap;
+    private minOverlap;
+    private displaceDirection;
+    getCollisionData(shapeA: Shape, shapeB: Shape): CollisionData | null;
+    private projectShapeOntoAxis;
+    private preventContainment;
+}

package/lib/physics/collision-old/shape/Rectangle.d.ts

@@ -0,0 +1,13 @@
+import { Vector2 } from "../../../math/Vector2";
+import { Shape } from "./Shape";
+export declare class Rectangle extends Shape {
+    private cacheVector;
+    private axes;
+    constructor(position: Vector2, width: number, height: number, angle?: number);
+    update(): void;
+    private updateModel;
+    private updateDirection;
+    private updateAxes;
+    clone(): Rectangle;
+    getAxes(): Vector2[];
+}

package/lib/physics/collision-old/shape/Shape.d.ts

@@ -0,0 +1,28 @@
+import { Vector2 } from "../../../math/Vector2";
+export declare enum ShapeType {
+    Rectangle = 0
+}
+export declare abstract class Shape {
+    protected _type: ShapeType;
+    protected _model: Vector2[];
+    protected _vertices: Vector2[];
+    protected _position: Vector2;
+    protected _direction: Vector2;
+    protected _height: number;
+    protected _width: number;
+    protected _angle: number;
+    get type(): ShapeType;
+    get position(): Vector2;
+    set position(position: Vector2);
+    get angle(): number;
+    set angle(angle: number);
+    get width(): number;
+    set width(width: number);
+    get height(): number;
+    set height(height: number);
+    get direction(): Vector2;
+    get vertices(): Vector2[];
+    abstract update(): void;
+    abstract clone(): Shape;
+    abstract getAxes(): Vector2[];
+}

package/lib/physics/rigodBody/RigidBodyData.d.ts

@@ -0,0 +1,9 @@
+import { Vector2 } from "../../math/Vector2";
+import { ColliderData } from "../collision/ColliderData";
+export interface RigidBodyData {
+    position: Vector2;
+    gravity: number;
+    velocity: Vector2;
+    layersToCollider: string[];
+    colliders: ColliderData[];
+}

package/lib/physics/rigodBody/RigidBodyManager.d.ts

@@ -0,0 +1,23 @@
+import { CollisionManager } from "../collision/CollisionManager";
+import { RigidBodyData } from "./RigidBodyData";
+export declare enum RigidBodyType {
+    Static = 0,
+    Dynamic = 1
+}
+export declare class RigidBodyManager {
+    private readonly collisionManager;
+    private rigidBodyData;
+    private cacheVelocity;
+    private cacheDisplacement;
+    private cacheNewDisplacement;
+    private cacheCollisions;
+    constructor(collisionManager: CollisionManager);
+    addRigidBodyData(data: RigidBodyData): void;
+    removeRigidBodyData(data: RigidBodyData): void;
+    update(deltaTime: number): void;
+    private applyGravity;
+    private applyVelocity;
+    private applyReposition;
+    private getCollisions;
+    clear(): void;
+}

package/lib/rendering/CameraData.d.ts

@@ -0,0 +1,9 @@
+import { Rectangle } from "../math/Rectangle";
+export declare class CameraData {
+    depth: number;
+    layers: string[];
+    originalViewportRect: Rectangle;
+    viewportRect: Rectangle;
+    worldSpaceRect: Rectangle;
+    zoom: number;
+}

package/lib/rendering/ContextRenderer.d.ts

@@ -0,0 +1,6 @@
+import { CameraData } from "./CameraData";
+import { RenderData } from "./renderData/RenderData";
+export interface ContextRenderer {
+    render(camera: CameraData, renderData: RenderData): void;
+    clearCanvas(color: string | null): void;
+}

package/lib/rendering/CullingService.d.ts

@@ -0,0 +1,10 @@
+import { CameraData } from "./CameraData";
+import { RenderData } from "./renderData/RenderData";
+export declare class CullingService {
+    applyCulling(camera: CameraData, renderDataCollection: RenderData[]): RenderData[];
+    private cullSprite;
+    private cullTilemap;
+    private cullCollider;
+    private cullText;
+    private isTargetVisible;
+}

package/lib/rendering/FontAtlasFactory.d.ts

@@ -0,0 +1,24 @@
+export declare class FontAtlasFactory {
+    private bitmapSize;
+    private chars;
+    private fontAtlas;
+    private loading;
+    hasFontAtlas(fontFamily: string): boolean;
+    loadingFontAtlas(fontFamily: string): boolean;
+    getFontAtlas(fontFamily: string): FontAtlas;
+    asyncCreate(charRanges: number[], fontFamily: string, fontUrl?: string, bitmapSize?: number): void;
+    private loadFont;
+    private renderAtlas;
+}
+export declare class FontAtlas {
+    readonly name: string;
+    readonly canvas: HTMLCanvasElement;
+    readonly glyphsData: Map<string, GlyphData>;
+    constructor(name: string);
+}
+export interface GlyphData {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

package/lib/rendering/RenderManager.d.ts

@@ -0,0 +1,22 @@
+import { ContextRenderer } from "./ContextRenderer";
+import { RenderData } from "./renderData/RenderData";
+import { CameraData } from "./CameraData";
+import { CullingService } from "./CullingService";
+export declare class RenderManager {
+    private renderer;
+    private cullingService;
+    private canvasColor;
+    private debug;
+    private renderData;
+    private cameraData;
+    constructor(gameRenderer: ContextRenderer, cullingService: CullingService, canvasColor: string, debug?: boolean);
+    clearCanvas(): void;
+    addRenderData(renderData: RenderData): void;
+    addCameraData(cameraData: CameraData): void;
+    render(): void;
+    clearData(): void;
+    private renderByCamera;
+    private orderRendeData;
+    private updateFromCameraViewport;
+    private setPositionInViewport;
+}

package/lib/rendering/context2D/Context2DRenderer.d.ts

@@ -0,0 +1,18 @@
+import { CameraData } from "../CameraData";
+import { ContextRenderer } from "../ContextRenderer";
+import { RenderData } from "../renderData/RenderData";
+export declare class Context2DRenderer implements ContextRenderer {
+    private canvas;
+    private canvasContext;
+    private imagePosition;
+    constructor(canvas: HTMLCanvasElement);
+    clearCanvas(color?: string | null): void;
+    render(camera: CameraData, renderData: RenderData): void;
+    private renderImage;
+    private renderTilemap;
+    private renderText;
+    private renderCollider;
+    private applyZoom;
+    private updateRenderPosition;
+    private centerImage;
+}

package/lib/rendering/renderData/ColliderRenderData.d.ts

@@ -0,0 +1,7 @@
+import { Shape } from "../../physics/collision/shape/Shape";
+import { RenderData, RenderDataType } from "./RenderData";
+export declare class ColliderRenderData extends RenderData {
+    type: RenderDataType;
+    color: string;
+    shape: Shape;
+}

package/lib/rendering/renderData/GeometricRenderData.d.ts

@@ -0,0 +1,12 @@
+import { Rectangle } from "../../math/Rectangle";
+import { RenderData, RenderDataType } from "./RenderData";
+declare type Geometric = Rectangle;
+declare type GeometricType = "Rectangle";
+export declare class GeometricRenderData extends RenderData {
+    type: RenderDataType;
+    color: string;
+    geometricType: GeometricType;
+    geometric: Geometric;
+    getGeometric<T extends Geometric>(): T;
+}
+export {};

package/lib/rendering/renderData/ImageRenderData.d.ts

@@ -0,0 +1,22 @@
+import { RenderData, RenderDataType } from "./RenderData";
+export interface Slice {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class ImageRenderData extends RenderData {
+    type: RenderDataType;
+    image: HTMLImageElement;
+    width: number;
+    height: number;
+    slice: Slice;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+    rotation: number;
+    smooth: boolean;
+    alpha: number;
+    maskColor: string;
+    maskColorMix: number;
+    tintColor: string;
+}

package/lib/rendering/renderData/MaskRenderData.d.ts

@@ -0,0 +1,9 @@
+import { RenderData, RenderDataType } from "./RenderData";
+export declare class MaskRenderData extends RenderData {
+    type: RenderDataType;
+    width: number;
+    height: number;
+    color: string;
+    rotation: number;
+    alpha: number;
+}

package/lib/rendering/renderData/RenderData.d.ts

@@ -0,0 +1,22 @@
+import { Rectangle } from "../../math/Rectangle";
+import { Vector2 } from "../../math/Vector2";
+export declare enum RenderDataType {
+    Image = 0,
+    Text = 1,
+    Collider = 2,
+    Tilemap = 3,
+    Mask = 4
+}
+export declare abstract class RenderData {
+    abstract type: RenderDataType;
+    ui: boolean;
+    debug: boolean;
+    layer: string;
+    viwportRect: Rectangle;
+    private _position;
+    get position(): Vector2;
+    set position(position: Vector2);
+    private _positionInViewport;
+    get positionInViewport(): Vector2;
+    set positionInViewport(position: Vector2);
+}

package/lib/rendering/renderData/TextRenderData.d.ts

@@ -0,0 +1,22 @@
+import { Vector2 } from "../../math/Vector2";
+import { RenderData, RenderDataType } from "./RenderData";
+export declare type Orientation = "rightUp" | "rightDown" | "center";
+export declare class TextRenderData extends RenderData {
+    type: RenderDataType;
+    color: string;
+    text: string;
+    fontFamily: string;
+    fontUrl: string;
+    fontSize: number;
+    lineSeparation: number;
+    letterSpacing: number;
+    bitmapSize: number;
+    charRanges: number[];
+    smooth: boolean;
+    bitmapOffset: Vector2;
+    width: number;
+    height: number;
+    rotation: number;
+    opacity: number;
+    orientation: Orientation;
+}

package/lib/rendering/renderData/TilemapRenderData.d.ts

@@ -0,0 +1,22 @@
+import { Vector2 } from "../../math/Vector2";
+import { Tile } from "../../component/rendering/tilemap/Tile";
+import { RenderData, RenderDataType } from "./RenderData";
+export declare class TileRenderData {
+    tile: Tile;
+    position: Vector2;
+    positionInViewport: Vector2;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+}
+export declare class TilemapRenderData extends RenderData {
+    type: RenderDataType;
+    image: HTMLImageElement;
+    smooth: boolean;
+    alpha: number;
+    tilesData: TileRenderData[];
+    tilesToRender: TileRenderData[];
+    tileWidth: number;
+    tileHeight: number;
+    textureCorrection: number;
+    tintColor: string;
+}

package/lib/rendering/webGL/ProgramFactory.d.ts

@@ -0,0 +1,7 @@
+import { ShaderLoader } from "./ShaderLoader";
+export declare class ProgramFactory {
+    private readonly shaderLoader;
+    constructor(shaderLoader: ShaderLoader);
+    create(gl: WebGLRenderingContext, vertexShaderSource: string, fragmentShaderSource: string): WebGLProgram;
+    private link;
+}

package/lib/rendering/webGL/ProgramManager.d.ts

@@ -0,0 +1,26 @@
+import { ProgramFactory } from "./ProgramFactory";
+import { WebGLContextVersion } from "./WebGLRenderer";
+export declare class ProgramManager {
+    private gl;
+    private contextVersion;
+    private programFactory;
+    private program;
+    positionBuffer: WebGLBuffer;
+    textureBuffer: WebGLBuffer;
+    positionCoordsAttr: GLint;
+    texCoordsAttr: GLint;
+    modelMatrixUniform: WebGLUniformLocation;
+    projectionMatrixUniform: WebGLUniformLocation;
+    textureMatrixUniform: WebGLUniformLocation;
+    renderTextureUniform: WebGLUniformLocation;
+    textureUniform: WebGLUniformLocation;
+    solidColorUniform: WebGLUniformLocation;
+    useTintColorUniform: WebGLUniformLocation;
+    tintColorUniform: WebGLUniformLocation;
+    useMaskColorUniform: WebGLUniformLocation;
+    maskColorUniform: WebGLUniformLocation;
+    maskColorMixUniform: WebGLUniformLocation;
+    alphaUniform: WebGLUniformLocation;
+    constructor(programFactory: ProgramFactory, contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement);
+    loadProgram(): void;
+}

package/lib/rendering/webGL/ShaderLoader.d.ts

@@ -0,0 +1,3 @@
+export declare class ShaderLoader {
+    load(gl: WebGLRenderingContext, type: number, source: string): WebGLShader;
+}

package/lib/rendering/webGL/TextureFactory.d.ts

@@ -0,0 +1,8 @@
+import { WebGLContextVersion } from "./WebGLRenderer";
+export declare class TextureFactory {
+    private gl;
+    constructor(contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement);
+    createFromImage(image: HTMLImageElement, smooth?: boolean, texture?: WebGLTexture): WebGLTexture;
+    createFromCanvas(canvas: HTMLCanvasElement, smooth?: boolean, texture?: WebGLTexture): WebGLTexture;
+    private create;
+}

package/lib/rendering/webGL/TextureManager.d.ts

@@ -0,0 +1,11 @@
+import { TextureFactory } from "./TextureFactory";
+export declare class TextureManager {
+    private textureFactory;
+    private textures;
+    constructor(textureFactory: TextureFactory);
+    getTexture(name: string): WebGLTexture | null;
+    getOrCreateTextureFromImage(image: HTMLImageElement, smooth?: boolean): WebGLTexture;
+    createTextureFromImage(image: HTMLImageElement, smooth?: boolean): WebGLTexture;
+    getOrCreateTextureFromCanvas(name: string, canvas: HTMLCanvasElement, smooth?: boolean): WebGLTexture;
+    createTextureFromCanvas(name: string, canvas: HTMLCanvasElement, smooth?: boolean): WebGLTexture;
+}

package/lib/rendering/webGL/Utils.d.ts

@@ -0,0 +1,7 @@
+export declare type RGBA = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+export declare const hexToRgba: (hex: string) => RGBA | null;

package/lib/rendering/webGL/WebGLRenderer.d.ts

@@ -0,0 +1,36 @@
+import { CameraData } from "../CameraData";
+import { ContextRenderer } from "../ContextRenderer";
+import { RenderData } from "../renderData/RenderData";
+import { TextureManager } from "./TextureManager";
+import { ImageRenderer } from "./renderer/ImageRenderer";
+import { FontAtlasFactory } from "../FontAtlasFactory";
+import { ProgramManager } from "./ProgramManager";
+import { TextRenderer } from "./renderer/TextRenderer";
+import { GeometricRenderer } from "./renderer/GeometricRenderer";
+import { TilemapRenderer } from "./renderer/TilemapRenderer";
+import { MaskRenderer } from "./renderer/MaskRenderer";
+export declare enum WebGLContextVersion {
+    LegacyWebGL = "webgl",
+    WebGL2 = "webgl2"
+}
+export declare type LastRender = "image" | "text" | "geometric" | "tilemap" | "mask";
+export declare class WebGLRenderer implements ContextRenderer {
+    private readonly canvas;
+    private readonly gl;
+    private readonly textureManager;
+    private readonly fontAtlasFactory;
+    private readonly imageRenderer;
+    private readonly textRenderer;
+    private readonly geometricRenderer;
+    private readonly tilemapRenderer;
+    private readonly maskRenderer;
+    private lastRender;
+    constructor(contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement, programManager: ProgramManager, textureManager: TextureManager, fontAtlasFactory: FontAtlasFactory, imageRenderer: ImageRenderer, tilemapRenderer: TilemapRenderer, textRenderer: TextRenderer, geometricRenderer: GeometricRenderer, maskRenderer: MaskRenderer);
+    clearCanvas(color: string): void;
+    render(camera: CameraData, renderData: RenderData): void;
+    private renderImage;
+    private renderTilemap;
+    private renderText;
+    private renderMask;
+    private fontAtlasLoaded;
+}

package/lib/rendering/webGL/renderer/GeometricRenderer.d.ts

@@ -0,0 +1,20 @@
+import { Rectangle } from "../../../math/Rectangle";
+import { LastRender, WebGLContextVersion } from "../WebGLRenderer";
+import { ColliderRenderData } from "../../renderData/ColliderRenderData";
+import { ProgramManager } from "../ProgramManager";
+export declare class GeometricRenderer {
+    private gl;
+    private programManager;
+    private projectionMatrix;
+    private modelMatrix;
+    private textureMatrix;
+    private readonly vertices;
+    private readonly texVertices;
+    private lastVertices;
+    private lastRender;
+    constructor(contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement, programManager: ProgramManager);
+    renderCollider(viewportRect: Rectangle, renderData: ColliderRenderData, lastRender: LastRender): void;
+    private renderPolygon;
+    private generateVerticesKey;
+    private generatePolygonVertices;
+}

package/lib/rendering/webGL/renderer/ImageRenderer.d.ts

@@ -0,0 +1,16 @@
+import { Rectangle } from "../../../math/Rectangle";
+import { ImageRenderData } from "../../renderData/ImageRenderData";
+import { LastRender, WebGLContextVersion } from "../WebGLRenderer";
+import { ProgramManager } from "../ProgramManager";
+export declare class ImageRenderer {
+    private gl;
+    private programManager;
+    private projectionMatrix;
+    private modelMatrix;
+    private textureMatrix;
+    private posVertices;
+    private texVertices;
+    private lastTexture;
+    constructor(contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement, programManager: ProgramManager);
+    render(viewportRect: Rectangle, texture: WebGLTexture, renderData: ImageRenderData, lastRender: LastRender): void;
+}

package/lib/rendering/webGL/renderer/MaskRenderer.d.ts

@@ -0,0 +1,14 @@
+import { Rectangle } from "../../../math/Rectangle";
+import { MaskRenderData } from "../../renderData/MaskRenderData";
+import { ProgramManager } from "../ProgramManager";
+import { LastRender, WebGLContextVersion } from "../WebGLRenderer";
+export declare class MaskRenderer {
+    private gl;
+    private programManager;
+    private projectionMatrix;
+    private modelMatrix;
+    private textureMatrix;
+    private readonly vertices;
+    constructor(contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement, programManager: ProgramManager);
+    render(viewportRect: Rectangle, renderData: MaskRenderData, lastRender: LastRender): void;
+}

package/lib/rendering/webGL/renderer/TextRenderer.d.ts

@@ -0,0 +1,21 @@
+import { Rectangle } from "../../../math/Rectangle";
+import { LastRender, WebGLContextVersion } from "../WebGLRenderer";
+import { FontAtlas } from "../../FontAtlasFactory";
+import { TextRenderData } from "../../renderData/TextRenderData";
+import { ProgramManager } from "../ProgramManager";
+export declare class TextRenderer {
+    private gl;
+    private programManager;
+    private projectionMatrix;
+    private modelMatrix;
+    private textureMatrix;
+    private posVertices;
+    private texVertices;
+    private posVerticesSize;
+    private lastTexture;
+    constructor(contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement, programManager: ProgramManager);
+    render(viewportRect: Rectangle, texture: WebGLTexture, fontAtlas: FontAtlas, renderData: TextRenderData, lastRender: LastRender): void;
+    private generateTextVertices;
+    private getTranslationForOrientation;
+    private getDimensions;
+}