OpenSCAD Geometry and Graphics Tutorials

https://openhome.cc/eGossip/OpenSCAD
Admin
This project offers a curated collection of markdown tutorials and examples illustrating various...
Tokens:40,970
Snippets:331
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Generate and Draw Maze

Source: https://openhome.cc/eGossip/OpenSCAD/RandomMaze.html

Initializes maze parameters, generates a maze using the `go_maze` function starting from (1, 1), and then draws the generated maze using specified dimensions and wall thickness.

```openscad
block_width = 3;
wall_thickness = 1;
maze_rows = 10;
maze_columns = 10;  

maze_blocks = go_maze(
    1, 1,   // the starting point
    starting_maze(maze_rows, maze_columns),
    maze_rows, maze_columns
);

draw_maze(
    maze_rows, 
    maze_columns, 
    maze_blocks, 
    block_width, 
    wall_thickness
);
```

--------------------------------

### Parameterized Text Model in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/HelloOpenSCAD.html

This example demonstrates parameterizing a 3D model by creating a text-based structure that can be dynamically generated. Change the `my_text`, `step_angle`, `radius`, and `height` variables to alter the output.

```openscad
my_text = "Hello, OpenSCAD!";
step_angle = 30;
step_height = 5;
radius = 30;
height = 5;

len_of_my_text = len(my_text);

for(i = [0:len_of_my_text]) {
    rotate(step_angle * i) 
        translate([radius, 0, i * step_height]) 
            linear_extrude(height) 
                text(my_text[len_of_my_text - i]);
}
```

```openscad
my_text = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
step_angle = 20;
step_height = 5;
radius = 30;
height = 5;
```

--------------------------------

### Creating a Hollow Sphere with Text Intersection

Source: https://openhome.cc/eGossip/OpenSCAD/BooleanOperationsHull.html

This example combines `difference` to create a hollow sphere and `intersection` to place text on its surface. It demonstrates encapsulating complex operations within modules for reusability and readability.

```openscad
character = "A";
font_size = 10;
thickness = 1;

module hollow_sphere(radius, thickness) {
    $fn = 48;
    inner_radius = radius - thickness;

    difference() {
        sphere(radius);
        sphere(inner_radius);
    }    
}

module sphere_character(ch, font_size, thickness) {
    font_offset = font_size / 2;

    intersection() {
        hollow_sphere(font_size, thickness);
        linear_extrude(font_size * 2) 
            translate([-font_offset, -font_offset, 0]) 
                text(ch, size = font_size);
    }
}

sphere_character(character[0], font_size, thickness);
sphere(font_size - thickness, $fn = 48);
```

--------------------------------

### Full maze generation and drawing example (OpenSCAD)

Source: https://openhome.cc/eGossip/OpenSCAD/ManualMaze.html

This code snippet sets up maze parameters, defines the block data for a 4x4 maze, and then calls the `draw_maze` module to render it. It demonstrates the complete usage of the previously defined modules.

```openscad
module line(point1, point2, width = 1, cap_round = true) {
    angle = 90 - atan((point2[1] - point1[1]) / (point2[0] - point1[0]));
    offset_x = 0.5 * width * cos(angle);
    offset_y = 0.5 * width * sin(angle);

    offset1 = [-offset_x, offset_y];
    offset2 = [offset_x, -offset_y];

    if(cap_round) {
        translate(point1) circle(d = width, $fn = 24);
        translate(point2) circle(d = width, $fn = 24);
    }

    polygon(points=[
        point1 + offset1, point2 + offset1,  
        point2 + offset2, point1 + offset2
    ]);
}

module polyline(points, width = 1) {
    module polyline_inner(points, index) {
        if(index < len(points)) {
            line(points[index - 1], points[index], width);
            polyline_inner(points, index + 1);
        }
    }

    polyline_inner(points, 1);
}

// Wall constants

NO_WALL = 0;      
UP_WALL = 1;      
RIGHT_WALL = 2;  
UP_RIGHT_WALL = 3;

function block_data(x, y, wall_type) = [x, y, wall_type];
function get_x(block_data) = block_data[0];
function get_y(block_data) = block_data[1];
function get_wall_type(block_data) = block_data[2];

module draw_block(wall_type, block_width, wall_thickness) {
    if(wall_type == UP_WALL || wall_type == UP_RIGHT_WALL) {
        // the upper wall
        polyline(
            [[0, block_width], [block_width, block_width]], wall_thickness
        ); 
    }

    if(wall_type == RIGHT_WALL || wall_type == UP_RIGHT_WALL) {
        // the right wall
        polyline(
            [[block_width, block_width], [block_width, 0]], wall_thickness
        );
    }
}

module draw_maze(rows, columns, blocks, block_width, wall_thickness) {
    for(block = blocks) {
        // move the block to its correspond position
        translate([get_x(block) - 1, get_y(block) - 1] * block_width) 
            draw_block(
                get_wall_type(block), 
                block_width, 
                wall_thickness
            );
    }

    // the lowermost wall
    polyline(
        [[0, 0], [block_width * columns, 0]], 
        wall_thickness);
    // the leftmost wall
    polyline(
        [[0, block_width], [0, block_width * rows]], 
        wall_thickness);
}

block_width = 3;
wall_thickness = 1;
maze_rows = 4;
maze_columns = 4;

// [x, y, wall_type]
maze_blocks =  [
    [1, 4, 1], [2, 4, 1], [3, 4, 1], [4, 4, 1], 
    [1, 3, 2], [2, 3, 3], [3, 3, 1], [4, 3, 2], 
    [1, 2, 0], [2, 2, 2], [3, 2, 2], [4, 2, 2], 
    [1, 1, 1], [2, 1, 1], [3, 1, 2], [4, 1, 2]
];


draw_maze(
    maze_rows, 
    maze_columns, 
    maze_blocks, 
    block_width, 
    wall_thickness
);

```

