@safe-engine/pixi 8.7.4 → 8.8.2

package/dist/packages/pixijs/src/rendering/batcher/shared/BatcherPipe.js

@@ -0,0 +1,107 @@
+import { extensions, ExtensionType } from '../../../extensions/Extensions';
+import { State } from '../../renderers/shared/state/State';
+import { DefaultBatcher } from './DefaultBatcher';
+/**
+ * A pipe that batches elements into batches and sends them to the renderer.
+ *
+ * You can install new Batchers using ExtensionType.Batcher. Each render group will
+ * have a default batcher and any required ones will be created on demand.
+ * @category rendering
+ * @advanced
+ */
+export class BatcherPipe {
+    static getBatcher(name) {
+        return new this._availableBatchers[name]();
+    }
+    constructor(renderer, adaptor) {
+        var _a, _b;
+        this.state = State.for2d();
+        this._batchersByInstructionSet = Object.create(null);
+        /** A record of all active batchers, keyed by their names */
+        this._activeBatches = Object.create(null);
+        this.renderer = renderer;
+        this._adaptor = adaptor;
+        (_b = (_a = this._adaptor).init) === null || _b === void 0 ? void 0 : _b.call(_a, this);
+    }
+    buildStart(instructionSet) {
+        let batchers = this._batchersByInstructionSet[instructionSet.uid];
+        if (!batchers) {
+            batchers = this._batchersByInstructionSet[instructionSet.uid] = Object.create(null);
+            batchers.default || (batchers.default = new DefaultBatcher({
+                maxTextures: this.renderer.limits.maxBatchableTextures,
+            }));
+        }
+        this._activeBatches = batchers;
+        this._activeBatch = this._activeBatches.default;
+        for (const i in this._activeBatches) {
+            this._activeBatches[i].begin();
+        }
+    }
+    addToBatch(batchableObject, instructionSet) {
+        if (this._activeBatch.name !== batchableObject.batcherName) {
+            this._activeBatch.break(instructionSet);
+            let batch = this._activeBatches[batchableObject.batcherName];
+            if (!batch) {
+                batch = this._activeBatches[batchableObject.batcherName]
+                    = BatcherPipe.getBatcher(batchableObject.batcherName);
+                batch.begin();
+            }
+            this._activeBatch = batch;
+        }
+        this._activeBatch.add(batchableObject);
+    }
+    break(instructionSet) {
+        this._activeBatch.break(instructionSet);
+    }
+    buildEnd(instructionSet) {
+        this._activeBatch.break(instructionSet);
+        const batches = this._activeBatches;
+        for (const i in batches) {
+            const batch = batches[i];
+            const geometry = batch.geometry;
+            geometry.indexBuffer.setDataWithSize(batch.indexBuffer, batch.indexSize, true);
+            geometry.buffers[0].setDataWithSize(batch.attributeBuffer.float32View, batch.attributeSize, false);
+        }
+    }
+    upload(instructionSet) {
+        const batchers = this._batchersByInstructionSet[instructionSet.uid];
+        for (const i in batchers) {
+            const batcher = batchers[i];
+            const geometry = batcher.geometry;
+            if (batcher.dirty) {
+                batcher.dirty = false;
+                geometry.buffers[0].update(batcher.attributeSize * 4);
+            }
+        }
+    }
+    execute(batch) {
+        if (batch.action === 'startBatch') {
+            const batcher = batch.batcher;
+            const geometry = batcher.geometry;
+            const shader = batcher.shader;
+            this._adaptor.start(this, geometry, shader);
+        }
+        this._adaptor.execute(this, batch);
+    }
+    destroy() {
+        this.state = null;
+        this.renderer = null;
+        this._adaptor = null;
+        for (const i in this._activeBatches) {
+            this._activeBatches[i].destroy();
+        }
+        this._activeBatches = null;
+    }
+}
+/** @ignore */
+BatcherPipe.extension = {
+    type: [
+        ExtensionType.WebGLPipes,
+        ExtensionType.WebGPUPipes,
+        ExtensionType.CanvasPipes,
+    ],
+    name: 'batch',
+};
+BatcherPipe._availableBatchers = Object.create(null);
+extensions.handleByMap(ExtensionType.Batcher, BatcherPipe._availableBatchers);
+extensions.add(DefaultBatcher);

