Grid.Space Applications

Unlike the legacy boolean method which subtracts a cutter prism from a solid, the geometric_offset chamfer is a topology and geometry transform. It follows a five-stage pipeline to ensure watertight, manifold results without the fragility of boolean operations:

1. Topology Extraction: Builds edge-to-incident-face adjacency and identifies valid manifold edges.
2. Per-Edge Offset Construction: Computes incident face normals, constructs offset planes, and determines the chamfer line via plane-plane intersection.
3. Face Trimming + Insertion: Trims original faces against the new chamfer boundaries and inserts new chamfer quad/tri strip faces.
4. Vertex Corner Solver: Solves multi-edge vertex neighborhoods (2-edge, n-edge star, etc.) by calculating intersection polygons in a tangent frame to create watertight corner patches.
5. Rebuild + Mapping: Rebuilds the indexed mesh and recomputes boundary segments and canonical edge references while preserving provenance.

The Void Constraints V2 architecture moves from a dual-solver model to a planegcs-first model. In this architecture, planegcs is the primary and default solver for all live interactions (like dragging) and final settling. The fallback solver is no longer applied unconditionally; it is retained only as a failure recovery mechanism when planegcs fails to converge or returns a non-converged status.

Key Concepts:

• Primary Solver: planegcs handles all geometry shaping.
• Fallback Solver: Used only for failure recovery.
• Temporary Constraints: During drag interactions, the system uses constraints with temporary: true. These provide guidance (e.g., point-to-point or point-to-line) to the cursor or ghost references without causing permanent topology mutations.
• Tangency: Tangent constraints are mapped into planegcs natively. For shared-endpoint tangency, the system uses the angle_via_point solver binding with an angle of 0 to ensure stability.

The PW0, PWX, and all modern Anycubic formats (v515+) use Nibble-coded RLE4 encoding. This is a variable-length format where each byte is split into a 4-bit code and a 4-bit repeat value.

Encoding Rules:

• Black (0x0): Extended format (2 bytes). Format: [0x0R] [RR]. Repeat is a 12-bit value: (R << 8) | RR (max 4095).
• White (0xF): Extended format (2 bytes). Format: [0xFR] [RR]. Repeat is a 12-bit value: (R << 8) | RR (max 4095).
• Grayscale (0x1-0xE): Single byte format. Color = (code << 4) | code. Repeat = 4-bit value (1-15).

Example Encodings:

• White (1000 pixels): F3 E8 (Code 0xF, Repeat (3 << 8) + 232 = 1000)
• Black (500 pixels): 01 F4 (Code 0x0, Repeat (1 << 8) + 244 = 500)
• Gray (0x77, 10 pixels): 7A (Code 0x7, Repeat 0xA = 10)
• Gray (0xAA, 5 pixels): A5 (Code 0xA, Repeat 0x5 = 5)

for (int i = 0; i < encodedRle.Length; i++)
{
    byte b = encodedRle[i];
    int code = b >> 4;        // Upper nibble
    int repeat = b & 0xf;    // Lower nibble
    byte color;

    switch (code)
    {
        case 0x0:  // Black (extended)
            color = 0;
            i++;
            repeat = (repeat << 8) + encodedRle[i];
            break;

        case 0xf:  // White (extended)
            color = 255;
            i++;
            repeat = (repeat << 8) + encodedRle[i];
            break;

        default:   // Grayscale (single byte)
            color = (byte)((code << 4) | code);
            break;
    }

    // Fill repeat pixels with color
}