Fastest way to add the same mesh many times to builder?

[tueboesen]

I have the following simple example, which illustrates my problem fairly well.
Basically I am trying to add the same mesh many times to the same scene, but with a different position or rotation. Unfortunately this seems to take a very long time to do. I'm hoping that someone can tell me a better way to do this.
My guess is that it copies the mesh every time. This is the only explanation I can come up with why it takes more than 20 seconds to add a mesh 150 times to the builder.

But the mesh will always be the same for me, and I'm hoping there is some way to only give the mesh ones, both when it builds the model, but also when it runs the scene.

(Essentially the idea is to run the same simulation many times with slightly different starting positions/rotations and just have all the different meshes not collide with each other, and only collide with a static background)

import math
import os
import time

import meshio
import warp.examples
from pxr import Usd, UsdGeom

import numpy as np

import warp as wp
import warp.sim
import warp.sim.render


class Example:
    def __init__(self, stage_path="static_background_rigid_soft_contact.usd"):
        self.sim_width = 8
        self.sim_height = 8

        fps = 60
        self.frame_dt = 1.0 / fps
        self.sim_substeps = 32
        self.sim_dt = self.frame_dt / self.sim_substeps
        self.sim_time = 0.0
        self.sim_iterations = 1
        self.sim_relaxation = 1.0
        self.profiler = {}
        self.scale = 1
        self.ke = 1.0e5
        self.kd = 250.0
        self.kf = 500.0

        builder = wp.sim.ModelBuilder()
        builder.default_particle_radius = 0.01

        ke = 1.0e3
        kf = 0.0
        kd = 1.0e0
        mu = 0.2
        builder.add_shape_box(
            body=-1,
            pos=wp.vec3(0.5, 0.0, 0.5),
            hx=0.25,
            hy=1.0,
            hz=1.0,
            ke=ke,
            kf=kf,
            kd=kd,
            mu=mu,
        )

        bunny = self.load_mesh(os.path.join(warp.examples.get_asset_directory(), "bunny.usd"), "/root/bunny")
        builder.add_shape_mesh(
            body=-1,
            mesh=bunny,
            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,
            density=1e3,
            collision_group=1,
        )
        t0 = time.perf_counter()

        for i in range(150):
            b = builder.add_body(
                origin=wp.transform(
                    (0.5 , 3.0 + i * 2 , 0.5),
                    wp.quat_from_axis_angle(wp.vec3(0.0, 1.0, 0.0), math.pi * 0.1 * i),
                )
            )

            builder.add_shape_mesh(
                body=b,
                mesh=bunny,
                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,
                density=1e3,
                collision_group=i,
            )
        keys = builder.shape_collision_group_map.keys()
        value = 1
        collision_maps = builder.shape_collision_group_map
        for key in keys:
            if key == -1:
                continue
            if value not in builder.shape_collision_group_map[key]:
                builder.shape_collision_group_map[key].insert(0,1)

        t1 = time.perf_counter()
        print(f"adding meshes to builder {t1-t0:2.5f}s")



        self.model = builder.finalize()
        self.model.ground = True
        self.model.soft_contact_ke = 1.0e3
        self.model.soft_contact_kd = 0.0
        self.model.soft_contact_kf = 1.0e3

        self.integrator = wp.sim.SemiImplicitIntegrator()

        self.state_0 = self.model.state()
        self.state_1 = self.model.state()

        if stage_path:
            # self.renderer = wp.sim.render.SimRenderer(self.model, stage_path, scaling=1.0)
            self.renderer = wp.sim.render.SimRendererOpenGL(self.model, stage_path)
        else:
            self.renderer = None

        self.use_cuda_graph = wp.get_device().is_cuda
        if self.use_cuda_graph:
            with wp.ScopedCapture() as capture:
                self.simulate()
            self.graph = capture.graph

    def load_mesh(self, filename, path):
        asset_stage = Usd.Stage.Open(filename)
        mesh_geom = UsdGeom.Mesh(asset_stage.GetPrimAtPath(path))

        points = np.array(mesh_geom.GetPointsAttr().Get())
        indices = np.array(mesh_geom.GetFaceVertexIndicesAttr().Get()).flatten()

        return wp.sim.Mesh(points, indices)

    def simulate(self):
        for _s in range(self.sim_substeps):
            wp.sim.collide(self.model, self.state_0)

            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", dict=self.profiler):
            if self.use_cuda_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__":
    import argparse

    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument("--device", type=str, default=None, help="Override the default Warp device.")
    parser.add_argument(
        "--stage_path",
        type=lambda x: None if x == "None" else str(x),
        default="static_background_rigid_soft_contact.usd",
        help="Path to the output USD file.",
    )
    parser.add_argument("--num_frames", type=int, default=300, help="Total number of frames.")

    args = parser.parse_known_args()[0]

    with wp.ScopedDevice(args.device):
        example = Example(stage_path=args.stage_path)

        for _ in range(args.num_frames):
            example.step()
            example.render()

        if example.renderer:
            example.renderer.save()

[DINHQuangDung1999]

I believe you are trying to simulate multiple environments in parallel. Instead of using one builder for everything, you can try using one builder for building the scene, and multiple other builders for the meshes only. Check out Rewarped. I am not one of the authors though, just an interested user.