def __occlusion_mesh(self, pos):
tgt = self.car.gfx.nodepath.get_pos()
occl = self.__closest_occl(pos, tgt)
if not occl:
return None
car_vec = self.car.logic.car_vec
rot_mat_left = Mat4()
rot_mat_left.setRotateMat(90, (0, 0, 1))
car_vec_left = rot_mat_left.xformVec(car_vec._vec)
# access to a protected member
tgt_left = tgt + car_vec_left
pos_left = pos + car_vec_left
occl_left = self.__closest_occl(pos_left, tgt_left)
if not occl_left:
return None
rot_mat_right = Mat4()
rot_mat_right.setRotateMat(-90, (0, 0, 1))
car_vec_right = rot_mat_right.xformVec(car_vec._vec)
# access to a protected member
car_vec_right += (0, 0, 2)
tgt_right = tgt + car_vec_right
pos_right = pos + car_vec_right
phys_root = self.eng.phys_mgr.root
occl_right = phys_root.ray_test_closest(tgt_right, pos_right)
occl_right = self.__closest_occl(pos_right, tgt_right)
if not occl_right:
return None
return occl
def update(self, pb_camera):
self.set_mat(self.Z2Y * Mat4(*pb_camera.pose_mat))
mat = np.asarray(pb_camera.proj_mat).reshape(4, 4)
m22, m32 = -mat[2, 2], -mat[3, 2]
zfar = (2.0 * m32) / (2.0 * m22 - 2.0)
znear = ((m22 - 1.0) * zfar) / (m22 + 1.0)
self._lens.set_near_far(znear, zfar)
self._lens.set_user_mat(self.Z2Y * Mat4(*pb_camera.proj_mat))
def rotsToMat4(x, y, z):
rotx = Mat4(1, 0, 0, 0, 0, cos(x), -sin(x), 0, 0, sin(x), cos(x), 0, 0, 0,
0, 1)
roty = Mat4(cos(y), 0, sin(y), 0, 0, 1, 0, 0, -sin(y), 0, cos(y), 0, 0, 0,
0, 1)
rotz = Mat4(cos(z), -sin(z), 0, 0, sin(z), cos(z), 0, 0, 0, 0, 1, 0, 0, 0,
0, 1)
swapyz = Mat4.rotateMat(90, Vec3(-1, 0, 0))
return rotx * roty * rotz * swapyz
def __init__(self, viewedmatrix, relativematrix):
from panda3d.core import Mat4, Mat3
self.viewedmatrix = viewedmatrix
assert relativematrix is not None
self.relmat = Mat4(
relativematrix.get_proxy("NodePath").getMat().getUpper3())
self.relmatinv = Mat4(self.relmat)
self.relmatinv.invertInPlace()
self.relpos = relativematrix.get_proxy("NodePath").getPos()
def beginTransformation(self):
self.originalMat = Mat4(Mat4.identMat())
self.originalMat.setRow(3, self.path.getMat(render).getRow(3))
self.originalMatInv = Mat4()
self.originalMatInv.invertAffineFrom(self.originalMat)
for i in xrange(len(self.clients)):
print 'Their matrix * My matrix'
print self.clients[i][0].getMat(self.path) * self.path.getMat()
print 'Total matrix:'
print self.clients[i][0].getMat()
#self.clients[i][1] = self.clients[i][0].getMat(self.path)
self.clients[i][1] = (self.clients[i][0].getMat() *
self.originalMatInv)
def is_drifting(self):
car_vec = self.car_vec
rot_mat_left = Mat4()
rot_mat_left.setRotateMat(90, (0, 0, 1))
car_vec_left = rot_mat_left.xformVec(car_vec._vec)
# access to a protected member
rot_mat_right = Mat4()
rot_mat_right.setRotateMat(-90, (0, 0, 1))
car_vec_right = rot_mat_right.xformVec(car_vec._vec)
# access to a protected member
vel = self.mediator.phys.vehicle.get_chassis().get_linear_velocity()
vel.normalize()
car_dot_vel_l = car_vec_left.dot(vel)
car_dot_vel_r = car_vec_right.dot(vel)
car_dot_vel = max(car_dot_vel_l, car_dot_vel_r)
return car_dot_vel > .1
def drawLeaf(nodePath,
vdata,
pos=Vec3(0, 0, 0),
vecList=[Vec3(0, 0, 1),
Vec3(1, 0, 0),
Vec3(0, -1, 0)],
scale=0.125):
#use the vectors that describe the direction the branch grows to make the right
#rotation matrix
newCs = Mat4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
newCs.setRow(0, vecList[2]) #right
newCs.setRow(1, vecList[1]) #up
newCs.setRow(2, vecList[0]) #forward
newCs.setRow(3, Vec3(0, 0, 0))
newCs.setCol(3, Vec4(0, 0, 0, 1))
axisAdj = Mat4.scaleMat(scale) * newCs * Mat4.translateMat(pos)
#orginlly made the leaf out of geometry but that didnt look good
#I also think there should be a better way to handle the leaf texture other than
#hardcoding the filename
leafModel = loader.loadModel('models/shrubbery')
leafTexture = loader.loadTexture('models/material-10-cl.png')
leafModel.reparentTo(nodePath)
leafModel.setTexture(leafTexture, 1)
leafModel.setTransform(TransformState.makeMat(axisAdj))
def mousePressed(self, event):
self.parent.beginTransformation()
lens = base.cam.node().getLens()
scale = Mat4.scaleMat(self.path.getScale(base.camera))
descale = Mat4()
descale.invertAffineFrom(scale)
mvMat = descale * self.path.getMat(base.camera)
origin = Point3(mvMat.xformPoint(Point3()))
dir = Vec3(mvMat.xformVec(Vec3(0, 0, 1)))
xprod = dir.cross(origin)
planeNorm = xprod.cross(dir)
planeNorm.normalize()
d = planeNorm.dot(origin)
self.dir = dir
self.origin = origin
self.planeNorm = planeNorm
self.d = d
self.lens = lens
self.fromCam = base.camera.getMat(self.parent.path) * scale
transl = self.mouse2Vec(event.pos)
self.origin = transl + self.origin
def rotmat(theta, axis_1=0, axis_2=3):
m = np.eye(4)
m[axis_1, axis_1] = np.cos(theta)
m[axis_1, axis_2] = -np.sin(theta)
m[axis_2, axis_1] = np.sin(theta)
m[axis_2, axis_2] = np.cos(theta)
return Mat4(*m.flatten())
def recurseScene(curnode, scene_members, data_cache, M, texture_cache, col_inst=None):
M = numpy.dot(M, curnode.matrix)
for node in curnode.children:
if isinstance(node, collada.scene.Node):
recurseScene(node, scene_members, data_cache, M, texture_cache, col_inst=col_inst)
elif isinstance(node, collada.scene.GeometryNode) or isinstance(node, collada.scene.ControllerNode):
if isinstance(node, collada.scene.GeometryNode):
geom = node.geometry
else:
geom = node.controller.geometry
materialnodesbysymbol = {}
for mat in node.materials:
materialnodesbysymbol[mat.symbol] = mat
for prim in geom.primitives:
if len(prim) > 0:
mat = materialnodesbysymbol.get(prim.material)
matstate = None
if mat is not None:
matstate = data_cache['material2state'].get(mat.target)
if matstate is None:
matstate = getStateFromMaterial(mat.target, texture_cache, col_inst)
if geom.double_sided:
matstate = matstate.addAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullNone))
data_cache['material2state'][mat.target] = matstate
mat4 = Mat4(*M.T.flatten().tolist())
primgeom = data_cache['prim2geom'].get(prim)
if primgeom is None:
primgeom = getGeomFromPrim(prim, matstate)
data_cache['prim2geom'][prim] = primgeom
scene_members.append((primgeom, matstate, mat4))
class PbCameraNode(NodePath):
"""Pybullet-compatible camera node wrapper
"""
Z2Y = Mat4(1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1)
def __init__(self, render: NodePath):
self._camera = Camera('pb_camera')
self._lens = MatrixLens()
self._camera.set_lens(self._lens)
super().__init__(self._camera)
self.reparent_to(render)
def set_active(self, active: bool):
self._camera.set_active(active)
def is_active(self):
return self._camera.is_active()
def update(self, pb_camera):
self.set_mat(self.Z2Y * Mat4(*pb_camera.pose_mat))
mat = np.asarray(pb_camera.proj_mat).reshape(4, 4)
m22, m32 = -mat[2, 2], -mat[3, 2]
zfar = (2.0 * m32) / (2.0 * m22 - 2.0)
znear = ((m22 - 1.0) * zfar) / (m22 + 1.0)
self._lens.set_near_far(znear, zfar)
self._lens.set_user_mat(self.Z2Y * Mat4(*pb_camera.proj_mat))
def move_city(self, task):
# moves the city, using the transformation matrix
# first, get the current transformation matrix
# getTransform() returns a TransformState, which is a higher level
# abstraction of our matrix
# getMat() retrieves the inner matrix. the returned matrix is const
# though
oldmat = self.cityModel.getTransform().getMat()
# oldmat ist a const Mat4, we need one we can manipulate
newmat = Mat4(oldmat)
# the matrices in Panda3d are suitable for row-vector multiplication, that is
# vector * Matrix (same as opengl). the bottom row (3) is therefore the
# translation in xyzt order
#
# replace it with a different one, we want to move the value of
# time, which is the number of seconds passed since starting this task
newmat.setRow(3, Vec4(1 - task.time, 3, 0, 1))
# we need to create a new TransformState from the matrix, and set it
# to apply the transformation
self.cityModel.setTransform(TransformState.makeMat(newmat))
return Task.cont
def getMat4_scale_quad_for_texture_pixels_to_match_screen_resolution():
# a single unit takes an amount of pixels of the p3d window
# by convention here, the height of what the initial fixed camera
# displays is exactly 2, i.e. the distance d((0,0,-1), (0,0,1))
pixels_per_unit = get_pixels_per_unit()
return Mat4(1. / pixels_per_unit, 0, 0, 0, 0, 1, 0, 0, 0, 0,
1. / pixels_per_unit, 0, 0, 0, 0, 1)
def load(self):
self.root = NodePath('PartyCog-%d' % self.id)
self.root.reparentTo(self.parentNode)
path = 'phase_13/models/parties/cogPinata_'
self.actor = Actor(
path + 'actor', {
'idle': path + 'idle_anim',
'down': path + 'down_anim',
'up': path + 'up_anim',
'bodyHitBack': path + 'bodyHitBack_anim',
'bodyHitFront': path + 'bodyHitFront_anim',
'headHitBack': path + 'headHitBack_anim',
'headHitFront': path + 'headHitFront_anim'
})
self.actor.setBlend(
frameBlend=config.GetBool('interpolate-animations', True))
self.actor.reparentTo(self.root)
self.temp_transform = Mat4()
self.head_locator = self.actor.attachNewNode('temphead')
self.bodyColl = CollisionTube(0, 0, 1, 0, 0, 5.75, 0.75)
self.bodyColl.setTangible(1)
self.bodyCollNode = CollisionNode('PartyCog-%d-Body-Collision' %
self.id)
self.bodyCollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.bodyCollNode.addSolid(self.bodyColl)
self.bodyCollNodePath = self.root.attachNewNode(self.bodyCollNode)
self.headColl = CollisionTube(0, 0, 3, 0, 0, 3.0, 1.5)
self.headColl.setTangible(1)
self.headCollNode = CollisionNode('PartyCog-%d-Head-Collision' %
self.id)
self.headCollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.headCollNode.addSolid(self.headColl)
self.headCollNodePath = self.root.attachNewNode(self.headCollNode)
self.arm1Coll = CollisionSphere(1.65, 0, 3.95, 1.0)
self.arm1Coll.setTangible(1)
self.arm1CollNode = CollisionNode('PartyCog-%d-Arm1-Collision' %
self.id)
self.arm1CollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.arm1CollNode.addSolid(self.arm1Coll)
self.arm1CollNodePath = self.root.attachNewNode(self.arm1CollNode)
self.arm2Coll = CollisionSphere(-1.65, 0, 3.45, 1.0)
self.arm2Coll.setTangible(1)
self.arm2CollNode = CollisionNode('PartyCog-%d-Arm2-Collision' %
self.id)
self.arm2CollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.arm2CollNode.addSolid(self.arm2Coll)
self.arm2CollNodePath = self.root.attachNewNode(self.arm2CollNode)
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splatType = globalPropPool.getPropType(splatName)
self.pieHitSound = globalBattleSoundCache.getSound(
'AA_wholepie_only.ogg')
self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.ogg')
self.hole = loader.loadModel('phase_13/models/parties/cogPinataHole')
self.hole.setTransparency(True)
self.hole.setP(-90.0)
self.hole.setScale(3)
self.hole.setBin('ground', 3)
self.hole.reparentTo(self.parentNode)
def __init__(self):
""" Constructs a new Light, subclasses have to call this """
DebugObject.__init__(self, "AbstractLight")
ShaderStructElement.__init__(self)
self.debugNode = NodePath("LightDebug")
self.visualizationNumSteps = 32
self.dataNeedsUpdate = False
self.castShadows = False
self.debugEnabled = False
self.bounds = OmniBoundingVolume()
self.shadowSources = []
self.lightType = self.getLightType()
self.position = Vec3(0)
self.color = Vec3(1)
self.posterIndex = -1
self.radius = 10.0
self.typeName = ""
self.sourceIndexes = PTAInt.emptyArray(6)
self.attached = False
self.shadowResolution = 512
self.index = -1
self.iesProfile = -1
self.iesProfileName = None
self.mvp = Mat4()
# A light can have up to 6 sources
for i in range(6):
self.sourceIndexes[i] = -1
def check_mouse1drag(self):
"""
this function uses a collision sphere to track the rotational mouse motion
:return:
author: weiwei
date: 20200315
"""
curm1pos = self.get_world_mouse1()
if curm1pos is None:
if self.lastm1pos is not None:
self.lastm1pos = None
return
if self.lastm1pos is None:
# first time click
self.lastm1pos = curm1pos
return
curm1vec = Vec3(curm1pos - self.lookatpos_pdv3)
lastm1vec = Vec3(self.lastm1pos - self.lookatpos_pdv3)
curm1vec.normalize()
lastm1vec.normalize()
rotatevec = curm1vec.cross(lastm1vec)
if rotatevec.length() > 1e-9: # avoid zero length
rotateangle = curm1vec.signedAngleDeg(lastm1vec, rotatevec)
rotateangle = rotateangle * self.camdist * 5000
if rotateangle > .02 or rotateangle < -.02:
rotmat = Mat4(self.base.cam.getMat())
posvec = Vec3(self.base.cam.getPos())
rotmat.setRow(3, Vec3(0, 0, 0))
self.base.cam.setMat(rotmat *
Mat4.rotateMat(rotateangle, rotatevec))
self.base.cam.setPos(Mat3.rotateMat(rotateangle, rotatevec). \
xform(posvec - self.lookatpos_pdv3) + self.lookatpos_pdv3)
self.lastm1pos = self.get_world_mouse1()
self.update_trackplane()
def getMat4_scale_unit_quad_to_image_aspect_ratio_forrowvecs(
image_width_pixels, image_height_pixels):
# the height stays constant (height of 1 in world coords)
quad_scalex = float(image_width_pixels)
quad_scalez = float(image_height_pixels)
return Mat4(quad_scalex * 1., 0, 0, 0, 0, 1, 0, 0, 0, 0, quad_scalez * 1.,
0, 0, 0, 0, 1)
def stop_camera(self):
mat = Mat4(camera.getMat())
mat.invertInPlace()
base.mouseInterfaceNode.setMat(mat)
base.enableMouse()
self.taskMgr.remove("SpinCameraTaskX")
self.taskMgr.remove("SpinCameraTaskY")
def update_scene(self, scene_graph, materials_only):
"""Update a scene using scene_graph description
Arguments:
scene_graph {SceneGraph} -- scene description
materials_only {bool} -- update only shape materials
"""
for uid, pb_node in scene_graph.nodes.items():
node = NodePath(f'pb_node_{uid:03d}')
for pb_shape in pb_node.shapes:
filename = shape_filename(pb_shape)
if not filename:
continue
shape = self._loader.load_model(filename)
shape.set_mat(Mat4(*pb_shape.pose.matrix))
shape.reparent_to(node)
if shape.has_material:
shape.set_material(PbMaterial(pb_shape.material), 1)
texture_id = pb_shape.material.diffuse_texture
if texture_id > -1:
texture = scene_graph.texture(texture_id)
shape.set_texture(texture.filename)
node.flatten_light()
node.reparent_to(self.scene)
self._node_dict[uid] = node
def pandaMatrice(self,mat):
mat = mat.transpose().reshape((16,))
# print mat,len(mat),mat.shape
pMat = Mat4(mat[0],mat[1],mat[2],mat[3],
mat[4],mat[5],mat[6],mat[7],
mat[8],mat[9],mat[10],mat[11],
mat[12],mat[13],mat[14],mat[15],)
return pMat
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()
def makeInterior(self, roomIndex=None):
self.dnaStore = self.cr.playGame.dnaStore
self.generator = random.Random()
self.generator.seed(self.zoneId)
if roomIndex == None:
interior = self.randomDNAItem('TI_room', self.dnaStore.findNode)
else:
interior = self.dnaStore.findNode(
self.dnaStore.getCatalogCode('TI_room', roomIndex))
self.interior = interior.copyTo(render)
hoodId = ZoneUtil.getHoodId(self.zoneId, 1)
self.colors = ToonInteriorColors.colors[hoodId]
self.replaceRandomInModel(self.interior)
doorModelName = 'door_double_round_ul'
if doorModelName[-1:] == 'r':
doorModelName = doorModelName[:-1] + 'l'
else:
doorModelName = doorModelName[:-1] + 'r'
door = self.dnaStore.findNode(doorModelName)
door_origin = render.find('**/door_origin;+s')
doorNP = door.copyTo(door_origin)
door_origin.setScale(0.8, 0.8, 0.8)
door_origin.setPos(door_origin, 0, -0.025, 0)
color = self.generator.choice(self.colors['TI_door'])
DNADoor.setupDoor(doorNP, self.interior, door_origin, self.dnaStore,
self.block, color)
doorFrame = doorNP.find('door_*_flat')
doorFrame.wrtReparentTo(self.interior)
doorFrame.setColor(color)
sign = hidden.find('**/tb%s:*_landmark_*_DNARoot/**/sign;+s' %
(self.block, ))
if not sign.isEmpty():
signOrigin = self.interior.find('**/sign_origin;+s')
newSignNP = sign.copyTo(signOrigin)
newSignNP.setDepthWrite(1, 1)
inv = Mat4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
newSignNP.setMat(inv)
newSignNP.flattenLight()
ll = Point3()
ur = Point3()
newSignNP.calcTightBounds(ll, ur)
width = ur[0] - ll[0]
height = ur[2] - ll[2]
if width != 0 and height != 0:
xScale = (SIGN_RIGHT - SIGN_LEFT) / width
zScale = (SIGN_TOP - SIGN_BOTTOM) / height
scale = min(xScale, zScale)
xCenter = (ur[0] + ll[0]) / 2.0
zCenter = (ur[2] + ll[2]) / 2.0
newSignNP.setPosHprScale(
(SIGN_RIGHT + SIGN_LEFT) / 2.0 - xCenter * scale, -0.1,
(SIGN_TOP + SIGN_BOTTOM) / 2.0 - zCenter * scale, 0.0, 0.0,
0.0, scale, scale, scale)
del self.generator
del self.dnaStore
del self.colors
self.interior.flattenMedium()
return
def __init__(self, init_x, pbase=None):
self.x = np.array(init_x)
self.v_i = np.array([0] * 3)
self.a_i = np.array([0] * 3)
self.q = np.array([0, 1, 0, 0])
self.omega = np.array([0]*3)
self.omega_dot = np.array([0]*3)
self.time = None
# Explicit runge-kutta method of order (4)5 due to Dormand & Prince
self.integrator = ode(self.rhs_equation).set_integrator('dopri5')
self.pbase = pbase
# Create quadcopter node.
self.node_path = pbase.render.attachNewNode("Quadcopter")
self.node_path.setPos(*self.x)
self.q = np.array(self.node_path.getQuat())
# Configure front camera
fb_prop = FrameBufferProperties()
# Request 8 RGB bits, no alpha bits, and a depth buffer.
fb_prop.setRgbColor(True)
fb_prop.setRgbaBits(8, 8, 8, 0)
# fb_prop.setDepthBits(16)
self.front_buffer = self.pbase.win.makeTextureBuffer("front_buffer", 256, 256, to_ram=True, fbp=fb_prop)
self.front_camera = self.pbase.makeCamera(self.front_buffer)
self.front_camera.reparentTo(self.node_path)
# self.front_camera.setH(-90)
# Configure bottom camera
self.bottom_buffer = self.pbase.win.makeTextureBuffer("bottom_buffer", 256, 256)
self.bottom_camera = self.pbase.makeCamera(self.bottom_buffer)
self.bottom_camera.reparentTo(self.node_path)
# self.bottom_camera.setP(-90)
self.pbase.accept("v", self.pbase.bufferViewer.toggleEnable)
self.pbase.accept("V", self.pbase.bufferViewer.toggleEnable)
self.pbase.bufferViewer.setPosition("llcorner")
self.pbase.bufferViewer.setCardSize(.5, 0.0)
self.pbase.accept("u", self.update_textures)
# Load in quadcopter model
self.model = pbase.loader.loadModel("models/plane.egg")
self.model.reparentTo(self.node_path)
self.model.setH(90)
# self.model.setScale(1/8., 1/8., 1/8.)
self.error = None
self.v_pid = PIDControl(20.0, 10.0, 0.0)
self.omega_pid = PIDControl(5.0, 0.0, 0.0)
self.__tmat_ib = Mat4()
def __init__(self, base, lookatpos, pggen, togglerotcenter=False):
self.base = base
self.originallookatpos = lookatpos # for backup
self.lookatpos_pdv3 = Vec3(lookatpos[0], lookatpos[1], lookatpos[2])
self.camdist = (self.base.cam.getPos() - self.lookatpos_pdv3).length()
self.pggen = pggen
self.initviewdist = (self.base.cam.getPos() -
self.lookatpos_pdv3).length()
self.wheelscale_distance = 150
self.lastm1pos = None
self.lastm2pos = None
# toggle on the following part to explicitly show the rotation center
self.togglerotcenter = togglerotcenter
if self.togglerotcenter:
self.rotatecenternp = self.base.p3dh.gensphere(
pos=self.originallookatpos,
radius=5,
rgba=np.array([1, 1, 0, 1]))
self.rotatecenternp.reparentTo(self.base.render)
# for resetting
self.original_cam_pdmat4 = Mat4(self.base.cam.getMat())
self.keymap = {
"mouse1": False,
"mouse2": False,
"mouse3": False,
"wheel_up": False,
"wheel_down": False,
"space": False,
"w": False,
"s": False,
"a": False,
"d": False,
"g": False,
"r": False
}
self.accept("mouse1", self.__setkeys, ["mouse1", True])
self.accept("mouse1-up", self.__setkeys, ["mouse1", False])
self.accept("mouse2", self.__setkeys, ["mouse2", True])
self.accept("mouse2-up", self.__setkeys, ["mouse2", False])
self.accept("mouse3", self.__setkeys, ["mouse3", True])
self.accept("mouse3-up", self.__setkeys, ["mouse3", False])
self.accept("wheel_up", self.__setkeys, ["wheel_up", True])
self.accept("wheel_down", self.__setkeys, ["wheel_down", True])
self.accept("space", self.__setkeys, ["space", True])
self.accept("space-up", self.__setkeys, ["space", False])
self.accept("w", self.__setkeys, ["w", True])
self.accept("w-up", self.__setkeys, ["w", False])
self.accept("s", self.__setkeys, ["s", True])
self.accept("s-up", self.__setkeys, ["s", False])
self.accept("a", self.__setkeys, ["a", True])
self.accept("a-up", self.__setkeys, ["a", False])
self.accept("d", self.__setkeys, ["d", True])
self.accept("d-up", self.__setkeys, ["d", False])
self.accept("g", self.__setkeys, ["g", True])
self.accept("g-up", self.__setkeys, ["g", False])
self.accept("r", self.__setkeys, ["r", True])
self.accept("r-up", self.__setkeys, ["r", False])
self.setup_interactiongeometries()
def transform(self, xform):
transl = Mat4(Mat4.identMat())
transl.setRow(3, xform.getRow3(3))
self.path.setMat(render, transl * self.originalMat)
self._fixScale()
xform.setRow(3, Vec3())
for client, originalMat in self.clients:
#client.setMat(self.path, originalMat * xform)
client.setMat(originalMat * xform * transl * self.originalMat)
def lookahead_ground(self, dist, deg):
lookahed_vec = self.car_vec * dist
rot_mat = Mat4()
rot_mat.setRotateMat(deg, (0, 0, 1))
lookahead_rot = rot_mat.xformVec(lookahed_vec)
lookahead_pos = self.car.gfx.nodepath.get_pos() + lookahead_rot
if hasattr(self, 'debug_lines_gnd'):
self.debug_lines_gnd.draw(self.car.gfx.nodepath.get_pos(), lookahead_pos)
return self.car.phys.gnd_name(lookahead_pos)
def decompose_transform(matrix):
"""Decompose transformation matrix into translation, rotation, scale matrices
:param matrix: matrix to decompose
"""
rotation = Mat4()
matrix.getQuat().extractToMatrix(rotation)
translation = Mat4().translateMat(matrix.getPos())
inverse_rotation = Mat4()
inverse_rotation.invertFrom(rotation)
inverse_translation = Mat4()
inverse_translation.invertFrom(translation)
scale = matrix.getMat() * inverse_translation * inverse_rotation
return translation, rotation, scale
def _update_obst(self, gnd):
if self.car.phys.speed >= 5:
nsam = 0
else:
nsam = 10
if len(self.obst_samples[gnd]) > nsam:
self.obst_samples[gnd].pop(0)
lat_deg = 40 - 35 * self.car.phys.speed_ratio
bounds = {'left': (0, lat_deg), 'center': (0, 0), 'right': (-lat_deg, 0)}
if gnd == 'center':
offset = (uniform(*self.width_bounds), 0, 0)
deg = 0
else:
offset = (self.width_bounds[self.bnd_idx(gnd)], 0, 0)
deg = uniform(*bounds[gnd])
start = self.car.gfx.nodepath.get_pos() - self.car_vec * .8
rot_mat = Mat4()
rot_mat.setRotateMat(self.car.gfx.nodepath.get_h(), (0, 0, 1))
offset_rot = rot_mat.xformVec(offset)
start = start + offset_rot + (0, 0, uniform(*self.height_bounds))
lgt = 4 + 31 * self.car.phys.speed_ratio
lookahed_vec = self.car_vec * lgt
rot_mat = Mat4()
rot_mat.setRotateMat(uniform(*bounds[gnd]), (0, 0, 1))
lookahead_rot = rot_mat.xformVec(lookahed_vec)
lookahead_pos = self.car.gfx.nodepath.get_pos() + lookahead_rot
b_m = BitMask32.bit(0)
car_idx = self.cars.index(self.car.name)
cars_idx = range(len(self.cars))
cars_idx.remove(car_idx)
for bitn in cars_idx:
b_m = b_m | BitMask32.bit(2 + bitn)
result = PhysMgr().ray_test_closest(start, lookahead_pos, b_m)
hit = result.get_node()
dist = 0
name = ''
if hit:
dist = self.car.gfx.nodepath.get_pos() - result.get_hit_pos()
dist = dist.length()
name = hit.get_name()
self.obst_samples[gnd] += [(name, dist)]
if hasattr(self, 'debug_lines_obst'):
self.debug_lines_obst.draw(start, lookahead_pos)
def add_vertices(self, radius, heading):
base_pos = self.last_pos + (0, 0, -radius + .05)
rot_mat = Mat4()
rot_mat.setRotateMat(heading, (0, 0, 1))
self.vertex.addData3f(base_pos + rot_mat.xformVec((-.12, 0, 0)))
self.vertex.addData3f(base_pos + rot_mat.xformVec((.12, 0, 0)))
if self.cnt >= 3:
self.prim.addVertices(self.cnt - 3, self.cnt - 2, self.cnt - 1)
self.prim.addVertices(self.cnt - 2, self.cnt, self.cnt - 1)
self.cnt += 2
def to_forrowvecs(m4x4):
"""
p3d uses internally a different matrix multiplication style
than is traditionally used in math. This function converts the
traditional format of a matrix into the p3d format.
Parameters:
- m4x4 is a 4x4 matrix in the not-forrowvecs (normal) format
"""
return Mat4(*tuple(np.transpose(m4x4).flatten()))
