class HeightfieldVehicle(ShowBase):
def __init__(self, heightfield_fn="heightfield.png"):
# Store the heightfield's filename.
self.heightfield_fn = heightfield_fn
"""
Load some configuration variables, it's important for this to happen
before ShowBase is initialized
"""
load_prc_file_data("", """
sync-video #t
textures-power-2 none
###gl-coordinate-system default
notify-level-gobj warning
notify-level-grutil debug
notify-level-shader_terrain debug
notify-level-bullet debug
### model paths
model-path /usr/share/panda3d
model-path /home/juzzuj/code/prereq/bullet-samples/bullet-samples
""")
ShowBase.__init__(self)
base.set_background_color(0.1, 0.1, 0.8, 1)
base.set_frame_rate_meter(True)
# Increase camera Field Of View and set near and far planes
base.camLens.set_fov(90)
base.camLens.set_near_far(0.1, 50000)
# Lights
alight = AmbientLight('ambientLight')
alight.set_color(LVector4(0.5, 0.5, 0.5, 1))
alightNP = render.attach_new_node(alight)
dlight = DirectionalLight('directionalLight')
dlight.set_direction(LVector3(1, 1, -1))
dlight.set_color(LVector4(0.7, 0.7, 0.7, 1))
dlightNP = render.attach_new_node(dlight)
render.clear_light()
render.set_light(alightNP)
render.set_light(dlightNP)
# Basic game controls
self.accept('escape', self.do_exit)
self.accept('f1', base.toggle_wireframe)
self.accept('f2', base.toggle_texture)
self.accept('f3', self.toggle_debug)
self.accept('f5', self.do_screenshot)
self.accept('r', self.do_reset)
# Vehicle controls
inputState.watchWithModifiers('forward', 'w')
inputState.watchWithModifiers('turnLeft', 'a')
inputState.watchWithModifiers('reverse', 's')
inputState.watchWithModifiers('turnRight', 'd')
inputState.watchWithModifiers('forward', 'arrow_up')
inputState.watchWithModifiers('turnLeft', 'arrow_left')
inputState.watchWithModifiers('reverse', 'arrow_down')
inputState.watchWithModifiers('turnRight', 'arrow_right')
self.accept('space', self.reset_vehicle)
# Controls to do with the terrain
#self.accept('t', self.rise_in_front)
self.accept('t', self.deform_terrain, ["raise"])
self.accept('g', self.deform_terrain, ["depress"])
self.accept('b', self.drop_boxes)
# Some debugging and miscellaneous controls
self.accept('e', self.query_elevation)
self.accept('c', self.convert_coordinates)
self.accept('p', self.save)
self.accept('h', self.hide_terrain)
# Task
taskMgr.add(self.update, 'updateWorld')
self.setup()
"""
Macro-like function used to reduce the amount to code needed to create the
on screen instructions
"""
def genLabelText(self, i, text, parent="a2dTopLeft"):
return OnscreenText(text=text, parent=getattr(base, parent), scale=.05,
pos=(0.06, -.065 * i), fg=(1, 1, 1, 1),
align=TextNode.ALeft)
# _____HANDLER_____
def cleanup(self):
self.world = None
self.worldNP.remove_node()
self.terrain.remove_node()
self.skybox.remove_node()
del self.terrain_node
def do_exit(self):
self.cleanup()
sys.exit(1)
def do_reset(self):
self.cleanup()
self.setup()
def toggle_debug(self):
if self.debugNP.is_hidden():
self.debugNP.show()
else:
self.debugNP.hide()
def do_screenshot(self):
base.screenshot('HeightfieldVehicle')
# ____TASK___
def update(self, task):
# Get the time passed since the last frame
dt = globalClock.get_dt()
# Pass dt as parameter (we need it for sensible steering calculations)
self.process_input(dt)
"""
Basically, we want to put our camera where the camera floater is. We
need the floater's world (=render-relative) position (it's parented to
the vehicle)
"""
floater_pos = render.get_relative_point(self.camera_floater,
LVector3(0))
"""
If the camera floater is under the terrain surface, adjust it, so that
it stays above the terrain.
"""
elevation_at_floater_pos = self.query_elevation(floater_pos)
if elevation_at_floater_pos.z >= floater_pos.z:
floater_pos.z = elevation_at_floater_pos.z + 1.
# Now we set our camera's position and make it look at the vehicle.
base.cam.set_pos(floater_pos)
base.cam.look_at(self.vehicleNP)
# Let the Bullet library do physics calculations.
self.world.do_physics(dt, 10, 0.008)
return task.cont
def process_input(self, dt):
# Relax steering towards straight
self.steering *= 1 - self.steering_relax_factor * dt
engine_force = 0.0
brake_force = 0.0
if inputState.isSet('forward'):
engine_force = 1000.0
brake_force = 0.0
if inputState.isSet('reverse'):
engine_force = 0.0
brake_force = 100.0
if inputState.isSet('turnLeft'):
self.steering += dt * self.steering_increment
self.steering = min(self.steering, self.steering_clamp)
if inputState.isSet('turnRight'):
self.steering -= dt * self.steering_increment
self.steering = max(self.steering, -self.steering_clamp)
# Lower steering intensity for high speeds
self.steering *= 1. - (self.vehicle.get_current_speed_km_hour() *
self.steering_speed_reduction_factor)
# Apply steering to front wheels
#self.vehicle.get_wheels()[0].set_steering(self.steering)
#self.vehicle.get_wheels()[1].set_steering(self.steering)
#self.vehicle.wheels[0].steering = self.steering
#self.vehicle.wheels[1].steering = self.steering
self.vehicle.set_steering_value(self.steering, 0)
self.vehicle.set_steering_value(self.steering, 1)
# Apply engine and brake to rear wheels
#self.vehicle.wheels[2].engine_force = engine_force
#self.vehicle.wheels[3].engine_force = engine_force
#self.vehicle.wheels[2].brake = brake_force
#self.vehicle.wheels[3].brake = brake_force
self.vehicle.apply_engine_force(engine_force, 2)
self.vehicle.apply_engine_force(engine_force, 3)
self.vehicle.set_brake(brake_force, 2)
self.vehicle.set_brake(brake_force, 3)
def setup(self):
# Bullet physics world
self.worldNP = render.attach_new_node('World')
self.debugNP = self.worldNP.attach_new_node(BulletDebugNode('Debug'))
self.world = BulletWorld()
self.world.set_gravity(LVector3(0, 0, -9.81))
self.world.set_debug_node(self.debugNP.node())
# Vehicle
# Steering info
self.steering = 0.0 # degrees
self.steering_clamp = 45.0 # degrees
self.steering_increment = 120.0 # degrees per second
# How fast steering relaxes to straight ahead
self.steering_relax_factor = 2.0
# How much steering intensity decreases with higher speeds
self.steering_speed_reduction_factor = 0.003
# Chassis collision box (note: Bullet uses half-measures)
shape = BulletBoxShape(LVector3(0.6, 1.4, 0.5))
ts = TransformState.make_pos(LPoint3(0, 0, 0.5))
self.vehicleNP = self.worldNP.attach_new_node(
BulletRigidBodyNode('Vehicle'))
self.vehicleNP.node().add_shape(shape, ts)
# Set initial position
self.vehicleNP.set_pos(0, 70, -10)
self.vehicleNP.node().set_mass(800.0)
self.vehicleNP.node().set_deactivation_enabled(False)
self.world.attach(self.vehicleNP.node())
# Camera floater
self.attach_camera_floater()
# BulletVehicle
self.vehicle = BulletVehicle(self.world, self.vehicleNP.node())
self.world.attach(self.vehicle)
# Vehicle model
self.yugoNP = loader.load_model('models/yugo/yugo.egg')
self.yugoNP.reparent_to(self.vehicleNP)
# Right front wheel
np = loader.load_model('models/yugo/yugotireR.egg')
np.reparent_to(self.worldNP)
self.add_wheel(LPoint3( 0.70, 1.05, 0.3), True, np)
# Left front wheel
np = loader.load_model('models/yugo/yugotireL.egg')
np.reparent_to(self.worldNP)
self.add_wheel(LPoint3(-0.70, 1.05, 0.3), True, np)
# Right rear wheel
np = loader.load_model('models/yugo/yugotireR.egg')
np.reparent_to(self.worldNP)
self.add_wheel(LPoint3( 0.70, -1.05, 0.3), False, np)
# Left rear wheel
np = loader.load_model('models/yugo/yugotireL.egg')
np.reparent_to(self.worldNP)
self.add_wheel(LPoint3(-0.70, -1.05, 0.3), False, np)
# Load a skybox
self.skybox = self.loader.load_model(
"samples/shader-terrain/models/skybox.bam")
self.skybox.reparent_to(self.render)
self.skybox.set_scale(20000)
skybox_texture = self.loader.load_texture(
"samples/shader-terrain/textures/skybox.jpg")
skybox_texture.set_minfilter(SamplerState.FT_linear)
skybox_texture.set_magfilter(SamplerState.FT_linear)
skybox_texture.set_wrap_u(SamplerState.WM_repeat)
skybox_texture.set_wrap_v(SamplerState.WM_mirror)
skybox_texture.set_anisotropic_degree(16)
self.skybox.set_texture(skybox_texture)
skybox_shader = Shader.load(Shader.SL_GLSL,
"samples/shader-terrain/skybox.vert.glsl",
"samples/shader-terrain/skybox.frag.glsl")
self.skybox.set_shader(skybox_shader)
# Terrain
self.setup_terrain()
def add_wheel(self, pos, front, np):
wheel = self.vehicle.create_wheel()
wheel.set_node(np.node())
wheel.set_chassis_connection_point_cs(pos)
wheel.set_front_wheel(front)
wheel.set_wheel_direction_cs(LVector3(0, 0, -1))
wheel.set_wheel_axle_cs(LVector3(1, 0, 0))
wheel.set_wheel_radius(0.25)
wheel.set_max_suspension_travel_cm(40.0)
wheel.set_suspension_stiffness(40.0)
wheel.set_wheels_damping_relaxation(2.3)
wheel.set_wheels_damping_compression(4.4)
wheel.set_friction_slip(100.0)
wheel.set_roll_influence(0.1)
def attach_camera_floater(self):
"""
Set up an auxiliary camera floater, which is parented to the vehicle.
Every frame base.cam's position will be set to the camera floater's.
"""
camera_behind = 8
camera_above = 3
self.camera_floater = NodePath("camera_floater")
self.camera_floater.reparent_to(self.vehicleNP)
self.camera_floater.set_y(-camera_behind)
self.camera_floater.set_z(camera_above)
def reset_vehicle(self):
reset_pos = self.vehicleNP.get_pos()
reset_pos.z += 3
self.vehicleNP.node().clear_forces()
self.vehicleNP.node().set_linear_velocity(LVector3(0))
self.vehicleNP.node().set_angular_velocity(LVector3(0))
self.vehicleNP.set_pos(reset_pos)
self.vehicleNP.set_hpr(LVector3(0))
def drop_boxes(self):
"""
Puts a stack of boxes at a distance in front of the vehicle.
The boxes will not necessarily spawn above the terrain and will not
be cleaned up.
"""
model = loader.load_model('models/box.egg')
model.set_pos(-0.5, -0.5, -0.5)
model.flatten_light()
shape = BulletBoxShape(LVector3(0.5, 0.5, 0.5))
ahead = self.vehicleNP.get_pos() + self.vehicle.get_forward_vector()*15
for i in range(6):
node = BulletRigidBodyNode('Box')
node.set_mass(5.0)
node.add_shape(shape)
node.set_deactivation_enabled(False)
np = render.attach_new_node(node)
np.set_pos(ahead.x, ahead.y, ahead.z + i*2)
self.world.attach(node)
model.copy_to(np)
def query_elevation(self, xy_pos=None):
"""
Query elevation for xy_pos if present, else for vehicle position.
No xy_pos means verbose mode.
"""
query_pos = xy_pos or self.vehicleNP.get_pos()
"""
This method is accurate and may be useful for placing
objects on the terrain surface.
"""
result = self.world.ray_test_closest(
LPoint3(query_pos.x, query_pos.y, -10000),
LPoint3(query_pos.x, query_pos.y, 10000))
if result.has_hit():
hit_pos = result.get_hit_pos()
if not xy_pos:
print("Bullet heightfield elevation at "
"X {:.2f} | Y {:.2f} is {:.3f}".format(
hit_pos.x, hit_pos.y, hit_pos.z))
else:
hit_pos = None
if not xy_pos:
print("Could not query elevation at {}".format(xy_pos))
"""
This method is less accurate than the one above.
Under heavy ray-testing stress (ray tests are performed for all vehicle
wheels, the above elevation query etc.) Bullet sometimes seems to be a
little unreliable.
"""
texspace_pos = self.terrain.get_relative_point(render, query_pos)
stm_pos = self.terrain_node.uv_to_world(
LTexCoord(texspace_pos.x, texspace_pos.y))
if not xy_pos:
print("ShaderTerrainMesh elevation at "
"X {:.2f} | Y {:.2f} is {:.3f}".format(
stm_pos.x, stm_pos.y, stm_pos.z))
return hit_pos or stm_pos
def setup_terrain(self):
"""
Terrain info
Units are meters, which is preferable when working with Bullet.
"""
self.terrain_scale = LVector3(512, 512, 100)
self.terrain_pos = LVector3(-256, -256, -70)
# sample values for a 4096 x 4096px heightmap.
#self.terrain_scale = LVector3(4096, 4096, 1000)
#self.terrain_pos = LVector3(-2048, -2048, -70)
"""
Diamond_subdivision is an alternating triangulation scheme and may
produce better results.
"""
use_diamond_subdivision = True
"""
Construct the terrain
Without scaling, any ShaderTerrainMesh is 1x1x1 units.
"""
self.terrain_node = ShaderTerrainMesh()
"""
Set a heightfield, the heightfield should be a 16-bit png and
have a quadratic size of a power of two.
"""
heightfield = Texture()
heightfield.read(self.heightfield_fn)
heightfield.set_keep_ram_image(True)
self.terrain_node.heightfield = heightfield
# Display characteristic values of the heightfield texture
#minpoint, maxpoint, avg = LPoint3(), LPoint3(), LPoint3()
#heightfield.calc_min_max(minpoint, maxpoint)
#heightfield.calc_average_point(avg, 0.5, 0.5, 0.5)
#print("avg: {} min: {} max: {}".format(avg.x, minpoint.x, maxpoint.x))
"""
Set the target triangle width. For a value of 10.0 for example,
the ShaderTerrainMesh will attempt to make every triangle 10 pixels
wide on screen.
"""
self.terrain_node.target_triangle_width = 10.0
if use_diamond_subdivision:
"""
This has to be specified before calling .generate()
The default is false.
"""
load_prc_file_data("", "stm-use-hexagonal-layout true")
self.terrain_node.generate()
"""
Attach the terrain to the main scene and set its scale. With no scale
set, the terrain ranges from (0, 0, 0) to (1, 1, 1)
"""
self.terrain = self.render.attach_new_node(self.terrain_node)
self.terrain.set_scale(self.terrain_scale)
self.terrain.set_pos(self.terrain_pos)
"""
Set a vertex and a fragment shader on the terrain. The
ShaderTerrainMesh only works with an applied shader.
"""
terrain_shader = Shader.load(Shader.SL_GLSL,
"samples/shader-terrain/terrain.vert.glsl",
"samples/shader-terrain/terrain.frag.glsl")
self.terrain.set_shader(terrain_shader)
self.terrain.set_shader_input("camera", base.camera)
# Set some texture on the terrain
grass_tex = self.loader.load_texture(
"samples/shader-terrain/textures/grass.png")
grass_tex.set_minfilter(SamplerState.FT_linear_mipmap_linear)
grass_tex.set_anisotropic_degree(16)
self.terrain.set_texture(grass_tex)
"""
Set up the DynamicHeightfield (it's a type of PfmFile). We load the
same heightfield image as with ShaderTerrainMesh.
"""
self.DHF = DynamicHeightfield()
self.DHF.read(self.heightfield_fn)
"""
Set up empty PfmFiles to prepare stuff in that is going to
dynamically modify our terrain.
"""
self.StagingPFM = PfmFile()
self.RotorPFM = PfmFile()
"""
Set up the BulletHeightfieldShape (=collision terrain) and give it
some sensible physical properties.
"""
self.HFS = BulletHeightfieldShape(self.DHF, self.terrain_scale.z,
STM=True)
if use_diamond_subdivision:
self.HFS.set_use_diamond_subdivision(True)
HFS_rigidbody = BulletRigidBodyNode("BulletTerrain")
HFS_rigidbody.set_static(True)
friction = 2.0
HFS_rigidbody.set_anisotropic_friction(
LVector3(friction, friction, friction/1.3))
HFS_rigidbody.set_restitution(0.3)
HFS_rigidbody.add_shape(self.HFS)
self.world.attach(HFS_rigidbody)
HFS_NP = NodePath(HFS_rigidbody)
HFS_NP.reparent_to(self.worldNP)
"""
This aligns the Bullet terrain with the ShaderTerrainMesh rendered
terrain. It will be exact as long as the terrain vertex shader from
the STM sample is used and no additional tessellation shader.
For Bullet (as for other physics engines) the origin of objects is at
the center.
"""
HFS_NP.set_pos(self.terrain_pos + self.terrain_scale/2)
HFS_NP.set_sx(self.terrain_scale.x / heightfield.get_x_size())
HFS_NP.set_sy(self.terrain_scale.y / heightfield.get_y_size())
# Disables Bullet debug rendering for the terrain, because it is slow.
#HFS_NP.node().set_debug_enabled(False)
"""
Finally, link the ShaderTerrainMesh and the BulletHeightfieldShape to
the DynamicHeightfield. From now on changes to the DynamicHeightfield
will propagate to the (visible) ShaderTerrainMesh and the (collidable)
BulletHeightfieldShape.
"""
self.HFS.set_dynamic_heightfield(self.DHF)
self.terrain_node.set_dynamic_heightfield(self.DHF)
def deform_terrain(self, mode="raise", duration=1.0):
self.deform_duration = duration
"""
Calculate distance to the spot at which we want to raise the terrain.
At its current speed the vehicle would reach it in 2.5 seconds.
[km/h] / 3.6 = [m/s] * [s] = [m]
"""
distance = self.vehicle.get_current_speed_km_hour() / 3.6 * 2.5
spot_pos_world = (self.vehicleNP.get_pos() +
self.vehicle.get_forward_vector() * distance)
spot_pos_heightfield = self.terrain_node.world_to_heightfield(
spot_pos_world)
xcenter = spot_pos_heightfield.x
ycenter = spot_pos_heightfield.y
"""
To create a smooth hill/depression we call PfmFile.pull_spot to create
a sort of gradient. You can use self.cardmaker_debug to view it.
From the Panda3D API documentation of PfmFile.pull_spot:
Applies delta * t to the point values within radius (xr, yr)
distance of (xc, yc). The t value is scaled from 1.0 at the center
to 0.0 at radius (xr, yr), and this scale follows the specified
exponent. Returns the number of points affected.
"""
# Delta to apply to the point values in DynamicHeightfield array.
delta = LVector4(0.001)
# Make the raised spot elliptical.
xradius = 10.0 # meters
yradius = 6.0 # meters
# Choose an exponent
exponent = 0.6
# Counter-clockwise angle between Y-axis
angle = self.vehicle.get_forward_vector().signed_angle_deg(
LVector3.forward(), LVector3.down())
# Define all we need to repeatedly deform the terrain using a task.
self.spot_params = [delta, xcenter, ycenter, xradius, yradius,
exponent, mode]
# Clear staging area to a size that fits our raised region.
self.StagingPFM.clear(int(xradius)*2, int(yradius)*2, num_channels=1)
"""
There are two options:
(1) Rotate our hill/depression to be perpendicular
to the vehicle's trajectory. This is the default.
(2) Just put it in the terrain unrotated.
"""
# Option (1)
self.StagingPFM.pull_spot(delta,
xradius-0.5, yradius-0.5,
xradius, yradius,
exponent)
# Rotate wider side so it's perpendicular to vehicle's trajectory.
self.RotorPFM.rotate_from(self.StagingPFM, angle)
self.raise_start_time = globalClock.get_real_time()
taskMgr.do_method_later(0.03, self.deform_perpendicular,
"DeformPerpendicularSpot")
# Option (2)
#taskMgr.do_method_later(0.03, self.deform_regular, "RaiseASpot")
def deform_perpendicular(self, task):
if (globalClock.get_real_time() - self.raise_start_time <
self.deform_duration):
(delta, xcenter, ycenter,
xradius, yradius, exponent, mode) = self.spot_params
"""
Copy rotated hill to our DynamicHeightfield.
The values from RotorPFM are added to the ones found in the
DynamicHeightfield.
"""
self.DHF.add_sub_image(self.RotorPFM,
int(xcenter - self.RotorPFM.get_x_size()/2),
int(ycenter - self.RotorPFM.get_y_size()/2),
0, 0, self.RotorPFM.get_x_size(), self.RotorPFM.get_y_size(),
1.0 if mode == "raise" else -1.0)
# Output images of our PfmFiles.
#self.RotorPFM.write("dbg_RotorPFM.png")
#self.StagingPFM.write("dbg_StagingPFM.png")
return task.again
self.cardmaker_debug()
return task.done
def deform_regular(self, task):
if (globalClock.get_real_time() - self.raise_start_time <
self.deform_duration):
(delta, xcenter, ycenter,
xradius, yradius, exponent, mode) = self.spot_params
self.DHF.pull_spot(delta * (1.0 if mode == "raise" else -1.0),
xcenter, ycenter, xradius, yradius, exponent)
return task.again
return task.done
def convert_coordinates(self):
vpos = self.vehicleNP.get_pos()
print("VPOS world: ", vpos)
W2H = self.terrain_node.world_to_heightfield(vpos)
print("W2H: ", W2H)
H2W = self.terrain_node.heightfield_to_world(LTexCoord(W2H.x, W2H.y))
print("H2W: ", H2W)
W2U = self.terrain_node.world_to_uv(vpos)
print("W2U: ", W2U)
U2W = self.terrain_node.uv_to_world(LTexCoord(W2U.x, W2U.y))
print("U2W: ", U2W)
def hide_terrain(self):
if self.terrain.is_hidden():
self.terrain.show()
else:
self.terrain.hide()
def save(self):
self.DHF.write("dbg_dynamicheightfield.png")
def pfmvizzer_debug(self, pfm):
vizzer = PfmVizzer(pfm)
"""
To align the mesh we generate with PfmVizzer with our
ShaderTerrainMesh, BulletHeightfieldShape, and DynamicHeightfield, we
need to set a negative scale on the Y axis. This reverses the winding
order of the triangles in the mesh, which is why we choose
PfmVizzer.MF_back
Note that this does not accurately match up with our mesh because the
interpolation differs. Still, PfmVizzer can be useful when
inspecting, distorting, etc. PfmFiles.
"""
self.vizNP = vizzer.generate_vis_mesh(PfmVizzer.MF_back)
self.vizNP.set_texture(loader.load_texture("maps/grid.rgb"))
self.vizNP.reparent_to(render)
if pfm == self.DHF or pfm == self.terrain_node.heightfield:
self.vizNP.set_pos(self.terrain_pos.x, -self.terrain_pos.y,
self.terrain_pos.z)
self.vizNP.set_scale(self.terrain_scale.x, -self.terrain_scale.y,
self.terrain_scale.z)
def cardmaker_debug(self):
for node in render2d.find_all_matches("pfm"):
node.remove_node()
for text in base.a2dBottomLeft.find_all_matches("*"):
text.remove_node()
width = 0.2 # render2d coordinates range: [-1..1]
# Pseudo-normalize our PfmFile for better contrast.
normalized_pfm = PfmFile(self.RotorPFM)
max_p = LVector3()
normalized_pfm.calc_min_max(LVector3(), max_p)
normalized_pfm *= 1.0 / max_p.x
# Put it in a texture
tex = Texture()
tex.load(normalized_pfm)
# Apply the texture to a quad and put it in the lower left corner.
cm = CardMaker("pfm")
cm.set_frame(0, width, 0,
width / normalized_pfm.get_x_size() * normalized_pfm.get_y_size())
card = base.render2d.attach_new_node(cm.generate())
card.set_pos(-1, 0, -1)
card.set_texture(tex)
# Display max value text
self.genLabelText(-3,
"Max value: {:.3f} == {:.2f}m".format(max_p.x,
max_p.x * self.terrain_scale.z),
parent="a2dBottomLeft")
class CarPhys(PhysColleague):
def __init__(self, mediator, car_props, tuning, players):
PhysColleague.__init__(self, mediator)
self.pnode = self.vehicle = self.__track_phys = self.coll_mesh = \
self.max_speed = self.friction_slip = \
self.friction_slip_rear = self.cfg = None
self.turbo = False
self._tuning = tuning
self._players = players
self.roll_influence = []
self.ai_meshes = []
self.curr_speed_mul = 1.0
self.roll_influence_k = self.friction_slip_k = 1.0
self.__prev_speed = 0
self.__last_drift_time = 0
self.__finds = {} # cache for find's results
self.__whl2flytime = {}
self.cprops = car_props
self._load_phys()
self.__set_collision_mesh()
self.__set_ai_meshes()
self.__set_phys_node()
self.__set_vehicle()
self.__set_wheels()
self.eng.attach_obs(self.on_end_frame)
def _load_phys(self):
ppath = self.cprops.race_props.season_props.gameprops.phys_path
fpath = ppath % self.cprops.name
with open(fpath) as phys_file:
self.cfg = load(phys_file)
# they may be changed by drivers and tuning
self.cfg['max_speed'] = self.get_speed()
self.cfg['friction_slip'] = self.get_friction_static()[0]
self.cfg['friction_slip_rear'] = self.get_friction_static()[1]
self.cfg['roll_influence'] = self.get_roll_influence_static()
self.friction_slip = self.cfg['friction_slip']
self.friction_slip_rear = self.cfg['friction_slip_rear']
self.__log_props()
set_a = lambda field: setattr(self, field, self.cfg[field])
list(map(set_a, self.cfg.keys()))
def __log_props(self, starting=True):
s_s = self.cfg['max_speed'] if starting else self.max_speed
s_f = self.cfg['friction_slip'] if starting else \
self.get_friction_static()[0]
s_fr = self.cfg['friction_slip_rear'] if starting else \
self.get_friction_static()[1]
s_r = self.cfg['roll_influence'] if starting else \
self.get_roll_influence_static()
log_info = [('speed', self.cprops.name, round(s_s, 2),
self.cprops.driver_engine),
('friction 0', self.cprops.name, round(s_f[0], 2),
self.cprops.driver_tires),
('friction 1', self.cprops.name, round(s_f[1], 2),
self.cprops.driver_tires),
('friction_rear 0', self.cprops.name, round(s_fr[0], 2),
self.cprops.driver_tires),
('friction_rear 1', self.cprops.name, round(s_fr[1], 2),
self.cprops.driver_tires),
('roll min', self.cprops.name, round(s_r[0], 2),
self.cprops.driver_suspensions),
('roll max', self.cprops.name, round(s_r[1], 2),
self.cprops.driver_suspensions)]
for l_i in log_info:
info('%s %s: %s (%s)' % l_i)
def __set_collision_mesh(self):
fpath = self.cprops.race_props.coll_path % self.cprops.name
try:
self.coll_mesh = self.eng.load_model(fpath)
except OSError: # new cars don't have collision meshes
self.coll_mesh = self.eng.load_model(
fpath.replace('capsule', 'car'))
# chassis_shape = BulletConvexHullShape()
# for geom in self.eng.lib.find_geoms(
# self.coll_mesh, self.cprops.race_props.coll_name):
# chassis_shape.add_geom(geom.node().get_geom(0),
# geom.get_transform())
# self.mediator.gfx.nodepath.get_node().add_shape(chassis_shape)
chassis_shape = BulletBoxShape(tuple(self.cfg['box_size']))
boxpos = self.cfg['box_pos']
boxpos[2] += self.cfg['center_mass_offset']
pos = TransformState.makePos(tuple(boxpos))
self.mediator.gfx.nodepath.p3dnode.add_shape(chassis_shape, pos)
car_names = [player.car for player in self._players]
car_idx = car_names.index(self.cprops.name)
car_bit = BitMask32.bit(BitMasks.car(car_idx))
ghost_bit = BitMask32.bit(BitMasks.ghost)
track_bit = BitMask32.bit(BitMasks.track_merged)
mask = car_bit | ghost_bit | track_bit
self.mediator.gfx.nodepath.set_collide_mask(mask)
def __set_ai_meshes(self):
return
# if we attach these meshes (or even only one mesh, box, sphere,
# whatever) then the collision between the goal and the vehicle doesn't
# work properly
h = .5
boxsz = self.cfg['box_size']
hs = []
hs += [
h / 2 + boxsz[2] * 2 + self.cfg['box_pos'][2] +
self.cfg['center_mass_offset']
]
hs += [
-h / 2 - boxsz[2] * 2 + self.cfg['box_pos'][2] +
self.cfg['center_mass_offset']
]
for _h in hs:
shape = BulletBoxShape((boxsz[0], boxsz[1], h))
ghost = GhostNode('Vehicle')
pos = TransformState.makePos((0, 0, _h))
ghost.node.addShape(shape, pos)
self.ai_meshes += [self.eng.attach_node(ghost.node)]
car_names = self.cprops.race_props.season_props.car_names
car_idx = car_names.index(self.cprops.name)
car_bit = BitMask32.bit(BitMasks.car(car_idx))
ghost_bit = BitMask32.bit(BitMasks.ghost)
mask = car_bit | ghost_bit
self.ai_meshes[-1].set_collide_mask(mask)
self.eng.phys_mgr.attach_ghost(ghost.node)
def __set_phys_node(self):
self.pnode = self.mediator.gfx.nodepath.p3dnode
self.pnode.set_mass(self.mass) # default 0
self.pnode.set_deactivation_enabled(False)
self.eng.phys_mgr.attach_rigid_body(self.pnode)
self.eng.phys_mgr.add_collision_obj(self.pnode)
def __set_vehicle(self):
self.vehicle = BulletVehicle(self.eng.phys_mgr.root._wld, self.pnode)
# access to a protected member
self.vehicle.set_coordinate_system(ZUp)
self.vehicle.set_pitch_control(self.pitch_control)
tuning = self.vehicle.get_tuning()
tuning.set_suspension_compression(self.suspension_compression)
# default .83
tuning.set_suspension_damping(self.suspension_damping)
# default .88
self.eng.phys_mgr.attach_vehicle(self.vehicle)
def __set_wheels(self):
wheels = self.mediator.gfx.wheels
f_bounds = wheels['fr'].tight_bounds
f_radius = (f_bounds[1][2] - f_bounds[0][2]) / 2.0 + .01
r_bounds = wheels['rr'].tight_bounds
r_radius = (r_bounds[1][2] - r_bounds[0][2]) / 2.0 + .01
wheel_names = self.cprops.race_props.wheel_names
ffr = self.coll_mesh.find('**/' + wheel_names.frontrear.fr)
ffl = self.coll_mesh.find('**/' + wheel_names.frontrear.fl)
rrr = self.coll_mesh.find('**/' + wheel_names.frontrear.rr)
rrl = self.coll_mesh.find('**/' + wheel_names.frontrear.rl)
meth = self.coll_mesh.find
fr_node = ffr if ffr else meth('**/' + wheel_names.both.fr)
fl_node = ffl if ffl else meth('**/' + wheel_names.both.fl)
rr_node = rrr if rrr else meth('**/' + wheel_names.both.rr)
rl_node = rrl if rrl else meth('**/' + wheel_names.both.rl)
if not fr_node: # new cars
fr_node = meth('**/w_fr')
fl_node = meth('**/w_fl')
rr_node = meth('**/w_rr')
rl_node = meth('**/w_rl')
offset = self.cfg['center_mass_offset']
fr_pos = fr_node.get_pos() + (0, 0, f_radius + offset)
fl_pos = fl_node.get_pos() + (0, 0, f_radius + offset)
rr_pos = rr_node.get_pos() + (0, 0, r_radius + offset)
rl_pos = rl_node.get_pos() + (0, 0, r_radius + offset)
wheels_info = [(fr_pos, True, wheels['fr'], f_radius),
(fl_pos, True, wheels['fl'], f_radius),
(rr_pos, False, wheels['rr'], r_radius),
(rl_pos, False, wheels['rl'], r_radius)]
for i, (pos, front, nodepath, radius) in enumerate(wheels_info):
self.__add_wheel(pos, front, nodepath.p3dnode, radius, i)
def __add_wheel(self, pos, is_front, node, radius, i):
whl = self.vehicle.create_wheel()
whl.set_node(node)
whl.set_chassis_connection_point_cs(LPoint3f(*pos))
whl.set_front_wheel(is_front)
whl.set_wheel_direction_cs((0, 0, -1))
whl.set_wheel_axle_cs((1, 0, 0))
whl.set_wheel_radius(radius)
whl.set_suspension_stiffness(self.suspension_stiffness[0])
# default 5.88
whl.set_wheels_damping_relaxation(self.wheels_damping_relaxation[0])
# default .88
whl.set_wheels_damping_compression(self.wheels_damping_compression[0])
# default .83
idx = 0 if is_front else 1
whl.set_friction_slip(self.get_friction_static()[idx][0])
# default 10.5
# friction slip high -> more adherence
whl.set_roll_influence(self.roll_influence[0])
# low -> more stability # default .1
whl.set_max_suspension_force(self.max_suspension_force)
# default 6000
whl.set_max_suspension_travel_cm(self.max_suspension_travel_cm)
# default 500
whl.set_skid_info(self.skid_info) # default 0
self.__whl2flytime[i] = 0
@property
def lateral_force(self):
vel = self.vehicle.get_chassis().get_linear_velocity()
rot_mat = Mat4()
rot_mat.setRotateMat(-90, (0, 0, 1))
car_lat = rot_mat.xformVec(self.mediator.logic.car_vec._vec)
# access to a protected member
proj_frc = vel.project(car_lat)
return proj_frc.length()
@property
def lin_vel(self):
return self.vehicle.get_chassis().get_linear_velocity().length() * 3.6
@property
def is_flying(self): # no need to be cached
rays = [whl.get_raycast_info() for whl in self.vehicle.get_wheels()]
return not any(ray.is_in_contact() for ray in rays)
@property
def is_drifting(self):
return self.lateral_force > 4.0
@property
def last_drift_time(self):
return self.__last_drift_time
@property
def prev_speed(self):
return self.__prev_speed
@property
def prev_speed_ratio(self):
return max(0, min(1.0, self.prev_speed / self.max_speed))
def on_end_frame(self):
self.__prev_speed = self.speed
@property
def speed(self):
if self.mediator.fsm.getCurrentOrNextState() == 'Countdown':
return 0 # getCurrentSpeedKmHour returns odd values otherwise
return self.vehicle.get_current_speed_km_hour()
@property
def speed_ratio(self):
return max(0, min(1.0, self.speed / self.max_speed))
@property
def lin_vel_ratio(self):
return max(0, min(1.0, self.lin_vel / self.max_speed))
def set_forces(self, eng_frc, brake_frc, brk_ratio, steering):
idx = 1 if self.mediator.logic.is_drifting else 0
eng_frc_ratio = self.engine_acc_frc_ratio[idx]
self.vehicle.set_steering_value(steering, 0)
self.vehicle.set_steering_value(steering, 1)
self.vehicle.apply_engine_force(eng_frc * eng_frc_ratio, 0)
self.vehicle.apply_engine_force(eng_frc * eng_frc_ratio, 1)
self.vehicle.apply_engine_force(eng_frc * (1 - eng_frc_ratio), 2)
self.vehicle.apply_engine_force(eng_frc * (1 - eng_frc_ratio), 3)
self.vehicle.set_brake((1 - brk_ratio) * brake_frc, 2)
self.vehicle.set_brake((1 - brk_ratio) * brake_frc, 3)
self.vehicle.set_brake(brk_ratio * brake_frc, 0)
self.vehicle.set_brake(brk_ratio * brake_frc, 1)
def update_car_props(self):
wheels = zip(self.vehicle.get_wheels(), range(4))
speeds = list(map(lambda whi: self.__update_whl_props(*whi), wheels))
speeds = [speed for speed in speeds if speed]
if self.is_drifting:
self.__last_drift_time = self.eng.curr_time
self.curr_speed_mul = (sum(speeds) / len(speeds)) if speeds else 1.0
def __update_whl_props(self, whl, i):
susp_min = self.suspension_stiffness[0]
susp_max = self.suspension_stiffness[1]
susp_diff = susp_max - susp_min
whl.set_suspension_stiffness(susp_min + self.speed_ratio * susp_diff)
relax_min = self.wheels_damping_relaxation[0]
relax_max = self.wheels_damping_relaxation[1]
relax_diff = relax_max - relax_min
relax = relax_min + self.speed_ratio * relax_diff
whl.set_wheels_damping_relaxation(relax)
compr_min = self.wheels_damping_compression[0]
compr_max = self.wheels_damping_compression[1]
compr_diff = compr_max - compr_min
compr = compr_min + self.speed_ratio * compr_diff
whl.set_wheels_damping_compression(compr)
roll_infl_min = self.roll_influence[0]
roll_infl_max = self.roll_influence[1]
roll_infl_diff = roll_infl_max - roll_infl_min
roll_infl = roll_infl_min + self.speed_ratio * roll_infl_diff
whl.set_roll_influence(self.roll_influence_k * roll_infl)
contact_pt = whl.get_raycast_info().getContactPointWs()
gnd_name = self.gnd_name(contact_pt)
if not gnd_name or gnd_name in ['Vehicle', 'Wall', 'Respawn']:
return
if gnd_name not in self.__finds:
gnd = self.cprops.race.track.phys.model.find('**/' + gnd_name)
self.__finds[gnd_name] = gnd
gfx_node = self.__finds[gnd_name]
if not gfx_node:
print('ground error', gnd_name)
return
fric = 1.0
if gfx_node.has_tag('friction'):
fric = float(gfx_node.get_tag('friction'))
if not whl.get_raycast_info().is_in_contact():
self.__whl2flytime[i] = self.eng.curr_time
gnd_time = self.eng.curr_time - self.__whl2flytime[i]
gnd_recovery_time = .2 if whl.is_front_wheel() else .1
gnd_factor = min(1, gnd_time / gnd_recovery_time)
idx = 0 if whl.is_front_wheel() else 1
turbo_factor = 1.24 if self.turbo else 1.0
whl.setFrictionSlip(self.get_friction()[idx] * fric * gnd_factor *
turbo_factor)
if gfx_node.has_tag('speed'):
return float(gfx_node.get_tag('speed'))
@property
def gnd_names(self): # no need to be cached
whls = self.vehicle.get_wheels()
pos = list(
map(lambda whl: whl.get_raycast_info().get_contact_point_ws(),
whls))
return list(map(self.gnd_name, pos))
@staticmethod
def gnd_name(pos):
top, bottom = pos + (0, 0, 20), pos + (0, 0, -20)
result = CarPhys.eng.phys_mgr.ray_test_closest(bottom, top)
ground = result.get_node()
return ground.get_name() if ground else ''
@staticmethod
def gnd_height(pos): # this should be a method of the track
top, bottom = pos + (0, 0, 20), pos + (0, 0, -20)
result = CarPhys.eng.phys_mgr.ray_test_closest(bottom, top)
hit_pos = result.get_hit_pos()
return hit_pos.z if hit_pos else None
def apply_damage(self, reset=False):
# wheels = self.vehicle.get_wheels()
if reset:
self.max_speed = self.get_speed()
self.friction_slip_k = 1.0
self.roll_influence_k = 1.0
else:
self.max_speed *= .95
self.friction_slip_k *= .95
self.roll_influence_k *= 1.05
# map(lambda whl: whl.set_friction_slip(self.friction_slip), wheels)
self.__log_props(False)
def get_speed(self):
return self.cfg['max_speed'] * (1 + .01 * self.cprops.driver_engine)
def get_friction(self):
k = (1 + .01 * self.cprops.driver_tires)
return self.friction_slip[0] * k, self.friction_slip_rear[0] * k
def get_roll_influence_static(self):
min_r = self.cfg['roll_influence'][0]
max_r = self.cfg['roll_influence'][1]
k = 1 + .01 * self.cprops.driver_suspensions
return [min_r * k, max_r * k]
def get_friction_static(self):
k = 1 + .01 * self.cprops.driver_tires
fstr = 'friction_slip'
return [(self.cfg[fstr][0] * k, self.cfg[fstr][1] * k),
(self.cfg[fstr + '_rear'][0] * k,
self.cfg[fstr + '_rear'][1] * k)]
def get_roll_influence(self):
min_r = self.cfg['roll_influence'][0]
max_r = self.cfg['roll_influence'][1]
diff_r = max_r - min_r
curr_r = min_r + self.speed_ratio * diff_r
return curr_r * (1 + .01 * self.cprops.driver_suspensions)
def rotate(self):
self.pnode.apply_torque((0, 0, 80000))
self.mediator.logic.applied_torque = True
def destroy(self):
self.eng.detach_obs(self.on_end_frame)
self.eng.phys_mgr.remove_vehicle(self.vehicle)
self.pnode = self.vehicle = self.__finds = self.__track_phys = \
self.coll_mesh = None
PhysColleague.destroy(self)
