[QUESTION] Moving mesh during physics simulation

[SangHunHan92]

Thanks for great work !

I want to simulate a cloth for a moving object, exactly like this question.
#160

But I couldn't find updated + refit() in the link below:
https://github.com/NVIDIA/warp/blob/main/warp/sim/model.py#L256

But, I found simillar functions during search "refit":

warp/warp/types.py

Lines 2997 to 3004 in bfbd025

	def refit(self):
	"""Refit the BVH to points. This should be called after users modify the `points` data."""
	if self.device.is_cpu:
	self.runtime.core.mesh_refit_host(self.id)
	else:
	self.runtime.core.mesh_refit_device(self.id)
	self.runtime.verify_cuda_device(self.device)

warp/warp/examples/core/example_mesh.py

Lines 116 to 129 in bfbd025

	def step(self):
	with wp.ScopedTimer("step", dict=self.sim_timers):
	wp.launch(kernel=deform, dim=len(self.mesh.points), inputs=[self.mesh.points, self.sim_time])
	# refit the mesh BVH to account for the deformation
	self.mesh.refit()
	wp.launch(
	kernel=simulate,
	dim=self.num_particles,
	inputs=[self.positions, self.velocities, self.mesh.id, self.sim_margin, self.sim_dt],
	)
	self.sim_time += self.sim_dt

Has the function to update mesh been moved?

Also, if I combine this properly with the example below, can I get it to work as I intended?
https://github.com/NVIDIA/warp/blob/main/warp/examples/sim/example_cloth.py

[SangHunHan92]

Now I can deform the mesh using wp.launch. It's working well !!

@wp.kernel
def deform(positions: wp.array(dtype=wp.vec3), new_positions: wp.array(dtype=wp.vec3)):    
    tid = wp.tid()
    positions[tid] = new_positions[tid]

wp.launch(kernel=deform, dim=len(self.mesh.points), inputs=[self.mesh.points, self.animations[self.time_step]])

But it doesn't seem to work with wp.sim.ModelBuilder(). I similarly used code to deform the mesh, but the mesh did not move.

    def simulate(self):
        wp.sim.collide(self.model, self.state_0)

        # self.model.shape_geo_src[0].vertices -> np.array
        # self.model.shape_geo_src[0].mesh.points -> <warp.types.array object at 0x7febf3d0ddb0>
        # self.animations[self.time_step] -> <warp.types.array object at 0x7febf3d0ddb0>
        wp.launch(
            kernel=deform, 
            dim=len(self.mesh.mesh.points), 
            inputs=[self.model.shape_geo_src[0].mesh.points, self.animations[self.time_step]]
        )

        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)

            # swap states
            (self.state_0, self.state_1) = (self.state_1, self.state_0)

warp/warp/examples/sim/example_cloth.py

Lines 130 to 139 in 7de9179

	def simulate(self):
	wp.sim.collide(self.model, self.state_0)
	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)
	# swap states
	(self.state_0, self.state_1) = (self.state_1, self.state_0)

How can I deform mesh in wp.sim.ModelBuilder() ?
Should I add the mesh any other way than builder.add_shape_mesh ?

[biansy000]

Same problem. I do not know how to add the deform function into the simulate function.

[christophercrouzet]

Hi @SangHunHan92 and @biansy000,

wp.sim.ModelBuilder() is there to help setting up a simulation model. Once it's done, all the data is stored as Warp arrays in wp.sim.Model and wp.sim.State, so that's what you'd need to look at if you wanted to update anything while stepping through the simulation.

For example, to deform the mesh from the cloth example, you could run a kernel that'd modify self.state_0.particle_q before or after calling self.simulate().

The example warp/examples/sim/example_soft_body.py is actually doing something along these lines when launching the kernel twist_points.

[biansy000]

Here is an example code I have written.

from enum import Enum

import numpy as np
from pxr import Usd, UsdGeom

import warp as wp
import warp.examples
import warp.sim
import warp.sim.render
import open3d as o3d


import tinyobjloader
def obj_loader(path):
    # Create reader.
    reader = tinyobjloader.ObjReader()
    # Load .obj(and .mtl) using default configuration
    ret = reader.ParseFromFile(path)
    # note here for wavefront obj, #v might not equal to #vt, same as #vn.
    attrib = reader.GetAttrib()
    verts = np.array(attrib.vertices).reshape(-1, 3)

    shapes = reader.GetShapes()
    tri = shapes[0].mesh.numpy_indices().reshape(-1, 9)
    faces = tri[:, [0, 3, 6]]

    return verts, faces


class IntegratorType(Enum):
    EULER = "euler"
    XPBD = "xpbd"

    def __str__(self):
        return self.value



@wp.kernel(enable_backward=False)
def update_collider_kernel(
    points_0: wp.array(dtype=wp.vec3),
    points_1: wp.array(dtype=wp.vec3),
    sim_dt: float,
    out_points: wp.array(dtype=wp.vec3),
    out_velocities: wp.array(dtype=wp.vec3),
):
    tid = wp.tid()

    point_0 = points_0[tid]
    point_1 = points_1[tid]

    out_points[tid] = point_0
    out_velocities[tid] = (point_1 - point_0) / sim_dt

    

