reze-engine 0.57.2 → 0.57.4

package/dist/shaders/passes/trails.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trails.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/trails.ts"],"names":[],"mappings":"AA4BA,KAAK,WAAW,GAAG;IACjB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb;oEACgE;IAChE,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAA;IAClB,8DAA8D;IAC9D,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IAC3B,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAKjF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,EAAE,CAAA;IACf;;;;kFAI8E;IAC9E,SAAS,EAAE,OAAO,CAAA;CACnB,GACA,MAAM,CAsVR"}
+{"version":3,"file":"trails.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/trails.ts"],"names":[],"mappings":"AA4BA,KAAK,WAAW,GAAG;IACjB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb;oEACgE;IAChE,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAA;IAClB,8DAA8D;IAC9D,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IAC3B,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAKjF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,EAAE,CAAA;IACf;;;;kFAI8E;IAC9E,SAAS,EAAE,OAAO,CAAA;CACnB,GACA,MAAM,CAyZR"}

package/dist/shaders/passes/trails.js

@@ -69,6 +69,10 @@ const SUB: i32 = ${TRAIL_SUBDIVISIONS};
 // scaling width pinches the strip shut at exactly the moments a hand decelerates,
 // which is every turn — and a ribbon that closes to nothing at each turn reads as
 // dark breaks in the middle of it.
+/** How far a bone may travel between two trail samples, as a fraction of its
+ *  owner's bounding radius. Generous on purpose: a hard swing covers a fraction
+ *  of this, and the only things above it are cuts. */
+const RZ_TRAIL_MAX_STEP: f32 = 0.5;
 const RZ_REF_SPAN: f32 = 0.37;
 
 struct CameraU {
@@ -124,18 +128,62 @@ fn _rzCastLive() -> i32 {
   }
   return n;
 }
