Remove "legacy mode", make deforms more dynamic

LunaTheFoxgirl · LunaTheFoxgirl · commit b964d63e923b · 2025-09-08T15:05:08.000+02:00
diff --git a/source/inochi2d/core/math/deform.d b/source/inochi2d/core/math/deform.d
@@ -18,23 +18,23 @@ public:
     /**
         The base position of the deformable's points.
     */
-    @property const(vec2)[] basePoints();
+    @property const(vec2)[] basePoints() @nogc;
 
     /**
         The points which may be deformed by the deformer.
     */
-    @property vec2[] deformPoints();
+    @property vec2[] deformPoints() @nogc;
 
     /**
         The base transform of the object before any 
         parameters have been applied.
     */
-    @property Transform baseTransform();
+    @property Transform baseTransform() @nogc;
 
     /**
         World transform of the deformable object.
     */
-    @property Transform worldTransform();
+    @property Transform worldTransform() @nogc;
 
     /**
         Deforms the IDeformable.
diff --git a/source/inochi2d/core/nodes/deformer/meshdeformer.d b/source/inochi2d/core/nodes/deformer/meshdeformer.d
@@ -26,16 +26,8 @@ private:
     Mesh mesh_;
     DeformedMesh base_;
     DeformedMesh deformed_;
-    BlendWeight[][] weights_;
     vec2[] deformDeltas_;
 
-    void clearWeights() {
-        foreach(i; 0..weights_.length) {
-            nu_freea(weights_[i]);
-        }
-        nu_freea(weights_);
-    }
-
 protected:
     /**
         Allows serializing self data (with pretty serializer)
@@ -62,7 +54,7 @@ public:
     /**
         The mesh
     */