--------------------------------

### Create Multiple Spirals with Rotation

Source: https://openhome.cc/eGossip/OpenSCAD/Polyline3D.html

This example generates multiple instances of a spiral, each rotated around the Z-axis. It defines a spiral's points and then uses a loop to apply rotations before rendering the polyline.

```openscad
module line3D(p1, p2, thickness, fn = 24) {
    $fn = fn;

    hull() {
        translate(p1) sphere(thickness / 2);
        translate(p2) sphere(thickness / 2);
    }
}

module polyline3D(points, thickness, fn) {
    module polyline3D_inner(points, index) {
        if(index < len(points)) {
            line3D(points[index - 1], points[index], thickness, fn);
            polyline3D_inner(points, index + 1);
        }
    }

    polyline3D_inner(points, 1);
}

r = 50;
points = [
    for(a = [0:180]) 
        [r * cos(-90 + a) * cos(a), r * cos(-90 + a) * sin(a), r * sin(-90 + a)]
];

for(i = [0:7]) {
    rotate(45 * i) polyline3D(points, 2, 3);
}
```

--------------------------------

### Calculate Starting Angle for Text Placement

Source: https://openhome.cc/eGossip/OpenSCAD/TextSphere.html

Determines the initial angle for placing the first character, based on the calculated angle and total semi-circles. This helps in positioning the text block.

```OpenSCAD
begin_angle = angle * total_semi_circles;
```

--------------------------------

### Chaining `use` Directives

Source: https://openhome.cc/eGossip/OpenSCAD/ModuleFunction.html

When importing definitions from files that themselves import other files, each dependency must be explicitly listed using `use`. For example, to use definitions from 'a.scad' and 'b.scad' where 'b.scad' depends on 'a.scad', both must be included in the main file.

```openscad
use <a.scad>;
use <b.scad>;
```

--------------------------------

### Example Maze Block Data (4x4)

Source: https://openhome.cc/eGossip/OpenSCAD/ManualMaze.html

Represents a 4x4 maze using [x, y, wall_type] vectors. The coordinate system aligns with OpenSCAD's axes.

```OpenSCAD
// [x, y, wall_type]
maze_blocks =  [
    [1, 4, 1], [2, 4, 1], [3, 4, 1], [4, 4, 1], 
    [1, 3, 2], [2, 3, 3], [3, 3, 1], [4, 3, 2], 
    [1, 2, 0], [2, 2, 2], [3, 2, 2], [4, 2, 2], 
    [1, 1, 1], [2, 1, 1], [3, 1, 2], [4, 1, 2]
];
```

--------------------------------

### Text on Sphere with Open Rim

Source: https://openhome.cc/eGossip/OpenSCAD/TextSphere.html

Creates a text sphere with an open rim by starting the character generation at a specified offset ('open_begin'). This controls the initial position and density.

```openscad
radius = 40;
step_angle = 10;
font_size = 10;
thickness = 1;

total_semi_circles = 15;
open_begin = 500;

for(a = [open_begin:step_angle:180 * total_semi_circles]) {
    rotate([0, -90 + a / total_semi_circles, a]) translate([radius, 0, 0]) 
        rotate([90, 0, 90]) 
            linear_extrude(thickness) 
                text("A", size = font_size, valign = "center", halign = "center");
}
%sphere(radius);
```

--------------------------------

### Lineup Module for Arranging Children

Source: https://openhome.cc/eGossip/OpenSCAD/Children.html

This module arranges multiple children horizontally with a specified spacing. It uses `$children` to get the count of children and `children(i)` to access individual children by index.

```openscad
module lineup(space) {
  for (i = [0 : $children - 1])
    translate([space * i, 0, 0 ]) children(i);
}

lineup(100) { sphere(10); sphere(10); }
lineup(100) { cube(35); cube(35); cube(35); }
```

--------------------------------

### Get Visitable Directions

Source: https://openhome.cc/eGossip/OpenSCAD/RandomMaze.html

Returns a list of directions (0:right, 1:up, 2:left, 3:down) from the current block (x, y) that lead to valid, unvisited blocks within the maze boundaries.

```openscad
// return visitable directions we can try
function visitable_dirs_from(x, y, maze, rows, columns) = [
    for(dir = [0, 1, 2, 3]) 
        if(visitable(next_x(x, dir), next_y(y, dir), maze, maze_rows, columns)) 
            dir
];  
```