package/dist/packages/pixijs/src/rendering/batcher/shared/DefaultBatcher.d.ts

@@ -0,0 +1,87 @@
+import { ExtensionType } from '../../../extensions/Extensions';
+import { Batcher } from './Batcher';
+import { BatchGeometry } from './BatchGeometry';
+import { DefaultShader } from './DefaultShader';
+import type { Matrix } from '../../../maths/matrix/Matrix';
+import type { BatchableMeshElement, BatchableQuadElement, BatcherOptions } from './Batcher';
+/**
+ * Represents the common elements for default batch rendering.
+ * This interface defines the properties that are used by the DefaultBatcher
+ * to render elements efficiently in a batch.
+ * @category rendering
+ * @advanced
+ */
+export interface DefaultBatchElements {
+    /**
+     * The color of the element that will be multiplied with the texture color.
+     * This is typically represented as a 32-bit integer in RGBA format.
+     */
+    color: number;
+    /**
+     * Determines whether the element should be rounded to the nearest pixel.
+     * - 0: No rounding (default)
+     * - 1: Round to nearest pixel
+     * This can help with visual consistency, especially for pixel art styles.
+     */
+    roundPixels: 0 | 1;
+    /**
+     * The transform matrix of the element.
+     * This matrix represents the position, scale, rotation, and skew of the element.
+     */
+    transform: Matrix;
+}
+/**
+ * Represents a batchable quad element with default batch properties.
+ * @category rendering
+ * @advanced
+ */
+export interface DefaultBatchableQuadElement extends BatchableQuadElement, DefaultBatchElements {
+}
+/**
+ * Represents a batchable mesh element with default batch properties.
+ * @category rendering
+ * @advanced
+ */
+export interface DefaultBatchableMeshElement extends BatchableMeshElement, DefaultBatchElements {
+}
+/**
+ * The default batcher is used to batch quads and meshes. This batcher will batch the following elements:
+ * - tints
+ * - roundPixels
+ * - texture
+ * - transform
+ * @category rendering
+ * @advanced
+ */
+export declare class DefaultBatcher extends Batcher {
+    /** @ignore */
+    static extension: {
+        readonly type: readonly [ExtensionType.Batcher];
+        readonly name: "default";
+    };
+    geometry: BatchGeometry;
+    shader: DefaultShader;
+    name: "default";
+    /** The size of one attribute. 1 = 32 bit. x, y, u, v, color, textureIdAndRound -> total = 6 */
+    vertexSize: number;
+    constructor(options: BatcherOptions);
+    /**
+     * Packs the attributes of a DefaultBatchableMeshElement into the provided views.
+     * @param element - The DefaultBatchableMeshElement to pack.
+     * @param float32View - The Float32Array view to pack into.
+     * @param uint32View - The Uint32Array view to pack into.
+     * @param index - The starting index in the views.
+     * @param textureId - The texture ID to use.
+     */
+    packAttributes(element: DefaultBatchableMeshElement, float32View: Float32Array, uint32View: Uint32Array, index: number, textureId: number): void;
+    /**
+     * Packs the attributes of a DefaultBatchableQuadElement into the provided views.
+     * @param element - The DefaultBatchableQuadElement to pack.
+     * @param float32View - The Float32Array view to pack into.
+     * @param uint32View - The Uint32Array view to pack into.
+     * @param index - The starting index in the views.
+     * @param textureId - The texture ID to use.
+     */
+    packQuadAttributes(element: DefaultBatchableQuadElement, float32View: Float32Array, uint32View: Uint32Array, index: number, textureId: number): void;
+}
+//# sourceMappingURL=DefaultBatcher.d.ts.map

