warp-lang 0.11.0__py3-none-manylinux2014_x86_64.whl → 1.0.0__py3-none-manylinux2014_x86_64.whl

warp/examples/sim/example_granular_collision_sdf.py

@@ -0,0 +1,185 @@
+# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+###########################################################################
+# Example Sim Granular Collision SDF
+#
+# Shows how to set up a particle-based granular material model using the
+# wp.sim.ModelBuilder(). This version shows how to create collision geometry
+# objects from SDFs.
+#
+# Note: requires a CUDA-capable device
+###########################################################################
+
+import math
+import os
+
+import numpy as np
+
+import warp as wp
+import warp.sim
+import warp.sim.render
+
+wp.init()
+
+
+class Example:
+    def __init__(self, stage):
+        self.frame_dt = 1.0 / 60
+        self.frame_count = 400
+
+        self.sim_substeps = 64
+        self.sim_dt = self.frame_dt / self.sim_substeps
+        self.sim_steps = self.frame_count * self.sim_substeps
+        self.sim_time = 0.0
+
+        self.radius = 0.1
+
+        builder = wp.sim.ModelBuilder()
+        builder.default_particle_radius = self.radius
+
+        builder.add_particle_grid(
+            dim_x=16,
+            dim_y=32,
+            dim_z=16,
+            cell_x=self.radius * 2.0,
+            cell_y=self.radius * 2.0,
+            cell_z=self.radius * 2.0,
+            pos=wp.vec3(0.0, 20.0, 0.0),
+            rot=wp.quat_identity(),
+            vel=wp.vec3(2.0, 0.0, 0.0),
+            mass=0.1,
+            jitter=self.radius * 0.1,
+        )
+        rock_file = open(os.path.join(os.path.dirname(__file__), "../assets/rocks.nvdb"), "rb")
+        rock_vdb = wp.Volume.load_from_nvdb(rock_file.read())
+        rock_file.close()
+
+        rock_sdf = wp.sim.SDF(rock_vdb)
+
+        builder.add_shape_sdf(
+            ke=1.0e4,
+            kd=1000.0,
+            kf=1000.0,
+            mu=0.5,
+            sdf=rock_sdf,
+            body=-1,
+            pos=wp.vec3(0.0, 0.0, 0.0),
+            rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), -0.5 * math.pi),
+            scale=wp.vec3(0.01, 0.01, 0.01),
+        )
+
+        mins = np.array([-3.0, -3.0, -3.0])
+        voxel_size = 0.2
+        maxs = np.array([3.0, 3.0, 3.0])
+        nums = np.ceil((maxs - mins) / (voxel_size)).astype(dtype=int)
+        center = np.array([0.0, 0.0, 0.0])
+        rad = 2.5
+        sphere_sdf_np = np.zeros(tuple(nums))
+        for x in range(nums[0]):
+            for y in range(nums[1]):
+                for z in range(nums[2]):
+                    pos = mins + voxel_size * np.array([x, y, z])
+                    dis = np.linalg.norm(pos - center)
+                    sphere_sdf_np[x, y, z] = dis - rad
+
+        sphere_vdb = wp.Volume.load_from_numpy(sphere_sdf_np, mins, voxel_size, rad + 3.0 * voxel_size)
+        sphere_sdf = wp.sim.SDF(sphere_vdb)
+
+        self.sphere_pos = wp.vec3(3.0, 15.0, 0.0)
+        self.sphere_scale = 1.0
+        self.sphere_radius = rad
+        builder.add_shape_sdf(
+            ke=1.0e4,
+            kd=1000.0,
+            kf=1000.0,
+            mu=0.5,
+            sdf=sphere_sdf,
+            body=-1,
+            pos=self.sphere_pos,
+            scale=wp.vec3(self.sphere_scale, self.sphere_scale, self.sphere_scale),
+        )
+
+        self.model = builder.finalize()
+        self.model.particle_kf = 25.0
+
+        self.model.soft_contact_kd = 100.0
+        self.model.soft_contact_kf *= 2.0
+
+        self.state_0 = self.model.state()
+        self.state_1 = self.model.state()
+
+        self.integrator = wp.sim.SemiImplicitIntegrator()
+
+        self.renderer = None
+        if stage:
+            self.renderer = wp.sim.render.SimRenderer(self.model, stage, scaling=20.0)
+
+        self.use_graph = wp.get_device().is_cuda
+        if self.use_graph:
+            with wp.ScopedCapture() as capture:
+                self.simulate()
+            self.graph = capture.graph
+
+    def simulate(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)
+
+            # swap states
+            (self.state_0, self.state_1) = (self.state_1, self.state_0)
+
+    def step(self):
+        with wp.ScopedTimer("step", active=True):
+            self.model.particle_grid.build(self.state_0.particle_q, self.radius * 2.0)
+            if self.use_graph:
+                wp.capture_launch(self.graph)
+            else:
+                self.simulate()
+
+        self.sim_time += self.frame_dt
+
+    def render(self):
+        if self.renderer is None:
+            return
+
+        with wp.ScopedTimer("render", active=True):
+            self.renderer.begin_frame(self.sim_time)
+
+            # Note the extra wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), math.pi) is because .usd is oriented differently from .nvdb
+            self.renderer.render_ref(
+                name="collision",
+                path=os.path.join(os.path.dirname(__file__), "../assets/rocks.usd"),
+                pos=wp.vec3(0.0, 0.0, 0.0),
+                rot=wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), -0.5 * math.pi)
+                * wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), math.pi),
+                scale=wp.vec3(0.01, 0.01, 0.01),
+            )
+
+            self.renderer.render_sphere(
+                name="sphere",
+                pos=self.sphere_pos,
+                radius=self.sphere_scale * self.sphere_radius,
+                rot=wp.quat(0.0, 0.0, 0.0, 1.0),
+            )
+
+            self.renderer.render(self.state_0)
+            self.renderer.end_frame()
+
+
+if __name__ == "__main__":
+    stage_path = os.path.join(os.path.dirname(__file__), "example_granular_collision_sdf.usd")
+
+    example = Example(stage_path)
+
+    for _ in range(example.frame_count):
+        example.step()
+        example.render()
+
+    if example.renderer:
+        example.renderer.save()