--------------------------------

### Rotate Cubes Around Z-Axis in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/TextSphere.html

This basic example demonstrates rotating a series of cubes around the z-axis to form a circular pattern. Adjust 'radius' and 'step_angle' to control the spacing and distance of the cubes.

```openscad
radius = 40;
step_angle = 10;
length = 5;
for(a = [0:step_angle:180]) {
    rotate([0, 0, a]) translate([radius, 0, 0]) 
        cube([length, length, length], center = true);
}
```

--------------------------------

### Generating Function Graph with Mathematical Function

Source: https://openhome.cc/eGossip/OpenSCAD/FunctionGrapher.html

This snippet generates a function graph by defining a mathematical function `f(x, y)` and creating a grid of points based on it. Similar to the previous example, it slices rectangles into triangles and uses `polyhedron` to render the 3D shape with a specified thickness.

```openscad
function f(x, y) = (pow(y,2)/pow(2, 2))-(pow(x,2)/pow(2, 2));

min_value = -3;
max_value = 3;
resolution = 0.5;
thickness = 1;

points = [
    for(y = [min_value:resolution:max_value])
        [
            for(x = [min_value:resolution:max_value]) 
                [x, y, f(x, y)]
        ]
];

faces = [
    [2, 1, 0],
    [3, 4, 5],
    [0, 1, 4, 3],
    [1, 2, 5, 4],
    [2, 0, 3, 5]
];
z_offset = [0, 0, -thickness];

for(yi = [0:len(points) - 2]) {
    for(xi = [0:len(points[yi]) - 2]) {
        tri1_top = [
            points[yi][xi], 
            points[yi][xi + 1], 
            points[yi + 1][xi + 1]
        ];
        tri1_bottom = [
            tri1_top[0] + z_offset, 
            tri1_top[1] + z_offset, 
            tri1_top[2] + z_offset
        ];

        tri2_top = [
            points[yi][xi], 
            points[yi + 1][xi + 1], 
            points[yi + 1][xi]
        ];
        tri2_bottom = [
            tri2_top[0] + z_offset, 
            tri2_top[1] + z_offset, 
            tri2_top[2] + z_offset
        ];

        polyhedron(
            points = concat(tri1_top, tri1_bottom), 
            faces = faces
        );

        polyhedron(
            points = concat(tri2_top, tri2_bottom), 
            faces = faces
        );
    }
}

```

--------------------------------

### Create a Spiral Effect in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/TextSphere.html

This example generates a spiral by decreasing the 'step_angle' significantly. A smaller 'step_angle' results in more cubes and a smoother, denser spiral. The rotation around the y-axis is still dependent on the loop variable 'a', creating the characteristic spiral shape.

```openscad
radius = 40;
step_angle = 0.25;
length = 5;
for(a = [0:step_angle:180]) {
    rotate([0, -90 + a, a]) translate([radius, 0, 0]) 
        cube([length, length, length], center = true);
}
%sphere(radius);
```

--------------------------------

### Create Text with a Specific Font

Source: https://openhome.cc/eGossip/OpenSCAD/CheatSheet.html

Use the `text` module to generate text with a specified font. Ensure the font supports the characters and is installed on your system. The source file should be UTF-8 encoded for non-ASCII characters.

```openscad
text("春", font = "標楷體");
```

--------------------------------

### Maze Initialization and Drawing

Source: https://openhome.cc/eGossip/OpenSCAD/RandomMaze.html

Sets up maze dimensions, generates the maze structure using the random walk algorithm, and then draws the final maze with specified block and wall sizes.

```openscad
block_width = 3;
wall_thickness = 1;
maze_rows = 30;
maze_columns = 30;  

maze_blocks = go_maze(
    1, 1,   // the starting point
    starting_maze(maze_rows, maze_columns),
    maze_rows, maze_columns
);

draw_maze(
    maze_rows, 
    maze_columns, 
    maze_blocks, 
    block_width, 
    wall_thickness
);
```

--------------------------------

### Basic Heart Module in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/ModifierCharacters.html

This code defines a basic heart module using circles and a square. It serves as an example for demonstrating modifier characters.

```openscad
radius = 10;

module heart(radius) {
    rotated_angle = 45;
    diameter = radius * 2;
    $fn = 48;

    rotate(-rotated_angle) union() {
        circle(radius);
        translate([0, -radius, 0]) 
            square(diameter);
    }

    translate([cos(rotated_angle) * diameter, 0, 0]) 
        circle(radius);
}

heart(radius);
```

--------------------------------

### Modify Cube Vertices for `polyhedron`

Source: https://openhome.cc/eGossip/OpenSCAD/FunctionGrapher.html

This example shows a modified cube where one vertex's z-coordinate is changed. OpenSCAD will attempt to triangulate non-planar faces automatically.

