def __init__(self, material: agx.Material = None):
super().__init__()
visual_geometry = agxCollide.Geometry(intermediate_shape.deepCopy(),
agx.AffineMatrix4x4.rotate(math.pi / 2, 0, 1, 0) *
agx.AffineMatrix4x4.rotate(math.pi, 1, 0, 0))
visual_geometry.setEnableCollisions(False)
snakeapp.create_visual(visual_geometry, agxRender.Color.Orange())
collision_geometry = agxCollide.Geometry(agxCollide.Box(intermediate_bounds),
agx.AffineMatrix4x4.translate(intermediate_len / 2, 0, 0))
self.body = agx.RigidBody()
self.body.add(visual_geometry)
self.body.add(collision_geometry)
self.add(self.body)
sensor_geometry = agxCollide.Geometry(agxCollide.Box(sensor_bounds),
agx.AffineMatrix4x4.translate(intermediate_len / 2, -0.035, 0))
self.sensor = agx.RigidBody(sensor_geometry)
self.add(self.sensor)
if material is not None:
collision_geometry.setMaterial(material)
sensor_geometry.setMaterial(material)
self.merged_body = agx.MergedBody()
self.merged_body.add(agx.MergedBodyEmptyEdgeInteraction(self.body, self.sensor))
snakeapp.add(self.merged_body)
def buildArena(arena_pos):
sim = agxPython.getContext().environment.getSimulation()
app = agxPython.getContext().environment.getApplication()
root = agxPython.getContext().environment.getSceneRoot()
arena_size = [width, width, 0.2]
h = 0.35
floor = agx.RigidBody(
agxCollide.Geometry(
agxCollide.Box(arena_size[0] / 2, arena_size[1] / 2,
arena_size[2] / 2)))
floor.setPosition(arena_pos[0], arena_pos[1],
arena_pos[2] - arena_size[2] / 2)
floor.setMotionControl(1)
sim.add(floor)
agxOSG.setDiffuseColor(agxOSG.createVisual(floor, root),
agxRender.Color.Gray())
# Octagon sides
sides = 8
skip_sides = [9]
side_len = width / (1 + np.sqrt(2)) + arena_size[2] / 2 / np.sqrt(2)
base_pos = agx.Vec3(arena_pos[0], arena_pos[1],
arena_pos[2] - arena_size[2] / 2 + h / 2)
for w in range(sides):
if w not in skip_sides:
theta = -w * np.pi / 4
rot = agx.Quat(theta, agx.Vec3(0, 0, 1))
rot_pos = agx.Vec3(
np.sin(theta) * width / 2, -np.cos(theta) * width / 2, 0)
wall = agx.RigidBody(
agxCollide.Geometry(
agxCollide.Box(side_len / 2, arena_size[2] / 2, h / 2)))
wall.setPosition(base_pos + rot_pos)
wall.setMotionControl(1)
wall.setRotation(rot)
sim.add(wall)
agxOSG.setDiffuseColor(agxOSG.createVisual(wall, root),
agxRender.Color.DarkGray())
# Ramp up to the course
ramp_dim = [1.4, side_len, 0.2] # *np.cos(np.pi/4)
ramp = agx.RigidBody(
agxCollide.Geometry(
agxCollide.Box(ramp_dim[0] / 2, ramp_dim[1] / 2, ramp_dim[2] / 2)))
theta = -np.arcsin(ramp_dim[2] / ramp_dim[0]) / 2
ramp.setPosition(
arena_pos[0] - arena_size[0] / 2 - ramp_dim[0] / 2 * np.cos(theta) -
ramp_dim[2] / 2 * np.sin(theta), arena_pos[1],
arena_pos[2] - arena_size[2] * 3 / 4) # +arena_size[1]/2-ramp_dim[1]/2
ramp.setRotation(agx.Quat(theta, agx.Vec3(0, 1, 0)))
ramp.setMotionControl(1)
sim.add(ramp)
agxOSG.setDiffuseColor(agxOSG.createVisual(ramp, root),
agxRender.Color.Gray())
obstacles(sim, root, arena_pos)
def create_bodies(position1, position2, size):
b1 = agx.RigidBody()
b2 = agx.RigidBody()
b1.add(agxCollide.Geometry(agxCollide.Box(size[0], size[1], size[2])))
b2.add(agxCollide.Geometry(agxCollide.Box(size[0], size[1], size[2])))
b1.setPosition(agx.Vec3(position1[0], position1[1], position1[2]))
b2.setPosition(agx.Vec3(position2[0], position2[1], position2[2]))
return b1, b2
def init(self, width, length, rFender):
ship = agx.RigidBody()
self.add(ship)
self.m_body = ship
self.m_body.setName('boat')
half_length = length * 0.5
half_width = width * 0.5
half_height = 0.25 * half_width
b = agxCollide.Geometry(agxCollide.Box(half_length, half_width, half_height))
b.setName('ship')
"""Capsules"""
radius = half_height * 1.2
left_c = agxCollide.Geometry(agxCollide.Capsule(radius, length - 2 * radius))
left_c.setRotation(agx.Quat(math.pi * 0.5, agx.Vec3.Z_AXIS()))
left_c.setPosition(0, half_width - radius, - (half_height + radius))
right_capsules = agxCollide.Geometry(agxCollide.Capsule(radius, length - 2 * radius))
right_capsules.setRotation(agx.Quat(math.pi * 0.5, agx.Vec3.Z_AXIS()))
right_capsules.setPosition(0, radius - half_width, - (half_height + radius))
"""Fender"""
fender_material = agx.Material("fenderMaterial")
landing_material = agx.Material("landingMaterial")
contact_material = demoutils.sim().getMaterialManager().getOrCreateContactMaterial(fender_material,
landing_material)
contact_material.setYoungsModulus(5e5)
contact_material.setFrictionCoefficient(1.0)
contact_material.setDamping(0.4)
self.create_fenders(fender_material, rFender, half_width, half_height, half_length)
"""Top"""
t_box = agxCollide.Geometry(agxCollide.Box(half_length * 0.5, half_width * 0.5, half_height))
t_box.setPosition(-0.4, 0, 2 * half_height)
tt_box = agxCollide.Geometry(agxCollide.Box(half_length * 0.2, half_width * 0.4, half_height * 1.1))
tt_box.setPosition(0, 0, 4.1 * half_height)
"""Assemble ship"""
ship.add(b) # base
ship.add(left_c) # left capsule
ship.add(right_capsules) # left fender
ship.add(t_box) # box on top of base
ship.add(tt_box) # box on top of box on top of base
ship.setPosition(-90, 0, 0)
self.n = 1
self.m_left_propeller = agx.Vec3(-half_length, half_width - radius, - (half_height + 2 * radius))
self.m_right_propeller = agx.Vec3(-half_length, radius - half_width, - (half_height + 2 * radius))
def make_water(water_density, water_length, water_width, water_height):
"""
Args:
water_density:
water_length:
water_width:
water_height:
Returns:
"""
seafloorImageBuilder.save_new_seafloor_image(width=water_length)
water_material = agx.Material("waterMaterial")
water_material.getBulkMaterial().setDensity(water_density)
water_geometry = agxCollide.Geometry(
agxCollide.Box(water_length, water_width / 2, water_height / 2))
water_geometry.setPosition(0, 0, -water_height / 2)
seafloor = MakeWater.make_seafloor(vairance=SEAFLOOR_VARIANCE,
length=water_length * 2,
width=water_width,
depth=-water_height)
"""Surface of water at z = 0."""
water_geometry.setMaterial(water_material)
MakeWater.add_color(water_geometry)
""" ads visualisation"""
agxOSG.createVisual(seafloor, demoutils.root())
print("build water and seafloor")
return water_geometry, seafloor
def __init__(self, material):
props = BrickProps()
props.length *= 2
props.mass *= 3
super(Duplo4x2Cone, self).__init__(props)
self.add_top(props, material)
self.add_walls(props, material)
self.add_center(props, material)
self.add_center(props, material, x=props.stud_centerdist * 2)
self.add_center(props, material, x=-props.stud_centerdist * 2)
self.add_extrudes(props, material)
self.add_stud(props, material, 3 * props.stud_centerdist, props.stud_centerdist)
self.add_stud(props, material, 3 * props.stud_centerdist, -props.stud_centerdist)
self.add_stud(props, material, -3 * props.stud_centerdist, props.stud_centerdist)
self.add_stud(props, material, -3 * props.stud_centerdist, -props.stud_centerdist)
#Add cone
base = agxCollide.Geometry(agxCollide.Box((props.width - 0.001) / 2, (props.width - 0.001) / 2, props.studcyl_height * 1.5))
self.brick_rb.add(base)
base.setLocalPosition(0, 0, props.height + props.studcyl_height * 1.5)
base.setMaterial(material)
cone_topradius = 2 * props.stud_radius
cone_bottomradius = (props.width -0.001) / 2
cone_height = 0.038
cone = agxCollide.Geometry(agxCollide.Cone(cone_topradius, cone_bottomradius, cone_height))
cone.setMaterial(material)
rotate_x(cone, 90)
self.brick_rb.add(cone)
cone.setLocalPosition(0, 0, props.height)
self.add_stud(props, material, x=0, y=0, z=cone_height)
self.height += cone_height #Add cone height
self.brick_rb.setRotation(agx.EulerAngles(0, 0, math.radians(-90)))
def create_bodies(position1, position2, size):
# Create first leg section and set position
leg_section1 = agx.RigidBody()
leg_section1.add(
agxCollide.Geometry(agxCollide.Box(size[0], size[1], size[2])))
leg_section1.setPosition(agx.Vec3(position1[0], position1[1],
position1[2]))
# Create second leg section and set position
leg_section2 = agx.RigidBody()
leg_section2.add(
agxCollide.Geometry(agxCollide.Box(size[0], size[1], size[2])))
leg_section2.setPosition(agx.Vec3(position2[0], position2[1],
position2[2]))
return leg_section1, leg_section2
def create_box(position: agx.Vec3, scale):
shape = agxCollide.Box(agx.Vec3(0.5 * scale, 0.5 * scale, 0.5 * scale))
geometry = agxCollide.Geometry(shape)
body = agx.RigidBody(geometry)
body.setPosition(position)
oneLegRobotApp.create_visual(body)
return body
def setup_scene(i: int):
snake = Snake(NUM_SNAKE_MODULES, pitch_only=False,
with_camera=True) # type: Snake
snake.setPosition(agx.Vec3(0, 0, 0.1))
snakeapp.add(snake)
plane_body = agx.RigidBody(
agxCollide.Geometry(agxCollide.Box(2, 2, 0.1),
agx.AffineMatrix4x4.translate(0, 0, -0.1 / 2)))
plane_body.setMotionControl(agx.RigidBody.STATIC)
snakeapp.create_visual(plane_body, diffuse_color=agxRender.Color.Green())
snakeapp.add(plane_body)
snake_controller = SnakeControl(snake)
if i == FLAPPING:
snake_controller.init_flapping(math.pi / 9.0, math.pi / 9.0, 16.0,
-math.pi * 5.0 / 180.0)
elif i == TURNING:
snake_controller.init_turning(math.pi / 9.0, math.pi * 2.0 / 3.0, 8.0,
0.0, math.pi * 20.0 / 180.0)
elif i == SIDEWINDING:
snake_controller.init_sidewinding(math.pi / 9.0, math.pi * 2.0 / 3.0,
16.0)
elif i == ROLLING:
snake_controller.init_rolling(math.pi / 6.0, math.pi / 6.0, 16.0)
elif i == ROTATING:
snake_controller.init_rotating(math.pi / 6.0, math.pi / 6.0, 16.0)
snakeapp.add_event_listener(snake_controller)
snakeapp.init_camera(eye=agx.Vec3(-1, -1, 0.5),
center=plane_body.getPosition())
def create_box(position: agx.Vec3):
shape = agxCollide.Box(agx.Vec3(0.5, 0.5, 0.5))
geometry = agxCollide.Geometry(shape)
body = agx.RigidBody(geometry)
body.setPosition(position)
demoutils.create_visual(body)
return body
def create_slope() -> agx.RigidBody:
slope_body = agx.RigidBody(agxCollide.Geometry(agxCollide.Box(1, 1, 0.05)))
snakeapp.create_visual(slope_body, diffuse_color=Color.Red())
# slope_body.setPosition(agx.Vec3(0, 0, 0))
slope_body.setRotation(agx.EulerAngles(0, -math.radians(slope_angle),
0)) # Rotate 30 deg around Y.
slope_body.setMotionControl(agx.RigidBody.STATIC)
material = agx.Material("slopeMaterial")
slope_body.getGeometries()[0].setMaterial(material)
return slope_body
def add_slope():
half_extents = agx.Vec3(length, 0.1, 0.005)
slope = agxCollide.Geometry(agxCollide.Box(half_extents),
agx.AffineMatrix4x4.translate(half_extents.x(), 0, -half_extents.z()))
slope.setRotation(agx.EulerAngles(0, -self._slope_angle, 0))
snakeapp.create_visual(slope, diffuse_color=agxRender.Color.Red())
slope.setMaterial(self.material)
self.add(slope)
return slope
def build_scene():
floor = agxCollide.Geometry(agxCollide.Box(10, 10, 0.1))
floor.setPosition(0, 0, -4)
demoutils.sim().add(floor)
# Create each and every one of the scenes
create_hinge_scene()
demoutils.app().getSceneDecorator().setEnableShadows(False)
demoutils.app().setEnableDebugRenderer(True)
def addboxx(sim, root, dims, pos, Fixed=True, color = agxRender.Color.Red()):
if type(pos) == type([]):
pos = agx.Vec3(pos[0], pos[1], pos[2])
boxx = agx.RigidBody( agxCollide.Geometry( agxCollide.Box(dims[0]/2, dims[1]/2, dims[2]/2)))
boxx.setPosition(pos)
if(Fixed):
boxx.setMotionControl(1)
sim.add(boxx)
agxOSG.setDiffuseColor(agxOSG.createVisual(boxx, root), color)
return boxx
def create_floor():
w = 200
b = 200
h = 10
#floor = agxCollide.Geometry(agxCollide.Box(2.5, 0.5, h), agx.AffineMatrix4x4.translate(0, 0, -h))
floor = agxCollide.Geometry(agxCollide.Box(w, b, h))
floor.setPosition(0, 0, 0)
floor.setRotation(agx.EulerAngles(0, 0, 0))
oneLegRobotApp.create_visual(floor, diffuse_color=agxRender.Color.Green())
oneLegRobotApp.add(floor)
def add_box():
height = math.sin(self._slope_angle) * length
half_extents = agx.Vec3(0.5, 0.1, height)
box = agxCollide.Geometry(agxCollide.Box(half_extents),
agx.AffineMatrix4x4.translate(0, 0, half_extents.z()))
box.setParentFrame(self.slope.getParentFrame())
box.setLocalPosition(0.5 + math.cos(self._slope_angle), 0, 0)
snakeapp.create_visual(box, diffuse_color=agxRender.Color.Yellow())
box.setMaterial(self.material)
self.add(box)
def add_walls(self, props, material, x=0, y=0, z=0):
""" Add four walls """
length_wall_1 = agxCollide.Geometry(agxCollide.Box(props.length / 2, props.wall_width / 2, props.wall_height / 2))
length_wall_1.setMaterial(material)
length_wall_2 = length_wall_1.clone()
width_wall_1 = agxCollide.Geometry(agxCollide.Box(props.width / 2, props.wall_width / 2, props.wall_height / 2))
width_wall_1.setMaterial(material)
width_wall_2 = width_wall_1.clone()
self.brick_rb.add(width_wall_1)
self.brick_rb.add(width_wall_2)
self.brick_rb.add(length_wall_1)
self.brick_rb.add(length_wall_2)
length_wall_1.setLocalPosition(x, y + props.width / 2 - props.wall_width / 2, z + props.wall_height / 2)
length_wall_2.setLocalPosition(x, y - props.width / 2 + props.wall_width / 2, z + props.wall_height / 2)
rotate_z(width_wall_1, 90)
rotate_z(width_wall_2, 90)
width_wall_1.setLocalPosition(x + props.length / 2 - props.wall_width / 2, y, z + props.wall_height / 2)
width_wall_2.setLocalPosition(x - props.length / 2 + props.wall_width / 2, y, z + props.wall_height / 2)
def createPond(sim, root):
water_material = agx.Material("waterMaterial")
water_material.getBulkMaterial().setDensity(1025)
water = agxCollide.Geometry(agxCollide.Box(30, 50, 5))
water.setMaterial(water_material)
water.setPosition(agxVec([10,-8,45]))
sim.add(water)
controller = agxModel.WindAndWaterController()
controller.addWater(water)
create_water_visual(water, root)
sim.add(controller)
def build_scene():
sim = demoutils.sim()
# Create a geometry with a plane shape as our 'floor'
floor_geometry = agxCollide.Geometry(agxCollide.Box(agx.Vec3(10, 10, 0.1)))
demoutils.create_visual(floor_geometry, Color.Green())
sim.add(floor_geometry) # Add the geometry to the simulation
sim.add(create_box(agx.Vec3(-2, 3, 5)))
sim.add(create_sphere(agx.Vec3(0, 1, 5)))
sim.add(create_capsule(agx.Vec3(3, 5, 5)))
sim.add(create_cylinder(agx.Vec3(-3, -2, 5)))
def buildArena(sim, root):
width = 14
arena_size = [width, width, 0.2]
arena_pos = [0, 0, -1]
h = 0.7
floor = agx.RigidBody(
agxCollide.Geometry(
agxCollide.Box(arena_size[0] / 2, arena_size[1] / 2,
arena_size[2] / 2)))
floor.setPosition(arena_pos[0], arena_pos[1],
arena_pos[2] - arena_size[2] / 2)
floor.setMotionControl(1)
sim.add(floor)
agxOSG.setDiffuseColor(agxOSG.createVisual(floor, root),
agxRender.Color.Gray())
sides = 8
side_len = width / (1 + np.sqrt(2)) + arena_size[2] / 2 / np.sqrt(2)
base_pos = agx.Vec3(arena_pos[0], arena_pos[1],
arena_pos[2] - arena_size[2] / 2 + h / 2)
for w in range(sides):
theta = -w * np.pi / 4
rot = agx.Quat(theta, agx.Vec3(0, 0, 1))
rot_pos = agx.Vec3(
np.sin(theta) * width / 2, -np.cos(theta) * width / 2, 0)
wall = agx.RigidBody(
agxCollide.Geometry(
agxCollide.Box(side_len / 2, arena_size[2] / 2, h / 2)))
wall.setPosition(base_pos + rot_pos)
wall.setMotionControl(1)
wall.setRotation(rot)
sim.add(wall)
agxOSG.setDiffuseColor(agxOSG.createVisual(wall, root),
agxRender.Color.DarkGray())
obstacles(sim, root, arena_pos[2])
def build_scene1():
# Create a geometry with a plane shape as our 'floor'
floor_geometry = agxCollide.Geometry(agxCollide.Box(agx.Vec3(10, 10, 0.1)))
demoutils.create_visual(floor_geometry)
demoutils.sim().add(floor_geometry) # Add the geometry to the simulation
rb1 = agx.RigidBody() # Create a rigid body
rb1.add(agxCollide.Geometry(agxCollide.Sphere(
0.5))) # Add a geometry with a sphere-shape of radius 0.5
rb1.setPosition(0, 0, 5.0) # Position the sphere somewhere above our plane
demoutils.create_visual(rb1)
demoutils.sim().add(
rb1) # Add the body to the simulation. The geometry will also be added
def add_extrudes(self, props, material):
""" Adds extrudes for hole fit at bottom wall_width """
extrude1 = agxCollide.Geometry(agxCollide.Box(props.ext_size / 2, props.wall_width / 2, props.center_height / 2))
extrude1.setMaterial(material)
extrude2 = extrude1.clone()
extrude3 = extrude1.clone()
extrude4 = extrude1.clone()
extrude5 = extrude1.clone()
extrude6 = extrude1.clone()
extrude7 = extrude1.clone()
extrude8 = extrude1.clone()
self.brick_rb.add(extrude1)
self.brick_rb.add(extrude2)
self.brick_rb.add(extrude3)
self.brick_rb.add(extrude4)
self.brick_rb.add(extrude5)
self.brick_rb.add(extrude6)
self.brick_rb.add(extrude7)
self.brick_rb.add(extrude8)
extrude1.setLocalPosition(props.length / 2 - props.wall_width - props.ext_size / 2, props.stud_centerdist, props.wall_height/2)
extrude2.setLocalPosition(props.length / 2 - props.wall_width - props.ext_size / 2, -props.stud_centerdist, props.wall_height/2)
rotate_z(extrude3, 90)
extrude3.setLocalPosition(props.stud_centerdist, -(props.width / 2 - props.wall_width - props.ext_size / 2), props.wall_height/2)
rotate_z(extrude4, 90)
extrude4.setLocalPosition(-props.stud_centerdist, -(props.width / 2 - props.wall_width - props.ext_size / 2), props.wall_height/2)
extrude5.setLocalPosition(-(props.length / 2 - props.wall_width - props.ext_size / 2), -props.stud_centerdist, props.wall_height/2)
extrude6.setLocalPosition(-(props.length / 2 - props.wall_width - props.ext_size / 2), props.stud_centerdist, props.wall_height/2)
rotate_z(extrude7, 90)
extrude7.setLocalPosition(-props.stud_centerdist, props.width / 2 - props.wall_width - props.ext_size / 2, props.wall_height/2)
rotate_z(extrude8, 90)
extrude8.setLocalPosition(props.stud_centerdist, props.width / 2 - props.wall_width - props.ext_size / 2, props.wall_height/2)
if props.length >= 2 * props.width:
#Long brick, add more extrudes
extrude9 = extrude3.clone()
extrude10 = extrude3.clone()
extrude11 = extrude3.clone()
extrude12 = extrude3.clone()
self.brick_rb.add(extrude9)
self.brick_rb.add(extrude10)
self.brick_rb.add(extrude11)
self.brick_rb.add(extrude12)
extrude9.setLocalPosition(props.stud_centerdist + props.width / 2, -(props.width / 2 - props.wall_width - props.ext_size / 2), props.wall_height/2)
extrude10.setLocalPosition(-(props.stud_centerdist + props.width / 2), -(props.width / 2 - props.wall_width - props.ext_size / 2), props.wall_height/2)
extrude11.setLocalPosition(-(props.stud_centerdist + props.width / 2), props.width / 2 - props.wall_width - props.ext_size / 2, props.wall_height/2)
extrude12.setLocalPosition(props.stud_centerdist + props.width / 2, props.width / 2 - props.wall_width - props.ext_size / 2, props.wall_height/2)
def create_floor(self):
w = 200
b = 200
h = 10
# floor = agxCollide.Geometry(agxCollide.Box(2.5, 0.5, h), agx.AffineMatrix4x4.translate(0, 0, -h))
floor = agxCollide.Geometry(agxCollide.Box(w, b, h))
floor.setPosition(0, 0, 0)
floor.setRotation(agx.EulerAngles(0, 0, 0))
floor.setEnableCollisions(True)
rigidBody = agx.RigidBody(floor)
rigidBody.setMotionControl(agx.RigidBody.STATIC)
oneLegRobotApp.create_visual(rigidBody,
diffuse_color=agxRender.Color.Green())
return floor
def build_scene(): # application entry point. Do not change method signature
snake1 = Snake(num_modules=5, pitch_only=True)
snake1.setLocalPosition(0, -0.1, 0)
snakeapp.add(snake1)
snake2 = Snake(num_modules=5, pitch_only=False)
snake2.setLocalPosition(0, 0.1, 0)
snakeapp.add(snake2)
snake3 = Snake2(num_modules=5, pitch_only=False, with_camera=True)
snake3.setLocalPosition(0, 0.4, 0)
snakeapp.add(snake3)
plane = agxCollide.Geometry(agxCollide.Box(2, 2, 0.1), agx.AffineMatrix4x4.translate(0, 0, -0.1 / 2))
snakeapp.create_visual(plane, diffuse_color=agxRender.Color.Green())
snakeapp.add(plane)
def add_table(sim, root, height, length, width, material, visual):
""" Just a flat table """
table = agx.RigidBody()
table.setMotionControl(agx.RigidBody.STATIC)
table.setName("table")
table_geom = agxCollide.Geometry(
agxCollide.Box(length / 2, width / 2, height / 2))
table_geom.setName("table")
table.add(table_geom)
table_geom.setPosition(0, 0, -height / 2)
table_geom.setMaterial(material)
sim.add(table)
if visual:
m = agxOSG.createVisual(table, root)
agxOSG.setDiffuseColor(m, agxRender.Color.SaddleBrown())
return table
def build_scene2():
# Create a geometry with a plane shape as our 'floor'
floor_geometry = agxCollide.Geometry(agxCollide.Box(agx.Vec3(10, 10, 0.1)))
demoutils.create_visual(floor_geometry, diffuse_color=Color.Green())
demoutils.sim().add(floor_geometry) # Add the geometry to the simulation
for x in range(-5, 5):
for y in range(-5, 5):
for z in range(1, 8):
rb = agx.RigidBody() # Create a rigid body
rb.add(agxCollide.Geometry(agxCollide.Sphere(
0.2))) # Add a geometry with a sphere-shape of radius 0.2
rb.setPosition(
x + random(), y + random(),
z) # Position the sphere somewhere above our plane
demoutils.create_visual(rb)
demoutils.sim().add(
rb
) # Add the body to the simulation. The geometry will also be added
def __init__(self, ground: agxCollide.Geometry, rov, depth):
"""
Args:
ground:
rov:
depth:
"""
super().__init__()
self.setMask(ContactEventListener.CONTACT)
b = agxCollide.Box(.1, .1, depth)
self.beam = Geometry(b)
# print(self.beam.getShapes(),self.beam)
self.beam.setPosition(0, 0, -depth)
self.beam.setSensor(True)
self.setFilter(GeometryFilter(self.beam, ground))
color = agxRender.Color.IndianRed()
node = agxOSG.createVisual(self.beam, demoutils.root())
agxOSG.setDiffuseColor(node, color)
agxOSG.setAmbientColor(node, agx.Vec4f(1))
agxOSG.setShininess(node, 120)
agxOSG.setAlpha(node, 0.6)
self.ground = ground.getShape().asHeightField()
def build_scene(): # application entry point. Do not change method signature
snakeapp.register_additional_scenes('build_scene_2')
snake = Snake(NUM_SNAKE_MODULES, pitch_only=False)#, with_camera=True) # type: snake_module.Snake
snake.setPosition(agx.Vec3(0, 0, 0.1))
snakeapp.add(snake)
plane = agxCollide.Geometry(agxCollide.Box(2, 2, 0.1), agx.AffineMatrix4x4.translate(0, 0, -0.1/2))
snakeapp.create_visual(plane, diffuse_color=agxRender.Color.Green())
snakeapp.add(plane)
ball = agxCollide.Geometry(agxCollide.Sphere(0.035), agx.AffineMatrix4x4.translate(0, 0, 0))
snakeapp.create_visual(ball, diffuse_color=agxRender.Color.YellowGreen())
ball.setPosition(agx.Vec3(-0.5, 0, 0.1))
snakeapp.add(ball)
snakeapp.add_event_listener(MyKeyEvent(ball))
snakeapp.init_camera(eye=agx.Vec3(-1, -1, 0.5))
snake_controller = SnakeBallControl(snake, ball)
snake_controller.init_turning(math.pi / 9.0, math.pi * 2.0 / 3.0, 8.0, 0.0, math.pi * 0.0 / 180.0)
snakeapp.add_event_listener(snake_controller)
def create_spoiler():
spoiler_geom = agxCollide.Geometry(agxCollide.Box(0.05, 0.38, 0.005))
spoiler = agx.RigidBody(spoiler_geom)
return spoiler
def ship_body(half_length, half_width, half_height) -> agx.RigidBody:
geom = agxCollide.Geometry(
agxCollide.Box(half_length, half_width, half_height))
boat = agx.RigidBody(geom)
boat.setMotionControl(agx.RigidBody.DYNAMICS)
return boat
