@blakron/core 0.4.0 → 0.4.2

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

@@ -0,0 +1,22 @@
+/**
+ * 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 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/blakron/player/webgl/shaders/ShaderLib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderLib.d.ts","sourceRoot":"","sources":["../../../../../src/blakron/player/webgl/shaders/ShaderLib.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;CAwMZ,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/blakron/player/webgl/shaders/ShaderLib.js

@@ -0,0 +1,246 @@
+/**
+ * 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;
+}`,
+    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/blakron/player/webgl/shaders/ShaderLib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderLib.js","sourceRoot":"","sources":["../../../../../src/blakron/player/webgl/shaders/ShaderLib.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACxB,YAAY,EAAE,UAAU,CAAC;;;;;;;;;;;;EAYxB;IAED,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/blakron/player/webgl/shaders/ShaderLib2.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 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/blakron/player/webgl/shaders/ShaderLib2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderLib2.d.ts","sourceRoot":"","sources":["../../../../../src/blakron/player/webgl/shaders/ShaderLib2.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;CAqNb,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"}

package/dist/blakron/player/webgl/shaders/ShaderLib2.js

@@ -0,0 +1,261 @@
+/**
+ * GLSL ES 3.00 shaders — used with WebGL2 context.
+ * For WebGL1 (GLSL ES 1.00) shaders see ../webgl/ShaderLib.ts
+ */
+export const ShaderLib2 = {
+    default_vert: /* glsl */ `#version 300 es
+in vec2 aVertexPosition;
+in vec2 aTextureCoord;
+in vec4 aColor;
+uniform vec2 projectionVector;
+out vec2 vTextureCoord;
+out 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-texture vertex shader: carries textureId as a float attribute.
+    multi_vert: /* glsl */ `#version 300 es
+in vec2 aVertexPosition;
+in vec2 aTextureCoord;
+in vec4 aColor;
+in float aTextureId;
+uniform vec2 projectionVector;
+out vec2 vTextureCoord;
+out vec4 vColor;
+out 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-texture fragment shader.
+    // WebGL2 / GLSL ES 3.00 supports dynamic indexing into sampler arrays natively.
+    multi_frag: /* glsl */ `#version 300 es
+precision lowp float;
+in vec2 vTextureCoord;
+in vec4 vColor;
+in float vTextureId;
+uniform sampler2D uSamplers[8];
+out vec4 fragColor;
+void main(void) {
+    vec4 color;
+    int id = int(vTextureId + 0.5);
+    if (id == 0)      color = texture(uSamplers[0], vTextureCoord);
+    else if (id == 1) color = texture(uSamplers[1], vTextureCoord);
+    else if (id == 2) color = texture(uSamplers[2], vTextureCoord);
+    else if (id == 3) color = texture(uSamplers[3], vTextureCoord);
+    else if (id == 4) color = texture(uSamplers[4], vTextureCoord);
+    else if (id == 5) color = texture(uSamplers[5], vTextureCoord);
+    else if (id == 6) color = texture(uSamplers[6], vTextureCoord);
+    else              color = texture(uSamplers[7], vTextureCoord);
+    fragColor = color * vColor;
+}`,
+    texture_frag: /* glsl */ `#version 300 es
+precision lowp float;
+in vec2 vTextureCoord;
+in vec4 vColor;
+uniform sampler2D uSampler;
+out vec4 fragColor;
+void main(void) {
+    fragColor = texture(uSampler, vTextureCoord) * vColor;
+}`,
+    primitive_frag: /* glsl */ `#version 300 es
+precision lowp float;
+in vec2 vTextureCoord;
+in vec4 vColor;
+out vec4 fragColor;
+void main(void) {
+    fragColor = vColor;
+}`,
+    blur_frag: /* glsl */ `#version 300 es
+precision mediump float;
+uniform vec2 blur;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+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 += texture(uSampler, uv);
+    }
+    color /= float(samples);
+    fragColor = color;
+}`,
+    // Horizontal blur pass for ping-pong two-pass Gaussian blur.
+    blur_h_frag: /* glsl */ `#version 300 es
+precision mediump float;
+uniform float blurX;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+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 += texture(uSampler, vTextureCoord + vec2(float(i) * step, 0.0)) * weight;
+        total += weight;
+    }
+    fragColor = color / total;
+}`,
+    // Vertical blur pass for ping-pong two-pass Gaussian blur.
+    blur_v_frag: /* glsl */ `#version 300 es
+precision mediump float;
+uniform float blurY;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+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 += texture(uSampler, vTextureCoord + vec2(0.0, float(i) * step)) * weight;
+        total += weight;
+    }
+    fragColor = color / total;
+}`,
+    glow_frag: /* glsl */ `#version 300 es
+precision highp float;
+in 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;
+out vec4 fragColor;
+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 = texture(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 = texture(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);
+    fragColor = vec4(mix2 * resultAlpha, resultAlpha);
+}`,
+    colorTransform_frag: /* glsl */ `#version 300 es
+precision mediump float;
+in vec2 vTextureCoord;
+in vec4 vColor;
+uniform mat4 matrix;
+uniform vec4 colorAdd;
+uniform sampler2D uSampler;
+out vec4 fragColor;
+void main(void) {
+    vec4 texColor = texture(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);
+    fragColor = vColor * vec4(locColor.rgb * locColor.a, locColor.a);
+}`,
+};
+// ── Dynamic blur shader generation (GLSL ES 3.00) ─────────────────────────────
+export const BLUR_TIERS2 = [4, 8, 16, 32];
+export function getBlurTier2(radius) {
+    for (const tier of BLUR_TIERS2) {
+        if (radius <= tier)
+            return tier;
+    }
+    return 32;
+}
+export function makeBlurHFrag2(tier) {
+    return /* glsl */ `#version 300 es
+precision mediump float;
+uniform float blurX;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+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 += texture(uSampler, vTextureCoord + vec2(float(i) * step, 0.0)) * weight;
+        total += weight;
+    }
+    fragColor = color / total;
+}`;
+}
+export function makeBlurVFrag2(tier) {
+    return /* glsl */ `#version 300 es
+precision mediump float;
+uniform float blurY;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+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 += texture(uSampler, vTextureCoord + vec2(0.0, float(i) * step)) * weight;
+        total += weight;
+    }
+    fragColor = color / total;
+}`;
+}
+//# sourceMappingURL=ShaderLib2.js.map

