public override void OnFixedUpdate() { //Restore the saved target when we are made active vessel if (!wasActiveVessel && vessel.isActiveVessel) { if (target != null && target.GetVessel() != null) { FlightGlobals.fetch.SetVesselTarget(target); } } //notice when the user switches targets if (vessel.isActiveVessel && target != FlightGlobals.fetch.VesselTarget) { target = FlightGlobals.fetch.VesselTarget; if (target is Vessel && ((Vessel)target).LandedOrSplashed && (((Vessel)target).mainBody == vessel.mainBody)) { targetBody = vessel.mainBody; targetLatitude = vessel.mainBody.GetLatitude(target.GetTransform().position); targetLongitude = vessel.mainBody.GetLongitude(target.GetTransform().position); } } //Update targets that need updating: if (target is DirectionTarget) { ((DirectionTarget)target).Update(targetDirection); } else if (target is PositionTarget) { ((PositionTarget)target).Update(targetBody, targetLatitude, targetLongitude); } wasActiveVessel = vessel.isActiveVessel; }
/// <summary> /// Returns facing (or anti-facing) vector of a ITargetable /// </summary> /// <param name="target"></param> /// <param name="targetMode"></param> /// <returns>Vector3</returns> public static Vector3 getAttitude(this ITargetable target, SmartDockingAid.TargetMode targetMode) { if (targetMode == SmartDockingAid.TargetMode.PARALLEL_NEGATIVE) { if (target is ModuleDockingNode) { return(-target.GetTransform().forward); } else { return(-target.GetTransform().up); } } else { if (target is ModuleDockingNode) { return(target.GetTransform().forward); } else { return(target.GetTransform().up); } } }
public void UpdateCoordinates(CelestialBody body) { if (target == null) { return; } Name = target.GetName(); switch (TargetInfo.targetType) { case ProtoTargetInfo.Type.Vessel: var v = target as Vessel; if (v == null) { break; } set_coordinates(v); return; case ProtoTargetInfo.Type.PartModule: var m = target as PartModule; if (m == null || m.vessel == null) { break; } set_coordinates(m.vessel); return; case ProtoTargetInfo.Type.Part: // There may be ITargetable Part derivatives in some mods // ReSharper disable once SuspiciousTypeConversion.Global var p = target as Part; if (p == null || p.vessel == null) { // ProtoTargetInfo.FindTarget() may return a Vessel when the Type == Part goto case ProtoTargetInfo.Type.Vessel; } set_coordinates(p.vessel); return; case ProtoTargetInfo.Type.Generic: var t = target.GetTransform(); if (t == null) { break; } var position = t.position; set_coordinates(body.GetLatitude(position), body.GetLongitude(position), body.GetAltitude(position)); return; } TargetInfo.targetType = ProtoTargetInfo.Type.Null; target = null; Valid = false; }
public void UpdateCoordinates(CelestialBody body) { if (target == null) { return; } Name = target.GetName(); switch (TargetInfo.targetType) { case ProtoTargetInfo.Type.Vessel: var v = target as Vessel; if (v == null) { break; } set_coordinates(v); return; case ProtoTargetInfo.Type.PartModule: var m = target as PartModule; if (m == null || m.vessel == null) { break; } set_coordinates(m.vessel); return; case ProtoTargetInfo.Type.Part: var p = target as Part; if (p == null || p.vessel == null) { break; } set_coordinates(p.vessel); return; case ProtoTargetInfo.Type.Generic: var t = target.GetTransform(); if (t == null) { break; } set_coordinates(body.GetLatitude(t.position), body.GetLongitude(t.position)); return; // case ProtoTargetInfo.Type.CelestialBody: default: break; } TargetInfo.targetType = ProtoTargetInfo.Type.Null; Name += " last location"; target = null; }
public void Update() { if (target != null) { if (Time.timeSinceLevelLoad >= nextAttackTime) { if (Vector3.Distance(transform.position, target.GetTransform().position) <= range) { Shoot(); } } } }
public static void SetTarget(ITargetable target, bool show = true) { if (indicator == null) { indicator = UIManager._instance.CreateTargetIndicator(target.getGridPosition(), Color.red, true); } else { indicator.SetTarget(target.getGridPosition()); indicator.SetColor(Color.red); indicator.SetShow(show); } currentTarget = target; currentPosition = target.getGridPosition(); CameraFollow.target = target.GetTransform(); if (Character.GetCharacterAtTile(currentPosition) != null) { BattleUIContainer.RefreshUnitView(Character.GetCharacterAtTile(currentPosition)); } if (currentTargetList != null && currentTargetList.Contains(target)) { SelectedIndex = currentTargetList.IndexOf(target); } }
private void UpdateTarget() { activeTarget = FlightGlobals.fetch.VesselTarget; if (activeTarget != null) { targetDisplacement = activeTarget.GetTransform().position - vessel.GetTransform().position; targetDirection = targetDisplacement.normalized; targetRelativeVelocity = vessel.obt_velocity - activeTarget.GetObtVelocity(); targetCmpSpeed = -1.0; targetDockingTransform = null; if (activeTarget is Vessel) { targetType = ((activeTarget as Vessel).vesselType == VesselType.SpaceObject) ? TargetType.Asteroid : TargetType.Vessel; } else if (activeTarget is CelestialBody) { targetType = TargetType.CelestialBody; } else if (activeTarget is ModuleDockingNode) { targetType = TargetType.DockingPort; targetDockingTransform = (activeTarget as ModuleDockingNode).GetTransform(); } else if (activeTarget is PositionTarget) { targetType = TargetType.PositionTarget; } else { Utility.LogError(this, "UpdateTarget() - unable to classify target {0}", activeTarget.GetType().Name); targetType = TargetType.None; } if (targetType == TargetType.Vessel || targetType == TargetType.DockingPort) { UpdateTargetDockingPorts(); } targetName = activeTarget.GetName(); targetOrbit = activeTarget.GetOrbit(); } else { targetCmpSpeed = 0.0; targetType = TargetType.None; targetDisplacement = Vector3.zero; targetRelativeVelocity = Vector3d.zero; targetDirection = forward; targetDockingTransform = null; targetName = string.Empty; targetOrbit = null; if (targetDockingPorts.Length > 0) { targetDockingPorts = new ModuleDockingNode[0]; } } approachSolver.ResetComputation(); }
public override void OnFixedUpdate() { //Restore the saved target when we are made active vessel if (!wasActiveVessel && vessel.isActiveVessel) { if (target != null && target.GetVessel() != null) { vessel.targetObject = target; } } //notice when the user switches targets if (target != vessel.targetObject) { target = vessel.targetObject; if (target is Vessel && ((Vessel)target).LandedOrSplashed && (((Vessel)target).mainBody == vessel.mainBody)) { targetBody = vessel.mainBody; targetLatitude = vessel.mainBody.GetLatitude(target.GetTransform().position); targetLongitude = vessel.mainBody.GetLongitude(target.GetTransform().position); } if (target is CelestialBody) { targetBody = (CelestialBody)target; } } // .23 temp fix until I understand better what's going on if (targetBody == null) { targetBody = vessel.mainBody; } //Update targets that need updating: if (target is DirectionTarget) { ((DirectionTarget)target).Update(targetDirection); } else if (target is PositionTarget) { ((PositionTarget)target).Update(targetBody, targetLatitude, targetLongitude); } wasActiveVessel = vessel.isActiveVessel; }
string CalcTargetDistance(ITargetable obj) { // from Docking Port Alignment Indicator Transform selfTransform = FlightGlobals.ActiveVessel.ReferenceTransform; Transform targetTransform = obj.GetTransform(); Vector3 targetToOwnship = selfTransform.position - targetTransform.position; float distance = targetToOwnship.magnitude; return(Formatter.Distance_short(distance) + " "); }
void LateUpdate() { if (this.navBall == null) { this.navBall = FindObjectOfType <NavBall>(); } if (FlightGlobals.fetch != null && FlightGlobals.ready && FlightGlobals.fetch.activeVessel != null && FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetTargetingMode() == VesselTargetModes.DirectionVelocityAndOrientation) { /// Targeted a Port if I am not mistaken o__o if (this.indicator == null) { SetupIndicator(); } #region "legacy" Code ITargetable targetPort = FlightGlobals.fetch.VesselTarget; Transform targetTransform = targetPort.GetTransform(); Transform selfTransform = FlightGlobals.ActiveVessel.ReferenceTransform; // Position Vector3 targetPortOutVector = targetTransform.forward.normalized; Vector3 rotatedTargetPortInVector = navBall.attitudeGymbal * -targetPortOutVector; this.indicator.transform.localPosition = rotatedTargetPortInVector * navBall.progradeVector.localPosition.magnitude; // Rotation Vector3 v1 = Vector3.Cross(selfTransform.up, -targetTransform.up); Vector3 v2 = Vector3.Cross(selfTransform.up, selfTransform.forward); float ang = Vector3.Angle(v1, v2); if (Vector3.Dot(selfTransform.up, Vector3.Cross(v1, v2)) < 0) { ang = -ang; } this.indicator.transform.rotation = Quaternion.Euler(90 + ang, 90, 270); #endregion // Set opacity float value = Vector3.Dot(indicator.transform.localPosition.normalized, Vector3.forward); value = Mathf.Clamp01(value); this.indicator.GetComponent <MeshRenderer>().materials[0].SetFloat("_Opacity", value); this.indicator.SetActive(indicator.transform.localPosition.z > 0.0d); return; } if (this.indicator != null) { this.indicator.SetActive(false); } }
public void LateUpdate() { if (FlightGlobals.ready == false) { return; } if (FlightGlobals.fetch != null) { if (FlightGlobals.fetch.VesselTarget != null) { if (FlightGlobals.fetch.VesselTarget.GetTargetingMode() == VesselTargetModes.DirectionVelocityAndOrientation) { ITargetable targetPort = FlightGlobals.fetch.VesselTarget; Transform targetTransform = targetPort.GetTransform(); Transform selfTransform = FlightGlobals.ActiveVessel.ReferenceTransform; //indicator position Vector3 targetPortOutVector = targetTransform.forward.normalized; Vector3 targetPortInVector = -targetPortOutVector; Vector3 rotatedTargetPortInVector = navBallBehaviour.attitudeGymbal * targetPortInVector; indicator.transform.localPosition = rotatedTargetPortInVector * navBallBehaviour.progradeVector.localPosition.magnitude; //indicator rotation Vector3 v1 = Vector3.Cross(selfTransform.up, -targetTransform.up); Vector3 v2 = Vector3.Cross(selfTransform.up, selfTransform.forward); float ang = Vector3.Angle(v1, v2); if (Vector3.Dot(selfTransform.up, Vector3.Cross(v1, v2)) < 0) { ang = -ang; } indicator.transform.rotation = Quaternion.Euler(90 + ang, 90, 270); //indicator visibility (invisible if on back half sphere) indicator.SetActive(indicator.transform.localPosition.z > 0.0d); return; } } } //no docking port is currently selected indicator.SetActive(false); return; }
private void updateVesselCourse() { ITargetable targetObject = this.part.vessel.targetObject; //First check to see if the vessel has selected a target. if (targetObject != null) { vesselCourse = targetObject.GetDisplayName().Replace("^N", ""); targetDistance = Math.Abs((part.vessel.GetWorldPos3D() - (Vector3d)targetObject.GetTransform().position).magnitude); // Light-years if (targetDistance > (kGigaMeter * 1000)) { targetDistance /= kLightYear; Fields["targetDistance"].guiUnits = "Ly"; } // Giga-meters else if (targetDistance > (kMegaMeter * 1000)) { targetDistance /= kGigaMeter; Fields["targetDistance"].guiUnits = "Gm"; } // Mega-meters else if (targetDistance > 1000 * 1000) { targetDistance /= kMegaMeter; Fields["targetDistance"].guiUnits = "Mm"; } else { targetDistance /= 1000; Fields["targetDistance"].guiUnits = "Km"; } } else { vesselCourse = "None"; targetDistance = 0; Fields["targetDistance"].guiUnits = "m"; } }
private void UpdateHealthBar() { if (_user == null || _user.Equals(null)) { OnDestroyed(); return; } //Convert the position of the entity to a viewpoint Vector2 viewport = Camera.main.WorldToViewportPoint(_user.GetTransform().position); //Calculate the position of the health bar to be above the entity. Vector2 position = new Vector2( ((viewport.x * _canvas.sizeDelta.x) - (_canvas.sizeDelta.x * 0.5f)), ((viewport.y * _canvas.sizeDelta.y) - (_canvas.sizeDelta.y * 0.5f)) + _offset); HealthBarRect.anchoredPosition = position; }
Vector3 GetOrientationDeviation(ITargetable obj) { Transform selfTransform = FlightGlobals.ActiveVessel.ReferenceTransform; Transform targetTransform = obj.GetTransform(); Vector3 targetPortOutVector = targetTransform.forward.normalized; Vector3 targetPortRollReferenceVector = -targetTransform.up; Vector3 orientationDeviation = new Vector3 { x = AngleAroundNormal(-targetPortOutVector, selfTransform.up, selfTransform.forward), y = AngleAroundNormal(-targetPortOutVector, selfTransform.up, -selfTransform.right), z = AngleAroundNormal(targetPortRollReferenceVector, selfTransform.forward, selfTransform.up) }; orientationDeviation.x = (360 + orientationDeviation.x) % 360; // -90..270 orientationDeviation.y = (360 + orientationDeviation.y) % 360; orientationDeviation.z = (360 - orientationDeviation.z) % 360; return(orientationDeviation); }
public void Update() { if (TVcam != null && CameraManager.Instance.currentCameraMode == CameraManager.CameraMode.IVA) { TVcam.transform.rotation = originalRotation; if (FlightGlobals.fetch.vesselTargetMode != VesselTargetModes.None) { ITargetable target = FlightGlobals.fetch.VesselTarget; TVcam.transform.LookAt(target.GetTransform(), Firespitter.Tools.WorldUp(vessel)); //TVcam.transform.localRotation = Quaternion.Euler(new Vector3(TVcam.transform.localRotation.eulerAngles.x, TVcam.transform.localRotation.eulerAngles.z, 0f)); TVcam.fieldOfView = Mathf.Lerp(TVcam.fieldOfView, 5f, lerpProgress); if (lerpProgress < 1f) { lerpProgress += 0.01f; } } else { TVcam.fieldOfView = 100f; lerpProgress = 0f; } TVcam.Render(); } }
private void FetchCommonData() { localGeeASL = vessel.orbit.referenceBody.GeeASL * gee; coM = vessel.findWorldCenterOfMass(); localGeeDirect = FlightGlobals.getGeeForceAtPosition(coM).magnitude; up = (coM - vessel.mainBody.position).normalized; forward = vessel.GetTransform().up; right = vessel.GetTransform().right; north = Vector3d.Exclude(up, (vessel.mainBody.position + vessel.mainBody.transform.up * (float)vessel.mainBody.Radius) - coM).normalized; rotationSurface = Quaternion.LookRotation(north, up); rotationVesselSurface = Quaternion.Inverse(Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(vessel.GetTransform().rotation) * rotationSurface); velocityVesselOrbit = vessel.orbit.GetVel(); velocityVesselSurface = velocityVesselOrbit - vessel.mainBody.getRFrmVel(coM); speedVertical = Vector3d.Dot(velocityVesselSurface, up); speedVerticalRounded = Math.Ceiling(speedVertical * 20) / 20; target = FlightGlobals.fetch.VesselTarget; node = vessel.patchedConicSolver.maneuverNodes.Count > 0 ? vessel.patchedConicSolver.maneuverNodes[0] : null; time = Planetarium.GetUniversalTime(); FetchAltitudes(); terrainHeight = altitudeASL - altitudeTrue; if (time >= lastTimePerSecond + 1) { terrainDelta = terrainHeight - lastTerrainHeight; lastTerrainHeight = terrainHeight; lastTimePerSecond = time; } horzVelocity = (velocityVesselSurface - (speedVertical * up)).magnitude; horzVelocityForward = Vector3d.Dot(velocityVesselSurface, forward); horzVelocityRight = Vector3d.Dot(velocityVesselSurface, right); atmPressure = FlightGlobals.getStaticPressure(altitudeASL, vessel.mainBody); dynamicPressure = 0.5 * velocityVesselSurface.sqrMagnitude * vessel.atmDensity; if (target != null) { targetSeparation = vessel.GetTransform().position - target.GetTransform().position; targetOrientation = target.GetTransform().rotation; targetVessel = target as Vessel; targetBody = target as CelestialBody; targetDockingNode = target as ModuleDockingNode; targetDistance = Vector3.Distance(target.GetTransform().position, vessel.GetTransform().position); // This is kind of messy. targetOrbitSensibility = false; // All celestial bodies except the sun have orbits that make sense. targetOrbitSensibility |= targetBody != null && targetBody != Planetarium.fetch.Sun; if (targetVessel != null) targetOrbitSensibility = JUtil.OrbitMakesSense(targetVessel); if (targetDockingNode != null) targetOrbitSensibility = JUtil.OrbitMakesSense(target.GetVessel()); if (targetOrbitSensibility) targetOrbit = target.GetOrbit(); // TODO: Actually, there's a lot of nonsensical cases here that need more reasonable handling. // Like what if we're targeting a vessel landed on a moon of another planet?... if (targetOrbit != null) { velocityRelativeTarget = vessel.orbit.GetVel() - target.GetOrbit().GetVel(); } else { velocityRelativeTarget = vessel.orbit.GetVel(); } // If our target is somehow our own celestial body, approach speed is equal to vertical speed. if (targetBody == vessel.mainBody) approachSpeed = speedVertical; // In all other cases, that should work. I think. approachSpeed = Vector3d.Dot(velocityRelativeTarget, (target.GetTransform().position - vessel.GetTransform().position).normalized); } else { velocityRelativeTarget = targetSeparation = Vector3d.zero; targetOrbit = null; targetDistance = 0; approachSpeed = 0; targetBody = null; targetVessel = null; targetDockingNode = null; targetOrientation = vessel.GetTransform().rotation; targetOrbitSensibility = false; } orbitSensibility = JUtil.OrbitMakesSense(vessel); if (vessel.situation == Vessel.Situations.SUB_ORBITAL || vessel.situation == Vessel.Situations.FLYING) { // Mental note: the local g taken from vessel.mainBody.GeeASL will suffice. // t = (v+sqrt(v²+2gd))/g or something. // What is the vertical component of current acceleration? double accelUp = Vector3d.Dot(vessel.acceleration, up); double altitude = altitudeTrue; if (vessel.mainBody.ocean && altitudeASL > 0.0) { // AltitudeTrue shows distance above the floor of the ocean, // so use ASL if it's closer in this case, and we're not // already below SL. altitude = Math.Min(altitudeASL, altitudeTrue); } if (accelUp < 0.0 || speedVertical >= 0.0 || Planetarium.TimeScale > 1.0) { // If accelUp is negative, we can't use it in the general // equation for finding time to impact, since it could // make the term inside the sqrt go negative. // If we're going up, we can use this as well, since // the precision is not critical. // If we are warping, accelUp is always zero, so if we // do not use this case, we would fall to the simple // formula, which is wrong. secondsToImpact = (speedVertical + Math.Sqrt(speedVertical * speedVertical + 2 * localGeeASL * altitude)) / localGeeASL; } else if (accelUp > 0.005) { // This general case takes into account vessel acceleration, // so estimates on craft that include parachutes or do // powered descents are more accurate. secondsToImpact = (speedVertical + Math.Sqrt(speedVertical * speedVertical + 2 * accelUp * altitude)) / accelUp; } else { // If accelUp is small, we get floating point precision // errors that tend to make secondsToImpact get really big. secondsToImpact = altitude / -speedVertical; } // MOARdV: I think this gets the computation right. High thrust will // result in NaN, which is already handled. /* double accelerationAtMaxThrust = localG - (totalMaximumThrust / totalShipWetMass); double timeToImpactAtMaxThrust = (speedVertical + Math.Sqrt(speedVertical * speedVertical + 2 * accelerationAtMaxThrust * altitude)) / accelerationAtMaxThrust; bestPossibleSpeedAtImpact = speedVertical - accelerationAtMaxThrust * timeToImpactAtMaxThrust; if (double.IsNaN(bestPossibleSpeedAtImpact)) bestPossibleSpeedAtImpact = 0; */ bestPossibleSpeedAtImpact = SpeedAtImpact(totalMaximumThrust, totalShipWetMass, localGeeASL, speedVertical, altitude); expectedSpeedAtImpact = SpeedAtImpact(totalCurrentThrust, totalShipWetMass, localGeeASL, speedVertical, altitude); } else { secondsToImpact = Double.NaN; bestPossibleSpeedAtImpact = 0; expectedSpeedAtImpact = 0; } }
public override void OnUpdate() { /* * Line_Forward.SetPosition(0, transform.position); Line_Forward.SetPosition(1, transform.position + vessel.vesselTransform.forward); * Line_Up.SetPosition(0, transform.position); Line_Up.SetPosition(1, transform.position + vessel.vesselTransform.up); * Line_Right.SetPosition(0, transform.position); Line_Right.SetPosition(1, transform.position + vessel.vesselTransform.right); */ vTarget = FlightGlobals.fetch.VesselTarget; vIsActive = vessel.isActiveVessel; foundTarget = vTarget != null; loadedTarget = foundTarget && vTarget.GetVessel() != null && vTarget.GetVessel().loaded; if (!toggle || !vIsActive || !foundTarget || !loadedTarget) { Line_Dock.SetPosition(0, Vector3.zero); Line_Dock.SetPosition(1, Vector3.zero); Line_Velocity.SetPosition(0, Vector3.zero); Line_Velocity.SetPosition(1, Vector3.zero); Line_V_Up.SetPosition(0, Vector3.zero); Line_V_Right.SetPosition(0, Vector3.zero); Line_V_Diff.SetPosition(0, Vector3.zero); Line_V_Up.SetPosition(1, Vector3.zero); Line_V_Right.SetPosition(1, Vector3.zero); Line_V_Diff.SetPosition(1, Vector3.zero); alignment = 0f; return; } velocity_smoothed = (velocity_smoothed * 0.9f + (vessel.rootPart.Rigidbody.velocity - vTarget.GetVessel().rootPart.Rigidbody.velocity) * Time.deltaTime * 0.1f) / 10f; // Sliding window arrow_point = vessel.GetTransform().position + velocity_smoothed.normalized; alignment = 100f * Vector3.Dot(velocity_smoothed.normalized, (vTarget.GetTransform().transform.position - vessel.GetTransform().position).normalized); if (alignment > 99.9f) { setLineColors(Line_Dock, Color_Velocity); setLineColors(Line_V_Diff, Color_Velocity); arrow_to_point = arrow_point; } else { setLineColors(Line_Dock, Color_Dock); setLineColors(Line_V_Diff, Color_Diff); arrow_to_point = Vector3.ProjectOnPlane(((vTarget.GetTransform().transform.position - vessel.GetTransform().position).normalized - arrow_point + vessel.GetTransform().position), vessel.GetTransform().up).normalized + arrow_point; } Line_Dock.SetPosition(0, vessel.GetTransform().position); // GetTransform returns the point being controlled from Line_Dock.SetPosition(1, vTarget.GetTransform().position); // This is the other dock port Line_Velocity.SetPosition(0, vessel.GetTransform().position); if (velocity_smoothed.magnitude > 0.00001f) { Line_Velocity.SetPosition(1, arrow_point); // Line_V_Down.SetPosition(0, arrow_point); Line_V_Down.SetPosition(1, arrow_point + vessel.GetTransform().up * -1f); Line_V_Up.SetPosition(1, arrow_point + vessel.GetTransform().forward * -1f); // Weird right? "Up" is actually "Back" on a Kerbin ship // Line_V_Left.SetPosition(0, arrow_point); Line_V_Left.SetPosition(1, arrow_point + vessel.GetTransform().right * -1f); Line_V_Right.SetPosition(1, arrow_point + vessel.GetTransform().right); Line_V_Diff.SetPosition(1, arrow_to_point); } else { Line_Velocity.SetPosition(1, vessel.GetTransform().position); Line_V_Up.SetPosition(1, arrow_point); Line_V_Right.SetPosition(1, arrow_point); Line_V_Diff.SetPosition(1, arrow_point); } Line_V_Up.SetPosition(0, arrow_point); Line_V_Right.SetPosition(0, arrow_point); Line_V_Diff.SetPosition(0, arrow_point); // print("Velocity is " + part.Rigidbody.velocity * Time.deltaTime); }
public void FixedUpdate() { if (HighLogic.LoadedSceneIsEditor) { return; } if (!JUtil.IsActiveVessel(vessel)) { return; } ITargetable target = FlightGlobals.fetch.VesselTarget; if (radarEnabled) { bool powered = true; // Resources check if (resourceAmount > 0.0f) { double requested = resourceAmount * TimeWarp.fixedDeltaTime; double supplied = part.RequestResource(resourceId, requested); if (supplied < requested * 0.5) { powered = false; } } if (target == null) { if (!powered) { JUtil.LogMessage(this, "Want to scan, but there's no power"); return; } // Scan ScanForTargets(); } else { if (!trackWhileOff && !powered) { JUtil.LogMessage(this, "Radar ran out of power and trackWhileOff is false, so clearing target"); FlightGlobals.fetch.SetVesselTarget(null); return; } // Target locked; tracking if (restrictTracking) { Vector3 vectorToTarget = (target.GetTransform().position - scanTransform.position); if (vectorToTarget.sqrMagnitude > maxRangeMetersSquared) { JUtil.LogMessage(this, "Target is out of range, losing lock"); FlightGlobals.fetch.SetVesselTarget(null); return; } float angle = Vector3.Angle(vectorToTarget.normalized, (scanTransformIsDockingNode) ? scanTransform.forward : scanTransform.up); if (angle > scanAngle) { JUtil.LogMessage(this, "Target is out of scan angle, losing lock"); FlightGlobals.fetch.SetVesselTarget(null); return; } } if (powered && targetDockingPorts && (target is Vessel) && !(target as Vessel).packed) { // Attempt to refine our target. ModuleDockingNode closestNode = null; float closestDistance = float.MaxValue; var l = (target as Vessel).FindPartModulesImplementing <ModuleDockingNode>(); if (l != null) { for (int i = 0; i < l.Count; ++i) { if (l[i].state == "Ready" && (string.IsNullOrEmpty(nodeType) || nodeType == l[i].nodeType)) { Vector3 vectorToTarget = (l[i].part.transform.position - scanTransform.position); if (vectorToTarget.sqrMagnitude < closestDistance) { closestDistance = vectorToTarget.sqrMagnitude; closestNode = l[i]; } } } } if (closestNode != null) { // This seems to be triggering continuously for // ranges > 0.2km. How do I determine // programmatically that I can target a docking // port? //JUtil.LogMessage(this, "Refining target to {1} at {0:0.000} km.", Mathf.Sqrt(closestDistance) * 0.001f, closestNode.vessel.vesselName); FlightGlobals.fetch.SetVesselTarget(closestNode); } } } } else if (target != null) { if (!trackWhileOff) { JUtil.LogMessage(this, "Radar is off and trackWhileOff is false, so clearing target"); FlightGlobals.fetch.SetVesselTarget(null); return; } if (restrictTracking) { Vector3 vectorToTarget = (target.GetTransform().position - scanTransform.position); if (vectorToTarget.sqrMagnitude > maxRangeMetersSquared) { JUtil.LogMessage(this, "Target is out of range, losing lock"); FlightGlobals.fetch.SetVesselTarget(null); return; } float angle = Vector3.Angle(vectorToTarget.normalized, (scanTransformIsDockingNode) ? scanTransform.forward : scanTransform.up); if (angle > scanAngle) { JUtil.LogMessage(this, "Target is out of scan angle, losing lock"); FlightGlobals.fetch.SetVesselTarget(null); return; } } } }
private void UpdateVP() { List <Part> ActiveEngines = new List <Part>(); ActiveEngines = GetListOfActivatedEngines(AV); VP.FlightStatus = (byte)AV.situation; //Orbit VP.CurrentOrbit = OrbUtil.GetOrbitData(AV.orbit); VP.VVI = (float)AV.verticalSpeed; VP.G = (float)AV.geeForce; double ASL = AV.mainBody.GetAltitude(AV.CoM); double AGL = (ASL - AV.terrainAltitude); if (AGL < ASL) { VP.RAlt = (float)AGL; } else { VP.RAlt = (float)ASL; } VP.Alt = (float)ASL; VP.Vsurf = (float)AV.srfSpeed; VP.Lat = (float)AV.latitude; VP.Lon = (float)AV.longitude; TempR = GetResourceTotal(AV, "LiquidFuel"); VP.LiquidFuelTot = TempR.Max; VP.LiquidFuel = TempR.Current; VP.LiquidFuelTotS = (float)ProspectForResourceMax("LiquidFuel", ActiveEngines); VP.LiquidFuelS = (float)ProspectForResource("LiquidFuel", ActiveEngines); TempR = GetResourceTotal(AV, "Oxidizer"); VP.OxidizerTot = TempR.Max; VP.Oxidizer = TempR.Current; VP.OxidizerTotS = (float)ProspectForResourceMax("Oxidizer", ActiveEngines); VP.OxidizerS = (float)ProspectForResource("Oxidizer", ActiveEngines); TempR = GetResourceTotal(AV, "ElectricCharge"); VP.EChargeTot = TempR.Max; VP.ECharge = TempR.Current; TempR = GetResourceTotal(AV, "MonoPropellant"); VP.MonoPropTot = TempR.Max; VP.MonoProp = TempR.Current; TempR = GetResourceTotal(AV, "IntakeAir"); VP.IntakeAirTot = TempR.Max; VP.IntakeAir = TempR.Current; TempR = GetResourceTotal(AV, "SolidFuel"); VP.SolidFuelTot = TempR.Max; VP.SolidFuel = TempR.Current; TempR = GetResourceTotal(AV, "XenonGas"); VP.XenonGasTot = TempR.Max; VP.XenonGas = TempR.Current; VP.MissionTime = (float)AV.missionTime; VP.UT = (float)Planetarium.GetUniversalTime(); VP.VOrbit = (float)AV.orbit.GetVel().magnitude; VP.MNTime = 0; VP.MNDeltaV = 0; VP.TargetDist = 0; VP.TargetV = 0; VP.HasTarget = (byte)(HasTarget() ? 1 : 0); //mathy stuff Quaternion rotationSurface; CoM = AV.CoM; up = (CoM - AV.mainBody.position).normalized; north = Vector3d.Exclude(up, (AV.mainBody.position + AV.mainBody.transform.up * (float)AV.mainBody.Radius) - CoM).normalized; east = Vector3d.Cross(up, north); rotationSurface = Quaternion.LookRotation(north, up); Vector3d attitude = Quaternion.Inverse(Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(AV.GetTransform().rotation) * rotationSurface).eulerAngles; VP.Roll = (float)((attitude.z > 180) ? (attitude.z - 360.0) : attitude.z); VP.Pitch = (float)((attitude.x > 180) ? (360.0 - attitude.x) : -attitude.x); VP.Heading = (float)attitude.y; Vector3d prograde = new Vector3d(0, 0, 0); switch (FlightGlobals.speedDisplayMode) { case FlightGlobals.SpeedDisplayModes.Surface: prograde = AV.srf_velocity.normalized; break; case FlightGlobals.SpeedDisplayModes.Orbit: prograde = AV.obt_velocity.normalized; break; case FlightGlobals.SpeedDisplayModes.Target: prograde = FlightGlobals.ship_tgtVelocity; break; } VP.Prograde = WorldVecToNavHeading(up, north, east, prograde); if (HasTarget()) { ITargetable t = AV.targetObject; VP.Target = WorldVecToNavHeading(up, north, east, t.GetTransform().position - AV.transform.position); VP.TargetDist = (float)Vector3.Distance(t.GetTransform().position, AV.transform.position); VP.TargetV = (float)FlightGlobals.ship_tgtVelocity.magnitude; if (t is Vessel) { attitude = Quaternion.Inverse(Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(t.GetVessel().GetTransform().rotation) * rotationSurface).eulerAngles; VP.TargetRotation.Pitch = (float)((attitude.x > 180) ? (360.0 - attitude.x) : -attitude.x); VP.TargetRotation.Heading = (float)attitude.y; } else if (t is ModuleDockingNode) { VP.TargetRotation = WorldVecToNavHeading(up, north, east, t.GetFwdVector()); } } if (AV.patchedConicSolver != null) { if (AV.patchedConicSolver.maneuverNodes != null) { if (AV.patchedConicSolver.maneuverNodes.Count > 0) { VP.MNTime = (UInt32)Math.Round(AV.patchedConicSolver.maneuverNodes[0].UT - Planetarium.GetUniversalTime()); VP.MNDeltaV = (float)AV.patchedConicSolver.maneuverNodes[0].GetBurnVector(AV.patchedConicSolver.maneuverNodes[0].patch).magnitude; //Added JS VP.Maneuver = WorldVecToNavHeading(up, north, east, AV.patchedConicSolver.maneuverNodes[0].GetBurnVector(AV.patchedConicSolver.maneuverNodes[0].patch)); } } } VP.MainControls = CalcMainControls(); VP.ActionGroups = CalcActionGroups(); VP.MaxOverHeat = GetMaxOverHeat(AV); VP.IAS = (float)AV.indicatedAirSpeed; VP.CurrentStage = (byte)StageManager.CurrentStage; VP.TotalStage = (byte)StageManager.StageCount; VP.SpeedMode = (byte)(FlightGlobals.speedDisplayMode + 1); VP.SASMode = GetSASMode(true); VP.timeWarpRateIndex = GetTimeWarpIndex(); }
// This is honestly very badly written code, probably the worst of what I have in this project. // Much of it dictated by the fact that I barely, if at all, understand what am I doing in vector mathematics, // the rest is because the problem is all built out of special cases. // Sorry. :) public bool RenderPFD(RenderTexture screen, float aspect) { if (screen == null || !startupComplete || HighLogic.LoadedSceneIsEditor) { return(false); } // Analysis disable once CompareOfFloatsByEqualityOperator if (aspect != cameraAspect) { cameraAspect = aspect; ballCamera.aspect = cameraAspect; } GL.Clear(true, true, backgroundColorValue); ballCamera.targetTexture = screen; Vector3d coM = vessel.findWorldCenterOfMass(); Vector3d up = (coM - vessel.mainBody.position).normalized; Vector3d velocityVesselOrbit = vessel.orbit.GetVel(); Vector3d velocityVesselOrbitUnit = velocityVesselOrbit.normalized; Vector3d velocityVesselSurface = velocityVesselOrbit - vessel.mainBody.getRFrmVel(coM); Vector3d velocityVesselSurfaceUnit = velocityVesselSurface.normalized; Vector3d radialPlus = Vector3d.Exclude(velocityVesselOrbit, up).normalized; Vector3d normalPlus = -Vector3d.Cross(radialPlus, velocityVesselOrbitUnit); //Vector3d targetDirection = -FlightGlobals.fetch.vesselTargetDirection.normalized; Vector3d targetDirection = FlightGlobals.ship_tgtVelocity.normalized; navBall.transform.rotation = MirrorX(stockNavBall.navBall.rotation); if (heading != null) { Vector3d north = Vector3d.Exclude(up, (vessel.mainBody.position + (Vector3d)vessel.mainBody.transform.up * vessel.mainBody.Radius) - coM).normalized; Quaternion rotationSurface = Quaternion.LookRotation(north, up); Quaternion rotationVesselSurface = Quaternion.Inverse(Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(vessel.GetTransform().rotation) * rotationSurface); heading.renderer.material.SetTextureOffset("_MainTex", new Vector2(JUtil.DualLerp(0f, 1f, 0f, 360f, rotationVesselSurface.eulerAngles.y) - headingSpan / 2f, 0)); } Quaternion gymbal = stockNavBall.attitudeGymbal; switch (FlightUIController.speedDisplayMode) { case FlightUIController.SpeedDisplayModes.Surface: MoveMarker(markerPrograde, velocityVesselSurfaceUnit, progradeColorValue, gymbal); MoveMarker(markerRetrograde, -velocityVesselSurfaceUnit, progradeColorValue, gymbal); break; case FlightUIController.SpeedDisplayModes.Target: MoveMarker(markerPrograde, targetDirection, progradeColorValue, gymbal); MoveMarker(markerRetrograde, -targetDirection, progradeColorValue, gymbal); break; case FlightUIController.SpeedDisplayModes.Orbit: MoveMarker(markerPrograde, velocityVesselOrbitUnit, progradeColorValue, gymbal); MoveMarker(markerRetrograde, -velocityVesselOrbitUnit, progradeColorValue, gymbal); break; } MoveMarker(markerNormal, normalPlus, normalColorValue, gymbal); MoveMarker(markerNormalMinus, -normalPlus, normalColorValue, gymbal); MoveMarker(markerRadial, radialPlus, radialColorValue, gymbal); MoveMarker(markerRadialMinus, -radialPlus, radialColorValue, gymbal); if (vessel.patchedConicSolver != null && vessel.patchedConicSolver.maneuverNodes.Count > 0) { Vector3d burnVector = vessel.patchedConicSolver.maneuverNodes[0].GetBurnVector(vessel.orbit); MoveMarker(markerManeuver, burnVector.normalized, maneuverColorValue, gymbal); MoveMarker(markerManeuverMinus, -burnVector.normalized, maneuverColorValue, gymbal); ShowHide(true, markerManeuver, markerManeuverMinus); } ITargetable target = FlightGlobals.fetch.VesselTarget; if (target != null) { Vector3 targetSeparation = (vessel.GetTransform().position - target.GetTransform().position).normalized; MoveMarker(markerTarget, targetSeparation, targetColorValue, gymbal); MoveMarker(markerTargetMinus, -targetSeparation, targetColorValue, gymbal); var targetPort = target as ModuleDockingNode; if (targetPort != null) { // Thanks to Michael Enßlin Transform targetTransform = targetPort.transform; Transform selfTransform = vessel.ReferenceTransform; Vector3 targetOrientationVector = -targetTransform.up.normalized; Vector3 v1 = Vector3.Cross(selfTransform.up, targetTransform.forward); Vector3 v2 = Vector3.Cross(selfTransform.up, selfTransform.forward); float angle = Vector3.Angle(v1, v2); if (Vector3.Dot(selfTransform.up, Vector3.Cross(v1, v2)) < 0) { angle = -angle; } MoveMarker(markerDockingAlignment, targetOrientationVector, dockingColorValue, gymbal); markerDockingAlignment.transform.Rotate(Vector3.up, -angle); ShowHide(true, markerDockingAlignment); } ShowHide(true, markerTarget, markerTargetMinus); } // This dirty hack reduces the chance that the ball might get affected by internal cabin lighting. int backupQuality = QualitySettings.pixelLightCount; QualitySettings.pixelLightCount = 0; ShowHide(true, cameraBody, navBall, overlay, heading, markerPrograde, markerRetrograde, markerNormal, markerNormalMinus, markerRadial, markerRadialMinus); ballCamera.Render(); QualitySettings.pixelLightCount = backupQuality; ShowHide(false, cameraBody, navBall, overlay, heading, markerPrograde, markerRetrograde, markerManeuver, markerManeuverMinus, markerTarget, markerTargetMinus, markerNormal, markerNormalMinus, markerRadial, markerRadialMinus, markerDockingAlignment); return(true); }
public override void OnFixedUpdate() { //Restore the saved target when we are made active vessel if (!wasActiveVessel && vessel.isActiveVessel) { if (target != null && target.GetVessel() != null) { FlightGlobals.fetch.SetVesselTarget(target); } } //notice when the user switches targets if (vessel.isActiveVessel && target != FlightGlobals.fetch.VesselTarget) { target = FlightGlobals.fetch.VesselTarget; if (target is Vessel && ((Vessel)target).LandedOrSplashed && (((Vessel)target).mainBody == vessel.mainBody)) { targetBody = vessel.mainBody; targetLatitude = vessel.mainBody.GetLatitude(target.GetTransform().position); targetLongitude = vessel.mainBody.GetLongitude(target.GetTransform().position); } } // .23 temp fix until I understand better what's going on if (targetBody == null) targetBody = vessel.mainBody; //Update targets that need updating: if (target is DirectionTarget) ((DirectionTarget)target).Update(targetDirection); else if (target is PositionTarget) ((PositionTarget)target).Update(targetBody, targetLatitude, targetLongitude); wasActiveVessel = vessel.isActiveVessel; }
public bool RenderCamera(RenderTexture screen, float cameraAspect) { // Just in case. if (HighLogic.LoadedSceneIsEditor) { return(false); } if (cameras.Count < 1) { return(false); } var activeCamera = cameras[currentCamera]; if (string.IsNullOrEmpty(activeCamera.cameraTransform)) { return(false); } if (cameraObject == null) { cameraObject = new FlyingCamera(part, cameraAspect); cameraObject.PointCamera(activeCamera.cameraTransform, activeCamera.currentFoV); } cameraObject.FOV = activeCamera.currentFoV; if (rentexWidth == 0) { rentexWidth = screen.width; rentexHeight = screen.height; // Note to self: when rentex dims != screen dims, the FOV seems to be wrong (like FOV is smaller). } if (renderTex == null) { renderTex = new RenderTexture(rentexWidth, rentexHeight, screen.depth); renderTex.Create(); } // Negate pitch - the camera object treats a negative pitch as "up" if (cameraObject.Render(renderTex, activeCamera.currentYaw, -activeCamera.currentPitch)) { if (cameraEffectMaterial != null) { cameraEffectMaterial.SetVector("_ImageDims", new Vector4((float)renderTex.width, (float)renderTex.height, 1.0f / (float)renderTex.width, 1.0f / (float)renderTex.height)); for (int i = 0; i < ceVariables.Count; ++i) { float value = ceVariables[i].value.AsFloat(); cameraEffectMaterial.SetFloat(ceVariables[i].variable, value); } Graphics.Blit(renderTex, screen, cameraEffectMaterial); } else { Graphics.Blit(renderTex, screen); } renderTex.DiscardContents(); ITargetable target = FlightGlobals.fetch.VesselTarget; bool drawSomething = ((gizmoTexture != null && target != null && showTargetIcon) || homeCrosshairMaterial.color.a > 0); if (drawSomething) { GL.PushMatrix(); GL.LoadPixelMatrix(0, screen.width, screen.height, 0); } if (gizmoTexture != null && target != null && showTargetIcon) { // Figure out which direction the target is. Vector3 targetDisplacement = target.GetTransform().position - cameraObject.GetTransform().position; targetDisplacement.Normalize(); // Transform it using the active camera's rotation. var targetDisp = GetNormalizedScreenPosition(activeCamera, targetDisplacement, cameraAspect); var iconCenter = new Vector2(screen.width * targetDisp.x, screen.height * targetDisp.y); // Apply some clamping values to force the icon to stay on screen iconCenter.x = Math.Max(iconPixelSize * 0.5f, iconCenter.x); iconCenter.x = Math.Min(screen.width - iconPixelSize * 0.5f, iconCenter.x); iconCenter.y = Math.Max(iconPixelSize * 0.5f, iconCenter.y); iconCenter.y = Math.Min(screen.height - iconPixelSize * 0.5f, iconCenter.y); var position = new Rect(iconCenter.x - iconPixelSize * 0.5f, iconCenter.y - iconPixelSize * 0.5f, iconPixelSize, iconPixelSize); Graphics.DrawTexture(position, gizmoTexture, GizmoIcons.GetIconLocation(GizmoIcons.IconType.TARGETPLUS), 0, 0, 0, 0, iconMaterial); } if (homeCrosshairMaterial.color.a > 0) { // Mihara: Reference point cameras are different enough to warrant it. var cameraForward = cameraObject.GetTransformForward(); var crossHairCenter = GetNormalizedScreenPosition(activeCamera, cameraForward, cameraAspect); crossHairCenter.x *= screen.width; crossHairCenter.y *= screen.height; crossHairCenter.x = Math.Max(iconPixelSize * 0.5f, crossHairCenter.x); crossHairCenter.x = Math.Min(screen.width - iconPixelSize * 0.5f, crossHairCenter.x); crossHairCenter.y = Math.Max(iconPixelSize * 0.5f, crossHairCenter.y); crossHairCenter.y = Math.Min(screen.height - iconPixelSize * 0.5f, crossHairCenter.y); float zoomAdjustedIconSize = iconPixelSize * Mathf.Tan(Mathf.Deg2Rad * activeCamera.fovLimits.y * 0.5f) / Mathf.Tan(Mathf.Deg2Rad * activeCamera.currentFoV * 0.5f); homeCrosshairMaterial.SetPass(0); GL.Begin(GL.LINES); GL.Vertex3(crossHairCenter.x - zoomAdjustedIconSize * 0.5f, crossHairCenter.y, 0.0f); GL.Vertex3(crossHairCenter.x + zoomAdjustedIconSize * 0.5f, crossHairCenter.y, 0.0f); GL.Vertex3(crossHairCenter.x, crossHairCenter.y - zoomAdjustedIconSize * 0.5f, 0.0f); GL.Vertex3(crossHairCenter.x, crossHairCenter.y + zoomAdjustedIconSize * 0.5f, 0.0f); GL.End(); } if (drawSomething) { GL.PopMatrix(); } return(true); } else if (skipMissingCameras) { // This will handle cameras getting ejected while in use. SelectNextCamera(); } return(false); }
public void FixedUpdate() { if (HighLogic.LoadedSceneIsEditor) { return; } ITargetable target = FlightGlobals.fetch.VesselTarget; if (radarEnabled) { bool powered = true; // Resources check if (resourceAmount > 0.0f) { float requested = resourceAmount * TimeWarp.fixedDeltaTime; float supplied = part.RequestResource(resourceId, requested); if (supplied < requested * 0.5f) { powered = false; } } if (target == null) { if (!powered) { JUtil.LogMessage(this, "Want to scan, but there's no power"); return; } // Scan ScanForTargets(); } else { if (!trackWhileOff && !powered) { JUtil.LogMessage(this, "Radar ran out of power and trackWhileOff is false, so clearing target"); FlightGlobals.fetch.SetVesselTarget(null); return; } // Target locked; tracking if (restrictTracking) { Vector3 vectorToTarget = (target.GetTransform().position - scanTransform.position); if (vectorToTarget.sqrMagnitude > maxRangeMetersSquared) { JUtil.LogMessage(this, "Target is out of range, losing lock"); FlightGlobals.fetch.SetVesselTarget(null); return; } float dotAngle = Vector3.Dot(vectorToTarget.normalized, (scanTransformIsDockingNode) ? scanTransform.forward : scanTransform.up); if (dotAngle < scanDotValue) { JUtil.LogMessage(this, "Target is out of scan angle, losing lock"); FlightGlobals.fetch.SetVesselTarget(null); return; } } if (powered && targetDockingPorts && (target is Vessel)) { // Attempt to refine our target. } } } else if (target != null) { if (!trackWhileOff) { JUtil.LogMessage(this, "Radar is off and trackWhileOff is false, so clearing target"); FlightGlobals.fetch.SetVesselTarget(null); return; } if (restrictTracking) { Vector3 vectorToTarget = (target.GetTransform().position - scanTransform.position); if (vectorToTarget.sqrMagnitude > maxRangeMetersSquared) { JUtil.LogMessage(this, "Target is out of range, losing lock"); FlightGlobals.fetch.SetVesselTarget(null); return; } float dotAngle = Vector3.Dot(vectorToTarget.normalized, (scanTransformIsDockingNode) ? scanTransform.forward : scanTransform.up); if (dotAngle < scanDotValue) { JUtil.LogMessage(this, "Target is out of scan angle, losing lock"); FlightGlobals.fetch.SetVesselTarget(null); return; } } } }
public bool RenderCamera(RenderTexture screen, float cameraAspect) { // Just in case. if (!HighLogic.LoadedSceneIsFlight) { return(false); } if (cameras.Count < 1) { return(false); } var activeCamera = cameras[currentCamera]; if (string.IsNullOrEmpty(activeCamera.cameraTransform)) { return(false); } if (cameraObject == null) { cameraObject = new FlyingCamera(part, screen, cameraAspect); cameraObject.PointCamera(activeCamera.cameraTransform, activeCamera.currentFoV); } cameraObject.FOV = activeCamera.currentFoV; // Negate pitch - the camera object treats a negative pitch as "up" if (cameraObject.Render(activeCamera.currentYaw, -activeCamera.currentPitch)) { ITargetable target = FlightGlobals.fetch.VesselTarget; bool drawSomething = ((gizmoTexture != null && target != null && showTargetIcon) || homeCrosshairMaterial.color.a > 0); if (drawSomething) { GL.PushMatrix(); GL.LoadPixelMatrix(0, screen.width, screen.height, 0); } if (gizmoTexture != null && target != null && showTargetIcon) { // Figure out which direction the target is. Vector3 targetDisplacement = target.GetTransform().position - cameraObject.GetTransform().position; targetDisplacement.Normalize(); // Transform it using the active camera's rotation. var targetDisp = GetNormalizedScreenPosition(activeCamera, targetDisplacement, cameraAspect); var iconCenter = new Vector2(screen.width * targetDisp.x, screen.height * targetDisp.y); // Apply some clamping values to force the icon to stay on screen iconCenter.x = Math.Max(iconPixelSize * 0.5f, iconCenter.x); iconCenter.x = Math.Min(screen.width - iconPixelSize * 0.5f, iconCenter.x); iconCenter.y = Math.Max(iconPixelSize * 0.5f, iconCenter.y); iconCenter.y = Math.Min(screen.height - iconPixelSize * 0.5f, iconCenter.y); var position = new Rect(iconCenter.x - iconPixelSize * 0.5f, iconCenter.y - iconPixelSize * 0.5f, iconPixelSize, iconPixelSize); Graphics.DrawTexture(position, gizmoTexture, GizmoIcons.GetIconLocation(GizmoIcons.IconType.TARGETPLUS), 0, 0, 0, 0, iconMaterial); } if (homeCrosshairMaterial.color.a > 0) { // Mihara: Reference point cameras are different enough to warrant it. var cameraForward = cameraObject.GetTransformForward(); var crossHairCenter = GetNormalizedScreenPosition(activeCamera, cameraForward, cameraAspect); crossHairCenter.x *= screen.width; crossHairCenter.y *= screen.height; crossHairCenter.x = Math.Max(iconPixelSize * 0.5f, crossHairCenter.x); crossHairCenter.x = Math.Min(screen.width - iconPixelSize * 0.5f, crossHairCenter.x); crossHairCenter.y = Math.Max(iconPixelSize * 0.5f, crossHairCenter.y); crossHairCenter.y = Math.Min(screen.height - iconPixelSize * 0.5f, crossHairCenter.y); float zoomAdjustedIconSize = iconPixelSize * Mathf.Tan(Mathf.Deg2Rad * activeCamera.fovLimits.y * 0.5f) / Mathf.Tan(Mathf.Deg2Rad * activeCamera.currentFoV * 0.5f); homeCrosshairMaterial.SetPass(0); GL.Begin(GL.LINES); GL.Vertex3(crossHairCenter.x - zoomAdjustedIconSize * 0.5f, crossHairCenter.y, 0.0f); GL.Vertex3(crossHairCenter.x + zoomAdjustedIconSize * 0.5f, crossHairCenter.y, 0.0f); GL.Vertex3(crossHairCenter.x, crossHairCenter.y - zoomAdjustedIconSize * 0.5f, 0.0f); GL.Vertex3(crossHairCenter.x, crossHairCenter.y + zoomAdjustedIconSize * 0.5f, 0.0f); GL.End(); } if (drawSomething) { GL.PopMatrix(); } return(true); } return(false); }
/// <summary> /// Forces the controller to pick a target to track. In order of preference: /// 1) A player-selected target. /// 2) A target vessel specified by the targetVessel variable. /// 3) A target celestial body specified by the targetBody variable. /// 4) A random target if trackRandomTargets is set to true. /// </summary> /// <returns></returns> public bool UpdateTarget() { ITargetable targetObject = this.part.vessel.targetObject; //chek for unset if (targetObject == null && targetObjectSet) { targetTransform = null; targetObjectSet = false; } //If we already have a target to track then we're good to go. if (targetTransform != null && targetObject == null) { return(true); } //First check to see if the vessel has selected a target. if (targetObject != null && canTrackPlayerTargets) { targetTransform = targetObject.GetTransform(); trackingStatus = targetObject.GetDisplayName().Replace("^N", ""); targetName = trackingStatus; targetObjectSet = true; return(true); } //Next check to see if we have a target vessel if (targetVessel != null) { targetTransform = targetVessel.vesselTransform; trackingStatus = targetVessel.vesselName; targetName = trackingStatus; return(true); } //Now check target planet if (targetBody != null) { targetTransform = targetBody.scaledBody.transform; trackingStatus = targetBody.displayName.Replace("^N", ""); targetName = trackingStatus; return(true); } //Lastly, if random tracking is enabled and we don't have a target, then randomly select one from the unloaded vessels list. if (trackRandomObjects && targetTransform == null) { //get the tracking controllers on the vessel List <WBIBGTrackingServo> trackingControllers = this.part.vessel.FindPartModulesImplementing <WBIBGTrackingServo>(); //If we aren't the first controller, then we're done. if (trackingControllers[0] != this) { trackingStatus = trackingControllers[0].trackingStatus; targetTransform = trackingControllers[0].targetTransform; targetName = trackingStatus; return(false); } //Find a random vessel to track int vesselCount = FlightGlobals.VesselsUnloaded.Count; Vessel trackedVessel; for (int index = 0; index < vesselCount; index++) { trackedVessel = FlightGlobals.VesselsUnloaded[UnityEngine.Random.Range(0, vesselCount - 1)]; //If we find a vessel we're interested in, tell all the other tracking controllers. if (trackedVessel.vesselType != VesselType.Flag && trackedVessel.vesselType != VesselType.EVA && trackedVessel.vesselType != VesselType.Unknown) { int controllerCount = trackingControllers.Count; for (int controllerIndex = 0; controllerIndex < controllerCount; controllerIndex++) { if (!trackingControllers[controllerIndex].trackRandomObjects) { continue; } trackingControllers[controllerIndex].targetTransform = trackedVessel.vesselTransform; trackingControllers[controllerIndex].trackingStatus = trackedVessel.vesselName; trackingControllers[controllerIndex].targetName = trackedVessel.vesselName; } return(true); } } } //Nothing to track trackingStatus = kTrackingNone; targetName = trackingStatus; return(false); }