package/dist/packages/pixijs/src/rendering/batcher/shared/DefaultBatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultBatcher.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/rendering/batcher/shared/DefaultBatcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAE3D,OAAO,KAAK,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAI5F;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IAEjC;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,2BAA4B,SAAQ,oBAAoB,EAAE,oBAAoB;CAAG;AAElG;;;;GAIG;AACH,MAAM,WAAW,2BAA4B,SAAQ,oBAAoB,EAAE,oBAAoB;CAAG;AAElG;;;;;;;;GAQG;AACH,qBAAa,cAAe,SAAQ,OAAO;IAEvC,cAAc;IACd,OAAc,SAAS;;;MAKZ;IAEJ,QAAQ,gBAAuB;IAC/B,MAAM,EAAE,aAAa,CAAC;IAEtB,IAAI,YAAiC;IAE5C,+FAA+F;IACxF,UAAU,SAAK;gBAEV,OAAO,EAAE,cAAc;IASnC;;;;;;;OAOG;IACI,cAAc,CACjB,OAAO,EAAE,2BAA2B,EACpC,WAAW,EAAE,YAAY,EACzB,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM;IAuCrB;;;;;;;OAOG;IACI,kBAAkB,CACrB,OAAO,EAAE,2BAA2B,EACpC,WAAW,EAAE,YAAY,EACzB,UAAU,EAAE,WAAW,EACvB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM;CAoExB"}

package/dist/packages/pixijs/src/rendering/batcher/shared/DefaultBatcher.js

@@ -0,0 +1,120 @@
+import { ExtensionType } from '../../../extensions/Extensions';
+import { Batcher } from './Batcher';
+import { BatchGeometry } from './BatchGeometry';
+import { DefaultShader } from './DefaultShader';
+let defaultShader = null;
+/**
+ * The default batcher is used to batch quads and meshes. This batcher will batch the following elements:
+ * - tints
+ * - roundPixels
+ * - texture
+ * - transform
+ * @category rendering
+ * @advanced
+ */
+export class DefaultBatcher extends Batcher {
+    constructor(options) {
+        super(options);
+        this.geometry = new BatchGeometry();
+        this.name = DefaultBatcher.extension.name;
+        /** The size of one attribute. 1 = 32 bit. x, y, u, v, color, textureIdAndRound -> total = 6 */
+        this.vertexSize = 6;
+        defaultShader !== null && defaultShader !== void 0 ? defaultShader : (defaultShader = new DefaultShader(options.maxTextures));
+        this.shader = defaultShader;
+    }
+    /**
+     * Packs the attributes of a DefaultBatchableMeshElement into the provided views.
+     * @param element - The DefaultBatchableMeshElement to pack.
+     * @param float32View - The Float32Array view to pack into.
+     * @param uint32View - The Uint32Array view to pack into.
+     * @param index - The starting index in the views.
+     * @param textureId - The texture ID to use.
+     */
+    packAttributes(element, float32View, uint32View, index, textureId) {
+        const textureIdAndRound = (textureId << 16) | (element.roundPixels & 0xFFFF);
+        const wt = element.transform;
+        const a = wt.a;
+        const b = wt.b;
+        const c = wt.c;
+        const d = wt.d;
+        const tx = wt.tx;
+        const ty = wt.ty;
+        const { positions, uvs } = element;
+        const argb = element.color;
+        const offset = element.attributeOffset;
+        const end = offset + element.attributeSize;
+        for (let i = offset; i < end; i++) {
+            const i2 = i * 2;
+            const x = positions[i2];
+            const y = positions[(i2) + 1];
+            float32View[index++] = (a * x) + (c * y) + tx;
+            float32View[index++] = (d * y) + (b * x) + ty;
+            float32View[index++] = uvs[i2];
+            float32View[index++] = uvs[(i2) + 1];
+            uint32View[index++] = argb;
+            uint32View[index++] = textureIdAndRound;
+        }
+    }
+    /**
+     * Packs the attributes of a DefaultBatchableQuadElement into the provided views.
+     * @param element - The DefaultBatchableQuadElement to pack.
+     * @param float32View - The Float32Array view to pack into.
+     * @param uint32View - The Uint32Array view to pack into.
+     * @param index - The starting index in the views.
+     * @param textureId - The texture ID to use.
+     */
+    packQuadAttributes(element, float32View, uint32View, index, textureId) {
+        const texture = element.texture;
+        const wt = element.transform;
+        const a = wt.a;
+        const b = wt.b;
+        const c = wt.c;
+        const d = wt.d;
+        const tx = wt.tx;
+        const ty = wt.ty;
+        const bounds = element.bounds;
+        const w0 = bounds.maxX;
+        const w1 = bounds.minX;
+        const h0 = bounds.maxY;
+        const h1 = bounds.minY;
+        const uvs = texture.uvs;
+        // _ _ _ _
+        // a b g r
+        const argb = element.color;
+        const textureIdAndRound = (textureId << 16) | (element.roundPixels & 0xFFFF);
+        float32View[index + 0] = (a * w1) + (c * h1) + tx;
+        float32View[index + 1] = (d * h1) + (b * w1) + ty;
+        float32View[index + 2] = uvs.x0;
+        float32View[index + 3] = uvs.y0;
+        uint32View[index + 4] = argb;
+        uint32View[index + 5] = textureIdAndRound;
+        // xy
+        float32View[index + 6] = (a * w0) + (c * h1) + tx;
+        float32View[index + 7] = (d * h1) + (b * w0) + ty;
+        float32View[index + 8] = uvs.x1;
+        float32View[index + 9] = uvs.y1;
+        uint32View[index + 10] = argb;
+        uint32View[index + 11] = textureIdAndRound;
+        // xy
+        float32View[index + 12] = (a * w0) + (c * h0) + tx;
+        float32View[index + 13] = (d * h0) + (b * w0) + ty;
+        float32View[index + 14] = uvs.x2;
+        float32View[index + 15] = uvs.y2;
+        uint32View[index + 16] = argb;
+        uint32View[index + 17] = textureIdAndRound;
+        // xy
+        float32View[index + 18] = (a * w1) + (c * h0) + tx;
+        float32View[index + 19] = (d * h0) + (b * w1) + ty;
+        float32View[index + 20] = uvs.x3;
+        float32View[index + 21] = uvs.y3;
+        uint32View[index + 22] = argb;
+        uint32View[index + 23] = textureIdAndRound;
+    }
+}
+/** @ignore */
+DefaultBatcher.extension = {
+    type: [
+        ExtensionType.Batcher,
+    ],
+    name: 'default',
+};