+/**
+ * CENTRIPETAL knot spacing: the square root of the chord.
+ *
+ * The whole reason the spline below is not the textbook one-liner. Uniform
+ * Catmull-Rom takes the tangent at p1 to be (p2 - p0)/2 — a quantity that knows
+ * nothing about how far apart those samples actually are. Trails are sampled at
+ * a FIXED RATE, so a hand that accelerates leaves one segment far longer than
+ * its neighbours, and a tangent sized for the long one applied over the short
+ * one swings the curve far outside the control polygon: the ribbon bulges out
+ * to a place no sample ever was, which reads as the trail teleporting, and it
+ * happens precisely on the quick moves.
+ *
+ * Spacing the knots by sqrt(chord) — alpha = 0.5, the centripetal variant — is
+ * the standard cure, and it is the only alpha proven to produce no cusp and no
+ * self-intersection whatever the samples do.
+ */
+fn rzKnot(a: vec3f, b: vec3f) -> f32 {
+  return max(sqrt(distance(a, b)), 1e-4);
+}
+
+/** The two Hermite tangents of the segment p1..p2, sized by real chord lengths. */
+fn rzSplineTangents(p0: vec3f, p1: vec3f, p2: vec3f, p3: vec3f) -> mat2x3f {
+  let d0 = rzKnot(p0, p1);
+  let d1 = rzKnot(p1, p2);
+  let d2 = rzKnot(p2, p3);
+  let m1 = ((p1 - p0) / d0 - (p2 - p0) / (d0 + d1) + (p2 - p1) / d1) * d1;
+  let m2 = ((p2 - p1) / d1 - (p3 - p1) / (d1 + d2) + (p3 - p2) / d2) * d1;
+  return mat2x3f(m1, m2);
+}
+
 /** Catmull-Rom through four samples — passes through p1 and p2. */
 fn rzSpline(p0: vec3f, p1: vec3f, p2: vec3f, p3: vec3f, t: f32) -> vec3f {
+  let m = rzSplineTangents(p0, p1, p2, p3);
   let t2 = t * t;
   let t3 = t2 * t;
-  return 0.5 * ((2.0 * p1) + (-p0 + p2) * t + (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * t2 +
-                (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3);
+  return (2.0 * t3 - 3.0 * t2 + 1.0) * p1
+       + (t3 - 2.0 * t2 + t) * m[0]
+       + (-2.0 * t3 + 3.0 * t2) * p2
+       + (t3 - t2) * m[1];
 }
-/** Its derivative — the ribbon's direction, smooth by construction. */
+
+/**
+ * Its derivative — the ribbon's direction, smooth by construction.
+ *
+ * Still exact at the knots, which is what the shared edge depends on: at t = 1
+ * this is m2 and at t = 0 it is m1, and the two segments meeting at a sample
+ * derive those from the same three points. They differ only by a positive
+ * scale, and this normalises, so both quads get the identical direction.
+ */
 fn rzSplineTangent(p0: vec3f, p1: vec3f, p2: vec3f, p3: vec3f, t: f32) -> vec3f {
+  let m = rzSplineTangents(p0, p1, p2, p3);
   let t2 = t * t;
-  let d = 0.5 * ((-p0 + p2) + 2.0 * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * t +
-                 3.0 * (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t2);
+  let d = (6.0 * t2 - 6.0 * t) * p1
+        + (3.0 * t2 - 4.0 * t + 1.0) * m[0]
+        + (-6.0 * t2 + 6.0 * t) * p2
+        + (3.0 * t2 - 2.0 * t) * m[1];
   if (length(d) < 1e-6) { return vec3f(0.0, 1.0, 0.0); }
   return normalize(d);
 }
@@ -262,9 +310,28 @@ fn vs(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> VSOut
   // where the hand slows — aggregation the width taper never clamps, because
   // width follows AGE, not speed. Where the hand is not moving there is no path,
   // and a path effect should draw nothing there at all.
+  // AND A GATE AT THE OTHER END, for the same reason. The minimum says "the
+  // hand is not moving"; this says "the hand did not move THERE". A bone cannot
+  // cross a sizeable fraction of its owner between two samples, so a span that
+  // large is not a motion — it is a cut: a seek, a clip boundary, a model
+  // repositioned, a motion that jumps. Joined anyway, the two samples either
+  // side are bridged by one enormous quad flung across the gap and drawn at full
+  // strength, which is the "trail teleports on a fast move" report. A path
+  // effect should draw nothing across a discontinuity, exactly as it draws
+  // nothing where there is no path.
+  //
+  // Measured against the subject's own bounding radius rather than in world
+  // units, so it holds for a doll and for a giant, and it is checked in WORLD
+  // space rather than in pixels — a camera cut moves every projected point at
+  // once and must not shred every ribbon on screen.
+  //
+  // Zero radius means the cast slot is not live, and then there is nothing to
+  // measure against: the test stands down rather than rejecting everything.
+  let reach = rzSubject(subject).bounds.w * RZ_TRAIL_MAX_STEP;
   let c1 = cam.proj * cam.view * vec4f(p1, 1.0);
   let c2 = cam.proj * cam.view * vec4f(p2, 1.0);
   if (c1.w <= 0.01 || c2.w <= 0.01 ||
+      (reach > 0.0 && distance(p1, p2) > reach) ||
       distance(c1.xy / c1.w * toPx, c2.xy / c2.w * toPx) < 0.7 * (H / 1080.0)) {
     out.clip = vec4f(0.0, 0.0, -2.0, 1.0);
     out.uv = vec2f(0.0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.57.2",
+  "version": "0.57.4",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/shaders/passes/trails.ts

@@ -120,6 +120,10 @@ const SUB: i32 = ${TRAIL_SUBDIVISIONS};
 // scaling width pinches the strip shut at exactly the moments a hand decelerates,
 // which is every turn — and a ribbon that closes to nothing at each turn reads as
 // dark breaks in the middle of it.
+/** How far a bone may travel between two trail samples, as a fraction of its
+ *  owner's bounding radius. Generous on purpose: a hard swing covers a fraction
+ *  of this, and the only things above it are cuts. */
+const RZ_TRAIL_MAX_STEP: f32 = 0.5;
 const RZ_REF_SPAN: f32 = 0.37;
 
 struct CameraU {
@@ -175,18 +179,62 @@ fn _rzCastLive() -> i32 {
   }
   return n;
 }
+/**
+ * CENTRIPETAL knot spacing: the square root of the chord.
+ *
+ * The whole reason the spline below is not the textbook one-liner. Uniform
+ * Catmull-Rom takes the tangent at p1 to be (p2 - p0)/2 — a quantity that knows
+ * nothing about how far apart those samples actually are. Trails are sampled at
+ * a FIXED RATE, so a hand that accelerates leaves one segment far longer than
+ * its neighbours, and a tangent sized for the long one applied over the short
+ * one swings the curve far outside the control polygon: the ribbon bulges out
+ * to a place no sample ever was, which reads as the trail teleporting, and it
+ * happens precisely on the quick moves.
+ *
+ * Spacing the knots by sqrt(chord) — alpha = 0.5, the centripetal variant — is
+ * the standard cure, and it is the only alpha proven to produce no cusp and no
+ * self-intersection whatever the samples do.
+ */
+fn rzKnot(a: vec3f, b: vec3f) -> f32 {
+  return max(sqrt(distance(a, b)), 1e-4);
+}
+
+/** The two Hermite tangents of the segment p1..p2, sized by real chord lengths. */
+fn rzSplineTangents(p0: vec3f, p1: vec3f, p2: vec3f, p3: vec3f) -> mat2x3f {
+  let d0 = rzKnot(p0, p1);
+  let d1 = rzKnot(p1, p2);
+  let d2 = rzKnot(p2, p3);
+  let m1 = ((p1 - p0) / d0 - (p2 - p0) / (d0 + d1) + (p2 - p1) / d1) * d1;
+  let m2 = ((p2 - p1) / d1 - (p3 - p1) / (d1 + d2) + (p3 - p2) / d2) * d1;
+  return mat2x3f(m1, m2);
+}
+
 /** Catmull-Rom through four samples — passes through p1 and p2. */
 fn rzSpline(p0: vec3f, p1: vec3f, p2: vec3f, p3: vec3f, t: f32) -> vec3f {
+  let m = rzSplineTangents(p0, p1, p2, p3);
   let t2 = t * t;
   let t3 = t2 * t;
-  return 0.5 * ((2.0 * p1) + (-p0 + p2) * t + (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * t2 +
-                (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t3);
+  return (2.0 * t3 - 3.0 * t2 + 1.0) * p1
+       + (t3 - 2.0 * t2 + t) * m[0]
+       + (-2.0 * t3 + 3.0 * t2) * p2
+       + (t3 - t2) * m[1];
 }
-/** Its derivative — the ribbon's direction, smooth by construction. */
+
+/**
+ * Its derivative — the ribbon's direction, smooth by construction.
+ *
+ * Still exact at the knots, which is what the shared edge depends on: at t = 1
+ * this is m2 and at t = 0 it is m1, and the two segments meeting at a sample
+ * derive those from the same three points. They differ only by a positive
+ * scale, and this normalises, so both quads get the identical direction.
+ */
 fn rzSplineTangent(p0: vec3f, p1: vec3f, p2: vec3f, p3: vec3f, t: f32) -> vec3f {
+  let m = rzSplineTangents(p0, p1, p2, p3);
   let t2 = t * t;
-  let d = 0.5 * ((-p0 + p2) + 2.0 * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3) * t +
-                 3.0 * (-p0 + 3.0 * p1 - 3.0 * p2 + p3) * t2);
+  let d = (6.0 * t2 - 6.0 * t) * p1
+        + (3.0 * t2 - 4.0 * t + 1.0) * m[0]
+        + (-6.0 * t2 + 6.0 * t) * p2
+        + (3.0 * t2 - 2.0 * t) * m[1];
   if (length(d) < 1e-6) { return vec3f(0.0, 1.0, 0.0); }
   return normalize(d);
 }
@@ -313,9 +361,28 @@ fn vs(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> VSOut
   // where the hand slows — aggregation the width taper never clamps, because
   // width follows AGE, not speed. Where the hand is not moving there is no path,
   // and a path effect should draw nothing there at all.
+  // AND A GATE AT THE OTHER END, for the same reason. The minimum says "the
+  // hand is not moving"; this says "the hand did not move THERE". A bone cannot
+  // cross a sizeable fraction of its owner between two samples, so a span that
+  // large is not a motion — it is a cut: a seek, a clip boundary, a model
+  // repositioned, a motion that jumps. Joined anyway, the two samples either
+  // side are bridged by one enormous quad flung across the gap and drawn at full
+  // strength, which is the "trail teleports on a fast move" report. A path
+  // effect should draw nothing across a discontinuity, exactly as it draws
+  // nothing where there is no path.
+  //
+  // Measured against the subject's own bounding radius rather than in world
+  // units, so it holds for a doll and for a giant, and it is checked in WORLD
+  // space rather than in pixels — a camera cut moves every projected point at
+  // once and must not shred every ribbon on screen.
+  //
+  // Zero radius means the cast slot is not live, and then there is nothing to
+  // measure against: the test stands down rather than rejecting everything.
+  let reach = rzSubject(subject).bounds.w * RZ_TRAIL_MAX_STEP;
   let c1 = cam.proj * cam.view * vec4f(p1, 1.0);
   let c2 = cam.proj * cam.view * vec4f(p2, 1.0);
   if (c1.w <= 0.01 || c2.w <= 0.01 ||
+      (reach > 0.0 && distance(p1, p2) > reach) ||
       distance(c1.xy / c1.w * toPx, c2.xy / c2.w * toPx) < 0.7 * (H / 1080.0)) {
     out.clip = vec4f(0.0, 0.0, -2.0, 1.0);
     out.uv = vec2f(0.0);