wuepgg3-track 6.0.2 → 6.0.3

package/dist/BufferResource-DV5KNkLU.mjs

@@ -0,0 +1,534 @@
+import { w as U, g, h as c, u as S, i as _, j as m, k as I, l as p } from "./index-CSHNJu6N.mjs";
+const x = {
+  name: "local-uniform-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+
+            struct LocalUniforms {
+                uTransformMatrix:mat3x3<f32>,
+                uColor:vec4<f32>,
+                uRound:f32,
+            }
+
+            @group(1) @binding(0) var<uniform> localUniforms : LocalUniforms;
+        `
+    ),
+    main: (
+      /* wgsl */
+      `
+            vColor *= localUniforms.uColor;
+            modelMatrix *= localUniforms.uTransformMatrix;
+        `
+    ),
+    end: (
+      /* wgsl */
+      `
+            if(localUniforms.uRound == 1)
+            {
+                vPosition = vec4(roundPixels(vPosition.xy, globalUniforms.uResolution), vPosition.zw);
+            }
+        `
+    )
+  }
+}, C = {
+  ...x,
+  vertex: {
+    ...x.vertex,
+    // replace the group!
+    header: x.vertex.header.replace("group(1)", "group(2)")
+  }
+}, D = {
+  name: "local-uniform-bit",
+  vertex: {
+    header: (
+      /* glsl */
+      `
+
+            uniform mat3 uTransformMatrix;
+            uniform vec4 uColor;
+            uniform float uRound;
+        `
+    ),
+    main: (
+      /* glsl */
+      `
+            vColor *= uColor;
+            modelMatrix = uTransformMatrix;
+        `
+    ),
+    end: (
+      /* glsl */
+      `
+            if(uRound == 1.)
+            {
+                gl_Position.xy = roundPixels(gl_Position.xy, uResolution);
+            }
+        `
+    )
+  }
+}, O = {
+  name: "texture-bit",
+  vertex: {
+    header: (
+      /* wgsl */
+      `
+
+        struct TextureUniforms {
+            uTextureMatrix:mat3x3<f32>,
+        }
+
+        @group(2) @binding(2) var<uniform> textureUniforms : TextureUniforms;
+        `
+    ),
+    main: (
+      /* wgsl */
+      `
+            uv = (textureUniforms.uTextureMatrix * vec3(uv, 1.0)).xy;
+        `
+    )
+  },
+  fragment: {
+    header: (
+      /* wgsl */
+      `
+            @group(2) @binding(0) var uTexture: texture_2d<f32>;
+            @group(2) @binding(1) var uSampler: sampler;
+
+
+        `
+    ),
+    main: (
+      /* wgsl */
+      `
+            outColor = textureSample(uTexture, uSampler, vUV);
+        `
+    )
+  }
+}, R = {
+  name: "texture-bit",
+  vertex: {
+    header: (
+      /* glsl */
+      `
+            uniform mat3 uTextureMatrix;
+        `
+    ),
+    main: (
+      /* glsl */
+      `
+            uv = (uTextureMatrix * vec3(uv, 1.0)).xy;
+        `
+    )
+  },
+  fragment: {
+    header: (
+      /* glsl */
+      `
+        uniform sampler2D uTexture;
+
+
+        `
+    ),
+    main: (
+      /* glsl */
+      `
+            outColor = texture(uTexture, vUV);
+        `
+    )
+  }
+};
+function k(e, t) {
+  for (const a in e.attributes) {
+    const s = e.attributes[a], r = t[a];
+    r ? (s.format ?? (s.format = r.format), s.offset ?? (s.offset = r.offset), s.instance ?? (s.instance = r.instance)) : U(`Attribute ${a} is not present in the shader, but is present in the geometry. Unable to infer attribute details.`);
+  }
+  M(e);
+}
+function M(e) {
+  const { buffers: t, attributes: a } = e, s = {}, r = {};
+  for (const n in t) {
+    const o = t[n];
+    s[o.uid] = 0, r[o.uid] = 0;
+  }
+  for (const n in a) {
+    const o = a[n];
+    s[o.buffer.uid] += g(o.format).stride;
+  }
+  for (const n in a) {
+    const o = a[n];
+    o.stride ?? (o.stride = s[o.buffer.uid]), o.start ?? (o.start = r[o.buffer.uid]), r[o.buffer.uid] += g(o.format).stride;
+  }
+}
+const l = [];
+l[c.NONE] = void 0;
+l[c.DISABLED] = {
+  stencilWriteMask: 0,
+  stencilReadMask: 0
+};
+l[c.RENDERING_MASK_ADD] = {
+  stencilFront: {
+    compare: "equal",
+    passOp: "increment-clamp"
+  },
+  stencilBack: {
+    compare: "equal",
+    passOp: "increment-clamp"
+  }
+};
+l[c.RENDERING_MASK_REMOVE] = {
+  stencilFront: {
+    compare: "equal",
+    passOp: "decrement-clamp"
+  },
+  stencilBack: {
+    compare: "equal",
+    passOp: "decrement-clamp"
+  }
+};
+l[c.MASK_ACTIVE] = {
+  stencilWriteMask: 0,
+  stencilFront: {
+    compare: "equal",
+    passOp: "keep"
+  },
+  stencilBack: {
+    compare: "equal",
+    passOp: "keep"
+  }
+};
+l[c.INVERSE_MASK_ACTIVE] = {
+  stencilWriteMask: 0,
+  stencilFront: {
+    compare: "not-equal",
+    passOp: "keep"
+  },
+  stencilBack: {
+    compare: "not-equal",
+    passOp: "keep"
+  }
+};
+class A {
+  constructor(t) {
+    this._syncFunctionHash = /* @__PURE__ */ Object.create(null), this._adaptor = t, this._systemCheck();
+  }
+  /**
+   * Overridable function by `pixi.js/unsafe-eval` to silence
+   * throwing an error if platform doesn't support unsafe-evals.
+   * @private
+   */
+  _systemCheck() {
+    if (!S())
+      throw new Error("Current environment does not allow unsafe-eval, please use pixi.js/unsafe-eval module to enable support.");
+  }
+  ensureUniformGroup(t) {
+    const a = this.getUniformGroupData(t);
+    t.buffer || (t.buffer = new _({
+      data: new Float32Array(a.layout.size / 4),
+      usage: m.UNIFORM | m.COPY_DST
+    }));
+  }
+  getUniformGroupData(t) {
+    return this._syncFunctionHash[t._signature] || this._initUniformGroup(t);
+  }
+  _initUniformGroup(t) {
+    const a = t._signature;
+    let s = this._syncFunctionHash[a];
+    if (!s) {
+      const r = Object.keys(t.uniformStructures).map((d) => t.uniformStructures[d]), n = this._adaptor.createUboElements(r), o = this._generateUboSync(n.uboElements);
+      s = this._syncFunctionHash[a] = {
+        layout: n,
+        syncFunction: o
+      };
+    }
+    return this._syncFunctionHash[a];
+  }
+  _generateUboSync(t) {
+    return this._adaptor.generateUboSync(t);
+  }
+  syncUniformGroup(t, a, s) {
+    const r = this.getUniformGroupData(t);
+    t.buffer || (t.buffer = new _({
+      data: new Float32Array(r.layout.size / 4),
+      usage: m.UNIFORM | m.COPY_DST
+    }));
+    let n = null;
+    return a || (a = t.buffer.data, n = t.buffer.dataInt32), s || (s = 0), r.syncFunction(t.uniforms, a, n, s), !0;
+  }
+  updateUniformGroup(t) {
+    if (t.isStatic && !t._dirtyId) return !1;
+    t._dirtyId = 0;
+    const a = this.syncUniformGroup(t);
+    return t.buffer.update(), a;
+  }
+  destroy() {
+    this._syncFunctionHash = null;
+  }
+}
+const h = [
+  // uploading pixi matrix object to mat3
+  {
+    type: "mat3x3<f32>",
+    test: (e) => e.value.a !== void 0,
+    ubo: `
+            var matrix = uv[name].toArray(true);
+            data[offset] = matrix[0];
+            data[offset + 1] = matrix[1];
+            data[offset + 2] = matrix[2];
+            data[offset + 4] = matrix[3];
+            data[offset + 5] = matrix[4];
+            data[offset + 6] = matrix[5];
+            data[offset + 8] = matrix[6];
+            data[offset + 9] = matrix[7];
+            data[offset + 10] = matrix[8];
+        `,
+    uniform: `
+            gl.uniformMatrix3fv(ud[name].location, false, uv[name].toArray(true));
+        `
+  },
+  // uploading a pixi rectangle as a vec4
+  {
+    type: "vec4<f32>",
+    test: (e) => e.type === "vec4<f32>" && e.size === 1 && e.value.width !== void 0,
+    ubo: `
+            v = uv[name];
+            data[offset] = v.x;
+            data[offset + 1] = v.y;
+            data[offset + 2] = v.width;
+            data[offset + 3] = v.height;
+        `,
+    uniform: `
+            cv = ud[name].value;
+            v = uv[name];
+            if (cv[0] !== v.x || cv[1] !== v.y || cv[2] !== v.width || cv[3] !== v.height) {
+                cv[0] = v.x;
+                cv[1] = v.y;
+                cv[2] = v.width;
+                cv[3] = v.height;
+                gl.uniform4f(ud[name].location, v.x, v.y, v.width, v.height);
+            }
+        `
+  },
+  // uploading a pixi point as a vec2
+  {
+    type: "vec2<f32>",
+    test: (e) => e.type === "vec2<f32>" && e.size === 1 && e.value.x !== void 0,
+    ubo: `
+            v = uv[name];
+            data[offset] = v.x;
+            data[offset + 1] = v.y;
+        `,
+    uniform: `
+            cv = ud[name].value;
+            v = uv[name];
+            if (cv[0] !== v.x || cv[1] !== v.y) {
+                cv[0] = v.x;
+                cv[1] = v.y;
+                gl.uniform2f(ud[name].location, v.x, v.y);
+            }
+        `
+  },
+  // uploading a pixi color as a vec4
+  {
+    type: "vec4<f32>",
+    test: (e) => e.type === "vec4<f32>" && e.size === 1 && e.value.red !== void 0,
+    ubo: `
+            v = uv[name];
+            data[offset] = v.red;
+            data[offset + 1] = v.green;
+            data[offset + 2] = v.blue;
+            data[offset + 3] = v.alpha;
+        `,
+    uniform: `
+            cv = ud[name].value;
+            v = uv[name];
+            if (cv[0] !== v.red || cv[1] !== v.green || cv[2] !== v.blue || cv[3] !== v.alpha) {
+                cv[0] = v.red;
+                cv[1] = v.green;
+                cv[2] = v.blue;
+                cv[3] = v.alpha;
+                gl.uniform4f(ud[name].location, v.red, v.green, v.blue, v.alpha);
+            }
+        `
+  },
+  // uploading a pixi color as a vec3
+  {
+    type: "vec3<f32>",
+    test: (e) => e.type === "vec3<f32>" && e.size === 1 && e.value.red !== void 0,
+    ubo: `
+            v = uv[name];
+            data[offset] = v.red;
+            data[offset + 1] = v.green;
+            data[offset + 2] = v.blue;
+        `,
+    uniform: `
+            cv = ud[name].value;
+            v = uv[name];
+            if (cv[0] !== v.red || cv[1] !== v.green || cv[2] !== v.blue) {
+                cv[0] = v.red;
+                cv[1] = v.green;
+                cv[2] = v.blue;
+                gl.uniform3f(ud[name].location, v.red, v.green, v.blue);
+            }
+        `
+  }
+];
+function w(e, t, a, s) {
+  const r = [`
+        var v = null;
+        var v2 = null;
+        var t = 0;
+        var index = 0;
+        var name = null;
+        var arrayOffset = null;
+    `];
+  let n = 0;
+  for (let d = 0; d < e.length; d++) {
+    const f = e[d], b = f.data.name;
+    let y = !1, i = 0;
+    for (let u = 0; u < h.length; u++)
+      if (h[u].test(f.data)) {
+        i = f.offset / 4, r.push(
+          `name = "${b}";`,
+          `offset += ${i - n};`,
+          h[u][t] || h[u].ubo
+        ), y = !0;
+        break;
+      }
+    if (!y)
+      if (f.data.size > 1)
+        i = f.offset / 4, r.push(a(f, i - n));
+      else {
+        const u = s[f.data.type];
+        i = f.offset / 4, r.push(
+          /* wgsl */
+          `
+                    v = uv.${b};
+                    offset += ${i - n};
+                    ${u};
+                `
+        );
+      }
+    n = i;
+  }
+  const o = r.join(`
+`);
+  return new Function(
+    "uv",
+    "data",
+    "dataInt32",
+    "offset",
+    o
+  );
+}
+function v(e, t) {
+  return `
+        for (let i = 0; i < ${e * t}; i++) {
+            data[offset + (((i / ${e})|0) * 4) + (i % ${e})] = v[i];
+        }
+    `;
+}
+const F = {
+  f32: `
+        data[offset] = v;`,
+  i32: `
+        dataInt32[offset] = v;`,
+  "vec2<f32>": `
+        data[offset] = v[0];
+        data[offset + 1] = v[1];`,
+  "vec3<f32>": `
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];`,
+  "vec4<f32>": `
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 3] = v[3];`,
+  "vec2<i32>": `
+        dataInt32[offset] = v[0];
+        dataInt32[offset + 1] = v[1];`,
+  "vec3<i32>": `
+        dataInt32[offset] = v[0];
+        dataInt32[offset + 1] = v[1];
+        dataInt32[offset + 2] = v[2];`,
+  "vec4<i32>": `
+        dataInt32[offset] = v[0];
+        dataInt32[offset + 1] = v[1];
+        dataInt32[offset + 2] = v[2];
+        dataInt32[offset + 3] = v[3];`,
+  "mat2x2<f32>": `
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 4] = v[2];
+        data[offset + 5] = v[3];`,
+  "mat3x3<f32>": `
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 4] = v[3];
+        data[offset + 5] = v[4];
+        data[offset + 6] = v[5];
+        data[offset + 8] = v[6];
+        data[offset + 9] = v[7];
+        data[offset + 10] = v[8];`,
+  "mat4x4<f32>": `
+        for (let i = 0; i < 16; i++) {
+            data[offset + i] = v[i];
+        }`,
+  "mat3x2<f32>": v(3, 2),
+  "mat4x2<f32>": v(4, 2),
+  "mat2x3<f32>": v(2, 3),
+  "mat4x3<f32>": v(4, 3),
+  "mat2x4<f32>": v(2, 4),
+  "mat3x4<f32>": v(3, 4)
+}, B = {
+  ...F,
+  "mat2x2<f32>": `
+        data[offset] = v[0];
+        data[offset + 1] = v[1];
+        data[offset + 2] = v[2];
+        data[offset + 3] = v[3];
+    `
+};
+class P extends I {
+  /**
+   * Create a new Buffer Resource.
+   * @param options - The options for the buffer resource
+   * @param options.buffer - The underlying buffer that this resource is using
+   * @param options.offset - The offset of the buffer this resource is using.
+   * If not provided, then it will use the offset of the buffer.
+   * @param options.size - The size of the buffer this resource is using.
+   * If not provided, then it will use the size of the buffer.
+   */
+  constructor({ buffer: t, offset: a, size: s }) {
+    super(), this.uid = p("buffer"), this._resourceType = "bufferResource", this._touched = 0, this._resourceId = p("resource"), this._bufferResource = !0, this.destroyed = !1, this.buffer = t, this.offset = a | 0, this.size = s, this.buffer.on("change", this.onBufferChange, this);
+  }
+  onBufferChange() {
+    this._resourceId = p("resource"), this.emit("change", this);
+  }
+  /**
+   * Destroys this resource. Make sure the underlying buffer is not used anywhere else
+   * if you want to destroy it as well, or code will explode
+   * @param destroyBuffer - Should the underlying buffer be destroyed as well?
+   */
+  destroy(t = !1) {
+    this.destroyed = !0, t && this.buffer.destroy(), this.emit("change", this), this.buffer = null, this.removeAllListeners();
+  }
+}
+export {
+  P as B,
+  l as G,
+  A as U,
+  x as a,
+  F as b,
+  w as c,
+  h as d,
+  k as e,
+  D as f,
+  R as g,
+  C as l,
+  O as t,
+  B as u
+};