package/dist/packages/pixijs/src/rendering/batcher/shared/DefaultShader.d.ts

@@ -0,0 +1,15 @@
+import { Shader } from '../../renderers/shared/shader/Shader';
+/**
+ * DefaultShader is a specialized shader class designed for batch rendering.
+ * It extends the base Shader class and provides functionality for handling
+ * color, texture batching, and pixel rounding in both WebGL and WebGPU contexts.
+ *
+ * It is used by the default batcher
+ * @extends Shader
+ * @category rendering
+ * @advanced
+ */
+export declare class DefaultShader extends Shader {
+    constructor(maxTextures: number);
+}
+//# sourceMappingURL=DefaultShader.d.ts.map

package/dist/packages/pixijs/src/rendering/batcher/shared/DefaultShader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultShader.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/rendering/batcher/shared/DefaultShader.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,sCAAsC,CAAC;AAE9D;;;;;;;;;GASG;AACH,qBAAa,aAAc,SAAQ,MAAM;gBAEzB,WAAW,EAAE,MAAM;CA4BlC"}

package/dist/packages/pixijs/src/rendering/batcher/shared/DefaultShader.js

@@ -0,0 +1,43 @@
+import { compileHighShaderGlProgram, compileHighShaderGpuProgram } from '../../high-shader/compileHighShaderToProgram';
+import { colorBit, colorBitGl } from '../../high-shader/shader-bits/colorBit';
+import { generateTextureBatchBit, generateTextureBatchBitGl } from '../../high-shader/shader-bits/generateTextureBatchBit';
+import { roundPixelsBit, roundPixelsBitGl } from '../../high-shader/shader-bits/roundPixelsBit';
+import { getBatchSamplersUniformGroup } from '../../renderers/gl/shader/getBatchSamplersUniformGroup';
+import { Shader } from '../../renderers/shared/shader/Shader';
+/**
+ * DefaultShader is a specialized shader class designed for batch rendering.
+ * It extends the base Shader class and provides functionality for handling
+ * color, texture batching, and pixel rounding in both WebGL and WebGPU contexts.
+ *
+ * It is used by the default batcher
+ * @extends Shader
+ * @category rendering
+ * @advanced
+ */
+export class DefaultShader extends Shader {
+    constructor(maxTextures) {
+        const glProgram = compileHighShaderGlProgram({
+            name: 'batch',
+            bits: [
+                colorBitGl,
+                generateTextureBatchBitGl(maxTextures),
+                roundPixelsBitGl,
+            ]
+        });
+        const gpuProgram = compileHighShaderGpuProgram({
+            name: 'batch',
+            bits: [
+                colorBit,
+                generateTextureBatchBit(maxTextures),
+                roundPixelsBit,
+            ]
+        });
+        super({
+            glProgram,
+            gpuProgram,
+            resources: {
+                batchSamplers: getBatchSamplersUniformGroup(maxTextures),
+            }
+        });
+    }
+}