```openscad
CubePoints = [
  [  0,  0,  0 ],  //0
  [ 10,  0,  0 ],  //1
  [ 10,  7,  0 ],  //2
  [  0,  7,  0 ],  //3
  [  0,  0,  5 ],  //4
  [ 10,  0,  5 ],  //5
  [ 10,  7,  7 ],  //6
  [  0,  7,  5 ]]; //7

CubeFaces = [
  [0,1,2,3],  // bottom
  [4,5,1,0],  // front
  [7,6,5,4],  // top
  [5,6,2,1],  // right
  [6,7,3,2],  // back
  [7,4,0,3]]; // left

polyhedron( CubePoints, CubeFaces );
```

--------------------------------

### Four golden spirals with diamond petals

Source: https://openhome.cc/eGossip/OpenSCAD/Flower.html

This snippet extends the previous example by creating four golden spirals arranged radially. This creates a more complex, flower-like structure.

```openscad
spirals = 4;

// omitted...the same as before...

module golden_spiral(from, to, thickness) {
    if(from <= to) {
        f1 = fibonacci(from);
        f2 = fibonacci(from + 1);

        offset = f2 - f1;

        linear_extrude(thickness, center = true) 
            scale([2, 1, 1]) circle(offset / 5, $fn = 4);

        translate([0, -offset, 0]) rotate(90)
            golden_spiral(from + 1, to, thickness);
    }
}

for(a = [0 : 360 / spirals : 360 - 360 / spirals]) {
    rotate(a) golden_spiral(5, 10, 1); 
}

```

--------------------------------

### Apply Rotation to a Module Instance

Source: https://openhome.cc/eGossip/OpenSCAD/ModuleFunction.html

Demonstrates how to apply transformations, such as rotation, to an instance of a previously defined module. Ensure the 'chinese_word' module and its required variables are defined.

```openscad
rotate([90, 0, 0]) 
    chinese_word(word, font, height, center = false);
```

--------------------------------

### Create a Ring using Difference and Circle

Source: https://openhome.cc/eGossip/OpenSCAD/Children.html

This snippet demonstrates creating a ring by subtracting a smaller circle from a larger one using the `difference` operation.

```openscad
module circle_ring(radius, thickness) {
    difference() {
        circle(radius, $fn = 48);
        circle(radius - thickness, , $fn = 48);
    }
}

circle_ring(3, 1);
```

--------------------------------

### Create a Centered Cube

Source: https://openhome.cc/eGossip/OpenSCAD/CheatSheet.html

Use the `cube` module with the `center` parameter set to `true` to center the cube at the origin (0, 0, 0).

```openscad
cube(size = [x,y,z], center = true);
```

--------------------------------

### Create a Cube with Dimensions

Source: https://openhome.cc/eGossip/OpenSCAD/CheatSheet.html

Use the `cube` module to create a 3D cube with specified dimensions. The `size` parameter accepts a 3-value vector [x, y, z].

```openscad
cube([x,y,z]);
```

--------------------------------

### Full Integration with `include`

Source: https://openhome.cc/eGossip/OpenSCAD/ModuleFunction.html

Use the `include` directive to integrate the contents of an external file as if it were part of the current script. This executes all commands and makes top-level variables from the included file active, allowing for default variable assignments that can be overridden.

```openscad
include <filename>;
```

--------------------------------

### Recursive Maze Traversal Function

Source: https://openhome.cc/eGossip/OpenSCAD/RandomMaze.html

Recursively walks through the maze starting from (x, y). If no visitable directions are available, it marks the current cell as visited. Otherwise, it randomly selects a direction and continues the walk.

```openscad
function go_maze(x, y, maze, rows, columns) = 
    // have visitable directions?
    len(visitable_dirs_from(x, y, maze, rows, columns)) == 0 ? 
        set_visited(x, y, maze)      // we visited here and cannot go further.
        : walk_around_from(          // walk randomly from (x, y) 
            x, y, 
            rand_dirs(),             // random directions
            set_visited(x, y, maze), // we visited here 
            rows, columns
        );
```

--------------------------------

### Connecting Characters with Cubes in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/TextCylinder.html

This snippet demonstrates an initial approach to connecting characters using small, intensive cubes. Be aware that this method can result in a high number of facets, leading to longer rendering times and larger file sizes.

```openscad
chars = "3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481";

PI = 3.14159;
chars_per_circle = 40;
radius = 40;
step_angle = 360 / chars_per_circle;
circumference = 2 * PI * radius;
char_size = circumference / chars_per_circle;
char_thickness = 1;
z_offset_per_char = char_size / 40;
line_thickness = char_size / 8;


for(i = [0 : len(chars) - 1]) {
    rotate(i * step_angle) 
        translate([0, radius + char_size / 2, -z_offset_per_char * i]) 
            rotate([90, 0, 180]) linear_extrude(char_thickness) 
                  union() {
                    text(
                        chars[i], 
                        font = "Courier New; Style = Bold", 
                        size = char_size, 
                        valign = "center", halign = "center"
                    );
                    translate([0, char_size / 2, 0])
                        square([char_size, line_thickness], center = true);
                }
}

```

--------------------------------

### Create a 3D Polyline from Points

Source: https://openhome.cc/eGossip/OpenSCAD/Polyline3D.html

This module constructs a 3D polyline by sequentially drawing lines between consecutive points in a given array. It utilizes the `line3D` module for each segment. Ensure the `points` array contains at least two points.

