reze-engine 0.64.0 → 0.66.0

package/src/unity/looks.ts

@@ -15,7 +15,7 @@
 // and the transparent queue in the engine's transparent phase. Shadows are the
 // engine's: a native material still casts through its pass.
 
-import { NativeHost, type NativeShader, type NativeStream, type NativeValue, type ValueSource } from "./host"
+import { NativeHost, sameValue, type NativeShader, type NativeStream, type NativeValue, type ValueSource } from "./host"
 import type { PassState } from "./state"
 import { UNITY_SKIN_WGSL, tangentsFor } from "./skin"
 import { characterBlock, type CharacterRig } from "./character"
@@ -28,6 +28,19 @@ export type NativeTexture = {
   data: Uint8Array
   /** Colour (sRGB) or data (linear) — how the shader expects to read it. */
   srgb: boolean
+  /** Unity's wrap mode as the game imported it (Repeat, Clamp, Mirror,
+   *  MirrorOnce); repeating when absent. A clamped mask sampled past its edge
+   *  reads its border, not the far side. */
+  wrap?: string
+  /** Unity's filter mode (Point, Bilinear, Trilinear); bilinear when absent. */
+  filter?: string
+}
+
+const WRAP: Record<string, GPUAddressMode> = {
+  Repeat: "repeat",
+  Clamp: "clamp-to-edge",
+  Mirror: "mirror-repeat",
+  MirrorOnce: "mirror-repeat",
 }
 
 export type NativeMaterialSpec = {
@@ -48,6 +61,12 @@ export type NativeLook = {
   textures: Record<string, NativeTexture>
   materials: NativeMaterialSpec[]
   rig?: CharacterRig
+  /** The game vertex streams the model's PMX carries, by semantic: the
+   *  additional UV channel (1–4) that holds each, four floats a vertex, keyed
+   *  over time by that channel's UV morphs (PMX types 4–7) — a particle's
+   *  colour over its life on a mesh's own vertex colours. A stream named here
+   *  reads that channel; any other reads as Unity binds a missing one. */
+  streams?: Record<string, number>
 }
 
 /** What the engine lends for one model. */
@@ -72,12 +91,30 @@ export type NativeModel = {
   headRest: [number, number, number]
   /** Its rendering-layer bits, for a look without a rig. */
   layers: number
+  /** A PMX additional UV channel (1–4), four floats a vertex, or null. */
+  additionalUv: (channel: number) => Float32Array | null
+  /** Its morphs, in the order of morphWeights. */
+  morphs: readonly { type: number; uvOffsets?: { vertexIndex: number; offset: [number, number, number, number] }[] }[]
+  /** The current effective (group-resolved, clamped) morph weights. */
+  morphWeights: () => Float32Array
+}
+
+/** A vertex stream out of an additional UV channel: its rest values, the
+ *  channel's morphs, and the weights it was last built at. */
+type CarriedStream = {
+  buffer: GPUBuffer
+  base: Float32Array
+  data: Float32Array
+  morphs: { index: number; offsets: { vertexIndex: number; offset: [number, number, number, number] }[] }[]
+  weights: Float32Array
 }
 
 type Install = {
   model: NativeModel
   look: NativeLook
   views: Map<string, GPUTextureView>
+  /** Per look texture: its sampler, as the game imported the texture. */
+  samplers: Map<string, GPUSampler>
   textures: GPUTexture[]
   pos: GPUBuffer
   nrm: GPUBuffer
@@ -85,9 +122,12 @@ type Install = {
   restTan: GPUBuffer
   params: GPUBuffer
   skinBind: GPUBindGroup
-  /** Per draw of the model: the spec that dresses it, if any. */
-  dressed: { draw: NativeModel["draws"][number]; spec: NativeMaterialSpec }[]
+  /** Per draw of the model: the spec that dresses it, and the values set on
+   *  that material since (setUniforms), over the spec's. */
+  dressed: { draw: NativeModel["draws"][number]; spec: NativeMaterialSpec; values: Record<string, NativeValue> }[]
   block: Record<string, NativeValue>
+  /** The look's streams (NativeLook.streams), by semantic. */
+  carried: Map<string, CarriedStream>
 }
 
 const OPAQUE_MODES = ["ALWAYS", "FORWARDBASE"]
@@ -97,6 +137,8 @@ const OVERRIDE_MODES = ["OVERRIDE1", "OVERRIDE2", "OVERRIDE3"]
 export class NativeLooks {
   readonly host: NativeHost
   private installs = new Map<string, Install>()
+  /** Per model: its passes' pipelines compiling (see install). */
+  private warming = new Map<string, Promise<void>>()
   private skinPipeline: GPUComputePipeline
   private zero: GPUBuffer
   private white: GPUBuffer
@@ -139,10 +181,38 @@ export class NativeLooks {
     return this.installs.size
   }
 
+  private samplerCache = new Map<string, GPUSampler>()
+
+  /** A texture's sampler: its wrap and filter, shared by every texture alike. */
+  private sampler(t: NativeTexture): GPUSampler {
+    const wrap = WRAP[t.wrap ?? "Repeat"] ?? "repeat"
+    const filter: GPUFilterMode = t.filter === "Point" ? "nearest" : "linear"
+    const key = `${wrap}|${filter}`
+    let s = this.samplerCache.get(key)
+    if (!s) {
+      s = this.device.createSampler({
+        label: `native look sampler ${key}`,
+        addressModeU: wrap,
+        addressModeV: wrap,
+        magFilter: filter,
+        minFilter: filter,
+        mipmapFilter: filter,
+      })
+      this.samplerCache.set(key, s)
+    }
+    return s
+  }
+
   has(model: string): boolean {
     return this.installs.has(model)
   }
 
+  /** Resolves once every pass of the model's look has its pipeline — until
+   *  then those draws sit out (NativeHost never compiles at a draw). */
+  ready(model: string): Promise<void> {
+    return this.warming.get(model) ?? Promise.resolve()
+  }
+
   /** Is this model's material drawn by its native look? */
   dresses(model: string, material: string): boolean {
     const i = this.installs.get(model)
@@ -154,8 +224,10 @@ export class NativeLooks {
     const d = this.device
     for (const s of look.shaders) this.host.register(s)
     const views = new Map<string, GPUTextureView>()
+    const samplers = new Map<string, GPUSampler>()
     const textures: GPUTexture[] = []
     for (const [key, t] of Object.entries(look.textures)) {
+      if (t.wrap || t.filter) samplers.set(key, this.sampler(t))
       const tex = d.createTexture({
         label: `${model.name}: ${key}`,
         size: [t.width, t.height],
@@ -203,12 +275,27 @@ export class NativeLooks {
     const dressed: Install["dressed"] = []
     for (const draw of model.draws) {
       const spec = look.materials.find((m) => m.materials.includes(draw.materialName))
-      if (spec) dressed.push({ draw, spec })
+      if (spec) dressed.push({ draw, spec, values: {} })
     }
-    this.installs.set(model.name, {
+    const carried = new Map<string, CarriedStream>()
+    for (const [semantic, channel] of Object.entries(look.streams ?? {})) {
+      const base = model.additionalUv(channel)
+      if (!base || base.length < n * 4) continue
+      const morphs = model.morphs
+        .map((m, index) => ({ index, type: m.type, offsets: m.uvOffsets ?? [] }))
+        .filter((m) => m.type === 3 + channel && m.offsets.length)
+        .map(({ index, offsets }) => ({ index, offsets }))
+      const buffer = buf(`stream ${semantic}`, n * 4, GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST)
+      const data = new Float32Array(base.subarray(0, n * 4))
+      d.queue.writeBuffer(buffer, 0, data)
+      // NaN: the first prepare builds the stream whatever the weights are
+      carried.set(semantic, { buffer, base: data.slice(), data, morphs, weights: new Float32Array(morphs.length).fill(NaN) })
+    }
+    const install: Install = {
       model,
       look,
       views,
+      samplers,
       textures,
       pos,
       nrm,
@@ -218,7 +305,19 @@ export class NativeLooks {
       skinBind,
       dressed,
       block: {},
-    })
+      carried,
+    }
+    this.installs.set(model.name, install)
+    // Every pass this look will draw, compiled now and side by side — the
+    // shader, its state and the streams are all known here.
+    const drawn = [...OPAQUE_MODES, ...CHARACTER_MODES, ...OVERRIDE_MODES]
+    const jobs: Promise<void>[] = []
+    for (const d of dressed)
+      for (const p of d.spec.passes) if (drawn.includes(p.lightMode)) jobs.push(this.host.warm(p.shader, p.state, this.streams(install, p.shader)))
+    this.warming.set(
+      model.name,
+      Promise.all(jobs).then(() => {}),
+    )
   }
 
   remove(name: string): void {
@@ -226,7 +325,7 @@ export class NativeLooks {
     if (!i) return
     this.installs.delete(name)
     this.host.release(`${name}|`)
-    const bufs = [i.pos, i.nrm, i.tan, i.restTan, i.params]
+    const bufs = [i.pos, i.nrm, i.tan, i.restTan, i.params, ...[...i.carried.values()].map((c) => c.buffer)]
     const texs = i.textures
     // Freed once the GPU is done with the frames that may still name them.
     void this.device.queue.onSubmittedWorkDone().then(() => {
@@ -259,12 +358,81 @@ export class NativeLooks {
         : {
             unity_RenderingLayer: new Uint32Array([i.model.layers >>> 0, 0, 0, 0]),
           }
+      if (i.carried.size) this.keyStreams(i)
     }
     pass.end()
   }
 
+  /** Each carried stream at the model's current morph weights: its rest values
+   *  plus every one of its channel's morphs at its weight, rebuilt and uploaded
+   *  only when one of those weights moved. */
+  private keyStreams(i: Install): void {
+    const weights = i.model.morphWeights()
+    for (const c of i.carried.values()) {
+      if (!c.morphs.length) continue
+      let moved = false
+      for (let k = 0; k < c.morphs.length; k++) {
+        const w = weights[c.morphs[k].index] ?? 0
+        if (w !== c.weights[k]) {
+          c.weights[k] = w
+          moved = true
+        }
+      }
+      if (!moved) continue
+      c.data.set(c.base)
+      for (let k = 0; k < c.morphs.length; k++) {
+        const w = c.weights[k]
+        if (!w) continue
+        for (const o of c.morphs[k].offsets) {
+          const at = o.vertexIndex * 4
+          if (at + 3 >= c.data.length) continue
+          c.data[at] += o.offset[0] * w
+          c.data[at + 1] += o.offset[1] * w
+          c.data[at + 2] += o.offset[2] * w
+          c.data[at + 3] += o.offset[3] * w
+        }
+      }
+      this.device.queue.writeBuffer(c.buffer, 0, c.data as Float32Array<ArrayBuffer>)
+    }
+  }
+
+  /**
+   * Set some of one dressed material's values (its Unity material properties,
+   * as the look's `values` hold them) — what a game animates on a material
+   * over a take. Each value stands until set again; the look's own stand
+   * under it. Only names the material's spec carries are taken: they are the
+   * ones its draws' uniform blocks read per draw. A value equal to the one
+   * already set keeps that one's object, so the host, which refills a
+   * uniform member only when its value object changes, writes nothing for
+   * it. Returns whether the model wears a look that dresses this material.
+   */
+  setUniforms(model: string, material: string, values: Record<string, NativeValue>): boolean {
+    const i = this.installs.get(model)
+    if (!i) return false
+    let found = false
+    for (const d of i.dressed) {
+      if (d.draw.materialName !== material) continue
+      found = true
+      for (const name in values) {
+        const v = values[name]
+        if (v === undefined || v === null || !(name in d.spec.values)) continue
+        const was = d.values[name]
+        if (was === undefined || !sameValue(was, v)) d.values[name] = v
+      }
+    }
+    return found
+  }
+
   private streams(i: Install, shader: string): NativeStream[] {
     return this.host.inputs(shader).map(({ semantic }) => {
+      const carried = i.carried.get(semantic)
+      if (carried)
+        return {
+          buffer: carried.buffer,
+          offset: 0,
+          stride: 16,
+          format: "float32x4" as const,
+        }
       if (semantic === "POSITION")
         return {
           buffer: i.pos,
@@ -329,7 +497,11 @@ export class NativeLooks {
     const textures: Record<string, GPUTextureView | undefined> = {
       ...this.frameTextures,
     }
-    for (const [slot, key] of Object.entries(d.spec.textures)) textures[slot] = key === "@diffuse" ? d.draw.diffuse : i.views.get(key)
+    const samplers: Record<string, GPUSampler | undefined> = {}
+    for (const [slot, key] of Object.entries(d.spec.textures)) {
+      textures[slot] = key === "@diffuse" ? d.draw.diffuse : i.views.get(key)
+      samplers[slot] = i.samplers.get(key)
+    }
     this.host.draw(pass, {
       shader: p.shader,
       state: p.state,
@@ -340,8 +512,9 @@ export class NativeLooks {
         offset: d.draw.firstIndex * 4,
         count: d.draw.count,
       },
-      sources: [perDraw, i.block, d.spec.values, this.globals],
+      sources: [perDraw, i.block, d.values, d.spec.values, this.globals],
       textures,
+      samplers,
       key: `${i.model.name}|${d.draw.materialName}|${p.lightMode}|${p.shader}`,
       pass: "main",
     })

package/src/unity/skin.ts

@@ -78,10 +78,13 @@ export function tangentsFor(verts: Float32Array, indices: Uint32Array | Uint16Ar
     const p = (v: number, k: number) => verts[v * 8 + k]
     const e1 = [p(b, 0) - p(a, 0), p(b, 1) - p(a, 1), p(b, 2) - p(a, 2)]
     const e2 = [p(c, 0) - p(a, 0), p(c, 1) - p(a, 1), p(c, 2) - p(a, 2)]
+    // v measured upward, as Unity builds tangent space: a PMX uv runs v down,
+    // and taken as it is the bitangent — the handedness in w — comes out
+    // reversed, which a game normal map reads as its green channel inverted.
     const du1 = p(b, 6) - p(a, 6),
-      dv1 = p(b, 7) - p(a, 7)
+      dv1 = p(a, 7) - p(b, 7)
     const du2 = p(c, 6) - p(a, 6),
-      dv2 = p(c, 7) - p(a, 7)
+      dv2 = p(a, 7) - p(c, 7)
     const det = du1 * dv2 - du2 * dv1
     if (Math.abs(det) < 1e-12) continue
     const r = 1 / det

package/src/unity/stage.ts

@@ -21,6 +21,7 @@
 import { NativeHost, type NativeShader, type NativeStream, type NativeValue, type ValueSource } from "./host"
 import type { PassState } from "./state"
 import { gameToEngine, invert4, mul4, scale4, flipY } from "./globals"
+import { SHADOW_CASCADES } from "../shadow-cascades"
 
 export type NativeStageMesh = {
   id: string
@@ -78,6 +79,12 @@ export type NativeStageLights = {
     direction: [number, number, number]
     color: [number, number, number]
     shadow: number
+    /** As the game's pipeline packed it, recorded: _MainLightColor and
+     *  SimMainLightColor (linear, intensity in w), SimMainLightColorNoInt. */
+    unity?: { color: number[]; simColor: number[]; simColorNoInt: number[] }
+    /** The Light's shadowBias and shadowNormalBias, in shadow-map texels. */
+    shadowBias?: number
+    shadowNormalBias?: number
   }
   additional: {
     position: [number, number, number]
@@ -147,6 +154,15 @@ export class NativeStage {
     min: [number, number, number]
     max: [number, number, number]
   }
+  /**
+   * How far the stage reaches from the origin, in engine units: every
+   * renderer's box, casters or not. A game's sky is a dome in the stage
+   * (X317's reaches 1900 units out), and the camera's far plane has to reach it.
+   */
+  get extent(): number {
+    return this.reach
+  }
+  private reach = 0
   private buffers: GPUBuffer[] = []
   private textures: GPUTexture[] = []
   private opaque: Item[] = []
@@ -242,6 +258,10 @@ export class NativeStage {
       }),
     )
 
+    // Loaded means drawable: every pass's pipeline is compiled before this
+    // resolves, rather than one at a time in the frames after it.
+    const warming = st.warm(hosts, meshes)
+
     const textures = new Map<string, Tex>()
     await Promise.all(
       pkg.textures.map(async (t) => {
@@ -255,6 +275,7 @@ export class NativeStage {
     )
 
     st.build(meshes, textures, tools.fallback)
+    await warming
     return st
   }
 
@@ -384,6 +405,7 @@ export class NativeStage {
         ey = b.size[1] / 2,
         ez = b.size[2] / 2
       const half = [0, 1, 2].map((i) => (Math.abs(m[i]) * ex + Math.abs(m[4 + i]) * ey + Math.abs(m[8 + i]) * ez) * s)
+      this.reach = Math.max(this.reach, Math.hypot(center[0], center[1], center[2]) + Math.hypot(half[0], half[1], half[2]))
       const world = Float32Array.from(m)
       const det = m[0] * (m[5] * m[10] - m[9] * m[6]) - m[4] * (m[1] * m[10] - m[9] * m[2]) + m[8] * (m[1] * m[6] - m[5] * m[2])
       const perDraw: ValueSource = {
@@ -429,8 +451,10 @@ export class NativeStage {
         const samplers: Record<string, GPUSampler | undefined> = {
           ...globalSamplers,
         }
-        // an empty slot reads what the shader declared it defaults to
-        for (const [slot, def] of Object.entries(mat.defaults ?? {})) views[slot] = fallback[def] ?? fallback.white
+        // an empty slot reads what the shader declared it defaults to. A default
+        // with no name ("") is no picture at all — a cube's, usually — and is
+        // left to the host, which stands in by the binding's own kind.
+        for (const [slot, def] of Object.entries(mat.defaults ?? {})) if (def && fallback[def]) views[slot] = fallback[def]
         for (const [slot, id] of [...Object.entries(mat.textures), ...Object.entries(r.textures)]) {
           const t = textures.get(id)
           if (!t) continue
@@ -459,6 +483,35 @@ export class NativeStage {
       })
   }
 
+  /**
+   * Every pass's pipeline, compiled before the stage reports loaded (see
+   * NativeHost.warm) — side by side, and never at the first draw. Needs only
+   * the meshes' stream layouts, so it runs while the pictures decode. The
+   * passes are the ones build() keeps: casters that cast, and the main modes.
+   */
+  private warm(
+    hosts: { scene: NativeHost; shadow: NativeHost },
+    meshes: Map<string, { info: NativeStageMesh; buffer: GPUBuffer }>,
+  ): Promise<void> {
+    const jobs: Promise<void>[] = []
+    const mats = new Map(this.pkg.materials.map((m) => [m.id, m]))
+    for (const r of this.pkg.renderers) {
+      const mesh = meshes.get(r.mesh)
+      if (!mesh) continue
+      r.materials.forEach((mid, sub) => {
+        const mat = mid ? mats.get(mid) : undefined
+        if (!mat || sub >= mesh.info.submeshes.length) return
+        for (const pass of mat.passes) {
+          const caster = pass.lightMode === "SHADOWCASTER"
+          if (caster ? !r.castShadows : !MAIN_MODES.includes(pass.lightMode)) continue
+          const host = caster ? hosts.shadow : hosts.scene
+          jobs.push(host.warm(pass.shader, pass.state, this.streams(host, { mesh, pass } as Item)))
+        }
+      })
+    }
+    return Promise.all(jobs).then(() => {})
+  }
+
   private streams(host: NativeHost, it: Item): NativeStream[] {
     const info = it.mesh.info
     return host.inputs(it.pass.shader).map(({ semantic }) => {
@@ -514,18 +567,24 @@ export class NativeStage {
     engineScale: number,
   ): void {
     const vp = flipY(mul4(viewProj, gameToEngine(engineScale)))
-    // ShadowUtils.GetShadowBias as the game set it: half a texel along the light
-    // and half a texel in along the normal, a texel being this tile's width in
-    // game units over its resolution (2048).
+    // ShadowUtils.GetShadowBias as the game sets it: (texel x the light's
+    // shadowBias, -texel x its shadowNormalBias), a texel being this tile's
+    // width in game units over its resolution. The stage's casters read it as
+    // _ShadowBias (Replica's CascadeShadowPass); the character's DrawShadowPass
+    // names it sim_ShadowBias. A package that predates the recorded biases
+    // takes half a texel of each.
     const rowLen = Math.hypot(vp[0], vp[4], vp[8])
-    const texel = rowLen > 0 ? 2 / rowLen / 2048 : 0
+    const texel = rowLen > 0 ? 2 / rowLen / SHADOW_CASCADES[cascade].mapSize : 0
+    const main = this.pkg.lights.main
+    const bias = [texel * (main.shadowBias ?? 0.5), -texel * (main.shadowNormalBias ?? 0.5), 0, 0]
     const g: Record<string, NativeValue> = {
       ...globals,
       unity_MatrixVP: vp,
       unity_MatrixV: scale4(1),
       unity_MatrixP: vp,
       glstate_matrix_projection: vp,
-      sim_ShadowBias: [0.5 * texel, -0.5 * texel, 0, 0],
+      _ShadowBias: bias,
+      sim_ShadowBias: bias,
     }
     for (const it of this.casters) this.draw(pass, host, it, g, {}, `|c${cascade}`)
   }

package/dist/physics-debug.d.ts

@@ -1,30 +0,0 @@
-import type { RezePhysics } from "./physics";
-export declare class PhysicsDebugRenderer {
-    private device;
-    private bindGroup;
-    private wirePipelineSphere;
-    private wirePipelineBox;
-    private wirePipelineCapsule;
-    private wireSphereBuffer;
-    private wireBoxBuffer;
-    private wireCapsuleBuffer;
-    private wireSphereCount;
-    private wireBoxCount;
-    private wireCapsuleCount;
-    private solidPipelineSphere;
-    private solidPipelineBox;
-    private solidPipelineCapsule;
-    private solidSphereBuffer;
-    private solidBoxBuffer;
-    private solidCapsuleBuffer;
-    private solidSphereCount;
-    private solidBoxCount;
-    private solidCapsuleCount;
-    private instanceBuffer;
-    private instanceData;
-    private instanceCapacity;
-    constructor(device: GPUDevice, cameraUniformBuffer: GPUBuffer, presentationFormat: GPUTextureFormat);
-    render(pass: GPURenderPassEncoder, physics: RezePhysics): void;
-    destroy(): void;
-}
-//# sourceMappingURL=physics-debug.d.ts.map

package/dist/physics-debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"physics-debug.d.ts","sourceRoot":"","sources":["../src/physics-debug.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAmB5C,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,SAAS,CAAc;IAG/B,OAAO,CAAC,kBAAkB,CAAmB;IAC7C,OAAO,CAAC,eAAe,CAAmB;IAC1C,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAW;IACnC,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,gBAAgB,CAAQ;IAIhC,OAAO,CAAC,mBAAmB,CAAmB;IAC9C,OAAO,CAAC,gBAAgB,CAAmB;IAC3C,OAAO,CAAC,oBAAoB,CAAmB;IAC/C,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,kBAAkB,CAAW;IACrC,OAAO,CAAC,gBAAgB,CAAQ;IAChC,OAAO,CAAC,aAAa,CAAQ;IAC7B,OAAO,CAAC,iBAAiB,CAAQ;IAEjC,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,gBAAgB,CAAQ;gBAG9B,MAAM,EAAE,SAAS,EACjB,mBAAmB,EAAE,SAAS,EAC9B,kBAAkB,EAAE,gBAAgB;IA2HtC,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,OAAO,EAAE,WAAW,GAAG,IAAI;IAmI9D,OAAO,IAAI,IAAI;CAShB"}