sdforge 0.1.0__py3-none-any.whl

sdforge/glsl/sdf/operations.glsl

@@ -0,0 +1,40 @@
+// --- Standard Boolean Operations ---
+// These operate on vec4(distance, material_id, 0, 0)
+
+vec4 opU(vec4 a, vec4 b) {
+    return (a.x < b.x) ? a : b;
+}
+
+vec4 opI(vec4 a, vec4 b) {
+    return (a.x > b.x) ? a : b;
+}
+
+vec4 opS(vec4 a, vec4 b) {
+    return opI(a, vec4(-b.x, b.y, b.z, b.w));
+}
+
+
+// --- Smooth Boolean Operations ---
+
+vec4 sUnion(vec4 a, vec4 b, float k ) 
+{
+    float h = clamp( 0.5 + 0.5*(b.x-a.x)/k, 0.0, 1.0 );
+    float dist = mix( b.x, a.x, h ) - k*h*(1.0-h);
+    // Return the material of the object that is closer at the blend point
+    return (a.x < b.x) ? vec4(dist, a.y, a.z, a.w) : vec4(dist, b.y, b.z, b.w);
+}
+
+vec4 sIntersect(vec4 a, vec4 b, float k ) 
+{
+    float h = clamp( 0.5 - 0.5*(b.x-a.x)/k, 0.0, 1.0 );
+    float dist = mix( b.x, a.x, h ) + k*h*(1.0-h);
+    return (a.x > b.x) ? vec4(dist, a.y, a.z, a.w) : vec4(dist, b.y, b.z, b.w);
+}
+
+vec4 sDifference(vec4 a, vec4 b, float k ) 
+{
+    float h = clamp( 0.5 - 0.5*(b.x+a.x)/k, 0.0, 1.0 );
+    float dist = mix( b.x, -a.x, h ) + k*h*(1.0-h);
+    // Difference is tricky, it usually inherits the material of the first object
+    return vec4(dist, a.y, a.z, a.w);
+}

sdforge/glsl/sdf/primitives.glsl

@@ -0,0 +1,79 @@
+// sdforge/glsl/sdf/primitives.glsl
+
+// --- 3D Primitives ---
+
+float sdSphere(in vec3 p, in float r) {
+    return length(p) - r;
+}
+
+float sdBox(in vec3 p, in vec3 b) {
+    vec3 q = abs(p) - b;
+    return length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0);
+}
+
+float sdRoundedBox(in vec3 p, in vec3 b, in float r) {
+    vec3 q = abs(p) - b;
+    return length(max(q, 0.0)) - r;
+}
+
+float sdTorus(in vec3 p, in vec2 t) { // t.x=major radius, t.y=minor radius
+    vec2 q = vec2(length(p.xz) - t.x, p.y);
+    return length(q) - t.y;
+}
+
+float sdCapsule(in vec3 p, in vec3 a, in vec3 b, in float r) {
+    vec3 pa = p - a, ba = b - a;
+    float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+    return length(pa - ba * h) - r;
+}
+
+float sdCone(in vec3 p, in vec2 c) { // c.x=height, c.y=radius
+    vec2 q = vec2(length(p.xz), p.y);
+    vec2 a = c - q;
+    vec2 b = q - c * vec2(1, -1);
+    float k = sign(c.y);
+    float d = min(dot(a, a), dot(b, b));
+    float s = max(k * (q.x * c.y - q.y * c.x), k * (q.y - c.y));
+    return sqrt(d) * sign(s);
+}
+
+float sdPlane(in vec3 p, in vec4 n) { // n.xyz is normal, n.w is offset
+    return dot(p, n.xyz) + n.w;
+}
+
+float sdHexPrism(in vec3 p, in vec2 h) { // h.x=radius, h.y=height
+    const vec3 k = vec3(-0.8660254, 0.5, 0.57735026);
+    p = abs(p);
+    p.xy -= 2.0 * min(dot(k.xy, p.xy), 0.0) * k.xy;
+    vec2 d = vec2(
+         length(p.xy - vec2(clamp(p.x, -k.z * h.x, k.z * h.x), h.x)) * sign(p.y - h.x),
+         p.z - h.y);
+    return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
+}
+
+float sdOctahedron(in vec3 p, in float s) {
+    p = abs(p);
+    return (p.x + p.y + p.z - s) * 0.57735027;
+}
+
+float sdEllipsoid(in vec3 p, in vec3 r) { // r is radii on each axis
+    float k0 = length(p / r);
+    float k1 = length(p / (r * r));
+    return k0 * (k0 - 1.0) / k1;
+}
+
+float sdCylinder(vec3 p, vec2 h) { // h.x=radius, h.y=half-height
+    vec2 d = abs(vec2(length(p.xz), p.y)) - h;
+    return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
+}
+
+// --- 2D Primitives (for extrusion or direct use if p.z=0) ---
+
+float sdCircle(in vec2 p, in float r) {
+    return length(p) - r;
+}
+
+float sdRectangle(in vec2 p, in vec2 b) {
+    vec2 d = abs(p) - b;
+    return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}

