python/examples/body_physics_props.py

"""
Copyright (c) 2020, 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.


Body physics properties example
-------------------------------
An example that demonstrates how to load rigid body, update its properties
and apply various actions. Specifically, there are three scenarios that
presents the following:
- Load rigid body asset with varying properties
- Modify body shape properties
- Modify body visual properties
- Apply body force
- Apply body linear velocity
"""

from isaacgym import gymutil
from isaacgym import gymapi

# initialize gym
gym = gymapi.acquire_gym()

# parse arguments
args = gymutil.parse_arguments(description="Body Physics Properties Example")

# configure sim
sim_params = gymapi.SimParams()
if args.physics_engine == gymapi.SIM_FLEX:
    sim_params.flex.relaxation = 0.9
    sim_params.flex.dynamic_friction = 0.0
    sim_params.flex.static_friction = 0.0
elif args.physics_engine == gymapi.SIM_PHYSX:
    sim_params.physx.solver_type = 1
    sim_params.physx.num_position_iterations = 4
    sim_params.physx.num_velocity_iterations = 1
    sim_params.physx.num_threads = args.num_threads
    sim_params.physx.use_gpu = args.use_gpu

sim_params.use_gpu_pipeline = False
if args.use_gpu_pipeline:
    print("WARNING: Forcing CPU pipeline.")

sim = gym.create_sim(args.compute_device_id, args.graphics_device_id, args.physics_engine, sim_params)

if sim is None:
    print("*** Failed to create sim")
    quit()

# create viewer using the default camera properties
viewer = gym.create_viewer(sim, gymapi.CameraProperties())
if viewer is None:
    raise ValueError('*** Failed to create viewer')

# add ground plane
plane_params = gymapi.PlaneParams()
plane_params.static_friction = 0.0
plane_params.dynamic_friction = 0.0

gym.add_ground(sim, plane_params)

# set up the env grid
num_envs = 3
spacing = 1.8
env_lower = gymapi.Vec3(-spacing, 0.0, -spacing)
env_upper = gymapi.Vec3(spacing, spacing, spacing)

# create list to mantain environment and asset handles
envs = []
box_handles = []
actor_handles = []

# create box assets w/ varying densities (measured in kg/m^3)
box_size = 0.2
box_densities = [8., 32., 1024.]
for dx in range(3):
    # AssetOptions enables loading assets with different properties
    # Properties include density, angularDamping, maxAngularVelocity, linearDamping, maxLinearVelocity etc.
    asset_options = gymapi.AssetOptions()
    asset_options.density = box_densities[dx]
    asset_box = gym.create_box(sim, box_size, box_size, box_size, asset_options)
    box_handles.append(asset_box)

# create capsule asset
asset_options = gymapi.AssetOptions()
asset_options.density = 100.
asset_capsule = gym.create_capsule(sim, 0.2, 0.2, asset_options)

# create ball asset with gravity disabled
asset_root = "../../assets"
asset_file = "urdf/ball.urdf"
asset_options = gymapi.AssetOptions()
asset_options.disable_gravity = True
print("Loading asset '%s' from '%s'" % (asset_file, asset_root))
asset_ball = gym.load_asset(sim, asset_root, asset_file, asset_options)

# create static box asset
asset_options.fix_base_link = True
asset_box = gym.create_box(sim, 0.5, 0.1, 0.5, asset_options)

