warp-lang 1.8.0__py3-none-win_amd64.whl → 1.9.0__py3-none-win_amd64.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

@@ -320,15 +320,14 @@ def update_vbo_transforms(
 @wp.kernel
 def update_vbo_vertices(
     points: wp.array(dtype=wp.vec3),
-    scale: wp.vec3,
     # outputs
     vbo_vertices: wp.array(dtype=float, ndim=2),
 ):
     tid = wp.tid()
     p = points[tid]
-    vbo_vertices[tid, 0] = p[0] * scale[0]
-    vbo_vertices[tid, 1] = p[1] * scale[1]
-    vbo_vertices[tid, 2] = p[2] * scale[2]
+    vbo_vertices[tid, 0] = p[0]
+    vbo_vertices[tid, 1] = p[1]
+    vbo_vertices[tid, 2] = p[2]
 
 
 @wp.kernel
@@ -422,7 +421,6 @@ 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),
@@ -431,9 +429,9 @@ def compute_average_normals(
     i = indices[tid, 0]
     j = indices[tid, 1]
     k = indices[tid, 2]
-    v0 = vertices[i] * scale[0]
-    v1 = vertices[j] * scale[1]
-    v2 = vertices[k] * scale[2]
+    v0 = vertices[i]
+    v1 = vertices[j]
+    v2 = vertices[k]
     n = wp.normalize(wp.cross(v1 - v0, v2 - v0))
     wp.atomic_add(normals, i, n)
     wp.atomic_add(faces_per_vertex, i, 1)
@@ -448,16 +446,15 @@ 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] * scale[0]
-    gfx_vertices[tid, 1] = v[1] * scale[1]
-    gfx_vertices[tid, 2] = v[2] * scale[2]
+    gfx_vertices[tid, 0] = v[0]
+    gfx_vertices[tid, 1] = v[1]
+    gfx_vertices[tid, 2] = v[2]
     gfx_vertices[tid, 3] = n[0]
     gfx_vertices[tid, 4] = n[1]
     gfx_vertices[tid, 5] = n[2]
@@ -1001,6 +998,7 @@ class OpenGLRenderer:
         enable_mouse_interaction=True,
         enable_keyboard_interaction=True,
         device=None,
+        use_legacy_opengl: bool | None = None,
     ):
         """
         Args:
@@ -1031,6 +1029,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:
 
@@ -1076,6 +1075,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:
@@ -1165,6 +1169,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 = {}
@@ -2054,9 +2060,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
 
@@ -2106,9 +2146,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()
@@ -2396,6 +2470,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 = []
@@ -2404,6 +2479,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)
 
@@ -2445,7 +2521,7 @@ Instances: {len(self._instances)}"""
 
         gl.glBindVertexArray(0)
 
-    def update_shape_instance(self, name, pos=None, rot=None, color1=None, color2=None, visible=None):
+    def update_shape_instance(self, name, pos=None, rot=None, color1=None, color2=None, scale=None, visible=None):
         """Update the instance properties of the shape
 
         Args:
@@ -2461,7 +2537,7 @@ Instances: {len(self._instances)}"""
         self._switch_context()
 
         if name in self._instances:
-            i, body, shape, tf, scale, old_color1, old_color2, v = self._instances[name]
+            i, body, shape, tf, old_scale, old_color1, old_color2, v = self._instances[name]
             if visible is None:
                 visible = v
             new_tf = np.copy(tf)
@@ -2474,7 +2550,7 @@ Instances: {len(self._instances)}"""
                 body,
                 shape,
                 new_tf,
-                scale,
+                old_scale if scale is None else scale,
                 old_color1 if color1 is None else color1,
                 old_color2 if color2 is None else color2,
                 visible,
@@ -2968,7 +3044,7 @@ Instances: {len(self._instances)}"""
         geo_hash = hash(("box", tuple(extents)))
         if geo_hash in self._shape_geo_hash:
             shape = self._shape_geo_hash[geo_hash]
-            if self.update_shape_instance(name, pos, rot):
+            if self.update_shape_instance(name, pos, rot, color1=color, color2=color):
                 return shape
         else:
             vertices, indices = self._create_box_mesh(extents)
