warp-lang 1.0.0b2__py3-none-win_amd64.whl → 1.0.0b6__py3-none-win_amd64.whl

examples/example_sim_rigid_chain.py

@@ -14,9 +14,10 @@
 #
 ###########################################################################
 
-import numpy as np
 import os
 
+import numpy as np
+
 import warp as wp
 import warp.sim
 import warp.sim.render
@@ -25,19 +26,8 @@ wp.init()
 
 
 class Example:
-    frame_dt = 1.0 / 100.0
-
-    episode_duration = 5.0  # seconds
-    episode_frames = int(episode_duration / frame_dt)
-
-    sim_substeps = 32  # 5
-    sim_dt = frame_dt / sim_substeps
-    sim_steps = int(episode_duration / sim_dt)
-
-    sim_time = 0.0
-    render_time = 0.0
-
-    def __init__(self, stage=None, render=True):
+    def __init__(self, stage):
+        self.device = wp.get_device()
         self.chain_length = 8
         self.chain_width = 1.0
         self.chain_types = [
@@ -48,9 +38,17 @@ class Example:
             wp.sim.JOINT_COMPOUND,
         ]
 
-        self.enable_rendering = render
         builder = wp.sim.ModelBuilder()
 
+        self.sim_time = 0.0
+        self.frame_dt = 1.0 / 100.0
+
+        episode_duration = 5.0  # seconds
+        self.episode_frames = int(episode_duration / self.frame_dt)
+
+        self.sim_substeps = 32  # 5
+        self.sim_dt = self.frame_dt / self.sim_substeps
+
         for c, t in enumerate(self.chain_types):
             # start a new articulation
             builder.add_articulation()
@@ -67,8 +65,8 @@ class Example:
                 b = builder.add_body(origin=wp.transform([i, 0.0, c * 1.0], wp.quat_identity()), armature=0.1)
 
                 # create shape
