reze-engine 0.13.5 → 0.14.0

package/src/index.ts

@@ -9,6 +9,9 @@ export {
   type LoadModelFromFilesOptions,
   type MaterialPreset,
   type MaterialPresetMap,
+  type GizmoDragEvent,
+  type GizmoDragCallback,
+  type GizmoDragKind,
 } from "./engine"
 export { parsePmxFolderInput, pmxFileAtRelativePath, type PmxFolderInputResult } from "./folder-upload"
 export { Model } from "./model"

package/src/model.ts

@@ -491,6 +491,41 @@ export class Model {
     return this.skeleton
   }
 
+  // Direct bone local-transform accessors (used by interactive gizmo drag).
+  // Readers return the live runtime state — callers that want a snapshot for
+  // later comparison should `.clone()` the returned Quat / copy the Vec3.
+  getBoneLocalRotation(boneIndex: number): Quat {
+    return this.runtimeSkeleton.localRotations[boneIndex]
+  }
+
+  getBoneLocalTranslation(boneIndex: number): Vec3 {
+    return this.runtimeSkeleton.localTranslations[boneIndex]
+  }
+
+  // Raw absolute-local translation write. NOT equivalent to
+  // `moveBones({ name: v }, 0)` — moveBones treats the input as VMD-relative
+  // (offset from bind pose) and runs convertVMDTranslationToLocal() over it.
+  // Use this when you already have the final local translation (e.g. the
+  // gizmo's computed target). For rotation, just use rotateBones(..., 0).
+  setBoneLocalTranslation(boneIndex: number, v: Vec3): void {
+    const t = this.runtimeSkeleton.localTranslations[boneIndex]
+    t.x = v.x; t.y = v.y; t.z = v.z
+    this.tweenState.transActive[boneIndex] = 0
+  }
+
+  // When true, update() skips applyPoseFromClip, so whatever was last written to
+  // localRotations / localTranslations persists across frames. Used by gizmo drag
+  // and other direct-manipulation flows to prevent the currently-shown clip from
+  // overwriting manual edits each frame. Auto-cleared on play()/seek() so the user
+  // gets back to normal playback without having to manage this flag explicitly.
+  private clipApplySuspended = false
+  setClipApplySuspended(suspended: boolean): void {
+    this.clipApplySuspended = suspended
+  }
+  isClipApplySuspended(): boolean {
+    return this.clipApplySuspended
+  }
+
   // World bone origin (world matrix col3); unknown name → null
   getBoneWorldPosition(boneName: string): Vec3 | null {
     const idx = this.runtimeSkeleton.nameIndex[boneName]
@@ -981,6 +1016,7 @@ export class Model {
   play(name: string): boolean
   play(name: string, options?: AnimationPlayOptions): boolean
   play(name?: string, options?: AnimationPlayOptions): void | boolean {
+    this.clipApplySuspended = false
     if (name === undefined) {
       this.animationState.play()
       return
@@ -1021,6 +1057,7 @@ export class Model {
 
   // Seek by absolute timeline seconds, not frame index.
   seek(seconds: number): void {
+    this.clipApplySuspended = false
     this.animationState.seek(seconds)
   }
 
@@ -1166,7 +1203,7 @@ export class Model {
     this.animationState.update(deltaTime)
     const clip = this.animationState.getCurrentClip()
     const frame = this.animationState.getCurrentFrame()
-    if (clip !== null) {
+    if (clip !== null && !this.clipApplySuspended) {
       this.applyPoseFromClip(clip, frame)
     }
 

package/src/shaders/materials/common.ts

@@ -69,7 +69,7 @@ struct LightVP { viewProj: mat4x4f, };
 `;
 
 // ─── Shadow sampler (3×3 PCF) ───────────────────────────────────────
-// 4096-map, normal-bias 0.08, depth-bias 0.001. Unrolled — Safari's Metal backend
+// 2048-map, normal-bias 0.08, depth-bias 0.001. Unrolled — Safari's Metal backend
 // doesn't unroll nested shadow loops reliably, and the early out on back-facing
 // fragments saves 9 texture taps per skipped pixel.
 
@@ -82,7 +82,7 @@ fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
   let ndc = lclip.xyz / max(lclip.w, 1e-6);
   let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
   let cmpZ = ndc.z - 0.001;
-  let ts = 1.0 / 4096.0;
+  let ts = 1.0 / 2048.0;
   let s00 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(-ts, -ts), cmpZ);
   let s10 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f(0.0, -ts), cmpZ);
   let s20 = textureSampleCompareLevel(shadowMap, shadowSampler, suv + vec2f( ts, -ts), cmpZ);

package/src/shaders/passes/gizmo.ts

@@ -0,0 +1,76 @@
+// Transform gizmo — 3 translation axes + 3 rotation rings, drawn as thick
+// ribbons. Per-segment perpendicular (no miter) → the "tick" look at each ring
+// vertex is intentional.
+//
+// axisT per-vertex: 0 at the bone origin, 1 at the axis tip. For ring verts it
+// is set to -1 as a "not an axis" flag. The FS uses axisT to:
+//   • fade + dash the inside-ring portion of each axis (not hittable, so the
+//     user can tell to only grab the outer stub for translation).
+//   • leave rings and the outer axis stub fully solid with only the edge-to-
+//     center alpha falloff.
+
+export const GIZMO_SHADER_WGSL = /* wgsl */ `
+struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _pad: f32 };
+struct Transform {
+  model: mat4x4f,
+  viewport: vec2f,
+  thicknessPx: f32,
+  _pad: f32,
+};
+struct Color { rgba: vec4f };
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(0) @binding(1) var<uniform> transform: Transform;
+@group(1) @binding(0) var<uniform> col: Color;
+
+struct VSOut {
+  @builtin(position) pos: vec4f,
+  @location(0) side: f32,
+  @location(1) axisT: f32,
+}
+
+@vertex fn vs(
+  @location(0) position: vec3f,
+  @location(1) segDir: vec3f,
+  @location(2) side: f32,
+  @location(3) axisT: f32,
+) -> VSOut {
+  let vp = camera.projection * camera.view * transform.model;
+  let c0 = vp * vec4f(position, 1.0);
+  let c1 = vp * vec4f(position + segDir, 1.0);
+  let w0 = max(abs(c0.w), 1e-6);
+  let w1 = max(abs(c1.w), 1e-6);
+  let s0 = (c0.xy / w0) * 0.5 * transform.viewport;
+  let s1 = (c1.xy / w1) * 0.5 * transform.viewport;
+  let tangent = normalize(s1 - s0);
+  let normalPx = vec2f(-tangent.y, tangent.x);
+  // Axes render thinner than rings. axisT < 0 → ring (full thickness); else → axis (reduced).
+  let thicknessMul = select(0.60, 1.0, axisT < 0.0);
+  let offsetPx = normalPx * side * transform.thicknessPx * 0.5 * thicknessMul;
+  let offsetClip = (offsetPx / (0.5 * transform.viewport)) * c0.w;
+  var out: VSOut;
+  out.pos = vec4f(c0.xy + offsetClip, c0.z, c0.w);
+  out.side = side;
+  out.axisT = axisT;
+  return out;
+}
+
+@fragment fn fs(in: VSOut) -> @location(0) vec4f {
+  // Center-bright, edges fade. abs(side) is 0 at ribbon center, 1 at ribbon edges.
+  let edge = 1.0 - smoothstep(0.55, 1.0, abs(in.side));
+  var alpha = col.rgba.a * edge;
+
+  // Dash + dim the inside-ring portion of axes. axisT is -1 for ring fragments,
+  // 0..1 along axes (0 at bone center, 1 at axis tip). Boundary 0.63 ≈ where the
+  // hit zone starts (ring radius 0.8 + 0.05 margin, over axis length 1.35).
+  let isInsideRingAxis = in.axisT >= 0.0 && in.axisT < 0.63;
+  if (isInsideRingAxis) {
+    // ~8 dash cycles inside the ring — readable without feeling busy.
+    let phase = fract(in.axisT * 12.0);
+    if (phase > 0.55) { discard; }
+    alpha = alpha * 0.40;
+  }
+
+  return vec4f(col.rgba.rgb, alpha);
+}
+`

package/src/shaders/passes/pick.ts

@@ -1,4 +1,7 @@
-// GPU picking pass: encodes (modelIndex, materialIndex) as RG8 into a 1×1 readback target.
+// GPU picking pass: encodes (modelIndex, materialIndex, dominantBoneIndex) as RGB8
+// into a 1×1 readback target. Dominant bone = the joint with the largest skinning
+// weight for the provoking vertex of the triangle (flat-interpolated to fragments).
+// 8-bit bone range (0..255) covers standard MMD skeletons (~100–200 bones).
 
 export const PICK_SHADER_WGSL = /* wgsl */ `
 struct CameraUniforms {
@@ -18,23 +21,44 @@ struct PickId {
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
 @group(2) @binding(0) var<uniform> pickId: PickId;
 
+struct VSOut {
+  @builtin(position) pos: vec4f,
+  @interpolate(flat) @location(0) boneId: u32,
+}
+
 @vertex fn vs(
   @location(0) position: vec3f,
   @location(1) normal: vec3f,
   @location(2) uv: vec2f,
   @location(3) joints0: vec4<u32>,
   @location(4) weights0: vec4<f32>
-) -> @builtin(position) vec4f {
+) -> VSOut {
   let pos4 = vec4f(position, 1.0);
   let weightSum = weights0.x + weights0.y + weights0.z + weights0.w;
   let invWeightSum = select(1.0, 1.0 / weightSum, weightSum > 0.0001);
   let nw = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * invWeightSum, weightSum > 0.0001);
   var sp = vec4f(0.0);
   for (var i = 0u; i < 4u; i++) { sp += (skinMats[joints0[i]] * pos4) * nw[i]; }
-  return camera.projection * camera.view * vec4f(sp.xyz, 1.0);
+
+  // Dominant joint for this vertex — index of max weight component.
+  var maxW: f32 = nw.x;
+  var idx: u32 = joints0.x;
+  if (nw.y > maxW) { maxW = nw.y; idx = joints0.y; }
+  if (nw.z > maxW) { maxW = nw.z; idx = joints0.z; }
+  if (nw.w > maxW) { maxW = nw.w; idx = joints0.w; }
+
+  var out: VSOut;
+  out.pos = camera.projection * camera.view * vec4f(sp.xyz, 1.0);
+  out.boneId = idx;
+  return out;
 }
 
-@fragment fn fs() -> @location(0) vec4f {
-  return vec4f(pickId.modelId / 255.0, pickId.materialId / 255.0, 0.0, 1.0);
+@fragment fn fs(in: VSOut) -> @location(0) vec4f {
+  return vec4f(
+    pickId.modelId / 255.0,
+    pickId.materialId / 255.0,
+    f32(in.boneId) / 255.0,
+    1.0
+  );
 }
 `

package/src/shaders/passes/selection.ts

@@ -0,0 +1,67 @@
+// Selection overlay — two screen-space passes that together draw a uniform
+// pixel-thick outline around the selected material.
+//
+// Pass 1 (mask): render only the selected material's triangles into an r8
+// texture (depth-always). Fragment outputs 1.0. No per-material uniforms;
+// reuses camera + skinMats from the outline/main bind group layouts.
+//
+// Pass 2 (edge): fullscreen pass over the swapchain. For each pixel, sample
+// the mask at center + 8 neighbours in a ring of `thickness` pixels. Emit
+// yellow where center is empty but any neighbour is filled. Result: uniform
+// screen-space thickness, traces the complete material boundary (including
+// through-occluder regions), independent of mesh geometry or camera angle.
+
+export const SELECTION_MASK_SHADER_WGSL = /* wgsl */ `
+struct CameraUniforms { view: mat4x4f, projection: mat4x4f, viewPos: vec3f, _pad: f32 };
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+
+@vertex fn vs(
+  @location(0) position: vec3f,
+  @location(3) joints0: vec4<u32>,
+  @location(4) weights0: vec4<f32>
+) -> @builtin(position) vec4f {
+  let ws = weights0.x + weights0.y + weights0.z + weights0.w;
+  let inv = select(1.0, 1.0 / ws, ws > 0.0001);
+  let nw = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * inv, ws > 0.0001);
+  var sp = vec4f(0.0);
+  for (var i = 0u; i < 4u; i++) {
+    sp += (skinMats[joints0[i]] * vec4f(position, 1.0)) * nw[i];
+  }
+  return camera.projection * camera.view * vec4f(sp.xyz, 1.0);
+}
+
+@fragment fn fs() -> @location(0) vec4f { return vec4f(1.0, 0.0, 0.0, 0.0); }
+`
+
+export const SELECTION_EDGE_SHADER_WGSL = /* wgsl */ `
+@group(0) @binding(0) var maskTex: texture_2d<f32>;
+@group(0) @binding(1) var maskSamp: sampler;
+struct Params { thickness: f32, _pad0: f32, _pad1: f32, _pad2: f32 };
+@group(0) @binding(2) var<uniform> params: Params;
+
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
+  let x = f32((vi & 1u) << 2u) - 1.0;
+  let y = f32((vi & 2u) << 1u) - 1.0;
+  return vec4f(x, y, 0.0, 1.0);
+}
+
+@fragment fn fs(@builtin(position) fragCoord: vec4f) -> @location(0) vec4f {
+  let dims = vec2f(textureDimensions(maskTex));
+  let uv = fragCoord.xy / dims;
+  let center = textureSample(maskTex, maskSamp, uv).r;
+  if (center > 0.5) { discard; }
+  let t = params.thickness / dims;
+  var m: f32 = 0.0;
+  m = max(m, textureSample(maskTex, maskSamp, uv + vec2f(-t.x,  0.0)).r);
+  m = max(m, textureSample(maskTex, maskSamp, uv + vec2f( t.x,  0.0)).r);
+  m = max(m, textureSample(maskTex, maskSamp, uv + vec2f( 0.0, -t.y)).r);
+  m = max(m, textureSample(maskTex, maskSamp, uv + vec2f( 0.0,  t.y)).r);
+  m = max(m, textureSample(maskTex, maskSamp, uv + vec2f(-t.x, -t.y)).r);
+  m = max(m, textureSample(maskTex, maskSamp, uv + vec2f( t.x, -t.y)).r);
+  m = max(m, textureSample(maskTex, maskSamp, uv + vec2f(-t.x,  t.y)).r);
+  m = max(m, textureSample(maskTex, maskSamp, uv + vec2f( t.x,  t.y)).r);
+  if (m < 0.05) { discard; }
+  return vec4f(1.0, 1.0, 0.0, m);
+}
+`