@kurot/core 1.0.12

package/dist/kurot/player/webgl/pipes/TextPipe.js

@@ -0,0 +1,201 @@
+import { TextFieldType } from '../../../text/enums/TextFieldType.js';
+import { RenderBuffer } from '../../canvas/index.js';
+// ── Texture GC registry ───────────────────────────────────────────────────────
+/**
+ * GC is the actual cleanup path for cached TextField textures: nothing in the
+ * engine calls destroyRenderable() during normal TextField lifecycle (UI
+ * relayouts, virtualized lists just drop references), so this registry is what
+ * actually reclaims GPU memory. destroyRenderable() remains as an optional
+ * explicit entry for future use. Mirrors GraphicsPipe's pattern.
+ */
+const _textureRegistry = new FinalizationRegistry(({ gl, texture }) => {
+    gl.deleteTexture(texture);
+});
+// ── Pipe ──────────────────────────────────────────────────────────────────────
+/**
+ * Handles WebGL rendering of TextField display objects.
+ *
+ * **Architecture** (following Egret's `WebGLRenderer.renderText`):
+ *
+ * 1. Compute the text draw area (width × height).
+ * 2. Scale by the device pixel ratio (`canvasScaleX/Y`), clamped to
+ *    `maxTextureSize` so we never exceed the GPU's limit.
+ * 3. Rasterize the text onto an offscreen `<canvas>` via `CanvasRenderer`.
+ * 4. Upload the canvas as a WebGL texture (create once, update on change).
+ * 5. Draw the texture via `buffer.context.drawTexture()`, scaling back down
+ *    by `canvasScale` so the on-screen size is correct.
+ *
+ * The cache is invalidated when `tf.$renderDirty` is true or when the
+ * dimensions / DPR change.
+ */
+export class TextPipe {
+    // ── Static fields ─────────────────────────────────────────────────────────
+    static PIPE_ID = 'text';
+    static _pool = [];
+    // ── Instance fields ───────────────────────────────────────────────────────
+    _canvasRenderer;
+    _cache = new WeakMap();
+    _registryTokens = new WeakMap();
+    _gl;
+    // ── Constructor ───────────────────────────────────────────────────────────
+    constructor(canvasRenderer) {
+        this._canvasRenderer = canvasRenderer;
+    }
+    static _alloc(tf, ox, oy) {
+        const inst = TextPipe._pool.pop() ?? {
+            renderPipeId: 'text',
+            renderable: tf,
+            offsetX: ox,
+            offsetY: oy,
+        };
+        inst.renderable = tf;
+        inst.offsetX = ox;
+        inst.offsetY = oy;
+        return inst;
+    }
+    static release(inst) {
+        TextPipe._pool.push(inst);
+    }
+    // ── RenderPipe impl ───────────────────────────────────────────────────────
+    addToInstructionSet(tf, set) {
+        set.add(TextPipe._alloc(tf, 0, 0));
+    }
+    updateRenderable(_tf) {
+        // Cache invalidation is driven by tf.$renderDirty,
+        // which is checked at execute time — nothing to pre-upload here.
+    }
+    destroyRenderable(tf) {
+        const cache = this._cache.get(tf);
+        if (cache?.texture) {
+            // Unregister from GC registry and delete texture immediately.
+            const token = this._registryTokens.get(tf);
+            if (token) {
+                _textureRegistry.unregister(token);
+                this._registryTokens.delete(tf);
+            }
+            if (this._gl)
+                this._gl.deleteTexture(cache.texture);
+        }
+        this._cache.delete(tf);
+    }
+    // ── Execute ───────────────────────────────────────────────────────────────
+    /**
+     * Render a TextField into the WebGL buffer.
+     * Follows Egret's `WebGLRenderer.renderText` pattern:
+     *
+     *   1. Compute logical width/height from the TextField.
+     *   2. Scale by canvasScale (DPR), clamped to maxTextureSize.
+     *   3. Rasterize to offscreen canvas (if dirty).
+     *   4. Upload as WebGL texture.
+     *   5. Draw with drawTexture, scaling back by canvasScale.
+     */
+    execute(inst, buffer) {
+        const tf = inst.renderable;
+        tf.getLinesArr(); // ensure lines are computed
+        // Cache the GL context for use in destroyRenderable.
+        if (!this._gl)
+            this._gl = buffer.context.gl;
+        // ── INPUT mode while focused: HTML input element owns the display ────
+        // Don't render the canvas texture — the native <input>/<textarea>
+        // is overlaid on top and already shows the text. Rendering here too
+        // would produce a double-text artefact.
+        if (tf.type === TextFieldType.INPUT && tf.isTyping) {
+            return;
+        }
+        // ── 1. Compute logical dimensions ────────────────────────────────────
+        const logicalW = Math.ceil(!isNaN(tf.$explicitWidth) ? tf.$explicitWidth : tf.textWidth);
+        const logicalH = Math.ceil(!isNaN(tf.$explicitHeight) ? tf.$explicitHeight : tf.textHeight);
+        if (logicalW <= 0 || logicalH <= 0) {
+            return;
+        }
+        buffer.offsetX = 0;
+        buffer.offsetY = 0;
+        // ── 2. Canvas scale factor (DPR handling) ────────────────────────────
+        // Follow Egret: scale the offscreen canvas by DPR so text looks crisp
+        // on HiDPI screens, but clamp to maxTextureSize to avoid GPU limits.
+        let canvasScaleX = /* devicePixelRatio || */ 1;
+        let canvasScaleY = /* devicePixelRatio || */ 1;
+        const maxTexSize = buffer.context.maxTextureSize;
+        if (logicalW * canvasScaleX > maxTexSize) {
+            canvasScaleX *= maxTexSize / (logicalW * canvasScaleX);
+        }
+        if (logicalH * canvasScaleY > maxTexSize) {
+            canvasScaleY *= maxTexSize / (logicalH * canvasScaleY);
+        }
+        // Scaled pixel dimensions for the offscreen canvas.
+        const pixelW = Math.ceil(logicalW * canvasScaleX);
+        const pixelH = Math.ceil(logicalH * canvasScaleY);
+        // ── 3. Cache lookup / rebuild ────────────────────────────────────────
+        let cache = this._cache.get(tf);
+        let scaleChanged = false;
+        if (cache) {
+            // Check if canvasScale changed (e.g. window moved between displays).
+            scaleChanged = cache.canvasScaleX !== canvasScaleX || cache.canvasScaleY !== canvasScaleY;
+            if (scaleChanged) {
+                cache.canvasScaleX = canvasScaleX;
+                cache.canvasScaleY = canvasScaleY;
+            }
+        }
+        else {
+            cache = {
+                renderBuffer: new RenderBuffer(pixelW, pixelH),
+                texture: undefined,
+                textureWidth: 0,
+                textureHeight: 0,
+                canvasScaleX,
+                canvasScaleY,
+            };
+            this._cache.set(tf, cache);
+        }
+        // Dirty when: text content changed, dimensions changed, or DPR changed.
+        const needsRebuild = tf.$renderDirty || cache.textureWidth !== pixelW || cache.textureHeight !== pixelH || scaleChanged;
+        if (needsRebuild) {
+            // Resize the offscreen canvas if needed.
+            if (cache.renderBuffer.width !== pixelW || cache.renderBuffer.height !== pixelH) {
+                cache.renderBuffer.resize(pixelW, pixelH);
+            }
+            // Clear the buffer first (note: clear() resets the transform to identity).
+            cache.renderBuffer.clear();
+            // Apply canvas scale transform so text renders at the higher resolution.
+            const ctx = cache.renderBuffer.context;
+            if (canvasScaleX !== 1 || canvasScaleY !== 1) {
+                ctx.setTransform(canvasScaleX, 0, 0, canvasScaleY, 0, 0);
+            }
+            // Rasterize the text onto the offscreen canvas.
+            this._canvasRenderer.renderTextFieldToContext(tf, ctx, 0, 0);
+            // Upload to WebGL texture.
+            const surface = cache.renderBuffer.surface;
+            if (!cache.texture) {
+                cache.texture = buffer.context.createTexture(surface);
+                // Register for GC-based cleanup.
+                const token = {};
+                _textureRegistry.register(tf, { gl: buffer.context.gl, texture: cache.texture }, token);
+                this._registryTokens.set(tf, token);
+            }
+            else {
+                // Unregister old texture, create new registration for updated texture.
+                const oldToken = this._registryTokens.get(tf);
+                if (oldToken)
+                    _textureRegistry.unregister(oldToken);
+                buffer.context.updateTexture(cache.texture, surface);
+                const token = {};
+                _textureRegistry.register(tf, { gl: buffer.context.gl, texture: cache.texture }, token);
+                this._registryTokens.set(tf, token);
+            }
+            cache.textureWidth = pixelW;
+            cache.textureHeight = pixelH;
+        }
+        if (!cache.texture)
+            return;
+        // ── 4. Draw cached texture ───────────────────────────────────────────
+        // Following Egret: draw the full texture but scale the destination by
+        // 1/canvasScale so the on-screen size matches the logical dimensions.
+        buffer.context.drawTexture(cache.texture, 0, 0, cache.textureWidth, cache.textureHeight, // src rect (full texture)
+        0, 0, // dest position (offset already in globalMatrix via _applyTransform)
+        cache.textureWidth / canvasScaleX, // dest width (scaled back)
+        cache.textureHeight / canvasScaleY, // dest height (scaled back)
+        cache.textureWidth, // texture source width
+        cache.textureHeight);
+    }
+}
+//# sourceMappingURL=TextPipe.js.map