-                s = builder.add_shape_box(
-                    pos=(self.chain_width * 0.5, 0.0, 0.0),
+                builder.add_shape_box(
+                    pos=wp.vec3(self.chain_width * 0.5, 0.0, 0.0),
                     hx=self.chain_width * 0.5,
                     hy=0.1,
                     hz=0.1,
@@ -137,62 +135,57 @@ class Example:
 
         self.integrator = wp.sim.XPBDIntegrator(iterations=5)
 
-        # -----------------------
-        # set up Usd renderer
-        self.renderer = None
-        if render:
-            self.renderer = wp.sim.render.SimRenderer(self.model, stage, scaling=20.0)
-
-    def update(self):
-        for _ in range(self.sim_substeps):
-            self.state_0.clear_forces()
-            self.integrator.simulate(self.model, self.state_0, self.state_1, self.sim_dt)
-            self.state_0, self.state_1 = self.state_1, self.state_0
-
-    def render(self, is_live=False):
-        time = 0.0 if is_live else self.sim_time
-
-        self.renderer.begin_frame(time)
-        self.renderer.render(self.state_0)
-        self.renderer.end_frame()
-
-    def run(self, render=True):
-        # ---------------
-        # run simulation
+        self.renderer = wp.sim.render.SimRenderer(self.model, stage, scaling=20.0)
 
-        self.sim_time = 0.0
         self.state_0 = self.model.state()
         self.state_1 = self.model.state()
 
         wp.sim.eval_fk(self.model, self.model.joint_q, self.model.joint_qd, None, self.state_0)
 
-        profiler = {}
-
-        # create update graph
-        wp.capture_begin()
-
-        # simulate
-        self.update()
+        self.use_graph = wp.get_device().is_cuda
+        self.graph = None
 
-        graph = wp.capture_end()
+        if self.use_graph:
+            # create update graph
+            wp.capture_begin(self.device)
+            try:
+                self.update()
+            finally:
+                self.graph = wp.capture_end(self.device)
 
-        # simulate
-        with wp.ScopedTimer("simulate", detailed=False, print=False, active=True, dict=profiler):
-            for f in range(0, self.episode_frames):
-                with wp.ScopedTimer("simulate", active=True):
-                    wp.capture_launch(graph)
+    def update(self):
+        with wp.ScopedTimer("simulate", active=True):
+            if not self.use_graph or self.graph is None:
+                for _ in range(self.sim_substeps):
+                    self.state_0.clear_forces()
+                    self.integrator.simulate(self.model, self.state_0, self.state_1, self.sim_dt)
+                    self.state_0, self.state_1 = self.state_1, self.state_0
+            else:
+                wp.capture_launch(self.graph)
+
+            if not wp.get_device().is_capturing:
                 self.sim_time += self.frame_dt
 
-                if self.enable_rendering:
-                    with wp.ScopedTimer("render", active=True):
-                        self.render()
+    def render(self, is_live=False):
+        with wp.ScopedTimer("render", active=True):
+            time = 0.0 if is_live else self.sim_time
 
-            wp.synchronize()
-            if self.enable_rendering:
-                self.renderer.save()
+            self.renderer.begin_frame(time)
+            self.renderer.render(self.state_0)
+            self.renderer.end_frame()
 
 
 if __name__ == "__main__":
     stage = os.path.join(os.path.dirname(__file__), "outputs/example_sim_rigid_chain.usd")
-    robot = Example(stage, render=True)
-    robot.run()
+    example = Example(stage)
+
+    profiler = {}
+
+    with wp.ScopedTimer("simulate", detailed=False, print=False, active=True, dict=profiler):
+        for _ in range(example.episode_frames):
+            example.update()
+            example.render()
+
+        wp.synchronize()
+
+    example.renderer.save()

examples/example_sim_rigid_contact.py

@@ -13,36 +13,32 @@
 #
 ###########################################################################
 
-import os
 import math
+import os
 
 import numpy as np
+from pxr import Usd, UsdGeom
 
 import warp as wp
 import warp.sim
 import warp.sim.render
 
-from pxr import UsdGeom, Usd
-
 wp.init()
 
 
 class Example:
-    frame_dt = 1.0 / 60.0
-
-    episode_duration = 20.0  # seconds
-    episode_frames = int(episode_duration / frame_dt)
-
-    sim_substeps = 10
-    sim_dt = frame_dt / sim_substeps
-    sim_steps = int(episode_duration / sim_dt)
+    def __init__(self, stage):
+        self.device = wp.get_device()
+        builder = wp.sim.ModelBuilder()
 
-    sim_time = 0.0
+        self.sim_time = 0.0
+        self.frame_dt = 1.0 / 60.0
 
-    def __init__(self, stage=None, render=True):
-        builder = wp.sim.ModelBuilder()
+        episode_duration = 20.0  # seconds
+        self.episode_frames = int(episode_duration / self.frame_dt)
 
-        self.enable_rendering = render
+        self.sim_substeps = 10
+        self.sim_dt = self.frame_dt / self.sim_substeps
 
         self.num_bodies = 8
         self.scale = 0.8
@@ -54,8 +50,8 @@ class Example:
         for i in range(self.num_bodies):
             b = builder.add_body(origin=wp.transform((i, 1.0, 0.0), wp.quat_identity()))
 
-            s = builder.add_shape_box(
-                pos=(0.0, 0.0, 0.0),
+            builder.add_shape_box(
+                pos=wp.vec3(0.0, 0.0, 0.0),
                 hx=0.5 * self.scale,
                 hy=0.2 * self.scale,
                 hz=0.2 * self.scale,
@@ -69,16 +65,16 @@ class Example:
         for i in range(self.num_bodies):
             b = builder.add_body(origin=wp.transform((i, 1.0, 2.0), wp.quat_identity()))
 
-            s = builder.add_shape_sphere(
-                pos=(0.0, 0.0, 0.0), radius=0.25 * self.scale, body=b, ke=self.ke, kd=self.kd, kf=self.kf
+            builder.add_shape_sphere(
+                pos=wp.vec3(0.0, 0.0, 0.0), radius=0.25 * self.scale, body=b, ke=self.ke, kd=self.kd, kf=self.kf
             )
 
         # capsules
         for i in range(self.num_bodies):
             b = builder.add_body(origin=wp.transform((i, 1.0, 6.0), wp.quat_identity()))
 
-            s = builder.add_shape_capsule(
-                pos=(0.0, 0.0, 0.0),
+            builder.add_shape_capsule(
+                pos=wp.vec3(0.0, 0.0, 0.0),
                 radius=0.25 * self.scale,
                 half_height=self.scale * 0.5,
                 up_axis=0,
@@ -98,15 +94,15 @@ class Example:
             b = builder.add_body(
                 origin=wp.transform(
                     (i * 0.5 * self.scale, 1.0 + i * 1.7 * self.scale, 4.0 + i * 0.5 * self.scale),
-                    wp.quat_from_axis_angle((0.0, 1.0, 0.0), math.pi * 0.1 * i),
+                    wp.quat_from_axis_angle(wp.vec3(0.0, 1.0, 0.0), math.pi * 0.1 * i),
                 )
             )
 
-            s = builder.add_shape_mesh(
+            builder.add_shape_mesh(
                 body=b,
                 mesh=bunny,
-                pos=(0.0, 0.0, 0.0),
-                scale=(self.scale, self.scale, self.scale),
+                pos=wp.vec3(0.0, 0.0, 0.0),
+                scale=wp.vec3(self.scale, self.scale, self.scale),
                 ke=self.ke,
                 kd=self.kd,
                 kf=self.kf,
@@ -119,10 +115,23 @@ class Example:
 
         self.integrator = wp.sim.SemiImplicitIntegrator()
 
-        # -----------------------
-        # set up OpenGL renderer
-        if self.enable_rendering:
-            self.renderer = wp.sim.render.SimRendererOpenGL(self.model, stage, scaling=0.5)
+        self.renderer = wp.sim.render.SimRenderer(self.model, stage, scaling=0.5)
+
+        self.state_0 = self.model.state()
+        self.state_1 = self.model.state()
+
+        wp.sim.eval_fk(self.model, self.model.joint_q, self.model.joint_qd, None, self.state_0)
+
+        self.use_graph = wp.get_device().is_cuda
+        self.graph = None
+
+        if self.use_graph:
+            # create update graph
+            wp.capture_begin(self.device)
+            try:
+                self.update()
+            finally:
+                self.graph = wp.capture_end(self.device)
 
     def load_mesh(self, filename, path):
         asset_stage = Usd.Stage.Open(filename)
@@ -134,53 +143,40 @@ class Example:
         return wp.sim.Mesh(points, indices)
 
     def update(self):
-        for _ in range(self.sim_substeps):
-            self.state_0.clear_forces()
-            wp.sim.collide(self.model, self.state_0)
-            self.integrator.simulate(self.model, self.state_0, self.state_1, self.sim_dt)
-            self.state_0, self.state_1 = self.state_1, self.state_0
+        with wp.ScopedTimer("simulate", active=True):
+            if not self.use_graph or self.graph is None:
+                for _ in range(self.sim_substeps):
+                    self.state_0.clear_forces()
+                    wp.sim.collide(self.model, self.state_0)
+                    self.integrator.simulate(self.model, self.state_0, self.state_1, self.sim_dt)
+                    self.state_0, self.state_1 = self.state_1, self.state_0
+            else:
+                wp.capture_launch(self.graph)
+
+            if not wp.get_device().is_capturing:
+                self.sim_time += self.frame_dt
 
     def render(self, is_live=False):
-        time = 0.0 if is_live else self.sim_time
+        with wp.ScopedTimer("render", active=True):
+            time = 0.0 if is_live else self.sim_time
 
-        self.renderer.begin_frame(time)
-        self.renderer.render(self.state_0)
-        self.renderer.end_frame()
+            self.renderer.begin_frame(time)
+            self.renderer.render(self.state_0)
+            self.renderer.end_frame()
 
-    def run(self, render=True):
-        # ---------------
-        # run simulation
 
-        self.sim_time = 0.0
-        self.state_0 = self.model.state()
-        self.state_1 = self.model.state()
-
-        wp.sim.eval_fk(self.model, self.model.joint_q, self.model.joint_qd, None, self.state_0)
-
-        profiler = {}
-
-        # create update graph
-        wp.capture_begin()
-
-        # simulate
-        self.update()
-
-        graph = wp.capture_end()
-
-        # simulate
-        with wp.ScopedTimer("simulate", detailed=False, print=False, active=True, dict=profiler):
-            for f in range(0, self.episode_frames):
-                with wp.ScopedTimer("simulate", active=True):
-                    wp.capture_launch(graph)
-                self.sim_time += self.frame_dt
+if __name__ == "__main__":
+    stage = os.path.join(os.path.dirname(__file__), "outputs/example_sim_rigid_contact.usd")
+    example = Example(stage)
+    example.run()
 
-                if self.enable_rendering:
-                    with wp.ScopedTimer("render", active=True):
-                        self.render()
+    profiler = {}
 
-            wp.synchronize()
+    with wp.ScopedTimer("simulate", detailed=False, print=False, active=True, dict=profiler):
+        for _ in range(example.episode_frames):
+            example.update()
+            example.render()
 
+        wp.synchronize()
 
-stage = os.path.join(os.path.dirname(__file__), "outputs/example_sim_rigid_contact.usd")
-robot = Example(stage, render=True)
-robot.run()
+    example.renderer.save()

examples/example_sim_rigid_fem.py

@@ -40,9 +40,9 @@ class Example:
         builder.default_particle_radius = 0.01
 
         builder.add_soft_grid(
-            pos=(0.0, 0.0, 0.0),
+            pos=wp.vec3(0.0, 0.0, 0.0),
             rot=wp.quat_identity(),
-            vel=(0.0, 0.0, 0.0),
+            vel=wp.vec3(0.0, 0.0, 0.0),
             dim_x=20,
             dim_y=10,
             dim_z=10,
@@ -69,7 +69,7 @@ class Example:
         self.state_0 = self.model.state()
         self.state_1 = self.model.state()
 
-        self.renderer = wp.sim.render.SimRendererOpenGL(self.model, stage, scaling=1.0)
+        self.renderer = wp.sim.render.SimRenderer(self.model, stage, scaling=1.0)
 
     def update(self):
         with wp.ScopedTimer("simulate", active=True):

examples/example_sim_rigid_force.py

@@ -48,7 +48,7 @@ class Example:
 
     def update(self):
         with wp.ScopedTimer("simulate"):
-            for s in range(self.sim_substeps):
+            for _ in range(self.sim_substeps):
                 wp.sim.collide(self.model, self.state_0)
 
                 self.state_0.clear_forces()

examples/example_sim_rigid_gyroscopic.py

@@ -36,7 +36,7 @@ class Example:
 
         # axis shape
         builder.add_shape_box(
-            pos=(0.3 * self.scale, 0.0, 0.0),
+            pos=wp.vec3(0.3 * self.scale, 0.0, 0.0),
             hx=0.25 * self.scale,
             hy=0.1 * self.scale,
             hz=0.1 * self.scale,
@@ -46,7 +46,7 @@ class Example:
 
         # tip shape
         builder.add_shape_box(
-            pos=(0.0, 0.0, 0.0), hx=0.05 * self.scale, hy=0.2 * self.scale, hz=1.0 * self.scale, density=100.0, body=b
+            pos=wp.vec3(0.0, 0.0, 0.0), hx=0.05 * self.scale, hy=0.2 * self.scale, hz=1.0 * self.scale, density=100.0, body=b
         )
 
         # initial spin
@@ -65,6 +65,7 @@ class Example:
         with wp.ScopedTimer("simulate", active=True):
             self.state.clear_forces()
             self.state = self.integrator.simulate(self.model, self.state, self.state, self.sim_dt)
+            self.sim_time += self.sim_dt
 
     def render(self, is_live=False):
         with wp.ScopedTimer("render", active=True):
@@ -74,8 +75,6 @@ class Example:
             self.renderer.render(self.state)
             self.renderer.end_frame()
 
-        self.sim_time += self.sim_dt
-
 
 if __name__ == "__main__":
     stage_path = os.path.join(os.path.dirname(__file__), "outputs/example_sim_rigid_gyroscopic.usd")

examples/example_sim_rigid_kinematics.py

@@ -13,8 +13,8 @@
 #
 ###########################################################################
 
-import os
 import math
+import os
 
 import numpy as np
 
@@ -25,24 +25,13 @@ import warp.sim.render
 wp.init()
 
 
-class Robot:
-    frame_dt = 1.0 / 60.0
-
-    episode_duration = 2.0  # seconds
-    episode_frames = int(episode_duration / frame_dt)
-
-    sim_substeps = 10
-    sim_dt = frame_dt / sim_substeps
-    sim_steps = int(episode_duration / sim_dt)
+class Example:
+    def __init__(self, stage, num_envs=1, device=None, verbose=False):
+        self.verbose = verbose
 
-    sim_time = 0.0
-    render_time = 0.0
-
-    def __init__(self, render=True, num_envs=1, device=None):
         builder = wp.sim.ModelBuilder()
 
-        self.render = render
-
+        self.sim_time = 0.0
         self.num_envs = num_envs
 
         for i in range(num_envs):
@@ -58,6 +47,7 @@ class Robot:
                 contact_mu=0.75,
                 limit_ke=1.0e3,
                 limit_kd=1.0e1,
+                up_axis="y",
             )
 
             coord_count = 15
@@ -69,7 +59,7 @@ class Robot:
             # base
             builder.joint_q[coord_start : coord_start + 3] = [i * 2.0, 0.70, 0.0]
             builder.joint_q[coord_start + 3 : coord_start + 7] = wp.quat_from_axis_angle(
-                (1.0, 0.0, 0.0), -math.pi * 0.5
+                wp.vec3(1.0, 0.0, 0.0), -math.pi * 0.5
             )
 
             # joints
@@ -84,20 +74,11 @@ class Robot:
 
         self.integrator = wp.sim.SemiImplicitIntegrator()
 
-        # -----------------------
-        # set up Usd renderer
-        if self.render:
-            self.renderer = wp.sim.render.SimRenderer(
-                self.model,
-                os.path.join(os.path.dirname(__file__), "outputs/example_sim_rigid_kinematics.usd"),
-                scaling=50.0,
-            )
+        self.renderer = wp.sim.render.SimRenderer(path=stage, model=self.model, scaling=50.0)
 
-    def run(self):
-        # ---------------
-        # run simulation
+        self.frame_dt = 1.0 / 60.0
 
-        self.sim_time = 0.0
+    def update(self):
         self.state = self.model.state()
 
         # save a copy of joint values
@@ -114,18 +95,26 @@ class Robot:
         q_err = q_fk - q_ik.numpy()
         qd_err = qd_fk - qd_ik.numpy()
 
-        if self.render:
-            self.renderer.begin_frame(self.render_time)
-            self.renderer.render(self.state)
-            self.renderer.end_frame()
-            self.renderer.save()
-
-        print(q_err)
-        print(qd_err)
+        if self.verbose:
+            print(f"q_err = {q_err}")
+            print(f"qd_err = {qd_err}")
 
         assert np.abs(q_err).max() < 1.0e-6
         assert np.abs(qd_err).max() < 1.0e-6
 
+        self.sim_time += self.frame_dt
+
+    def render(self):
+        self.renderer.begin_frame(self.sim_time)
+        self.renderer.render(self.state)
+        self.renderer.end_frame()
+
+
+if __name__ == "__main__":
+    stage_path = os.path.join(os.path.dirname(__file__), "outputs/example_sim_rigid_kinematics.usd")
+
+    example = Example(stage_path, num_envs=1, verbose=True)
+    example.update()
+    example.render()
 
-robot = Robot(render=False, num_envs=1)
-robot.run()
+    example.renderer.save()