```openscad
module line3D(p1, p2, thickness, fn = 24) {
    $fn = fn;

    hull() {
        translate(p1) sphere(thickness / 2);
        translate(p2) sphere(thickness / 2);
    }
}

module polyline3D(points, thickness, fn) {
    module polyline3D_inner(points, index) {
        if(index < len(points)) {
            line3D(points[index - 1], points[index], thickness, fn);
            polyline3D_inner(points, index + 1);
        }
    }

    polyline3D_inner(points, 1);
}

points = [[1, 2, 3], [4, -5, -6], [-1, -3, -5], [0, 0, 0]];
polyline3D(points, 1, 3);
```

--------------------------------

### Get Visitable Directions in Maze

Source: https://openhome.cc/eGossip/OpenSCAD/RandomMaze.html

Returns a list of valid directions from the current position (x, y) in the maze. It checks if the next step in each of the four cardinal directions is within bounds and not already visited.

```openscad
function visitable_dirs_from(x, y, maze, rows, columns) = [
    for(dir = [0, 1, 2, 3]) 
        if(visitable(next_x(x, dir), next_y(y, dir), maze, maze_rows, columns)) 
            dir
];  
```

--------------------------------

### OpenSCAD Maze Generation and Drawing Script

Source: https://openhome.cc/eGossip/OpenSCAD/SimpleGeneratedMaze.html

Sets maze dimensions, generates the maze blocks using the binary tree algorithm, and then draws the maze using the `draw_maze` module. This is the main script to generate a maze.

```openscad
block_width = 3;
wall_thickness = 1;
maze_rows = 10;
maze_columns = 10; 

function flip_coin() = round(rands(0, 1, 1)[0]) + 1;

function binary_tree_block(x, y, rows, columns) = 
    y == rows ? block_data(x, y, 1) : (        // the uppermost row
        x == columns ? block_data(x, y, 2) :   // the rightmost column
            block_data(x, y, flip_coin())      // flip a coin
    );

function binary_tree_algorithm(rows, columns) = 
    [
        for(y = [1:rows]) 
            for(x = [1:columns]) 
                binary_tree_block(x, y, rows, columns)
    ];

maze_blocks = binary_tree_algorithm(maze_rows, maze_columns);

draw_maze(
    maze_rows, 
    maze_columns, 
    maze_blocks, 
    block_width, 
    wall_thickness
);
```

--------------------------------

### OpenSCAD Polyline and Line Modules

Source: https://openhome.cc/eGossip/OpenSCAD/BezierCurve.html

Provides modules to draw lines and polylines, used here to render the calculated Bezier curve points. Ensure the 'polyline' module is available or defined.

```openscad
function bezier_coordinate(t, n0, n1, n2, n3) = 
    n0 * pow((1 - t), 3) + 3 * n1 * t * pow((1 - t), 2) + 
        3 * n2 * pow(t, 2) * (1 - t) + n3 * pow(t, 3);

function bezier_point(t, p0, p1, p2, p3) = 
    [
        bezier_coordinate(t, p0[0], p1[0], p2[0], p3[0]),
        bezier_coordinate(t, p0[1], p1[1], p2[1], p3[1]),
        bezier_coordinate(t, p0[2], p1[2], p2[2], p3[2])
    ];


function bezier_curve(t_step, p0, p1, p2, p3) = 
    [for(t = [0: t_step: 1 + t_step]) bezier_point(t, p0, p1, p2, p3)];


module line(point1, point2, width = 1, cap_round = true) {
    angle = 90 - atan((point2[1] - point1[1]) / (point2[0] - point1[0]));
    offset_x = 0.5 * width * cos(angle);
    offset_y = 0.5 * width * sin(angle);

    offset1 = [-offset_x, offset_y];
    offset2 = [offset_x, -offset_y];

    if(cap_round) {
        translate(point1) circle(d = width, $fn = 24);
        translate(point2) circle(d = width, $fn = 24);
    }

    polygon(points=[
        point1 + offset1, point2 + offset1,  
        point2 + offset2, point1 + offset2
    ]);
}

module polyline(points, width = 1) {
    module polyline_inner(points, index) {
        if(index < len(points)) {
            line(points[index - 1], points[index], width);
            polyline_inner(points, index + 1);
        }
    }

    polyline_inner(points, 1);
}

t_step = 0.05;
width = 2;

p0 = [0, 0];
p1 = [40, 60];
p2 = [-50, 90];
p3 = [0, 200];

points = bezier_curve(t_step, 
    p0, p1, p2, p3
);

polyline(points, width);
```

--------------------------------

### Define a Chinese Word Module with Parameters

Source: https://openhome.cc/eGossip/OpenSCAD/ModuleFunction.html

Defines a module that accepts 'word', 'font', 'height', and 'offset_for_center' as parameters for greater flexibility. Call the module with specific arguments.

```openscad
height = 10;
offset_for_center = -height / 2;
word = "春";
font = "標楷體";

module chinese_word(word, font, height, offset_for_center) {
    translate([offset_for_center, offset_for_center, offset_for_center])
        linear_extrude(height) 
            text(word, font = font);
}

chinese_word(word, font, height, offset_for_center);
```