package/dist/kurot/player/webgl/pipes/TextPipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextPipe.js","sourceRoot":"","sources":["../../../../../src/kurot/player/webgl/pipes/TextPipe.ts"],"names":[],"mappings":"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"}

package/dist/kurot/player/webgl/pipes/index.d.ts

@@ -0,0 +1,8 @@
+export { BitmapPipe, type BitmapInstruction } from './BitmapPipe.js';
+export { FilterPipe, type FilterPushInstruction, type FilterPopInstruction } from './FilterPipe.js';
+export { GraphicsPipe, type GraphicsInstruction } from './GraphicsPipe.js';
+export { MaskPipe, type MaskPushInstruction, type MaskPopInstruction } from './MaskPipe.js';
+export { MeshPipe, type MeshInstruction } from './MeshPipe.js';
+export { TextPipe, type TextInstruction } from './TextPipe.js';
+export { ParticlePipe, type ParticleInstruction } from './ParticlePipe.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/kurot/player/webgl/pipes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/kurot/player/webgl/pipes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,KAAK,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACpG,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EAAE,QAAQ,EAAE,KAAK,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/kurot/player/webgl/pipes/index.js

@@ -0,0 +1,8 @@
+export { BitmapPipe } from './BitmapPipe.js';
+export { FilterPipe } from './FilterPipe.js';
+export { GraphicsPipe } from './GraphicsPipe.js';
+export { MaskPipe } from './MaskPipe.js';
+export { MeshPipe } from './MeshPipe.js';
+export { TextPipe } from './TextPipe.js';
+export { ParticlePipe } from './ParticlePipe.js';
+//# sourceMappingURL=index.js.map

