@oxy.so/bloom 7.1.2 → 7.1.4

package/assets/character-runtime/sha256.mjs

@@ -0,0 +1,44 @@
+// SHA-256 for insecure HTTP/WebView origins without SubtleCrypto. The standard
+// 32-bit round operations hash original bytes; no trusted-hash shortcut.
+const K = new Uint32Array([
+  0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
+  0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
+  0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
+  0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
+  0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
+  0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
+  0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
+  0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,
+]);
+const rotate = (x,n) => (x >>> n) | (x << (32-n));
+export function sha256Bytes(value) {
+  const source = value instanceof Uint8Array ? value : new Uint8Array(value);
+  const length = source.length;
+  const bytes = new Uint8Array(Math.ceil((length + 9)/64)*64);
+  bytes.set(source); bytes[length] = 128;
+  const view = new DataView(bytes.buffer);
+  view.setUint32(bytes.length-8, Math.floor(length / 0x20000000));
+  view.setUint32(bytes.length-4, (length*8) >>> 0);
+  const h = new Uint32Array([0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19]);
+  const w = new Uint32Array(64);
+  for (let offset=0;offset<bytes.length;offset+=64) {
+    for(let j=0;j<16;j++) w[j]=view.getUint32(offset+j*4);
+    for(let j=16;j<64;j++) {
+      const x=w[j-15], y=w[j-2];
+      w[j]=(w[j-16]+(rotate(x,7)^rotate(x,18)^(x>>>3))+w[j-7]+(rotate(y,17)^rotate(y,19)^(y>>>10)))>>>0;
+    }
+    let [a,b,c,d,e,f,g,z]=h;
+    for(let j=0;j<64;j++) {
+      const t1=(z+(rotate(e,6)^rotate(e,11)^rotate(e,25))+((e&f)^(~e&g))+K[j]+w[j])>>>0;
+      const t2=((rotate(a,2)^rotate(a,13)^rotate(a,22))+((a&b)^(a&c)^(b&c)))>>>0;
+      z=g;g=f;f=e;e=(d+t1)>>>0;d=c;c=b;b=a;a=(t1+t2)>>>0;
+    }
+    const next=[a,b,c,d,e,f,g,z];for(let j=0;j<8;j++)h[j]=(h[j]+next[j])>>>0;
+  }
+  return Array.from(h,word=>word.toString(16).padStart(8,'0')).join('');
+}
+export async function sha256(value) {
+  if (globalThis.crypto?.subtle)
+    return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', value)),byte=>byte.toString(16).padStart(2,'0')).join('');
+  return sha256Bytes(value);
+}

package/assets/character-runtime/shared-programs.mjs