package/dist/blakron/player/webgl/shaders/ShaderLib2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderLib2.js","sourceRoot":"","sources":["../../../../../src/blakron/player/webgl/shaders/ShaderLib2.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACzB,YAAY,EAAE,UAAU,CAAC;;;;;;;;;;;;EAYxB;IAED,uEAAuE;IACvE,UAAU,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;EAetB;IAED,iCAAiC;IACjC,gFAAgF;IAChF,UAAU,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;EAmBtB;IAED,YAAY,EAAE,UAAU,CAAC;;;;;;;;EAQxB;IAED,cAAc,EAAE,UAAU,CAAC;;;;;;;EAO1B;IAED,SAAS,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;EAqBrB;IAED,6DAA6D;IAC7D,WAAW,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;EAkBvB;IAED,2DAA2D;IAC3D,WAAW,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;EAkBvB;IAED,SAAS,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDrB;IAED,mBAAmB,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;EAe/B;CACQ,CAAC;AAEX,iFAAiF;AAEjF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAU,CAAC;AAGnD,MAAM,UAAU,YAAY,CAAC,MAAc;IAC1C,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAChC,IAAI,MAAM,IAAI,IAAI;YAAE,OAAO,IAAI,CAAC;IACjC,CAAC;IACD,OAAO,EAAE,CAAC;AACX,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,IAAe;IAC7C,OAAO,UAAU,CAAC;;;;;;;;;;;oBAWC,IAAI,UAAU,IAAI;;;;;;;EAOpC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,IAAe;IAC7C,OAAO,UAAU,CAAC;;;;;;;;;;;oBAWC,IAAI,UAAU,IAAI;;;;;;;EAOpC,CAAC;AACH,CAAC"}

package/dist/blakron/player/webgl/shaders/index.d.ts

@@ -0,0 +1,5 @@
+export { ShaderLib, BLUR_TIERS, getBlurTier, makeBlurHFrag, makeBlurVFrag } from './ShaderLib.js';
+export type { BlurTier } from './ShaderLib.js';
+export { ShaderLib2, BLUR_TIERS2, getBlurTier2, makeBlurHFrag2, makeBlurVFrag2 } from './ShaderLib2.js';
+export type { BlurTier2 } from './ShaderLib2.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/blakron/player/webgl/shaders/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/blakron/player/webgl/shaders/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAClG,YAAY,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxG,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/blakron/player/webgl/shaders/index.js

@@ -0,0 +1,5 @@
+// GLSL ES 1.00 — WebGL1
+export { ShaderLib, BLUR_TIERS, getBlurTier, makeBlurHFrag, makeBlurVFrag } from './ShaderLib.js';
+// GLSL ES 3.00 — WebGL2
+export { ShaderLib2, BLUR_TIERS2, getBlurTier2, makeBlurHFrag2, makeBlurVFrag2 } from './ShaderLib2.js';
+//# sourceMappingURL=index.js.map

package/dist/blakron/player/webgl/shaders/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/blakron/player/webgl/shaders/index.ts"],"names":[],"mappings":"AAAA,wBAAwB;AACxB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGlG,wBAAwB;AACxB,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/blakron/player/webgl2/ShaderLib2.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 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/blakron/player/webgl2/ShaderLib2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderLib2.d.ts","sourceRoot":"","sources":["../../../../src/blakron/player/webgl2/ShaderLib2.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;CAqNb,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"}