package/dist/kurot/player/webgl/pipes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/kurot/player/webgl/pipes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA0B,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,UAAU,EAAyD,MAAM,iBAAiB,CAAC;AACpG,OAAO,EAAE,YAAY,EAA4B,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EAAE,QAAQ,EAAqD,MAAM,eAAe,CAAC;AAC5F,OAAO,EAAE,QAAQ,EAAwB,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAwB,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,YAAY,EAA4B,MAAM,mBAAmB,CAAC"}

package/dist/kurot/player/webgl/shaders/ShaderLib.d.ts

@@ -0,0 +1,23 @@
+/**
+ * GLSL ES 1.00 shaders — used with WebGL1 context.
+ * For WebGL2 (GLSL ES 3.00) shaders see ../webgl2/ShaderLib2.ts
+ */
+export declare const ShaderLib: {
+    readonly default_vert: "\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n   vColor = aColor;\n   }";
+    readonly fullscreen_vert: "\n   attribute vec2 aVertexPosition;\n   attribute vec2 aTextureCoord;\n   attribute vec4 aColor;\n   uniform vec2 projectionVector;\n   varying vec2 vTextureCoord;\n   varying vec4 vColor;\n   const vec2 center = vec2(-1.0, 1.0);\n   void main(void) {\n      gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);\n      vTextureCoord = aTextureCoord;\n      vColor = aColor;\n   }";
+    readonly multi_vert: "\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aColor;\nattribute float aTextureId;\nuniform vec2 projectionVector;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nvarying float vTextureId;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n   vColor = aColor;\n   vTextureId = aTextureId;\n}";
+    readonly multi_frag: "\nprecision lowp float;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nvarying float vTextureId;\nuniform sampler2D uSamplers[8];\nvoid main(void) {\n    vec4 color;\n    int id = int(vTextureId + 0.5);\n    if (id == 0)      color = texture2D(uSamplers[0], vTextureCoord);\n    else if (id == 1) color = texture2D(uSamplers[1], vTextureCoord);\n    else if (id == 2) color = texture2D(uSamplers[2], vTextureCoord);\n    else if (id == 3) color = texture2D(uSamplers[3], vTextureCoord);\n    else if (id == 4) color = texture2D(uSamplers[4], vTextureCoord);\n    else if (id == 5) color = texture2D(uSamplers[5], vTextureCoord);\n    else if (id == 6) color = texture2D(uSamplers[6], vTextureCoord);\n    else              color = texture2D(uSamplers[7], vTextureCoord);\n    gl_FragColor = color * vColor;\n}";
+    readonly texture_frag: "\nprecision lowp float;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nuniform sampler2D uSampler;\nvoid main(void) {\n    gl_FragColor = texture2D(uSampler, vTextureCoord) * vColor;\n}";
+    readonly primitive_frag: "\nprecision lowp float;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nvoid main(void) {\n    gl_FragColor = vColor;\n}";
+    readonly blur_frag: "\nprecision mediump float;\nuniform vec2 blur;\nuniform sampler2D uSampler;\nvarying vec2 vTextureCoord;\nuniform vec2 uTextureSize;\nvoid main() {\n    const int sampleRadius = 5;\n    const int samples = sampleRadius * 2 + 1;\n    vec2 blurUv = blur / uTextureSize;\n    vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n    vec2 uv = vec2(0.0, 0.0);\n    blurUv /= float(sampleRadius);\n    for (int i = -sampleRadius; i <= sampleRadius; i++) {\n        uv.x = vTextureCoord.x + float(i) * blurUv.x;\n        uv.y = vTextureCoord.y + float(i) * blurUv.y;\n        color += texture2D(uSampler, uv);\n    }\n    color /= float(samples);\n    gl_FragColor = color;\n}";
+    readonly blur_h_frag: "\nprecision mediump float;\nuniform float blurX;\nuniform sampler2D uSampler;\nvarying vec2 vTextureCoord;\nuniform vec2 uTextureSize;\nvoid main() {\n    float step = 1.0 / uTextureSize.x;\n    vec4 color = vec4(0.0);\n    float total = 0.0;\n    for (int i = -8; i <= 8; i++) {\n        if (abs(float(i)) > blurX) continue;\n        float weight = 1.0 - abs(float(i)) / (blurX + 1.0);\n        color += texture2D(uSampler, vTextureCoord + vec2(float(i) * step, 0.0)) * weight;\n        total += weight;\n    }\n    gl_FragColor = color / total;\n}";
+    readonly blur_v_frag: "\nprecision mediump float;\nuniform float blurY;\nuniform sampler2D uSampler;\nvarying vec2 vTextureCoord;\nuniform vec2 uTextureSize;\nvoid main() {\n    float step = 1.0 / uTextureSize.y;\n    vec4 color = vec4(0.0);\n    float total = 0.0;\n    for (int i = -8; i <= 8; i++) {\n        if (abs(float(i)) > blurY) continue;\n        float weight = 1.0 - abs(float(i)) / (blurY + 1.0);\n        color += texture2D(uSampler, vTextureCoord + vec2(0.0, float(i) * step)) * weight;\n        total += weight;\n    }\n    gl_FragColor = color / total;\n}";
+    readonly glow_frag: "\nprecision highp float;\nvarying vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float dist;\nuniform float angle;\nuniform vec4 color;\nuniform float alpha;\nuniform float blurX;\nuniform float blurY;\nuniform float strength;\nuniform float inner;\nuniform float knockout;\nuniform float hideObject;\nuniform vec2 uTextureSize;\nfloat random(vec2 scale) {\n    return fract(sin(dot(gl_FragCoord.xy, scale)) * 43758.5453);\n}\nvoid main(void) {\n    vec2 px = vec2(1.0 / uTextureSize.x, 1.0 / uTextureSize.y);\n    const float linearSamplingTimes = 7.0;\n    const float circleSamplingTimes = 12.0;\n    vec4 ownColor = texture2D(uSampler, vTextureCoord);\n    vec4 curColor;\n    float totalAlpha = 0.0;\n    float maxTotalAlpha = 0.0;\n    float offsetX = dist * cos(angle) * px.x;\n    float offsetY = dist * sin(angle) * px.y;\n    const float PI = 3.14159265358979323846264;\n    float offset = PI * 2.0 / circleSamplingTimes * random(vec2(12.9898, 78.233));\n    float stepX = blurX * px.x / linearSamplingTimes;\n    float stepY = blurY * px.y / linearSamplingTimes;\n    for (float a = 0.0; a <= PI * 2.0; a += PI * 2.0 / circleSamplingTimes) {\n        float cosAngle = cos(a + offset);\n        float sinAngle = sin(a + offset);\n        for (float i = 1.0; i <= linearSamplingTimes; i++) {\n            float curDistanceX = i * stepX * cosAngle;\n            float curDistanceY = i * stepY * sinAngle;\n            if (vTextureCoord.x + curDistanceX - offsetX >= 0.0 && vTextureCoord.y + curDistanceY + offsetY <= 1.0) {\n                curColor = texture2D(uSampler, vec2(vTextureCoord.x + curDistanceX - offsetX, vTextureCoord.y + curDistanceY + offsetY));\n                totalAlpha += (linearSamplingTimes - i) * curColor.a;\n            }\n            maxTotalAlpha += (linearSamplingTimes - i);\n        }\n    }\n    ownColor.a = max(ownColor.a, 0.0001);\n    ownColor.rgb = ownColor.rgb / ownColor.a;\n    float outerGlowAlpha = (totalAlpha / maxTotalAlpha) * strength * alpha * (1.0 - inner) * max(min(hideObject, knockout), 1.0 - ownColor.a);\n    float innerGlowAlpha = ((maxTotalAlpha - totalAlpha) / maxTotalAlpha) * strength * alpha * inner * ownColor.a;\n    ownColor.a = max(ownColor.a * knockout * (1.0 - hideObject), 0.0001);\n    vec3 mix1 = mix(ownColor.rgb, color.rgb, innerGlowAlpha / (innerGlowAlpha + ownColor.a));\n    vec3 mix2 = mix(mix1, color.rgb, outerGlowAlpha / (innerGlowAlpha + ownColor.a + outerGlowAlpha));\n    float resultAlpha = min(ownColor.a + outerGlowAlpha + innerGlowAlpha, 1.0);\n    gl_FragColor = vec4(mix2 * resultAlpha, resultAlpha);\n}";
+    readonly colorTransform_frag: "\nprecision mediump float;\nvarying vec2 vTextureCoord;\nvarying vec4 vColor;\nuniform mat4 matrix;\nuniform vec4 colorAdd;\nuniform sampler2D uSampler;\nvoid main(void) {\n    vec4 texColor = texture2D(uSampler, vTextureCoord);\n    if (texColor.a > 0.0) {\n        texColor = vec4(texColor.rgb / texColor.a, texColor.a);\n    }\n    vec4 locColor = clamp(texColor * matrix + colorAdd, 0.0, 1.0);\n    gl_FragColor = vColor * vec4(locColor.rgb * locColor.a, locColor.a);\n}";
+};
+export declare const BLUR_TIERS: readonly [4, 8, 16, 32];
+export type BlurTier = (typeof BLUR_TIERS)[number];
+export declare function getBlurTier(radius: number): BlurTier;
+export declare function makeBlurHFrag(tier: BlurTier): string;
+export declare function makeBlurVFrag(tier: BlurTier): string;
+//# sourceMappingURL=ShaderLib.d.ts.map

