Blender Git Loki

adaptive_cloth: Mesh: add checked loose edge

Adds a loose edge to the mesh with the given vert indices and ensures
that these vert indices do not already have an edge between them and
that they exist.

adaptive_cloth: Mesh: compute info separate functions for each type

`compute_info()` now calls separate functions for each element type
instead of computing it within that function. This allows other parts
of the code to compute info of the element when it is easier to do
over creating a mesh diff.

adaptive_cloth: Mesh: functions to check if mesh has that element

Given the element's index, it check if the element still exists in the
mesh.

adaptive_cloth: AdaptiveMesh: sewing edge: get set of opposite edges

Given a vertex, the function is supposed to add a sewing edge to it if
possible.

Currently the function gets the set of opposite edges. An opposite
edge is an edge that is in between 2 loose edges and these loose edges
are connected to edges that connect to the given vert.

e1 vert e5
e1_ov.________.________.e4_ov
| |
e2| |e4
._________________.
e2_ov opposite_edge e3_ov
(e3)

What needs to be done: With the set of opposite edges, if the edge is
splittable then it should be split and a new edge should be added
between vert and the newly created vert (vert created when splitting
the opposite edge).

adaptive_cloth: Mesh: Edge: get checked other vert

adaptive_cloth: fix: Mesh: split edge: elements missed in MeshDiff

Split edge function didn't add the new node and the new vert(s) to
MeshDiff.

adaptive_cloth: AdaptiveMesh: flag for sewing with gui where needed

Added a new flag to have sewing enabled. The flag doesn't do anything
yet (no functionality).

Added the required code to pass this sewing option to
adaptive_remesh().

Created the GUI for this flag in the AdaptiveRemesh modifier.

float2x3: initial

float3x2: initial

float2x2: documentation

float4x4: documentation

adaptive_cloth: ClothNodeData: fix typo for ClothVertex flags interp

adaptive_cloth: ClothNodeData: interp goal correctly

The goal of the ClothVertex causes the vertex to move towards xconst
so it doesn't make sense to interpolate the goal since this will lead
to a gradient for the goal and this is not artist friendly, there
would be no way for the artist to define only a specific vertex to be
attached to a point in 3D space.

adaptive_cloth: ClothNodeData: interp flags correctly

cloth: fix: reset per vertex spring count when building springs

While building the structural springs, the vertices that connect the
springs, their spring count is incremented.

Since the springs are being rebuilt entirely, the spring count should
also be reset.

adaptive_mesh: serialize and dump the cloth mesh every frame

adaptive_cloth: fix: Mesh: collapse edge: can lead to loose verts

The previous commit can lead to loose verts (verts that don't have any
edges attached). Such verts should be deleted.

adaptive_cloth: fix: Mesh: collapse edge: can lead to loose edges

There are some edge cases (:P) that can lead to the creation of loose
edges when collapsing the edge.

Suppose v2 has an edge that contains only 1 face and this face also
contains v1, the face was deleted but the remaining edge between v2
and ov, remained. This causes the loose edge. The simple check and
deletion of such an edge fixes this bug.

adaptive_cloth: AdaptiveMesh: fix: aspect ratio, wrong area

Must take the non directional area (absolute value of the area) since
the order of the verts of the face may not correspond to normal of the
face always. The aspect ratio calculation should not be doing the
inversion testing as well. (This could be used for inversion testing
but without proper math backing it, don't want to use it right now).

adaptive_cloth: AdaptiveMesh: aspect ratio test when collapsing edge

Test to see if the faces generated when collapsing the edge will not
meet the aspect ratio criterion.

There is a lot more information about which algorithm is used for
calculating the aspect ratio in the code comments. A gist of it would
be that there many different ways to calculate the aspect ratio of a
triangle and each provides a different end result suitable for
different needs. This makes it hard to select the right algorithm.