We are building a Ruby API plugin targeting SketchUp 2017 through 2026 that generates kitchen wall cabinet compositions, including a wood cornice profile (crown molding) on top of each arrangement. The cornice is generated via FollowMe along a 2D path derived from the cabinet tops.
What works fine — linear arrangements: When all cabinets are in a straight line, we merge the cornice groups using a chain of .union() calls on copies (so originals survive if the boolean fails), guarded by a manifold? check before each operation. This is stable across SU versions.
The problem: 90° corner cabinet When the composition includes a corner unit (W_Corner90), the cornice path has a non-rectangular turn. FollowMe generates the corner piece (gC) along the angled path, and the two straight arms (U1 left, U2 right) meet at the junction.
We need to bridgeU1 + gC + U2 into one solid group. When we try:
merged = U1_copy.outer_shell(gC_copy)
two things can happen:
It works — seamless corner (what we want).
It fails — and on SU 2022 in particular, a boolean on a non-manifold group can silently wipe the entire parent Entities collection (container becomes empty). On older versions the fail is less destructive but still leaves broken geometry.
The root of the problem: FollowMe output is often non-manifold — especially when the path has a non-90° turn and the profile has no clean mitering. manifold? (where available) returns false, so our guard skips the merge entirely to stay safe.
Our current workaround:
# Bridge disabled — leaves a visible seam at the corner joint
Copies as shield: pass copies to outer_shell / union — originals survive on failure, but doesn’t fix the non-manifold geometry.
Both orderings:a.outer_shell(b) and b.outer_shell(a) — occasionally one succeeds, not reliably.
manifold? guard: reliable on SU 2022 to prevent wipe, but always returns false for FollowMe groups, so the merge never runs.
Questions:
Is there a reliable, version-safe way (SU 2017 through 2026) to get a seamless solid at the junction of two FollowMe cornice pieces that meet at an angle?
Is there a known technique to repair a FollowMe group into a true manifold solid before attempting a boolean? (e.g. explode + re-wrap, manual face construction at the miter joint, mesh-based approach?)
Has anyone used a pre-built miter cut (constructing the corner geometry directly from points/faces instead of FollowMe) to avoid the non-manifold problem at the junction entirely?
For plugins targeting SU 2017 through 2026: what is the safest boolean strategy that degrades gracefully on older versions where manifold? is not available?
Thanks — this is a real-world production plugin and any battle-tested approach is very welcome.
The textual description (without pictures and/or a model) is a bit vague about what exactly you are doing (wanting to do).
My first idea is:
What if you collect the 2D paths derived from the cabinet tops into a common array of edges and create a shape along these edges with Face#followme(edges)? That way, you don’t have to perform a solid operation, because one piece of cornice shape is created in the first place.
If I understand you correctly the main problem is followme which often fails for wide profiles and tight corners. There is a VERY old and quite poorly written script on Sketchucation that takes care of many of these special cases and produces solids where FollowMe fails.
Hello Dezmo and CAUL — thank you both for taking the time to reply; it really helps.
I’ll try to be more concrete about what we are building and where we are stuck, so your suggestions map cleanly to our pipeline.
What we want
We generate kitchen wall-cabinet compositions in Ruby (SketchUp 2017 → 2026+). On top of the cabinets we build a wood crown moulding using FollowMe: a 2D profile is swept along a path that follows the cabinet tops (plan view). In a straight run, we merge the resulting cornice groups with Solid Tools on copies, with manifold? guards — that path is stable.
The difficult case is a layout that includes our 90° corner wall unit (W_Corner90). The path around the corner is not a simple rectangle: the corner inherits a non‑zero base angle from the floor corner cabinet, so the turn on plan is skewed. FollowMe produces separate segments (left arm, corner segment, right arm). We then try to bridge them into one solid (outer_shell / union) for a seamless joint and reliable rendering — but FollowMe output is often manifold? == false, especially at non‑90° turns. On SU 2022, unsafe booleans can even empty the parent Entities if we are not extremely defensive.
What we have achieved so far
Robust guards (manifold? checks, operations on copies, safe ordering).
A corner bridge that, in our latest build, can fuse most of the cornice into one manifold group and removes the worst Z‑fighting / lighting shimmer.
For one residual skew case we still use a small separate “infill” wedge (triangle) because removing a kink from the main path was necessary to keep the main sweep manifold — touching solids don’t boolean cleanly when they only meet along an edge, so we stopped forcing outer_shell there.
So we are in the situation your answers point to: either one continuous sweep or a different repair strategy when FollowMe is the weak link.
Questions
For Dezmo — Face#followme(edges)
When you suggest collecting the 2D paths into a common array of edges and running Face#followme(edges), could you clarify the practical workflow for the API?
Should the profile face and all path edges live in the same Entities context before the call?
Are we meant to build one chained polyline (possibly with arcs as curve edges) that visits all cabinet tops in order, then sweep once — i.e. intentionally no per‑cabinet groups that we merge later?
Any caveats for tight or skewed corners with a relatively tall/wide moulding profile (the classic FollowMe failure modes)?
For CAUL — Sketchucation script
Thank you for the pointer. If you still recall the script name or a Sketchucation link, we’d like to study the techniques it uses for wide profiles and tight corners (we’re not looking to ship someone else’s code blindly — mainly ideas we can reimplement in a maintainable way for a commercial plugin).
Thanks again — happy to post a small SKP + snippet if pictures/model would make the corner case clearer.
The screenshot refers to a layout that uses the base corner cabinet together with the wall corner cabinet (W_Corner90) when the floor corner angle is not zero (the corner inherits a skewed angle from the base run). In that situation we still get visible joint / overlap issues where the crown-moulding segments meet at the inside corner (see arrows). When the angle is zero (rectangular corner, straight runs), we do not see this problem and the cornice behaves as expected.
Attached is the script and an example file with profiles + paths where followme fails and the script succeeds. You operate the script by selecting BOTH the profile and the path and run run the script from extensions->Followfy from the extensions menu. Output is a solid in a separate group.
The basic idea is this:
You have a planar path and a profile. Every vertex in the profile will trace an offset to the path at some height. The script supports a much more robust offset and then stitches the resulting offset paths into a solid. If Sketchup had provided API support for Sketchup’s native offset the script would have been much simpler and more robust. The script is old and very hacky but you can use whatever you find useful.