package/dist/packages/pixijs/src/rendering/high-shader/compileHighShaderToProgram.d.ts

@@ -0,0 +1,24 @@
+import { GlProgram } from '../renderers/gl/shader/GlProgram';
+import { GpuProgram } from '../renderers/gpu/shader/GpuProgram';
+import type { HighShaderBit } from './compiler/types';
+/**
+ * @param root0
+ * @param root0.bits
+ * @param root0.name
+ * @internal
+ */
+export declare function compileHighShaderGpuProgram({ bits, name }: {
+    bits: HighShaderBit[];
+    name: string;
+}): GpuProgram;
+/**
+ * @param root0
+ * @param root0.bits
+ * @param root0.name
+ * @internal
+ */
+export declare function compileHighShaderGlProgram({ bits, name }: {
+    bits: HighShaderBit[];
+    name: string;
+}): GlProgram;
+//# sourceMappingURL=compileHighShaderToProgram.d.ts.map

package/dist/packages/pixijs/src/rendering/high-shader/compileHighShaderToProgram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileHighShaderToProgram.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/rendering/high-shader/compileHighShaderToProgram.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKhE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IAAC,IAAI,EAAE,aAAa,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAG,UAAU,CAwB7G;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;IAAC,IAAI,EAAE,aAAa,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAG,SAAS,CAe3G"}

package/dist/packages/pixijs/src/rendering/high-shader/compileHighShaderToProgram.js

@@ -0,0 +1,52 @@
+import { GlProgram } from '../renderers/gl/shader/GlProgram';
+import { GpuProgram } from '../renderers/gpu/shader/GpuProgram';
+import { compileHighShader, compileHighShaderGl } from './compiler/compileHighShader';
+import { fragmentGlTemplate, fragmentGPUTemplate, vertexGlTemplate, vertexGPUTemplate } from './defaultProgramTemplate';
+import { globalUniformsBit, globalUniformsBitGl } from './shader-bits/globalUniformsBit';
+/**
+ * @param root0
+ * @param root0.bits
+ * @param root0.name
+ * @internal
+ */
+export function compileHighShaderGpuProgram({ bits, name }) {
+    const source = compileHighShader({
+        template: {
+            fragment: fragmentGPUTemplate,
+            vertex: vertexGPUTemplate,
+        },
+        bits: [
+            globalUniformsBit,
+            ...bits,
+        ]
+    });
+    return GpuProgram.from({
+        name,
+        vertex: {
+            source: source.vertex,
+            entryPoint: 'main',
+        },
+        fragment: {
+            source: source.fragment,
+            entryPoint: 'main',
+        },
+    });
+}
+/**
+ * @param root0
+ * @param root0.bits
+ * @param root0.name
+ * @internal
+ */
+export function compileHighShaderGlProgram({ bits, name }) {
+    return new GlProgram(Object.assign({ name }, compileHighShaderGl({
+        template: {
+            vertex: vertexGlTemplate,
+            fragment: fragmentGlTemplate,
+        },
+        bits: [
+            globalUniformsBitGl,
+            ...bits,
+        ]
+    })));
+}

package/dist/packages/pixijs/src/rendering/high-shader/compiler/compileHighShader.d.ts