warp/examples/sim/example_jacobian_ik.py

@@ -0,0 +1,213 @@
+# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+###########################################################################
+# Example Jacobian
+#
+# Demonstrates how to compute the Jacobian of a multi-valued function.
+# Here, we use the simulation of a cartpole to differentiate
+# through the kinematics function. We instantiate multiple copies of the
+# cartpole and compute the Jacobian of the state of each cartpole in parallel
+# in order to perform inverse kinematics via Jacobian transpose.
+#
+###########################################################################
+
+import math
+import os
+
+import numpy as np
+
+import warp as wp
+import warp.sim
+import warp.sim.render
+
+wp.init()
+
+
+@wp.kernel
+def compute_endeffector_position(
+    body_q: wp.array(dtype=wp.transform),
+    num_links: int,
+    ee_link_index: int,
+    ee_link_offset: wp.vec3,
+    ee_pos: wp.array(dtype=wp.vec3),
+):
+    tid = wp.tid()
+    ee_pos[tid] = wp.transform_point(body_q[tid * num_links + ee_link_index], ee_link_offset)
+
+
+class Example:
+    def __init__(self, stage, num_envs=1):
+        builder = wp.sim.ModelBuilder()
+
+        self.num_envs = num_envs
+
+        self.frame_dt = 1.0 / 60.0
+
+        self.render_time = 0.0
+
+        # step size to use for the IK updates
+        self.step_size = 0.1
+
+        articulation_builder = wp.sim.ModelBuilder()
+
+        wp.sim.parse_urdf(
+            os.path.join(os.path.dirname(__file__), "../assets/cartpole.urdf"),
+            articulation_builder,
+            xform=wp.transform_identity(),
+            floating=False,
+        )
+
+        builder = wp.sim.ModelBuilder()
+
+        self.num_links = len(articulation_builder.joint_type)
+        # use the last link as the end-effector
+        self.ee_link_index = self.num_links - 1
+        self.ee_link_offset = wp.vec3(0.0, 0.0, 1.0)
+
+        self.dof = len(articulation_builder.joint_q)
+
+        self.target_origin = []
+        for i in range(num_envs):
+            builder.add_builder(
+                articulation_builder,
+                xform=wp.transform(
+                    wp.vec3(i * 2.0, 4.0, 0.0), wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), -math.pi * 0.5)
+                ),
+            )
+            self.target_origin.append((i * 2.0, 4.0, 0.0))
+            # joint initial positions
+            builder.joint_q[-3:] = np.random.uniform(-0.5, 0.5, size=3)
+        self.target_origin = np.array(self.target_origin)
+
+        # finalize model
+        self.model = builder.finalize()
+        self.model.ground = True
+
+        self.model.joint_q.requires_grad = True
+        self.model.body_q.requires_grad = True
+
+        self.model.joint_attach_ke = 1600.0
+        self.model.joint_attach_kd = 20.0
+
+        self.integrator = wp.sim.SemiImplicitIntegrator()
+
+        self.renderer = None
+        if stage:
+            self.renderer = wp.sim.render.SimRenderer(self.model, stage)
+
+        self.ee_pos = wp.zeros(self.num_envs, dtype=wp.vec3, requires_grad=True)
+
+        self.state = self.model.state(requires_grad=True)
+
+        self.targets = self.target_origin.copy()
+
+        self.profiler = {}
+
+    def compute_ee_position(self):
+        # computes the end-effector position from the current joint angles
+        wp.sim.eval_fk(self.model, self.model.joint_q, self.model.joint_qd, None, self.state)
+        wp.launch(
+            compute_endeffector_position,
+            dim=self.num_envs,
+            inputs=[self.state.body_q, self.num_links, self.ee_link_index, self.ee_link_offset],
+            outputs=[self.ee_pos]
+        )
+        return self.ee_pos
+
+    def compute_jacobian(self):
+        # our function has 3 outputs (EE position), so we need a 3xN jacobian per environment
+        jacobians = np.empty((self.num_envs, 3, self.dof), dtype=np.float32)
+        tape = wp.Tape()
+        with tape:
+            self.compute_ee_position()
+        for output_index in range(3):
+            # select which row of the Jacobian we want to compute
+            select_index = np.zeros(3)
+            select_index[output_index] = 1.0
+            e = wp.array(np.tile(select_index, self.num_envs), dtype=wp.vec3)
+            tape.backward(grads={self.ee_pos: e})
+            q_grad_i = tape.gradients[self.model.joint_q]
+            jacobians[:, output_index, :] = q_grad_i.numpy().reshape(self.num_envs, self.dof)
+            tape.zero()
+        return jacobians
+
+    def compute_fd_jacobian(self, eps=1e-4):
+        jacobians = np.zeros((self.num_envs, 3, self.dof), dtype=np.float32)
+        q0 = self.model.joint_q.numpy().copy()
+        for e in range(self.num_envs):
+            for i in range(self.dof):
+                q = q0.copy()
+                q[e * self.dof + i] += eps
+                self.model.joint_q.assign(q)
+                self.compute_ee_position()
+                f_plus = self.ee_pos.numpy()[e].copy()
+                q[e * self.dof + i] -= 2 * eps
+                self.model.joint_q.assign(q)
+                self.compute_ee_position()
+                f_minus = self.ee_pos.numpy()[e].copy()
+                jacobians[e, :, i] = (f_plus - f_minus) / (2 * eps)
+        return jacobians
+
+    def step(self):
+        with wp.ScopedTimer("jacobian", print=False, active=True, dict=self.profiler):
+            # compute jacobian
+            jacobians = self.compute_jacobian()
+
+        # compute error
+        self.ee_pos_np = self.compute_ee_position().numpy()
+        error = self.targets - self.ee_pos_np
+        self.error = error.reshape(self.num_envs, 3, 1)
+
+        # compute Jacobian transpose update
+        delta_q = np.matmul(jacobians.transpose(0, 2, 1), self.error)
+
+        self.model.joint_q = wp.array(
+            self.model.joint_q.numpy() + self.step_size * delta_q.flatten(),
+            dtype=wp.float32,
+            requires_grad=True,
+        )
+
+    def render(self):
+        if self.renderer is None:
+            return
+
+        self.renderer.begin_frame(self.render_time)
+        self.renderer.render(self.state)
+        self.renderer.render_points("targets", self.targets, radius=0.05)
+        self.renderer.render_points("ee_pos", self.ee_pos_np, radius=0.05)
+        self.renderer.end_frame()
+        self.render_time += self.frame_dt
+
+
+if __name__ == "__main__":
+    stage_path = os.path.join(os.path.dirname(__file__), "example_jacobian_ik.usd")
+
+    example = Example(stage_path, num_envs=10)
+
+    print("autodiff:")
+    print(example.compute_jacobian())
+    print("finite diff:")
+    print(example.compute_fd_jacobian())
+
+    for _ in range(5):
+        # select new random target points
+        example.targets = example.target_origin.copy()
+        example.targets[:, 1:] += np.random.uniform(-0.5, 0.5, size=(example.num_envs, 2))
+
+        for iter in range(50):
+            example.step()
+            example.render()
+            print("iter:", iter, "error:", example.error.mean())
+
+    if example.renderer:
+        example.renderer.save()
+
+    avg_time = np.array(example.profiler["jacobian"]).mean()
+    avg_steps_second = 1000.0 * float(example.num_envs) / avg_time
+
+    print(f"envs: {example.num_envs} steps/second {avg_steps_second} avg_time {avg_time}")

