extract features to folder

I'm calling "key features" anything that goes on the key that isn't artisanal, so legends, the clearance check, the bump, etc.

CHANGELOG.md

@@ -7,10 +7,7 @@ CHANGELOG:
     * created "hull" folder to house different ways of creating the overall key shape
     * promoted "feature" folder to first-class folder with keytext and switch clearance as new residents
     * wrote this changelog!
-    * implemented `$inner_shape_type`, use "flat" for less geometry or "disable" to make a completely solid key easily. didn't help render rounded keys though
+    * `flat_keytop_bottom` for less geometry. didn't help render rounded keys though
+    * still todo: add a magic scaling variable so you can scale the whole world up, see if that fixes degeneracy
     * side-printed keycaps are first class! you can use the `sideways()` modifier to set up sideways keycaps that have flat sides to print on.
     * it's much easier to make quick artisans now that the inside of the keycap is differenced from any additive features placed on top
-    * `$linear_extrude_shape` and `$skin_extrude_shape` retired in favor of `$hull_shape_type`
-    * still todo: add a magic scaling variable so you can scale the whole world up, see if that fixes degeneracy
-    * still todo: rejigger supports
-    * still todo: rejigger inner shape. maybe just always make it flat

README.md

@@ -60,7 +60,7 @@ You can chain as many modifier functions as you like!
 
 ## Modifier functions
 