sdforge/glsl/sdf/transforms.glsl

@@ -0,0 +1,46 @@
+// --- Transformations ---
+
+vec4 opTwist( in vec4 sdf_result, inout vec3 p, float k )
+{
+    float c = cos(k*p.y);
+    float s = sin(k*p.y);
+    mat2  m = mat2(c,-s,s,c);
+    p.xz = m*p.xz;
+
+    return sdf_result;
+}
+
+vec3 opRotateX(vec3 p, float theta) {
+  float c = cos(theta);
+  float s = sin(theta);
+  return vec3(p.x, p.y * c - p.z * s, p.y * s + p.z * c);
+}
+
+vec3 opRotateY(vec3 p, float theta) {
+  float c = cos(theta);
+  float s = sin(theta);
+  return vec3(p.x * c + p.z * s, p.y, -p.x * s + p.z * c);
+}
+
+vec3 opRotateZ(vec3 p, float theta) {
+  float c = cos(theta);
+  float s = sin(theta);
+  return vec3(p.x * c - p.y * s, p.x * s + p.y * c, p.z);
+}
+
+
+// --- Domain Repetition ---
+
+vec3 opRepeat(vec3 p, vec3 c)
+{
+    return mod(p + 0.5 * c, c) - 0.5 * c;
+}
+
+// --- Mirroring ---
+
+vec3 opMirror(vec3 p, vec3 a) {
+    if (a.x > 0.5) p.x = abs(p.x);
+    if (a.y > 0.5) p.y = abs(p.y);
+    if (a.z > 0.5) p.z = abs(p.z);
+    return p;
+}

sdforge/mesh.py

