| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  | // Poopy Shoe | 
					
						
							|  |  |  | // poop shute for bambu labs printer - optimized for printing. | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | // Set units | 
					
						
							|  |  |  | @settings(defaultLengthUnit = in) | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2025-04-04 11:03:13 -07:00
										 |  |  | // Define parameters | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  | wallThickness = 0.125 | 
					
						
							|  |  |  | wallsWidth = 3 | 
					
						
							|  |  |  | height = 5.125 | 
					
						
							|  |  |  | filletRadius = 0.050 | 
					
						
							|  |  |  | backLength = 6 | 
					
						
							|  |  |  | exitHeight = 1 | 
					
						
							|  |  |  | frontLength = 7 | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2025-04-04 11:03:13 -07:00
										 |  |  | // Create the curved portion that catches the printer poop | 
					
						
							| 
									
										
										
										
											2025-03-26 08:53:34 -07:00
										 |  |  | sketch001 = startSketchOn(-YZ) | 
					
						
							| 
									
										
										
										
											2025-04-25 16:01:35 -05:00
										 |  |  |   |> startProfile(at = [wallsWidth / 2, 0]) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> xLine(length = wallThickness / 2) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 60, endAbsoluteX = wallsWidth, tag = $seg01) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> yLine(endAbsolute = height) | 
					
						
							|  |  |  |   |> xLine(length = -wallThickness) | 
					
						
							|  |  |  |   |> yLine(endAbsolute = segEndY(seg01)) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 60, endAbsoluteX = wallsWidth / 2 + wallThickness / 2) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> xLine(length = -wallThickness) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 180 - 60, endAbsoluteX = wallThickness) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> yLine(endAbsolute = height) | 
					
						
							|  |  |  |   |> xLine(endAbsolute = 0) | 
					
						
							|  |  |  |   |> yLine(endAbsolute = segEndY(seg01)) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 180 - 60, endAbsoluteY = 0) | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |   |> close() | 
					
						
							| 
									
										
										
										
											2025-03-26 08:53:34 -07:00
										 |  |  | part001 = revolve( | 
					
						
							|  |  |  |   sketch001, | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |   angle = 90, | 
					
						
							|  |  |  |   axis = { | 
					
						
							| 
									
										
										
										
											2025-04-03 22:44:52 +13:00
										 |  |  |     direction = [1.0, 0.0], | 
					
						
							|  |  |  |     origin = [0.0, height + .0001] | 
					
						
							| 
									
										
										
										
											2025-03-26 08:53:34 -07:00
										 |  |  |   }, | 
					
						
							| 
									
										
										
										
											2025-03-18 20:34:44 -07:00
										 |  |  | ) | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2025-03-26 08:53:34 -07:00
										 |  |  | sketch002 = startSketchOn(-YZ) | 
					
						
							| 
									
										
										
										
											2025-04-25 16:01:35 -05:00
										 |  |  |   |> startProfile(at = [wallsWidth / 2, 0]) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> xLine(length = wallThickness / 2) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 60, endAbsoluteX = wallsWidth, tag = $seg02) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> yLine(endAbsolute = height) | 
					
						
							|  |  |  |   |> xLine(length = -wallThickness) | 
					
						
							|  |  |  |   |> yLine(endAbsolute = segEndY(seg01)) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 60, endAbsoluteX = wallsWidth / 2 + wallThickness / 2) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> xLine(length = -wallThickness) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 180 - 60, endAbsoluteX = wallThickness) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> yLine(endAbsolute = height) | 
					
						
							|  |  |  |   |> xLine(endAbsolute = 0) | 
					
						
							|  |  |  |   |> yLine(endAbsolute = segEndY(seg02)) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 180 - 60, endAbsoluteY = 0) | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |   |> close() | 
					
						
							|  |  |  |   |> extrude(length = backLength - height) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | customPlane = { | 
					
						
							| 
									
										
										
										
											2025-04-14 05:58:19 -04:00
										 |  |  |   origin = { | 
					
						
							|  |  |  |     x = 0, | 
					
						
							|  |  |  |     y = -(wallsWidth / 2 - (wallThickness / 2)), | 
					
						
							|  |  |  |     z = 0 | 
					
						
							|  |  |  |   }, | 
					
						
							|  |  |  |   xAxis = { x = 1, y = 0, z = 0 }, | 
					
						
							| 
									
										
										
										
											2025-04-24 22:01:27 +12:00
										 |  |  |   yAxis = { x = 0, y = 0, z = 1 } | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  | } | 
					
						
							|  |  |  | sketch003 = startSketchOn(customPlane) | 
					
						
							| 
									
										
										
										
											2025-04-25 16:01:35 -05:00
										 |  |  |   |> startProfile(at = [0, 0]) | 
					
						
							| 
									
										
										
										
											2025-04-11 14:17:20 -04:00
										 |  |  |   |> tangentialArc(angle = 60, radius = height) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 60, endAbsoluteY = 0) | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |   |> close() | 
					
						
							|  |  |  |   |> extrude(length = wallThickness) | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2025-04-04 11:03:13 -07:00
										 |  |  | // Create the right side wall of the tub | 
					
						
							| 
									
										
										
										
											2025-04-14 05:58:19 -04:00
										 |  |  | sketch004 = startSketchOn(sketch002, face = END) | 
					
						
							| 
									
										
										
										
											2025-04-25 16:01:35 -05:00
										 |  |  |   |> startProfile(at = [0, 0]) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> yLine(endAbsolute = height) | 
					
						
							|  |  |  |   |> xLine(endAbsolute = wallThickness) | 
					
						
							|  |  |  |   |> yLine(endAbsolute = segEndY(seg01)) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 180 - 60, endAbsoluteX = wallsWidth / 2 - (wallThickness / 2)) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> xLine(length = wallThickness) | 
					
						
							| 
									
										
										
											
												KCL: Angled line should use keyword args (#5803)
We continue migrating KCL stdlib functions to use keyword arguments. Next up is the `angledLine` family of functions (except `angledLineThatIntersects, which will be a quick follow-up).
Before vs. after:
`angledLine({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, length = 3, tag = $edge)`
`angledLineOfXLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthX = 3, tag = $edge)`
`angledLineOfYLength({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, lengthY = 3, tag = $edge)`
`angledLineToX({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteX = 3, tag = $edge)`
`angledLineToY({angle = 90, length = 3}, %, $edge)`
  => `angledLine(angle = 90, endAbsoluteY = 3, tag = $edge)`
											
										 
											2025-04-09 14:55:15 -05:00
										 |  |  |   |> angledLine(angle = 60, endAbsoluteY = segEndY(seg01)) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> yLine(endAbsolute = height) | 
					
						
							|  |  |  |   |> xLine(length = wallThickness) | 
					
						
							| 
									
										
										
										
											2025-04-11 14:17:20 -04:00
										 |  |  |   |> tangentialArc(endAbsolute = [ | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |        (frontLength - wallsWidth) / 2 + wallsWidth, | 
					
						
							|  |  |  |        height - ((height - exitHeight) / 2) | 
					
						
							| 
									
										
										
										
											2025-04-11 14:17:20 -04:00
										 |  |  |      ]) | 
					
						
							|  |  |  |   |> tangentialArc(endAbsolute = [frontLength, exitHeight]) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> yLine(endAbsolute = 0) | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |   |> close(tag = $seg04) | 
					
						
							|  |  |  |   |> extrude(length = wallThickness) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | customPlane2 = { | 
					
						
							| 
									
										
										
										
											2025-04-14 05:58:19 -04:00
										 |  |  |   origin = { | 
					
						
							|  |  |  |     x = -1 * (backLength - height + wallsWidth), | 
					
						
							|  |  |  |     y = 0, | 
					
						
							|  |  |  |     z = 0 | 
					
						
							|  |  |  |   }, | 
					
						
							| 
									
										
										
										
											2025-04-24 22:01:27 +12:00
										 |  |  |   xAxis = { x = 0, y = 1, z = 0 }, | 
					
						
							|  |  |  |   yAxis = { x = 0, y = 0, z = 1 } | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  | } | 
					
						
							|  |  |  | sketch005 = startSketchOn(customPlane2) | 
					
						
							| 
									
										
										
										
											2025-04-25 16:01:35 -05:00
										 |  |  |   |> startProfile(at = [0, 0]) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> yLine(endAbsolute = height) | 
					
						
							| 
									
										
										
										
											2025-04-24 22:01:27 +12:00
										 |  |  |   |> xLine(endAbsolute = -wallsWidth) | 
					
						
							| 
									
										
										
										
											2025-04-11 14:17:20 -04:00
										 |  |  |   |> tangentialArc(endAbsolute = [ | 
					
						
							| 
									
										
										
										
											2025-04-24 22:01:27 +12:00
										 |  |  |        -1 * ((frontLength - wallsWidth) / 2 + wallsWidth), | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |        height - ((height - exitHeight) / 2) | 
					
						
							| 
									
										
										
										
											2025-04-11 14:17:20 -04:00
										 |  |  |      ]) | 
					
						
							| 
									
										
										
										
											2025-04-24 22:01:27 +12:00
										 |  |  |   |> tangentialArc(endAbsolute = [-frontLength, exitHeight]) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> yLine(endAbsolute = 0, tag = $seg03) | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |   |> close() | 
					
						
							|  |  |  |   |> extrude(length = wallThickness) | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2025-04-14 05:58:19 -04:00
										 |  |  | sketch006 = startSketchOn(sketch005, face = seg03) | 
					
						
							| 
									
										
										
										
											2025-04-25 16:01:35 -05:00
										 |  |  |   |> startProfile(at = [0, -1 * (backLength - height)]) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> xLine(endAbsolute = -exitHeight) | 
					
						
							|  |  |  |   |> yLine(length = -wallsWidth) | 
					
						
							|  |  |  |   |> xLine(endAbsolute = 0) | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |   |> close() | 
					
						
							|  |  |  |   |> extrude(length = wallThickness) | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2025-04-14 05:58:19 -04:00
										 |  |  | sketch007 = startSketchOn(sketch004, face = END) | 
					
						
							| 
									
										
										
										
											2025-04-25 16:01:35 -05:00
										 |  |  |   |> startProfile(at = [0, 0]) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> xLine(endAbsolute = wallThickness) | 
					
						
							|  |  |  |   |> yLine(endAbsolute = height) | 
					
						
							|  |  |  |   |> xLine(endAbsolute = 0) | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |   |> close() | 
					
						
							|  |  |  |   |> extrude(length = wallsWidth - (2 * wallThickness)) | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | customPlane3 = { | 
					
						
							| 
									
										
										
										
											2025-04-14 05:58:19 -04:00
										 |  |  |   origin = { | 
					
						
							|  |  |  |     x = -1 * (backLength - height + wallsWidth), | 
					
						
							|  |  |  |     y = 0, | 
					
						
							|  |  |  |     z = wallThickness | 
					
						
							|  |  |  |   }, | 
					
						
							|  |  |  |   xAxis = { x = 0, y = -1, z = 0 }, | 
					
						
							| 
									
										
										
										
											2025-04-24 22:01:27 +12:00
										 |  |  |   yAxis = { x = 1, y = 0, z = 0 } | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | sketch008 = startSketchOn(customPlane3) | 
					
						
							| 
									
										
										
										
											2025-04-25 16:01:35 -05:00
										 |  |  |   |> startProfile(at = [wallThickness, wallThickness]) | 
					
						
							| 
									
										
										
										
											2025-03-07 22:07:16 -06:00
										 |  |  |   |> xLine(endAbsolute = frontLength) | 
					
						
							|  |  |  |   |> yLine(length = wallsWidth - (2 * wallThickness)) | 
					
						
							|  |  |  |   |> xLine(endAbsolute = wallThickness) | 
					
						
							| 
									
										
										
										
											2025-03-06 18:01:24 -05:00
										 |  |  |   |> close() | 
					
						
							|  |  |  |   |> extrude(length = -wallThickness) |