-There is a bevy of supporting functions to customize your keycaps. You can add a brim to more easily print the stem with `brimmed_stem_support`, make 2x2 keycaps with `2u() 2uh()`, add legends, rotate stems, and more. All these functions manipulate the settings available to you in [`settings.scad`](https://github.com/rsheldiii/KeyV2/blob/master/src/settings.scad), though [some of them](https://github.com/rsheldiii/KeyV2/blob/851ececdb297c77bfbcd0a7cb4cdbc5e21970396/src/key_transformations.scad#L128) are quite complex.
+There is a bevy of supporting functions to customize your keycaps. You can add a brim to more easily print the stem with `brimmed_stem_support`, make 2x2 keycaps with `2u() 2uh()`, add legends, rotate stems, and more. All these functions manipulate the settings available to you in [`settings.scad`](https://github.com/rsheldiii/KeyV2/blob/master/src/settings.scad), though [some of them](https://github.com/rsheldiii/KeyV2/blob/master/src/key_transformations.scad#L128) are quite complex.
 
 These modifier functions can be found in [`key_profiles/`](https://github.com/rsheldiii/KeyV2/blob/master/src/key_profiles) for different keycap profiles, [`key_types.scad`](https://github.com/rsheldiii/KeyV2/blob/master/src/key_types.scad) for predefined settings for common keys (spacebar, left shift, etc), [`key_sizes.scad`](https://github.com/rsheldiii/KeyV2/blob/master/src/key_sizes.scad) for common unit sizes, and [`key_transformations.scad`](https://github.com/rsheldiii/KeyV2/blob/master/src/key_transformations.scad) for everything else. I encourage you to do some sleuthing but for a list of (most) helper functions with explanations, [Check out the wiki!](https://github.com/rsheldiii/KeyV2/wiki/KeyV2-Helper-Documentation)
 

TIPS_AND_TRICKS.md

@@ -14,7 +14,7 @@ At the end of the day though, all the columnular sculpting is doing is adding ex
 
 ## skin mode
 
-SA, HiPro and DSA keycaps take _forever_ to render. This is a multifaceted issue that I don't want to get into here, but suffice to say _one_ of the reasons it takes so long is how the keycap is constructed from multiple, smaller slices. OpenSCAD takes more time to render the more objects you have, regardless of how they interact. Enter `$hull_shape_type = "skin"`.
+SA, HiPro and DSA keycaps take _forever_ to render. This is a multifaceted issue that I don't want to get into here, but suffice to say _one_ of the reasons it takes so long is how the keycap is constructed from multiple, smaller slices. OpenSCAD takes more time to render the more objects you have, regardless of how they interact. Enter `$skin_extrude_shape = true`.
 
 `skin()` is a list comprehension function available [here](https://github.com/openscad/list-comprehension-demos/blob/master/skin.scad). The gist of it is that instead of having x number of keycap slices unioned together, we give `skin()` a set of profiles and it makes a single object out of it for us. This reduces the number of objects per keycap, which makes it easier to render them.
 

src/constants.scad

@@ -1,4 +1 @@
-// a safe theoretical distance between two vertices such that they don't collapse. hard to use
 SMALLEST_POSSIBLE = 1/128;
-$fs=0.1;
-$unit=19.05;

src/dishes/3d_surface.scad

@@ -1,14 +1,9 @@
-include <../libraries/3d_surface.scad>
-
 module 3d_surface_dish(width, height, depth, inverted) {
   echo(inverted ? "inverted" : "not inverted");
   // scale_factor is dead reckoning
-  // it doesn't have to be dead reckoning for anything but sculpted sides
-  // we know the angle of the sides from the width difference, height difference,
-  // skew and tilt of the top. it's a pain to calculate though
-  scale_factor = 1.1;
+  scale_factor = 1.2;
   // the edges on this behave differently than with the previous dish implementations
-  scale([width*scale_factor/$3d_surface_size/2,height*scale_factor/$3d_surface_size/2,depth]) rotate([inverted ? 0:180,0,180]) polar_3d_surface(bottom=-10);
+  scale([width*scale_factor/$3d_surface_size/2,height*scale_factor/$3d_surface_size/2,depth]) rotate([inverted ? 0:180,0,0]) polar_3d_surface(bottom=-10);
   /* %scale([width*scale_factor/$3d_surface_size/2,height*scale_factor/$3d_surface_size/2,depth]) rotate([180,0,0]) polar_3d_surface(bottom=-10); */
 
 }

src/features/legends.scad

@@ -2,7 +2,7 @@ module keytext(text, position, font_size, depth) {
   woffset = (top_total_key_width()/3.5) * position[0];
   hoffset = (top_total_key_height()/3.5) * -position[1];
   translate([woffset, hoffset, -depth]){
-    color($tertiary_color) linear_extrude(height=$dish_depth + depth){
+    color($tertiary_color) linear_extrude(height=$dish_depth){
       text(text=text, font=$font, size=font_size, halign="center", valign="center");
     }
   }

src/functions.scad

@@ -4,8 +4,6 @@ include <constants.scad>
 // functions need to be explicitly included, unlike special variables, which
 // just need to have been set before they are used. hence this file
 
-function stem_height() = $total_depth - $dish_depth - $stem_inset;
-
 // cherry stem dimensions
 function outer_cherry_stem(slop) = [7.2 - slop * 2, 5.5 - slop * 2];
 
@@ -42,27 +40,3 @@ function vertical_inclination_due_to_top_tilt() = sin($top_tilt) * (top_total_ke
 // of the keycap a flat plane. 1 = front, -1 = back
 // I derived this through a bunch of trig reductions I don't really understand.
 function extra_keytop_length_for_flat_sides() = ($width_difference * vertical_inclination_due_to_top_tilt()) / ($total_depth);
-
-// 3d surface functions (still in beta)
-
-// monotonically increasing function that distributes the points of the surface mesh
-// only for polar_3d_surface right now
-// if it's linear it's a grid. sin(dim) * size concentrates detail around the edges
-function surface_distribution_function(dim, size) = sin(dim) * size;
-
-// the function that actually determines what the surface is.
-// feel free to override, the last one wins
-
-// debug
-function surface_function(x,y) = 1;
-// cylindrical
-function surface_function(x,y) = (sin(acos(x/$3d_surface_size)));
-// spherical
-function surface_function(x,y) = (sin(acos(x/$3d_surface_size))) * sin(acos(y/$3d_surface_size));
-// (statically) random!
-// ripples
-/* function surface_function(x,y) = cos(pow(pow(x,2)+pow(y,2),0.5)*10)/4+0.75; */
-// Rosenbrock's banana
-/* function surface_function(x,y) = (pow(1-(x/100), 2) + 100 * pow((y/100)-pow((x/100),2),2))/200 + 0.1; */
-// y=x revolved around the y axis
-/* function surface_function(x,y) = 1/(pow(pow(x,2)+pow(y,2),0.5)/100 + .01); */

src/hulls.scad

@@ -8,9 +8,9 @@ include <hulls/hull.scad>
 // extra_slices is a hack to make inverted dishes still work
 module shape_hull(thickness_difference, depth_difference, extra_slices = 0){
   render() {
-    if ($hull_shape_type == "skin") {
+    if ($skin_extrude_shape) {
       skin_extrude_shape_hull(thickness_difference, depth_difference, extra_slices);
-    } else if ($hull_shape_type == "linear extrude") {
+    } else if ($linear_extrude_shape) {
       linear_extrude_shape_hull(thickness_difference, depth_difference, extra_slices);
     } else {
       hull_shape_hull(thickness_difference, depth_difference, extra_slices);

src/hulls/hull.scad

@@ -18,7 +18,7 @@ module shape_slice(progress, thickness_difference, depth_difference) {
 
   translate([x_skew_this_slice, skew_this_slice, depth_this_slice]) {
     rotate([tilt_this_slice,y_tilt_this_slice,0]){
-      linear_extrude(height = SMALLEST_POSSIBLE, scale = 1){
+      linear_extrude(height = SMALLEST_POSSIBLE + $minkowski_radius, scale = 0.1){
         key_shape(
           [
             total_key_width(thickness_difference),

src/hulls/linear_extrude.scad

@@ -9,8 +9,8 @@ module linear_extrude_shape_hull(thickness_difference, depth_difference, extra_s
     linear_extrude(height = height, scale = [width_scale, height_scale]) {
         translate([0,-$linear_extrude_height_adjustment,0]){
         key_shape(
-          [total_key_width(), total_key_height()],
-          [thickness_difference, thickness_difference]
+          [total_key_width(thickness_difference), total_key_height(thickness_difference)],
+          [$width_difference, $height_difference]
         );
       }
     }

src/key.scad

@@ -6,7 +6,6 @@ include <stem_supports.scad>
 include <dishes.scad>
 include <supports.scad>
 include <features.scad>
-include <hulls.scad>
 
 include <libraries/geodesic_sphere.scad>
 
@@ -16,100 +15,173 @@ use <libraries/scad-utils/lists.scad>
 use <libraries/scad-utils/shapes.scad>
 use <libraries/skin.scad>
 
+
 /* [Hidden] */
 SMALLEST_POSSIBLE = 1/128;
-// basically disable $fs - though it might be useful for these CGAL problems
-$fs = .01;
+$fs = .1;
 $unit = 19.05;
 
 // key shape including dish. used as the ouside and inside shape in hollow_key(). allows for itself to be shrunk in depth and width / height
 module shape(thickness_difference, depth_difference=0){
   dished(depth_difference, $inverted_dish) {
-    color($primary_color) shape_hull(thickness_difference, depth_difference, $inverted_dish ? 200 : 0);
+    color($primary_color) shape_hull(thickness_difference, depth_difference, $inverted_dish ? 2 : 0);
   }
 }
 
-// Not currently used due to CGAL errors. Rounds the shape via minkowski
+// shape of the key but with soft, rounded edges. no longer includes dish
+// randomly doesnt work sometimes
+// the dish doesn't _quite_ reach as far as it should
 module rounded_shape() {
+  dished(-$minkowski_radius, $inverted_dish) {
+    color($primary_color) minkowski(){
+      // half minkowski in the z direction
+      color($primary_color) shape_hull($minkowski_radius * 2, $minkowski_radius/2, $inverted_dish ? 2 : 0);
+      /* cube($minkowski_radius); */
+      sphere(r=$minkowski_radius, $fn=48);
+    }
+  }
+  /* %envelope(); */
+}
+
+// this function is more correct, but takes _forever_
+// the main difference is minkowski happens after dishing, meaning the dish is
+// also minkowski'd
+/* module rounded_shape() {
   color($primary_color) minkowski(){
     // half minkowski in the z direction
     shape($minkowski_radius * 2, $minkowski_radius/2);
-    minkowski_object();
-  }
-}
-
-// minkowski places this object at every vertex of the other object then mashes
-// it all together
-module minkowski_object() {
-  // alternative minkowski shape that needs the bottom of the keycap to be trimmed
-  /* sphere(1); */
-
-  difference(){
-    sphere(r=$minkowski_radius, $fa=360/$minkowski_facets);
-    translate([0,0,-$minkowski_radius]){
-      cube($minkowski_radius * 2, center=true);
-    }
-  }
-}
-
-module envelope(depth_difference=0) {
-  s = 1.5;
-  hull(){
-    cube([total_key_width() * s, total_key_height() * s, 0.01], center = true);
-    top_placement(SMALLEST_POSSIBLE + depth_difference){
-      cube([top_total_key_width() * s, top_total_key_height() * s, 0.01], center = true);
-    }
-  }
-}
-
-// for when you want to take the dish out of things
-// used for adding the dish to the key shape and making sure stems don't stick out the top
-// creates a bounding box 1.5 times larger in width and height than the keycap.
-module dished(depth_difference = 0, inverted = false) {
-  intersection() {
-    children();
     difference(){
-      union() {
-        // envelope is needed to "fill in" the rest of the keycap
-        envelope(depth_difference);
-        if (inverted) top_placement(depth_difference) _dish(inverted);
+      sphere(r=$minkowski_radius, $fn=20);
+      translate([0,0,-$minkowski_radius]){
+        cube($minkowski_radius * 2, center=true);
       }
-      if (!inverted) top_placement(depth_difference) _dish(inverted);
+    }
+  }
+} */
+
+
+
+// basic key shape, no dish, no inside
+// which is only used for dishing to cut the dish off correctly
+// $height_difference used for keytop thickness
+// extra_slices is a hack to make inverted dishes still work
+module shape_hull(thickness_difference, depth_difference, extra_slices = 0){
+  render() {
+    if ($skin_extrude_shape) {
+      skin_extrude_shape_hull(thickness_difference, depth_difference, extra_slices);
+    } else if ($linear_extrude_shape) {
+      linear_extrude_shape_hull(thickness_difference, depth_difference, extra_slices);
+    } else {
+      hull_shape_hull(thickness_difference, depth_difference, extra_slices);
     }
   }
 }
 
-// just to DRY up the code
-module _dish(inverted=$inverted_dish) {
-  color($secondary_color) dish(top_total_key_width() + $dish_overdraw_width, top_total_key_height() + $dish_overdraw_height, $dish_depth, inverted);
+// use skin() instead of successive hulls. much more correct, and looks faster
+// too, in most cases. successive hull relies on overlapping faces which are
+// not good. But, skin works on vertex sets instead of shapes, which makes it
+// a lot more difficult to use
+module skin_extrude_shape_hull(thickness_difference, depth_difference, extra_slices = 0 ) {
+  skin([
+    for (index = [0:$height_slices + extra_slices])
+      let(
+        progress = (index / $height_slices),
+        skew_this_slice = $top_skew * progress,
+        x_skew_this_slice = $top_skew_x * progress,
+        depth_this_slice = ($total_depth - depth_difference) * progress,
+        tilt_this_slice = -$top_tilt / $key_height * progress,
+        y_tilt_this_slice = $double_sculpted ? (-$top_tilt_y / $key_length * progress) : 0
+      )
+      skin_shape_slice(progress, thickness_difference, skew_this_slice, x_skew_this_slice, depth_this_slice, tilt_this_slice, y_tilt_this_slice)
+  ]);
 }
 
-// puts its children at each keystem position provided
-module keystem_positions(positions) {
-  for (connector_pos = positions) {
-    translate(connector_pos) {
-      rotate([0, 0, $stem_rotation]){
-        children();
+function skin_shape_slice(progress, thickness_difference, skew_this_slice, x_skew_this_slice, depth_this_slice, tilt_this_slice, y_tilt_this_slice) =
+  transform(
+    translation([x_skew_this_slice,skew_this_slice,depth_this_slice]),
+    transform(
+      rotation([tilt_this_slice,y_tilt_this_slice,0]),
+        skin_key_shape([
+          total_key_width(0),
+          total_key_height(0),
+          ],
+          [$width_difference, $height_difference],
+          progress,
+          thickness_difference
+        )
+    )
+  );
+
+// corollary is hull_shape_hull
+// extra_slices unused, only to match argument signatures
+module linear_extrude_shape_hull(thickness_difference, depth_difference, extra_slices = 0){
+  height = $total_depth - depth_difference;
+  width_scale = top_total_key_width() / total_key_width();
+  height_scale = top_total_key_height() / total_key_height();
+
+  translate([0,$linear_extrude_height_adjustment,0]){
+    linear_extrude(height = height, scale = [width_scale, height_scale]) {
+        translate([0,-$linear_extrude_height_adjustment,0]){
+        key_shape(
+          [total_key_width(thickness_difference), total_key_height(thickness_difference)],
+          [$width_difference, $height_difference]
+        );
       }
     }
   }
 }
 
-module support_for(positions, stem_type) {
-  keystem_positions(positions) {
-    color($tertiary_color) supports($support_type, stem_type, $stem_throw, $total_depth - $stem_throw);
+module hull_shape_hull(thickness_difference, depth_difference, extra_slices = 0) {
+  for (index = [0:$height_slices - 1 + extra_slices]) {
+    hull() {
+      shape_slice(index / $height_slices, thickness_difference, depth_difference);
+      shape_slice((index + 1) / $height_slices, thickness_difference, depth_difference);
+    }
   }
 }
 
-module stems_for(positions, stem_type) {
-  keystem_positions(positions) {
-    color($tertiary_color) stem(stem_type, stem_height(), $stem_slop);
-    if ($stem_support_type != "disable") {
-      color($quaternary_color) stem_support($stem_support_type, stem_type, $stem_support_height, $stem_slop);
+module shape_slice(progress, thickness_difference, depth_difference) {
+  skew_this_slice = $top_skew * progress;
+  x_skew_this_slice = $top_skew_x * progress;
+
+  depth_this_slice = ($total_depth - depth_difference) * progress;
+
+  tilt_this_slice = -$top_tilt / $key_height * progress;
+  y_tilt_this_slice = $double_sculpted ? (-$top_tilt_y / $key_length * progress) : 0;
+
+  translate([x_skew_this_slice, skew_this_slice, depth_this_slice]) {
+    rotate([tilt_this_slice,y_tilt_this_slice,0]){
+      linear_extrude(height = SMALLEST_POSSIBLE){
+        key_shape(
+          [
+            total_key_width(thickness_difference),
+            total_key_height(thickness_difference)
+          ],
+          [$width_difference, $height_difference],
+          progress
+        );
+      }
     }
   }
 }
 
+// for when you want something to only exist inside the keycap.
+// used for the support structure
+module inside() {
+  intersection() {
+    shape($wall_thickness, $keytop_thickness);
+    children();
+  }
+}
+
+// for when you want something to only exist outside the keycap
+module outside() {
+  difference() {
+    children();
+    shape($wall_thickness, $keytop_thickness);
+  }
+}
+
 // put something at the top of the key, with no adjustments for dishing
 module top_placement(depth_difference=0) {
   top_tilt_by_height = -$top_tilt / $key_height;
@@ -124,20 +196,7 @@ module top_placement(depth_difference=0) {
   }
 }
 
-// puts its children at the center of the dishing on the key, including dish height
-// more user-friendly than top_placement
-module top_of_key(){
-  // if there is a dish, we need to account for how much it digs into the top
-  dish_depth = ($dish_type == "disable") ? 0 : $dish_depth;
-  // if the dish is inverted, we need to account for that too. in this case we do half, otherwise the children would be floating on top of the dish
-  corrected_dish_depth = ($inverted_dish) ? -dish_depth / 2 : dish_depth;
-
-  top_placement(corrected_dish_depth) {
-    children();
-  }
-}
-
-module front_of_key() {
+module front_placement() {
   // all this math is to take top skew and tilt into account
   // we need to find the new effective height and depth of the top, front lip
   // of the keycap to find the angle so we can rotate things correctly into place
@@ -156,95 +215,172 @@ module front_of_key() {
   }
 }
 
-module outer_shape() {
-  shape(0, 0);
+// just to DRY up the code
+module _dish() {
+  color($secondary_color) dish(top_total_key_width() + $dish_overdraw_width, top_total_key_height() + $dish_overdraw_height, $dish_depth, $inverted_dish);
 }
 
-module inner_shape(extra_wall_thickness = 0, extra_keytop_thickness = 0) {
-  if ($inner_shape_type == "flat") {
-    /* $key_shape_type="square"; */
-    $height_slices = 1;
-    color($primary_color) shape_hull($wall_thickness + extra_wall_thickness, $keytop_thickness + extra_keytop_thickness, 0);
-  } else {
-    shape($wall_thickness + extra_wall_thickness, $keytop_thickness + extra_keytop_thickness);
+module envelope(depth_difference=0) {
+  s = 1.5;
+  hull(){
+    cube([total_key_width() * s, total_key_height() * s, 0.01], center = true);
+    top_placement(SMALLEST_POSSIBLE + depth_difference){
+      cube([top_total_key_width() * s, top_total_key_height() * s, 0.01], center = true);
+    }
   }
 }
 
-// additive objects at the top of the key
-module additive_features(inset) {
-  top_of_key() {
-    if($key_bump) keybump($key_bump_depth, $key_bump_edge);
-    if(!inset && $children > 0) color($secondary_color) children();
-  }
-  if($outset_legends) legends(0);
-  // render the clearance check if it's enabled, but don't have it intersect with anything
-  if ($clearance_check) %clearance_check();
-}
-
-// subtractive objects at the top of the key
-module subtractive_features(inset) {
-  top_of_key() {
-    if (inset && $children > 0) color($secondary_color) children();
-  }
-  if(!$outset_legends) legends($inset_legend_depth);
-  // subtract the clearance check if it's enabled, letting the user see the
-  // parts of the keycap that will hit the cherry switch
-  // this is a little confusing as it eats the stem too
-  /* if ($clearance_check) clearance_check(); */
-}
-
-// all stems and stabilizers
-module stems_and_stabilizers() {
-  translate([0, 0, $stem_inset]) {
-    if ($stabilizer_type != "disable") stems_for($stabilizers, $stabilizer_type);
-    if ($stem_type != "disable") stems_for($stem_positions, $stem_type);
+// I think this is unused
+module dished_for_show() {
+  difference(){
+    union() {
+      envelope();
+      if ($inverted_dish) top_placement(0) _dish();
+    }
+    if (!$inverted_dish) top_placement(0) _dish();
   }
 }
 
-// features inside the key itself (stem, supports, etc)
-module inside_features() {
-  // Stems and stabilizers are not "inside features" unless they are fully
-  // contained inside the cap. otherwise they'd be cut off when they are
-  // differenced with the outside shape
-  if ($stem_inset >= 0) stems_and_stabilizers();
-  if ($support_type != "disable") translate([0, 0, $stem_inset]) support_for($stem_positions, $stem_type);
-}
 
-// helpers for doubleshot keycaps for now
-module inner_total_shape() {
-  difference() {
-    inner_shape();
-    inside_features();
-  }
-}
-
-module outer_total_shape(inset=false) {
-  outer_shape();
-  additive_features(inset) {
+// for when you want to take the dish out of things
+// used for adding the dish to the key shape and making sure stems don't stick out the top
+// creates a bounding box 1.5 times larger in width and height than the keycap.
+module dished(depth_difference = 0, inverted = false) {
+  intersection() {
     children();
-  };
+    difference(){
+      union() {
+        envelope(depth_difference);
+        if (inverted) top_placement(depth_difference) _dish();
+      }
+      if (!inverted) top_placement(depth_difference) _dish();
+    }
+  }
 }
 
+// puts it's children at the center of the dishing on the key, including dish height
+// more user-friendly than top_placement
+module top_of_key(){
+  // if there is a dish, we need to account for how much it digs into the top
+  dish_depth = ($dish_type == "disable") ? 0 : $dish_depth;
+  // if the dish is inverted, we need to account for that too. in this case we do half, otherwise the children would be floating on top of the dish
+  corrected_dish_depth = ($inverted_dish) ? -dish_depth / 2 : dish_depth;
+
+  top_placement(corrected_dish_depth) {
+    children();
+  }
+}
+
+module keystem_positions(positions) {
+  for (connector_pos = positions) {
+    translate(connector_pos) {
+      rotate([0, 0, $stem_rotation]){
+        children();
+      }
+    }
+  }
+}
+
+module support_for(positions, stem_type) {
+  keystem_positions(positions) {
+    color($tertiary_color) supports($support_type, stem_type, $stem_throw, $total_depth - $stem_throw);
+  }
+}
+
+module stems_for(positions, stem_type) {
+  keystem_positions(positions) {
+    color($tertiary_color) stem(stem_type, $total_depth, $stem_slop);
+    if ($stem_support_type != "disable") {
+      color($quaternary_color) stem_support($stem_support_type, stem_type, $stem_support_height, $stem_slop);
+    }
+  }
+}
+
+    }
+  }
+}
+
+      }
+    }
+  }
+}
+
+  }
+    }
+  }
+}
+
+// legends / artisan support
+module artisan(depth) {
+  top_of_key() {
+    // artisan objects / outset shape legends
+    color($secondary_color) children();
+  }
+}
+
+// key with hollowed inside but no stem
+module hollow_key() {
+  difference(){
+    if ($rounded_key) {
+      rounded_shape();
+    } else {
+      shape(0, 0);
+    }
+    // translation purely for aesthetic purposes, to get rid of that awful lattice
+    translate([0,0,-SMALLEST_POSSIBLE]) {
+      shape($wall_thickness, $keytop_thickness);
+    }
+  }
+}
+
+
 // The final, penultimate key generation function.
 // takes all the bits and glues them together. requires configuration with special variables.
-module key(inset=false) {
-  difference(){
-    outer_total_shape(inset);
-
-    if ($inner_shape_type != "disable") {
-      translate([0,0,-SMALLEST_POSSIBLE]) {
-        inner_total_shape();
-      }
+module key(inset = false) {
+  difference() {
+    union(){
+      // the shape of the key, inside and out
+      hollow_key();
+      if($key_bump) top_of_key() keybump($key_bump_depth, $key_bump_edge);
+      // additive objects at the top of the key
+      // outside() makes them stay out of the inside. it's a bad name
+      if(!inset && $children > 0) outside() artisan(0) children();
+      if($outset_legends) legends(0);
+      // render the clearance check if it's enabled, but don't have it intersect with anything
+      if ($clearance_check) %clearance_check();
     }
 
-    subtractive_features(inset) {
-      children();
-    };
+    // subtractive objects at the top of the key
+    // no outside() - I can't think of a use for it. will save render time
+    if (inset && $children > 0) artisan($inset_legend_depth) children();
+    if(!$outset_legends) legends($inset_legend_depth);
+    // subtract the clearance check if it's enabled, letting the user see the
+    // parts of the keycap that will hit the cherry switch
+    if ($clearance_check) %clearance_check();
   }
 
-  // if $stem_inset is less than zero, we add the
-  if ($stem_inset < 0) {
-    stems_and_stabilizers();
+  // both stem and support are optional
+  if ($stem_type != "disable" || ($stabilizers != [] && $stabilizer_type != "disable")) {
+    dished($keytop_thickness, $inverted_dish) {
+      translate([0, 0, $stem_inset]) {
+        if ($stabilizer_type != "disable") stems_for($stabilizers, $stabilizer_type);
+
+        if ($stem_type != "disable") stems_for($stem_positions, $stem_type);
+      }
+    }
+  }
+
+  if ($support_type != "disable"){
+    inside() {
+      translate([0, 0, $stem_inset]) {
+        if ($stabilizer_type != "disable") support_for($stabilizers, $stabilizer_type);
+
+        // always render stem support even if there isn't a stem.
+        // rendering flat support w/no stem is much more common than a hollow keycap
+        // so if you want a hollow keycap you'll have to turn support off entirely
+        support_for($stem_positions, $stem_type);
+      }
+    }
   }
 }
 

src/key_features.scad

@@ -1 +0,0 @@
-include <features/key_bump.scad>

src/key_profiles.scad

@@ -9,7 +9,6 @@ include <key_profiles/sa.scad>
 include <key_profiles/g20.scad>
 include <key_profiles/hipro.scad>
 include <key_profiles/grid.scad>
-include <key_profiles/regular_polygon.scad>
 
 // man, wouldn't it be so cool if functions were first order
 module key_profile(key_profile_type, row, column=0) {
@@ -27,10 +26,6 @@ module key_profile(key_profile_type, row, column=0) {
     hipro_row(row, column) children();
   } else if (key_profile_type == "grid") {
     grid_row(row, column) children();
-  } else if (key_profile_type == "hexagon") {
-    hexagonal_row(row, column) children();
-  } else if (key_profile_type == "octagon") {
-    octagonal_row(row, column) children();
   } else if (key_profile_type == "disable") {
     children();
   } else {

src/key_profiles/grid.scad

@@ -11,7 +11,7 @@ module grid_row(row=3, column = 0) {
   $dish_skew_x = 0;
   $dish_skew_y = 0;
 
-  $hull_shape_type = "linear extrude";
+  $linear_extrude_shape = true;
 
 
   $dish_overdraw_width = -8;

src/key_profiles/regular_polygon.scad

@@ -1,66 +0,0 @@
-include <../constants.scad>
-// Regular polygon shapes CIRCUMSCRIBE the sphere of diameter $bottom_key_width
-// This is to make tiling them easier, like in the case of hexagonal keycaps etc
-
-// this function doesn't set the key shape, so you can't use it directly without some fiddling
-module regular_polygon_row(n=3, column=0) {
-  $bottom_key_width = $unit - 0.5;
-  $bottom_key_height = $unit - 0.5;
-  $width_difference = 0;
-  $height_difference = 0;
-  $dish_type = "spherical";
-  $dish_depth = 0.85;
-  $dish_skew_x = 0;
-  $dish_skew_y = 0;
-  $top_skew = 0;
-  $height_slices = 1;
-  $corner_radius = 1;
-
-  // this is _incredibly_ intensive
-  /* $rounded_key = true; */
-
-  $top_tilt_y = side_tilt(column);
-  extra_height = $double_sculpted ? extra_side_tilt_height(column) : 0;
-
-  base_depth = 7.5;
-  if (n <= 1){
-    $total_depth = base_depth + 2.5 + extra_height;
-    $top_tilt = -13;
-
-    children();
-  } else if (n == 2) {
-    $total_depth = base_depth + 0.5 + extra_height;
-    $top_tilt = -7;
-
-    children();
-  } else if (n == 3) {
-    $total_depth = base_depth + extra_height;
-    $top_tilt = 0;
-
-    children();
-  } else if (n == 4){
-    $total_depth = base_depth + 0.5 + extra_height;
-    $top_tilt = 7;
-
-    children();
-  } else {
-    $total_depth = base_depth + extra_height;
-    $top_tilt = 0;
-
-    children();
-  }
-}
-
-module hexagonal_row(n=3, column=0) {
-  $key_shape_type = "hexagon";
-  regular_polygon_row(n,column) {
-    children();
-  }
-}
-
-module octagonal_row(n=3, column=0) {
-  $key_shape_type = "octagon";
-  regular_polygon_row(n, column) {
-    children();
-  }
-}

src/key_transformations.scad

@@ -1,9 +1,10 @@
 // kind of a catch-all at this point for any directive that doesn't fit in the other files
 
-include <constants.scad>
+//TODO duplicate def to not make this a special var. maybe not worth it
+unit = 19.05;
 
 module translate_u(x=0, y=0, z=0){
-  translate([x * $unit, y*$unit, z*$unit]) children();
+  translate([x * unit, y*unit, z*unit]) children();
 }
 
 module no_stem_support() {

src/key_types.scad

@@ -46,7 +46,7 @@ module iso_enter() {
   $top_tilt = 0;
   $stem_support_type = "disable";
   $key_shape_type = "iso_enter";
-  /* $hull_shape_type = "linear extrude"; */
+  /* $linear_extrude_shape = true; */
   $linear_extrude_height_adjustment = 19.05 * 0.5;
   // this equals (unit_length(1.5) - unit_length(1.25)) / 2
   $dish_overdraw_width = 2.38125;

src/layouts/lets_split/default.scad

@@ -1,7 +1,7 @@
 include <../layout.scad>
 
 // negative numbers are used for spacing
-lets_split_layout = [
+lets_split_mapping = [
   [1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1],
   [1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1],
   [1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1],
@@ -9,5 +9,5 @@ lets_split_layout = [
 ];
 
 module lets_split_default(profile) {
-  layout(lets_split_layout, profile, row_sculpting_offset=1) children();
+  layout(lets_split_mapping, profile, row_sculpting_offset=1) children();
 }

src/libraries/3d_surface.scad

@@ -0,0 +1,76 @@
+include <../functions.scad>
+
+module 3d_surface(size=$3d_surface_size, step=$3d_surface_step, bottom=-SMALLEST_POSSIBLE){
+  function p(x, y) = [ x, y, surface_function(x, y) ];
+  function p0(x, y) = [ x, y, bottom ];
+  function rev(b, v) = b ? v : [ v[3], v[2], v[1], v[0] ];
+  function face(x, y) = [ p(x, y + step), p(x + step, y + step), p(x + step, y), p(x + step, y), p(x, y), p(x, y + step) ];
+  function fan(a, i) =
+        a == 0 ? [ [ 0, 0, bottom ], [ i, -size, bottom ], [ i + step, -size, bottom ] ]
+      : a == 1 ? [ [ 0, 0, bottom ], [ i + step,  size, bottom ], [ i,  size, bottom ] ]
+      : a == 2 ? [ [ 0, 0, bottom ], [ -size, i + step, bottom ], [ -size, i, bottom ] ]
+      :          [ [ 0, 0, bottom ], [  size, i, bottom ], [  size, i + step, bottom ] ];
+  function sidex(x, y) = [ p0(x, y), p(x, y), p(x + step, y), p0(x + step, y) ];
+  function sidey(x, y) = [ p0(x, y), p(x, y), p(x, y + step), p0(x, y + step) ];
+
+  points = flatten(concat(
+      // top surface
+      [ for (x = [ -size : step : size - step ], y = [ -size : step : size - step ]) face(x, y) ],
+      // bottom surface as triangle fan
+      [ for (a = [ 0 : 3 ], i = [ -size : step : size - step ]) fan(a, i) ],
+      // sides
+      [ for (x = [ -size : step : size - step ], y = [ -size, size ]) rev(y < 0, sidex(x, y)) ],
+      [ for (y = [ -size : step : size - step ], x = [ -size, size ]) rev(x > 0, sidey(x, y)) ]
+  ));
+
+  tcount = 2 * pow(2 * size / step, 2) + 8 * size / step;
+  scount = 8 * size / step;
+
+  tfaces = [ for (a = [ 0 : 3 : 3 * (tcount - 1) ] ) [ a, a + 1, a + 2 ] ];
+  sfaces = [ for (a = [ 3 * tcount : 4 : 3 * tcount + 4 * scount ] ) [ a, a + 1, a + 2, a + 3 ] ];
+  faces = concat(tfaces, sfaces);
+
+  polyhedron(points, faces, convexity = 8);
+}
+
+module polar_3d_surface(size=$3d_surface_size, step=$3d_surface_step, bottom=-SMALLEST_POSSIBLE){
+  function to_polar(q) = q * (90 / size);
+
+  function p(x, y) = [
+    surface_distribution_function(to_polar(x)),
+    surface_distribution_function(to_polar(y)),
+    surface_function(surface_distribution_function(to_polar(x)), surface_distribution_function(to_polar(y)))
+  ];
+  function p0(x, y) = [ x, y, bottom ];
+  function rev(b, v) = b ? v : [ v[3], v[2], v[1], v[0] ];
+  function face(x, y) = [ p(x, y + step), p(x + step, y + step), p(x + step, y), p(x + step, y), p(x, y), p(x, y + step) ];
+  function fan(a, i) =
+        a == 0 ? [ [ 0, 0, bottom ], [ i, -size, bottom ], [ i + step, -size, bottom ] ]
+      : a == 1 ? [ [ 0, 0, bottom ], [ i + step,  size, bottom ], [ i,  size, bottom ] ]
+      : a == 2 ? [ [ 0, 0, bottom ], [ -size, i + step, bottom ], [ -size, i, bottom ] ]
+      :          [ [ 0, 0, bottom ], [  size, i, bottom ], [  size, i + step, bottom ] ];
+  function sidex(x, y) = [ p0(x, y), p(x, y), p(x + step, y), p0(x + step, y) ];
+  function sidey(x, y) = [ p0(x, y), p(x, y), p(x, y + step), p0(x, y + step) ];
+
+  points = flatten(concat(
+      // top surface
+      [ for (x = [ -size : step : size - step ], y = [ -size : step : size - step ]) face(x, y) ],
+      // bottom surface as triangle fan
+      [ for (a = [ 0 : 3 ], i = [ -size : step : size - step ]) fan(a, i) ],
+      // sides
+      [ for (x = [ -size : step : size - step ], y = [ -size, size ]) rev(y < 0, sidex(x, y)) ],
+      [ for (y = [ -size : step : size - step ], x = [ -size, size ]) rev(x > 0, sidey(x, y)) ]
+  ));
+
+  tcount = 2 * pow(2 * size / step, 2) + 8 * size / step;
+  scount = 8 * size / step;
+
+  tfaces = [ for (a = [ 0 : 3 : 3 * (tcount - 1) ] ) [ a, a + 1, a + 2 ] ];
+  sfaces = [ for (a = [ 3 * tcount : 4 : 3 * tcount + 4 * scount ] ) [ a, a + 1, a + 2, a + 3 ] ];
+  faces = concat(tfaces, sfaces);
+
+  polyhedron(points, faces, convexity = 8);
+}
+
+function surface_distribution_function(dim) = sin(dim) * $3d_surface_size;
+function surface_function(x,y) = (sin(acos(x/$3d_surface_size))) * sin(acos(y/$3d_surface_size));

src/libraries/rounded_rectangle_profile.scad

@@ -1,35 +1,17 @@
+function rounded_rectangle_profile(size=[1,1],r=1,fn=32) = [
+	for (index = [0:fn-1])
+		let(a = index/fn*360)
+			r * [cos(a), sin(a)]
+			+ sign_x(index, fn) * [size[0]/2-r,0]
+			+ sign_y(index, fn) * [0,size[1]/2-r]
+];
+
 function sign_x(i,n) =
-	i < n/4 || i > n*3/4  ?  1 :
-	i > n/4 && i < n*3/4  ? -1 :
+	i < n/4 || i > n-n/4  ?  1 :
+	i > n/4 && i < n-n/4  ? -1 :
 	0;
 
 function sign_y(i,n) =
 	i > 0 && i < n/2  ?  1 :
 	i > n/2 ? -1 :
 	0;
-
-
-function rectangle_profile(size=[1,1],fn=32) = [
-	for (index = [0:fn-1])
-		let(a = index/fn*360)
-			sign_x(index, fn) * [size[0]/2,0]
-			+ sign_y(index, fn) * [0,size[1]/2]
-];
-
-function rounded_rectangle_profile(size=[1,1],r=1,fn=32) = [
-	let(max_fn = max(fn,8))
-		for (index = [0:max_fn-1])
-			let(a = index/max_fn*360)
-				r * [cos(a), sin(a)]
-				+ sign_x(index, max_fn) * [size[0]/2-r,0]
-				+ sign_y(index, max_fn) * [0,size[1]/2-r]
-];
-
-function double_rounded_rectangle_profile(size=[1,1], r=1, fn=32) = [
-	let(max_fn = max(fn,8))
-		for (index = [0:max_fn-1])
-			let(a = index/max_fn*360)
-				r * [cos(a), sin(a)]
-				+ sign_x(index, max_fn) * [size[0]/2-r,0]
-				+ sign_y(index, max_fn) * [0,size[1]/2-r]
-];

src/settings.scad

@@ -74,7 +74,6 @@ $rounded_cherry_stem_d = 5.5;
 
 // How much higher the stem is than the bottom of the keycap.
 // Inset stem requires support but is more accurate in some profiles
-// can be negative to make outset stems!
 $stem_inset = 0;
 // How many degrees to rotate the stems. useful for sideways keycaps, maybe
 $stem_rotation = 0;
@@ -87,7 +86,7 @@ $extra_long_stem_support = false;
 
 // Key shape type, determines the shape of the key. default is 'rounded square'
 $key_shape_type = "rounded_square";
-// ISO enter needs to be linear extruded NOT from the center when not using skin. this tells the program how far up 'not from the center' is
+// ISO enter needs to be linear extruded NOT from the center. this tells the program how far up 'not from the center' is
 $linear_extrude_height_adjustment = 0;
 // How many slices will be made, to approximate curves on corners. Leave at 1 if you are not curving corners
 // If you're doing fancy bowed keycap sides, this controls how many slices you take
@@ -119,10 +118,12 @@ $font="DejaVu Sans Mono:style=Book";
 // Whether or not to render fake keyswitches to check clearances
 $clearance_check = false;
 // Should be faster, also required for concave shapes
+// Use linear_extrude instead of hull slices to make the shape of the key
+$linear_extrude_shape = false;
 
-// what kind of extrusion we use to create the keycap. "hull" is standard, "linear extrude" is legacy, "skin" is new and not well supported.
-$hull_shape_type = "hull"; // ["hull", "linear extrude", "skin"]
-
+// warns in trajectory.scad but it looks benign
+// brand new, more correct, hopefully faster, lots more work
+$skin_extrude_shape = false;
 // This doesn't work very well, but you can try
 $rounded_key = false;
 //minkowski radius. radius of sphere used in minkowski sum for minkowski_key function. 1.75 for G20
@@ -182,16 +183,3 @@ $secondary_color = [.4412, .7, .3784];
 $tertiary_color = [1, .6941, .2];
 $quaternary_color = [.4078, .3569, .749];
 $warning_color = [1,0,0, 0.15];
-
-// how many facets circles will have when used in these features
-$minkowski_facets = 30;
-$shape_facets =30;
-
-// 3d surface settings
-// unused for now
-$3d_surface_size = 100;
-// resolution in each axis. 10 = 10 divisions per x/y = 100 points total
-$3d_surface_step = 5;
-
-// "flat" / "dished" / "disable"
-$inner_shape_type = "flat";

src/shapes.scad

@@ -1,10 +1,11 @@
-include <constants.scad>
+$fs=.1;
+unit = 19.05;
+
 include <shapes/ISO_enter.scad>
 include <shapes/sculpted_square.scad>
 include <shapes/rounded_square.scad>
 include <shapes/square.scad>
 include <shapes/oblong.scad>
-include <shapes/regular_polygon.scad>
 
 // size: at progress 0, the shape is supposed to be this size
 // delta: at progress 1, the keycap is supposed to be size - delta
@@ -24,10 +25,6 @@ module key_shape(size, delta, progress = 0) {
     square_shape(size, delta, progress);
   } else if ($key_shape_type == "oblong") {
     oblong_shape(size, delta, progress);
-  } else if ($key_shape_type == "hexagon") {
-    regular_polygon_shape(size, delta, progress);
-  } else if ($key_shape_type == "octagon") {
-    regular_polygon_shape(size, delta, progress, sides=8);
   } else {
     echo("Warning: unsupported $key_shape_type");
   }
@@ -35,11 +32,9 @@ module key_shape(size, delta, progress = 0) {
 
 function skin_key_shape(size, delta, progress = 0, thickness_difference) =
   $key_shape_type == "rounded_square" ?
-    skin_rounded_square(size, delta, progress, thickness_difference) :
+    skin_rounded_square(size, delta, progress) :
     $key_shape_type == "sculpted_square" ?
-      skin_sculpted_square_shape(size, delta, progress, thickness_difference) :
-    $key_shape_type == "square" ?
-      skin_square_shape(size, delta, progress, thickness_difference) :
+      skin_sculpted_square_shape(size, delta, progress) :
     $key_shape_type == "iso_enter" ?
       skin_iso_enter_shape(size, delta, progress, thickness_difference) :
       echo("Warning: unsupported $key_shape_type for skin shape. disable skin_extrude_shape or pick a new shape");

src/shapes/ISO_enter.scad

@@ -2,7 +2,6 @@
 // NOT 3D
 function unit_length(length) = unit * (length - 1) + 18.16;
 
-
 module ISO_enter_shape(size, delta, progress){
   width = size[0];
   height = size[1];
@@ -17,21 +16,19 @@ module ISO_enter_shape(size, delta, progress){
   width_ratio = unit_length(1.25) / unit_length(1.5);
   height_ratio = unit_length(1) / unit_length(2);
 
-  delta = delta / 2;
-
   pointArray = [
-      [                   0-delta.x,                     0-delta.y], // top right
-      [                   0-delta.x,               -height+delta.y], // bottom right
-      [-width * width_ratio+delta.x,               -height+delta.y], // bottom left
-      [-width * width_ratio + delta.x,-height * height_ratio+delta.y], // inner middle point
-      [              -width + delta.x,-height * height_ratio + delta.y], // outer middle point
-      [              -width + delta.x,                     0-delta.y]  // top left
+      [                   0,                     0], // top right
+      [                   0,               -height], // bottom right
+      [-width * width_ratio,               -height], // bottom left
+      [-width * width_ratio,-height * height_ratio], // inner middle point
+      [              -width,-height * height_ratio], // outer middle point
+      [              -width,                     0]  // top left
   ];
 
   minkowski(){
-    circle(r=$corner_radius);
+    circle(r=corner_size);
     // gives us rounded inner corner
-    offset(r=-$corner_radius*2) {
+    offset(r=-corner_size*2) {
       translate([(width * width_ratio)/2, height/2]) polygon(points=pointArray);
     }
   }

src/shapes/regular_polygon.scad

@@ -1,14 +0,0 @@
-// we do this weird key_shape_type check here because rounded_square uses
-// square_shape, and we want flat sides to work for that too.
-// could be refactored, idk
-module regular_polygon_shape(size, delta, progress, sides=6){
-  // https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/undersized_circular_objects
-  fudge = 1/cos(180/sides);
-  diameter = (size.x - delta.x * progress - $corner_radius*2) * fudge;
-  offset(r=$corner_radius) rotate([0,0,360/sides/2]) circle(d = diameter, $fn=sides);
-}
-
-
-
-// TODO not implemented
-function skin_regular_polygon_shape(size, delta, progress, thickness_difference, sides=6) = echo("skin regular polygon not implemented");

src/shapes/rounded_square.scad

@@ -1,12 +1,12 @@
 include <../libraries/rounded_rectangle_profile.scad>
 
 module rounded_square_shape(size, delta, progress, center = true) {
-  offset(r=$corner_radius, $fa=360/$shape_facets){
+  offset(r=$corner_radius){
     square_shape([size.x - $corner_radius*2, size.y - $corner_radius*2], delta, progress);
   }
 }
 
 // for skin
 
-function skin_rounded_square(size, delta, progress, thickness_difference) =
-  rounded_rectangle_profile(size - (delta * progress) - [thickness_difference, thickness_difference], fn=$shape_facets, r=$corner_radius);
+function skin_rounded_square(size, delta, progress) =
+  rounded_rectangle_profile(size - (delta * progress), fn=36, r=$corner_radius);

src/shapes/sculpted_square.scad

@@ -37,7 +37,7 @@ module sculpted_square_shape(size, delta, progress) {
     height - extra_height_this_slice
   ];
 
-  offset(r = extra_corner_radius_this_slice, $fa=360/$shape_facets) {
+  offset(r = extra_corner_radius_this_slice) {
     offset(r = -extra_corner_radius_this_slice) {
       side_rounded_square(square_size, r = $more_side_sculpting_factor * progress);
     }
@@ -46,7 +46,7 @@ module sculpted_square_shape(size, delta, progress) {
 
 // fudging the hell out of this, I don't remember what the negative-offset-positive-offset was doing in the module above
 // also no 'bowed' square shape for now
-function skin_sculpted_square_shape(size, delta, progress, thickness_difference) =
+function skin_sculpted_square_shape(size, delta, progress) =
   let(
     width = size[0],
     height = size[1],
@@ -64,10 +64,10 @@ function skin_sculpted_square_shape(size, delta, progress, thickness_difference)
     extra_corner_radius_this_slice = ($corner_radius + extra_corner_size),
 
     square_size = [
-      width - extra_width_this_slice - thickness_difference,
-      height - extra_height_this_slice - thickness_difference
+      width - extra_width_this_slice,
+      height - extra_height_this_slice
     ]
-  ) double_rounded_rectangle_profile(square_size - [extra_corner_radius_this_slice, extra_corner_radius_this_slice]/4, fn=$shape_facets, r=extra_corner_radius_this_slice/1.5 + $more_side_sculpting_factor * progress);
+  ) rounded_rectangle_profile(square_size - [extra_corner_radius_this_slice, extra_corner_radius_this_slice]/4, fn=36, r=extra_corner_radius_this_slice/1.5 + $more_side_sculpting_factor * progress);
 
   /* offset(r = extra_corner_radius_this_slice) {
     offset(r = -extra_corner_radius_this_slice) {
@@ -85,10 +85,10 @@ module side_rounded_square(size, r) {
     sw = iw / resolution;
     union() {
       if (sr > 0) {
-        translate([-iw/2, 0]) scale([sr, sh]) circle(d = resolution, $fa=360/$shape_facets);
-        translate([iw/2, 0]) scale([sr, sh]) circle(d = resolution, $fa=360/$shape_facets);
-        translate([0, -ih/2]) scale([sw, sr]) circle(d = resolution, $fa=360/$shape_facets);
-        translate([0, ih/2]) scale([sw, sr]) circle(d = resolution, $fa=360/$shape_facets);
+        translate([-iw/2, 0]) scale([sr, sh]) circle(d = resolution);
+        translate([iw/2, 0]) scale([sr, sh]) circle(d = resolution);
+        translate([0, -ih/2]) scale([sw, sr]) circle(d = resolution);
+        translate([0, ih/2]) scale([sw, sr]) circle(d = resolution);
       }
         square([iw, ih], center=true);
     }

src/shapes/square.scad

@@ -1,6 +1,4 @@
 use <../functions.scad>
-include <../libraries/rounded_rectangle_profile.scad>
-
 
 // we do this weird key_shape_type check here because rounded_square uses
 // square_shape, and we want flat sides to work for that too.
@@ -30,17 +28,3 @@ module flat_sided_square_shape(size, delta, progress) {
     [(-size.x + (delta.x - extra_keytop_length_for_flat_sides()) * progress)/2, (size.y - delta.y * progress)/2]
   ]);
 }
-
-function skin_square_shape(size, delta, progress, thickness_difference) =
-  let(
-    width = size[0],
-    height = size[1],
-
-    width_difference = delta[0] * progress,
-    height_difference = delta[1] * progress,
-
-    square_size = [
-      width - width_difference - thickness_difference,
-      height - height_difference - thickness_difference
-    ]
-  ) rectangle_profile(square_size, fn=36);