@@ -3031,50 +3107,54 @@ Instances: {len(self._instances)}"""
         if not update_topology:
             if name in self._instances:
                 # Update the instance's transform.
-                self.update_shape_instance(name, pos, rot, color1=colors)
+                self.update_shape_instance(name, pos, rot, color1=colors, color2=colors, scale=scale, visible=visible)
 
             if shape is not None:
                 # Update the shape's point positions.
-                self.update_shape_vertices(shape, points, scale)
+                self.update_shape_vertices(shape, points)
 
                 if not is_template and name not in self._instances:
                     # Create a new instance.
                     body = self._resolve_body_id(parent_body)
-                    self.add_shape_instance(name, shape, body, pos, rot, color1=colors)
+                    self.add_shape_instance(name, shape, body, pos, rot, color1=colors, scale=scale)
 
                 return shape
 
         # No existing shape for the given mesh was found, or its topology may have changed,
         # so we need to define a new one either way.
-        if smooth_shading:
-            normals = wp.zeros(point_count, dtype=wp.vec3)
-            vertices = wp.array(points, dtype=wp.vec3)
-            faces_per_vertex = wp.zeros(point_count, dtype=int)
-            wp.launch(
-                compute_average_normals,
-                dim=idx_count,
-                inputs=[wp.array(indices, dtype=int), vertices, scale],
-                outputs=[normals, faces_per_vertex],
-            )
-            gfx_vertices = wp.zeros((point_count, 8), dtype=float)
-            wp.launch(
-                assemble_gfx_vertices,
-                dim=point_count,
-                inputs=[vertices, normals, faces_per_vertex, scale],
-                outputs=[gfx_vertices],
-            )
-            gfx_vertices = gfx_vertices.numpy()
-            gfx_indices = indices.flatten()
-        else:
-            gfx_vertices = wp.zeros((idx_count * 3, 8), dtype=float)
-            wp.launch(
-                compute_gfx_vertices,
-                dim=idx_count,
-                inputs=[wp.array(indices, dtype=int), wp.array(points, dtype=wp.vec3), scale],
-                outputs=[gfx_vertices],
-            )
-            gfx_vertices = gfx_vertices.numpy()
-            gfx_indices = np.arange(idx_count * 3)
+        with wp.ScopedDevice(self._device):
+            if smooth_shading:
+                normals = wp.zeros(point_count, dtype=wp.vec3)
+                vertices = wp.array(points, dtype=wp.vec3)
+                faces_per_vertex = wp.zeros(point_count, dtype=int)
+                wp.launch(
+                    compute_average_normals,
+                    dim=idx_count,
+                    inputs=[wp.array(indices, dtype=int), vertices],
+                    outputs=[normals, faces_per_vertex],
+                    record_tape=False,
+                )
+                gfx_vertices = wp.zeros((point_count, 8), dtype=float)
+                wp.launch(
+                    assemble_gfx_vertices,
+                    dim=point_count,
+                    inputs=[vertices, normals, faces_per_vertex],
+                    outputs=[gfx_vertices],
+                    record_tape=False,
+                )
+                gfx_vertices = gfx_vertices.numpy()
+                gfx_indices = indices.flatten()
+            else:
+                gfx_vertices = wp.zeros((idx_count * 3, 8), dtype=float)
+                wp.launch(
+                    compute_gfx_vertices,
+                    dim=idx_count,
+                    inputs=[wp.array(indices, dtype=int), wp.array(points, dtype=wp.vec3)],
+                    outputs=[gfx_vertices],
+                    record_tape=False,
+                )
+                gfx_vertices = gfx_vertices.numpy()
+                gfx_indices = np.arange(idx_count * 3)
 
         # If there was a shape for the given mesh, clean it up.
         if shape is not None:
@@ -3090,7 +3170,7 @@ Instances: {len(self._instances)}"""
         if not is_template:
             # Create a new instance if necessary.
             body = self._resolve_body_id(parent_body)
-            self.add_shape_instance(name, shape, body, pos, rot, color1=colors)
+            self.add_shape_instance(name, shape, body, pos, rot, color1=colors, scale=scale)
 
         return shape
 
@@ -3278,7 +3358,7 @@ Instances: {len(self._instances)}"""
         lines = np.array(lines)
         self._render_lines(name, lines, color, radius)
 
-    def update_shape_vertices(self, shape, points, scale):
+    def update_shape_vertices(self, shape, points):
         if isinstance(points, wp.array):
             wp_points = points.to(self._device)
         else:
@@ -3291,7 +3371,7 @@ Instances: {len(self._instances)}"""
         wp.launch(
             update_vbo_vertices,
             dim=vertices_shape[0],
-            inputs=[wp_points, scale],
+            inputs=[wp_points],
             outputs=[vbo_vertices],
             device=self._device,
         )

warp/render/render_usd.py

@@ -647,7 +647,6 @@ 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/collide.py

@@ -1236,8 +1236,7 @@ def handle_contact_pairs(
         p_b_body = closest_point_box(geo_scale_b, query_b)
         p_b_world = wp.transform_point(X_ws_b, p_b_body)
         diff = p_a_world - p_b_world
-        # use center of box A to query normal to make sure we are not inside B
-        query_b = wp.transform_point(X_sw_b, wp.transform_get_translation(X_ws_a))
+
         normal = wp.transform_vector(X_ws_b, box_sdf_grad(geo_scale_b, query_b))
         distance = wp.dot(diff, normal)
 

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,