warp-lang 1.8.1__py3-none-manylinux_2_34_aarch64.whl → 1.9.1__py3-none-manylinux_2_34_aarch64.whl

warp/render/imgui_manager.py

@@ -0,0 +1,289 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import warp as wp
+
+
+class ImGuiManager:
+    """Base class for managing an ImGui UI."""
+
+    def __init__(self, renderer):
+        try:
+            import imgui
+            from imgui.integrations.pyglet import PygletProgrammablePipelineRenderer
+
+            self.imgui = imgui
+            self.is_available = True
+        except ImportError:
+            self.is_available = False
+            print('Warning: imgui not found. To use the UI, please install it with: pip install "imgui[pyglet]"')
+            return
+
+        self.imgui.create_context()
+        self.renderer = renderer
+        self.impl = PygletProgrammablePipelineRenderer(self.renderer.window)
+
+    def render_frame(self):
+        """Renders a single frame of the UI. This should be called from the main render loop."""
+        if not self.is_available:
+            return
+
+        io = self.imgui.get_io()
+        self.renderer.enable_mouse_interaction = not io.want_capture_mouse
+        self.renderer.enable_keyboard_interaction = not io.want_capture_keyboard
+        io.display_size = self.renderer.screen_width, self.renderer.screen_height
+
+        self.imgui.new_frame()
+
+        self.draw_ui()
+
+        self.imgui.render()
+        self.imgui.end_frame()
+        self.impl.render(self.imgui.get_draw_data())
+
+    def draw_ui(self):
+        """Draws the UI. To be implemented by subclasses."""
+        pass
+
+    def open_save_file_dialog(
+        self,
+        title: str = "Save File",
+        defaultextension: str = "",
+        filetypes: list[tuple[str, str]] | None = None,
+    ) -> str | None:
+        """Opens a file dialog for saving a file and returns the selected path."""
+        try:
+            import tkinter as tk
+            from tkinter import filedialog
+        except ImportError:
+            print("Warning: tkinter not found. To use the file dialog, please install it.")
+            return None
+
+        try:
+            root = tk.Tk()
+        except tk.TclError:
+            print("Warning: no display found - cannot open file dialog.")
+            return None
+
+        root.withdraw()  # Hide the main window
+        file_path = filedialog.asksaveasfilename(
+            defaultextension=defaultextension,
+            filetypes=filetypes or [("All Files", "*.*")],
+            title=title,
+        )
+        root.destroy()
+        return file_path
+
+    def open_load_file_dialog(
+        self, title: str = "Open File", filetypes: list[tuple[str, str]] | None = None
+    ) -> str | None:
+        """Opens a file dialog for loading a file and returns the selected path."""
+        try:
+            import tkinter as tk
+            from tkinter import filedialog
+        except ImportError:
+            print("Warning: tkinter not found. To use the file dialog, please install it.")
+            return None
+
+        try:
+            root = tk.Tk()
+        except tk.TclError:
+            print("Warning: no display found - cannot open file dialog.")
+            return None
+
+        root.withdraw()  # Hide the main window
+        file_path = filedialog.askopenfilename(
+            filetypes=filetypes or [("All Files", "*.*")],
+            title=title,
+        )
+        root.destroy()
+        return file_path
+
+    def drag_vec3(self, label, vec, speed=0.1, min_val=0.0, max_val=100.0):
+        """Helper method to create a drag widget for a wp.vec3"""
+        changed, *values = self.imgui.drag_float3(label, *vec, speed, min_val, max_val)
+        if changed:
+            vec = wp.vec3(*values)
+        return changed, vec
+
+    def drag_vec3_list(
+        self,
+        label_prefix: str,
+        vec_list: list[wp.vec3] | wp.array,
+        speed: float = 0.1,
+        min_val: float = 0.0,
+        max_val: float = 100.0,
+        max_num_elements: int = 10,
+    ) -> tuple[bool, list[wp.vec3] | wp.array]:
+        """Helper method to create drag widgets for a list of wp.vec3.
+
+        Note: The `label_prefix` is used to create unique IDs for each widget.
+        If you are displaying multiple lists, ensure that `label_prefix` is unique
+        for each list to prevent UI elements from interfering with each other.
+        """
+        self.imgui.text(f"List: {label_prefix} with {len(vec_list)} elements")
+        changed = False
+
+        # Convert to numpy array if it's a warp array
+        is_warp_array = isinstance(vec_list, wp.array)
+        working_array = vec_list.numpy() if is_warp_array else vec_list
+
+        for i, vec in enumerate(working_array[:max_num_elements]):
+            vec_changed, new_vec = self.drag_vec3(f"{label_prefix} {i}", vec, speed, min_val, max_val)
+            if vec_changed:
+                working_array[i] = new_vec
+                changed = True
+
+        if is_warp_array:
+            if changed:
+                return changed, wp.array(working_array, dtype=wp.vec3)
+            return changed, vec_list
+        return changed, working_array
+
+    def drag_vec2(
+        self, label: str, vec: wp.vec2, speed: float = 0.1, min_val: float = 0.0, max_val: float = 100.0
+    ) -> tuple[bool, wp.vec2]:
+        """Helper method to create a drag widget for a wp.vec2"""
+        changed, *values = self.imgui.drag_float2(label, *vec, speed, min_val, max_val)
+        if changed:
+            vec = wp.vec2(*values)
+        return changed, vec
+
+    def drag_vec2_list(
+        self,
+        label_prefix: str,
+        vec_list: list[wp.vec2] | wp.array,
+        speed: float = 0.1,
+        min_val: float = 0.0,
+        max_val: float = 100.0,
+        max_num_elements: int = 10,
+    ) -> tuple[bool, list[wp.vec2] | wp.array]:
+        """Helper method to create drag widgets for a list of wp.vec2.
+
+        Note: The `label_prefix` is used to create unique IDs for each widget.
+        If you are displaying multiple lists, ensure that `label_prefix` is unique
+        for each list to prevent UI elements from interfering with each other.
+        """
+        self.imgui.text(f"List: {label_prefix} with {len(vec_list)} elements")
+        changed = False
+
+        # Convert to numpy array if it's a warp array
+        is_warp_array = isinstance(vec_list, wp.array)
+        working_array = vec_list.numpy() if is_warp_array else vec_list
+
+        for i, vec in enumerate(working_array[:max_num_elements]):
+            vec_changed, new_vec = self.drag_vec2(f"{label_prefix} {i}", vec, speed, min_val, max_val)
+            if vec_changed:
+                working_array[i] = new_vec
+                changed = True
+
+        if is_warp_array:
+            if changed:
+                return changed, wp.array(working_array, dtype=wp.vec2)
+            return changed, vec_list
+        return changed, working_array
+
+    def drag_vec4(
+        self, label: str, vec: wp.vec4, speed: float = 0.1, min_val: float = 0.0, max_val: float = 100.0
+    ) -> tuple[bool, wp.vec4]:
+        """Helper method to create a drag widget for a wp.vec4"""
+        changed, *values = self.imgui.drag_float4(label, *vec, speed, min_val, max_val)
+        if changed:
+            vec = wp.vec4(*values)
+        return changed, vec
+
+    def drag_vec4_list(
+        self,
+        label_prefix: str,
+        vec_list: list[wp.vec4] | wp.array,
+        speed: float = 0.1,
+        min_val: float = 0.0,
+        max_val: float = 100.0,
+        max_num_elements: int = 10,
+    ) -> tuple[bool, list[wp.vec4] | wp.array]:
+        """Helper method to create drag widgets for a list of wp.vec4.
+
+        Note: The `label_prefix` is used to create unique IDs for each widget.
+        If you are displaying multiple lists, ensure that `label_prefix` is unique
+        for each list to prevent UI elements from interfering with each other.
+        """
+        self.imgui.text(f"List: {label_prefix} with {len(vec_list)} elements")
+        changed = False
+
+        # Convert to numpy array if it's a warp array
+        is_warp_array = isinstance(vec_list, wp.array)
+        working_array = vec_list.numpy() if is_warp_array else vec_list
+
+        for i, vec in enumerate(working_array[:max_num_elements]):
+            vec_changed, new_vec = self.drag_vec4(f"{label_prefix} {i}", vec, speed, min_val, max_val)
+            if vec_changed:
+                working_array[i] = new_vec
+                changed = True
+
+        if is_warp_array:
+            if changed:
+                return changed, wp.array(working_array, dtype=wp.vec4)
+            return changed, vec_list
+        return changed, working_array
+
+    def drag_float(
+        self, label: str, val: float, speed: float = 0.1, min_val: float = 0.0, max_val: float = 100.0
+    ) -> tuple[bool, float]:
+        """Helper method to create a drag widget for a float"""
+        changed, value = self.imgui.drag_float(label, val, speed, min_val, max_val)
+        if changed:
+            val = value
+        return changed, val
+
+    def drag_float_list(
+        self,
+        label_prefix: str,
+        float_list: list[float] | wp.array,
+        speed: float = 0.1,
+        min_val: float = 0.0,
+        max_val: float = 100.0,
+        max_num_elements: int = 10,
+    ) -> tuple[bool, list[float] | wp.array]:
+        """Helper method to create drag widgets for a list of floats.
+
+        Note: The `label_prefix` is used to create unique IDs for each widget.
+        If you are displaying multiple lists, ensure that `label_prefix` is unique
+        for each list to prevent UI elements from interfering with each other.
+        """
+        self.imgui.text(f"List: {label_prefix} with {len(float_list)} elements")
+        changed = False
+
+        # Convert to numpy array if it's a warp array
+        is_warp_array = isinstance(float_list, wp.array)
+        working_array = float_list.numpy() if is_warp_array else float_list
+
+        for i, val in enumerate(working_array[:max_num_elements]):
+            val_changed, new_val = self.drag_float(f"{label_prefix} {i}", val, speed, min_val, max_val)
+            if val_changed:
+                working_array[i] = new_val
+                changed = True
+
+        if is_warp_array:
+            if changed:
+                return changed, wp.array(working_array, dtype=float_list.dtype)
+            return changed, float_list
+        return changed, working_array
+
+    def shutdown(self):
+        if not self.is_available:
+            return
+        self.impl.shutdown()