warp/examples/sim/example_particle_chain.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+###########################################################################
+# Example Sim Particle Chain
+#
+# Shows how to set up a simple chain of particles connected by springs
+# using wp.sim.ModelBuilder().
+#
+###########################################################################
+
+import math
+import os
+
+import warp as wp
+import warp.sim
+import warp.sim.render
+
+wp.init()
+
+
+class Example:
+    def __init__(self, stage):
+        self.sim_width = 64
+        self.sim_height = 32
+
+        self.sim_fps = 60.0
+        self.frame_dt = 1.0 / self.sim_fps
+        self.sim_substeps = 10
+        self.sim_duration = 5.0
+        self.sim_frames = int(self.sim_duration * self.sim_fps)
+        self.sim_dt = (1.0 / self.sim_fps) / self.sim_substeps
+        self.sim_time = 0.0
+
+        builder = wp.sim.ModelBuilder()
+
+        # anchor
+        builder.add_particle(wp.vec3(0.0, 1.0, 0.0), wp.vec3(0.0, 0.0, 0.0), 0.0)
+
+        # chain
+        for i in range(1, 10):
+            radius = math.sqrt(i) * 0.2
+            mass = math.pi * radius * radius * radius
+            builder.add_particle(wp.vec3(i, 1.0, 0.0), wp.vec3(0.0, 0.0, 0.0), mass, radius=radius)
+            builder.add_spring(i - 1, i, 1.0e6, 0.0, 0)
+
+        self.model = builder.finalize()
+        self.model.ground = False
+
+        self.integrator = wp.sim.XPBDIntegrator()
+
+        self.state_0 = self.model.state()
+        self.state_1 = self.model.state()
+
+        self.renderer = None
+        if stage:
+            self.renderer = wp.sim.render.SimRenderer(self.model, stage, scaling=15.0)
+
+        self.use_graph = wp.get_device().is_cuda
+        if self.use_graph:
+            with wp.ScopedCapture() as capture:
+                self.simulate()
+            self.graph = capture.graph
+
+    def simulate(self):
+        for _ in range(self.sim_substeps):
+            self.state_0.clear_forces()
+            self.state_1.clear_forces()
+            self.integrator.simulate(self.model, self.state_0, self.state_1, self.sim_dt)
+
+            # swap states
+            (self.state_0, self.state_1) = (self.state_1, self.state_0)
+
+    def step(self):
+        with wp.ScopedTimer("step"):
+            if self.use_graph:
+                wp.capture_launch(self.graph)
+            else:
+                self.simulate()
+        self.sim_time += self.frame_dt
+
+    def render(self):
+        if self.renderer is None:
+            return
+
+        with wp.ScopedTimer("render"):
+            self.renderer.begin_frame(self.sim_time)
+            self.renderer.render(self.state_0)
+            self.renderer.end_frame()
+
+
+if __name__ == "__main__":
+    stage_path = os.path.join(os.path.dirname(__file__), "example_particle_chain.usd")
+
+    example = Example(stage_path)
+
+    for i in range(example.sim_frames):
+        example.step()
+        example.render()
+
+    if example.renderer:
+        example.renderer.save()

