def AlignToDirection(self): destination = sm.StartService('space').warpDestinationCache[3] ballPark = sm.StartService('michelle').GetBallpark() egoball = ballPark.GetBall(ballPark.ego) direction = [ egoball.x - destination[0], egoball.y - destination[1], egoball.z - destination[2] ] zaxis = direction if geo2.Vec3LengthSqD(zaxis) > 0.0: zaxis = geo2.Vec3NormalizeD(zaxis) xaxis = geo2.Vec3CrossD((0, 1, 0), zaxis) if geo2.Vec3LengthSqD(xaxis) == 0.0: zaxis = geo2.Vec3AddD(zaxis, mathCommon.RandomVector(0.0001)) zaxis = geo2.Vec3NormalizeD(zaxis) xaxis = geo2.Vec3CrossD((0, 1, 0), zaxis) xaxis = geo2.Vec3NormalizeD(xaxis) yaxis = geo2.Vec3CrossD(zaxis, xaxis) else: self.transformFlags = effectconsts.FX_TF_POSITION_BALL | effectconsts.FX_TF_ROTATION_BALL self.Prepare() return mat = ((xaxis[0], xaxis[1], xaxis[2], 0.0), (yaxis[0], yaxis[1], yaxis[2], 0.0), (zaxis[0], zaxis[1], zaxis[2], 0.0), (0.0, 0.0, 0.0, 1.0)) quat = geo2.QuaternionRotationMatrix(mat) self.gfxModel.rotationCurve = None if self.gfxModel and hasattr(self.gfxModel, 'modelRotationCurve'): self.gfxModel.modelRotationCurve = trinity.TriRotationCurve( 0.0, 0.0, 0.0, 1.0) self.gfxModel.modelRotationCurve.value = quat self.debugAligned = True
def AlignToDirection(self, direction): """Align the space object to a direction.""" if not self.model: return zaxis = direction if geo2.Vec3LengthSqD(zaxis) > 0.0: zaxis = geo2.Vec3NormalizeD(zaxis) xaxis = geo2.Vec3CrossD(zaxis, (0, 1, 0)) if geo2.Vec3LengthSqD(xaxis) == 0.0: zaxis = geo2.Vec3AddD(zaxis, mathCommon.RandomVector(0.0001)) zaxis = geo2.Vec3NormalizeD(zaxis) xaxis = geo2.Vec3CrossD(zaxis, (0, 1, 0)) xaxis = geo2.Vec3NormalizeD(xaxis) yaxis = geo2.Vec3CrossD(xaxis, zaxis) else: self.LogError('Space object', self.id, 'has invalid direction (', direction, '). Unable to rotate it.') return mat = ((xaxis[0], xaxis[1], xaxis[2], 0.0), (yaxis[0], yaxis[1], yaxis[2], 0.0), (-zaxis[0], -zaxis[1], -zaxis[2], 0.0), (0.0, 0.0, 0.0, 1.0)) quat = geo2.QuaternionRotationMatrix(mat) if hasattr(self.model, 'modelRotationCurve'): if not self.model.modelRotationCurve: self.model.modelRotationCurve = trinity.TriRotationCurve( 0.0, 0.0, 0.0, 1.0) self.model.modelRotationCurve.value = quat else: self.model.rotationCurve = None
def GetWarpCollisions(self, ball): space = sm.GetService('space') planets = space.planetManager.planets destination = self.destination source = (ball.x, ball.y, ball.z) self.direction = geo2.Vec3SubtractD(destination, source) direction = self.direction warpDistance = geo2.Vec3LengthD(direction) normDirection = geo2.Vec3NormalizeD(direction) self.normDirection = normDirection ballpark = sm.GetService('michelle').GetBallpark() collisions = [] for planet in planets: planetBall = ballpark.GetBall(planet.id) if planetBall is None: log.LogWarn('Warping got a None planet ball.') continue planetRadius = planetBall.radius planetPosition = (planetBall.x, planetBall.y, planetBall.z) planetDir = geo2.Vec3SubtractD(planetPosition, source) if geo2.Vec3LengthSqD( self.direction) < geo2.Vec3LengthSqD(planetDir): continue effectiveRadius = self.CalcEffectiveRadius(normDirection, planetDir, planetRadius) if effectiveRadius is None: continue collisions.append((planetBall, effectiveRadius)) blue.pyos.BeNice() return collisions
def GetRayAndPointFromUI(self, x, y, projection2view=None, view2world=None): viewport = self.viewport mx = x - viewport.x my = y - viewport.y w = viewport.width h = viewport.height fx = float(mx * 2) / w - 1.0 fy = float(my * 2) / h - 1.0 fy *= -1 projection2view = projection2view or geo2.MatrixInverse( self.projectionMatrix.transform) view2world = view2world or geo2.MatrixInverse( self.viewMatrix.transform) rayStart = (fx, fy, 0.0) rayStart = geo2.Vec3TransformCoord(rayStart, projection2view) rayStart = geo2.Vec3TransformCoord(rayStart, view2world) rayEnd = (fx, fy, 1.0) rayEnd = geo2.Vec3TransformCoord(rayEnd, projection2view) rayEnd = geo2.Vec3TransformCoord(rayEnd, view2world) rayDir = geo2.Vec3SubtractD(rayEnd, rayStart) return (geo2.Vec3NormalizeD(rayDir), rayStart)
def ZoomToDistance(self, endCameraDistance, immediate=True): endCameraDistance = min(self.maxDistance, max(self.minDistance, endCameraDistance)) eyePositionNorm = geo2.Vec3NormalizeD(self._eyePosition) self._eyePosition = geo2.Vec3ScaleD(eyePositionNorm, endCameraDistance) if immediate: self._eyePositionCurrent = self._eyePosition
def Update(self, center, range, closestPoints, width): self.AddLinesToScene() self.ClearLines() d0 = geo2.Vec3SubtractD(center, closestPoints[0]) d1 = geo2.Vec3SubtractD(center, closestPoints[1]) up = geo2.Vec3NormalizeD(geo2.Vec3CrossD(d1, d0)) dir = geo2.Vec3NormalizeD(d0) pFar = geo2.Vec3AddD(center, geo2.Vec3ScaleD(dir, range)) pNear = geo2.Vec3AddD(center, geo2.Vec3ScaleD(dir, -range)) perp = geo2.Vec3NormalizeD(geo2.Vec3CrossD(dir, up)) pRight = geo2.Vec3AddD(center, geo2.Vec3ScaleD(perp, range)) pLeft = geo2.Vec3AddD(center, geo2.Vec3ScaleD(perp, -range)) width *= LINE_WIDTH self.lineSet.AddSpheredLineCrt(pFar, DEFAULT_COLOR, pRight, DEFAULT_COLOR, center, width) self.lineSet.AddSpheredLineCrt(pRight, DEFAULT_COLOR, pNear, DEFAULT_COLOR, center, width) self.lineSet.AddSpheredLineCrt(pNear, DEFAULT_COLOR, pLeft, DEFAULT_COLOR, center, width) self.lineSet.AddSpheredLineCrt(pLeft, DEFAULT_COLOR, pFar, DEFAULT_COLOR, center, width) self.lineSet.SubmitChanges()
def AddGfxResult(self, siteData, myPos): if self.suppressGfxReasons: return if not self.sensorSuiteService.siteController.IsSiteVisible(siteData): return if siteData.signalStrength >= 1.0: return if siteData.targetID in self.gfxActiveSensorResults: return direction = geo2.Vec3SubtractD(siteData.position, myPos) distToSite = geo2.Vec3LengthD(direction) deviation = siteData.deviation * 0.5 a = min(distToSite, deviation) b = max(distToSite, deviation) tanA = a / b angle = math.atan(tanA) normalizedDir = geo2.Vec3NormalizeD(direction) self.AddGfxResultToScene(siteData.targetID, normalizedDir, angle)
def __UpdateCompass(self): bp = self.michelle.GetBallpark() if bp is None: return camera = self.GetCamera() camRotation = geo2.QuaternionRotationGetYawPitchRoll( camera.rotationAroundParent) yaw, pitch, roll = camRotation cx, cy, cz = geo2.QuaternionTransformVector( camera.rotationAroundParent, (0, 0, -1.0)) camLengthInPlane = geo2.Vec2Length((cx, cz)) camAngle = math.atan2(cy, camLengthInPlane) self.compassTransform.rotation = -yaw + math.pi myPos = bp.GetCurrentEgoPos() if self.lastPose: lastCamRot, lastPos = self.lastPose isNewCamRotation = not AreVectorsEqual(lastCamRot, camRotation, 0.05) isNewPosition = not AreVectorsEqual(lastPos, myPos, 0.5) isNewPose = isNewPosition or isNewCamRotation else: isNewPosition = True isNewPose = True for siteID, indicator in self.siteIndicatorsBySiteID.iteritems(): if indicator.isNew or isNewPose: toSiteVec = geo2.Vec3SubtractD(indicator.data.position, myPos) toSiteVec = geo2.Vec3NormalizeD(toSiteVec) if indicator.isNew or isNewPosition: angle = math.atan2(-toSiteVec[2], toSiteVec[0]) indicator.SetRotation(angle + MATH_PI_2) sx, sy, sz = toSiteVec siteLengthInPlane = geo2.Vec2Length((sx, sz)) siteAngle = math.atan2(sy, siteLengthInPlane) inclinationAngle = siteAngle - camAngle verticalAngle = min(inclinationAngle, MATH_PI_2) indicator.SetInclination(verticalAngle) indicator.isNew = False self.lastPose = (camRotation, myPos)
def GetViewVector(self): t = geo2.MatrixInverse(self.viewMatrix.transform) ret = geo2.Vec3NormalizeD((t[2][0], t[2][1], t[2][2])) return ret
def GetZAxis(self): t = self.viewMatrix.transform return geo2.Vec3NormalizeD((t[0][2], t[1][2], t[2][2]))
def Update(self): pointOfInterestOverrideValue = self.GetPointOfInterestOverrideValue() if pointOfInterestOverrideValue is not None: self._pointOfInterest = pointOfInterestOverrideValue elif self.followMarker: followMarker = self.followMarker() if followMarker: markerPosition = followMarker.GetDisplayPosition() if markerPosition is not None: self._pointOfInterest = markerPosition speedFactor = 0.4 diff = geo2.Vec3Subtract(self._pointOfInterest, self._pointOfInterestCurrent) diffLength = geo2.Vec3Length(diff) if diffLength > 0.001: addVector = geo2.Vec3ScaleD(diff, speedFactor) newPosition = geo2.Vec3Add(self._pointOfInterestCurrent, addVector) if geo2.Vec3Equal(newPosition, self._pointOfInterestCurrent): newPosition = self._pointOfInterest self._pointOfInterestCurrent = newPosition 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) currentPositionN = geo2.Vec3Normalize(self._eyePositionCurrent) self._eyePosition = geo2.Vec3Scale( currentPositionN, geo2.Vec3Length(self._eyePosition)) 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) currentPositionN = geo2.Vec3NormalizeD(self._eyePositionCurrent) self._eyePosition = geo2.Vec3ScaleD( currentPositionN, geo2.Vec3Length(self._eyePosition)) self._pitchSpeed -= pitchChange else: self._pitchSpeed = 0.0 setCameraDistance = geo2.Vec3Length(self._eyePosition) currentCameraDistance = geo2.Vec3Length(self._eyePositionCurrent) cameraDistanceDiff = setCameraDistance - currentCameraDistance if math.fabs(cameraDistanceDiff) > 0.001: usedDist = cameraDistanceDiff * speedFactor * 0.5 viewVectorNormalized = geo2.Vec3NormalizeD( self._eyePositionCurrent) newDistance = min( self.maxDistance, max(self.minDistance, currentCameraDistance + usedDist)) self._eyePositionCurrent = geo2.Vec3ScaleD(viewVectorNormalized, newDistance) self.UpdateProjection() self.UpdateView() if self.callback: self.callback()