def ProcessCameraUpdate(self, camera, now, frameTime):
if not self.smoothBehindEnabled:
return
self.camera = camera
self.frameTime = frameTime
if self.entity is None:
self.entity = self._GetEntity(self.charEntID)
if self.entity is None:
raise RuntimeError("Problem retrieving the avatar's entity. cameras.CameraBehavior._GetEntity returned None for entityID", self.charEntID)
if self.model is None:
self.model = self._GetEntityModel(self.charEntID)
if self.model is None:
raise RuntimeError("Problem retrieving the avatar's model object. entityClient.FindEntityByID returned None for entityID", self.charEntID)
if not camera.mouseLeftButtonDown and not camera.mouseRightButtonDown:
avatarHasMoved = geo2.Vec3Distance(self.model.translation, self.lastAvatarPosition) > const.FLOAT_TOLERANCE
avatarHasRotated = geo2.Vec3Distance(geo2.QuaternionRotationGetYawPitchRoll(self.model.rotation), self.lastAvatarRotation) > const.FLOAT_TOLERANCE
movementDetected = avatarHasMoved or avatarHasRotated
self.lastAvatarPosition = self.model.translation
self.lastAvatarRotation = geo2.QuaternionRotationGetYawPitchRoll(self.model.rotation)
if movementDetected:
self.rotationSpeed = cameras.SMOOTH_BEHIND_ANIMATION_SPEED_REALLY_FAST
else:
self.rotationSpeed = cameras.SMOOTH_BEHIND_ANIMATION_SPEED
if self.enableTriggerableSmoothBehind:
if movementDetected:
self.smoothBehind = True
else:
self.smoothBehind = True
else:
self.smoothBehind = False
if self.smoothBehind:
self.SmoothBehind()
def UpdateMyLocation(self):
if not uiutil.IsUnder(self, uicore.desktop):
return
bp = sm.GetService('michelle').GetBallpark()
if bp is None or self is None or self.destroyed:
self.updatemylocationtimer = None
return
myball = bp.GetBall(eve.session.shipid)
if myball is None:
self.updatemylocationtimer = None
return
size = max(1, self.absoluteRight - self.absoluteLeft)
if size == 1:
size = max(1, self.absoluteRight - self.absoluteLeft)
x = y = None
if self.allowAbstract and settings.user.ui.Get('solarsystemmapabstract', 0):
if not len(self.orbs):
return
x, y = self.GetAbstractPosition((myball.x, 0.0, myball.z), 1)
elif self.sr.sizefactor is not None and self.sr.sizefactorsize is not None:
maxdist = self.GetMaxDist()
sizefactor = size / 2 / maxdist * self.fillSize
x = FLIPMAP * myball.x * sizefactor / float(size) + 0.5
y = -(myball.z * sizefactor) / float(size) + 0.5
if x is not None and y is not None:
self.imhere.sr.x = x
self.imhere.sr.y = y
self.imhere.state = uiconst.UI_DISABLED
scene = sm.GetService('sceneManager').GetRegisteredScene('default')
camera = sm.GetService('sceneManager').GetRegisteredCamera('default')
if camera is None:
return
rot = geo2.QuaternionRotationGetYawPitchRoll(camera.rotationAroundParent)
look = geo2.QuaternionRotationGetYawPitchRoll(camera.rotationOfInterest)
if not self.fov:
self.fov = Fov(parent=self.imhere)
self.fov.SetRotation(rot[0] + look[0] - pi)
actualfov = camera.fieldOfView * (uicore.desktop.width / float(uicore.desktop.height))
degfov = actualfov - pi / 2
self.fov.SetFovAngle(actualfov)
if self.showingtempangle:
if not self.tempAngleFov:
self.tempAngleFov = Fov(parent=self.imhere, state=uiconst.UI_DISABLED, blendMode=trinity.TR2_SBM_ADDX2)
self.tempAngleFov.SetColor((0.0, 0.3, 0.0, 1.0))
self.tempAngleFov.display = True
self.tempAngleFov.SetRotation(rot[0] + look[0] - pi)
angle = self.showingtempangle
self.tempAngleFov.SetFovAngle(angle)
elif self.tempAngleFov:
self.tempAngleFov.display = False
self.RefreshOverlays()
def _ChooseSpawnLocation(self, worldspaceID, sessionChanges={}):
searchTerm = None
if 'charid' in sessionChanges and sessionChanges['charid'][0] == None:
searchTerm = const.cef.CQ_NEWBIE_SPAWN
elif 'stationid' in sessionChanges and sessionChanges['stationid'][
0] == None:
searchTerm = const.cef.CQ_BALCONY_SPAWN
else:
searchTerm = const.cef.CQ_BEDROOM_SPAWN
if searchTerm is not None:
spawnLocators = sm.GetService(
'spawnLocationClient').GetSpawnLocationsBySceneID(worldspaceID)
for locator in spawnLocators:
spawnLocationComponent = locator.GetComponent('spawnLocation')
locationType = spawnLocationComponent.spawnLocationType
if locationType == searchTerm:
self.cameraClient.RegisterCameraStartupInfo(
spawnLocationComponent.cameraYaw,
spawnLocationComponent.cameraPitch,
spawnLocationComponent.cameraZoom)
spawnPoint = locator.GetComponent('position').position
xyzRot = locator.GetComponent('position').rotation
spawnRot = geo2.QuaternionRotationGetYawPitchRoll(xyzRot)
return (spawnPoint, spawnRot)
self.LogWarn('Failed to find the locator:', searchTerm)
spawnPoint, spawnRot = sm.GetService(
'worldSpaceClient').GetWorldSpaceSafeSpot(session.worldspaceid)
self.LogWarn(
"Spawn point search term was None which means we don't have a defined spawn",
'location and will revert to the default safe spot')
return (spawnPoint, spawnRot)
def NewDirectionObstacleCheck(self, destYaw, heading):
"""
Calculates the direction we want to move in, performs a raycast to a specified length.
The compares the collision normal if there is one with the direction vector to determine if angle between them
is such where we will allow the character to walk and graze the wall.
"""
entity = self.entityClient.GetPlayerEntity()
gw = GameWorld.Manager.GetGameWorld(long(entity.scene.sceneID))
posComp = entity.GetComponent('position')
movComp = entity.GetComponent('movement')
start = posComp.position
start = geo2.Vec3Add(
start, (0.0, self.AVATAR_COLLISION_DETECTION_CAPSULE_HEIGHT_MOD *
movComp.characterController.height, 0.0))
yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(
posComp.rotation)
direction = geo2.QuaternionRotationSetYawPitchRoll(yaw + destYaw, 0, 0)
end = heading
end = geo2.QuaternionTransformVector(direction, end)
direction = end = geo2.Vec3Scale(
end, self.AVATAR_COLLISION_DETECTION_FEELER_LENGTH)
end = geo2.Vec3Add(end, start)
hitResult = gw.SweptSphere(
start, end, self.AVATAR_COLLISION_DETECTION_FEELER_RADIUS)
result = False
if hitResult:
dotProduct = geo2.Vec3Dot(direction, hitResult[1])
if abs(dotProduct) > self.AVATAR_COLLISION_RESTRICTION_ANGLE_DP:
result = True
return result
def NewDirectionObstacleCheck(self, destYaw, heading):
entity = self.entityClient.GetPlayerEntity()
gw = GameWorld.Manager.GetGameWorld(long(entity.scene.sceneID))
posComp = entity.GetComponent('position')
movComp = entity.GetComponent('movement')
start = posComp.position
start = geo2.Vec3Add(
start, (0.0, self.AVATAR_COLLISION_DETECTION_CAPSULE_HEIGHT_MOD *
movComp.characterController.height, 0.0))
yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(
posComp.rotation)
direction = geo2.QuaternionRotationSetYawPitchRoll(yaw + destYaw, 0, 0)
end = heading
end = geo2.QuaternionTransformVector(direction, end)
direction = end = geo2.Vec3Scale(
end, self.AVATAR_COLLISION_DETECTION_FEELER_LENGTH)
end = geo2.Vec3Add(end, start)
hitResult = gw.SweptSphere(
start, end, self.AVATAR_COLLISION_DETECTION_FEELER_RADIUS)
result = False
if hitResult:
dotProduct = geo2.Vec3Dot(direction, hitResult[1])
if abs(dotProduct) > self.AVATAR_COLLISION_RESTRICTION_ANGLE_DP:
result = True
return result
def GetYawPitch(self):
rotMatrix = geo2.MatrixTranspose(self.viewMatrix.transform)
quat = geo2.QuaternionRotationMatrix(rotMatrix)
yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(quat)
yaw = math.pi / 2 - yaw
pitch = math.pi / 2 - pitch
return (yaw, pitch)
def SetIntendedState(self, xInput, zInput, mbMove, runToggle, facingYaw):
ent = self.entityClient.GetPlayerEntity()
mode = ent.GetComponent('movement').moveModeManager.GetCurrentMode()
metaStateIndex = self.movementStates.FindCurrentMetaState(ent)
if metaStateIndex >= 0:
self.metaState = self.movementStates.metaStates[metaStateIndex]
else:
self.metaState = None
if self.metaState is not None:
lastYaw, trash, trash = geo2.QuaternionRotationGetYawPitchRoll(
ent.GetComponent('position').rotation)
baseSpeed = self.metaState.get(const.movement.METASTATE_BASE_SPEED,
0.0)
if not self.metaState.get(
const.movement.METASTATE_DISABLE_RUN_TOGGLE, False):
self.runToggle = runToggle
if self.runToggle:
baseSpeed *= self.metaState.get(
const.movement.METASTATE_RUNNING_MOD, 1.0)
animState = self.GetDesiredState(xInput, zInput, mbMove)
animState = self.CheckStaticStateOK(animState, facingYaw - lastYaw)
if animState is not None:
if hasattr(mode, 'CheckNewSetStaticState'):
mode.CheckNewSetStaticState(metaStateIndex, animState,
baseSpeed, facingYaw - lastYaw)
return
if hasattr(mode, 'SetMetaState'):
mode.SetMetaState(metaStateIndex, baseSpeed)
def _SaveBall(self, ballID, michelle):
try:
slimItem = michelle.GetItem(ballID)
if not slimItem:
return
objectID = slimItem.dunObjectID
if self.unsavedChanges[
ballID] & dungeonEditorTools.CHANGE_TRANSLATION:
dungeonHelper.SaveObjectPosition(objectID, slimItem.dunX,
slimItem.dunY, slimItem.dunZ)
if self.unsavedChanges[ballID] & dungeonEditorTools.CHANGE_SCALE:
dungeonHelper.SaveObjectRadius(objectID, slimItem.dunRadius)
targetBall = michelle.GetBall(slimItem.itemID)
targetModel = getattr(targetBall, 'model', None)
if not targetModel and not self.unsavedChanges[
ballID] & dungeonEditorTools.CHANGE_TRANSLATION | dungeonEditorTools.CHANGE_SCALE:
del self.lockedObjects[objectID]
if targetModel and self.unsavedChanges[
ballID] & dungeonEditorTools.CHANGE_ROTATION:
quat = targetModel.rotationCurve.value
yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(quat)
yaw = yaw / math.pi * 180.0
pitch = pitch / math.pi * 180.0
roll = roll / math.pi * 180.0
dungeonHelper.SaveObjectRotation(objectID, yaw, pitch, roll)
finally:
del self.unsavedChanges[ballID]
del self.unsavedTime[ballID]
def AdjustYaw(self, delta):
if self.controlStyle == CONTROL_NONE:
return
if self._rotateAvatar:
delta = min(35.0, max(-35.0, delta)) * 0.005
yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(
self.avatar.rotation)
yaw = yaw + delta
if self.maxRotation is not None and self.minRotation is not None:
if yaw < math.pi:
yaw = min(yaw, self.minRotation)
else:
yaw = max(yaw, self.maxRotation)
rotation = geo2.QuaternionRotationSetYawPitchRoll(yaw, pitch, roll)
self.avatar.rotation = rotation
charSvc = sm.GetService('character')
if uiutil.GetAttrs(charSvc, 'sculpting', 'highlightGhost',
'avatar'):
charSvc.sculpting.highlightGhost.avatar.rotation = rotation
if uiutil.GetAttrs(charSvc, 'sculpting', 'bodyHighlightGhost',
'avatar'):
charSvc.sculpting.bodyHighlightGhost.avatar.rotation = rotation
self.Update()
else:
cameras.PolarCamera.AdjustYaw(self, delta * 0.005)
def _AutoOrbit(self, surfacePoint, newZoom, time):
cam = self.camera
self.cameraAuto = True
tMax = time
t = 0.0
zoomInit = self.zoom
spTheta = -surfacePoint.theta + math.pi / 2.0
if spTheta < 0.0:
spTheta += 2 * math.pi
spPhi = surfacePoint.phi - math.pi / 2
camTheta, camPhi, roll = geo2.QuaternionRotationGetYawPitchRoll(
self.camera.rotationAroundParent)
if math.fabs(camTheta - spTheta) > math.pi:
if camTheta > spTheta:
camTheta -= 2 * math.pi
else:
spTheta -= 2 * math.pi
while self.cameraAuto and t < tMax:
elapsed = 1.0 / blue.os.fps
t += elapsed
if newZoom is not None:
currZoom = self.GetSplineValue(t, tMax, zoomInit, newZoom)
self.ApplyZoom(currZoom)
newTh = self.GetSplineValue(t, tMax, camTheta, spTheta)
newPhi = self.GetSplineValue(t, tMax, camPhi - self.pitchDiff,
spPhi + self.pitchDiff)
cam.SetOrbit(newTh, newPhi + self.pitchDiff)
blue.pyos.synchro.Yield()
def DecomposeMatrix(matrix):
if hasattr(matrix,
'__bluetype__') and matrix.__bluetype__ == 'trinity.TriMatrix':
matrix = util.ConvertTriToTupleMatrix(matrix)
scale, rot, pos = geo2.MatrixDecompose(matrix)
rot = geo2.QuaternionRotationGetYawPitchRoll(rot)
return (pos, rot, scale)
def GetUprightCapsulePosAndRot(curPos, curRot, floorHeight):
yaw, trash, trash = geo2.QuaternionRotationGetYawPitchRoll(curRot)
rot = geo2.QuaternionRotationSetYawPitchRoll(yaw, 0, 0)
pos = geo2.Vector(*curPos)
adjustment = geo2.QuaternionTransformVector(curRot, adjustment)
pos = pos + adjustment
pos.y = floorHeight
return (pos, rot)
def SetupComponent(self, entity, component):
positionComponent = entity.GetComponent('position')
if positionComponent:
component.renderObject.position = positionComponent.position
if hasattr(component.renderObject, 'SetRotationYawPitchRoll'):
component.renderObject.SetRotationYawPitchRoll(geo2.QuaternionRotationGetYawPitchRoll(positionComponent.rotation))
self.ApplyShadowCasterType(entity)
self.ApplyPerformanceLevelLightDisable(entity)
def GetMaxLookAtWeight_Facing(ent, targetPos):
sourcePos = ent.GetComponent('position').position
sourceRot = ent.GetComponent('position').rotation
source2Target = geo2.Vec3Subtract(targetPos, sourcePos)
source2Target = geo2.Vec3Normalize(source2Target)
facingDir = mathCommon.CreateDirectionVectorFromYawAngle(geo2.QuaternionRotationGetYawPitchRoll(sourceRot)[0])
dot = geo2.Vec3Dot(source2Target, facingDir)
return max(dot, 0)
def SetupComponent(self, entity, component):
positionComponent = entity.GetComponent('position')
if positionComponent:
component.renderObject.SetPosition(positionComponent.position)
if hasattr(component.renderObject, 'SetRotationYawPitchRoll'):
component.renderObject.SetRotationYawPitchRoll(
geo2.QuaternionRotationGetYawPitchRoll(
positionComponent.rotation))
def GetNewQuatToFacePos(sourcePos, sourceRot, targetPos):
"""
Get the Quaternion needed to face a target position given a source position/rotation.
"""
deltaAngle = GetDeltaAngleToFaceTarget(sourcePos, sourceRot, targetPos)
yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(sourceRot)
yaw += deltaAngle
return geo2.QuaternionRotationSetYawPitchRoll(yaw, pitch, roll)
def GetDeltaAngleToFaceTarget(sourcePos, sourceRot, targetPos):
"""
Calculates the change in yaw angle necessary to face the targetPos given your sourcePos and your current rotation (sourceRot)
"""
targetVec = geo2.Vec3Subtract(targetPos, sourcePos)
theta = GetYawAngleFromDirectionVector(targetVec)
yaw, trash, trash = geo2.QuaternionRotationGetYawPitchRoll(sourceRot)
return GetLesserAngleBetweenYaws(yaw, theta)
def GetObjectRotation(objectID):
scenario = sm.StartService('scenario')
targetBall, slimItem = scenario.GetBallAndSlimItemFromObjectID(objectID)
if slimItem is None:
raise RuntimeError('No slim item?')
targetModel = getattr(targetBall, 'model', None)
if not targetModel or not targetModel.rotationCurve or not hasattr(targetModel.rotationCurve, 'value'):
return (None, None, None)
return (x * 180.0 / math.pi for x in geo2.QuaternionRotationGetYawPitchRoll(targetModel.rotationCurve.value))
def GetRelativeLookAtVector(sourcePosition, sourceRotation, targetPosition):
lookAtVector = geo2.Vec3Subtract(targetPosition, sourcePosition)
yaw, trash, trash = geo2.QuaternionRotationGetYawPitchRoll(sourceRotation)
yaw = -yaw
relativeLookAtVector = (lookAtVector[0] * math.cos(yaw) +
lookAtVector[2] * math.sin(yaw), lookAtVector[1],
-lookAtVector[0] * math.sin(yaw) +
lookAtVector[2] * math.cos(yaw))
return relativeLookAtVector
def RecreatePlayerMovement(self):
"""
Decides local heading values from given input; also switches from pathin to kb
move mode if needed.
"""
heading = [0, 0, 0]
if self.navKeys is None:
self.PrimeNavKeys()
if self.inputMap is None:
self.inputMap = EveInputMap()
if getattr(self, '_delayedMouseUpStillPending', False):
return
player = self.entityClient.GetPlayerEntity()
if player:
isPathing = isinstance(player.movement.moveModeManager.GetCurrentMode(), GameWorld.PathToMode)
if self.HasControl() and trinity.app.IsActive() and player.movement.moveModeManager.allowedToMove:
curKeyState = self.GetKeyState()
fwdActive, backActive, moveLActive, moveRActive = curKeyState
isKeyPressed = fwdActive or backActive or moveLActive or moveRActive
isMouseDriving = self.leftMouseDown and self.rightMouseDown
if isKeyPressed or isMouseDriving:
if isPathing:
player.movement.moveModeManager.PushMoveMode(GameWorld.PlayerInputMode())
isPathing = False
if self.aoClient.IsEntityUsingActionObject(player.entityID):
self.aoClient.ExitActionObject(player.entityID)
return
heading[1] = 0.0
heading[2] = 0.0
if backActive and fwdActive and self.lastForwardBackward == const.MOVDIR_BACKWARD or backActive and not fwdActive:
heading[2] = -1.0
elif fwdActive or isMouseDriving:
heading[2] = 1.0
heading[0] = 0.0
if moveLActive and moveRActive and self.lastLeftRight == const.MOVDIR_LEFT or moveLActive and not moveRActive:
heading[0] = 1.0
elif moveRActive:
heading[0] = -1.0
if not isPathing:
heading = self.CheckForStop(heading)
mode = player.movement.moveModeManager.GetCurrentMode()
cc = sm.GetService('cameraClient')
cameraOrbitMode = self.rightMouseDown and not self.leftMouseDown
if cameraOrbitMode:
yawValue, trash, trash = geo2.QuaternionRotationGetYawPitchRoll(player.GetComponent('position').rotation)
moving = 1 if heading[2] == 1 else 0
self.inputMap.SetIntendedState(0, moving, 0, False, yawValue)
else:
yawValue = -math.pi / 2.0 - cc.GetActiveCamera().yaw
self.inputMap.SetIntendedState(heading[0], heading[2], int(isMouseDriving), False, yawValue)
if hasattr(mode, 'SetDynamicState'):
if heading[0] != 0 or heading[2] != 0:
mode.SetDynamicState(yawValue)
elif not isPathing:
self.inputMap.SetIntendedState(0, 0, 0, 0, 0)
self.lastHeading = heading
def GetEntityYaw(entity):
entityRot = entity.GetComponent('position').rotation
yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(entityRot)
yaw += math.pi / 2
if yaw > 2.0 * math.pi:
yaw = yaw - 2.0 * math.pi
elif yaw < 0.0:
yaw = yaw + 2.0 * math.pi
if yaw <= math.pi:
return math.pi - yaw
else:
return -(yaw - math.pi)
def PointToYawPitchDist(self, pos):
upVector = (0, 1, 0)
if trinity.IsRightHanded():
rotMatrix = geo2.MatrixLookAtRH(pos, self.poi, upVector)
else:
rotMatrix = geo2.MatrixLookAtLH(pos, self.poi, upVector)
rotMatrix = geo2.MatrixTranspose(rotMatrix)
quat = geo2.QuaternionRotationMatrix(rotMatrix)
yaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(quat)
yaw = math.pi / 2 - yaw
pitch = math.pi / 2 - pitch
return (yaw, pitch, geo2.Vec3Distance(pos, self.poi))
def AlignSpaceCameraToViewVector(self, viewVector, duration = None, callback = None, sleep = False):
rotation = geo2.QuaternionRotationArc((0, 0, 1), viewVector)
y, p, r = geo2.QuaternionRotationGetYawPitchRoll(rotation)
if duration:
currentYaw, currentPitch = self.spaceCameraOrbit
yawDiff = GetLesserAngleBetweenYaws(currentYaw, y)
pitchDiff = GetLesserAngleBetweenYaws(currentPitch, p)
endVal = (currentYaw + yawDiff, currentPitch + pitchDiff)
uicore.animations.MorphVector2(self, 'spaceCameraOrbit', startVal=(currentYaw, currentPitch), endVal=endVal, duration=duration, callback=callback, sleep=sleep)
else:
uicore.animations.StopAnimation(self, 'spaceCameraOrbit')
self.spaceCameraOrbit = (y, p)
def SetupComponent(self, entity, component):
"""
Gets called once all components have been prepared.
Use this to setup stuff which references other components
"""
positionComponent = entity.GetComponent('position')
if positionComponent:
component.renderObject.SetPosition(positionComponent.position)
if hasattr(component.renderObject, 'SetRotationYawPitchRoll'):
component.renderObject.SetRotationYawPitchRoll(
geo2.QuaternionRotationGetYawPitchRoll(
positionComponent.rotation))
def GetSynchedAnimStartLocation(sourcePos, sourceRot, targetPos, targetRot, animInfo):
relVec = geo2.Vec3Subtract(sourcePos, targetPos)
curDist = geo2.Vec3Length(relVec)
if curDist <= 0.01:
sourcePos = geo2.Vec3Add(targetPos, (0, 0, -1))
relVec = geo2.Vec3Subtract(sourcePos, targetPos)
entName = const.animation.ATTACKER_NAME
if entName in animInfo and const.animation.METADATA_TURN_TO_FACE in animInfo[entName] and animInfo[entName][const.animation.METADATA_TURN_TO_FACE] == False:
newSourceRot = sourceRot
else:
newSourceRot = GetQuatFromDirection(sourcePos, targetPos)
entName = const.animation.VICTIM_NAME
if entName in animInfo and const.animation.METADATA_TURN_TO_FACE in animInfo[entName] and animInfo[entName][const.animation.METADATA_TURN_TO_FACE] == False:
newTargetRot = targetRot
newTargetYaw, trash, trash = geo2.QuaternionRotationGetYawPitchRoll(targetRot)
else:
newTargetRot = GetQuatFromDirection(targetPos, sourcePos)
if entName in animInfo and const.animation.METADATA_START_OFFSET_YAW in animInfo[entName]:
degrees = animInfo[entName][const.animation.METADATA_START_OFFSET_YAW]
offsetYaw = math.pi * -degrees / 180.0
offsetRot = geo2.QuaternionRotationSetYawPitchRoll(offsetYaw, 0.0, 0.0)
newTargetRot = geo2.QuaternionMultiply(newTargetRot, offsetRot)
distance = 0.5
if const.animation.METADATA_START_DISTANCE in animInfo:
distance = animInfo[const.animation.METADATA_START_DISTANCE]
entName = const.animation.VICTIM_NAME
if entName in animInfo and const.animation.METADATA_START_OFFSET_YAW in animInfo[entName]:
if '/righthanded' in blue.pyos.GetArg():
front = (0, 0, distance)
else:
front = (0, 0, -distance)
degrees = animInfo[entName][const.animation.METADATA_START_OFFSET_YAW]
radians = math.pi * degrees / 180.0
offsetRot = geo2.QuaternionRotationSetYawPitchRoll(radians, 0.0, 0.0)
yawOffsetQuat = geo2.QuaternionMultiply(newTargetRot, offsetRot)
radOffset = geo2.QuaternionTransformVector(yawOffsetQuat, front)
newSourcePos = geo2.Vec3Add(targetPos, radOffset)
newSourceRot = GetQuatFromDirection(newSourcePos, targetPos)
else:
direction = geo2.Vec3Normalize(relVec)
newSourcePos = geo2.Vec3Add(targetPos, (distance * direction[0], distance * direction[1], distance * direction[2]))
entName = const.animation.ATTACKER_NAME
if entName in animInfo and const.animation.METADATA_START_OFFSET_YAW in animInfo[entName]:
degrees = animInfo[entName][const.animation.METADATA_START_OFFSET_YAW]
radians = math.pi * -degrees / 180.0
offsetRot = geo2.QuaternionRotationSetYawPitchRoll(radians, 0.0, 0.0)
newSourceRot = geo2.QuaternionMultiply(newSourceRot, offsetRot)
return (newSourcePos,
newSourceRot,
targetPos,
newTargetRot)
def RotateSelected(self, yaw, pitch, roll):
slimItems = self.GetSelObjects()
if len(slimItems) == 0:
return
yawRad = yaw / 180.0 * math.pi
pitchRad = pitch / 180.0 * math.pi
rollRad = roll / 180.0 * math.pi
rotationToAdd = geo2.QuaternionRotationSetYawPitchRoll(
yawRad, pitchRad, rollRad)
posCtr = geo2.VectorD(0, 0, 0)
for slimItem in slimItems:
posCtr += geo2.VectorD(slimItem.dunX, slimItem.dunY, slimItem.dunZ)
geo2.Scale(posCtr, 1.0 / len(slimItems))
for slimItem in slimItems:
rot = getattr(slimItem, 'dunRotation', None)
slimItemRotation = geo2.QuaternionIdentity()
if rot is not None:
yaw, pitch, roll = rot
slimItemRotation = geo2.QuaternionRotationSetYawPitchRoll(
yaw / 180.0 * math.pi, pitch / 180.0 * math.pi,
roll / 180.0 * math.pi)
y, p, r = geo2.QuaternionRotationGetYawPitchRoll(slimItemRotation)
slimItemRotation = geo2.QuaternionMultiply(rotationToAdd,
slimItemRotation)
y, p, r = geo2.QuaternionRotationGetYawPitchRoll(slimItemRotation)
y = y / math.pi * 180.0
p = p / math.pi * 180.0
r = r / math.pi * 180.0
translation = geo2.VectorD(slimItem.dunX, slimItem.dunY,
slimItem.dunZ)
translation -= posCtr
geo2.QuaternionTransformVector(rotationToAdd, translation)
translation += posCtr
dungeonHelper.SetObjectPosition(slimItem.dunObjectID,
translation.x, translation.y,
translation.z)
dungeonHelper.SetObjectRotation(slimItem.dunObjectID, y, p, r)
def CameraMove_thread(self):
try:
camera = self.GetCamera()
lastYawRad, _, _ = geo2.QuaternionRotationGetYawPitchRoll(
camera.GetRotationQuat())
radDelta = 0
while self.cameraStillSpinning:
blue.pyos.synchro.Yield()
if self.mouseDownPos is None or camera is None:
self.cameraStillSpinning = False
return
curYaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(
camera.GetRotationQuat())
angleBtwYaws = mathCommon.GetLesserAngleBetweenYaws(
lastYawRad, curYaw)
radDelta += angleBtwYaws
lastYawRad = curYaw
if abs(radDelta) > math.pi / 2:
sm.ScatterEvent('OnClientMouseSpinInSpace')
return
except Exception as e:
LogException(e)
def _PollCamera(self):
cameraStillSpinning = True
while cameraStillSpinning:
blue.pyos.synchro.Yield()
if self.camera is None:
cameraStillSpinning = False
break
curYaw, pitch, roll = geo2.QuaternionRotationGetYawPitchRoll(
self.camera.rotationAroundParent)
cameraStillSpinning = self._IsCameraSpinning(curYaw)
if cameraStillSpinning:
self._CountRotations(curYaw)
self.spinThread = None
def SetupComponent(self, entity, component):
positionComponent = entity.GetComponent('position')
if positionComponent:
component.renderObject.SetPosition(positionComponent.position)
if hasattr(component.renderObject, 'SetRotationYawPitchRoll'):
component.renderObject.SetRotationYawPitchRoll(
geo2.QuaternionRotationGetYawPitchRoll(
positionComponent.rotation))
scene = self.graphicClient.GetScene(entity.scene.sceneID)
cells = scene.cells
if component.cellA and component.cellB:
cellAObj = scene._GetCell(component.cellA)
cellBObj = scene._GetCell(component.cellB)
component.renderObject.ConnectCells(cellAObj, cellBObj)
def GetTargetPlaneNormal(self, ray):
if self.activeManipAxis in ('y', ):
camera = sm.GetService('sceneManager').GetRegisteredCamera(
'systemmap')
y, p, r = geo2.QuaternionRotationGetYawPitchRoll(
camera.rotationAroundParent)
q = geo2.QuaternionRotationSetYawPitchRoll(y, 0.0, 0.0)
return geo2.QuaternionTransformVector(q, (0.0, 0.0, 1.0))
elif self.activeManipAxis in ('x', 'z', 'xz'):
return Y_AXIS
elif self.activeManipAxis in ('y', 'xy'):
return Z_AXIS
else:
return X_AXIS