def RenderPin(outPath, objectPath, size=128, freezeTime=True):
if freezeTime:
FreezeTime()
model = blue.resMan.LoadObject(objectPath)
blue.resMan.Wait()
blue.os.Pump()
if hasattr(model, 'curveSets'):
model.curveSets.removeAt(-1)
scene = trinity.EveSpaceScene()
scene.sunDirection = (-0.5, -0.5, -0.6)
scene.objects.append(model)
bgColor = (0.0, 0.0, 0.0, 1.0)
transparent = False
if model.mesh != None:
bBoxMin = (0.0, 0.0, 0.0)
bBoxMax = (0.0, 0.0, 0.0)
for i in range(model.mesh.geometry.GetMeshAreaCount(0)):
boundingBoxMin, boundingBoxMax = model.mesh.geometry.GetAreaBoundingBox(
0, i)
if abs(boundingBoxMax[1] - boundingBoxMin[1]) > 0.005:
if geo2.Vec3Length(bBoxMin) < geo2.Vec3Length(boundingBoxMin):
bBoxMin = boundingBoxMin
if geo2.Vec3Length(bBoxMax) < geo2.Vec3Length(boundingBoxMax):
bBoxMax = boundingBoxMax
view, projection = camera_util.GetViewAndProjectionUsingBoundingBox(
bBoxMin, bBoxMax)
hostBitmap = RenderToSurface(scene=scene,
view=view,
projection=projection,
size=size,
bgColor=bgColor,
transparent=transparent)
hostBitmap.Save(outPath)
def PickProbes(self, pickBorder = False):
mouseInsideProbes = []
borderPick = []
probeHandler = self.GetProbeHandler()
if probeHandler:
probeData = sm.StartService('scanSvc').GetProbeData()
cameraPosition = geo2.Vec3Add(self.mapView.camera.pointOfInterest, self.mapView.camera._eyePosition)
probes = probeHandler.GetProbeControls()
for probeID, probeControl in probes.iteritems():
if probeID not in probeData or probeData[probeID].state != const.probeStateIdle:
continue
targetPlanePos = probeControl.GetWorldPosition()
cameraDistance = geo2.Vec3Length(geo2.Vec3Subtract(cameraPosition, targetPlanePos))
rad = probeControl.GetRange() * SOLARSYSTEM_SCALE
mousePositionOnCameraPlane = self.GetDotInCameraAlignedPlaneFromPosition(targetPlanePos)
distanceFromCenter = geo2.Vec3Length(geo2.Vec3Subtract(targetPlanePos, mousePositionOnCameraPlane))
if pickBorder:
pickRadiusPos = self.GetDotInCameraAlignedPlaneFromPosition(targetPlanePos, offsetMouse=(-10, 0))
pickRadius = geo2.Vec3Length(geo2.Vec3Subtract(pickRadiusPos, mousePositionOnCameraPlane))
if rad + pickRadius > distanceFromCenter > rad - pickRadius:
borderPick.append((abs(rad - distanceFromCenter), probeControl))
elif distanceFromCenter <= rad:
mouseInsideProbes.append((cameraDistance, probeControl))
if pickBorder:
if borderPick:
return SortListOfTuples(borderPick)[0]
else:
return None
return SortListOfTuples(mouseInsideProbes)
def GetAngleLookAtToUpDirection(self):
try:
vLookAt = self.GetLookAtDirectionWithOffset()
return math.acos(
geo2.Vec3Dot(vLookAt, self.upDirection) /
(geo2.Vec3Length(vLookAt) * geo2.Vec3Length(self.upDirection)))
except ValueError:
return 0.0
def LoadSolarSystemMap(self):
self.maxRadius = 0.0
solarsystemID = self.solarsystemID
parent = self.systemMapTransform
solarSystemData = self.systemMapSvc.GetSolarsystemData(solarsystemID)
planets = []
childrenToParentByID = {}
sunID = None
maxRadius = 0.0
for celestialObject in solarSystemData:
if celestialObject.groupID == const.groupPlanet:
planets.append((celestialObject.itemID, geo2.Vector(celestialObject.x, celestialObject.y, celestialObject.z)))
maxRadius = max(maxRadius, geo2.Vec3Length((celestialObject.x, celestialObject.y, celestialObject.z)))
elif celestialObject.groupID == const.groupSun:
sunID = celestialObject.itemID
sunGraphicFilePath = GetGraphicFile(evetypes.GetGraphicID(celestialObject.typeID))
sunGraphicFile = trinity.Load(sunGraphicFilePath)
self.CreateSun(sunGraphicFile)
self.sunID = sunID
objectPositions = {}
for each in solarSystemData:
objectPositions[each.itemID] = (each.x, each.y, each.z)
if each.groupID in (const.groupPlanet, const.groupStargate):
childrenToParentByID[each.itemID] = sunID
continue
closest = []
eachPosition = geo2.Vector(each.x, each.y, each.z)
maxRadius = max(maxRadius, geo2.Vec3Length(eachPosition))
for planetID, planetPos in planets:
diffPos = planetPos - eachPosition
diffVector = geo2.Vec3Length(diffPos)
closest.append((diffVector, planetID))
closest.sort()
childrenToParentByID[each.itemID] = closest[0][1]
self.maxRadius = maxRadius
for each in solarSystemData:
if each.itemID == each.locationID:
continue
if each.groupID == const.groupSecondarySun:
continue
if each.groupID == const.groupPlanet:
self.CreatePlanet((each.x, each.y, each.z))
OrbitCircle(each.itemID, (each.x, each.y, each.z), objectPositions[sunID], self.systemMapTransform)
elif each.groupID == const.groupMoon:
parentID = childrenToParentByID.get(each.itemID, None)
if parentID:
self.CreatePlanet((each.x, each.y, each.z))
OrbitCircle(each.itemID, (each.x, each.y, each.z), objectPositions[parentID], self.systemMapTransform)
self.solarSystemRadius = maxRadius
cfg.evelocations.Prime(objectPositions.keys(), 0)
def Zoom(self, val):
dev = trinity.device
pos = self.GetPosition()
target = self.GetPointOfInterest()
view = geo2.Vec3Normalize(geo2.Subtract(pos, target))
length = geo2.Vec3Length(geo2.Subtract(pos, target))
nextPos = geo2.Vec3Add(pos, geo2.Vec3Scale(view, length * val))
nextLength = geo2.Vec3Length(geo2.Vec3Subtract(nextPos, target))
if nextLength < self.minZoomDistance:
nextPos = geo2.Vec3Add(target, geo2.Vec3Scale(view, self.minZoomDistance))
elif nextLength > self.maxZoomDistance:
nextPos = geo2.Vec3Add(target, geo2.Vec3Scale(view, self.maxZoomDistance))
self.SetPosition(nextPos)
def CheckForStop(self, heading):
returnValue = heading
headingLength = geo2.Vec3Length(heading)
if not self.delayTimerActive and headingLength < const.FLOAT_TOLERANCE and geo2.Vec3Length(self.lastHeading) > 0:
returnValue = self.lastHeading
self.StartStopDelayTimer()
if self.delayTimerActive and self.delayTimerEnd > blue.os.GetWallclockTime():
if headingLength < const.FLOAT_TOLERANCE:
returnValue = self.lastHeading
else:
self.StopStopDelayTimer()
if self.delayTimerActive and self.delayTimerEnd <= blue.os.GetWallclockTime():
self.StopStopDelayTimer()
return returnValue
def GetAbstractPosition(self, pos, asPortion = 0, size = None):
if not len(self.orbs):
return (None, None)
dist = geo2.Vec3Length(pos)
maxorb = None
minorb = (0.0, 0)
for orbdist, pixelrad, orbititem, SIZE in self.orbs:
if orbdist < dist:
minorb = (orbdist, pixelrad)
elif orbdist > dist and maxorb is None:
maxorb = (orbdist, pixelrad)
mindist, minpixelrad = minorb
distInPixels = minpixelrad
if maxorb:
maxdist, maxpixelrad = maxorb
rnge = maxdist - mindist
pixelrnge = maxpixelrad - minpixelrad
posWithinRange = dist - mindist
distInPixels += pixelrnge * (posWithinRange / rnge)
sizefactor = float(distInPixels) / dist
if asPortion:
size = max(1, self.absoluteRight - self.absoluteLeft)
return (float(size) / (FLIPMAP * pos[0] * sizefactor + SIZE / 2), float(size) / (pos[2] * sizefactor + SIZE / 2))
return (int(FLIPMAP * pos[0] * sizefactor) + SIZE / 2, int(pos[2] * sizefactor) + SIZE / 2)
def GetMaxDist(self):
maxdist = 0.0
for item in self.mapitems:
pos = (item.x, 0.0, item.z)
maxdist = max(maxdist, geo2.Vec3Length(pos))
return maxdist
def OnActivated(self,
lastCamera=None,
itemID=None,
duration=None,
**kwargs):
settings.char.ui.Set('spaceCameraID', evecamera.CAM_TACTICAL)
if lastCamera:
distance = max(
self.maxZoom,
min(geo2.Vec3Length(self.eyePosition), self.minZoom))
if lastCamera.cameraID in (evecamera.CAM_SHIPORBIT,
evecamera.CAM_UNDOCK,
evecamera.CAM_ENTERSPACE):
self._ResetEyeAndAtPosition(lastCamera.eyePosition,
lastCamera.atPosition, distance)
else:
animate = lastCamera.cameraID not in (evecamera.CAM_SHIPPOV,
evecamera.CAM_HANGAR)
self._ResetEyeAndAtPosition(self.eyePosition, self.atPosition,
distance, animate)
self._SetLookAtBall(GetBall(lastCamera.GetItemID()))
if lastCamera.cameraID != evecamera.CAM_SHIPPOV:
self.fov = lastCamera.fov
self.ResetFOV()
else:
if not itemID:
itemID = self.ego
self._SetLookAtBall(GetBall(itemID))
self.SetEyePosition(self.default_eyePosition)
BaseSpaceCamera.OnActivated(self, **kwargs)
def update_line_position(posInfo):
lineData = posInfo[2]
lineID = lineData.lineID
fromPosition = posInfo[0]
if fromPosition is None:
fromMapNode = GetNodeBySolarSystemID(lineData.fromSolarSystemID)
fromPosition = fromMapNode.position
posInfo[0] = fromPosition
toPosition = posInfo[1]
if toPosition is None:
toMapNode = GetNodeBySolarSystemID(lineData.toSolarSystemID)
toPosition = toMapNode.position
posInfo[1] = toPosition
if lineID in adjustLines:
fromPosition = geo2.Vec3Add(fromPosition, adjustLines[lineID][0])
toPosition = geo2.Vec3Add(toPosition, adjustLines[lineID][2])
lineSet.ChangeLinePositionCrt(lineID, fromPosition, toPosition)
if lineData.jumpType == JUMPBRIDGE_TYPE:
linkVec = geo2.Vec3Subtract(toPosition, fromPosition)
normLinkVec = geo2.Vec3Normalize(linkVec)
rightVec = geo2.Vec3Cross(worldUp, normLinkVec)
upVec = geo2.Vec3Cross(rightVec, normLinkVec)
offsetVec = geo2.Vec3Scale(geo2.Vec3Normalize(upVec), geo2.Vec3Length(linkVec) * 1.0)
midPos = geo2.Vec3Scale(geo2.Vec3Add(toPosition, fromPosition), 0.5)
splinePos = geo2.Vec3Add(midPos, offsetVec)
lineSet.ChangeLineIntermediateCrt(lineID, splinePos)
def _UpdateAnchorPosition(self):
if self.lookAtBall and self.lookAtBall.mode == destiny.DSTBALL_WARP:
self.ResetAnchorPos()
elif not self._anchorBall or geo2.Vec3Length(
GetBallPosition(
self._anchorBall)) > evecamera.LOOKATRANGE_MAX_NEW:
self.UpdateAnchorPos()
def _DrawVelocityTrace(self):
while True:
try:
entity = self.debugSelectionClient.GetSelectedEntity()
if entity is not None:
if not entity.HasComponent('movement'):
return
scaleFactor = 1.5 / 4.0
offset = 0.25
pos = entity.position.position
vel = entity.GetComponent('movement').physics.velocity
speed = geo2.Vec3Length(vel)
speedScaled = speed * scaleFactor
velPos = geo2.Vec3Add(pos, (0, offset + speedScaled, 0))
velRulePos = geo2.Vec3Add(pos, (0, offset + 1, 0))
if self.lastVelPos != velPos:
self.debugRenderClient.RenderRay(self.lastVelPos,
velPos,
4278190335L,
4278190335L,
time=1000,
pulse=True)
self.debugRenderClient.RenderRay(self.lastVelRulePos,
velRulePos,
4278255360L,
4278255360L,
time=1000,
pulse=False)
self.lastVelPos = velPos
self.lastVelRulePos = velRulePos
except:
log.LogException()
blue.pyos.synchro.SleepWallclock(const.ONE_TICK / const.MSEC)
def ProcessNewMovement(self):
moveState = self.entityRef.GetComponent('movement').moveState
headingToApply = self.entityRef.movement.physics.velocity
deltaTurnAngle = moveState.GetDeltaYaw()
speed = geo2.Vec3Length((headingToApply[0], 0.0, headingToApply[2]))
self.SetControlParameter('Speed', speed)
maxSpeed = moveState.GetMaxSpeed()
self.SetControlParameter('nominalSpeed', maxSpeed)
modifier = maxSpeed
if modifier > 0:
modifier = speed / maxSpeed
modifier = min(max(modifier, 0.8), 1.2)
self.SetControlParameter('speedMod', modifier)
moving = moveState.GetStaticStateIndex() > 0
self.SetControlParameter('Moving', moving)
immed = moveState.GetImmediateRotation() / math.pi
applied = moveState.GetImmediateRotationApplied() / math.pi
if applied != 0.0 and applied != immed:
self.SetControlParameter('immediateTurn', immed)
else:
self.SetControlParameter('immediateTurn', 0)
if moving and not self.previousMoving:
self.SetControlParameter('immediateTurnNoReset', immed)
if moving:
self.SetControlParameter('TurnAngle', deltaTurnAngle / math.pi)
else:
self.SetControlParameter('TurnAngle', 0)
self.previousMoving = moving
if self.renderDebugControlParameters:
self.RenderDebugControlParameters(speed, deltaTurnAngle / math.pi,
immed, applied)
def __init__(self, orbitID, position, parentPosition, parentTransform):
self.orbitID = orbitID
dirVec = geo2.Vec3Subtract(position, parentPosition)
radius = geo2.Vec3Length(dirVec)
dirVec = geo2.Vec3Normalize(dirVec)
fwdVec = (-1.0, 0.0, 0.0)
rotation = geo2.QuaternionRotationArc(fwdVec, dirVec)
radius = radius / self.lineSetScaling
lineSet = mapViewUtil.CreateLineSet()
lineSet.scaling = (self.lineSetScaling, self.lineSetScaling, self.lineSetScaling)
lineSet.translation = parentPosition
lineSet.rotation = rotation
parentTransform.children.append(lineSet)
self.pixelLineSet = lineSet
mapViewUtil.DrawCircle(lineSet, (0, 0, 0), radius, startColor=(1, 1, 1, 0.25), endColor=(1, 1, 1, 0.25), lineWidth=2.5)
lineSet.SubmitChanges()
lineSet = mapViewUtil.CreatePlanarLineSet()
lineSet.scaling = (self.lineSetScaling, self.lineSetScaling, self.lineSetScaling)
lineSet.translation = parentPosition
lineSet.rotation = rotation
parentTransform.children.append(lineSet)
self.planarLineSet = lineSet
orbitLineColor = (1, 1, 1, 0.25)
self.planarLineIDs = mapViewUtil.DrawCircle(lineSet, (0, 0, 0), radius, startColor=orbitLineColor, endColor=orbitLineColor, lineWidth=radius / 150.0)
lineSet.SubmitChanges()
def Update(self):
sourcePoint = self.sourceFunction.GetValue()
destPoint = self.destinationFunction.GetValue()
d = geo2.Vec3Subtract(destPoint, sourcePoint)
length = geo2.Vec3Length(d)
self.model.scaling = (self.radius, length, self.radius)
self.model.rotation = geo2.QuaternionRotationArc((0, 1, 0), geo2.Vec3Normalize(d))
def CreateBehaviorFromMagnitudeAndPosition(magnitude, shakeOrigin, camera):
timeFactor = pow(magnitude / 400.0, 0.7)
noiseScaleCurve = trinity.TriScalarCurve()
noiseScaleCurve.AddKey(0.0, 1.2, 0.0, 0.0, 3)
noiseScaleCurve.AddKey(0.1, 0.1, 0.0, 0.0, 3)
noiseScaleCurve.AddKey(1.5 * timeFactor, 0.13, 0.0, 0.0, 3)
noiseScaleCurve.AddKey(2.0 * timeFactor, 0.0, 0.0, 0.0, 3)
noiseScaleCurve.extrapolation = 1
noiseDampCurve = trinity.TriScalarCurve()
noiseDampCurve.AddKey(0.0, 80.0, 0.0, 0.0, 3)
noiseDampCurve.AddKey(0.1, 20.0, 0.0, 0.0, 3)
noiseDampCurve.AddKey(1.5 * timeFactor, 0.0, 0.0, 0.0, 3)
noiseDampCurve.AddKey(2.0 * timeFactor, 0.0, 0.0, 0.0, 3)
noiseDampCurve.extrapolation = 1
distance = geo2.Vec3Length(geo2.Vec3Subtract(shakeOrigin, camera.pos))
if isnan(distance):
return
if distance < 700.0:
distance = 700.0
elif distance > 2000000000:
distance = 2000000000
actualMagnitude = 0.7 * magnitude / pow(distance, 0.7)
noiseScaleCurve.ScaleValue(actualMagnitude)
noiseDampCurve.ScaleValue(actualMagnitude)
if camera.noiseScaleCurve is not None and camera.noiseScaleCurve.value > noiseScaleCurve.keys[
1].value:
return
behavior = camshake.ShakeBehavior()
behavior.scaleCurve = noiseScaleCurve
behavior.dampCurve = noiseDampCurve
return behavior
def Update(self):
sourcePoint = self.sourceFunction.GetValue()
destPoint = self.destinationFunction.GetValue()
d = geo2.Vec3Subtract(destPoint, sourcePoint)
length = geo2.Vec3Length(d)
self.model.scaling = (length, self.scaling, length)
self.model.rotation = self.rotation
def _WaitForAcceleration(self, accT=215000.0):
shipBall = self.GetEffectShipBall()
shipPosL = shipBall.GetVectorAt(blue.os.GetSimTime())
shipPosL = (shipPosL.x, shipPosL.y, shipPosL.z)
speedL = 0
timeL = blue.os.GetSimTime()
acc = 0
while not self.abort:
timeN = blue.os.GetSimTime()
v = shipBall.GetVectorDotAt(timeN)
speed = geo2.Vec3Length((v.x, v.y, v.z))
shipPos = shipBall.GetVectorAt(blue.os.GetSimTime())
shipPos = (shipPos.x, shipPos.y, shipPos.z)
self.direction = geo2.Vec3Subtract(shipPos, shipPosL)
shipPosL = shipPos
timeDiffSec = blue.os.TimeDiffInMs(timeL, timeN) / 1000.0
if timeDiffSec != 0.0:
acc = (speed - speedL) / timeDiffSec
speedL = speed
timeL = timeN
if acc > accT:
break
blue.synchro.Yield()
return speedL
def DrawLineSetCircle(lineSet, centerPosition, outerPosition, segmentSize, lineColor = (0.3, 0.3, 0.3, 0.5), lineWeight = 2.0, animationSpeed = 0.0, dashSegments = 0, dashColor = None):
orbitPos = geo2.Vector(*outerPosition)
parentPos = geo2.Vector(*centerPosition)
dirVec = orbitPos - parentPos
radius = geo2.Vec3Length(dirVec)
fwdVec = (1.0, 0.0, 0.0)
dirVec = geo2.Vec3Normalize(dirVec)
rotation = geo2.QuaternionRotationArc(fwdVec, dirVec)
matrix = geo2.MatrixAffineTransformation(1.0, (0.0, 0.0, 0.0), rotation, centerPosition)
circum = math.pi * 2 * radius
steps = min(256, max(16, int(circum / segmentSize)))
coordinates = []
stepSize = math.pi * 2 / steps
for step in range(steps):
angle = step * stepSize
x = math.cos(angle) * radius
z = math.sin(angle) * radius
pos = geo2.Vector(x, 0.0, z)
pos = geo2.Vec3TransformCoord(pos, matrix)
coordinates.append(pos)
lineIDs = set()
dashColor = dashColor or lineColor
for start in xrange(steps):
end = (start + 1) % steps
lineID = lineSet.AddStraightLine(coordinates[start], lineColor, coordinates[end], lineColor, lineWeight)
lineIDs.add(lineID)
if dashSegments:
lineSet.ChangeLineAnimation(lineID, dashColor, animationSpeed, dashSegments)
return lineIDs
def _EnforceMaximumDistanceDetached(self):
dist = geo2.Vec3Length(self.eyePosition)
if dist > evecamera.LOOKATRANGE_MAX_NEW and not self.IsInTransit():
direction = geo2.Vec3Normalize(self.eyePosition)
newEye = geo2.Vec3Scale(direction, evecamera.LOOKATRANGE_MAX_NEW)
diff = geo2.Vec3Subtract(self.eyePosition, newEye)
self.SetEyePosition(newEye)
self.SetAtPosition(geo2.Vec3Subtract(self._atPosition, diff))
def _GetTrackAtOffset(self):
trackOffset = geo2.Vec3Subtract(self.GetTrackPosition(self.trackBall),
self._atPosition)
length = geo2.Vec3Length(trackOffset)
maxLen = 250000
if length > maxLen:
trackOffset = geo2.Vec3Scale(trackOffset, maxLen / length)
return trackOffset
def fset(self, rotationQuaternion):
rotationMatrix = geo2.MatrixRotationQuaternion(rotationQuaternion)
transformedVec = geo2.Vec3Transform((1.0, 0.0, 0.0),
rotationMatrix)
cameraDistance = geo2.Vec3Length(self._eyePositionCurrent)
self._eyePositionCurrent = geo2.Vec3Scale(transformedVec,
cameraDistance)
self._eyePosition = self._eyePositionCurrent
def Zoom(self, val):
"""
Move the camera towards the point of interest
val - the percentage of the distance between the camera and the target point
"""
dev = trinity.device
pos = self.GetPosition()
target = self.GetPointOfInterest()
view = geo2.Vec3Normalize(geo2.Subtract(pos, target))
length = geo2.Vec3Length(geo2.Subtract(pos, target))
nextPos = geo2.Vec3Add(pos, geo2.Vec3Scale(view, length * val))
nextLength = geo2.Vec3Length(geo2.Vec3Subtract(nextPos, target))
if nextLength < self.minZoomDistance:
nextPos = geo2.Vec3Add(target, geo2.Vec3Scale(view, self.minZoomDistance))
elif nextLength > self.maxZoomDistance:
nextPos = geo2.Vec3Add(target, geo2.Vec3Scale(view, self.maxZoomDistance))
self.SetPosition(nextPos)
def GetSpeedOffsetProportion(self):
speed = self.GetLookAtBallSpeed()
velocity = geo2.Vec3Length(speed)
if velocity <= 1.0:
return 0.0
elif velocity < MAX_SPEED_OFFSET_SPEED:
return math.log(velocity)**2 / MAX_SPEED_OFFSET_LOGSPEED
else:
return 1.0
def _GetViewAndProjectionUsingProjectedBoundingBox(
calculateProjectedBoundingBox,
scene=None,
boundingSphereRadius=None,
boundingSphereCenter=None,
boundingBoxMin=None,
boundingBoxMax=None,
cameraAngle=None):
"""
Fits an object in frame with view and projection matrices. We first do a rough fit
using either the bounding sphere or bounding box. We then "zoom in" to the point where
the projected bounding box fills 90% of the image.
"""
cameraAngle = cameraAngle or GETPHOTO_ANGLE
if boundingSphereRadius:
radius = boundingSphereRadius
center = boundingSphereCenter if boundingSphereCenter else (0.0, 0.0,
0.0)
else:
center = geo2.Vec3Add(boundingBoxMin, boundingBoxMax)
center = geo2.Vec3Scale(center, 0.5)
radius = geo2.Vec3Length(
geo2.Vec3Subtract(boundingBoxMax, boundingBoxMin))
dist = _SphericalFit(radius)
viewEyeAtUp = _GetViewMatrixFromAngle(cameraAngle, center, dist)
projTransform = geo2.MatrixPerspectiveFovRH(*GETPHOTO_PROJECTION)
viewTransform = geo2.MatrixLookAtRH(*viewEyeAtUp)
combinedTransform = viewTransform
combinedTransform = geo2.MatrixMultiply(combinedTransform, projTransform)
safeMin, safeMax = calculateProjectedBoundingBox(combinedTransform)
deltaX = safeMax[0] - safeMin[0]
deltaY = safeMax[1] - safeMin[1]
scalingFactor = 0.9 * (2.0 / max(deltaX, deltaY))
try:
if scene.backgroundEffect is not None:
params = scene.backgroundEffect.Find(['trinity.Tr2FloatParameter'])
for param in params:
if param.name == 'ProjectionScaling':
param.value = scalingFactor
except AttributeError:
pass
offsetX = -1 * scalingFactor * (safeMin[0] + safeMax[0]) / 2.0
offsetY = -1 * scalingFactor * (safeMin[1] + safeMax[1]) / 2.0
scale = 1.0 / tan(GETPHOTO_FOV / 2.0) * scalingFactor
zn = 1.0
zf = dist + radius * 2
t = zn * (1 - offsetY) / scale
b = -t * (1 + offsetY) / (1 - offsetY)
r = zn * (1 - offsetX) / scale
l = -r * (1 + offsetX) / (1 - offsetX)
projection = trinity.TriProjection()
projection.PerspectiveOffCenter(l, r, b, t, zn, zf)
view = trinity.TriView()
view.SetLookAtPosition(*viewEyeAtUp)
return (view, projection)
def GetTrackingAtPosition(self):
ballPos = GetBallPosition(self.trackBall)
if geo2.Vec3Length(ballPos) > evecamera.LOOKATRANGE_MAX_NEW:
direction = geo2.Vec3Normalize(
geo2.Vec3Subtract(ballPos, self.eyePosition))
ballPos = geo2.Vec3Add(
self.eyePosition,
geo2.Vec3Scale(direction, evecamera.LOOKATRANGE_MAX_NEW))
return self.trackBallMorpher.GetValue(self.atPosition, ballPos)
def CheckStaticStateOK(self, staticIndex, destYaw):
staticState = self.metaState[const.movement.METASTATE_STATIC_STATES][staticIndex]
camOffset = staticState.get(const.movement.STATICSTATE_CAMERAOFFSET, 0.0) * math.pi / 180.0
destYaw = destYaw + camOffset
heading = staticState[const.movement.STATICSTATE_HEADING]
if geo2.Vec3Length(heading):
if self.NewDirectionObstacleCheck(destYaw, heading):
staticIndex = self.GetDesiredState(0, 0, 0)
return staticIndex
def Update(self):
speedFactor = 0.2
diff = geo2.Vec3Subtract(self.pointOfInterest, self._pointOfInterestCurrent)
diffLength = geo2.Vec3Length(diff)
if diffLength > 0.001:
self._pointOfInterestCurrent = geo2.Vec3Add(self._pointOfInterestCurrent, geo2.Vec3Scale(diff, speedFactor))
else:
self._pointOfInterestCurrent = self.pointOfInterest
if abs(self._yawSpeed) > 0.0001:
yawChange = self._yawSpeed * speedFactor
rotYaw = geo2.MatrixRotationAxis(self.upVector, yawChange)
self._eyePositionCurrent = geo2.Vec3Transform(self._eyePositionCurrent, rotYaw)
self._yawSpeed -= yawChange
else:
self._yawSpeed = 0.0
if abs(self._pitchSpeed) > 0.0001:
pitchChange = self._pitchSpeed * speedFactor
viewVectorNormalized = geo2.Vec3Normalize(self._eyePositionCurrent)
axis = geo2.Vec3Cross(viewVectorNormalized, self.upVector)
rotPitch = geo2.MatrixRotationAxis(axis, pitchChange)
self._eyePositionCurrent = geo2.Vec3Transform(self._eyePositionCurrent, rotPitch)
self._pitchSpeed -= pitchChange
else:
self._pitchSpeed = 0.0
if self._panSpeed:
panDistance = geo2.Vec3Length(self._panSpeed)
if panDistance > 0.001:
toMove = geo2.Vec3Scale(self._panSpeed, 0.95)
self.pointOfInterest = geo2.Add(self.pointOfInterest, toMove)
self._panSpeed -= toMove
else:
self._panSpeed = None
cameraDistance = self.GetZoomDistance()
cameraDistanceDiff = self._translationFromPOI - cameraDistance
if math.fabs(cameraDistanceDiff) > 0.001:
usedDist = cameraDistanceDiff * 0.1
viewVectorNormalized = geo2.Vec3Normalize(self._eyePositionCurrent)
newDistance = min(self.maxDistance, max(self.minDistance, cameraDistance + usedDist))
self._eyePositionCurrent = geo2.Vec3Scale(viewVectorNormalized, newDistance)
self.translationFromParent = newDistance
self.UpdateProjection()
self.UpdateView()
if self.callback:
self.callback()
def CheckForStop(self, heading):
"""
if the player is going to stop we want to delay a fraction in case they press a
new key, if that happens then we want to change to the new direction and stop
the timer
"""
returnValue = heading
headingLength = geo2.Vec3Length(heading)
if not self.delayTimerActive and headingLength < const.FLOAT_TOLERANCE and geo2.Vec3Length(self.lastHeading) > 0:
returnValue = self.lastHeading
self.StartStopDelayTimer()
if self.delayTimerActive and self.delayTimerEnd > blue.os.GetWallclockTime():
if headingLength < const.FLOAT_TOLERANCE:
returnValue = self.lastHeading
else:
self.StopStopDelayTimer()
if self.delayTimerActive and self.delayTimerEnd <= blue.os.GetWallclockTime():
self.StopStopDelayTimer()
return returnValue
def PlerpVec3(self, start, end, timeLeft):
doneSoFar = LERP_TIME - timeLeft
percDone = doneSoFar / LERP_TIME
if percDone > 1.0:
return end
percToEnd = math.sin(percDone * math.pi - math.pi / 2.0) / 2.0 + 0.5
distance = geo2.Vec3Length(geo2.Vec3Subtract(end, start)) * percToEnd
vector = geo2.Vec3Normalize(geo2.Vec3Subtract(end, start))
currPoint = geo2.Vec3Add(start, (val * distance for val in vector))
return currPoint