warp/render/render_opengl.py

@@ -390,9 +390,9 @@ def compute_gfx_vertices(
     gfx_vertices: wp.array(dtype=float, ndim=2),
 ):
     tid = wp.tid()
-    v0 = vertices[indices[tid, 0]] * scale[0]
-    v1 = vertices[indices[tid, 1]] * scale[1]
-    v2 = vertices[indices[tid, 2]] * scale[2]
+    v0 = wp.cw_mul(vertices[indices[tid, 0]], scale)
+    v1 = wp.cw_mul(vertices[indices[tid, 1]], scale)
+    v2 = wp.cw_mul(vertices[indices[tid, 2]], scale)
     i = tid * 3
     j = i + 1
     k = i + 2
@@ -421,6 +421,7 @@ def compute_gfx_vertices(
 def compute_average_normals(
     indices: wp.array(dtype=int, ndim=2),
     vertices: wp.array(dtype=wp.vec3),
+    scale: wp.vec3,
     # outputs
     normals: wp.array(dtype=wp.vec3),
     faces_per_vertex: wp.array(dtype=int),
@@ -429,9 +430,9 @@ def compute_average_normals(
     i = indices[tid, 0]
     j = indices[tid, 1]
     k = indices[tid, 2]
-    v0 = vertices[i]
-    v1 = vertices[j]
-    v2 = vertices[k]
+    v0 = wp.cw_mul(vertices[i], scale)
+    v1 = wp.cw_mul(vertices[j], scale)
+    v2 = wp.cw_mul(vertices[k], scale)
     n = wp.normalize(wp.cross(v1 - v0, v2 - v0))
     wp.atomic_add(normals, i, n)
     wp.atomic_add(faces_per_vertex, i, 1)
@@ -446,15 +447,16 @@ def assemble_gfx_vertices(
     vertices: wp.array(dtype=wp.vec3, ndim=1),
     normals: wp.array(dtype=wp.vec3),
     faces_per_vertex: wp.array(dtype=int),
+    scale: wp.vec3,
     # outputs
     gfx_vertices: wp.array(dtype=float, ndim=2),
 ):
     tid = wp.tid()
     v = vertices[tid]
     n = normals[tid] / float(faces_per_vertex[tid])
-    gfx_vertices[tid, 0] = v[0]
-    gfx_vertices[tid, 1] = v[1]
-    gfx_vertices[tid, 2] = v[2]
+    gfx_vertices[tid, 0] = v[0] * scale[0]
+    gfx_vertices[tid, 1] = v[1] * scale[1]
+    gfx_vertices[tid, 2] = v[2] * scale[2]
     gfx_vertices[tid, 3] = n[0]
     gfx_vertices[tid, 4] = n[1]
     gfx_vertices[tid, 5] = n[2]
@@ -998,6 +1000,7 @@ class OpenGLRenderer:
         enable_mouse_interaction=True,
         enable_keyboard_interaction=True,
         device=None,
+        use_legacy_opengl: bool | None = None,
     ):
         """
         Args:
@@ -1028,6 +1031,7 @@ class OpenGLRenderer:
             enable_mouse_interaction (bool): Whether to enable mouse interaction.
             enable_keyboard_interaction (bool): Whether to enable keyboard interaction.
             device (Devicelike): Where to store the internal data.
+            use_legacy_opengl (bool | None): Whether to use a legacy OpenGL implementation that is more compatible with macOS. If ``None``, it will be automatically detected based on the operating system.
 
         Note:
 
@@ -1073,6 +1077,11 @@ class OpenGLRenderer:
         self.render_depth = render_depth
         self.enable_backface_culling = enable_backface_culling
 
+        if use_legacy_opengl is None:
+            self.use_legacy_opengl = sys.platform == "darwin"
+        else:
+            self.use_legacy_opengl = use_legacy_opengl
+
         if device is None:
             self._device = wp.get_preferred_device()
         else:
@@ -1162,6 +1171,8 @@ class OpenGLRenderer:
         self._wp_instance_bodies = None
         self._update_shape_instances = False
         self._add_shape_instances = False
+        self.instance_matrix_size = 0
+        self.instance_color_size = 0
 
         # additional shape instancer used for points and line rendering
         self._shape_instancers = {}
@@ -2051,9 +2062,43 @@ Instances: {len(self._instances)}"""
             num_instances = len(self._shape_instances[shape])
 
             gl.glBindVertexArray(vao)
-            gl.glDrawElementsInstancedBaseInstance(
-                gl.GL_TRIANGLES, tri_count, gl.GL_UNSIGNED_INT, None, num_instances, start_instance_idx
-            )
+            if self.use_legacy_opengl:
+                if self.instance_matrix_size > 0 and self.instance_color_size:
+                    # update attribute pointers
+                    matrix_size = self.instance_matrix_size
+                    color_size = self.instance_color_size
+
+                    # update transforms
+                    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._instance_transform_gl_buffer)
+                    for i in range(4):
+                        gl.glVertexAttribPointer(
+                            3 + i,
+                            4,
+                            gl.GL_FLOAT,
+                            gl.GL_FALSE,
+                            matrix_size,
+                            ctypes.c_void_p(start_instance_idx * matrix_size + i * matrix_size // 4),
+                        )
+                        gl.glVertexAttribDivisor(3 + i, 1)
+
+                    # update colors
+                    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._instance_color1_buffer)
+                    gl.glVertexAttribPointer(
+                        7, 3, gl.GL_FLOAT, gl.GL_FALSE, color_size, ctypes.c_void_p(start_instance_idx * color_size)
+                    )
+                    gl.glVertexAttribDivisor(7, 1)
+
+                    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._instance_color2_buffer)
+                    gl.glVertexAttribPointer(
+                        8, 3, gl.GL_FLOAT, gl.GL_FALSE, color_size, ctypes.c_void_p(start_instance_idx * color_size)
+                    )
+                    gl.glVertexAttribDivisor(8, 1)
+
+                    gl.glDrawElementsInstanced(gl.GL_TRIANGLES, tri_count, gl.GL_UNSIGNED_INT, None, num_instances)
+            else:
+                gl.glDrawElementsInstancedBaseInstance(
+                    gl.GL_TRIANGLES, tri_count, gl.GL_UNSIGNED_INT, None, num_instances, start_instance_idx
+                )
 
             start_instance_idx += num_instances
 