warp/examples/sim/example_quadruped.py

@@ -0,0 +1,179 @@
+# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+###########################################################################
+# Example Sim Quadruped
+#
+# Shows how to set up a simulation of a rigid-body quadruped articulation
+# from a URDF using the wp.sim.ModelBuilder().
+# Note this example does not include a trained policy.
+#
+###########################################################################
+
+import math
+import os
+
+import numpy as np
+
+import warp as wp
+import warp.sim
+import warp.sim.render
+
+wp.init()
+
+
+# Taken from env/environment.py
+def compute_env_offsets(num_envs, env_offset=(5.0, 0.0, 5.0), up_axis="Y"):
+    # compute positional offsets per environment
+    env_offset = np.array(env_offset)
+    nonzeros = np.nonzero(env_offset)[0]
+    num_dim = nonzeros.shape[0]
+    if num_dim > 0:
+        side_length = int(np.ceil(num_envs ** (1.0 / num_dim)))
+        env_offsets = []
+    else:
+        env_offsets = np.zeros((num_envs, 3))
+    if num_dim == 1:
+        for i in range(num_envs):
+            env_offsets.append(i * env_offset)
+    elif num_dim == 2:
+        for i in range(num_envs):
+            d0 = i // side_length
+            d1 = i % side_length
+            offset = np.zeros(3)
+            offset[nonzeros[0]] = d0 * env_offset[nonzeros[0]]
+            offset[nonzeros[1]] = d1 * env_offset[nonzeros[1]]
+            env_offsets.append(offset)
+    elif num_dim == 3:
+        for i in range(num_envs):
+            d0 = i // (side_length * side_length)
+            d1 = (i // side_length) % side_length
+            d2 = i % side_length
+            offset = np.zeros(3)
+            offset[0] = d0 * env_offset[0]
+            offset[1] = d1 * env_offset[1]
+            offset[2] = d2 * env_offset[2]
+            env_offsets.append(offset)
+    env_offsets = np.array(env_offsets)
+    min_offsets = np.min(env_offsets, axis=0)
+    correction = min_offsets + (np.max(env_offsets, axis=0) - min_offsets) / 2.0
+    if isinstance(up_axis, str):
+        up_axis = "XYZ".index(up_axis.upper())
+    correction[up_axis] = 0.0  # ensure the envs are not shifted below the ground plane
+    env_offsets -= correction
+    return env_offsets
+
+
+class Example:
+    def __init__(self, stage=None, num_envs=1, print_timers=True):
+        self.num_envs = num_envs
+        articulation_builder = wp.sim.ModelBuilder()
+        wp.sim.parse_urdf(
+            os.path.join(os.path.dirname(__file__), "../assets/quadruped.urdf"),
+            articulation_builder,
+            xform=wp.transform([0.0, 0.7, 0.0], wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), -math.pi * 0.5)),
+            floating=True,
+            density=1000,
+            armature=0.01,
+            stiffness=200,
+            damping=1,
+            contact_ke=1.0e4,
+            contact_kd=1.0e2,
+            contact_kf=1.0e2,
+            contact_mu=1.0,
+            limit_ke=1.0e4,
+            limit_kd=1.0e1,
+        )
+
+        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 = 5
+        self.sim_dt = self.frame_dt / self.sim_substeps
+
+        offsets = compute_env_offsets(num_envs)
+        for i in range(num_envs):
+            builder.add_builder(articulation_builder, xform=wp.transform(offsets[i], wp.quat_identity()))
+
+            builder.joint_q[-12:] = [0.2, 0.4, -0.6, -0.2, -0.4, 0.6, -0.2, 0.4, -0.6, 0.2, -0.4, 0.6]
+
+            builder.joint_axis_mode = [wp.sim.JOINT_MODE_TARGET_POSITION] * len(builder.joint_axis_mode)
+            builder.joint_act[-12:] = [0.2, 0.4, -0.6, -0.2, -0.4, 0.6, -0.2, 0.4, -0.6, 0.2, -0.4, 0.6]
+
+        np.set_printoptions(suppress=True)
+        # finalize model
+        self.model = builder.finalize()
+        self.model.ground = True
+        # self.model.gravity = 0.0
+
+        self.model.joint_attach_ke = 16000.0
+        self.model.joint_attach_kd = 200.0
+
+        # self.integrator = wp.sim.XPBDIntegrator()
+        # self.integrator = wp.sim.SemiImplicitIntegrator()
+        self.integrator = wp.sim.FeatherstoneIntegrator(self.model)
+
+        self.renderer = None
+        if stage:
+            self.renderer = wp.sim.render.SimRenderer(self.model, stage)
+
+        self.print_timers = print_timers
+
+        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:
+            with wp.ScopedCapture() as capture:
+                self.simulate()
+            self.graph = capture.graph
+
+    def simulate(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
+
+    def step(self):
+        with wp.ScopedTimer("step", active=True, print=self.print_timers):
+            if self.use_graph:
+                wp.capture_launch(self.graph)
+            else:
+                self.simulate()
+        self.sim_time += self.frame_dt
+
+    def render(self):
+        if self.renderer is None:
+            return
+
+        with wp.ScopedTimer("render", active=True, print=self.print_timers):
+            self.renderer.begin_frame(self.sim_time)
+            self.renderer.render(self.state_0)
+            self.renderer.end_frame()
+
+
+if __name__ == "__main__":
+
+    stage = os.path.join(os.path.dirname(__file__), "example_quadruped.usd")
+
+    example = Example(stage, num_envs=25)
+
+    for _ in range(example.episode_frames):
+        example.step()
+        example.render()
+
+    if example.renderer:
+        example.renderer.save()