def PickObject(self, x, y): if self.sceneManager.GetActiveScene() != self.renderScene: return rescale = 1.0 / 10000.0 projection = trinity.TriProjection() projection.PerspectiveFov(trinity.GetFieldOfView(), trinity.GetAspectRatio(), trinity.GetFrontClip(), trinity.GetBackClip()) view = trinity.TriView() view.transform = trinity.GetViewTransform() scaling, rotation, translation = geo2.MatrixDecompose( self.transform.worldTransform) pZ = geo2.Vec3Transform((0, 0, 1), self.transform.worldTransform) surfaceNormal = geo2.Subtract(pZ, translation) cameraZ = geo2.Vector(view.transform[0][2], view.transform[1][2], view.transform[2][2]) if geo2.Vec3Dot(surfaceNormal, cameraZ) < 0: return self.renderObject.translation = geo2.Vec3Scale(translation, rescale) self.renderObject.rotation = rotation self.renderObject.scaling = geo2.Vec3Scale(scaling, rescale) scaling, rotation, translation = geo2.MatrixDecompose(view.transform) translation = geo2.Vec3Scale(translation, rescale) view.transform = geo2.MatrixTransformation(None, None, scaling, None, rotation, translation) return self.renderObject.PickObject(x, y, projection, view, trinity.device.viewport)
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 Update(self): normalCamera = self._GetNonDebugCamera() if not self.IsUpdatingDebugCamera() and normalCamera: if normalCamera: normalCamera.Update() if self.IsShowingNormalCamera() and normalCamera: camPos = normalCamera.GetPosition() poi = normalCamera.GetPointOfInterest() vec = geo2.Vec3Subtract(poi, camPos) vec = geo2.Vec3Normalize(vec) vec = geo2.Vec3Scale(vec, 0.5) self.debugRenderClient.RenderCone(camPos, geo2.Vec3Add(camPos, vec), 0.25, 4278190335L, time=1) if self.lastCamPos is not None and camPos != self.lastCamPos: self.debugRenderClient.RenderRay(self.lastCamPos, camPos, 4278190335L, 4278255360L, time=1000, pulse=True) self.lastCamPos = camPos if self.translationVector != [0.0, 0.0, 0.0]: now = blue.os.GetWallclockTime() frameTime = float(now - self.lastUpdateTime) / const.SEC poi = cameras.PolarCamera.GetPointOfInterest(self) rotMatrix = geo2.MatrixRotationYawPitchRoll( math.pi / 2.0 - self.yaw, math.pi / 2.0 - self.pitch, 0.0) scaledVector = geo2.Vec3Scale(self.translationVector, frameTime) relativeVector = geo2.Vec3TransformCoord(scaledVector, rotMatrix) newPos = geo2.Vec3Add(poi, relativeVector) cameras.PolarCamera.SetPointOfInterest(self, newPos) cameras.PolarCamera.Update(self)
def _UpdateCameraNoiseOffset(self): if self.noiseScaleCurve: self.noiseScale = self.noiseScaleCurve.UpdateScalar( blue.os.GetSimTime()) if self.noiseScale == 0: return if self.noiseDampCurve: self.noiseDamp = self.noiseDampCurve.UpdateScalar( blue.os.GetSimTime()) dT = 1.0 / blue.os.fps ran = random.random() - 0.5 self._noiseX = (self._noiseX + self.noiseDamp * ran) / (1.0 + self.noiseDamp * dT) self._noiseX = max(-MAX_NOISE, min(self._noiseX, MAX_NOISE)) ran = random.random() - 0.5 self._noiseY = (self._noiseY + self.noiseDamp * ran) / (1.0 + self.noiseDamp * dT) self._noiseY = max(-MAX_NOISE, min(self._noiseY, MAX_NOISE)) noiseScale = self.GetZoomDistance() / 100.0 * self.noiseScale direction = self.GetLookAtDirection() vecX = geo2.Vec3Cross(direction, self._upDirection) vecY = geo2.Vec3Cross(direction, vecX) vecX = geo2.Vec3Scale(vecX, self._noiseX * noiseScale) vecY = geo2.Vec3Scale(vecY, self._noiseY * noiseScale) noiseOffset = geo2.Vec3Add(vecX, vecY) self._AddToAtOffset(noiseOffset)
def getPoint(i): p = obb[3] x = obb[0] y = obb[1] z = obb[2] size = obb[4] p = geo2.Vec3Add(p, geo2.Vec3Scale(x, size[0] if i & 1 else -size[0])) p = geo2.Vec3Add(p, geo2.Vec3Scale(y, size[1] if i & 2 else -size[1])) p = geo2.Vec3Add(p, geo2.Vec3Scale(z, size[2] if i & 4 else -size[2])) return p
def _GetNewLookAtEyePos(self, atPos1, itemID, radius): typeID = self.lookAtBall.typeID if typeID and evetypes.GetGroupID(typeID) == invconst.groupBillboard: direction = GetSpeedDirection(self.lookAtBall) if geo2.Vec3Dot(self.GetLookAtDirection(), direction) < 0: direction = geo2.Vec3Scale(direction, -1) radius = self.lookAtBall.radius * 5 else: direction = self.GetLookAtDirection() eyePos1 = geo2.Vec3Add(atPos1, geo2.Vec3Scale(direction, radius)) return eyePos1
def MoveTF(self, tf, dx, dy): camera = sm.GetService('sceneManager').GetRegisteredCamera('starmap') X = float(dx) / float(trinity.device.width) Y = -float(dy) / float(trinity.device.height) viewVec = camera.viewVec upVec = geo2.Vec3Scale(camera.upVec, Y) rightVec = geo2.Vec3Scale(camera.rightVec, X) pos = geo2.Vec3Add(rightVec, upVec) pos = geo2.Vec3Scale(pos, pow(tf.cameraDistSq, 0.5) * 1.5) pos = geo2.QuaternionTransformVector(camera.rotationAroundParent, pos) tf.translation = geo2.Vec3Add(tf.translation, pos)
def UpdateAtEyePositions(self): trackPos = self.GetTrackPosition() lookDir = self.GetLookDirection() ballPos = GetBallPosition(self.trackBall) if self.trackBall.model: radius = self.trackBall.model.GetBoundingSphereRadius() else: radius = self.trackBall.radius * 1.2 self.SetEyePosition( geo2.Vec3Add(ballPos, geo2.Vec3Scale(lookDir, -radius))) self.SetAtPosition( geo2.Vec3Add(ballPos, geo2.Vec3Scale(lookDir, -2 * radius)))
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 OnActivated(self, **kwargs): BaseSpaceCamera.OnActivated(self, **kwargs) duration = max(blue.os.desiredSimDilation, 0.2) * 1.75 self._eyePosition = geo2.Vec3Scale(self.GetLookAtDirection(), -30.0) eyePos1 = geo2.Vec3Scale(self.GetLookAtDirection(), 8.0) uicore.animations.MorphVector3(self, '_eyePosition', self._eyePosition, eyePos1, duration=duration) uicore.animations.MorphScalar(self, 'fov', startVal=self.fov, endVal=0.55, duration=duration)
def UpdateSpeedOffset(self): if IsDynamicCameraMovementEnabled() and not self.IsTracking(): speedProp = self.GetSpeedOffsetProportion() offsetAmount = speedProp * 0.5 * self.maxZoom self.speedOffset = geo2.Vec3Scale(self.speedDir, offsetAmount) else: self.speedOffset = (0, 0, 0)
def _OnActivated(self): duration = 15.0 ball = GetBallWaitForModel(self.ego) self.SetEyePosition( geo2.Vec3Scale(GetSpeedDirection(ball), 2 * GetBallRadius(ball))) self.SetMaxZoom(GetBallMaxZoom(ball, self.nearClip)) uicore.animations.MorphScalar(self, 'yaw', self.yaw, self.yaw + math.pi / 20, duration=duration) uicore.animations.MorphScalar(self, 'pitch', self.pitch, self.pitch + math.pi / 40, duration=duration) dist = GetInitialLookAtDistance(self.maxZoom, self.minZoom) zoom0 = self.GetZoomProportionByZoomDistance(5 * dist) zoom1 = self.GetZoomProportionByZoomDistance(dist) uicore.animations.MorphScalar(self, 'zoom', zoom0, zoom1, duration=duration * 0.8) blue.synchro.SleepWallclock(duration * 1000) uthread.new(self.SwitchToPrimaryCamera)
def _OnActivated(self): duration = 30.0 ball = GetBallWaitForModel(self.ego) self.SetEyePosition( geo2.Vec3Scale(GetSpeedDirection(ball), 2 * GetBallRadius(ball))) self.SetMaxZoom(GetBallMaxZoom(ball, self.nearClip)) self.pitch -= math.pi / 40 uicore.animations.MorphScalar(self, 'yaw', self.yaw, self.yaw + math.pi / 3, duration=duration) uicore.animations.MorphScalar(self, 'pitch', self.pitch, self.pitch - math.pi / 10, duration=duration) zoom0 = 0.48 zoom1 = 0.65 self.SetZoom(zoom0) uicore.animations.MorphScalar(self, 'zoom', zoom0, zoom1, duration=duration * 0.8) blue.synchro.SleepWallclock(duration * 1000 + 500) uthread.new(self.SwitchToPrimaryCamera)
def Stop(self): self.ending = True if self.cameraLookAnimation is not None: self.cameraLookAnimation.Stop() camera = self.GetCamera() camera.shakeController.EndCameraShake('JumpIn') sm.GetService('viewState').GetView( ViewState.Space).ActivatePrimaryCamera() with ExceptionEater('JumpTransitionTunnelEnd'): if not self.destinationSceneApplied: self.transition.ApplyDestinationScene() camera = self.GetCamera() anim = camera.animationController offset = geo2.Vec3Scale(self.normDir, -self.camOffsetEnd) anim.Schedule(transitioncam.InFOV(self.endCamDurationS)) camera.shakeController.DoCameraShake(self.shakeJumpIn) if self.startCS is not None: self.startCS.Stop() if self.mainCS is not None: self.mainCS.Stop() if self.stopCS is not None: self.stopCS.Play() self.FadeUIIn() uthread.new(self.BlinkSystemName) uthread.new(self._DelayedCleanup) self.cameraLookAnimation.OnJumpDone()
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 UpdatePosition(self, localPosition=None): """ Updates the position and scale of the supernova. localPosition: An optional 3 tuple for the local position. If not passed in the session.solarsystemid is used to determine the position. """ if not self.model: self._LoadModel() if not localPosition: localSystem = sm.StartService('map').GetItem(session.solarsystemid) localPosition = (localSystem.x, localSystem.y, localSystem.z) if not self.effectPosition: effectSystem = sm.StartService('map').GetItem(SUPERNOVA_SYSTEM_ID) self.effectPosition = (effectSystem.x, effectSystem.y, effectSystem.z) effect = self.model.children[0] direction = geo2.Vec3SubtractD(localPosition, self.effectPosition) direction = (direction[0], direction[1], -direction[2]) distance = geo2.Vec3LengthD(direction) / 1e+16 direction = geo2.Vec3Normalize(direction) if distance < self.nearDistance: scale = self.nearSize else: shift = (self.farSize * self.farDistance - self.nearSize * self.nearDistance) / (self.nearSize - self.farSize) baseSize = self.nearSize * (self.nearDistance + shift) scale = baseSize / (distance + shift) effect.scaling = (scale, scale, scale) effect.translation = geo2.Vec3Scale(direction, 15.0)
def Update(self): self._UpdateAnchorPosition() BaseSpaceCamera.Update(self) if not self.lookAtBall or not self.ego: return zoomProp = self.GetZoomProportion() self._UpdateAtOffset() self._UpdateEyeOffset() newAtPos = self.GetTrackPosition(self.lookAtBall) atDiff = geo2.Vec3Subtract(newAtPos, self._atPosition) self.SetAtPosition(newAtPos) if self.IsChasing(): self.SetEyePosition( self.trackLerper.GetValue(self._eyePosition, self.GetChaseEyePosition())) elif self.IsTracking(): self.SetEyePosition( self.trackLerper.GetValue(self._eyePosition, self.GetTrackingEyePosition())) else: prop = self._GetEyePosDriftProporition() eyeOffset = geo2.Vec3Scale(atDiff, prop) self.SetEyePosition(geo2.Vec3Add(self._eyePosition, eyeOffset)) if not self.IsInTransit(): if self.GetItemID() == self.ego or self.IsTracking( ) or self.IsChasing(): self.SetZoom(zoomProp) self.EnforceMinZoom() if not self.isManualFovEnabled and IsDynamicCameraMovementEnabled(): self.SetFovTarget(self.GetDynamicFov())
def GetStarGateLineOffsets(self, solarSystemID): fromSystemInfo = cfg.mapSolarSystemContentCache[solarSystemID] mapNode = self.GetNodeBySolarSystemID(solarSystemID) adjustLines = {} for lineData in mapNode.lineData: if solarSystemID == lineData.fromSolarSystemID: otherSystemInfo = cfg.mapSolarSystemContentCache[lineData.toSolarSystemID] else: otherSystemInfo = cfg.mapSolarSystemContentCache[lineData.fromSolarSystemID] fromStargateVector = None for each in fromSystemInfo.stargates: if fromSystemInfo.stargates[each].destination in otherSystemInfo.stargates: fromStargate = fromSystemInfo.stargates[each] fromStargateVector = (fromStargate.position.x, fromStargate.position.y, fromStargate.position.z) break if fromStargateVector: stargateOffset = geo2.Vec3Scale(fromStargateVector, ScaleSolarSystemValue(1.0)) if solarSystemID == lineData.fromSolarSystemID: adjustLines[lineData.lineID] = (lineData.fromSolarSystemID, lineData.toSolarSystemID, stargateOffset, (0, 0, 0), lineData.jumpType) else: adjustLines[lineData.lineID] = (lineData.fromSolarSystemID, lineData.toSolarSystemID, (0, 0, 0), stargateOffset, lineData.jumpType) return adjustLines
def UpdatePosition(self, localPosition=None): if not self.model: self._LoadModel() if not len(self.model.children): return if not localPosition: localSystem = sm.StartService('map').GetItem(session.solarsystemid) localPosition = (localSystem.x, localSystem.y, localSystem.z) if not self.effectPosition: effectSystem = sm.StartService('map').GetItem(SUPERNOVA_SYSTEM_ID) self.effectPosition = (effectSystem.x, effectSystem.y, effectSystem.z) effect = self.model.children[0] direction = geo2.Vec3SubtractD(localPosition, self.effectPosition) direction = (direction[0], direction[1], -direction[2]) distance = geo2.Vec3LengthD(direction) / 1e+16 direction = geo2.Vec3Normalize(direction) if distance < self.nearDistance: scale = self.nearSize else: shift = (self.farSize * self.farDistance - self.nearSize * self.nearDistance) / (self.nearSize - self.farSize) baseSize = self.nearSize * (self.nearDistance + shift) scale = baseSize / (distance + shift) effect.scaling = (scale, scale, scale) effect.translation = geo2.Vec3Scale(direction, 15.0)
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 MoveCursor(self, tf, dx, dy, camera): dev = trinity.device X = float(dx) / float(dev.width) Y = float(dy) / float(dev.height) * -1 upVec = geo2.Vec3Scale(camera.upVec, Y) rightVec = geo2.Vec3Scale(camera.rightVec, X) pos = geo2.Vec3Add(rightVec, upVec) cameraDistance = geo2.Vec3Length(geo2.Vec3Subtract(camera.pos, self.cursor.translation)) pos = geo2.Vec3Scale(pos, cameraDistance * 3.0) if tf in self.yCursor: pos = (0.0, pos[1], 0.0) elif tf in self.xCursor: pos = (pos[0], 0.0, 0.0) elif tf in self.zCursor: pos = (0.0, 0.0, pos[2]) self.cursor.translation = geo2.Vec3Add(self.cursor.translation, pos)
def GetCenter(positions): if not positions: return (0, 0, 0) accPos = geo2.Vector((0, 0, 0)) for pos in positions: accPos += pos return geo2.Vec3Scale(accPos, 1.0 / len(positions))
def DistanceFromSegment(self, p, p0, p1, v, c2): w = geo2.Vec3Subtract(p, p0) c1 = geo2.Vec3Dot(v, w) if c1 <= 0: return None if c2 <= c1: return geo2.Vec3Distance(p, p1) return geo2.Vec3Distance(p, geo2.Vec3Add(p0, geo2.Vec3Scale(v, c1 / c2)))
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 UpdateProbePosition(self, probeID, position): probeData = self.probeData[probeID] distSq = geo2.Vec3LengthSq(position) if distSq > probescanning.const.MAX_PROBE_DIST_FROM_SUN_SQUARED: scale = probescanning.const.MAX_PROBE_DIST_FROM_SUN_SQUARED / distSq position = geo2.Vec3Scale(position, scale) probeData.pos = probeData.destination = position return position
def SetCamera(self, yaw, pitch, pan): cam = sm.GetService('sceneManager').GetActiveCamera() cam.SetYaw(math.radians(yaw)) cam.SetPitch(math.radians(pitch)) pan = ClampPan(pan) newPos = geo2.Vec3Add(geo2.Vec3Scale(cam.GetLookAtDirection(), pan), cam.GetAtPosition()) cam.TransitTo(atPosition=cam.GetAtPosition(), eyePosition=newPos)
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 _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 SetAppropriateAtPositionForRotation(self, atPos): distanceToNewAtPos = geo2.Vec3Distance(self.eyePosition, atPos) distanceToNewAtPos = min(evecamera.LOOKATRANGE_MAX_NEW, distanceToNewAtPos) lookVec = geo2.Vec3Scale(self.GetLookAtDirection(), distanceToNewAtPos) newAtPos = geo2.Vec3Subtract(self.eyePosition, lookVec) if newAtPos != self._eyePosition: self.SetAtPosition(newAtPos)
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