angry-pixel 1.0.8 → 1.1.1

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,10 @@
+import { Vector2 } from "../../math/Vector2";
+import { ColliderData } from "../collision/ColliderData";
+export interface RigidBodyData {
+    position: Vector2;
+    gravity: number;
+    velocity: Vector2;
+    layersToCollider: string[];
+    colliders: ColliderData[];
+    cacheVelocity?: Vector2;
+}

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/CullingService.d.ts

@@ -4,7 +4,6 @@ export declare class CullingService {
     applyCulling(camera: CameraData, renderDataCollection: RenderData[]): RenderData[];
     private cullSprite;
     private cullTilemap;
-    private cullCollider;
     private cullGeometric;
     private cullText;
     private isTargetVisible;

package/lib/rendering/FontAtlasFactory.d.ts

@@ -1,7 +1,12 @@
 export declare class FontAtlasFactory {
     private bitmapSize;
     private chars;
-    create(charRanges: number[], fontFamily: string, fontUrl?: string, bitmapSize?: number): Promise<FontAtlas>;
+    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;
 }

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

@@ -1,12 +1,17 @@
 import { Rectangle } from "../../math/Rectangle";
+import { Vector2 } from "../../math/Vector2";
 import { RenderData, RenderDataType } from "./RenderData";
-declare type Geometric = Rectangle;
-declare type GeometricType = "Rectangle";
+export declare enum GeometricShape {
+    Polygon = 0,
+    Circumference = 1,
+    Line = 2
+}
 export declare class GeometricRenderData extends RenderData {
     type: RenderDataType;
     color: string;
-    geometricType: GeometricType;
-    geometric: Geometric;
-    getGeometric<T extends Geometric>(): T;
+    shape: GeometricShape;
+    vertexModel: Vector2[];
+    angle: number;
+    radius: number;
+    boundingBox: Rectangle;
 }
-export {};

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

@@ -3,9 +3,9 @@ import { Vector2 } from "../../math/Vector2";
 export declare enum RenderDataType {
     Image = 0,
     Text = 1,
-    Geometric = 2,
-    Collider = 3,
-    Tilemap = 4
+    Tilemap = 2,
+    Mask = 3,
+    Geometric = 4
 }
 export declare abstract class RenderData {
     abstract type: RenderDataType;

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

@@ -1,6 +1,11 @@
 import { Vector2 } from "../../math/Vector2";
-import { Tile } from "../../component/renderingComponent/tilemap/Tile";
 import { RenderData, RenderDataType } from "./RenderData";
+interface Tile {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
 export declare class TileRenderData {
     tile: Tile;
     position: Vector2;
@@ -20,3 +25,4 @@ export declare class TilemapRenderData extends RenderData {
     textureCorrection: number;
     tintColor: string;
 }
+export {};

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

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

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

@@ -8,27 +8,29 @@ 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";
+export declare type LastRender = "image" | "text" | "geometric" | "tilemap" | "mask";
 export declare class WebGLRenderer implements ContextRenderer {
-    private canvas;
-    private gl;
-    private textureManager;
-    private fontAtlasFactory;
-    private imageRenderer;
-    private textRenderer;
-    private geometricRenderer;
-    private tilemapRenderer;
+    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;
-    private fontAtlas;
-    constructor(contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement, programManager: ProgramManager, textureManager: TextureManager, fontAtlasFactory: FontAtlasFactory, imageRenderer: ImageRenderer, tilemapRenderer: TilemapRenderer, textRenderer: TextRenderer, geometricRenderer: GeometricRenderer);
+    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

@@ -1,6 +1,5 @@
 import { Rectangle } from "../../../math/Rectangle";
 import { LastRender, WebGLContextVersion } from "../WebGLRenderer";
-import { ColliderRenderData } from "../../renderData/ColliderRenderData";
 import { ProgramManager } from "../ProgramManager";
 import { GeometricRenderData } from "../../renderData/GeometricRenderData";
 export declare class GeometricRenderer {
@@ -10,13 +9,13 @@ export declare class GeometricRenderer {
     private modelMatrix;
     private textureMatrix;
     private readonly vertices;
-    private readonly texVertices;
+    private readonly circumferenceVertices;
     private lastVertices;
     private lastRender;
     constructor(contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement, programManager: ProgramManager);
-    renderCollider(viewportRect: Rectangle, renderData: ColliderRenderData, lastRender: LastRender): void;
-    renderGeometric(viewportRect: Rectangle, renderData: GeometricRenderData, lastRender: LastRender): void;
-    private renderRectangle;
-    private generateRectangleVertices;
-    private generateLineVertices;
+    render(viewportRect: Rectangle, renderData: GeometricRenderData, lastRender: LastRender): void;
+    private renderLines;
+    private generateVerticesKey;
+    private generatePolygonVertices;
+    private renderCircumference;
 }

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/shader/imageFragmentShader.d.ts

@@ -1 +1 @@
-export declare const imageFragmentShader = "#version 300 es\nprecision mediump float;\n\nout vec4 fragColor;\n\nin vec2 texCoords;\n\nuniform int u_renderTexture;\nuniform sampler2D u_texImage;\nuniform vec4 u_solidColor;\n\nuniform int u_useTintColor;\nuniform vec4 u_tintColor;\n\nuniform int u_useMaskColor;\nuniform vec4 u_maskColor;\nuniform float u_maskColorMix;\n\nuniform float u_alpha;\n\nvoid main()\n{\n    if (u_renderTexture == 1) {\n        vec4 texColor = texture(u_texImage, texCoords);\n\n        if (texColor.a < 0.0001) {\n            discard;\n        }\n\n        if (u_useTintColor == 1) {\n            texColor = u_tintColor * texColor;\n        }\n\n        if (u_useMaskColor == 1) {\n            texColor = mix(texColor, u_maskColor, clamp(u_maskColorMix, 0.0, 1.0));\n        }\n\n        fragColor = vec4(texColor.rgb, u_alpha);        \n    } else {\n        fragColor = u_solidColor;\n    }\n}";
+export declare const imageFragmentShader = "#version 300 es\nprecision mediump float;\n\nout vec4 fragColor;\n\nin vec2 texCoords;\n\nuniform int u_renderTexture;\nuniform sampler2D u_texImage;\nuniform vec4 u_solidColor;\n\nuniform int u_useTintColor;\nuniform vec4 u_tintColor;\n\nuniform int u_useMaskColor;\nuniform vec4 u_maskColor;\nuniform float u_maskColorMix;\n\nuniform float u_alpha;\n\nvoid main()\n{\n    if (u_renderTexture == 1) {\n        vec4 texColor = texture(u_texImage, texCoords);\n\n        if (texColor.a < 0.0001) {\n            discard;\n        }\n\n        if (u_useTintColor == 1) {\n            texColor = u_tintColor * texColor;\n        }\n\n        if (u_useMaskColor == 1) {\n            texColor = mix(texColor, u_maskColor, clamp(u_maskColorMix, 0.0, 1.0));\n        }\n\n        fragColor = vec4(texColor.rgb, u_alpha * texColor.a);        \n    } else {\n        fragColor = vec4(u_solidColor.rgb, u_alpha);\n    }\n}";

package/lib/rendering/webGL/shader/legacy/imageFragmentShader.d.ts

@@ -1 +1 @@
-export declare const imageFragmentShader = "precision mediump float;\n\nvarying vec2 texCoords;\n\nuniform int u_renderTexture;\nuniform sampler2D u_texImage;\nuniform vec4 u_solidColor;\n\nuniform int u_useTintColor;\nuniform vec4 u_tintColor;\n\nuniform int u_useMaskColor;\nuniform vec4 u_maskColor;\nuniform float u_maskColorMix;\n\nuniform float u_alpha;\n\nvoid main()\n{\n    if (u_renderTexture == 1) {\n        vec4 texColor = texture2D(u_texImage, texCoords);\n\n        if (texColor.a < 0.0001) {\n            discard;\n        }\n\n        if (u_useTintColor == 1) {\n            texColor = u_tintColor * texColor;\n        }\n\n        if (u_useMaskColor == 1) {\n            texColor = mix(texColor, u_maskColor, clamp(u_maskColorMix, 0.0, 1.0));\n        }\n\n        gl_FragColor = vec4(texColor.rgb, u_alpha);\n    } else {\n        gl_FragColor = u_solidColor;\n    }\n}";
+export declare const imageFragmentShader = "precision mediump float;\n\nvarying vec2 texCoords;\n\nuniform int u_renderTexture;\nuniform sampler2D u_texImage;\nuniform vec4 u_solidColor;\n\nuniform int u_useTintColor;\nuniform vec4 u_tintColor;\n\nuniform int u_useMaskColor;\nuniform vec4 u_maskColor;\nuniform float u_maskColorMix;\n\nuniform float u_alpha;\n\nvoid main()\n{\n    if (u_renderTexture == 1) {\n        vec4 texColor = texture2D(u_texImage, texCoords);\n\n        if (texColor.a < 0.0001) {\n            discard;\n        }\n\n        if (u_useTintColor == 1) {\n            texColor = u_tintColor * texColor;\n        }\n\n        if (u_useMaskColor == 1) {\n            texColor = mix(texColor, u_maskColor, clamp(u_maskColorMix, 0.0, 1.0));\n        }\n\n        gl_FragColor = vec4(texColor.rgb, u_alpha * texColor.a);\n    } else {\n        gl_FragColor =  vec4(u_solidColor.rgb, u_alpha);\n    }\n}";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "angry-pixel",
-    "version": "1.0.8",
+    "version": "1.1.1",
     "description": "Lightweight 2D game engine made with TypeScript.",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",