@@ -0,0 +1,34 @@
+import type { HighShaderBit, HighShaderSource } from './types';
+/**
+ * A high template consists of vertex and fragment source
+ * @internal
+ */
+export interface HighShaderTemplate {
+    name?: string;
+    fragment: string;
+    vertex: string;
+}
+/** @internal */
+export interface CompileHighShaderOptions {
+    template: HighShaderTemplate;
+    bits: HighShaderBit[];
+}
+/**
+ * This function will take a HighShader template, some High fragments and then merge them in to a shader source.
+ * @param options
+ * @param options.template
+ * @param options.bits
+ * @internal
+ */
+export declare function compileHighShader({ template, bits }: CompileHighShaderOptions): HighShaderSource;
+/**
+ * This function will take a HighShader template, some High fragments and then merge them in to a shader source.
+ * It is specifically for WebGL and does not compile inputs and outputs.
+ * @param options
+ * @param options.template - The HighShader template containing vertex and fragment source.
+ * @param options.bits - An array of HighShaderBit objects to be compiled into the shader.
+ * @returns A HighShaderSource object containing the compiled vertex and fragment shaders.
+ * @internal
+ */
+export declare function compileHighShaderGl({ template, bits }: CompileHighShaderOptions): HighShaderSource;
+//# sourceMappingURL=compileHighShader.d.ts.map

package/dist/packages/pixijs/src/rendering/high-shader/compiler/compileHighShader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileHighShader.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/rendering/high-shader/compiler/compileHighShader.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAE/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,gBAAgB;AAChB,MAAM,WAAW,wBAAwB;IAErC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,IAAI,EAAE,aAAa,EAAE,CAAC;CACzB;AAOD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,EAC9B,QAAQ,EACR,IAAI,EACP,EAAE,wBAAwB,GAAG,gBAAgB,CAW7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,EAChC,QAAQ,EACR,IAAI,EACP,EAAE,wBAAwB,GAAG,gBAAgB,CAS7C"}

package/dist/packages/pixijs/src/rendering/high-shader/compiler/compileHighShader.js

@@ -0,0 +1,74 @@
+import { addBits } from './utils/addBits';
+import { compileHooks } from './utils/compileHooks';
+import { compileInputs } from './utils/compileInputs';
+import { compileOutputs } from './utils/compileOutputs';
+import { injectBits } from './utils/injectBits';
+const cacheMap = Object.create(null);
+const bitCacheMap = new Map();
+let CACHE_UID = 0;
+/**
+ * This function will take a HighShader template, some High fragments and then merge them in to a shader source.
+ * @param options
+ * @param options.template
+ * @param options.bits
+ * @internal
+ */
+export function compileHighShader({ template, bits }) {
+    const cacheId = generateCacheId(template, bits);
+    if (cacheMap[cacheId])
+        return cacheMap[cacheId];
+    const { vertex, fragment } = compileInputsAndOutputs(template, bits);
+    cacheMap[cacheId] = compileBits(vertex, fragment, bits);
+    return cacheMap[cacheId];
+}
+/**
+ * This function will take a HighShader template, some High fragments and then merge them in to a shader source.
+ * It is specifically for WebGL and does not compile inputs and outputs.
+ * @param options
+ * @param options.template - The HighShader template containing vertex and fragment source.
+ * @param options.bits - An array of HighShaderBit objects to be compiled into the shader.
+ * @returns A HighShaderSource object containing the compiled vertex and fragment shaders.
+ * @internal
+ */
+export function compileHighShaderGl({ template, bits }) {
+    const cacheId = generateCacheId(template, bits);
+    if (cacheMap[cacheId])
+        return cacheMap[cacheId];
+    cacheMap[cacheId] = compileBits(template.vertex, template.fragment, bits);
+    return cacheMap[cacheId];
+}
+function compileInputsAndOutputs(template, bits) {
+    const vertexFragments = bits.map((shaderBit) => shaderBit.vertex).filter((v) => !!v);
+    const fragmentFragments = bits.map((shaderBit) => shaderBit.fragment).filter((v) => !!v);
+    // WebGPU compile inputs and outputs..
+    let compiledVertex = compileInputs(vertexFragments, template.vertex, true);
+    compiledVertex = compileOutputs(vertexFragments, compiledVertex);
+    const compiledFragment = compileInputs(fragmentFragments, template.fragment, true);
+    return {
+        vertex: compiledVertex,
+        fragment: compiledFragment,
+    };
+}
+function generateCacheId(template, bits) {
+    return bits
+        .map((highFragment) => {
+        if (!bitCacheMap.has(highFragment)) {
+            bitCacheMap.set(highFragment, CACHE_UID++);
+        }
+        return bitCacheMap.get(highFragment);
+    })
+        .sort((a, b) => a - b)
+        .join('-') + template.vertex + template.fragment;
+}
+function compileBits(vertex, fragment, bits) {
+    const vertexParts = compileHooks(vertex);
+    const fragmentParts = compileHooks(fragment);
+    bits.forEach((shaderBit) => {
+        addBits(shaderBit.vertex, vertexParts, shaderBit.name);
+        addBits(shaderBit.fragment, fragmentParts, shaderBit.name);
+    });
+    return {
+        vertex: injectBits(vertex, vertexParts),
+        fragment: injectBits(fragment, fragmentParts),
+    };
+}