@@ -0,0 +1,534 @@
+// Original shaders/programs, shared within ONE real context. The logical objects
+// remain separate because Emscripten stores mutable IDs and uniform caches on them.
+// This wrapper does not own the context and never suppresses context loss itself.
+// Mali-G715 rejects this GLSL ES array constructor even with an explicit
+// precision qualifier. Lower only the two known original-engine expressions;
+// assigning the same four values separately preserves their evaluation order.
+// Keep the source binaries intact and leave unrelated shaders byte-for-byte alone.
+export function compatibleShaderSource(source) {
+  return source
+    .replace(
+      "float felipeLTC(vec3 p,mat3 transform,vec3 rect[4]) {",
+      "float felipeLTC(vec3 p,mat3 transform,highp vec3 rect[4]) {",
+    )
+    .replace(
+      "vec3 rect[4]=vec3[4](light+right-up,light-right-up,light-right+up,light+right+up);",
+      "highp vec3 rect[4];rect[0]=light+right-up;rect[1]=light-right-up;rect[2]=light-right+up;rect[3]=light+right+up;",
+    );
+}
+
+export function createSharedProgramPool(gl) {
+  const shaders = new WeakMap(),
+    programs = new WeakMap(),
+    locations = new WeakMap();
+  const shaderCache = new Map(),
+    programCache = new Map();
+  const livePrograms = new Set(),
+    liveShaders = new Set(),
+    bound = new Map();
+  let current = null,
+    disposed = false,
+    shaderCompiles = 0,
+    programLinks = 0,
+    uniformReplays = 0,
+    uniformReplaySkips = 0,
+    blockReplays = 0,
+    blockReplaySkips = 0;
+
+  const shaderKey = (s) => JSON.stringify([s.type, s.source]);
+  function collectShader(entry) {
+    if (!entry || entry.records.size || entry.programs.size) return;
+    gl.deleteShader(entry.real);
+    if (shaderCache.get(entry.key) === entry) shaderCache.delete(entry.key);
+  }
+  function releaseShader(s) {
+    if (!s.deleted || s.attached.size) return;
+    liveShaders.delete(s);
+    s.entry?.records.delete(s);
+    collectShader(s.entry);
+  }
+  function compile(s) {
+    const key = shaderKey(s);
+    if (s.entry?.key === key) return s.entry;
+    let entry = shaderCache.get(key);
+    if (!entry) {
+      const real = gl.createShader(s.type);
+      gl.shaderSource(real, compatibleShaderSource(s.source));
+      gl.compileShader(real);
+      shaderCompiles++;
+      entry = { key, real, records: new Set(), programs: new Set() };
+      shaderCache.set(key, entry);
+    }
+    const previous = s.entry;
+    previous?.records.delete(s);
+    entry.records.add(s);
+    s.entry = entry;
+    collectShader(previous);
+    return entry;
+  }
+  function releaseProgramEntry(p) {
+    const entry = p.entry;
+    if (!entry) return;
+    p.entry = null;
+    entry.refs.delete(p);
+    if (entry.owner === p) entry.owner = null;
+    if (entry.refs.size) return;
+    gl.deleteProgram(entry.real);
+    if (programCache.get(entry.key) === entry) programCache.delete(entry.key);
+    for (const shader of entry.shaders) {
+      shader.programs.delete(entry);
+      collectShader(shader);
+    }
+  }
+  // Active uniform reflection provides complete defaults, including uniforms an
+  // alias has never assigned. Otherwise switching to a new alias leaks old values.
+  const types = new Map([
+    [gl.FLOAT, ["uniform1fv", 1, Float32Array]],
+    [gl.FLOAT_VEC2, ["uniform2fv", 2, Float32Array]],
+    [gl.FLOAT_VEC3, ["uniform3fv", 3, Float32Array]],
+    [gl.FLOAT_VEC4, ["uniform4fv", 4, Float32Array]],
+    [gl.INT, ["uniform1iv", 1, Int32Array]],
+    [gl.INT_VEC2, ["uniform2iv", 2, Int32Array]],
+    [gl.INT_VEC3, ["uniform3iv", 3, Int32Array]],
+    [gl.INT_VEC4, ["uniform4iv", 4, Int32Array]],
+    [gl.UNSIGNED_INT, ["uniform1uiv", 1, Uint32Array]],
+    [gl.UNSIGNED_INT_VEC2, ["uniform2uiv", 2, Uint32Array]],
+    [gl.UNSIGNED_INT_VEC3, ["uniform3uiv", 3, Uint32Array]],
+    [gl.UNSIGNED_INT_VEC4, ["uniform4uiv", 4, Uint32Array]],
+    [gl.BOOL, ["uniform1iv", 1, Int32Array]],
+    [gl.BOOL_VEC2, ["uniform2iv", 2, Int32Array]],
+    [gl.BOOL_VEC3, ["uniform3iv", 3, Int32Array]],
+    [gl.BOOL_VEC4, ["uniform4iv", 4, Int32Array]],
+    [gl.FLOAT_MAT2, ["uniformMatrix2fv", 4, Float32Array]],
+    [gl.FLOAT_MAT3, ["uniformMatrix3fv", 9, Float32Array]],
+    [gl.FLOAT_MAT4, ["uniformMatrix4fv", 16, Float32Array]],
+    [gl.FLOAT_MAT2x3, ["uniformMatrix2x3fv", 6, Float32Array]],
+    [gl.FLOAT_MAT2x4, ["uniformMatrix2x4fv", 8, Float32Array]],
+    [gl.FLOAT_MAT3x2, ["uniformMatrix3x2fv", 6, Float32Array]],
+    [gl.FLOAT_MAT3x4, ["uniformMatrix3x4fv", 12, Float32Array]],
+    [gl.FLOAT_MAT4x2, ["uniformMatrix4x2fv", 8, Float32Array]],
+    [gl.FLOAT_MAT4x3, ["uniformMatrix4x3fv", 12, Float32Array]],
+  ]);
+  for (const name of [
+    "SAMPLER_2D",
+    "SAMPLER_CUBE",
+    "SAMPLER_3D",
+    "SAMPLER_2D_SHADOW",
+    "SAMPLER_2D_ARRAY",
+    "SAMPLER_2D_ARRAY_SHADOW",
+    "SAMPLER_CUBE_SHADOW",
+    "INT_SAMPLER_2D",
+    "INT_SAMPLER_3D",
+    "INT_SAMPLER_CUBE",
+    "INT_SAMPLER_2D_ARRAY",
+    "UNSIGNED_INT_SAMPLER_2D",
+    "UNSIGNED_INT_SAMPLER_3D",
+    "UNSIGNED_INT_SAMPLER_CUBE",
+    "UNSIGNED_INT_SAMPLER_2D_ARRAY",
+  ])
+    types.set(gl[name], ["uniform1iv", 1, Int32Array]);
+
+  function reflect(real) {
+    const uniforms = [],
+      names = new Map();
+    for (let i = 0; i < gl.getProgramParameter(real, gl.ACTIVE_UNIFORMS); i++) {
+      const active = gl.getActiveUniform(real, i);
+      const location = gl.getUniformLocation(real, active.name);
+      if (location === null) continue; // Uniform block members use buffers.
+      const type = types.get(active.type);
+      if (!type)
+        throw new Error(`Unsupported shared uniform type: ${active.type}`);
+      const [method, width, ArrayType] = type;
+      const uniform = {
+        name: active.name,
+        size: active.size,
+        method,
+        width,
+        ArrayType,
+        matrix: method.startsWith("uniformMatrix"),
+        location,
+        type: active.type,
+      };
+      const index = uniforms.push(uniform) - 1;
+      for (let element = 0; element < active.size; element++) {
+        const name = active.name.includes("[0]")
+          ? active.name.replace("[0]", `[${element}]`)
+          : active.name;
+        names.set(name, { index, element });
+      }
+      if (active.name.endsWith("[0]"))
+        names.set(active.name.slice(0, -3), { index, element: 0 });
+    }
+    return {
+      uniforms,
+      names,
+      blocks: gl.getProgramParameter(real, gl.ACTIVE_UNIFORM_BLOCKS),
+    };
+  }
+  function link(p) {
+    const attached = [...p.attached].map((shader) =>
+      compile(shaders.get(shader)),
+    );
+    const bindings = [...p.bindings].sort(([a], [b]) => a.localeCompare(b));
+    const key = JSON.stringify([
+      attached.map((s) => s.key).sort(),
+      bindings,
+      p.feedback,
+    ]);
+    let entry = programCache.get(key);
+    if (!entry) {
+      const real = p.unlinked ?? gl.createProgram();
+      p.unlinked = null;
+      for (const shader of attached) gl.attachShader(real, shader.real);
+      for (const [name, index] of bindings)
+        gl.bindAttribLocation(real, index, name);
+      if (p.feedback) gl.transformFeedbackVaryings(real, ...p.feedback);
+      gl.linkProgram(real);
+      programLinks++;
+      const linked = gl.getProgramParameter(real, gl.LINK_STATUS);
+      const reflection = linked
+        ? reflect(real)
+        : { uniforms: [], names: new Map(), blocks: 0 };
+      entry = {
+        key,
+        real,
+        linked,
+        shaders: attached,
+        refs: new Set(),
+        owner: null,
+        ...reflection,
+      };
+      programCache.set(key, entry);
+      for (const shader of attached) shader.programs.add(entry);
+    }
+    // Hold the new reference before releasing a same-key previous link.
+    const previous = p.entry;
+    if (previous !== entry) {
+      releaseProgramEntry(p);
+      entry.refs.add(p);
+      p.entry = entry;
+    }
+    if (p.unlinked) {
+      gl.deleteProgram(p.unlinked);
+      p.unlinked = null;
+    }
+    p.values = entry.uniforms.map((u) => new u.ArrayType(u.width * u.size));
+    p.blockBindings = new Uint32Array(entry.blocks);
+    p.locations.clear();
+    p.generation++;
+    // Relinking resets the logical program's uniforms even when its source key
+    // stays identical. A later useProgram must replay the reset values.
+    if (entry.owner === p) entry.owner = null;
+    if (current === p) use(p);
+  }
+  function realProgram(p) {
+    return p.entry?.real ?? (p.unlinked ??= gl.createProgram());
+  }
+  function equalValues(a, b) {
+    if (!a || a.length !== b.length) return false;
+    // Signed zero can be observable inside GLSL, so ordinary === is not enough.
+    for (let i = 0; i < b.length; i++) if (!Object.is(a[i], b[i])) return false;
+    return true;
+  }
+  function use(p) {
+    gl.useProgram(p ? realProgram(p) : null);
+    current = p;
+    if (!p?.entry || p.entry.owner === p) return;
+    const entry = p.entry;
+    const previous = entry.owner;
+    // The last owner records the physical program's complete uniform state,
+    // including partial writes. Deletion/relinking invalidates that owner, so
+    // unknown state still receives a complete replay, including all defaults.
+    for (let i = 0; i < entry.uniforms.length; i++) {
+      const u = entry.uniforms[i];
+      if (equalValues(previous?.values[i], p.values[i])) {
+        uniformReplaySkips++;
+        continue;
+      }
+      if (u.matrix) gl[u.method](u.location, false, p.values[i]);
+      else gl[u.method](u.location, p.values[i]);
+      uniformReplays++;
+    }
+    for (let i = 0; i < p.blockBindings.length; i++) {
+      if (previous && previous.blockBindings[i] === p.blockBindings[i]) {
+        blockReplaySkips++;
+        continue;
+      }
+      gl.uniformBlockBinding(entry.real, i, p.blockBindings[i]);
+      blockReplays++;
+    }
+    entry.owner = p;
+  }
+  function uniformCall(method, args) {
+    if (args[0] == null) return gl[method](...args);
+    const location = locations.get(args[0]);
+    if (!location) return gl[method](...args);
+    const { program: p, index, element, real, generation } = location;
+    if (current !== p || generation !== p.generation || p.deleted)
+      throw new Error("Shared uniform belongs to another logical program");
+    const result = gl[method](real, ...args.slice(1));
+    const u = p.entry.uniforms[index];
+    const vector = method.endsWith("v"),
+      matrix = method.startsWith("uniformMatrix");
+    if (matrix && args[1] !== false) return result;
+    let values;
+    if (vector) {
+      const at = matrix ? 2 : 1,
+        data = args[at];
+      const offset = args[at + 1] ?? 0,
+        length = args[at + 2] || data.length - offset;
+      values = Array.prototype.slice.call(data, offset, offset + length);
+    } else values = args.slice(1);
+    const offset = element * u.width;
+    if (
+      values.length % u.width === 0 &&
+      offset + values.length <= p.values[index].length
+    )
+      p.values[index].set(values, offset);
+    return result;
+  }
+  const api = {
+    createShader(type) {
+      const virtual = Object.create(WebGLShader.prototype);
+      const s = {
+        type,
+        source: "",
+        entry: null,
+        attached: new Set(),
+        deleted: false,
+      };
+      shaders.set(virtual, s);
+      liveShaders.add(s);
+      return virtual;
+    },
+    shaderSource(shader, source) {
+      shaders.get(shader).source = String(source);
+    },
+    compileShader(shader) {
+      compile(shaders.get(shader));
+    },
+    deleteShader(shader) {
+      if (!shader) return;
+      const s = shaders.get(shader);
+      if (!s) return gl.deleteShader(shader);
+      s.deleted = true;
+      releaseShader(s);
+    },
+    getShaderSource(shader) {
+      return shaders.get(shader)?.source ?? gl.getShaderSource(shader);
+    },
+    getShaderParameter(shader, parameter) {
+      const s = shaders.get(shader);
+      if (!s) return gl.getShaderParameter(shader, parameter);
+      if (parameter === gl.DELETE_STATUS) return s.deleted;
+      if (parameter === gl.SHADER_TYPE) return s.type;
+      return gl.getShaderParameter(compile(s).real, parameter);
+    },
+    getShaderInfoLog(shader) {
+      return gl.getShaderInfoLog(compile(shaders.get(shader)).real);
+    },
+    isShader(shader) {
+      const s = shaders.get(shader);
+      return s ? !s.deleted : gl.isShader(shader);
+    },
+    createProgram() {
+      const virtual = Object.create(WebGLProgram.prototype);
+      const p = {
+        virtual,
+        entry: null,
+        unlinked: null,
+        attached: new Set(),
+        bindings: new Map(),
+        feedback: null,
+        values: [],
+        blockBindings: [],
+        locations: new Map(),
+        generation: 0,
+        deleted: false,
+      };
+      programs.set(virtual, p);
+      livePrograms.add(p);
+      return virtual;
+    },
+    attachShader(program, shader) {
+      const p = programs.get(program),
+        s = shaders.get(shader);
+      p.attached.add(shader);
+      s.attached.add(p);
+    },
+    detachShader(program, shader) {
+      const p = programs.get(program),
+        s = shaders.get(shader);
+      p.attached.delete(shader);
+      s.attached.delete(p);
+      releaseShader(s);
+    },
+    getAttachedShaders(program) {
+      return [...programs.get(program).attached];
+    },
+    bindAttribLocation(program, index, name) {
+      programs.get(program).bindings.set(name, index);
+    },
+    transformFeedbackVaryings(program, varyings, mode) {
+      programs.get(program).feedback = [[...varyings], mode];
+    },
+    linkProgram(program) {
+      link(programs.get(program));
+    },
+    useProgram(program) {
+      use(program == null ? null : programs.get(program));
+    },
+    deleteProgram(program) {
+      if (!program) return;
+      const p = programs.get(program);
+      if (!p) return gl.deleteProgram(program);
+      if (p.deleted) return;
+      p.deleted = true;
+      if (current === p) {
+        gl.useProgram(null);
+        current = null;
+      }
+      for (const shader of p.attached) {
+        const s = shaders.get(shader);
+        s.attached.delete(p);
+        releaseShader(s);
+      }
+      p.attached.clear();
+      releaseProgramEntry(p);
+      if (p.unlinked) gl.deleteProgram(p.unlinked);
+      p.locations.clear();
+      p.values = [];
+      livePrograms.delete(p);
+    },
+    isProgram(program) {
+      const p = programs.get(program);
+      return p ? !p.deleted : gl.isProgram(program);
+    },
+    getProgramParameter(program, parameter) {
+      const p = programs.get(program);
+      if (!p) return gl.getProgramParameter(program, parameter);
+      if (parameter === gl.DELETE_STATUS) return p.deleted;
+      if (parameter === gl.ATTACHED_SHADERS) return p.attached.size;
+      return gl.getProgramParameter(realProgram(p), parameter);
+    },
+    getUniformLocation(program, name) {
+      const p = programs.get(program),
+        entry = p.entry;
+      if (p.locations.has(name)) return p.locations.get(name);
+      const real = gl.getUniformLocation(realProgram(p), name);
+      if (real === null) return null;
+      const slot = entry.names.get(name);
+      if (!slot) throw new Error(`Unknown shared uniform: ${name}`);
+      const virtual = Object.create(WebGLUniformLocation.prototype);
+      locations.set(virtual, {
+        program: p,
+        real,
+        ...slot,
+        generation: p.generation,
+      });
+      p.locations.set(name, virtual);
+      return virtual;
+    },
+    getUniform(program, uniform) {
+      const location = locations.get(uniform);
+      if (!location)
+        return gl.getUniform(realProgram(programs.get(program)), uniform);
+      const p = programs.get(program);
+      if (location.program !== p || location.generation !== p.generation)
+        throw new Error("Invalid shared uniform query");
+      const u = p.entry.uniforms[location.index];
+      const value = p.values[location.index].slice(
+        location.element * u.width,
+        (location.element + 1) * u.width,
+      );
+      return u.width === 1 ? value[0] : value;
+    },
+    uniformBlockBinding(program, index, binding) {
+      const p = programs.get(program);
+      p.blockBindings[index] = binding;
+      // This is a program operation, so it can be called while another alias is
+      // active. Do not overwrite that alias's live block bindings.
+      if (p.entry.owner === p)
+        gl.uniformBlockBinding(p.entry.real, index, binding);
+    },
+    getActiveUniformBlockParameter(program, index, parameter) {
+      const p = programs.get(program);
+      if (parameter === gl.UNIFORM_BLOCK_BINDING) return p.blockBindings[index];
+      return gl.getActiveUniformBlockParameter(
+        realProgram(p),
+        index,
+        parameter,
+      );
+    },
+    getParameter(parameter) {
+      if (parameter === gl.CURRENT_PROGRAM) return current?.virtual ?? null;
+      return gl.getParameter(parameter);
+    },
+  };
+  const programFirst = new Set([
+    "getProgramInfoLog",
+    "validateProgram",
+    "getActiveAttrib",
+    "getAttribLocation",
+    "getActiveUniform",
+    "getUniformIndices",
+    "getActiveUniforms",
+    "getUniformBlockIndex",
+    "getActiveUniformBlockName",
+    "getTransformFeedbackVarying",
+    "getFragDataLocation",
+  ]);
+  const context = new Proxy(gl, {
+    get(target, property) {
+      if (Object.hasOwn(api, property)) return api[property];
+      if (bound.has(property)) return bound.get(property);
+      const value = Reflect.get(target, property, target);
+      if (typeof value !== "function") return value;
+      if (!bound.has(property)) {
+        if (
+          /^uniform(?:[1-4](?:f|i|ui)v?|Matrix[2-4](?:x[2-4])?fv)$/.test(
+            String(property),
+          )
+        )
+          bound.set(property, (...args) => uniformCall(property, args));
+        else if (programFirst.has(property))
+          bound.set(property, (program, ...args) =>
+            value.call(
+              target,
+              programs.has(program)
+                ? realProgram(programs.get(program))
+                : program,
+              ...args,
+            ),
+          );
+        else bound.set(property, value.bind(target));
+      }
+      return bound.get(property);
+    },
+  });
+  return {
+    context,
+    stats: () => ({
+      logicalPrograms: livePrograms.size,
+      logicalShaders: liveShaders.size,
+      programs: programCache.size,
+      shaders: shaderCache.size,
+      programLinks,
+      shaderCompiles,
+      uniformReplays,
+      uniformReplaySkips,
+      blockReplays,
+      blockReplaySkips,
+    }),
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const p of [...livePrograms]) api.deleteProgram(p.virtual);
+      for (const s of [...liveShaders]) {
+        s.deleted = true;
+        releaseShader(s);
+      }
+      bound.clear();
+    },
+  };
+}