package/dist/kurot/player/webgl/shaders/ShaderLib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderLib.d.ts","sourceRoot":"","sources":["../../../../../src/kurot/player/webgl/shaders/ShaderLib.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;CA0NZ,CAAC;AAIX,eAAO,MAAM,UAAU,yBAA0B,CAAC;AAClD,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnD,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,CAKpD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAmBpD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAmBpD"}

package/dist/kurot/player/webgl/shaders/ShaderLib.js

@@ -0,0 +1,263 @@
+/**
+ * GLSL ES 1.00 shaders — used with WebGL1 context.
+ * For WebGL2 (GLSL ES 3.00) shaders see ../webgl2/ShaderLib2.ts
+ */
+export const ShaderLib = {
+    default_vert: /* glsl */ `
+attribute vec2 aVertexPosition;
+attribute vec2 aTextureCoord;
+attribute vec4 aColor;
+uniform vec2 projectionVector;
+varying vec2 vTextureCoord;
+varying vec4 vColor;
+const vec2 center = vec2(-1.0, 1.0);
+void main(void) {
+   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);
+   vTextureCoord = aTextureCoord;
+   vColor = aColor;
+   }`,
+    // Standalone vertex shader for fullscreen quad blits (filters, blur passes).
+    // Identical to default_vert but kept separate so filter passes can be
+    // paired with their own fragment shaders without colliding with the
+    // batched-texture program cache key.
+    fullscreen_vert: /* glsl */ `
+   attribute vec2 aVertexPosition;
+   attribute vec2 aTextureCoord;
+   attribute vec4 aColor;
+   uniform vec2 projectionVector;
+   varying vec2 vTextureCoord;
+   varying vec4 vColor;
+   const vec2 center = vec2(-1.0, 1.0);
+   void main(void) {
+      gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);
+      vTextureCoord = aTextureCoord;
+      vColor = aColor;
+   }`,
+    multi_vert: /* glsl */ `
+attribute vec2 aVertexPosition;
+attribute vec2 aTextureCoord;
+attribute vec4 aColor;
+attribute float aTextureId;
+uniform vec2 projectionVector;
+varying vec2 vTextureCoord;
+varying vec4 vColor;
+varying float vTextureId;
+const vec2 center = vec2(-1.0, 1.0);
+void main(void) {
+   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);
+   vTextureCoord = aTextureCoord;
+   vColor = aColor;
+   vTextureId = aTextureId;
+}`,
+    multi_frag: /* glsl */ `
+precision lowp float;
+varying vec2 vTextureCoord;
+varying vec4 vColor;
+varying float vTextureId;
+uniform sampler2D uSamplers[8];
+void main(void) {
+    vec4 color;
+    int id = int(vTextureId + 0.5);
+    if (id == 0)      color = texture2D(uSamplers[0], vTextureCoord);
+    else if (id == 1) color = texture2D(uSamplers[1], vTextureCoord);
+    else if (id == 2) color = texture2D(uSamplers[2], vTextureCoord);
+    else if (id == 3) color = texture2D(uSamplers[3], vTextureCoord);
+    else if (id == 4) color = texture2D(uSamplers[4], vTextureCoord);
+    else if (id == 5) color = texture2D(uSamplers[5], vTextureCoord);
+    else if (id == 6) color = texture2D(uSamplers[6], vTextureCoord);
+    else              color = texture2D(uSamplers[7], vTextureCoord);
+    gl_FragColor = color * vColor;
+}`,
+    texture_frag: /* glsl */ `
+precision lowp float;
+varying vec2 vTextureCoord;
+varying vec4 vColor;
+uniform sampler2D uSampler;
+void main(void) {
+    gl_FragColor = texture2D(uSampler, vTextureCoord) * vColor;
+}`,
+    primitive_frag: /* glsl */ `
+precision lowp float;
+varying vec2 vTextureCoord;
+varying vec4 vColor;
+void main(void) {
+    gl_FragColor = vColor;
+}`,
+    blur_frag: /* glsl */ `
+precision mediump float;
+uniform vec2 blur;
+uniform sampler2D uSampler;
+varying vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+void main() {
+    const int sampleRadius = 5;
+    const int samples = sampleRadius * 2 + 1;
+    vec2 blurUv = blur / uTextureSize;
+    vec4 color = vec4(0.0, 0.0, 0.0, 0.0);
+    vec2 uv = vec2(0.0, 0.0);
+    blurUv /= float(sampleRadius);
+    for (int i = -sampleRadius; i <= sampleRadius; i++) {
+        uv.x = vTextureCoord.x + float(i) * blurUv.x;
+        uv.y = vTextureCoord.y + float(i) * blurUv.y;
+        color += texture2D(uSampler, uv);
+    }
+    color /= float(samples);
+    gl_FragColor = color;
+}`,
+    blur_h_frag: /* glsl */ `
+precision mediump float;
+uniform float blurX;
+uniform sampler2D uSampler;
+varying vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+void main() {
+    float step = 1.0 / uTextureSize.x;
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    for (int i = -8; i <= 8; i++) {
+        if (abs(float(i)) > blurX) continue;
+        float weight = 1.0 - abs(float(i)) / (blurX + 1.0);
+        color += texture2D(uSampler, vTextureCoord + vec2(float(i) * step, 0.0)) * weight;
+        total += weight;
+    }
+    gl_FragColor = color / total;
+}`,
+    blur_v_frag: /* glsl */ `
+precision mediump float;
+uniform float blurY;
+uniform sampler2D uSampler;
+varying vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+void main() {
+    float step = 1.0 / uTextureSize.y;
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    for (int i = -8; i <= 8; i++) {
+        if (abs(float(i)) > blurY) continue;
+        float weight = 1.0 - abs(float(i)) / (blurY + 1.0);
+        color += texture2D(uSampler, vTextureCoord + vec2(0.0, float(i) * step)) * weight;
+        total += weight;
+    }
+    gl_FragColor = color / total;
+}`,
+    glow_frag: /* glsl */ `
+precision highp float;
+varying vec2 vTextureCoord;
+uniform sampler2D uSampler;
+uniform float dist;
+uniform float angle;
+uniform vec4 color;
+uniform float alpha;
+uniform float blurX;
+uniform float blurY;
+uniform float strength;
+uniform float inner;
+uniform float knockout;
+uniform float hideObject;
+uniform vec2 uTextureSize;
+float random(vec2 scale) {
+    return fract(sin(dot(gl_FragCoord.xy, scale)) * 43758.5453);
+}
+void main(void) {
+    vec2 px = vec2(1.0 / uTextureSize.x, 1.0 / uTextureSize.y);
+    const float linearSamplingTimes = 7.0;
+    const float circleSamplingTimes = 12.0;
+    vec4 ownColor = texture2D(uSampler, vTextureCoord);
+    vec4 curColor;
+    float totalAlpha = 0.0;
+    float maxTotalAlpha = 0.0;
+    float offsetX = dist * cos(angle) * px.x;
+    float offsetY = dist * sin(angle) * px.y;
+    const float PI = 3.14159265358979323846264;
+    float offset = PI * 2.0 / circleSamplingTimes * random(vec2(12.9898, 78.233));
+    float stepX = blurX * px.x / linearSamplingTimes;
+    float stepY = blurY * px.y / linearSamplingTimes;
+    for (float a = 0.0; a <= PI * 2.0; a += PI * 2.0 / circleSamplingTimes) {
+        float cosAngle = cos(a + offset);
+        float sinAngle = sin(a + offset);
+        for (float i = 1.0; i <= linearSamplingTimes; i++) {
+            float curDistanceX = i * stepX * cosAngle;
+            float curDistanceY = i * stepY * sinAngle;
+            if (vTextureCoord.x + curDistanceX - offsetX >= 0.0 && vTextureCoord.y + curDistanceY + offsetY <= 1.0) {
+                curColor = texture2D(uSampler, vec2(vTextureCoord.x + curDistanceX - offsetX, vTextureCoord.y + curDistanceY + offsetY));
+                totalAlpha += (linearSamplingTimes - i) * curColor.a;
+            }
+            maxTotalAlpha += (linearSamplingTimes - i);
+        }
+    }
+    ownColor.a = max(ownColor.a, 0.0001);
+    ownColor.rgb = ownColor.rgb / ownColor.a;
+    float outerGlowAlpha = (totalAlpha / maxTotalAlpha) * strength * alpha * (1.0 - inner) * max(min(hideObject, knockout), 1.0 - ownColor.a);
+    float innerGlowAlpha = ((maxTotalAlpha - totalAlpha) / maxTotalAlpha) * strength * alpha * inner * ownColor.a;
+    ownColor.a = max(ownColor.a * knockout * (1.0 - hideObject), 0.0001);
+    vec3 mix1 = mix(ownColor.rgb, color.rgb, innerGlowAlpha / (innerGlowAlpha + ownColor.a));
+    vec3 mix2 = mix(mix1, color.rgb, outerGlowAlpha / (innerGlowAlpha + ownColor.a + outerGlowAlpha));
+    float resultAlpha = min(ownColor.a + outerGlowAlpha + innerGlowAlpha, 1.0);
+    gl_FragColor = vec4(mix2 * resultAlpha, resultAlpha);
+}`,
+    colorTransform_frag: /* glsl */ `
+precision mediump float;
+varying vec2 vTextureCoord;
+varying vec4 vColor;
+uniform mat4 matrix;
+uniform vec4 colorAdd;
+uniform sampler2D uSampler;
+void main(void) {
+    vec4 texColor = texture2D(uSampler, vTextureCoord);
+    if (texColor.a > 0.0) {
+        texColor = vec4(texColor.rgb / texColor.a, texColor.a);
+    }
+    vec4 locColor = clamp(texColor * matrix + colorAdd, 0.0, 1.0);
+    gl_FragColor = vColor * vec4(locColor.rgb * locColor.a, locColor.a);
+}`,
+};
+// ── Dynamic blur shader generation (GLSL ES 1.00) ─────────────────────────────
+export const BLUR_TIERS = [4, 8, 16, 32];
+export function getBlurTier(radius) {
+    for (const tier of BLUR_TIERS) {
+        if (radius <= tier)
+            return tier;
+    }
+    return 32;
+}
+export function makeBlurHFrag(tier) {
+    return /* glsl */ `
+precision mediump float;
+uniform float blurX;
+uniform sampler2D uSampler;
+varying vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+void main() {
+    float step = 1.0 / uTextureSize.x;
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    for (int i = -${tier}; i <= ${tier}; i++) {
+        if (abs(float(i)) > blurX) continue;
+        float weight = 1.0 - abs(float(i)) / (blurX + 1.0);
+        color += texture2D(uSampler, vTextureCoord + vec2(float(i) * step, 0.0)) * weight;
+        total += weight;
+    }
+    gl_FragColor = color / total;
+}`;
+}
+export function makeBlurVFrag(tier) {
+    return /* glsl */ `
+precision mediump float;
+uniform float blurY;
+uniform sampler2D uSampler;
+varying vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+void main() {
+    float step = 1.0 / uTextureSize.y;
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    for (int i = -${tier}; i <= ${tier}; i++) {
+        if (abs(float(i)) > blurY) continue;
+        float weight = 1.0 - abs(float(i)) / (blurY + 1.0);
+        color += texture2D(uSampler, vTextureCoord + vec2(0.0, float(i) * step)) * weight;
+        total += weight;
+    }
+    gl_FragColor = color / total;
+}`;
+}
+//# sourceMappingURL=ShaderLib.js.map