@@ -0,0 +1,95 @@
+import numpy as np
+import time
+import struct
+from skimage import measure
+
+def _cartesian_product(*arrays):
+    la = len(arrays)
+    dtype = np.result_type(*arrays)
+    arr = np.empty([len(a) for a in arrays] + [la], dtype=dtype)
+    for i, a in enumerate(np.ix_(*arrays)):
+        arr[...,i] = a
+    return arr.reshape(-1, la)
+
+def _write_binary_stl(path, points):
+    n = len(points) // 3
+    points = np.array(points, dtype='float32').reshape((-1, 3, 3))
+    normals = np.cross(points[:,1] - points[:,0], points[:,2] - points[:,0])
+    norm = np.linalg.norm(normals, axis=1).reshape((-1, 1))
+    normals /= np.where(norm == 0, 1, norm)
+
+    dtype = np.dtype([
+        ('normal', ('<f', 3)),
+        ('points', ('<f', (3, 3))),
+        ('attr', '<H'),
+    ])
+
+    a = np.zeros(n, dtype=dtype)
+    a['points'] = points
+    a['normal'] = normals
+
+    with open(path, 'wb') as fp:
+        fp.write(b'\x00' * 80)
+        fp.write(struct.pack('<I', n))
+        fp.write(a.tobytes())
+
+def save(sdf_obj, path, bounds=((-1.5, -1.5, -1.5), (1.5, 1.5, 1.5)), samples=2**22, verbose=True):
+    """
+    Generates a mesh from an SDF object using the Marching Cubes algorithm and saves it to a file.
+    """
+    start_time = time.time()
+    if verbose:
+        print(f"INFO: Generating mesh for '{path}'...")
+
+    try:
+        sdf_callable = sdf_obj.to_callable()
+    except (NotImplementedError, ImportError) as e:
+        print(f"ERROR: Could not generate mesh. {e}")
+        return
+
+    volume = (bounds[1][0] - bounds[0][0]) * (bounds[1][1] - bounds[0][1]) * (bounds[1][2] - bounds[0][2])
+    step = (volume / samples) ** (1 / 3)
+
+    if verbose:
+        print(f"  - Bounds: {bounds}")
+        print(f"  - Target samples: {samples}")
+        print(f"  - Voxel step size: {step:.4f}")
+
+    X = np.arange(bounds[0][0], bounds[1][0], step)
+    Y = np.arange(bounds[0][1], bounds[1][1], step)
+    Z = np.arange(bounds[0][2], bounds[1][2], step)
+
+    if verbose:
+        count = len(X)*len(Y)*len(Z)
+        print(f"  - Grid dimensions: {len(X)} x {len(Y)} x {len(Z)} = {count} points")
+
+    # Create all grid points (float32 for downstream libs)
+    points_grid = _cartesian_product(X, Y, Z).astype('f4')
+
+    if verbose:
+        print("  - Evaluating SDF on grid...")
+
+    distances = sdf_callable(points_grid)
+    distances = np.array(distances, dtype='f4').reshape(len(X), len(Y), len(Z))
+
+    try:
+        verts, faces, _, _ = measure.marching_cubes(distances, level=0, spacing=(step, step, step))
+    except ValueError:
+        print("ERROR: Marching cubes failed. The surface may not intersect the specified bounds or the SDF evaluation returned invalid values.")
+        print("  Suggestions:")
+        print("    - Increase 'samples' to produce a finer voxel grid (e.g. samples=2**23 or 2**24).")
+        print("    - Expand 'bounds' so the object is definitely inside the volume.")
+        print("    - Verify your SDF callable returns finite numeric distances for all points.")
+        return
+        
+    verts += np.array(bounds[0]) # Offset vertices to correct world position
+
+    if path.lower().endswith('.stl'):
+        _write_binary_stl(path, verts[faces])
+    else:
+        print(f"ERROR: Unsupported file format '{path}'. Only .stl is currently supported.")
+        return
+
+    elapsed = time.time() - start_time
+    if verbose:
+        print(f"SUCCESS: Mesh with {len(faces)} triangles saved to '{path}' in {elapsed:.2f}s.")

sdforge/render.py