--------------------------------

### Custom String Length Function using Recursion

Source: https://openhome.cc/eGossip/OpenSCAD/ModuleFunction.html

Implements a custom function to calculate the length of a string using recursion. This serves as an example of how to handle iterative tasks without loops within OpenSCAD functions.

```openscad
function my_len(text, counter = 0) = 
    text[counter] == undef ? counter : my_len(text, counter + 1);

echo(my_len("TEST"));  // ECHO: 4
```

--------------------------------

### Hull of Two 2D Circles in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/BooleanOperationsHull.html

This example shows how to apply the `hull` transformation to two 2D circles. The `hull` operation creates a convex shape that encloses both circles, effectively forming a capsule shape.

```openscad
radius = 10;
hull() {
    circle(radius);
    translate([2 * radius, 0, 0]) 
        circle(radius);
}
```

--------------------------------

### Create a Square Frame using Offset

Source: https://openhome.cc/eGossip/OpenSCAD/Children.html

This snippet demonstrates creating a square frame by subtracting an offset inner square from an outer square.

```openscad
module square_frame(dimension, thickness) {
    difference() {
        square(dimension);
        offset(r = -thickness) square(dimension);
    }
}

square_frame([10, 5], 1);
```

--------------------------------

### Polyline Module with Rounded Caps

Source: https://openhome.cc/eGossip/OpenSCAD/Polyline.html

This improved `line` module includes an option to add rounded caps at the start and end points of each line segment, preventing gaps in the polyline. The `cap_round` parameter defaults to true.

```openscad
module line(point1, point2, width = 1, cap_round = true) {
    angle = 90 - atan((point2[1] - point1[1]) / (point2[0] - point1[0]));
    offset_x = 0.5 * width * cos(angle);
    offset_y = 0.5 * width * sin(angle);

    offset1 = [-offset_x, offset_y];
    offset2 = [offset_x, -offset_y];

    if(cap_round) {
        translate(point1) circle(d = width, $fn = 24);
        translate(point2) circle(d = width, $fn = 24);
    }

    polygon(points=[
        point1 + offset1, point2 + offset1,  
        point2 + offset2, point1 + offset2
    ]);
}

module polyline(points, width = 1) {
    module polyline_inner(points, index) {
        if(index < len(points)) {
            line(points[index - 1], points[index], width);
            polyline_inner(points, index + 1);
        }
    }

    polyline_inner(points, 1);
}

polyline([[1, 2], [-5, -4], [-5, 3], [5, 5]], 1);
```

--------------------------------

### Define Basic Triangle and Two Triangles Modules

Source: https://openhome.cc/eGossip/OpenSCAD/Fractal.html

Defines a `triangle` module using turtle graphics and a `two_triangles` module that draws a triangle and a smaller, reversed triangle within it. This forms the base for fractal generation.

```openscad
module triangle(t, side_leng, width) {
    angle = 120;
    t_p1 = forward(t, side_leng);
    polyline([get_xy(t), get_xy(t_p1)], width);

    t_p2 = forward(turn(t_p1, angle), side_leng);
    polyline([get_xy(t_p1), get_xy(t_p2)], width);

    t_p3 = forward(turn(t_p2, angle), side_leng);
    polyline([get_xy(t_p2), get_xy(t_p3)], width);
}

module two_triangles(t, side_len, len_limit, width) {
    angle = 60;
    triangle(t, side_len, width);
    next_t = turn(forward(t, side_len / 2), angle);
    triangle(next_t, side_len / 2, width);
}

module concentric_triangles(t, side_len, len_limit, width) {
    if(side_len >= len_limit) {
        two_triangles(t, side_len, len_limit, width);

        next_t = turn(forward(t, side_len / 2), 60);
        concentric_triangles(next_t, side_len / 2, len_limit, width);
    }
}

side_len = 50;
len_limit = 4;
width = 1;
t = turtle(0, 0, 0);

concentric_triangles(t, side_len, len_limit, width);
```

--------------------------------

### Create a Cube in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/HelloOpenSCAD.html

Use the `cube()` function to create a basic cube with specified dimensions. The dimensions are provided as a vector `[x, y, z]`.

```openscad
cube([1, 2, 3]);
```

--------------------------------

### Importing 2D Modules with `use`

Source: https://openhome.cc/eGossip/OpenSCAD/ModuleFunction.html

Use the `use` directive to import modules and functions from an external file, such as '2d.scad', into your current OpenSCAD script. This method only imports definitions and does not execute commands.

```openscad
use <2d.scad>;
```

--------------------------------

### Visualize Bézier Curves and Intermediate Paths

Source: https://openhome.cc/eGossip/OpenSCAD/BezierSurface.html

This code visualizes individual Bézier curves generated from control points, highlights a specific intermediate path, and then draws new Bézier curves derived from points along these paths. It requires 'line3d.scad', 'polyline3d.scad', and 'bezier_curve.scad'.