package/dist/kurot/player/webgl/shaders/ShaderLib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderLib.js","sourceRoot":"","sources":["../../../../../src/kurot/player/webgl/shaders/ShaderLib.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACxB,YAAY,EAAE,UAAU,CAAC;;;;;;;;;;;;KAYrB;IAEJ,6EAA6E;IAC7E,sEAAsE;IACtE,oEAAoE;IACpE,qCAAqC;IACrC,eAAe,EAAE,UAAU,CAAC;;;;;;;;;;;;KAYxB;IAEJ,UAAU,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;EAetB;IAED,UAAU,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;EAkBtB;IAED,YAAY,EAAE,UAAU,CAAC;;;;;;;EAOxB;IAED,cAAc,EAAE,UAAU,CAAC;;;;;;EAM1B;IAED,SAAS,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;EAoBrB;IAED,WAAW,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;EAiBvB;IAED,WAAW,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;EAiBvB;IAED,SAAS,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsDrB;IAED,mBAAmB,EAAE,UAAU,CAAC;;;;;;;;;;;;;;EAc/B;CACQ,CAAC;AAEX,iFAAiF;AAEjF,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAU,CAAC;AAGlD,MAAM,UAAU,WAAW,CAAC,MAAc;IACzC,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC/B,IAAI,MAAM,IAAI,IAAI;YAAE,OAAO,IAAI,CAAC;IACjC,CAAC;IACD,OAAO,EAAE,CAAC;AACX,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,IAAc;IAC3C,OAAO,UAAU,CAAC;;;;;;;;;;oBAUC,IAAI,UAAU,IAAI;;;;;;;EAOpC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,IAAc;IAC3C,OAAO,UAAU,CAAC;;;;;;;;;;oBAUC,IAAI,UAAU,IAAI;;;;;;;EAOpC,CAAC;AACH,CAAC"}

