Pathagon model in CascadeStudio

[johnsonm]

I modeled from memory elements of a fun game, pathagon, that I had recently seen, as an exercise to play with CascadeStudio, including filleting. (To be clear, I haven't made a physical copy of this game, I just looked around me for something to model when I first learned about CascadeStudio.)

let baseLen = 38; // nominal X/Y spacing
let clearance = 1; // clearance from nominal for play
let partClearance = 5; // clearance for separate parts
let units = 8; // number of units across board
let bezelInset = 3;
let boardWidth = units * baseLen + 2 * bezelInset;

let bezelWidth = 12;
let bezelHeight = 17;
let bezelLength = boardWidth + 2 * bezelWidth - 2 * bezelInset;
let bezelInsetOffset = 2;

let boardHeight = 3;
let pegHeight = 6;
let pegOffset = pegHeight / 2 + boardHeight;
let pegWidth = baseLen / 2.414; // side length of peg, without clearance

let pawnHeight = pegHeight + 6;
let pawnsPerSide = 14;

let assembled = Checkbox("Assembled", false);
let darkPieces = Checkbox("Dark pieces", false);

function pawn() {
    let pawnLeg = baseLen - clearance;
    let basePawn = Box(pawnLeg, pawnLeg, pawnHeight, true);
    return Intersection([
        basePawn,
        Rotate([0, 0, 1], 45, basePawn)
    ]);
}

function peg() {
    let pegLeg = pegWidth - clearance;
    return Rotate([0, 0, 1], 45, Box(pegLeg, pegLeg, pegHeight+0.2, true));
}

function baseBoard() {
    let board = [Translate([0, 0, boardHeight / 2], Box(boardWidth, boardWidth, boardHeight, true))];
    for (let x = 1; x < units; x++) {
        let xOffset = (x - units / 2) * baseLen;
        for (let y = 1; y < units; y++) {
            let yOffset = (y - units / 2) * baseLen;
            board.push(Translate([xOffset, yOffset, pegOffset-0.1],  peg()));
        }
    }
    return Union(board);
}

function bezel() {
    return Translate([0, 0, bezelWidth / 2],
        FilletEdges(
            Difference(
                ChamferEdges(Box(bezelLength, bezelHeight, bezelWidth, true), bezelWidth - 0.01, [1, 5]),
                [Translate([0, -(bezelHeight/2-boardHeight/2), bezelWidth / 2 - bezelInset / 2], Box(bezelLength, boardHeight+2*clearance, bezelInset+2*clearance, true))]
            ),
            1.5, [7, 17, 13]
        )
    );
}

function bezelSet() {
    return Rotate([0, 0, 1], 90, Union([
        Translate([0, -(bezelHeight / 2 + partClearance/2), 0], bezel()),
        Translate([0, bezelHeight / 2 + partClearance/2, 0], bezel())
    ]));
}

function pawnSet() {
    let pawns = [];
    for (let y = 0; y < pawnsPerSide/2; y++) {
        pawns.push(Translate([0, boardWidth/2 - baseLen/2 - y * (baseLen + partClearance), 0], pawn()));
        pawns.push(Translate([baseLen + partClearance, boardWidth/2 - baseLen/2 -y * (baseLen + partClearance), 0], pawn()));
    }
    return Union(pawns);
}

if (assembled) {
    Translate([0, 0, bezelInsetOffset], baseBoard());
    let b = Translate([0, boardWidth/2 + bezelWidth - bezelInset, bezelHeight/2], Rotate([1, 0, 0], 90, bezel()));
    for (let n=0; n < 4; n++) {
        b = Rotate([0, 0, 1], 90, b, true);
    }
    for (let x=0; x < units; x++) {
        for (let y=0; y < units; y++) {
            // show that every position could be filled with one of the 28 actual pawns
            Translate([-baseLen*units/2 + baseLen/2 + baseLen*x, -baseLen*units/2 + baseLen/2 + baseLen*y, bezelInsetOffset+boardHeight+pawnHeight/2], pawn());
        }
    }
} else if (darkPieces) {
    Translate([baseLen/2 + partClearance, 0, 0], pawnSet());
    Translate([-(bezelWidth + partClearance), 0, 0], bezelSet());
} else {
    baseBoard();
    Translate([boardWidth/2 + baseLen/2 + partClearance, 0, pawnHeight/2], pawnSet());
    Translate([-(boardWidth/2 + bezelWidth + partClearance*3), 0, 0], bezelSet());
}

[Irev-Dev]

👏 @johnsonm

[zalo]

Awesome sketch! I was definitely making a "pogface" when I saw how many operations it was as it was rendering.

It looks very faithful to the original game board 😄

[johnsonm]

Should be conceptually faithful; unlikely to be dimensionally faithful from memory, though! ☺

[johnsonm]

After buying my own copy of the real thing, I printed a copy at 20mm spacing to be a more travel-friendly version.

When I exported the OBJ files, PrusaSlicer had to fix thousands of open edges.

I see there haven't been many changes recently. Does that mean that CascadeStudio is no longer being maintained, even for new OpenCascade builds?

[johnsonm]

I would think that SDFs would make hull- and minkowski-basd chamfers and fillets cheap; using OpenSCAD with the Manifold engine that worked fine for me, but it looks like ManifoldCAD doesn't implement either hull or minkowski in its OpenSCAD-like bindings.

But yes, CADQuery may have some of the strongest topological naming robustness available, since it's explicitly semantic rather than heuristic. ☺

[zalo]

I don't think Hulls or (Non-Sphere) Minkowski sums are easy with anything...
If you have a pure voxel grid, then hulls and minkowksi sums are straightforward(ish) to implement, but extraordinarily expensive (like O(n^3) on the number of voxels).
Mesh hulls have some good reference implementations, but mesh minkowski sums have probably only been implemented well a single-digit number of times in history... to say nothing of how hard it would be with BReps. 💀

Manifold might have a way to dilate models by adding distance to their implicit representation... but I wasn't able to find it after a quick poke-around...

[johnsonm]

Once I started using the Manifold-based OpenSCAD development builds, I quit avoiding minkowskis, because they weren't particularly slow any more. My most recent change there was to use a minkowski of two hulls, the second of which was two cones back to back (which gave me a chamfer on a fairly irregular shape). And I'm not even using the GPU-accelerated version, just pure CPU. That model has three parts, and also includes a fully modeled thread as well as the non-trivial (non-spherical) minkowski, and still takes about one second to render (F6) from a cold start.

Given that performance in Manifold-based OpenSCAD, it seemed likely that it could also work in ManifoldCAD. But then I didn't see functions exported in the bindings. I don't know anything about modeling in pure Manifold. Everything I "know" about its bindings was from merely skimming through bindings/wasm/bindings.js in the Manifold source. (I'm clueless.)

It looks like the only use of SDFs in Manifold is LevelSet.

(I brought up SDFs vis-a-vis fillets and chamfers only because I saw years ago that ImplicitCAD advertised that it was its use of SDFs that made fillets and chamfers cheap. But I ended up not using ImplicitCAD when I particularly expected to, because I discovered that it was weak in some math functions relative to OpenSCAD, and missing some I needed for that particular project, whatever it was.)

For CadQuery, the readme says:

Provide a non-proprietary, plain text model format that can be edited and executed with only a web browser.

But I don't see any reference to being able to do that, so I think I'm missing something.

[zalo]

Cool! I didn't know someone was giving OpenSCAD a new backend! I really have to get with the times :-)

Heck, now that there's an OpenSCAD WASM implementation with a fast backend, it might even be cool to port the CascadeStudio editor to use it.
The main issue is that it's still GPL, despite shucking CGAL, so that makes it less interesting...

My bet for CadQuery is that the "browser" comment was a reference to Jupyter, which has a browser client, but needs a backing web server:
https://cadquery.readthedocs.io/en/latest/installation.html?highlight=browser#jupyter

[johnsonm]

Ah, so they didn't really mean the "only" part of "only a web browser" then. ☺

Here's a post with some context from a few months ago, shortly after it first became available:

https://social.makerforums.info/@mcdanlj/110046620727479425