@@ -2103,9 +2148,43 @@ Instances: {len(self._instances)}"""
                 start_instance_idx = self._inverse_instance_ids[instance]
 
                 gl.glBindVertexArray(vao)
-                gl.glDrawElementsInstancedBaseInstance(
-                    gl.GL_TRIANGLES, tri_count, gl.GL_UNSIGNED_INT, None, 1, start_instance_idx
-                )
+                if self.use_legacy_opengl:
+                    if self.instance_matrix_size > 0 and self.instance_color_size:
+                        # update attribute pointers
+                        matrix_size = self.instance_matrix_size
+                        color_size = self.instance_color_size
+
+                        # update transforms
+                        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._instance_transform_gl_buffer)
+                        for j in range(4):
+                            gl.glVertexAttribPointer(
+                                3 + j,
+                                4,
+                                gl.GL_FLOAT,
+                                gl.GL_FALSE,
+                                matrix_size,
+                                ctypes.c_void_p(start_instance_idx * matrix_size + j * matrix_size // 4),
+                            )
+                            gl.glVertexAttribDivisor(3 + j, 1)
+
+                        # update colors
+                        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._instance_color1_buffer)
+                        gl.glVertexAttribPointer(
+                            7, 3, gl.GL_FLOAT, gl.GL_FALSE, color_size, ctypes.c_void_p(start_instance_idx * color_size)
+                        )
+                        gl.glVertexAttribDivisor(7, 1)
+
+                        gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self._instance_color2_buffer)
+                        gl.glVertexAttribPointer(
+                            8, 3, gl.GL_FLOAT, gl.GL_FALSE, color_size, ctypes.c_void_p(start_instance_idx * color_size)
+                        )
+                        gl.glVertexAttribDivisor(8, 1)
+
+                        gl.glDrawElementsInstanced(gl.GL_TRIANGLES, tri_count, gl.GL_UNSIGNED_INT, None, 1)
+                else:
+                    gl.glDrawElementsInstancedBaseInstance(
+                        gl.GL_TRIANGLES, tri_count, gl.GL_UNSIGNED_INT, None, 1, start_instance_idx
+                    )
 
             if self.draw_axis:
                 self._axis_instancer.render()
@@ -2393,6 +2472,7 @@ Instances: {len(self._instances)}"""
 
         # set up instance attribute pointers
         matrix_size = transforms[0].nbytes
