private static Location KSCLocation() { CelestialBody home = FlightGlobals.Bodies.Where(cb => cb.isHomeWorld).First(); PQSCity ksc = home.GetComponentsInChildren <PQSCity>(true).Where(pqs => pqs.name == "KSC").First(); return(new Location(home, home.GetLatitude(ksc.transform.position), home.GetLongitude(ksc.transform.position))); }
protected bool isNearAnomaly() { CelestialBody mainBody = this.part.vessel.mainBody; PQSSurfaceObject[] anomalies = mainBody.pqsSurfaceObjects; double longitude; double latitude; double distance = 0f; if (this.part.vessel.situation == Vessel.Situations.LANDED || this.part.vessel.situation == Vessel.Situations.PRELAUNCH) { for (int index = 0; index < anomalies.Length; index++) { if (requiredAnomalies.Contains(anomalies[index].SurfaceObjectName)) { //Get the longitude and latitude of the anomaly longitude = mainBody.GetLongitude(anomalies[index].transform.position); latitude = mainBody.GetLatitude(anomalies[index].transform.position); //Get the distance (in meters) from the anomaly. distance = Utils.HaversineDistance(longitude, latitude, this.part.vessel.longitude, this.part.vessel.latitude, this.part.vessel.mainBody) * 1000; //If we're near the anomaly, then we're done if (distance <= minAnomalyRange) { return(true); } } } } //Not near anomaly or not close enough return(false); }
public static Coordinates SurfacePoint(Vector3 worldPos, CelestialBody body) { var c = new Coordinates(body.GetLatitude(worldPos), body.GetLongitude(worldPos), 0); c.SetAlt2Surface(body); return(c); }
//******************************************************* public static Vector3 SimAeroForce(CelestialBody body, IShipconstruct vessel, Vector3 v_wrld_vel, Vector3 position) { double latitude = body.GetLatitude(position) / 180.0 * Math.PI; double altitude = (position - body.position).magnitude - body.Radius; return(SimAeroForce(body, vessel, v_wrld_vel, altitude, latitude)); }
//******************************************************* public static Vector3 SimAeroForce(List <Part> parts, CelestialBody body, Vector3 v_wrld_vel, Vector3 position) { double latitude = body.GetLatitude(position) / 180.0 * Math.PI; double altitude = (position - body.position).magnitude - body.Radius; return(SimAeroForce(parts, body, v_wrld_vel, altitude, latitude)); }
// Credits to https://github.com/jrossignol/WaypointManager/blob/master/source/WaypointManager/CustomWaypointGUI.cs // for this code public static bool GetBodyRayIntersect(CelestialBody targetBody, bool map, out double latitude, out double longitude, out double altitude) { latitude = 0; longitude = 0; altitude = 0; if (targetBody.pqsController == null) { return(false); } Ray mouseRay = map ? PlanetariumCamera.Camera.ScreenPointToRay(Input.mousePosition) : FlightCamera.fetch.mainCamera.ScreenPointToRay(Input.mousePosition); if (map) // use scaled space { mouseRay.origin = ScaledSpace.ScaledToLocalSpace(mouseRay.origin); } var bodyToOrigin = mouseRay.origin - targetBody.position; double curRadius = targetBody.pqsController.radiusMax; double lastRadius = 0; int loops = 0; while (loops < 10) { Vector3d relSurfacePosition; if (PQS.LineSphereIntersection(bodyToOrigin, mouseRay.direction, curRadius, out relSurfacePosition)) { var surfacePoint = targetBody.position + relSurfacePosition; double alt = targetBody.pqsController.GetSurfaceHeight( QuaternionD.AngleAxis(targetBody.GetLongitude(surfacePoint), Vector3d.down) * QuaternionD.AngleAxis(targetBody.GetLatitude(surfacePoint), Vector3d.forward) * Vector3d.right); double error = Math.Abs(curRadius - alt); if (error < (targetBody.pqsController.radiusMax - targetBody.pqsController.radiusMin) / 500) { latitude = targetBody.GetLatitude(surfacePoint); longitude = targetBody.GetLongitude(surfacePoint); altitude = targetBody.TerrainAltitude(latitude, longitude); return(true); } else { lastRadius = curRadius; curRadius = 0.5 * alt + 0.5 * curRadius; loops++; } } else { if (loops == 0) { break; } // Went too low, needs to try higher else { curRadius = (lastRadius * 9 + curRadius) / 10; loops++; } } } return(true); }
public static double GetPressure(Vector3 position, CelestialBody body) { double latitude = body.GetLatitude(position) / 180.0 * Math.PI; double altitude = (position - body.position).magnitude - body.Radius; return GetPressure(altitude, latitude, body); }
private void GeneratePQSCityCoordinates(WaypointData wpData, CelestialBody body) { LoggingUtil.LogVerbose(this, " pqs city: {0}", wpData.pqsCity); LoggingUtil.LogVerbose(this, " Generating a waypoint based on PQS city {0}...", wpData.pqsCity.name); Vector3d position = wpData.pqsCity.transform.position; LoggingUtil.LogVerbose(this, " pqs city position = {0}", position); // Translate by the PQS offset (inverse transform of coordinate system) Vector3d v = wpData.pqsOffset; Vector3d i = wpData.pqsCity.transform.right; Vector3d j = wpData.pqsCity.transform.forward; Vector3d k = wpData.pqsCity.transform.up; LoggingUtil.LogVerbose(this, " i, j, k = {0}, {1}, {2}", i, j, k); LoggingUtil.LogVerbose(this, " pqs transform = {0}", wpData.pqsCity.transform); LoggingUtil.LogVerbose(this, " parent transform = {0}", wpData.pqsCity.transform.parent); Vector3d offsetPos = new Vector3d( (j.y * k.z - j.z * k.y) * v.x + (i.z * k.y - i.y * k.z) * v.y + (i.y * j.z - i.z * j.y) * v.z, (j.z * k.x - j.x * k.z) * v.x + (i.x * k.z - i.z * k.x) * v.y + (i.z * j.x - i.x * j.z) * v.z, (j.x * k.y - j.y * k.x) * v.x + (i.y * k.x - i.x * k.y) * v.y + (i.x * j.y - i.y * j.x) * v.z ); offsetPos *= (i.x * j.y * k.z) + (i.y * j.z * k.x) + (i.z * j.x * k.y) - (i.z * j.y * k.x) - (i.y * j.x * k.z) - (i.x * j.z * k.y); wpData.waypoint.latitude = body.GetLatitude(position + offsetPos); wpData.waypoint.longitude = body.GetLongitude(position + offsetPos); LoggingUtil.LogVerbose(this, " resulting lat, lon = ({0}, {1})", wpData.waypoint.latitude, wpData.waypoint.longitude); }
public static Vector3d WorldPositionToGeoCoords(Vector3d worldPosition, CelestialBody body) { if (!body) { return(Vector3d.zero); } var _lat = body.GetLatitude(worldPosition); var _lon = body.GetLongitude(worldPosition); var _random = new System.Random().Next(0, 10); var random = _random / 5; double lat_ = 0.0f; double lon_ = 0.0f; if (_random <= 5) { lat_ = _lat + (random / 10000); lon_ = _lon + (random / 10000); } else { lat_ = _lat + (random / -10000); lon_ = _lon + (random / -10000); } double lat = lat_; double longi = lon_; double alt = body.GetAltitude(worldPosition); Debug.Log("[Spawn OrX ODST] Lat: " + lat + " - Lon:" + longi + " - Alt: " + alt); return(new Vector3d(lat, longi, alt)); }
public static ConfigNode GenerateILSConfig(string siteName, Vector3 endpoint, float heading) { CelestialBody body = FlightGlobals.ActiveVessel.mainBody; Vector2d localizer = GenerateLocalizerCoords((Vector3d)endpoint, heading); ConfigNode ILScfg = new ConfigNode(); ILScfg.name = cfgNodeName; ILScfg.AddValue("ident", siteName); // Well, if we make it editable, than NavUtilities will save this runway into custom.cfg // And next time there will be two duplicate runways. Not a good thing. // We'll try to address it from NavUtilities side // ILScfg.AddValue ("custom", "True"); // Make it editable via NavUtils menu ILScfg.AddValue("shortID", siteName); ILScfg.AddValue("hdg", heading); ILScfg.AddValue("body", body.name); ILScfg.AddValue("altMSL", body.GetAltitude((Vector3d)endpoint)); ILScfg.AddValue("gsLatitude", body.GetLatitude(endpoint)); ILScfg.AddValue("gsLongitude", body.GetLongitude(endpoint)); ILScfg.AddValue("locLatitude", localizer.x); ILScfg.AddValue("locLongitude", localizer.y); // marker distances are blankly hardcoded as of now ILScfg.AddValue("outerMarkerDist", 8000); ILScfg.AddValue("middleMarkerDist", 2000); ILScfg.AddValue("innerMarkerDist", 300); ConfigNode wrapper = new ConfigNode(); wrapper.AddNode(ILScfg); return(wrapper); }
public Vector3d Up() { double lat = body.GetLatitude(center); double lon = body.GetLongitude(center); return(body.GetSurfaceNVector(lat, lon)); }
} // So many ifs..... // Cinically stolen from Waypoint Manager source code :D private void PlaceTargetAtCursor() { CelestialBody targetBody = this.vessel.mainBody; if (targetBody.pqsController == null) { return; } Ray mouseRay = PlanetariumCamera.Camera.ScreenPointToRay(Input.mousePosition); mouseRay.origin = ScaledSpace.ScaledToLocalSpace(mouseRay.origin); var bodyToOrigin = mouseRay.origin - targetBody.position; double curRadius = targetBody.pqsController.radiusMax; double lastRadius = 0; int loops = 0; while (loops < 50) { Vector3d relSurfacePosition; if (PQS.LineSphereIntersection(bodyToOrigin, mouseRay.direction, curRadius, out relSurfacePosition)) { var surfacePoint = targetBody.position + relSurfacePosition; double alt = targetBody.pqsController.GetSurfaceHeight( QuaternionD.AngleAxis(targetBody.GetLongitude(surfacePoint), Vector3d.down) * QuaternionD.AngleAxis(targetBody.GetLatitude(surfacePoint), Vector3d.forward) * Vector3d.right); double error = Math.Abs(curRadius - alt); if (error < (targetBody.pqsController.radiusMax - targetBody.pqsController.radiusMin) / 100) { targetLatitude = (targetBody.GetLatitude(surfacePoint) + 360) % 360; targetLongitude = (targetBody.GetLongitude(surfacePoint) + 360) % 360; /* this.distanceToTarget = GeoUtils.GetDistance( * this.vessel.latitude, this.vessel.longitude, this.targetLatitude, this.targetLongitude, this.vessel.mainBody.Radius * ); * this.distanceTravelled = 0;*/ return; } else { lastRadius = curRadius; curRadius = alt; loops++; } } else { if (loops == 0) { break; } // Went too low, needs to try higher else { curRadius = (lastRadius * 9 + curRadius) / 10; loops++; } } } }
public static void logPlanetaryPosition(Vector3 v, CelestialBody planet) { double lng = planet.GetLongitude(v); double lat = planet.GetLatitude(v); double alt = planet.GetAltitude(v); Debug.Log(formatVector(planet.GetWorldSurfacePosition(lat, lng, alt))); }
public static void logLongLatAlt(Vector3 v, CelestialBody planet) { double lng = planet.GetLongitude(v); double lat = planet.GetLatitude(v); double alt = planet.GetAltitude(v); Debug.Log(string.Format("Long: {0}, Lat: {1}, Alt: {2}", lng, lat, alt)); }
public static void logLongLatAlt(Vector3 v, CelestialBody planet) { double lng = planet.GetLongitude(v); double lat = planet.GetLatitude(v); double alt = planet.GetAltitude(v); Utils.Log("Long: {}, Lat: {}, Alt: {}", lng, lat, alt); }
//******************************************************* public static Vector3d SimAeroForce(Vector3d v_wrld_vel, Vector3 position) { CelestialBody body = Trajectories.AttachedVessel.mainBody; double latitude = body.GetLatitude(position) / 180.0 * Math.PI; double altitude = (position - body.position).magnitude - body.Radius; return(SimAeroForce(v_wrld_vel, altitude, latitude)); }
public static Vector3d planetaryPosition(Vector3 v, CelestialBody planet) { double lng = planet.GetLongitude(v); double lat = planet.GetLatitude(v); double alt = planet.GetAltitude(v); return(planet.GetWorldSurfacePosition(lat, lng, alt)); }
/// <summary> /// Place target at cursor in the map mode. Borrowed Waypoint Manager and changed. /// Returns latitude and longitude of a target or double.MinValue, if target is not valid /// </summary> /// <param name="targetBody"></param> /// <returns>[latitude, longitude]</returns> internal static double[] PlaceTargetAtCursor(CelestialBody targetBody) { if (targetBody.pqsController == null) { return new double[2] { double.MinValue, double.MinValue } } ; Ray mouseRay = PlanetariumCamera.Camera.ScreenPointToRay(Input.mousePosition); mouseRay.origin = ScaledSpace.ScaledToLocalSpace(mouseRay.origin); var bodyToOrigin = mouseRay.origin - targetBody.position; double curRadius = targetBody.pqsController.radiusMax; double lastRadius = 0; int loops = 0; while (loops < 50) { Vector3d relSurfacePosition; if (PQS.LineSphereIntersection(bodyToOrigin, mouseRay.direction, curRadius, out relSurfacePosition)) { var surfacePoint = targetBody.position + relSurfacePosition; double alt = targetBody.pqsController.GetSurfaceHeight(QuaternionD.AngleAxis(targetBody.GetLongitude(surfacePoint), Vector3d.down) * QuaternionD.AngleAxis(targetBody.GetLatitude(surfacePoint), Vector3d.forward) * Vector3d.right); double error = Math.Abs(curRadius - alt); if (error < (targetBody.pqsController.radiusMax - targetBody.pqsController.radiusMin) / 100) { return(new double[2] { (targetBody.GetLatitude(surfacePoint) + 360) % 360, (targetBody.GetLongitude(surfacePoint) + 360) % 360 }); } else { lastRadius = curRadius; curRadius = alt; loops++; } } else { if (loops == 0) { break; } else // Went too low, needs to try higher { curRadius = (lastRadius * 9 + curRadius) / 10; loops++; } } } return(new double[2] { double.MinValue, double.MinValue }); }
public override void OnFixedUpdate() { CelestialBody body = vessel.mainBody; ORSX_PlanetaryResourcePixel res_pixel = ORSX_PlanetaryResourceMapData.getResourceAvailability(vessel.mainBody.flightGlobalsIndex, resourceName, body.GetLatitude(vessel.transform.position), body.GetLongitude(vessel.transform.position)); abundance = res_pixel.getAmount(); }
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; }
private static float GetHeading(Transform transform) { CelestialBody body = FlightGlobals.ActiveVessel.mainBody; Vector3 upVector = body.GetSurfaceNVector(body.GetLatitude((Vector3d)transform.position), body.GetLongitude((Vector3d)transform.position)).normalized; Vector3 north = Vector3.ProjectOnPlane(body.transform.up, upVector).normalized; Vector3 east = Vector3.Cross(upVector, north).normalized; Vector3 forward = Vector3.ProjectOnPlane(transform.forward, upVector); return(Vector3.Angle(forward, north)); }
public static Vector3d WorldPositionToGeoCoords(Vector3d worldPosition, CelestialBody body) { if(!body) { return Vector3d.zero; } double lat = body.GetLatitude(worldPosition); double longi = body.GetLongitude(worldPosition); double alt = body.GetAltitude(worldPosition); return new Vector3d(lat,longi,alt); }
public static Vector3d WorldPositionToGeoCoords(Vector3d worldPosition, CelestialBody body) { if (!body) { return Vector3d.zero; } double lat = body.GetLatitude(worldPosition); double longi = body.GetLongitude(worldPosition); double alt = body.GetAltitude(worldPosition); return new Vector3d(lat, longi, alt); }
public static Location GetLocation(PQSCity city) { if (city == null) { return(null); } Vector3d position = city.transform.position; CelestialBody body = Part.GetComponentUpwards <CelestialBody>(city.sphere.gameObject); return(new Location(body, body.GetLatitude(position), body.GetLongitude(position))); }
protected float getAnomalyBonus() { CelestialBody mainBody = this.part.vessel.mainBody; PQSSurfaceObject[] anomalies = mainBody.pqsSurfaceObjects; double longitude; double latitude; double distance = 0f; ConfigNode[] anomalyBlacklists = GameDatabase.Instance.GetConfigNodes(kAnomalyBlacklistNode); string blacklist = kAnomalyBlacklist; //We've covered the stock anomalies, now make sure we can blacklist anomalies from mods. try { foreach (ConfigNode blacklistNode in anomalyBlacklists) { blacklist += ";" + blacklistNode.GetValue("anomalies"); } } catch { } if (this.part.vessel.situation == Vessel.Situations.LANDED || this.part.vessel.situation == Vessel.Situations.PRELAUNCH) { for (int index = 0; index < anomalies.Length; index++) { //If the anomaly is on the blacklist, skip it. if (blacklist.Contains(anomalies[index].SurfaceObjectName)) { continue; } //Get the longitude and latitude of the anomaly longitude = mainBody.GetLongitude(anomalies[index].transform.position); latitude = mainBody.GetLatitude(anomalies[index].transform.position); //Get the distance (in kilometers) from the anomaly. distance = Utils.HaversineDistance(longitude, latitude, this.part.vessel.longitude, this.part.vessel.latitude, this.part.vessel.mainBody); //If we're near the anomaly, then we get a big location bonus. if (distance < kMinAnomalyDistance) { anomalyName = anomalies[index].SurfaceObjectName; return(kAnomalyBonus); } } } //No bonus anomalyName = string.Empty; return(0f); }
public double PositionToLatitude(Vector pos) { CelestialBody parent = GetParentBody(); if (parent == null) //happens when this Orbitable is the Sun { return(0.0); } Vector3d unityWorldPos = GetPosition() + (Vector3d)Shared.Vessel.findWorldCenterOfMass(); return(Utils.DegreeFix(parent.GetLatitude(unityWorldPos), -180)); }
public double PositionToLatitude(Vector pos) { CelestialBody parent = Orbit.referenceBody; if (parent == null) //happens when this Orbitable is the Sun { return(0.0); } Vector3d unityWorldPos = GetPosition() + Shared.Vessel.GetWorldPos3D(); return(parent.GetLatitude(unityWorldPos)); }
private static void PlaceWaypointAtCursor() { if (targetBody.pqsController == null) { return; } Ray mouseRay = PlanetariumCamera.Camera.ScreenPointToRay(Input.mousePosition); mouseRay.origin = ScaledSpace.ScaledToLocalSpace(mouseRay.origin); var bodyToOrigin = mouseRay.origin - targetBody.position; double curRadius = targetBody.pqsController.radiusMax; double lastRadius = 0; int loops = 0; while (loops < 50) { Vector3d relSurfacePosition; if (PQS.LineSphereIntersection(bodyToOrigin, mouseRay.direction, curRadius, out relSurfacePosition)) { var surfacePoint = targetBody.position + relSurfacePosition; double alt = targetBody.pqsController.GetSurfaceHeight( QuaternionD.AngleAxis(targetBody.GetLongitude(surfacePoint), Vector3d.down) * QuaternionD.AngleAxis(targetBody.GetLatitude(surfacePoint), Vector3d.forward) * Vector3d.right); double error = Math.Abs(curRadius - alt); if (error < (targetBody.pqsController.radiusMax - targetBody.pqsController.radiusMin) / 100) { latitude = targetBody.GetLatitude(surfacePoint).ToString(); longitude = targetBody.GetLongitude(surfacePoint).ToString(); return; } else { lastRadius = curRadius; curRadius = alt; loops++; } } else { if (loops == 0) { break; } // Went too low, needs to try higher else { curRadius = (lastRadius * 9 + curRadius) / 10; loops++; } } } }
public static bool CBhit(CelestialBody body, out Vector2 latlon) { Vector3d hitA; Vector3 origin, dir; if (MapView.MapIsEnabled) { //Use Scaled camera and don't attempt physics raycast if in map view. Ray ray = ScaledCamera.Instance.camera.ScreenPointToRay(Input.mousePosition); origin = ScaledSpace.ScaledToLocalSpace(ray.origin); dir = ray.direction.normalized; } else { //Attempt ray cast and return results if successfull. Ray ray = FlightCamera.fetch.mainCamera.ScreenPointToRay(Input.mousePosition); RaycastHit hitB; float dist = (float)(Vector3.Distance(body.position, ray.origin) - body.Radius / 2); if (Physics.Raycast(ray, out hitB, dist)) { latlon = new Vector2((float)body.GetLatitude(hitB.point), (float)body.GetLongitude(hitB.point)); return(true); } //if all else fails, try with good oldfashioned arithmetic. origin = ray.origin; dir = ray.direction.normalized; } if (CBhit(body, origin, dir, out hitA)) { latlon = new Vector2((float)body.GetLatitude(hitA), (float)body.GetLongitude(hitA)); return(true); } else { latlon = Vector2.zero; return(false); } }
public static Vector3d WorldPositionToGeoCoords(Vector3d worldPosition, CelestialBody body) { if (!body) { return(Vector3d.zero); } double lat = body.GetLatitude(worldPosition); double longi = body.GetLongitude(worldPosition); double alt = body.GetAltitude(worldPosition); Debug.Log("[Spawn OrX Waldo Attack] Lat: " + lat + " - Lon:" + longi + " - Alt: " + alt); return(new Vector3d(lat, longi, alt)); }
void FixedUpdate() { if (param != null && param.starJeb != null) { if (param.velocity != null) { param.starJeb.SetPosition(param.starJeb.transform.position + (param.velocity.Value * Time.fixedDeltaTime)); } else if (param.Destination != null) { Vector3 direction = (param.starJeb.transform.position - param.Destination.Value).normalized; float t = Time.fixedTime - param.stepTime; float x = t / 8.0f - 1.0f; if (t + Time.fixedDeltaTime * 2.0f > 8.0f) { x = 0.0f; } if (param.starJeb.altitude < param.starJeb.terrainAltitude + 10.0f) { CelestialBody body = param.DestinationBody; double lat = body.GetLatitude(param.starJeb.transform.position); double lon = body.GetLongitude(param.starJeb.transform.position); param.starJeb.SetPosition(body.GetWorldSurfacePosition(lat, lon, param.starJeb.terrainAltitude + 10.0f)); } else { param.starJeb.SetPosition(param.Destination.Value + direction * param.startDistance * x * x); } } if (param.Destination != null) { // Adjust the velocity, but only every frame - adjusting this too frequently // seems to cause the velocity to resonate back and forth if (Time.frameCount != lastAdjustment) { lastAdjustment = Time.frameCount; param.starJeb.ChangeWorldVelocity(-param.starJeb.GetSrfVelocity()); // Keep us safe! foreach (Part p in param.starJeb.parts) { p.crashTolerance = 10000000.0f; } CheatOptions.NoCrashDamage = true; } } } }
public DMAnomalyObject(PQSCity City) { city = City; name = city.name; try { body = FlightGlobals.Bodies.FirstOrDefault(b => b.name == city.transform.parent.name); } catch (Exception e) { DMUtils.Logging("Something Went Wrong Here: {0}", e); } if (body != null) { worldLocation = city.transform.position; lat = clampLat(body.GetLatitude(worldLocation)); lon = clampLon(body.GetLongitude(worldLocation)); } }
public static string traceTrans(string prev, Transform tr, CelestialBody body = null) { string tmp; if (body != null) { tmp = prev + "." + tr.name + " - (" + body.GetLatitude(tr.position) + ", " + body.GetLongitude(tr.position) + ", " + body.GetAltitude(tr.position) + ")\n"; } else { tmp = prev + "." + tr.name + " - (" + tr.position + ", " + tr.rotation + ")\n"; } Component[] comps = tr.gameObject.GetComponents<Component>(); foreach (Component comp in comps) { tmp += "\t" + comp.GetType().Name + " - " + comp.name + "\n"; } for (int i = 0; i < tr.childCount; i++) { tmp += traceTrans(prev + "." + tr.name, tr.GetChild(i), body); } return tmp; }
public static Coordinates GetMouseCoordinates(CelestialBody body) { Ray mouseRay = PlanetariumCamera.Camera.ScreenPointToRay(Input.mousePosition); mouseRay.origin = ScaledSpace.ScaledToLocalSpace(mouseRay.origin); Vector3d relOrigin = mouseRay.origin - body.position; Vector3d relSurfacePosition; if (PQS.LineSphereIntersection(relOrigin, mouseRay.direction, body.Radius, out relSurfacePosition)) { Vector3d surfacePoint = body.position + relSurfacePosition; return new Coordinates(body.GetLatitude(surfacePoint), MuUtils.ClampDegrees180(body.GetLongitude(surfacePoint))); } else { return null; } }
// relativePosition is in world frame, but relative to the body (i.e. inertial body space) // returns the altitude above sea level (can be negative for bodies without ocean) private double GetGroundAltitude(CelestialBody body, Vector3 relativePosition) { if (body.pqsController == null) return 0; double lat = body.GetLatitude(relativePosition + body.position) / 180.0 * Math.PI; double lon = body.GetLongitude(relativePosition + body.position) / 180.0 * Math.PI; Vector3d rad = new Vector3d(Math.Cos(lat) * Math.Cos(lon), Math.Sin(lat), Math.Cos(lat) * Math.Sin(lon)); double elevation = body.pqsController.GetSurfaceHeight(rad) - body.Radius; if (body.ocean) elevation = Math.Max(elevation, 0.0); return elevation; }
public Vector3d getForces_StockAero(CelestialBody body, Vector3d bodySpacePosition, Vector3d airVelocity, double angleOfAttack, double dt) { Vector3 position = body.position + bodySpacePosition; double latitude = body.GetLatitude(position) / 180.0 * Math.PI; double altitude = (position - body.position).magnitude - body.Radius; if (altitude > body.atmosphereDepth) { return Vector3d.zero; } #if !USE_CACHE return computeForces_StockAero(altitude, airVelocity, new Vector3(0, 1, 0), angleOfAttack, dt); #else //double approxMachNumber = useNEAR ? 0.0 : (double)FARAeroUtil_GetMachNumber.Invoke(null, new object[] { body_, body.maxAtmosphereAltitude * 0.5, new Vector3d((float)airVelocity.magnitude, 0, 0) }); //Util.PostSingleScreenMessage("machNum", "machNumber = " + actualMachNumber + " ; approx machNumber = " + approxMachNumber); Vector2 force = getCachedForce(airVelocity.magnitude, altitude, angleOfAttack); Vector3d forward = airVelocity.normalized; Vector3d right = Vector3d.Cross(forward, bodySpacePosition).normalized; Vector3d up = Vector3d.Cross(right, forward).normalized; return forward * force.x + up * force.y; #endif }
private IEnumerator updateCoordinates(CelestialBody b) { yield return new WaitForSeconds(3); currentBodyAnomalies.Clear(); if (anomalies.ContainsKey(b.name)) { foreach (var anom in anomalies[b.name].Values) { anom.WorldLocation = anom.City.transform.position; anom.Lat = b.GetLatitude(anom.WorldLocation); anom.Lon = b.GetLongitude(anom.WorldLocation); } currentBodyAnomalies = anomalies[b.name].Values.ToList(); } else currentBodyAnomalies = new List<DMAnomalyObject>(); }
static Coordinates Search(CelestialBody body, Ray mouseRay) { Vector3d relSurfacePosition; Vector3d relOrigin = mouseRay.origin - body.position; double curRadius = body.pqsController.radiusMax; double lastRadius = 0; double error = 0; int loops = 0; float st = Time.time; while(loops < 50) { if(PQS.LineSphereIntersection(relOrigin, mouseRay.direction, curRadius, out relSurfacePosition)) { var alt = body.pqsController.GetSurfaceHeight(relSurfacePosition); if(body.ocean && alt < body.Radius) alt = body.Radius; error = Math.Abs(curRadius - alt); if(error < (body.pqsController.radiusMax - body.pqsController.radiusMin) / 100) { var surfacePoint = body.position + relSurfacePosition; return new Coordinates(body.GetLatitude(surfacePoint), body.GetLongitude(surfacePoint)); } else { lastRadius = curRadius; curRadius = alt; loops++; } } else { if(loops == 0) break; else { // Went too low, needs to try higher curRadius = (lastRadius * 9 + curRadius) / 10; loops++; } } } return null; }
//******************************************************* public static Vector3 SimAeroForce(List<Part> parts, CelestialBody body, Vector3 v_wrld_vel, Vector3 position) { double latitude = body.GetLatitude(position) / 180.0 * Math.PI; double altitude = (position - body.position).magnitude - body.Radius; return SimAeroForce(parts, body, v_wrld_vel, altitude, latitude); }
public static double PQSAltitude(Vector3d pos, CelestialBody body) { return (pos - body.position).magnitude - body.Radius - PQSSurfaceHeight(body.GetLatitude(pos), body.GetLongitude(pos), body); }
/// <summary> /// Converts world position to Lat,Long,Alt form. /// </summary> /// <returns>The position in geo coords.</returns> /// <param name="worldPosition">World position.</param> /// <param name="body">Body.</param> public static Vector3d WorldPositionToGeoCoords(Vector3d worldPosition, CelestialBody body) { if(!body) { //Debug.Log ("BahaTurret.VectorUtils.WorldPositionToGeoCoords body is null"); return Vector3d.zero; } double lat = body.GetLatitude(worldPosition); double longi = body.GetLongitude(worldPosition); double alt = body.GetAltitude(worldPosition); return new Vector3d(lat,longi,alt); }
private void GeneratePQSCityCoordinates(WaypointData wpData, CelestialBody body) { LoggingUtil.LogVerbose(this, " pqs city: " + wpData.pqsCity); LoggingUtil.LogVerbose(this, " Generating a waypoint based on PQS city " + wpData.pqsCity.name + "..."); Vector3d position = wpData.pqsCity.transform.position; LoggingUtil.LogVerbose(this, " pqs city position = " + position); // Translate by the PQS offset (inverse transform of coordinate system) Vector3d v = wpData.pqsOffset; Vector3d i = wpData.pqsCity.transform.right; Vector3d j = wpData.pqsCity.transform.forward; Vector3d k = wpData.pqsCity.transform.up; LoggingUtil.LogVerbose(this, " i, j, k = " + i + ", " + j + "," + k); LoggingUtil.LogVerbose(this, " pqs transform = " + wpData.pqsCity.transform); LoggingUtil.LogVerbose(this, " parent transform = " + wpData.pqsCity.transform.parent); Vector3d offsetPos = new Vector3d( (j.y * k.z - j.z * k.y) * v.x + (i.z * k.y - i.y * k.z) * v.y + (i.y * j.z - i.z * j.y) * v.z, (j.z * k.x - j.x * k.z) * v.x + (i.x * k.z - i.z * k.x) * v.y + (i.z * j.x - i.x * j.z) * v.z, (j.x * k.y - j.y * k.x) * v.x + (i.y * k.x - i.x * k.y) * v.y + (i.x * j.y - i.y * j.x) * v.z ); offsetPos *= (i.x * j.y * k.z) + (i.y * j.z * k.x) + (i.z * j.x * k.y) - (i.z * j.y * k.x) - (i.y * j.x * k.z) - (i.x * j.z * k.y); wpData.waypoint.latitude = body.GetLatitude(position + offsetPos); wpData.waypoint.longitude = body.GetLongitude(position + offsetPos); LoggingUtil.LogVerbose(this, " resulting lat, lon = (" + wpData.waypoint.latitude + ", " + wpData.waypoint.longitude + ")"); }
Vector3d WorldPositionToGeoCoords(Vector3d worldPosition, CelestialBody body) { if(!body) { Debug.LogWarning ("WorldPositionToGeoCoords body is null"); return Vector3d.zero; } double lat = body.GetLatitude(worldPosition); double longi = body.GetLongitude(worldPosition); double alt = body.GetAltitude(worldPosition); return new Vector3d(lat,longi,alt); }
public static Coordinates GetMouseCoordinates(CelestialBody body) { Ray mouseRay = PlanetariumCamera.Camera.ScreenPointToRay(Input.mousePosition); mouseRay.origin = ScaledSpace.ScaledToLocalSpace(mouseRay.origin); Vector3d relOrigin = mouseRay.origin - body.position; Vector3d relSurfacePosition; double curRadius = body.pqsController.radiusMax; double lastRadius = 0; double error = 0; int loops = 0; float st = Time.time; while (loops < 50) { if (PQS.LineSphereIntersection(relOrigin, mouseRay.direction, curRadius, out relSurfacePosition)) { Vector3d surfacePoint = body.position + relSurfacePosition; double alt = body.pqsController.GetSurfaceHeight(QuaternionD.AngleAxis(body.GetLongitude(surfacePoint), Vector3d.down) * QuaternionD.AngleAxis(body.GetLatitude(surfacePoint), Vector3d.forward) * Vector3d.right); error = Math.Abs(curRadius - alt); if (error < (body.pqsController.radiusMax - body.pqsController.radiusMin) / 100) { return new Coordinates(body.GetLatitude(surfacePoint), MuUtils.ClampDegrees180(body.GetLongitude(surfacePoint))); } else { lastRadius = curRadius; curRadius = alt; loops++; } } else { if (loops == 0) { break; } else { // Went too low, needs to try higher curRadius = (lastRadius * 9 + curRadius) / 10; loops++; } } } return null; }