package/dist/kurot/player/webgl/shaders/ShaderLib2.d.ts

@@ -0,0 +1,23 @@
+/**
+ * GLSL ES 3.00 shaders — used with WebGL2 context.
+ * For WebGL1 (GLSL ES 1.00) shaders see ../webgl/ShaderLib.ts
+ */
+export declare const ShaderLib2: {
+    readonly default_vert: "#version 300 es\nin vec2 aVertexPosition;\nin vec2 aTextureCoord;\nin vec4 aColor;\nuniform vec2 projectionVector;\nout vec2 vTextureCoord;\nout vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n   vColor = aColor;\n}";
+    readonly fullscreen_vert: "#version 300 es\nin vec2 aVertexPosition;\nin vec2 aTextureCoord;\nin vec4 aColor;\nuniform vec2 projectionVector;\nout vec2 vTextureCoord;\nout vec4 vColor;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n   vColor = aColor;\n}";
+    readonly multi_vert: "#version 300 es\nin vec2 aVertexPosition;\nin vec2 aTextureCoord;\nin vec4 aColor;\nin float aTextureId;\nuniform vec2 projectionVector;\nout vec2 vTextureCoord;\nout vec4 vColor;\nout float vTextureId;\nconst vec2 center = vec2(-1.0, 1.0);\nvoid main(void) {\n   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);\n   vTextureCoord = aTextureCoord;\n   vColor = aColor;\n   vTextureId = aTextureId;\n}";
+    readonly multi_frag: "#version 300 es\nprecision lowp float;\nin vec2 vTextureCoord;\nin vec4 vColor;\nin float vTextureId;\nuniform sampler2D uSamplers[8];\nout vec4 fragColor;\nvoid main(void) {\n    vec4 color;\n    int id = int(vTextureId + 0.5);\n    if (id == 0)      color = texture(uSamplers[0], vTextureCoord);\n    else if (id == 1) color = texture(uSamplers[1], vTextureCoord);\n    else if (id == 2) color = texture(uSamplers[2], vTextureCoord);\n    else if (id == 3) color = texture(uSamplers[3], vTextureCoord);\n    else if (id == 4) color = texture(uSamplers[4], vTextureCoord);\n    else if (id == 5) color = texture(uSamplers[5], vTextureCoord);\n    else if (id == 6) color = texture(uSamplers[6], vTextureCoord);\n    else              color = texture(uSamplers[7], vTextureCoord);\n    fragColor = color * vColor;\n}";
+    readonly texture_frag: "#version 300 es\nprecision lowp float;\nin vec2 vTextureCoord;\nin vec4 vColor;\nuniform sampler2D uSampler;\nout vec4 fragColor;\nvoid main(void) {\n    fragColor = texture(uSampler, vTextureCoord) * vColor;\n}";
+    readonly primitive_frag: "#version 300 es\nprecision lowp float;\nin vec2 vTextureCoord;\nin vec4 vColor;\nout vec4 fragColor;\nvoid main(void) {\n    fragColor = vColor;\n}";
+    readonly blur_frag: "#version 300 es\nprecision mediump float;\nuniform vec2 blur;\nuniform sampler2D uSampler;\nin vec2 vTextureCoord;\nuniform vec2 uTextureSize;\nout vec4 fragColor;\nvoid main() {\n    const int sampleRadius = 5;\n    const int samples = sampleRadius * 2 + 1;\n    vec2 blurUv = blur / uTextureSize;\n    vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n    vec2 uv = vec2(0.0, 0.0);\n    blurUv /= float(sampleRadius);\n    for (int i = -sampleRadius; i <= sampleRadius; i++) {\n        uv.x = vTextureCoord.x + float(i) * blurUv.x;\n        uv.y = vTextureCoord.y + float(i) * blurUv.y;\n        color += texture(uSampler, uv);\n    }\n    color /= float(samples);\n    fragColor = color;\n}";
+    readonly blur_h_frag: "#version 300 es\nprecision mediump float;\nuniform float blurX;\nuniform sampler2D uSampler;\nin vec2 vTextureCoord;\nuniform vec2 uTextureSize;\nout vec4 fragColor;\nvoid main() {\n    float step = 1.0 / uTextureSize.x;\n    vec4 color = vec4(0.0);\n    float total = 0.0;\n    for (int i = -8; i <= 8; i++) {\n        if (abs(float(i)) > blurX) continue;\n        float weight = 1.0 - abs(float(i)) / (blurX + 1.0);\n        color += texture(uSampler, vTextureCoord + vec2(float(i) * step, 0.0)) * weight;\n        total += weight;\n    }\n    fragColor = color / total;\n}";
+    readonly blur_v_frag: "#version 300 es\nprecision mediump float;\nuniform float blurY;\nuniform sampler2D uSampler;\nin vec2 vTextureCoord;\nuniform vec2 uTextureSize;\nout vec4 fragColor;\nvoid main() {\n    float step = 1.0 / uTextureSize.y;\n    vec4 color = vec4(0.0);\n    float total = 0.0;\n    for (int i = -8; i <= 8; i++) {\n        if (abs(float(i)) > blurY) continue;\n        float weight = 1.0 - abs(float(i)) / (blurY + 1.0);\n        color += texture(uSampler, vTextureCoord + vec2(0.0, float(i) * step)) * weight;\n        total += weight;\n    }\n    fragColor = color / total;\n}";
+    readonly glow_frag: "#version 300 es\nprecision highp float;\nin vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform float dist;\nuniform float angle;\nuniform vec4 color;\nuniform float alpha;\nuniform float blurX;\nuniform float blurY;\nuniform float strength;\nuniform float inner;\nuniform float knockout;\nuniform float hideObject;\nuniform vec2 uTextureSize;\nout vec4 fragColor;\nfloat random(vec2 scale) {\n    return fract(sin(dot(gl_FragCoord.xy, scale)) * 43758.5453);\n}\nvoid main(void) {\n    vec2 px = vec2(1.0 / uTextureSize.x, 1.0 / uTextureSize.y);\n    const float linearSamplingTimes = 7.0;\n    const float circleSamplingTimes = 12.0;\n    vec4 ownColor = texture(uSampler, vTextureCoord);\n    vec4 curColor;\n    float totalAlpha = 0.0;\n    float maxTotalAlpha = 0.0;\n    float offsetX = dist * cos(angle) * px.x;\n    float offsetY = dist * sin(angle) * px.y;\n    const float PI = 3.14159265358979323846264;\n    float offset = PI * 2.0 / circleSamplingTimes * random(vec2(12.9898, 78.233));\n    float stepX = blurX * px.x / linearSamplingTimes;\n    float stepY = blurY * px.y / linearSamplingTimes;\n    for (float a = 0.0; a <= PI * 2.0; a += PI * 2.0 / circleSamplingTimes) {\n        float cosAngle = cos(a + offset);\n        float sinAngle = sin(a + offset);\n        for (float i = 1.0; i <= linearSamplingTimes; i++) {\n            float curDistanceX = i * stepX * cosAngle;\n            float curDistanceY = i * stepY * sinAngle;\n            if (vTextureCoord.x + curDistanceX - offsetX >= 0.0 && vTextureCoord.y + curDistanceY + offsetY <= 1.0) {\n                curColor = texture(uSampler, vec2(vTextureCoord.x + curDistanceX - offsetX, vTextureCoord.y + curDistanceY + offsetY));\n                totalAlpha += (linearSamplingTimes - i) * curColor.a;\n            }\n            maxTotalAlpha += (linearSamplingTimes - i);\n        }\n    }\n    ownColor.a = max(ownColor.a, 0.0001);\n    ownColor.rgb = ownColor.rgb / ownColor.a;\n    float outerGlowAlpha = (totalAlpha / maxTotalAlpha) * strength * alpha * (1.0 - inner) * max(min(hideObject, knockout), 1.0 - ownColor.a);\n    float innerGlowAlpha = ((maxTotalAlpha - totalAlpha) / maxTotalAlpha) * strength * alpha * inner * ownColor.a;\n    ownColor.a = max(ownColor.a * knockout * (1.0 - hideObject), 0.0001);\n    vec3 mix1 = mix(ownColor.rgb, color.rgb, innerGlowAlpha / (innerGlowAlpha + ownColor.a));\n    vec3 mix2 = mix(mix1, color.rgb, outerGlowAlpha / (innerGlowAlpha + ownColor.a + outerGlowAlpha));\n    float resultAlpha = min(ownColor.a + outerGlowAlpha + innerGlowAlpha, 1.0);\n    fragColor = vec4(mix2 * resultAlpha, resultAlpha);\n}";
+    readonly colorTransform_frag: "#version 300 es\nprecision mediump float;\nin vec2 vTextureCoord;\nin vec4 vColor;\nuniform mat4 matrix;\nuniform vec4 colorAdd;\nuniform sampler2D uSampler;\nout vec4 fragColor;\nvoid main(void) {\n    vec4 texColor = texture(uSampler, vTextureCoord);\n    if (texColor.a > 0.0) {\n        texColor = vec4(texColor.rgb / texColor.a, texColor.a);\n    }\n    vec4 locColor = clamp(texColor * matrix + colorAdd, 0.0, 1.0);\n    fragColor = vColor * vec4(locColor.rgb * locColor.a, locColor.a);\n}";
+};
+export declare const BLUR_TIERS2: readonly [4, 8, 16, 32];
+export type BlurTier2 = (typeof BLUR_TIERS2)[number];
+export declare function getBlurTier2(radius: number): BlurTier2;
+export declare function makeBlurHFrag2(tier: BlurTier2): string;
+export declare function makeBlurVFrag2(tier: BlurTier2): string;
+//# sourceMappingURL=ShaderLib2.d.ts.map

package/dist/kurot/player/webgl/shaders/ShaderLib2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderLib2.d.ts","sourceRoot":"","sources":["../../../../../src/kurot/player/webgl/shaders/ShaderLib2.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;CAyOb,CAAC;AAIX,eAAO,MAAM,WAAW,yBAA0B,CAAC;AACnD,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAKtD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAoBtD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAoBtD"}