def update_collider(state, points) -> None:
    """Updates the collider state."""
    # Swap the previous and current collider point positions.
    (state.collider_points_0, state.collider_points_1) = (
        state.collider_points_1,
        state.collider_points_0,
    )

    # print('state.collider_mesh.mesh.points', state.collider_mesh.mesh.points)
    wp.copy(state.collider_points_1, points)

    # Update the internal point positions and velocities.
    wp.launch(
        kernel=update_collider_kernel,
        dim=len(state.collider_mesh.vertices),
        inputs=[
            state.collider_points_0,
            state.collider_points_1,
            state.sim_dt,
        ],
        outputs=[
            state.collider_mesh.mesh.points,
            state.collider_mesh.mesh.velocities,
        ],
    )

    # Refit the BVH.
    state.collider_mesh.mesh.refit()



class Example:
    def __init__(
        self, stage_path="example_cloth.usd", integrator: IntegratorType = IntegratorType.EULER,
    ):
        self.integrator_type = integrator

        fps = 60
        self.sim_substeps = 32
        self.frame_dt = 1.0 / fps
        self.sim_dt = self.frame_dt / self.sim_substeps
        self.sim_time = 0.0
        self.profiler = {}

        builder = wp.sim.ModelBuilder()

        cloth_verts, cloth_faces = obj_loader('path_to_clothing_obj_file')

        cloth_verts = cloth_verts * 1
        cloth_verts = [wp.vec3(item) for item in cloth_verts]
        builder.add_cloth_mesh(
            pos=wp.vec3(0.0, 100.0, 0.0),
            rot=(0.0, 0.0, 0.0, 1.0),
            scale=1.0,
            vel=wp.vec3(0.0, 0.0, 0.0),
            vertices=cloth_verts,
            indices=cloth_faces.reshape(-1).tolist(),
            density=100.0
        )


        body_verts, body_faces = obj_loader('path_to_collider_obj_file')
        body_verts = [wp.vec3(item * 100) for item in body_verts]
        body_faces = body_faces.reshape(-1).tolist()

        mesh = wp.sim.Mesh(body_verts, body_faces)

        builder.add_shape_mesh(
            body=-1,
            mesh=mesh,
            pos=wp.vec3(0.0, 100.0, 0.0),
            rot=None,
            scale=wp.vec3(1.0, 1.0, 1.0),
            ke=1.0e2,
            kd=1.0e2,
            kf=1.0e1,
        )

        self.integrator = wp.sim.XPBDIntegrator(iterations=1)

        self.model = builder.finalize()
        self.model.ground = True
        self.model.soft_contact_ke = 1.0e4
        self.model.soft_contact_kd = 1.0e2

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

        # Store the collider's point positions as internal state.
        collider_points = wp.array(body_verts, dtype=wp.vec3)
        collider_points_0 = wp.empty_like(collider_points)
        collider_points_1 = wp.empty_like(collider_points)
        wp.copy(collider_points_0, collider_points)
        wp.copy(collider_points_1, collider_points)
        # Store the class members.
        self.collider_mesh = mesh
        self.collider_points_0 = collider_points_0
        self.collider_points_1 = collider_points_1

        self.body_verts = np.array(body_verts).copy()

        if stage_path:
            self.renderer = wp.sim.render.SimRenderer(self.model, stage_path, scaling=1.0)
        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 simulate(self):
        wp.sim.collide(self.model, self.state_0)

        for _ in range(self.sim_substeps):
            self.state_0.clear_forces()

            # wp.launch(
            #     update_contacts_kernel,
            #     self.model.soft_contact_max,
            #     inputs=[
            #         self.model.soft_contact_body_pos,
            #         self.model.soft_contact_body_vel,
            #         self.sim_dt,
            #     ],
            #     outputs=[
            #         self.model.soft_contact_body_pos,
            #     ],
            # )
            self.body_verts = self.body_verts + np.array([[0, 100, 0]])
            update_collider(self, wp.array(self.body_verts, dtype=wp.vec3))

            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="example_cloth.usd",
        help="Path to the output USD file.",
    )
    parser.add_argument("--num_frames", type=int, default=5, help="Total number of frames.")
    parser.add_argument(
        "--integrator",
        help="Type of integrator",
        type=IntegratorType,
        choices=list(IntegratorType),
        default=IntegratorType.XPBD,
    )
    args = parser.parse_known_args()[0]

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

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

        frame_times = example.profiler["step"]
        print("\nAverage frame sim time: {:.2f} ms".format(sum(frame_times) / len(frame_times)))

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

@christophercrouzet In the code, the collider is updated in each simulation step by updating self.body_verts and calling update_collider. However, I find that the collider is not moving in the simulating. Could you please tell me what is missing in my code? Thanks so much!