def jump_to (self, pos=None, hpr=None, speed=None):
if pos is None:
pos = self.pos(refbody=self.parent)
if hpr is None:
hpr = self.hpr(refbody=self.parent)
if speed is None:
speed = self.speed(refbody=self.parent)
self.node.setPos(pos)
self.node.setHpr(hpr)
q = Quat()
q.setHpr(hpr)
self._vel = Vec3(q.xform(Vec3(0, speed, 0)))
self._acc = Vec3()
self._angvel = Vec3()
self._angacc = Vec3()
self._prev_vel = Vec3(self._vel)
self._prev_angvel = Vec3(self._angvel)
def hpr_to_quat(hpr):
q = Quat()
q.setHpr(hpr)
return q
def __init__ (self, body, handle, duration,
offpos=None, offdir=None, offspeed=0.0,
traildurfac=1.0, traillifespan=0.0,
trailthickness=0.0, trailendthfac=4.0,
trailspacing=1.0, trailtcol=0.0,
trailfire=False,
keeptogether=False, texture=None):
if isinstance(body, tuple):
model, world = body
models = [model]
shadow_model = None
body = None
self.world = world
else:
self.world = body.world
models = list(body.models)
if base.with_world_shadows and body.shadow_node is not None:
shadow_model = body.shadow_node
else:
shadow_model = None
self.node = self.world.node.attachNewNode("breakup-part")
if not keeptogether:
shader = make_shader(ambln=self.world.shdinp.ambln,
dirlns=self.world.shdinp.dirlns)
self.node.setShader(shader)
if texture is not None:
set_texture(self.node, texture)
if isinstance(handle, basestring):
handles = [handle]
else:
handles = handle
offset = offpos
pos = None
quat = None
self._together_nodes = []
for model in models:
if model is None:
continue
for handle in handles:
nd = model.find("**/%s" % handle)
if not nd.isEmpty():
if offset is None:
if body is not None:
offset = nd.getPos(body.node)
else:
offset = nd.getPos(self.world.node)
if pos is None:
# Must be done here because of wrtReparentTo below.
if body is not None:
pos = body.pos(offset=offset)
quat = body.quat()
else:
pos = self.world.node.getRelativePoint(model, offset)
quat = model.getQuat(self.world.node)
self.node.setPos(pos)
self.node.setQuat(quat)
if offdir is None:
offdir = unitv(offset)
if not keeptogether:
nd.wrtReparentTo(self.node)
else:
offset2 = nd.getPos(self.node)
self._together_nodes.append((nd, offset2))
if pos is None:
if offpos is not None:
pos = offpos
self.node.setPos(pos)
else:
raise StandardError(
"No subnodes found for given handle, "
"and no initial position given.")
if shadow_model is not None:
for handle in handles:
nd = shadow_model.find("**/%s" % handle)
if not nd.isEmpty():
nd.removeNode()
if body is not None:
odir = self.world.node.getRelativeVector(body.node, offdir)
bvel = body.vel()
elif models[0] is not None:
odir = self.world.node.getRelativeVector(models[0], offdir)
bvel = Vec3(0.0, 0.0, 0.0)
else:
odir = offdir
bvel = Vec3(0.0, 0.0, 0.0)
vel = bvel + odir * offspeed
if quat is None:
quat = Quat()
quat.setHpr(vectohpr(vel))
self._pos0 = pos
self._vel0 = vel
self._quat0 = quat
self._duration = duration
self._time = 0.0
self._trails = []
if traildurfac > 0.0 and traillifespan > 0.0 and trailthickness > 0.0:
self._start_trail(traildurfac, traillifespan, trailthickness,
trailendthfac, trailspacing, trailtcol, trailfire)
self.alive = True
# Before general loops, e.g. to have updated position in effect loops.
base.taskMgr.add(self._loop, "breakup-part-loop", sort=-1)
def hpr2quat(h,p,r):
q = Quat()
q.setHpr((h,p,r))
return q
def __init__ (self, world,
family, species, hitforce,
name, side,
mass=None,
pos=Point3(), hpr=Vec3(),
vel=Vec3(), angvel=Vec3(),
acc=Vec3(), angacc=Vec3(),
modeldata=None,
hitboxdata=[], hitboxcritdata=[],
hitinto=True, hitfrom=True,
sensordata=None,
center=None, bbox=None, bboxcenter=None,
hitlight=None, hitdebris=None, hitflash=None,
passhitfx=False,
amblit=False, dirlit=False, pntlit=0, fogblend=False,
obright=False, ltrefl=False,
shdshow=False, shdmodind=None,
parent=None):
self.alive = True
self.world = world
self.family = family
self.species = species
self.name = name
self.side = side
self.parent = parent or world
self.mass = mass
self.hitforce = hitforce
self.hitlight = hitlight
self.hitdebris = hitdebris
self.hitflash = hitflash
self.passhitfx = passhitfx
self.racc = Vec3()
self.aacc = Vec3()
self.rangacc = Vec3()
self.aangacc = Vec3()
if isinstance(vel, (float, int)):
q = Quat()
q.setHpr(hpr)
vel = q.xform(Vec3(0, vel, 0))
self._acc = Vec3(acc)
self._angacc = Vec3(angacc)
self._vel = Vec3(vel)
self._prev_vel = Vec3(vel)
self._angvel = Vec3(angvel)
self._prev_angvel = Vec3(angvel)
self.birth_time = world.time
self.initiator = None
arg_bbox = bbox
arg_bboxcenter = bboxcenter
self.node = self.parent.node.attachNewNode(self.name)
if modeldata and modeldata.path:
if ltrefl:
glossmap = modeldata.glossmap
if not glossmap:
glossmap = "images/_glossmap_none.png"
else:
glossmap = None
if isinstance(modeldata.glowmap, Vec4):
glowcol = modeldata.glowmap
glowmap = None
else:
glowcol = None
glowmap = modeldata.glowmap
if modeldata.clamp is not None:
clamp = modeldata.clamp
else:
clamp = True
shadowmap = base.world_shadow_texture if shdshow else None
if isinstance(modeldata.path, (tuple, list)):
if (len(modeldata.path) == 2 and
isinstance(modeldata.path[0], NodePath) and
isinstance(modeldata.path[1], str)):
pnode, tname = modeldata.path
ret = extract_model_lod_chain(pnode, tname,
texture=modeldata.texture, normalmap=modeldata.normalmap,
glowmap=glowmap, glossmap=glossmap,
shadowmap=shadowmap,
clamp=clamp)
lnode, models, fardists, bbox, bcen, ppos, phpr = ret
if pos is None:
pos = ppos
if hpr is None:
hpr = phpr
for model in models:
model.setPos(Point3())
model.setHpr(Vec3())
else:
ret = load_model_lod_chain(
world.vfov, modeldata.path,
texture=modeldata.texture, normalmap=modeldata.normalmap,
glowmap=glowmap, glossmap=glossmap,
shadowmap=shadowmap,
clamp=clamp, scale=modeldata.scale,
pos=modeldata.offset, hpr=modeldata.rot)
lnode, models, fardists, bbox, bcen = ret
self.modelnode = lnode
self.models = models
self.fardists = fardists
self.bbox = bbox
self.bboxcenter = bcen
lnode.reparentTo(self.node)
else:
model = load_model(
modeldata.path,
texture=modeldata.texture, normalmap=modeldata.normalmap,
glowmap=glowmap, glossmap=glossmap,
shadowmap=shadowmap,
clamp=clamp, scale=modeldata.scale,
pos=modeldata.offset, hpr=modeldata.rot)
self.modelnode = model
self.models = [model]
self.fardists = [-1.0]
model.reparentTo(self.node)
if not modeldata.nobbox:
bmin, bmax = model.getTightBounds()
self.bbox = bmax - bmin
self.bboxcenter = (bmin + bmax) * 0.5
else:
self.bbox = Vec3()
self.bboxcenter = Vec3()
else:
self.modelnode = None
self.models = []
self.fardists = []
self.bbox = Vec3()
self.bboxcenter = Vec3()
if arg_bbox is not None:
self.bbox = arg_bbox
if arg_bboxcenter is not None:
self.bboxcenter = arg_bboxcenter
else:
self.bboxcenter = Vec3()
elif arg_bboxcenter is not None:
self.bboxcenter = arg_bboxcenter
self.update_bbox(bbox=self.bbox, bboxcenter=self.bboxcenter)
self.node.setPos(pos)
self.node.setHpr(hpr)
self.hitboxes = []
self.set_hitboxes(hitboxdata, hitboxcritdata, hitinto, hitfrom)
#for hbx in self.hitboxes:
#hbx.cnode.show()
self.inert_collide = False
self.hits_critical = True
if center is not None:
self.center = center
elif self.hitboxes:
self.center = Point3()
volume = 0.0
for hbx in self.hitboxes:
self.center += hbx.center * hbx.volume
volume += hbx.volume
self.center /= volume
else:
self.center = self.bboxcenter
if self.hitlight:
self._init_hitlight()
if self.hitdebris:
self._init_hitdebris()
if self.hitflash:
self._init_hitflash()
# Before shader is set.
if base.with_world_shadows:
if modeldata and modeldata.shadowpath:
model = load_model(
modeldata.shadowpath,
scale=modeldata.scale,
pos=modeldata.offset, hpr=modeldata.rot)
model.reparentTo(world.shadow_node)
self.shadow_node = model
elif self.models and shdmodind is not None:
model = self.models[shdmodind]
self.shadow_node = model.copyTo(world.shadow_node)
else:
self.shadow_node = None
if self.models:
shdinp = world.shdinp
ambln = shdinp.ambln if amblit else None
dirlns = shdinp.dirlns if dirlit else []
#pntlit = 0
pntlns = shdinp.pntlns[:pntlit]
fogn = shdinp.fogn if fogblend else None
camn = shdinp.camn
pntobrn = shdinp.pntobrn if obright else None
normal = modeldata.normalmap is not None
gloss = ltrefl
glow = glowcol if glowcol is not None else (glowmap is not None)
shadowrefn = shdinp.shadowrefn if shdshow else None
shadowdirlin = shdinp.shadowdirlin if shdshow else None
shadowblendn = shdinp.shadowblendn if shdshow else None
shadowpush = 0.003 if shdshow else None
shadowblur = SHADOWBLUR.NONE if shdshow else None
showas = False
#showas = "%s-shader" % (self.family)
ret = make_shader(
ambln=ambln, dirlns=dirlns, pntlns=pntlns,
fogn=fogn, camn=camn, pntobrn=pntobrn,
normal=normal, gloss=gloss, glow=glow,
shadowrefn=shadowrefn, shadowdirlin=shadowdirlin,
shadowblendn=shadowblendn, shadowpush=shadowpush,
shadowblur=shadowblur,
showas=showas, getargs=True)
self.shader, self.shader_kwargs = ret
self.modelnode.setShader(self.shader)
self.pntlit = pntlit
if sensordata is not None:
self.sensorpack = SensorPack(parent=self,
scanperiod=sensordata.scanperiod,
relspfluct=sensordata.relspfluct,
maxtracked=sensordata.maxtracked)
else:
self.sensorpack = None
self.shotdown = False
self.retreating = False
self.outofbattle = False
self.controlout = False
self._last_collide_body = None
self._recorded_as_kill = False
if not base.with_sound_doppler:
self.ignore_flyby = 0
world.register_body(self)
base.taskMgr.add(self._loop_fx, "body-effects-%s" % self.name)
def hpr_to_quat (hpr):
q = Quat ()
q.setHpr (hpr)
return q