```openscad
include <line3d.scad>;
include <polyline3d.scad>;
include <bezier_curve.scad>;

ctrl_pts = [
    [[0, 0, 20],  [60, 0, -35],   [90, 0, 60],    [200, 0, 5]],
    [[0, 50, 30], [100, 60, -25], [120, 50, 120], [200, 50, 5]],
    [[0, 100, 0], [60, 120, 35],  [90, 100, 60],  [200, 100, 45]],
    [[0, 150, 0], [60, 150, -35], [90, 180, 60],  [200, 150, 45]]
];

thickness = 2;
t_step = 0.05;

// Four bazier curves
g_pts = [for(i = [0:len(ctrl_pts) - 1]) 
    bezier_curve(t_step, ctrl_pts[i])
]; 
for(i = [0:len(g_pts) - 1]) {
    polyline3d(g_pts[i], thickness);
}

// The curve created by the 5th point at the path of each curve.
crtl_j = 5;
color("red") union() {
    polyline3d([for(i = [0:len(g_pts) - 1]) g_pts[i][crtl_j]], thickness);
    for(i = [0:3]) {
        translate(g_pts[i][5]) sphere(r = thickness * 2);
    }
}

// Using Bézier to create Bézier
for(j = [0:len(g_pts[0]) - 1]) {
    ctrl_pts2 = [for(i = [0:len(g_pts) - 1]) g_pts[i][j]];
    bezier_pts = bezier_curve(t_step, ctrl_pts2);
    color(j == crtl_j ? "blue" : "green") polyline3d(bezier_pts, thickness);

}

```

--------------------------------

### Rotate Cubes Around Z and Y Axes in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/TextSphere.html

This snippet extends the previous example by adding rotation around the y-axis. This creates an arc effect, with the angle of rotation around the y-axis determining the position of the arc relative to the x-y plane. A transparent sphere is added to visualize the rotation.

```openscad
radius = 40;
step_angle = 10;
length = 5;
for(a = [0:step_angle:180]) {
    rotate([0, -45, a]) translate([radius, 0, 0]) 
        cube([length, length, length], center = true);
}
%sphere(radius);
```

--------------------------------

### Create a Ring using Offset Transformation

Source: https://openhome.cc/eGossip/OpenSCAD/Children.html

This snippet shows an alternative method for creating a ring using the `offset` transformation to create the inner circle.

```openscad
module circle_ring(radius, thickness) {
    difference() {
        circle(radius, $fn = 48);
        offset(r = -thickness) circle(radius, , $fn = 48);
    }
}

circle_ring(3, 1);
```

--------------------------------

### Wrap Cubes Around a Sphere in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/TextSphere.html

This code wraps cubes around a sphere by simultaneously rotating them around the y and z axes. The rotation around the y-axis is dynamically adjusted based on the loop variable 'a' to achieve a spherical distribution. Adjust the initial offset for the y-axis rotation to change the starting position of the wrapped elements.

```openscad
radius = 40;
step_angle = 10;
length = 5;
for(a = [0:step_angle:180]) {
    rotate([0, -90 + a, a]) translate([radius, 0, 0]) 
        cube([length, length, length], center = true);
}
%sphere(radius);
```

--------------------------------

### Define a Chinese Word Module with a Centering Option

Source: https://openhome.cc/eGossip/OpenSCAD/ModuleFunction.html

Introduces a 'center' parameter with a default value of 'true'. Uses a ternary operator to conditionally set the offset for centering. Call the module with or without the 'center' argument.

```openscad
height = 10;
word = "春";
font = "標楷體";

module chinese_word(word, font, height, center = true) {
    offset_for_center = center ? -height / 2 : 0;
    translate([offset_for_center, offset_for_center, offset_for_center])
        linear_extrude(height) 
            text(word, font = font);
}

chinese_word(word, font, height, center = false);
```

--------------------------------

### Initialize Maze Grid in OpenSCAD

Source: https://openhome.cc/eGossip/OpenSCAD/RandomMaze.html

Initializes the maze grid with specified dimensions. Each block is created using `block_data`, with the exit block having only an UP_WALL and all others having UP_RIGHT_WALL. All blocks are initially marked as unvisited.

```openscad
// initialize the status of a maze   
function starting_maze(rows, columns) =  [
    for(y = [1:rows]) 
        for(x = [1:columns]) 
            block_data(
                x, y, 
                // all blocks have UP_RIGHT_WALL except the exit
                y == rows && x == columns ? UP_WALL : UP_RIGHT_WALL, 
                // false is unvisited
                false 
            )
];
```

--------------------------------

### Draw a Triangle using Turtle Graphics

Source: https://openhome.cc/eGossip/OpenSCAD/TurtleGraphics.html

Demonstrates drawing a triangle by sequentially moving and turning a turtle, then drawing the line segments between the turtle's positions.

```OpenSCAD
side_leng = 10;
angle = 120; 
width = 1;

t = turtle(0, 0, 0);

t_p1 = forward(t, side_leng);                   // forward side_leng
polyline([get_xy(t), get_xy(t_p1)], width);     // draw a line

t_p2 = forward(turn(t_p1, angle), side_leng);   // turn angle and forward side_leng
polyline([get_xy(t_p1), get_xy(t_p2)], width);  // draw a line

t_p3 = forward(turn(t_p2, angle), side_leng);   // turn angle and forward side_leng
polyline([get_xy(t_p2), get_xy(t_p3)], width);  // draw a line
```