package/dist/packages/pixijs/src/rendering/high-shader/compiler/types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * the vertex source code, an obj
+ * @internal
+ */
+export type Vertex = {
+    /** stick uniforms and functions in here all headers will be compiled at the top of the shader */
+    header?: string;
+    /** code will be added at the start of the shader */
+    start?: string;
+    /** code will be run here before lighting happens */
+    main?: string;
+    /** code here will to modify anything before it is passed to the fragment shader */
+    end?: string;
+};
+/** @internal */
+export type Fragment = {
+    /** stick uniforms and functions in here all headers will be compiled at the top of the shader */
+    header?: string;
+    /** code will be added at the start of the shader */
+    start?: string;
+    /** code will be run here before lighting happens */
+    main?: string;
+    /** code here will to modify anything before it is passed to the fragment shader */
+    end?: string;
+};
+/**
+ * HighShaderBit is a part of a shader.
+ * it is used to compile HighShaders.
+ *
+ * Internally shaders are made up of many of these.
+ * You can even write your own and compile them in.
+ * @internal
+ */
+export interface HighShaderBit {
+    /** used to make the shader easier to understand! */
+    name?: string;
+    /** the snippets of vertex code */
+    vertex?: Vertex;
+    /** the snippets of fragment code */
+    fragment?: Fragment;
+}
+/**
+ * source code to compile a shader. this can be directly used by pixi and should be good to go!
+ * It contains the vertex and fragment source code.
+ * This is the final output of the HighShader compiler.
+ * It is used to create a shader program.
+ * @internal
+ */
+export interface HighShaderSource {
+    fragment: string;
+    vertex: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/packages/pixijs/src/rendering/high-shader/compiler/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/rendering/high-shader/compiler/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG;IACjB,iGAAiG;IACjG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mFAAmF;IACnF,GAAG,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,gBAAgB;AAChB,MAAM,MAAM,QAAQ,GAAG;IACnB,iGAAiG;IACjG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mFAAmF;IACnF,GAAG,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAE1B,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,oCAAoC;IACpC,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAE7B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAClB"}

package/dist/packages/pixijs/src/rendering/high-shader/compiler/types.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/pixijs/src/rendering/high-shader/compiler/utils/addBits.d.ts

@@ -0,0 +1,9 @@
+/**
+ * takes the HighFragment source parts and adds them to the hook hash
+ * @param srcParts - the hash of hook arrays
+ * @param parts - the code to inject into the hooks
+ * @param name - optional the name of the part to add
+ * @internal
+ */
+export declare function addBits(srcParts: Record<string, string>, parts: Record<string, string[]>, name?: string): void;
+//# sourceMappingURL=addBits.d.ts.map

package/dist/packages/pixijs/src/rendering/high-shader/compiler/utils/addBits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addBits.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/rendering/high-shader/compiler/utils/addBits.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,QAoCvG"}