print('Creating %d environments' % num_envs)
for i in range(num_envs):
    # create env
    env = gym.create_env(sim, env_lower, env_upper, 1)
    envs.append(env)

    # Scenario 1: Source boxes collide with target boxes with varying densities
    if i == 0:
        # add moving boxes to env
        for dx in range(3):
            name = 'moving_box_{}'.format(dx)
            actor_handles.append(gym.create_actor(env, box_handles[0], gymapi.Transform(p=gymapi.Vec3(dx, 0.1, 0.)), name, i, 0))
            # set shape physics properties for moving boxes
            shape_props = gym.get_actor_rigid_shape_properties(env, actor_handles[-1])
            # set_actor_rigid_shape_properties enables setting shape properties for rigid body
            # Properties include friction, rolling_friction, torsion_friction, restitution etc.
            shape_props[0].friction = 0.
            shape_props[0].rolling_friction = 0.
            shape_props[0].torsion_friction = 0.
            gym.set_actor_rigid_shape_properties(env, actor_handles[-1], shape_props)
            # set visual property like color to moving boxes
            gym.set_rigid_body_color(env, actor_handles[-1], 0, gymapi.MESH_VISUAL, gymapi.Vec3(0., 1., 0.))
            # apply linear velocity
            gym.set_rigid_linear_velocity(env,
                                          gym.get_rigid_handle(env, name, gym.get_actor_rigid_body_names(env, actor_handles[0])[0]),
                                          gymapi.Vec3(0., 0., 2.))

        # add target boxes to env
        target_box_names = ['target_box_low', 'target_box_med', 'target_box_high']
        target_box_positions = [gymapi.Vec3(0., 0.1, 2.), gymapi.Vec3(1, 0.1, 2.), gymapi.Vec3(2, 0.1, 2.)]
        target_box_color = [gymapi.Vec3(0., 1., 0.), gymapi.Vec3(2, 0.1, 2.), gymapi.Vec3(1., 0., 0.)]
        for dx in range(3):
            actor_handles.append(gym.create_actor(env, box_handles[dx], gymapi.Transform(p=target_box_positions[dx]), target_box_names[dx], i, 0))
            # set shape physics properties for target boxes
            shape_props = gym.get_actor_rigid_shape_properties(env, actor_handles[-1])
            # set coeffecient of friction
            shape_props[0].friction = 0.
            shape_props[0].rolling_friction = 0.
            shape_props[0].torsion_friction = 0.
            gym.set_actor_rigid_shape_properties(env, actor_handles[-1], shape_props)
            # set visual property like color to target boxes
            gym.set_rigid_body_color(env, actor_handles[-1], 0, gymapi.MESH_VISUAL, target_box_color[dx])

    # Scenario 2: Capsule with varying restitution and complince dropped on a hanging box
    if i == 1:
        # add box actor
        pose = gymapi.Transform()
        pose.p = gymapi.Vec3(0.0, 0.5, 0.0)
        pose.r = gymapi.Quat(0, 0, 0, 1)
        box_handle = gym.create_actor(env, asset_box, pose, "actor1", i, 0)
        actor_handles.append(box_handle)

        # set restitution for box actor
        shape_props = gym.get_actor_rigid_shape_properties(env, box_handle)
        shape_props[0].restitution = 1
        shape_props[0].compliance = 0.5
        gym.set_actor_rigid_shape_properties(env, box_handle, shape_props)

        # add capsule actor
        pose.p = gymapi.Vec3(0.0, 2.0, 0.0)
        capsule_handle = gym.create_actor(env, asset_capsule, pose, "actor2", i, 0)

        # set restitution for capsule actor
        shape_props = gym.get_actor_rigid_shape_properties(env, capsule_handle)
        shape_props[0].restitution = 1
        shape_props[0].compliance = 0.5
        gym.set_actor_rigid_shape_properties(env, capsule_handle, shape_props)

    # Scenario 3: Balls with gravity enabled and disabled
    if i == 2:
        # create ball pyramid
        pose = gymapi.Transform()
        pose.r = gymapi.Quat(0, 0, 0, 1)
        num_balls = 3
        ball_radius = .2
        ball_spacing = 2.5 * ball_radius
        y = 1 * (num_balls - 1) * ball_spacing
        while num_balls > 0:
            pose.p = gymapi.Vec3(num_balls * 0.001, 1. + y, 0)
            # create ball actor
            ball_handle = gym.create_actor(env, asset_ball, pose, None)
            color_vec = [1, .2, .2]
            if num_balls != 2:
                color_vec = [.3, .8, .3]
                # Enable gravity back on the middle ball
                body_props = gym.get_actor_rigid_body_properties(env, ball_handle)
                for b in range(len(body_props)):
                    body_props[b].flags = gymapi.RIGID_BODY_NONE
                gym.set_actor_rigid_body_properties(env, ball_handle, body_props)

            # set ball color
            color = gymapi.Vec3(color_vec[0], color_vec[1], color_vec[2])
            gym.set_rigid_body_color(env, ball_handle, 0, gymapi.MESH_VISUAL_AND_COLLISION, color)

            y += ball_spacing
            num_balls -= 1

# look at the first env
cam_pos = gymapi.Vec3(6, 4.5, 3)
cam_target = gymapi.Vec3(-0.8, 0.5, 0)
gym.viewer_camera_look_at(viewer, None, cam_pos, cam_target)

while not gym.query_viewer_has_closed(viewer):

    # step the physics
    gym.simulate(sim)
    gym.fetch_results(sim, True)

    # update the viewer
    gym.step_graphics(sim)
    gym.draw_viewer(viewer, sim, True)

    # Wait for dt to elapse in real time.
    # This synchronizes the physics simulation with the rendering rate.
    gym.sync_frame_time(sim)

print('Done')

gym.destroy_viewer(viewer)
gym.destroy_sim(sim)