+        self.instance_matrix_size = matrix_size
 
         instance_ids = []
         instance_custom_ids = []
@@ -2401,6 +2481,7 @@ Instances: {len(self._instances)}"""
         inverse_instance_ids = {}
         instance_count = 0
         colors_size = np.zeros(3, dtype=np.float32).nbytes
+        self.instance_color_size = colors_size
         for shape, (vao, _vbo, _ebo, _tri_count, _vertex_cuda_buffer) in self._shape_gl_buffers.items():
             gl.glBindVertexArray(vao)
 
@@ -3051,7 +3132,7 @@ Instances: {len(self._instances)}"""
                 wp.launch(
                     compute_average_normals,
                     dim=idx_count,
-                    inputs=[wp.array(indices, dtype=int), vertices],
+                    inputs=[wp.array(indices, dtype=int), vertices, scale],
                     outputs=[normals, faces_per_vertex],
                     record_tape=False,
                 )
@@ -3059,7 +3140,7 @@ Instances: {len(self._instances)}"""
                 wp.launch(
                     assemble_gfx_vertices,
                     dim=point_count,
-                    inputs=[vertices, normals, faces_per_vertex],
+                    inputs=[vertices, normals, faces_per_vertex, scale],
                     outputs=[gfx_vertices],
                     record_tape=False,
                 )
@@ -3070,7 +3151,7 @@ Instances: {len(self._instances)}"""
                 wp.launch(
                     compute_gfx_vertices,
                     dim=idx_count,
-                    inputs=[wp.array(indices, dtype=int), wp.array(points, dtype=wp.vec3)],
+                    inputs=[wp.array(indices, dtype=int), wp.array(points, dtype=wp.vec3), scale],
                     outputs=[gfx_vertices],
                     record_tape=False,
                 )

warp/render/render_usd.py

@@ -647,6 +647,7 @@ class UsdRenderer:
             mesh.GetDisplayColorAttr().Set(colors, self.time)
 
         self._shape_constructors[name] = UsdGeom.Mesh
+        self._shape_custom_scale[name] = scale
 
         if not is_template:
             _usd_set_xform(mesh, pos, rot, scale, self.time)

warp/sim/graph_coloring.py

@@ -234,7 +234,7 @@ def color_graph(
             f"graph_edge_indices must be a 2 dimensional array! The provided one is {graph_edge_indices.ndim} dimensional."
         )
 
-    num_colors = wp.context.runtime.core.graph_coloring(
+    num_colors = wp.context.runtime.core.wp_graph_coloring(
         num_nodes,
         graph_edge_indices.__ctype__(),
         algorithm.value,
@@ -242,7 +242,7 @@ def color_graph(
     )
 
     if balance_colors:
-        max_min_ratio = wp.context.runtime.core.balance_coloring(
+        max_min_ratio = wp.context.runtime.core.wp_balance_coloring(
             num_nodes,
             graph_edge_indices.__ctype__(),
             num_colors,