def setView(self, x, y, z, h, p, r):
self.viewOrigin = Vec3(x, y, z)
self.viewAngles = Vec3(h, p, r)
quat = Quat()
quat.setHpr(self.viewAngles)
self.viewAngleVectors = [
quat.getRight(), quat.getForward(),
quat.getUp()
]
def guide_missile(self, task):
try:
quat = Quat()
lookAt(quat, self.target.np.getPos() - self.missile.anp.getPos(), Vec3.up())
self.missile.anp.setQuat(quat)
fwd = quat.getForward()
fwd.normalize()
mvel = self.missile.anpo.getVelocity().length()
self.missile.anpo.setVelocity(fwd*mvel)
except:
return task.done
return task.cont
def makeMuzzleFlash(node, pos, hpr, scale, color=(1, 1, 1, 1)):
import random
from panda3d.core import Quat, Point3
from src.coginvasion.base.MuzzleParticle import MuzzleParticle
quat = Quat()
quat.setHpr(hpr)
forward = quat.getForward()
scale = random.uniform(scale - 0.25, scale + 0.25)
#scale = clamp(scale, 0.5, 8.0)
for i in xrange(1, 9):
offset = Point3(pos) + (forward * (i * (2 / 16.0) * scale))
size = (random.uniform(6 / 16.0, 9 / 16.0) * (12 - (i)) / 9) * scale
roll = random.randint(0, 360)
dur = 0.035
p = MuzzleParticle(size, size, roll, color, dur)
p.reparentTo(node)
p.setPos(offset)
p.setHpr(hpr)
def __updateTask(self, task):
# TODO -- This function does a lot of math, I measured it to take .5 ms on my laptop
# That's a lot of time for something miniscule like sway and bob.
dt = globalClock.getDt()
time = globalClock.getFrameTime()
if base.localAvatar.isFirstPerson():
eyePoint = base.localAvatar.getEyePoint()
if base.localAvatar.walkControls.crouching:
eyePoint[2] = eyePoint[2] / 2.0
eyePoint[2] = CIGlobals.lerpWithRatio(eyePoint[2],
self.lastEyeHeight, 0.4)
self.lastEyeHeight = eyePoint[2]
camRootAngles = Vec3(0)
# Mouse look around
mw = base.mouseWatcherNode
if mw.hasMouse():
md = base.win.getPointer(0)
center = Point2(base.win.getXSize() / 2, base.win.getYSize() / 2)
xDist = md.getX() - center.getX()
yDist = md.getY() - center.getY()
sens = self.__getMouseSensitivity()
angular = -(xDist * sens) / dt
base.localAvatar.walkControls.controller.setAngularMovement(
angular)
camRootAngles.setY(self.lastPitch - yDist * sens)
if camRootAngles.getY() > FPSCamera.MaxP:
camRootAngles.setY(FPSCamera.MaxP)
yDist = 0
elif camRootAngles.getY() < FPSCamera.MinP:
yDist = 0
camRootAngles.setY(FPSCamera.MinP)
base.win.movePointer(0, int(center.getX()), int(center.getY()))
if base.localAvatar.isFirstPerson():
# Camera / viewmodel bobbing
vmBob = Point3(0)
vmAngles = Vec3(0)
vmRaise = Point3(0)
camBob = Point3(0)
maxSpeed = base.localAvatar.walkControls.BattleRunSpeed * 16.0
speed = base.localAvatar.walkControls.speeds.length() * 16.0
speed = max(-maxSpeed, min(maxSpeed, speed))
bobOffset = CIGlobals.remapVal(speed, 0, maxSpeed, 0.0, 1.0)
self.bobTime += (time - self.lastBobTime) * bobOffset
self.lastBobTime = time
# Calculate the vertical bob
cycle = self.bobTime - int(
self.bobTime / self.BobCycleMax) * self.BobCycleMax
cycle /= self.BobCycleMax
if cycle < self.BobUp:
cycle = math.pi * cycle / self.BobUp
else:
cycle = math.pi + math.pi * (cycle - self.BobUp) / (1.0 -
self.BobUp)
verticalBob = speed * 0.005
verticalBob = verticalBob * 0.3 + verticalBob * 0.7 * math.sin(
cycle)
verticalBob = max(-7.0, min(4.0, verticalBob))
verticalBob /= 16.0
# Calculate the lateral bob
cycle = self.bobTime - int(
self.bobTime / self.BobCycleMax * 2) * self.BobCycleMax * 2
cycle /= self.BobCycleMax * 2
if cycle < self.BobUp:
cycle = math.pi * cycle / self.BobUp
else:
cycle = math.pi + math.pi * (cycle - self.BobUp) / (1.0 -
self.BobUp)
lateralBob = speed * 0.005
lateralBob = lateralBob * 0.3 + lateralBob * 0.7 * math.sin(cycle)
lateralBob = max(-7.0, min(4.0, lateralBob))
lateralBob /= 16.0
# Apply bob, but scaled down a bit
vmBob.set(lateralBob * 0.8, 0, verticalBob * 0.1)
# Z bob a bit more
vmBob[2] += verticalBob * 0.1
# Bob the angles
vmAngles[2] += verticalBob * 0.5
vmAngles[1] -= verticalBob * 0.4
vmAngles[0] -= lateralBob * 0.3
# ================================================================
# Viewmodel lag/sway
angles = self.camRoot.getHpr(render)
quat = Quat()
quat.setHpr(angles)
invQuat = Quat()
invQuat.invertFrom(quat)
maxVMLag = 1.5
lagforward = quat.getForward()
if dt != 0.0:
lagdifference = lagforward - self.lastFacing
lagspeed = 5.0
lagdiff = lagdifference.length()
if (lagdiff > maxVMLag) and (maxVMLag > 0.0):
lagscale = lagdiff / maxVMLag
lagspeed *= lagscale
self.lastFacing = CIGlobals.extrude(self.lastFacing,
lagspeed * dt,
lagdifference)
self.lastFacing.normalize()
lfLocal = invQuat.xform(lagdifference)
vmBob = CIGlobals.extrude(vmBob, 5.0 / 16.0, lfLocal * -1.0)
pitch = angles[1]
if pitch > 180:
pitch -= 360
elif pitch < -180:
pitch += 360
vmBob = CIGlobals.extrude(vmBob, pitch * (0.035 / 16),
Vec3.forward())
vmBob = CIGlobals.extrude(vmBob, pitch * (0.03 / 16), Vec3.right())
vmBob = CIGlobals.extrude(vmBob, pitch * (0.02 / 16), Vec3.up())
# ================================================================
vmRaise.set(
0, 0, 0
) #(0, abs(camRootAngles.getY()) * -0.002, camRootAngles.getY() * 0.002)
camBob.set(0, 0, 0)
# Apply bob, raise, and sway to the viewmodel.
self.viewModel.setPos(vmBob + vmRaise + self.lastVMPos)
self.vmRoot2.setHpr(vmAngles)
self.camRoot.setPos(eyePoint + camBob)
newPitch = camRootAngles.getY()
if abs(newPitch - self.lastPitch) > self.PitchUpdateEpsilon:
# Broadcast where our head is looking
head = base.localAvatar.getPart("head")
if head and not head.isEmpty():
# Constrain the head pitch a little bit so it doesn't look like their head snapped
headPitch = max(-47, newPitch)
headPitch = min(75, headPitch)
base.localAvatar.b_setLookPitch(headPitch)
self.lastPitch = newPitch
if base.localAvatar.isFirstPerson():
# Apply punch angle
self.decayPunchAngle()
camRootAngles += self.punchAngle
self.camRoot.setHpr(camRootAngles)
return task.cont
def drawFern(self, LOD, pos, quat, drawResourcesFactory, scale=1.0):
scalar = random.random()
scale *= scalar
if scale < .3: return
count = int((scalar**.7) * 12)
if scale < .8:
if LOD == self.lowLOD: return
else:
if LOD == self.midLOD: return
leafResources = drawResourcesFactory.getDrawResources(
self.leafDataIndex[LOD])
leafTri = leafResources.getGeomTriangles()
vertexWriter = leafResources.getWriter("vertex")
normalWriter = leafResources.getWriter("normal")
if self.leafTexture:
texcoordWriter = leafResources.getWriter("texcoord")
scale *= self.scalar * 3
q2 = Quat()
q3 = Quat()
for i in xrange(count):
p = (random.random()**2) * 60 + 20
h = random.random() * 360
q2.setHpr((h, p, 0))
q3.setHpr((h, p - 20 - p / 4, 0))
length1 = scale * 4
length2 = scale * 3
f = q2.getForward() * length1
r = q2.getRight() * scale * .5
f2 = q3.getForward() * length2 + f
norm0 = q2.getUp()
norm2 = q3.getUp()
norm1 = norm0 + norm2
norm1.normalize()
for x in range(2):
leafRow = vertexWriter.getWriteRow()
vertexWriter.addData3f(pos)
vertexWriter.addData3f(pos + f + r)
vertexWriter.addData3f(pos + f - r)
vertexWriter.addData3f(pos + f2)
if self.leafTexture:
texcoordWriter.addData2f(0, 0)
texcoordWriter.addData2f(0, 1)
texcoordWriter.addData2f(1, 0)
texcoordWriter.addData2f(1, 1)
if x == 1:
# back sides
norm0 = -norm0
norm1 = -norm1
norm2 = -norm2
leafTri.addVertices(leafRow + 1, leafRow, leafRow + 2)
leafTri.addVertices(leafRow + 3, leafRow + 1, leafRow + 2)
else:
leafTri.addVertices(leafRow, leafRow + 1, leafRow + 2)
leafTri.addVertices(leafRow + 1, leafRow + 3, leafRow + 2)
normalWriter.addData3f(norm0)
normalWriter.addData3f(norm1)
normalWriter.addData3f(norm1)
normalWriter.addData3f(norm2)
def drawFern(self,LOD,pos,quat,drawResourcesFactory,scale=1.0):
scalar=random.random()
scale*=scalar
if scale<.3: return
count=int((scalar**.7)*12)
if scale<.8:
if LOD==self.lowLOD: return
else:
if LOD==self.midLOD: return
leafResources=drawResourcesFactory.getDrawResources(self.leafDataIndex[LOD])
leafTri=leafResources.getGeomTriangles()
vertexWriter=leafResources.getWriter("vertex")
normalWriter=leafResources.getWriter("normal")
if self.leafTexture:
texcoordWriter = leafResources.getWriter("texcoord")
scale*=self.scalar*3
q2=Quat()
q3=Quat()
for i in xrange(count):
p=(random.random()**2)*60+20
h=random.random()*360
q2.setHpr((h,p,0))
q3.setHpr((h,p-20-p/4,0))
length1=scale*4
length2=scale*3
f=q2.getForward()*length1
r=q2.getRight()*scale*.5
f2=q3.getForward()*length2+f
norm0=q2.getUp()
norm2=q3.getUp()
norm1=norm0+norm2
norm1.normalize()
for x in range(2):
leafRow = vertexWriter.getWriteRow()
vertexWriter.addData3f(pos)
vertexWriter.addData3f(pos+f+r)
vertexWriter.addData3f(pos+f-r)
vertexWriter.addData3f(pos+f2)
if self.leafTexture:
texcoordWriter.addData2f(0,0)
texcoordWriter.addData2f(0,1)
texcoordWriter.addData2f(1,0)
texcoordWriter.addData2f(1,1)
if x==1:
# back sides
norm0=-norm0
norm1=-norm1
norm2=-norm2
leafTri.addVertices(leafRow+1,leafRow,leafRow+2)
leafTri.addVertices(leafRow+3,leafRow+1,leafRow+2)
else:
leafTri.addVertices(leafRow,leafRow+1,leafRow+2)
leafTri.addVertices(leafRow+1,leafRow+3,leafRow+2)
normalWriter.addData3f(norm0)
normalWriter.addData3f(norm1)
normalWriter.addData3f(norm1)
normalWriter.addData3f(norm2)
