@blakron/core 0.5.0 → 0.5.2

package/dist/blakron/player/webgl/ShaderLib.js

@@ -1,268 +0,0 @@
-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-texture vertex shader: carries textureId as a float attribute.
-    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-texture fragment shader: samples from one of up to 8 texture units.
-    // WebGL 1 does not support dynamic indexing into sampler arrays, so we use
-    // an if/else chain — the same technique used by Pixi.js for WebGL1.
-    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;
-}`,
-    // Horizontal blur pass for ping-pong two-pass Gaussian blur.
-    // Samples along the X axis only; blurX is the radius in pixels.
-    // Radius is hardcoded to 8 (legacy fallback, kept for reference).
-    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;
-}`,
-    // Vertical blur pass for ping-pong two-pass Gaussian blur.
-    // Samples along the Y axis only; blurY is the radius in pixels.
-    // Radius is hardcoded to 8 (legacy fallback, kept for reference).
-    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 ───────────────────────────────────────────
-/**
- * Blur radius tiers. Each tier generates a dedicated shader variant with a
- * loop bound matching the tier value, avoiding the WebGL1 limitation where
- * loop bounds must be compile-time constants.
- *
- * Tier selection: pick the smallest tier >= ceil(blurValue).
- * e.g. blurX=5 → tier 8, blurX=12 → tier 16, blurX=25 → tier 32.
- */
-export const BLUR_TIERS = [4, 8, 16, 32];
-/** Returns the smallest tier that can accommodate the given blur radius. */
-export function getBlurTier(radius) {
-    for (const tier of BLUR_TIERS) {
-        if (radius <= tier)
-            return tier;
-    }
-    return 32;
-}
-/**
- * Generates a horizontal blur fragment shader for the given radius tier.
- * The loop bound is a compile-time constant so it is valid in WebGL1 GLSL.
- */
-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;
-}`;
-}
-/**
- * Generates a vertical blur fragment shader for the given radius tier.
- */
-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/ShaderLib.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ShaderLib.js","sourceRoot":"","sources":["../../../../src/blakron/player/webgl/ShaderLib.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,SAAS,GAAG;IACxB,YAAY,EAAE,UAAU,CAAC;;;;;;;;;;;;EAYxB;IAED,uEAAuE;IACvE,UAAU,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;EAetB;IAED,4EAA4E;IAC5E,2EAA2E;IAC3E,oEAAoE;IACpE,UAAU,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;EAkBtB;IAED,YAAY,EAAE,UAAU,CAAC;;;;;;;EAOxB;IAED,cAAc,EAAE,UAAU,CAAC;;;;;;EAM1B;IAED,SAAS,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;EAoBrB;IAED,6DAA6D;IAC7D,gEAAgE;IAChE,kEAAkE;IAClE,WAAW,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;EAiBvB;IAED,2DAA2D;IAC3D,gEAAgE;IAChE,kEAAkE;IAClE,WAAW,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;EAiBvB;IAED,SAAS,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsDrB;IAED,mBAAmB,EAAE,UAAU,CAAC;;;;;;;;;;;;;;EAc/B;CACQ,CAAC;AAEX,gFAAgF;AAEhF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAU,CAAC;AAGlD,4EAA4E;AAC5E,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;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,IAAc;IAC3C,OAAO,UAAU,CAAC;;;;;;;;;;oBAUC,IAAI,UAAU,IAAI;;;;;;;EAOpC,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,IAAc;IAC3C,OAAO,UAAU,CAAC;;;;;;;;;;oBAUC,IAAI,UAAU,IAAI;;;;;;;EAOpC,CAAC;AACH,CAAC"}