--------------------------------

### Draw the entire maze structure (OpenSCAD)

Source: https://openhome.cc/eGossip/OpenSCAD/ManualMaze.html

Iterates through block data to draw each block at its corresponding position and adds the outer boundary walls. This module uses `draw_block` and `polyline` to construct the maze.

```openscad
module draw_maze(rows, columns, blocks, block_width, wall_thickness) {
    for(block = blocks) {
        // move the block to its correspond position
        translate([get_x(block) - 1, get_y(block) - 1] * block_width) 
            draw_block(
                get_wall_type(block), 
                block_width, 
                wall_thickness
            );
    }

    // the lower wall
    polyline(
        [[0, 0], [block_width * columns, 0]], 
        wall_thickness);
    // the left wall
    polyline(
        [[0, block_width], [0, block_width * rows]], 
        wall_thickness);
}
```

--------------------------------

### Define a Cube using `polyhedron`

Source: https://openhome.cc/eGossip/OpenSCAD/FunctionGrapher.html

This snippet demonstrates how to define a cube by specifying its eight vertices and the indices of the vertices that form each face. Ensure faces are defined in a clockwise order.

```openscad
CubePoints = [
  [  0,  0,  0 ],  //0
  [ 10,  0,  0 ],  //1
  [ 10,  7,  0 ],  //2
  [  0,  7,  0 ],  //3
  [  0,  0,  5 ],  //4
  [ 10,  0,  5 ],  //5
  [ 10,  7,  5 ],  //6
  [  0,  7,  5 ]]; //7

CubeFaces = [
  [0,1,2,3],  // bottom
  [4,5,1,0],  // front
  [7,6,5,4],  // top
  [5,6,2,1],  // right
  [6,7,3,2],  // back
  [7,4,0,3]]; // left

polyhedron( CubePoints, CubeFaces );
```

--------------------------------

### Create a 3D Line using Hull and Spheres

Source: https://openhome.cc/eGossip/OpenSCAD/Polyline3D.html

This module creates a 3D line between two points using the `hull` operation on two spheres. Adjust the `thickness` parameter for line width and `fn` for resolution. Note that a higher `fn` value increases rendering time.

```openscad
module line3D(p1, p2, thickness, fn = 24) {
    $fn = fn;

    hull() {
        translate(p1) sphere(thickness / 2);
        translate(p2) sphere(thickness / 2);
    }
}

line3D([1, 1, 1], [10, 10, 10], 1, 3);
```

--------------------------------

### Basic OpenSCAD Sector Module

Source: https://openhome.cc/eGossip/OpenSCAD/SectorArc.html

A foundational module to draw a sector of a circle. It uses the difference operation between a circle and a polygon. Note: This initial version may have issues with coverage at the edges.

```openscad
radius = 20;
angles = [45, 135];
fn = 12;

module sector(radius, angles, fn = 24) {
    step = -360 / fn;

    points = concat([[0, 0]],
        [for(a = [angles[0] : step : angles[1] - 360]) 
            [radius * cos(a), radius * sin(a)]
        ],
        [[radius * cos(angles[1]), radius * sin(angles[1])]]
    );

    difference() {
        circle(radius, $fn = fn);
        #polygon(points);
    }
}

sector(radius, angles, fn);

```

--------------------------------

### Define a Basic Chinese Word Module

Source: https://openhome.cc/eGossip/OpenSCAD/ModuleFunction.html

Encapsulates text rendering operations into a reusable module. Ensure 'height', 'offset_for_center', 'word', and 'font' variables are defined in the scope.

```openscad
height = 10;
offset_for_center = -height / 2;
word = "春";
font = "標楷體";

module chinese_word() {
    translate([offset_for_center, offset_for_center, offset_for_center])
        linear_extrude(height) 
            text(word, font = font);
}

chinese_word();
```

--------------------------------

### Basic Polyline Module

Source: https://openhome.cc/eGossip/OpenSCAD/Polyline.html

This snippet defines a basic `line` module and a `polyline` module that draws a series of connected lines. It's suitable for simple cases where gaps at the endpoints are not a concern.

```openscad
module line(point1, point2, width = 1) {
    angle = 90 - atan((point2[1] - point1[1]) / (point2[0] - point1[0]));
    offset_x = 0.5 * width * cos(angle);
    offset_y = 0.5 * width * sin(angle);

    offset1 = [-offset_x, offset_y];
    offset2 = [offset_x, -offset_y];

    polygon(points=[
        point1 + offset1, point2 + offset1,  
        point2 + offset2, point1 + offset2
    ]);
}

module polyline(points, width = 1) {
    module polyline_inner(points, index) {
        if(index < len(points)) {
            line(points[index - 1], points[index], width);
            polyline_inner(points, index + 1);
        }
    }

    polyline_inner(points, 1);
}

polyline([[1, 2], [-5, -4], [-5, 3], [5, 5]], 1);
```
Tokens:
Raw