L Systems

1# Defining the Rules of Nature
2def define_l_system_grammar():
3    """Setting up the alphabet and the rules."""
4    
5    # The starting point (Axiom)
6    axiom = "F"
7    
8    # The Rules: Every time you see 'F', replace it with this string!
9    # F = Draw Forward
10    # + = Turn Right
11    # - = Turn Left
12    rules = {
13        "F": "F+F-F-F+F"
14    }
15    
16    return axiom, rules

1# Replacing Text with Text
2def expand_grammar(current_string, rules):
3    """The recursive heart of the algorithm."""
4    
5    next_string = ""
6    
7    # Read every character one by one
8    for char in current_string:
9        
10        # If there's a rule for this letter, swap it!
11        if char in rules:
12            next_string += rules[char]
13            
14        # Otherwise, just keep the letter as it is
15        else:
16            next_string += char
17            
18    return next_string

1# Navigating in 3D Space
2def rotate_turtle(current_direction, axis, angle):
3    """The Matrix handles the hard math for us."""
4    
5    # + = Turn around Z axis (Yaw)
6    # & = Pitch down around X axis
7    # ^ = Pitch up around X axis
8    # \ = Roll left around Y axis
9    # / = Roll right around Y axis
10    
11    # We use a 3x3 Rotation Matrix to perfectly calculate the new 3D vector
12    rotation_matrix = Matrix.Rotation(angle, axis)
13    
14    new_direction = rotation_matrix * current_direction
15    
16    return new_direction

1# Creating Branches
2def process_branching_string(char, turtle, stack):
3    """How to grow a leaf and return to the main trunk."""
4    
5    # '[' pushes the current State onto the Stack
6    if char == "[":
7        current_state = {
8            "position": turtle.position.copy(),
9            "heading": turtle.heading.copy()
10        }
11        stack.push(current_state)
12        
13    # ']' pops the State off the Stack
14    elif char == "]":
15        saved_state = stack.pop()
16        
17        # Teleport the turtle back to where it was!
18        turtle.position = saved_state["position"]
19        turtle.heading = saved_state["heading"]

1# Generating Real 3D Geometry
2def build_3d_branch(start_point, end_point, thickness):
3    """Converting invisible math lines into solid wood."""
4    
5    # 1. The Turtle drew a line from start to end
6    vector = end_point - start_point
7    length = length(vector)
8    
9    # 2. We generate a 3D Cylinder geometry
10    branch_mesh = Cylinder(radius=thickness, height=length)
11    
12    # 3. We move the cylinder to exactly halfway between the points
13    midpoint = (start_point + end_point) / 2
14    branch_mesh.position = midpoint
15    
16    # 4. We rotate the cylinder so it aligns perfectly with the vector
17    branch_mesh.align_to_vector(vector)
18    
19    return branch_mesh

1# Natural Tapering
2def build_tree_branch(char, turtle):
3    """Making it look organic."""
4    
5    # 1. As the turtle moves forward, it draws a branch
6    if char == "F":
7        
8        # Draw the cylinder using the CURRENT thickness
9        build_3d_branch(turtle.position, thickness=turtle.current_thickness)
10        
11        # 2. Every time a branch grows, it gets slightly thinner!
12        # This creates the natural tapering of a real tree trunk.
13        turtle.current_thickness = turtle.current_thickness * 0.85
14        
15        # 3. The branch also gets slightly shorter!
16        turtle.current_length = turtle.current_length * 0.90

1# L-System parser drawing to a 2D canvas
2def draw_l_system(canvas_ctx, expanded_string, angle_rad, step_size):
3    stack = []
4    x, y = 0.0, 0.0
5    heading = -Math.PI / 2 # Upwards
6    
7    for cmd in expanded_string:
8        if cmd == 'F':
9            nx = x + cos(heading) * step_size
10            ny = y + sin(heading) * step_size
11            canvas_ctx.line(x, y, nx, ny)
12            x, y = nx, ny
13        elif cmd == '+':
14            heading += angle_rad
15        elif cmd == '-':
16            heading -= angle_rad
17        elif cmd == '[':
18            stack.append((x, y, heading))
19        elif cmd == ']':
20            x, y, heading = stack.pop()