@@ -0,0 +1,415 @@
+import sys
+import os
+import time
+from pathlib import Path
+import importlib.util
+import numpy as np
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+from .api import Camera, Light
+
+# The maximum number of unique materials supported in a scene.
+MAX_MATERIALS = 64
+
+def _glsl_format(val):
+    """Formats a Python value for injection into a GLSL string."""
+    if isinstance(val, str):
+        return val
+    return f"{float(val)}"
+
+def is_in_colab():
+    """Checks if the code is running in a Google Colab environment."""
+    return 'google.colab' in sys.modules
+
+def get_glsl_content(filename: str) -> str:
+    """Reads the content of a GLSL file from the package."""
+    glsl_dir = Path(__file__).parent / 'glsl'
+    try:
+        with open(glsl_dir / filename, 'r') as f:
+            return f.read()
+    except FileNotFoundError:
+        print(f"ERROR: Could not find GLSL file: {filename}")
+        return ""
+
+def assemble_shader_code(sdf_obj) -> str:
+    """Assembles the final GLSL scene function from an SDF object."""
+    # The Scene function now returns a vec4: (distance, material_id, 0, 0)
+    scene_glsl = sdf_obj.to_glsl()
+    inline_definitions = []
+    # Use a set to prevent duplicates, which cause redefinition errors
+    unique_defs = set(sdf_obj.get_glsl_definitions())
+    for d in unique_defs:
+        inline_definitions.append(d)
+    joined_defs = '\n'.join(inline_definitions)
+    return f"""
+    {joined_defs}
+    vec4 Scene(in vec3 p) {{ return {scene_glsl}; }}
+    """
+
+class NativeRenderer:
+    """Handles the creation of a native window and renders the SDF."""
+
+    def __init__(self, sdf_obj, camera=None, lighting=None, watch=False, width=1280, height=720, record=None, bg_color=(0.1, 0.12, 0.15)):
+        self.sdf_obj = sdf_obj
+        self.camera = camera
+        self.lighting = lighting
+        self.watching = watch
+        self.width = width
+        self.height = height
+        self.record_path = record
+        self.bg_color = bg_color
+        self.window = None
+        self.ctx = None
+        self.program = None
+        self.vao = None
+        self.vbo = None
+        self.script_path = os.path.abspath(sys.argv[0])
+        self.reload_pending = False
+
+    def _init_window(self):
+        import glfw
+        if not glfw.init(): raise RuntimeError("Could not initialize GLFW")
+        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
+        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
+        glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
+        glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
+        self.window = glfw.create_window(self.width, self.height, "SDF Forge Viewer", None, None)
+        if not self.window:
+            glfw.terminate()
+            raise RuntimeError("Could not create GLFW window")
+        glfw.make_context_current(self.window)
+
+    def _compile_shader(self):
+        import moderngl
+        
+        materials = []
+        self.sdf_obj._collect_materials(materials)
+        if len(materials) > MAX_MATERIALS:
+            print(f"WARNING: Exceeded maximum of {MAX_MATERIALS} materials. Truncating.")
+            materials = materials[:MAX_MATERIALS]
+
+        material_struct_glsl = "struct MaterialInfo { vec3 color; };\n"
+        material_uniform_glsl = f"uniform MaterialInfo u_materials[{max(1, len(materials))}];\n"
+
+        # --- Light ---
+        light_pos_str = "ro"
+        ambient_strength_str = "0.1"
+        shadow_softness_str = "8.0"
+        ao_strength_str = "3.0"
+
+        if self.lighting:
+            if self.lighting.position:
+                pos = self.lighting.position
+                light_pos_str = f"vec3({_glsl_format(pos[0])}, {_glsl_format(pos[1])}, {_glsl_format(pos[2])})"
+            ambient_strength_str = _glsl_format(self.lighting.ambient_strength)
+            shadow_softness_str = _glsl_format(self.lighting.shadow_softness)
+            ao_strength_str = _glsl_format(self.lighting.ao_strength)
+        
+        # --- Camera ---
+        camera_logic_glsl = ""
+        if self.camera:
+            pos = self.camera.position
+            pos_str = f"vec3({_glsl_format(pos[0])}, {_glsl_format(pos[1])}, {_glsl_format(pos[2])})"
+            
+            target = self.camera.target
+            target_str = f"vec3({_glsl_format(target[0])}, {_glsl_format(target[1])}, {_glsl_format(target[2])})"
+
+            zoom_str = _glsl_format(self.camera.zoom)
+            
+            camera_logic_glsl = f"cameraStatic(st, {pos_str}, {target_str}, {zoom_str}, ro, rd);"
+        else:
+            camera_logic_glsl = "cameraOrbit(st, u_mouse.xy, u_resolution, 1.0, ro, rd);"
+
+        scene_code = assemble_shader_code(self.sdf_obj)
+        
+        full_fragment_shader = f"""
+            #version 330 core
+            
+            uniform vec2 u_resolution;
+            uniform float u_time;
+            uniform vec4 u_mouse;
+            uniform vec3 u_bg_color;
+            
+            {material_struct_glsl}
+            {material_uniform_glsl}
+
+            out vec4 f_color;
+            
+            {get_glsl_content('sdf/primitives.glsl')}
+            {get_glsl_content('scene/camera.glsl')}
+            {get_glsl_content('scene/raymarching.glsl')}
+            {get_glsl_content('scene/lighting.glsl')}
+            
+            {scene_code}
+
+            void main() {{
+                vec2 st = (2.0 * gl_FragCoord.xy - u_resolution.xy) / u_resolution.y;
+                vec3 ro, rd;
+                {camera_logic_glsl}
+                
+                vec3 color = u_bg_color;
+                vec4 hit = raymarch(ro, rd);
+                float t = hit.x;
+                int material_id = int(hit.y);
+                
+                if (t > 0.0) {{
+                    vec3 p = ro + t * rd;
+                    vec3 normal = estimateNormal(p);
+                    vec3 lightPos = {light_pos_str};
+                    vec3 lightDir = normalize(lightPos - p);
+                    
+                    float diffuse = max(dot(normal, lightDir), {ambient_strength_str});
+                    float shadow = softShadow(p + normal * 0.01, lightDir, {shadow_softness_str});
+                    diffuse *= shadow;
+                    float ao = ambientOcclusion(p, normal, {ao_strength_str});
+                    
+                    vec3 material_color = vec3(0.8); // Default color if no material
+                    if (material_id >= 0 && material_id < {len(materials)}) {{
+                        material_color = u_materials[material_id].color;
+                    }}
+
+                    color = material_color * diffuse * ao;
+                }}
+                f_color = vec4(color, 1.0);
+            }}
+        """
+
+        vertex_shader = """
+            #version 330 core
+            in vec2 in_vert;
+            void main() { gl_Position = vec4(in_vert, 0.0, 1.0); }
+        """
+        try:
+            program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=full_fragment_shader)
+            print("INFO: Shader compiled successfully.")
+            
+            # Upload material data
+            for i, mat in enumerate(materials):
+                program[f'u_materials[{i}].color'].value = mat.color
+            
+            program['u_bg_color'].value = self.bg_color
+
+            return program
+        except Exception as e:
+            print(f"ERROR: Shader compilation failed. Keeping previous shader. Details:\n{e}")
+            return self.program
+
+    def _setup_gl(self):
+        import moderngl
+        self.ctx = moderngl.create_context()
+        self.program = self._compile_shader()
+        if self.program is None:
+            raise RuntimeError("Failed to compile initial shader. Cannot continue.")
+        vertices = np.array([-1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0], dtype='f4')
+        self.vbo = self.ctx.buffer(vertices)
+        self.vao = self.ctx.simple_vertex_array(self.program, self.vbo, 'in_vert')
+
+    def _reload_script(self):
+        print(f"INFO: Change detected in '{Path(self.script_path).name}'. Reloading...")
+        try:
+            spec = importlib.util.spec_from_file_location("user_script", self.script_path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            if hasattr(module, 'main') and callable(module.main):
+                result = module.main()
+                new_sdf_obj, new_cam_obj, new_lighting_obj = None, None, None
+                
+                if isinstance(result, tuple):
+                    new_sdf_obj = result[0]
+                    for item in result[1:]:
+                        if isinstance(item, Camera):
+                            new_cam_obj = item
+                        elif isinstance(item, Light):
+                            new_lighting_obj = item
+                else:
+                    new_sdf_obj = result
+                
+                if new_sdf_obj:
+                    self.sdf_obj = new_sdf_obj
+                    self.camera = new_cam_obj
+                    self.lighting = new_lighting_obj
+                    self.program = self._compile_shader()
+                    self.vao = self.ctx.simple_vertex_array(self.program, self.vbo, 'in_vert')
+            else:
+                print("WARNING: No valid `main` function found. Cannot reload.")
+        except Exception as e:
+            print(f"ERROR: Failed to reload script: {e}")
+
+    def _start_watcher(self):
+        class ChangeHandler(FileSystemEventHandler):
+            def __init__(self, renderer_instance): self.renderer = renderer_instance
+            def on_modified(self, event):
+                if event.src_path == self.renderer.script_path:
+                    self.renderer.reload_pending = True
+        
+        observer = Observer()
+        observer.schedule(ChangeHandler(self), str(Path(self.script_path).parent), recursive=False)
+        observer.daemon = True
+        observer.start()
+        print(f"INFO: Watching '{Path(self.script_path).name}' for changes...")
+
+    def run(self):
+        import glfw
+        import moderngl
+
+        writer = None
+        if self.record_path:
+            try:
+                import imageio
+                fps = 30
+                writer = imageio.get_writer(self.record_path, fps=fps)
+                print(f"INFO: Recording video to '{self.record_path}' at {fps} FPS.")
+            except ImportError:
+                print("ERROR: 'imageio' is required for video recording.\nPlease install it via: pip install sdforge[record]")
+                self.record_path = None
+
+        self._init_window()
+        self._setup_gl()
+        
+        if self.watching: self._start_watcher()
+
+        while not glfw.window_should_close(self.window):
+            if self.reload_pending:
+                self._reload_script()
+                self.reload_pending = False
+
+            width, height = glfw.get_framebuffer_size(self.window)
+            self.ctx.viewport = (0, 0, width, height)
+            
+            try: self.program['u_resolution'].value = (width, height)
+            except KeyError: pass
+            try: self.program['u_time'].value = glfw.get_time()
+            except KeyError: pass
+            try:
+                mx, my = glfw.get_cursor_pos(self.window)
+                self.program['u_mouse'].value = (mx, height - my, 0, 0)
+            except KeyError: pass
+
+            self.vao.render(mode=moderngl.TRIANGLE_STRIP)
+            
+            if writer:
+                frame_bytes = self.ctx.fbo.read(components=3, alignment=1)
+                frame_np = np.frombuffer(frame_bytes, dtype=np.uint8).reshape((height, width, 3))
+                writer.append_data(np.flipud(frame_np))
+            
+            glfw.swap_buffers(self.window)
+            glfw.poll_events()
+
+        if writer: writer.close()
+        print("INFO: Viewer window closed.")
+        glfw.terminate()
+
+def render(sdf_obj, camera=None, lighting=None, watch=True, record=None, bg_color=(0.1, 0.12, 0.15), **kwargs):
+    if is_in_colab():
+        from IPython.display import display, HTML
+        
+        materials = []
+        sdf_obj._collect_materials(materials)
+        if len(materials) > MAX_MATERIALS:
+            materials = materials[:MAX_MATERIALS]
+
+        material_struct_glsl = "struct MaterialInfo { vec3 color; };\n"
+        
+        colors_glsl = ", ".join([f"vec3({c.color[0]}, {c.color[1]}, {c.color[2]})" for c in materials])
+        material_array_glsl = f"const MaterialInfo u_materials[{max(1, len(materials))}] = MaterialInfo[]({colors_glsl});\n"
+        
+        # --- Light ---
+        light_pos_str = "ro"
+        ambient_strength_str = "0.1"
+        shadow_softness_str = "8.0"
+        ao_strength_str = "3.0"
+
+        if lighting:
+            if lighting.position:
+                pos = lighting.position
+                light_pos_str = f"vec3({_glsl_format(pos[0])}, {_glsl_format(pos[1])}, {_glsl_format(pos[2])})"
+            ambient_strength_str = _glsl_format(lighting.ambient_strength)
+            shadow_softness_str = _glsl_format(lighting.shadow_softness)
+            ao_strength_str = _glsl_format(lighting.ao_strength)
+
+        # --- Camera ---
+        camera_logic_glsl = ""
+        if camera:
+            pos = camera.position
+            pos_str = f"vec3({_glsl_format(pos[0])}, {_glsl_format(pos[1])}, {_glsl_format(pos[2])})"
+            target = camera.target
+            target_str = f"vec3({_glsl_format(target[0])}, {_glsl_format(target[1])}, {_glsl_format(target[2])})"
+            zoom_str = _glsl_format(camera.zoom)
+            camera_logic_glsl = f"cameraStatic(st, {pos_str}, {target_str}, {zoom_str}, ro, rd);"
+        else:
+            camera_logic_glsl = "cameraOrbit(st, u_mouse.xy, u_resolution, 1.0, ro, rd);"
+
+        shader_code = assemble_shader_code(sdf_obj)
+        html_template = f"""
+        <!DOCTYPE html><html><head><title>SDF Forge Viewer</title>
+        <style>body{{margin:0;overflow:hidden}}canvas{{display:block}}</style></head>
+        <body><script type="importmap">{{"imports":{{"three":"https://unpkg.com/three@0.157.0/build/three.module.js"}}}}</script>
+        <script type="module">
+        import * as THREE from 'three';
+        const fragmentShader = `
+            varying vec2 vUv;
+            uniform float u_time;
+            uniform vec4 u_mouse;
+            #define u_resolution vec2(800.0, 600.0)
+            #define u_bg_color vec3({bg_color[0]}, {bg_color[1]}, {bg_color[2]})
+            
+            {material_struct_glsl}
+            {material_array_glsl}
+
+            {get_glsl_content('sdf/primitives.glsl')}
+            {get_glsl_content('scene/camera.glsl')}
+            {get_glsl_content('scene/raymarching.glsl')}
+            {get_glsl_content('scene/lighting.glsl')}
+            {shader_code}
+            void main() {{
+                vec2 st = (2.0*vUv - 1.0) * vec2(u_resolution.x/u_resolution.y, 1.0);
+                vec3 ro, rd;
+                {camera_logic_glsl}
+                vec3 color = u_bg_color;
+                vec4 hit = raymarch(ro, rd);
+                float t = hit.x;
+                int material_id = int(hit.y);
+                if (t > 0.0) {{
+                    vec3 p = ro + t * rd;
+                    vec3 normal = estimateNormal(p);
+                    vec3 lightPos = {light_pos_str};
+                    vec3 lightDir = normalize(lightPos - p);
+                    float diffuse = max(dot(normal, lightDir), {ambient_strength_str});
+                    float shadow = softShadow(p+normal*0.01, lightDir, {shadow_softness_str});
+                    diffuse *= shadow;
+                    float ao = ambientOcclusion(p, normal, {ao_strength_str});
+                    vec3 material_color = vec3(0.8);
+                    if (material_id >= 0 && material_id < {len(materials)}) {{
+                        material_color = u_materials[material_id].color;
+                    }}
+                    color = material_color * diffuse * ao;
+                }}
+                gl_FragColor = vec4(color, 1.0);
+            }}
+        `;
+        const scene = new THREE.Scene();
+        const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+        const renderer = new THREE.WebGLRenderer({{antialias: true}});
+        document.body.appendChild(renderer.domElement);
+        const uniforms = {{u_time:{{value:0}}, u_mouse:{{value:new THREE.Vector4()}}}};
+        const material = new THREE.ShaderMaterial({{vertexShader:`varying vec2 vUv; void main(){{vUv=uv;gl_Position=vec4(position,1.0);}}`, fragmentShader, uniforms}});
+        scene.add(new THREE.Mesh(new THREE.PlaneGeometry(2,2), material));
+        renderer.setSize(800,600);
+        document.addEventListener('mousemove', e=>{{uniforms.u_mouse.value.x=e.clientX;uniforms.u_mouse.value.y=600-e.clientY;}});
+        function animate(t){{requestAnimationFrame(animate);uniforms.u_time.value=t*0.001;renderer.render(scene,camera);}}
+        animate();
+        </script></body></html>
+        """
+        escaped_html = html_template.replace('"', "&quot;")
+        display(HTML(f'<iframe srcdoc="{escaped_html}" width="800" height="600" style="border:1px solid #ccc"></iframe>'))
+        return
+
+    try:
+        import moderngl, glfw
+    except ImportError:
+        print("ERROR: Live rendering requires 'moderngl' and 'glfw'.\nPlease install them via: pip install sdforge")
+        return
+        
+    renderer = NativeRenderer(sdf_obj, camera=camera, lighting=lighting, watch=watch, record=record, bg_color=bg_color, **kwargs)
+    renderer.run()