-    @property Mesh mesh() => mesh_;
+    @property Mesh mesh() @nogc => mesh_;
     final @property void mesh(Mesh value) @nogc {
         if (value is mesh_)
             return;
@@ -83,8 +75,8 @@ public:
     /**
         The control points of the deformer.
     */
-    override @property vec2[] controlPoints() => deformed_.points;
-    override @property void controlPoints(vec2[] value) {
+    override @property vec2[] controlPoints() @nogc => deformed_.points;
+    override @property void controlPoints(vec2[] value) @nogc {
         import nulib.math : min;
 
         size_t m = min(value.length, deformed_.points.length);
@@ -94,18 +86,18 @@ public:
     /**
         The base position of the deformable's points, in world space.
     */
-    override @property const(vec2)[] basePoints() => base_.points;
+    override @property const(vec2)[] basePoints() @nogc => base_.points;
 
     /**
         The points which may be deformed by a deformer, in world space.
     */
-    override @property vec2[] deformPoints() => deformed_.points;
+    override @property vec2[] deformPoints() @nogc => deformed_.points;
 
     // Destructor
     ~this() {
         nu_freea(deformDeltas_);
         nogc_delete(deformed_);
-        this.clearWeights();
+        nogc_delete(base_);
         mesh_.release();
     }
 
@@ -165,75 +157,45 @@ public:
         // Use the weights to deform each subpoint by a delta determined
         // by the weight to each vertex in their triangle.
         foreach(i, mesh; toDeform) {
-            if (weights_[i].length == 0)
-                continue;
-
             foreach(j; 0..mesh.deformPoints.length) {
-                BlendWeight weight = weights_[i][j];
-                vec2 dfDelta = -(
-                    (deformDeltas_[weight.indices[0]]*weight.weights.x) +
-                    (deformDeltas_[weight.indices[1]]*weight.weights.y) +
-                    (deformDeltas_[weight.indices[2]]*weight.weights.z)
-                );
-                mesh.deform(j, dfDelta);
-            }
-        }
-    }
-
-    override
-    void rescan() {
-        super.rescan();
-
-        base_.reset();
-        base_.pushMatrix(transform!true.matrix);
-
-        // Clear weights lists.
-        if (weights_.length < toDeform.length) {
-            weights_ = weights_.nu_resize(toDeform.length);
-            nogc_zeroinit(weights_[0..$]);
-        }
-
-        // Use barycentric coordinates of triangles to calculate
-        // weights for deformed points.
-        Triangle[] tris = base_.getTriangles();
-        foreach(i, df; toDeform) {
-
-            // Reset all the data in the weights.
-            weights_[i] = weights_[i].nu_resize(df.deformPoints.length);
-            weights_[i][0..$] = BlendWeight.init;
-
-            mat4 baseTransformMat = df.baseTransform.matrix;
-            foreach(j; 0..df.deformPoints.length) {
-
-                // NOTE:    IDeformable doesn't have the internal mesh reference
-                //          so instead we just multiply the point with their world
-                //          matrix. 
-                vec2 wpt = (baseTransformMat * vec4(df.basePoints[j], 0, 1)).xy;
-                foreach(k, ref tri; tris) {
-                    vec3 bc = tri.barycentric(wpt);
-                    if (bc.x > 0 && bc.y > 0 && bc.z > 0) {
-                        weights_[i][j] = BlendWeight(
-                            [
-                                mesh_.indices[(k*3)+0],
-                                mesh_.indices[(k*3)+1],
-                                mesh_.indices[(k*3)+2],
-                            ], 
-                            bc
-                        );
-                        break;
-                    }
+                vec2 mp = mesh.deformPoints[j];
+
+                foreach(k; 0..deformed_.elementCount/3) {
+
+                    uint[3] idx = [
+                        mesh_.indices[(k*3)+0],
+                        mesh_.indices[(k*3)+1],
+                        mesh_.indices[(k*3)+2],
+                    ];
+                    Triangle tri = Triangle(
+                        base_.points[idx[0]],
+                        base_.points[idx[1]],
+                        base_.points[idx[2]],
+                    );
+
+                    // Do some cheaper checks first.
+                    float minX = min(tri.p1.x, tri.p2.x, tri.p3.x);
+                    float maxX = max(tri.p1.x, tri.p2.x, tri.p3.x);
+                    float minY = min(tri.p1.y, tri.p2.y, tri.p3.y);
+                    float maxY = max(tri.p1.y, tri.p2.y, tri.p3.y);
+                    if (!(minX < mp.x && maxX > mp.x) && 
+                        !(minY < mp.y && maxY > mp.y))
+                        continue;
+
+                    // Expensive check and barycentric coordinates.
+                    vec3 bc = tri.barycentric(mesh.deformPoints[j]);
+                    if (bc.x < 0 || bc.y < 0 || bc.z < 0)
+                        continue;
+
+                    mesh.deform(j, -(
+                        (deformDeltas_[idx[0]]*bc.x) +
+                        (deformDeltas_[idx[1]]*bc.y) +
+                        (deformDeltas_[idx[2]]*bc.z)
+                    ));
+                    break;
                 }
             }
         }
-        nu_freea(tris);
     }
 }
-mixin Register!(MeshDeformer, in_node_registry);
-
-/**
-    Weights for meshes
-*/
-struct BlendWeight {
-    uint[3] indices = [0, 0, 0];
-    vec3 weights = vec3(0, 0, 0);
-}
+mixin Register!(MeshDeformer, in_node_registry);
diff --git a/source/inochi2d/core/nodes/deformer/package.d b/source/inochi2d/core/nodes/deformer/package.d
@@ -27,24 +27,17 @@ public import inochi2d.core.nodes.deformer.latticedeformer;
 abstract
 class Deformer : Node, IDeformable {
 private:
-    bool legacyMode_;
-
     void scanPartsRecurse(Node node) {
 
         // Don't need to scan null nodes
         if (node is null) return;
 
-        // NOTE:    Backwards compatibility mode does not allow
-        //          MeshGroup instances to be nested.
-        if (legacyMode_ && cast(Deformer)node)
-            return;
-
         // Do the main check
         if (IDeformable deformable = cast(IDeformable)node)
             toDeform ~= deformable;
         
         foreach(child; node.children) {
-            scanPartsRecurse(child);
+            this.scanPartsRecurse(child);
         }
     }
 
@@ -60,13 +53,11 @@ protected:
     override
     void onSerialize(ref JSONValue object, bool recursive=true) {
         super.onSerialize(object, recursive);
-        object["legacyMode"] = legacyMode_;
     }
 
     override
     void onDeserialize(ref JSONValue object) {
         super.onDeserialize(object);
-        this.legacyMode_ = object.tryGet!bool("legacyMode", true);
     }
 
     /**
@@ -80,15 +71,6 @@ protected:
 
 public:
 
-    /**
-        Whether deformers should act like MeshGroup when selecting
-        nodes to deform.
-    */
-    final @property bool legacyMode() => legacyMode_;
-    final @property void legacyMode(bool value) {
-        this.legacyMode_ = value;
-    }
-
     ~this() { }
 
     /**
@@ -101,28 +83,28 @@ public:
     /**
         The control points of the deformer.
     */
-    abstract @property vec2[] controlPoints();
-    abstract @property void controlPoints(vec2[] value);
+    abstract @property vec2[] controlPoints() @nogc;
+    abstract @property void controlPoints(vec2[] value) @nogc;
 
     /**
         The base position of the deformable's points.
     */
-    abstract @property const(vec2)[] basePoints();
+    abstract @property const(vec2)[] basePoints() @nogc;
 
     /**
         Local matrix of the deformable object.
     */
-    override @property Transform baseTransform() => transform!true;
+    override @property Transform baseTransform() @nogc => transform!true;
 
     /**
         World matrix of the deformable object.
     */
-    override @property Transform worldTransform() => transform!false;
+    override @property Transform worldTransform() @nogc => transform!false;
 
     /**
         The points which may be deformed by the deformer.
     */
-    override @property vec2[] deformPoints() => controlPoints();
+    override @property vec2[] deformPoints() @nogc => controlPoints();
 
     /**
         Deforms the IDeformable.
diff --git a/source/inochi2d/core/nodes/drawable/package.d b/source/inochi2d/core/nodes/drawable/package.d
@@ -35,6 +35,7 @@ abstract class Drawable : Node, IDeformable {
 private:
     Mesh mesh_;
     DeformedMesh deformed_;
+    DeformedMesh base_;
 
 protected:
 
@@ -58,8 +59,10 @@ protected:
     override
     void onDeserialize(ref JSONValue object) {
         super.onDeserialize(object);
-        this.mesh_ = Mesh.fromMeshData(object.tryGet!MeshData("mesh"));
-        this.deformed_ = nogc_new!DeformedMesh(mesh_);
+
+        this.deformed_ = nogc_new!DeformedMesh();
+        this.base_ = nogc_new!DeformedMesh();
+        this.mesh = Mesh.fromMeshData(object.tryGet!MeshData("mesh"));
     }
 
 public:
@@ -77,22 +80,23 @@ public:
 
         this.mesh_ = value.retained();
         this.deformed_.parent = value;
+        this.base_.parent = value;
     }
 
     /**
         Local matrix of the deformable object.
     */
-    override @property Transform baseTransform() => transform!true;
+    override @property Transform baseTransform() @nogc => transform!true;
 
     /**
         World matrix of the deformable object.
     */
-    override @property Transform worldTransform() => transform!false;
+    override @property Transform worldTransform() @nogc => transform!false;
 
     /**
         The base position of the deformable's points.
     */
-    @property const(vec2)[] basePoints() => mesh_.points;
+    @property const(vec2)[] basePoints() => base_.points;
 
     /**
         The points which may be deformed by the deformer.
@@ -125,8 +129,9 @@ public:
     this(MeshData data, GUID guid, Node parent = null) {
         super(guid, parent);
         
-        this.mesh_ = Mesh.fromMeshData(data);
-        this.deformed_ = nogc_new!DeformedMesh(mesh_);
+        this.deformed_ = nogc_new!DeformedMesh();
+        this.base_ = nogc_new!DeformedMesh();
+        this.mesh = Mesh.fromMeshData(data);
     }
 
     /**
@@ -172,6 +177,9 @@ public:
     override
     void resetDeform() {
         deformed_.reset();
+        
+        base_.reset();
+        base_.pushMatrix(baseTransform.matrix);
     }
 
     /**
