sdforge 0.2.0__tar.gz → 0.2.1__tar.gz

{sdforge-0.2.0/sdforge.egg-info → sdforge-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdforge
-Version: 0.2.0
+Version: 0.2.1
 Summary: A Python library for SDF modeling with real-time GLSL rendering and mesh export.
 Home-page: https://github.com/nassimberrada/sdforge
 Author: nassimberrada
@@ -23,9 +23,12 @@ Provides-Extra: ui
 Requires-Dist: imgui[glfw]>=2.0.0; extra == "ui"
 Provides-Extra: export
 Requires-Dist: pygltflib; extra == "export"
+Provides-Extra: saving
+Requires-Dist: trimesh; extra == "saving"
 Provides-Extra: full
 Requires-Dist: imgui[glfw]>=2.0.0; extra == "full"
 Requires-Dist: pygltflib; extra == "full"
+Requires-Dist: trimesh; extra == "full"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{sdforge-0.2.0 → sdforge-0.2.1}/examples/camera.py

@@ -6,7 +6,7 @@ def static_camera_example():
     Returns a scene and a fixed Camera object.
     The renderer will use this camera's position and target.
     """
-    scene = box(1.5, radius=0.1) | sphere(1.2)
+    scene = box(1.5).round(0.1) | sphere(radius=1.2)
     
     # Define a camera positioned at (4, 3, 4), looking at the origin.
     cam = Camera(position=(4, 3, 4), target=(0, 0, 0), zoom=1.5)
@@ -19,7 +19,7 @@ def interactive_camera_example():
     When no camera is provided to the render function, it defaults
     to an interactive orbit camera controlled by the mouse.
     """
-    scene = box(1.5, radius=0.1) | sphere(1.2)
+    scene = box(1.5).round(0.1) | sphere(radius=1.2)
     return scene
 
 def main():

sdforge-0.2.1/examples/constraints.py

@@ -0,0 +1,213 @@
+import sys
+import numpy as np
+from sdforge import box, sphere, cylinder, line, Param, Group, X, Y, Z, cone
+from sdforge.api.constraints import (
+    tangent_offset,
+    midpoint,
+    distribute,
+)
+
+def dimensional_equality_example():
+    """
+    Demonstrates dimensional equality by using the same Param object
+    for multiple dimensions, ensuring they always match.
+    """
+    p_hole_dia = Param("Hole Diameter", 0.8, 0.2, 1.5)
+    block = box(size=(3, 1, 2))
+    hole = cylinder(radius=p_hole_dia / 2, height=1.1)
+    sphere_on_top = sphere(radius=p_hole_dia / 2).translate((0, 1.0, 0))
+
+    scene = (block - hole) | sphere_on_top
+    return scene
+
+def tangent_and_coincident_example():
+    """
+    Demonstrates creating tangent and coincident relationships through
+    explicit calculation and construction.
+    """
+    center_point = np.array([0.0, 0.0, 0.0])
+    c = cylinder(radius=1.0, height=0.2)
+
+    line_dir = np.array([1.0, 1.0, 0.0])
+    line_dir /= np.linalg.norm(line_dir) 
+
+    offset = tangent_offset(circle_radius=1.0, line_direction=line_dir)
+
+    tangent_line = line(
+        start = center_point + offset - line_dir * 2,
+        end = center_point + offset + line_dir * 2,
+        radius=0.1
+    )
+
+    scene = c | tangent_line
+    return scene
+
+def perpendicular_and_parallel_example():
+    """
+    Demonstrates creating perpendicular and parallel features by construction,
+    using the .align_to() method.
+    """
+    main_block = box(size=(2.0, 1.0, 1.5))
+    main_block_half_size = np.array(main_block.size) / 2.0
+
+    # A boss to be placed on the +X face, perpendicular to it.
+    boss = cylinder(radius=0.3, height=0.5)
+
+    # Define the point on the center of the +X face of the block
+    face_point_positive_x = X * main_block_half_size[0]
+
+    # Use the fluent helper method .align_to()
+    aligned_boss = boss.align_to(reference_point=face_point_positive_x, face_normal=X)
+
+    # A hole through the -X face.
+    hole = cylinder(radius=0.2, height=2.1)
+    face_point_negative_x = -X * main_block_half_size[0]
+    aligned_hole = hole.align_to(reference_point=face_point_negative_x, face_normal=-X)
+
+    scene = (main_block | aligned_boss) - aligned_hole
+    return scene
+
+def angle_and_midpoint_example():
+    """
+    Demonstrates placing features at an angle and at the midpoint of an edge.
+    """
+    flange = cylinder(radius=2.0, height=0.5) - cylinder(radius=1.5, height=0.6)
+    hole = cylinder(radius=0.2, height=0.6)
+
+    # Use the fluent .place_at_angle() method
+    num_holes = 6
+    holes = []
+    for i in range(num_holes):
+        angle = i * (2 * np.pi / num_holes)
+        h = hole.place_at_angle(
+            pivot_point=(0,0,0), 
+            axis=Y, 
+            angle_rad=angle, 
+            distance=1.75
+        )
+        holes.append(h)
+
+    corner_a = np.array([2.5, 0, -0.5])
+    corner_b = np.array([2.5, 0, 0.5])
+    slot_center = midpoint(corner_a, corner_b)
+    slot = box(size=(0.2, 0.6, 1.5)).round(0.1).translate(slot_center)
+
+    scene = (flange - Group(*holes)) | slot
+    return scene
+
+def offset_and_bounds_example():
+    """
+    Demonstrates offsetting an object along a vector and creating a
+    bounding box around a complex shape.
+    """
+    base_part = box(1.0).scale((2, 0.5, 1)) | sphere(radius=0.8).translate(X * 0.7)
+
+    # Use fluent .offset_along()
+    pillar_start_point = np.array([0.0, -1.0, 0.0])
+    pillar_direction = np.array([-1.0, -0.5, 1.0])
+    pillar = cylinder(0.2, 1.5)
+    placed_pillar = pillar.offset_along(pillar_start_point, pillar_direction, 2.0)
+
+    # Generate a bounding box using the fluent .bounding_box() method
+    bbox = base_part.bounding_box(padding=0.1)
+
+    # Make the bounding box hollow
+    enclosure = bbox.shell(0.05)
+
+    final_scene = enclosure.color(0.4, 0.4, 0.5) | base_part.color(1, 0, 0) | placed_pillar
+    return final_scene
+
+def stacking_example():
+    """
+    Demonstrates the .stack() method to place objects relative to each other
+    without manual coordinate calculations.
+    """
+    # 1. Start with a large base
+    base = box(size=(3.0, 0.5, 3.0)).round(0.1)
+    
+    # 2. Stack a cylinder on top (+Y)
+    # The system calculates the top face of the box and bottom face of the cylinder
+    # and positions them to touch.
+    pedestal = cylinder(radius=1.0, height=1.0)
+    stage_1 = base.stack(pedestal, direction=(0, 1, 0))
+    
+    # 3. Stack a sphere on top of the resulting union, with a small gap
+    orb = sphere(radius=0.8).color(1, 0.2, 0.2)
+    final_scene = stage_1.stack(orb, direction=(0, 1, 0), spacing=0.2)
+    
+    return final_scene
+
+def distribute_example():
+    """
+    Demonstrates the distribute() function to layout multiple objects sequentially.
+    """
+    shapes = [
+        box(1.0).color(0.8, 0.2, 0.2),       # Red Box
+        sphere(0.6).color(0.2, 0.8, 0.2),    # Green Sphere
+        cylinder(0.4, 1.5).color(0.2, 0.2, 0.8), # Blue Cylinder
+        cone(1.0, 0.5).color(0.8, 0.8, 0.2)  # Yellow Cone
+    ]
+    
+    # Distribute them along the X axis with a 0.5 unit gap between each
+    scene = distribute(shapes, direction=(1, 0, 0), spacing=0.5)
+    
+    return scene
+
+def design_patterns_example():
+    """
+    Demonstrates achieving constraints like concentricity and symmetry
+    using core SDForge features as a design pattern.
+    """
+    center = np.array([2.0, 0.5, 0.0])
+
+    outer_cyl = cylinder(radius=0.8, height=1.0).translate(center)
+    inner_cyl = cylinder(radius=0.5, height=1.2).translate(center)
+    concentric_part = outer_cyl - inner_cyl
+
+    quarter_shape = box(size=(1, 0.4, 1)).round(0.1).translate((0.5, 0.2, 0.5))
+    cutout = sphere(radius=0.3).translate((0.8, 0.2, 0.8))
+    quarter_part = quarter_shape - cutout
+
+    symmetrical_part = quarter_part.mirror(X | Z).translate((-2.0, 0, 0))
+
+    scene = concentric_part | symmetrical_part
+    return scene
+
+def main():
+    """
+    Renders a constraints example based on a command-line argument.
+    """
+    print("--- SDForge Constraints by Construction Examples ---")
+
+    examples = {
+        "dims_equal": dimensional_equality_example,
+        "tangent": tangent_and_coincident_example,
+        "alignment": perpendicular_and_parallel_example,
+        "angle_midpoint": angle_and_midpoint_example,
+        "offset_bounds": offset_and_bounds_example,
+        "stack": stacking_example,
+        "distribute": distribute_example,
+        "patterns": design_patterns_example,
+    }
+
+    if len(sys.argv) < 2:
+        print("\nPlease provide the name of an example to run.")
+        print("Available examples:")
+        for key in examples:
+            print(f"  - {key}")
+        print(f"\nUsage: python {sys.argv[0]} <example_name>")
+        return
+
+    example_name = sys.argv[1]
+    scene_func = examples.get(example_name)
+
+    if not scene_func:
+        print(f"\nError: Example '{example_name}' not found.")
+        return
+
+    print(f"Rendering: {example_name.replace('_', ' ').title()} Example")
+    scene = scene_func()
+    scene.render()
+
+if __name__ == "__main__":
+    main()

{sdforge-0.2.0 → sdforge-0.2.1}/examples/debug.py

@@ -3,25 +3,41 @@ from sdforge import box, sphere, Debug
 
 def normals_debug_example():
     """Visualizes the surface normals as colors."""
-    scene = box(1.5, radius=0.1) - sphere(1.2)
+    scene = box(1.5).round(0.1) - sphere(radius=1.2)
     debug = Debug('normals')
     return scene, debug
 
 def steps_debug_example():
     """Visualizes the number of raymarching steps."""
-    scene = box(1.5, radius=0.1) - sphere(1.2)
+    scene = box(1.5).round(0.1) - sphere(radius=1.2)
     debug = Debug('steps')
     return scene, debug
 
+def slice_debug_example():
+    """
+    Visualizes a 2D cross-section of the distance field.
+
+    Orange = Positive distance (Outside)
+    Blue   = Negative distance (Inside)
+    White  = Surface boundary
+    """
+    # A hollow sphere cut in half
+    scene = sphere(1.0).shell(0.1) - box(1.0).translate((0.5, 0, 0))
+
+    # Slice through the XY plane at Z=0, with a view scale of 3.0 units
+    debug = Debug('slice', plane='xy', slice_height=0.0, view_scale=3.0)
+    return scene, debug
+
 def main():
     """Renders a debug example based on a command-line argument."""
     print("--- SDForge Debug Examples ---")
-    
+
     examples = {
         "normals": normals_debug_example,
         "steps": steps_debug_example,
+        "slice": slice_debug_example,
     }
-    
+
     if len(sys.argv) < 2:
         print("\nPlease provide the name of an example to run.")
         print("Available examples:")
@@ -32,17 +48,17 @@ def main():
 
     example_name = sys.argv[1]
     scene_func = examples.get(example_name)
-    
+
     if not scene_func:
         print(f"\nError: Example '{example_name}' not found.")
         return
 
     print(f"Rendering: {example_name.replace('_', ' ').title()} Example")
     result = scene_func()
-    
+
     scene, debug = None, None
     for item in result:
-        from sdforge.core import SDFNode
+        from sdforge.api.core import SDFNode
         if isinstance(item, SDFNode): scene = item
         if isinstance(item, Debug): debug = item
 

{sdforge-0.2.0 → sdforge-0.2.1}/examples/export.py

@@ -10,7 +10,7 @@ def main():
 
     # Create a scene with some complexity and a parameter.
     p_radius = Param("Sphere Radius", 0.8, 0.5, 1.5)
-    scene = box(1.5, radius=0.1) - sphere(p_radius)
+    scene = box(1.5).round(0.1) - sphere(radius=p_radius)
 
     output_path = "exported_shader.glsl"
     print(f"Exporting scene to '{output_path}'...")

{sdforge-0.2.0 → sdforge-0.2.1}/examples/group.py

@@ -7,8 +7,8 @@ def group_transform_example():
     Demonstrates applying a single transformation to a group of objects.
     """
     # Create two separate objects, offset from the origin.
-    b = box(size=(1.5, 0.5, 0.5), radius=0.1).translate((-1, 0, 0))
-    s = sphere(0.5).translate((1, 0, 0))
+    b = box(size=(1.5, 0.5, 0.5)).round(0.1).translate((-1, 0, 0))
+    s = sphere(radius=0.5).translate((1, 0, 0))
     
     # Combine them into a group.
     g = Group(b, s)

{sdforge-0.2.0 → sdforge-0.2.1}/examples/light.py

@@ -4,13 +4,13 @@ from sdforge import box, sphere, Light, Camera
 
 def static_light_example():
     """A scene lit by a single, fixed-position light."""
-    scene = box(1.5, radius=0.1) | sphere(1.2)
+    scene = box(1.5).round(0.1) | sphere(radius=1.2)
     light = Light(position=(4, 5, 3), shadow_softness=16.0)
     return scene, light
 
 def headlight_example():
     """A scene lit by a headlight attached to the camera."""
-    scene = box(1.5, radius=0.1) | sphere(1.2)
+    scene = box(1.5).round(0.1) | sphere(radius=1.2)
     # When Light() is created with no position, it defaults to the camera's position.
     light = Light(shadow_softness=32.0, ao_strength=5.0)
     return scene, light
@@ -46,7 +46,7 @@ def main():
     
     # Unpack the result tuple which may contain scene, light, and/or camera
     scene, light, cam = None, None, None
-    from sdforge.core import SDFNode
+    from sdforge.api.core import SDFNode
     for item in result:
         if isinstance(item, SDFNode): scene = item
         if isinstance(item, Light): light = item

sdforge-0.2.1/examples/material.py

@@ -0,0 +1,65 @@
+import sys
+from sdforge import box, sphere, cylinder, X
+
+def simple_material_example():
+    """
+    Demonstrates applying different colors to objects.
+    """
+    # A blue sphere is subtracted from a red box.
+    red_box = box(1.5).round(0.1).color(1.0, 0.2, 0.2)
+    blue_sphere = sphere(radius=1.2).color(0.3, 0.5, 1.0)
+    
+    scene = red_box - blue_sphere
+    return scene
+
+def masked_material_example():
+    """
+    Demonstrates applying a color to a specific region using a mask.
+    This creates a 'decal' effect or a pattern.
+    """
+    # Base object: White box
+    base = box(2.0).color(0.9, 0.9, 0.9)
+    
+    # Mask: A cylinder running through the box along X
+    # We want to paint the box red where this cylinder intersects it.
+    mask_shape = cylinder(radius=0.5, height=3.0).rotate(X, 1.57).translate((0, 0.5, 0))
+    
+    # Apply red color using the mask.
+    # Where mask < 0 (inside cylinder), color is Red.
+    # Elsewhere, it keeps the previous color (White).
+    scene = base.color(1.0, 0.1, 0.1, mask=mask_shape)
+    
+    return scene
+
+def main():
+    """
+    Renders an example based on a command-line argument.
+    """
+    print("--- SDForge Material Examples ---")
+    
+    examples = {
+        "simple": simple_material_example,
+        "masked": masked_material_example,
+    }
+    
+    if len(sys.argv) < 2:
+        print("\nPlease provide the name of an example to run.")
+        print("Available examples:")
+        for key in examples:
+            print(f"  - {key}")
+        print(f"\nUsage: python {sys.argv[0]} <example_name>")
+        return
+
+    example_name = sys.argv[1]
+    scene_func = examples.get(example_name)
+    
+    if not scene_func:
+        print(f"\nError: Example '{example_name}' not found.")
+        return
+
+    print(f"Rendering: {example_name.replace('_', ' ').title()} Example")
+    scene = scene_func()
+    scene.render()
+
+if __name__ == "__main__":
+    main()

{sdforge-0.2.0 → sdforge-0.2.1}/examples/noise.py

@@ -3,13 +3,13 @@ from sdforge import sphere, box
 
 def noise_displacement_example():
     """Applies procedural noise to the surface of a sphere."""
-    s = sphere(r=1.2)
+    s = sphere(radius=1.2)
     # Higher scale = finer detail, higher strength = more displacement.
     return s.displace_by_noise(scale=8.0, strength=0.1)
 
 def sine_wave_displacement_example():
     """Applies a custom GLSL sine wave displacement to a box."""
-    b = box(size=1.8, radius=0.1)
+    b = box(size=1.8).round(0.1)
     # You can use any GLSL expression that returns a float.
     # The variable 'p' represents the point in space being sampled.
     glsl_code = "sin(p.x * 20.0) * sin(p.z * 20.0) * 0.05"

sdforge-0.2.1/examples/operations.py

@@ -0,0 +1,149 @@
+import sys
+import numpy as np
+from sdforge import sphere, box, cylinder, X, Y, Param
+
+def union_example():
+    """A sphere and a box joined together."""
+    s = sphere(radius=0.8)
+    b = box(size=(1.5, 0.5, 0.5))
+    return s | b
+
+def intersection_example():
+    """A lens shape created by intersecting two spheres."""
+    s1 = sphere(radius=1.0).translate((-0.5, 0, 0))
+    s2 = sphere(radius=1.0).translate((0.5, 0, 0))
+    return s1 & s2
+
+def difference_example():
+    """A box with a sphere carved out of it."""
+    b = box(size=1.5)
+    s = sphere(radius=1.0)
+    return b - s
+
+def smooth_union_example():
+    """Two spheres smoothly blended together."""
+    s1 = sphere(radius=0.7).translate((-0.5, 0, 0))
+    s2 = sphere(radius=0.7).translate((0.5, 0, 0))
+    # The 'blend' parameter controls the smoothness of the blend.
+    return s1.union(s2, blend=0.3)
+
+def masked_blend_example():
+    """
+    Demonstrates using a mask to apply smoothing only to specific areas.
+    The union transitions from a sharp crease to a smooth fillet.
+    """
+    # Two spheres sitting next to each other
+    s1 = sphere(radius=0.7).translate((-0.6, 0, 0))
+    s2 = sphere(radius=0.7).translate((0.6, 0, 0))
+
+    # Mask: A box covering the top half (Y > 0)
+    # The blend will be 0.4 inside this box, and 0.0 (sharp) outside.
+    mask_obj = box(size=(3, 2, 3)).translate((0, 1.0, 0))
+
+    # Apply variable smoothing
+    return s1.union(s2, blend=0.4, mask=mask_obj, mask_falloff=0.2)
+
+def fillet_difference_example():
+    """Demonstrates subtracting a shape with a rounded (filleted) edge."""
+    plate = box(size=(2.0, 0.5, 2.0))
+    hole = cylinder(radius=0.5, height=1.0)
+
+    # blend=0.1 creates a rounded edge where the cylinder is subtracted.
+    scene = plate.difference(hole, blend=0.1)
+    return scene
+
+def linear_difference_example():
+    """Demonstrates subtracting a shape with a linear (chamfered) edge."""
+    plate = box(size=(2.0, 0.5, 2.0))
+    hole = cylinder(radius=0.5, height=1.0)
+
+    # blend=0.1, blend_type='linear' creates a 45-degree bevel.
+    scene = plate.difference(hole, blend=0.1, blend_type='linear')
+    return scene
+
+def fillet_union_example():
+    """Demonstrates joining two shapes with a filleted seam."""
+    s1 = sphere(0.8).translate(-X * 0.5)
+    s2 = sphere(0.8).translate(X * 0.5)
+
+    # The blend parameter smoothly blends the two spheres together.
+    scene = s1.union(s2, blend=0.4)
+    return scene
+
+def morphing_example():
+    """
+    Demonstrates interpolating between two shapes (morphing).
+    Uses a Param to make it interactive.
+    """
+    s = sphere(radius=1.0)
+    b = box(size=1.5)
+
+    # Use a parameter to control the morph factor (0.0 = sphere, 1.0 = box)
+    p_morph = Param("Morph Factor", 0.5, 0.0, 1.0)
+
+    return s.morph(b, factor=p_morph)
+
+def masked_morph_example():
+    """
+    Demonstrates a partial morph. The object is a sphere on the left
+    and transitions into a box on the right.
+    """
+    s = sphere(1.0)
+    b = box(1.5)
+    
+    # Mask covers the right side (X > 0).
+    # Inside mask -> Factor 1.0 (Box)
+    # Outside mask -> Factor 0.0 (Sphere)
+    mask_obj = box(3.0).translate((1.5, 0, 0))
+    
+    return s.morph(b, factor=1.0, mask=mask_obj, mask_falloff=0.5)
+
+def main():
+    """
+    Renders an example based on a command-line argument.
+    """
+    print("--- SDForge Operation Examples ---")
+
+    examples = {
+        "union": union_example,
+        "intersection": intersection_example,
+        "difference": difference_example,
+        "smooth_union": smooth_union_example,
+        "masked_blend": masked_blend_example,
+        "fillet_cut": fillet_difference_example,
+        "linear_cut": linear_difference_example,
+        "fillet_join": fillet_union_example,
+        "morph": morphing_example,
+        "masked_morph": masked_morph_example,
+    }
+
+    if len(sys.argv) < 2:
+        print("\nPlease provide the name of an example to run.")
+        print("Available examples:")
+        for key in examples:
+            print(f"  - {key}")
+        print(f"\nUsage: python {sys.argv[0]} <example_name>")
+        return
+
+    example_name = sys.argv[1]
+    scene_func = examples.get(example_name)
+
+    if not scene_func:
+        print(f"\nError: Example '{example_name}' not found.")
+        print("Available examples are:")
+        for key in examples:
+            print(f"  - {key}")
+        return
+
+    print(f"Rendering: {example_name.replace('_', ' ').title()} Example")
+    result = scene_func()
+    if isinstance(result, tuple):
+        scene, cam = result
+        scene.render(camera=cam)
+    else:
+        scene = result
+        scene.render()
+
+
+if __name__ == "__main__":
+    main()

{sdforge-0.2.0 → sdforge-0.2.1}/examples/params.py

@@ -5,7 +5,7 @@ import numpy as np
 def main():
     """
     Demonstrates using interactive parameters.
-    
+
     While this script is running, a UI would typically appear allowing you
     to drag sliders to change the model in real-time. This example sets up
     the backend for that functionality.
@@ -19,8 +19,8 @@ def main():
     p_twist = Param("Twist", 0.0, -10.0, 10.0)
 
     # Use the Param objects just like regular numbers.
-    scene = box(size=p_size, radius=p_radius).twist(p_twist)
-    
+    scene = box(size=p_size).round(p_radius).twist(strength=p_twist)
+
     # You can also use them in GLSL expressions for animation.
     # Note: `save()` will fail if string expressions are used.
     # animated_box = box(1.0).translate((np.sin(time) * p_size, 0, 0))