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