コード例 #1
0
        private void RedrawMap()
        {
            map = new SCANmap();
            map.setProjection(SCANmap.MapProjection.Rectangular);
            orbitingBody = vessel.mainBody;
            map.setBody(vessel.mainBody);
            map.setSize(screenWidth, screenHeight);
            map.mapscale *= (zoomLevel * zoomLevel + zoomModifier);
            mapCenterLong = vessel.longitude;
            mapCenterLat  = vessel.latitude;
            // That's really just sweeping the problem under the carpet instead of fixing it, but meh.
            if (zoomLevel == 0)
            {
                mapCenterLat = 0;
            }
            map.centerAround(mapCenterLong, mapCenterLat);
            map.resetMap(mapMode, 1);

            // Compute and store the map scale factors in mapSizeScale.  We
            // use these values for every segment when drawing trails, so it
            // makes sense to compute it only when it changes.
            mapSizeScale    = new Vector2d(360.0 * map.mapscale / map.mapwidth, 180.0 * map.mapscale / map.mapheight);
            redrawDeviation = redrawEdge * 180 / (zoomLevel * zoomLevel + zoomModifier);
            try {
                localAnomalies = SCANUtil.getData(vessel.mainBody).getAnomalies();
            } catch {
                Debug.Log("JSISCANsatRPM: Could not get a list of anomalies, what happened?");
            }
            // MATH!
            double kmPerDegreeLon  = (2 * Math.PI * (orbitingBody.Radius / 1000d)) / 360d;
            double pixelsPerDegree = Math.Abs(longitudeToPixels(mapCenterLong + (((mapCenterLong + 1) > 360) ? -1 : 1), mapCenterLat) - longitudeToPixels(mapCenterLong, mapCenterLat));

            pixelsPerKm = pixelsPerDegree / kmPerDegreeLon;
        }
コード例 #2
0
ファイル: SCANdata.cs プロジェクト: DMagic1/SCAN
 public void drawHeightScanline(SCANtype type)
 {
     Color[] cols_height_map_small = map_small.GetPixels(0, scanline, 360, 1);
     for (int ilon = 0; ilon < 360; ilon += 1)
     {
         int   scheme = 0;
         float val    = heightmap[ilon, scanline];
         if (val == 0 && isCovered(ilon - 180, scanline - 90, SCANtype.Altimetry))
         {
             if (body.pqsController == null)
             {
                 heightmap[ilon, scanline]   = 0;
                 cols_height_map_small[ilon] = Color.Lerp(Color.black, Color.white, UnityEngine.Random.value);
                 continue;
             }
             else
             {
                 // convert to radial vector
                 double   rlon = Mathf.Deg2Rad * (ilon - 180);
                 double   rlat = Mathf.Deg2Rad * (scanline - 90);
                 Vector3d rad  = new Vector3d(Math.Cos(rlat) * Math.Cos(rlon), Math.Sin(rlat), Math.Cos(rlat) * Math.Sin(rlon));
                 // query terrain controller for elevation at this point
                 val = (float)Math.Round(body.pqsController.GetSurfaceHeight(rad) - body.pqsController.radius, 1);
                 if (val == 0)
                 {
                     val = -0.001f;                                  // this is terrible
                 }
                 heightmap[ilon, scanline] = val;
             }
         }
         Color c = Color.black;
         if (val != 0)
         {
             if (isCovered(ilon - 180, scanline - 90, SCANtype.AltimetryHiRes))
             {
                 c = SCANmap.heightToColor(val, scheme);
             }
             else
             {
                 c = SCANmap.heightToColor(val, 1);
             }
         }
         else
         {
             c = Color.grey;
             if (scanline % 30 == 0 && ilon % 3 == 0)
             {
                 c = Color.white;
             }
             else if (ilon % 30 == 0 && scanline % 3 == 0)
             {
                 c = Color.white;
             }
         }
         if (type != SCANtype.Nothing)
         {
             if (!isCoveredByAll(ilon - 180, scanline - 90, type))
             {
                 c = Color.Lerp(c, Color.black, 0.5f);
             }
         }
         cols_height_map_small[ilon] = c;
     }
     map_small.SetPixels(0, scanline, 360, 1, cols_height_map_small);
     scanline = scanline + 1;
     if (scanline >= 180)
     {
         scanstep += 1;
         scanline  = 0;
     }
 }
コード例 #3
0
ファイル: SCANui.cs プロジェクト: BenChung/SCAN
 private static void drawVesselLabel(Rect maprect, SCANmap map, int num, Vessel vessel)
 {
     double lon = (vessel.longitude + 360 + 180) % 360;
     double lat = (vessel.latitude + 180 + 90) % 180;
     if(map != null) {
         lat = (map.projectLatitude(vessel.longitude, vessel.latitude) + 90) % 180;
         lon = (map.projectLongitude(vessel.longitude, vessel.latitude) + 180) % 360;
         lat = map.scaleLatitude(lat);
         lon = map.scaleLongitude(lon);
         if(lat < 0 || lon < 0 || lat > 180 || lon > 360) return;
     }
     lon = lon * maprect.width / 360f;
     lat = maprect.height - lat * maprect.height / 180f;
     string txt = num.ToString();
     if(num == 0) txt = vessel.vesselName;
     else if(num < 0) txt = "";
     Rect r = new Rect(maprect.x + (float)lon, maprect.y + (float)lat, 250f, 25f);
     Color col = Color.white;
     if(SCANcontroller.controller.colours == 1 && vessel != FlightGlobals.ActiveVessel) col = cb_skyBlue;
     if(vessel == FlightGlobals.ActiveVessel && (int)(Time.realtimeSinceStartup % 2) == 0) {
         col = cb_yellow;
     }
     int sz = 16;
     if(vessel.vesselType == VesselType.Flag) sz = 24;
     drawOrbitIcon((int)r.x, (int)r.y, orbitIconForVesselType(vessel.vesselType), col, sz, true);
     if(maprect.width < 360) return;
     r.x += 12;
     drawLabel(r, col, txt, true, true);
 }
コード例 #4
0
ファイル: SCANui.cs プロジェクト: BenChung/SCAN
        private static void drawOrbit(Rect maprect, SCANmap map, Vessel vessel)
        {
            if(vessel.LandedOrSplashed) return;
            bool lite = maprect.width < 400;
            Orbit o = vessel.orbit;
            startUT = Planetarium.GetUniversalTime();
            double UT = startUT;
            int steps = 100; // increase for neater lines, decrease for better speed indication
            bool ath = false;
            if(vessel.mainBody.atmosphere) {
                if(vessel.mainBody.maxAtmosphereAltitude >= vessel.altitude) {
                    ath = true;
                }
            }
            Rect r = new Rect(0, 0, 50f, 50f);
            Color col;
            // project the last and the current orbital period onto the map
            for(int i=-steps; i<steps; ++i) {
                if(i < 0) UT = startUT - (steps + i) * (o.period / steps);
                else UT = startUT + i * o.period * 1f / steps;
                if(double.IsNaN(UT)) continue;
                if(UT < o.StartUT && o.StartUT != startUT) continue;
                if(UT > o.EndUT) continue;
                if(double.IsNaN(o.getObtAtUT(UT))) continue;
                Vector3d pos = o.getPositionAtUT(UT);
                double rotation = 0;
                if(vessel.mainBody.rotates) {
                    rotation = (360 * ((UT - startUT) / vessel.mainBody.rotationPeriod)) % 360;
                }
                double alt = (vessel.mainBody.GetAltitude(pos));
                if(alt < 0) {
                    if(i < 0) {
                        i = 0;
                        continue;
                    }
                    break;
                }
                double lo = (vessel.mainBody.GetLongitude(pos) - rotation);
                double la = (vessel.mainBody.GetLatitude(pos));
                double lon = (map.projectLongitude(lo, la) + 180) % 360;
                double lat = (map.projectLatitude(lo, la) + 90) % 180;
                lat = map.scaleLatitude(lat);
                lon = map.scaleLongitude(lon);
                if(lat < 0 || lon < 0 || lat > 180 || lon > 360) continue;
                lon = lon * maprect.width / 360f;
                lat = maprect.height - lat * maprect.height / 180f;
                r.x = maprect.x + (float)lon;
                r.y = maprect.y + (float)lat;
                col = cb_skyBlue;
                if(i < 0) {
                    col = cb_orange;
                } else {
                    if(vessel.mainBody.atmosphere) {
                        if(vessel.mainBody.maxAtmosphereAltitude >= alt) {
                            if(!ath) {
                                ath = true;
                                // do something when it flips?
                            }
                            col = cb_reddishPurple;
                        }
                    }
                }
                drawOrbitIcon((int)r.x, (int)r.y, OrbitIcon.Planet, col, 8, false);
            }

            // show apoapsis and periapsis
            if(o.ApA > 0 && mapPosAtT(maprect, map, ref r, vessel, o, o.timeToAp)) {
                drawOrbitIcon((int)r.x, (int)r.y, OrbitIcon.Ap, cb_skyBlue, 32, true);
                r.x += 24;
                r.y -= 12;
                if(!lite) drawLabel(r, cb_skyBlue, o.ApA.ToString("N1"), true, true);
            }
            if(o.PeA > 0 && mapPosAtT(maprect, map, ref r, vessel, o, o.timeToPe)) {
                drawOrbitIcon((int)r.x, (int)r.y, OrbitIcon.Pe, cb_skyBlue, 32, true);
                r.x += 24;
                r.y -= 12;
                if(!lite) drawLabel(r, cb_skyBlue, o.PeA.ToString("N1"), true, true);
            }

            if(lite) return;

            // show first maneuver node
            if(vessel.patchedConicSolver.maneuverNodes.Count > 0) {
                ManeuverNode n = vessel.patchedConicSolver.maneuverNodes[0];
                if(n.patch == vessel.orbit && n.nextPatch != null && n.nextPatch.activePatch && n.UT > startUT - o.period && mapPosAtT(maprect, map, ref r, vessel, o, n.UT - startUT)) {
                    col = cb_reddishPurple;
                    if(SCANcontroller.controller.colours != 1) col = XKCDColors.PurplyPink;
                    drawOrbitIcon((int)r.x, (int)r.y, OrbitIcon.ManeuverNode, col, 32, true);
                    Orbit nuo = n.nextPatch;
                    for(int i=0; i<steps; ++i) {
                        double T = n.UT - startUT + i * nuo.period / steps;
                        if(T + startUT > nuo.EndUT) break;
                        if(mapPosAtT(maprect, map, ref r, vessel, nuo, T)) {
                            drawOrbitIcon((int)r.x, (int)r.y, OrbitIcon.Planet, col, 8, false);
                        }
                    }
                    if(nuo.patchEndTransition == Orbit.PatchTransitionType.ESCAPE) {
                        drawOrbitIcon((int)r.x, (int)r.y, OrbitIcon.Exit, col, 32, true);
                    } else if(nuo.patchEndTransition == Orbit.PatchTransitionType.ENCOUNTER) {
                        drawOrbitIcon((int)r.x, (int)r.y, OrbitIcon.Encounter, col, 32, true);
                    }
                    if(nuo.timeToAp > 0 && n.UT + nuo.timeToAp < nuo.EndUT && mapPosAtT(maprect, map, ref r, vessel, nuo, n.UT - startUT + nuo.timeToAp)) {
                        drawOrbitIcon((int)r.x, (int)r.y, OrbitIcon.Ap, col, 32, true);
                    }
                    if(nuo.timeToPe > 0 && n.UT + nuo.timeToPe < nuo.EndUT && mapPosAtT(maprect, map, ref r, vessel, nuo, n.UT - startUT + nuo.timeToPe)) {
                        drawOrbitIcon((int)r.x, (int)r.y, OrbitIcon.Pe, col, 32, true);
                    }
                }
            }

            if(o.PeA < 0) return;
            if(overlay_static == null) return;
            if(map.projection == SCANmap.MapProjection.Polar) return;

            if(eq_frame <= 0) {
                // predict equatorial crossings for the next 100 loops
                double TAAN = 360f - o.argumentOfPeriapsis;	// true anomaly at ascending node
                double TADN = (TAAN + 180) % 360;			// true anomaly at descending node
                double MAAN = meanForTrue(TAAN, o.eccentricity);
                double MADN = meanForTrue(TADN, o.eccentricity);
                double tAN = (((MAAN - o.meanAnomaly * Mathf.Rad2Deg + 360) % 360) / 360f * o.period + startUT);
                double tDN = (((MADN - o.meanAnomaly * Mathf.Rad2Deg + 360) % 360) / 360f * o.period + startUT);

                int eqh = 16;
                if(eq_an_map == null || eq_dn_map == null || eq_an_map.Length != overlay_static.width) {
                    eq_an_map = new int[overlay_static.width];
                    eq_dn_map = new int[overlay_static.width];
                }
                if(eq_map == null || eq_map.width != eq_an_map.Length) {
                    eq_map = new Texture2D(eq_an_map.Length, eqh, TextureFormat.ARGB32, false);
                }
                for(int i=0; i<eq_an_map.Length; ++i) {
                    eq_an_map[i] = 0;
                    eq_dn_map[i] = 0;
                }
                for(int i=0; i<100; ++i) {
                    double UTAN = tAN + o.period * i;
                    double UTDN = tDN + o.period * i;
                    if(double.IsNaN(UTAN) || double.IsNaN(UTDN)) continue;
                    Vector3d pAN = o.getPositionAtUT(UTAN);
                    Vector3d pDN = o.getPositionAtUT(UTDN);
                    double rotAN = 0, rotDN = 0;
                    if(vessel.mainBody.rotates) {
                        rotAN = ((360 * ((UTAN - startUT) / vessel.mainBody.rotationPeriod)) % 360);
                        rotDN = ((360 * ((UTDN - startUT) / vessel.mainBody.rotationPeriod)) % 360);
                    }
                    double loAN = vessel.mainBody.GetLongitude(pAN) - rotAN;
                    double loDN = vessel.mainBody.GetLongitude(pDN) - rotDN;
                    int lonAN = (int)(((map.projectLongitude(loAN, 0) + 180) % 360) * eq_an_map.Length / 360f);
                    int lonDN = (int)(((map.projectLongitude(loDN, 0) + 180) % 360) * eq_dn_map.Length / 360f);
                    if(lonAN >= 0 && lonAN < eq_an_map.Length) eq_an_map[lonAN] += 1;
                    if(lonDN >= 0 && lonDN < eq_dn_map.Length) eq_dn_map[lonDN] += 1;
                }
                Color[] pix = eq_map.GetPixels(0, 0, eq_an_map.Length, eqh);
                Color cAN = cb_skyBlue, cDN = cb_orange;
                for(int y = 0; y < eqh; ++y) {
                    Color lc = Color.clear;
                    for(int x = 0; x < eq_an_map.Length; ++x) {
                        Color c = Color.clear;
                        float scale = 0;
                        if(y < eqh / 2) {
                            c = cDN;
                            scale = eq_dn_map[x];
                        } else {
                            c = cAN;
                            scale = eq_an_map[x];
                        }
                        if(scale >= 1) {
                            if(y == 0 || y == eqh - 1) {
                                c = Color.black;
                            } else {
                                if(lc == Color.clear) pix[y * eq_an_map.Length + x - 1] = Color.black;
                                scale = Mathf.Clamp(scale - 1, 0, 10) / 10f;
                                c = Color.Lerp(c, Color.white, scale);
                            }
                        } else {
                            c = Color.clear;
                            if(lc != Color.clear && lc != Color.black) c = Color.black;
                        }
                        pix[y * eq_an_map.Length + x] = c;
                        lc = c;
                    }
                }
                eq_map.SetPixels(0, 0, eq_an_map.Length, eqh, pix);
                eq_map.Apply();
                eq_frame = 4;
            } else {
                eq_frame -= 1;
            }

            if(eq_map != null) {
                r.x = maprect.x;
                r.y = maprect.y + maprect.height / 2 + - eq_map.height / 2;
                r.width = eq_map.width;
                r.height = eq_map.height;
                GUI.DrawTexture(r, eq_map);
            }
        }
コード例 #5
0
ファイル: SCANui.cs プロジェクト: BenChung/SCAN
 private static void drawMapLabels(Rect maprect, Vessel vessel, SCANmap map, SCANdata data)
 {
     foreach(Vessel v in FlightGlobals.Vessels) {
         if(v.mainBody == vessel.mainBody) {
             if(v.vesselType == VesselType.Flag && SCANcontroller.controller.map_flags) {
                 drawVesselLabel(maprect, map, 0, v);
             }
         }
     }
     if(SCANcontroller.controller.map_markers) {
         foreach(SCANdata.SCANanomaly anomaly in data.getAnomalies()) {
             drawAnomalyLabel(maprect, map, anomaly);
         }
     }
     drawVesselLabel(maprect, map, 0, vessel);
 }
コード例 #6
0
ファイル: SCANui.cs プロジェクト: BenChung/SCAN
 private static void drawGrid(Rect maprect, SCANmap map)
 {
     int x, y;
     for(double lat=-90; lat<90; lat += 2) {
         for(double lon=-180; lon<180; lon += 2) {
             if(lat % 30 == 0 || lon % 30 == 0) {
                 x = (int)(map.mapscale * ((map.projectLongitude(lon, lat) + 180) % 360));
                 y = (int)(map.mapscale * ((map.projectLatitude(lon, lat) + 90) % 180));
                 drawDot(x, y, Color.white, overlay_static);
             }
         }
     }
 }
コード例 #7
0
ファイル: SCANui.cs プロジェクト: BenChung/SCAN
 private static void drawAnomalyLabel(Rect maprect, SCANmap map, SCANdata.SCANanomaly anomaly)
 {
     if(!anomaly.known) return;
     double lon = (anomaly.longitude + 360 + 180) % 360;
     double lat = (anomaly.latitude + 180 + 90) % 180;
     if(map != null) {
         lat = (map.projectLatitude(anomaly.longitude, anomaly.latitude) + 90) % 180;
         lon = (map.projectLongitude(anomaly.longitude, anomaly.latitude) + 180) % 360;
         lat = map.scaleLatitude(lat);
         lon = map.scaleLongitude(lon);
         if(lat < 0 || lon < 0 || lat > 180 || lon > 360) return;
     }
     lon = lon * maprect.width / 360f;
     lat = maprect.height - lat * maprect.height / 180f;
     string txt = SCANcontroller.controller.anomalyMarker + " " + anomaly.name;
     if(!anomaly.detail) txt = SCANcontroller.controller.anomalyMarker + " Anomaly";
     Rect r = new Rect(maprect.x + (float)lon, maprect.y + (float)lat, 250f, 25f);
     drawLabel(r, cb_yellow, txt, true, true);
 }
コード例 #8
0
ファイル: SCANui.cs プロジェクト: BenChung/SCAN
        public static void gui_show()
        {
            bool repainting = Event.current.type == EventType.Repaint;
            Vessel vessel = FlightGlobals.ActiveVessel;

            if(Time.frameCount - gui_frame_ping > 5) {
                gui_active = false;
                RenderingManager.RemoveFromPostDrawQueue(3, guicb);
            }
            if(Time.frameCount > gui_frame_draw) {
                fps_time_passed += Time.deltaTime;
                fps_frames += 1;
                fps_sum += Time.timeScale / Time.deltaTime;
                if(fps_time_passed >= 1) {
                    fps = fps_sum / fps_frames;
                    fps_time_passed = 0;
                    fps_frames = 0;
                    fps_sum = 0;
                }
            }
            gui_frame_draw = Time.frameCount;

            if(style_headline == null) {
                style_headline = new GUIStyle();
                style_headline.normal.textColor = XKCDColors.YellowGreen;
                style_headline.alignment = TextAnchor.MiddleCenter;
                style_headline.fontSize = 40;
            }
            if(style_readout == null) {
                style_readout = new GUIStyle();
            }
            if(style_overlay == null) {
                style_overlay = new GUIStyle();
            }
            if(dotty == null) {
                ScreenMessages sm = (ScreenMessages)GameObject.FindObjectOfType(typeof(ScreenMessages));
                dotty = sm.textStyles[1].font;
                style_headline.font = dotty;
                style_readout.font = dotty;
                style_overlay.font = dotty;
            }

            if(style_button == null) {
                style_button = new GUIStyle(GUI.skin.button);
            }
            if(style_toggle == null) {
                style_toggle = new GUIStyle(GUI.skin.toggle);
            }

            GUI.skin = null; // and by this, I mean "set it to the default"
            GUI.skin.label.wordWrap = false;
            GUI.skin.button.wordWrap = false;

            SCANdata.SCANtype sensors = SCANcontroller.controller.activeSensorsOnVessel(vessel.id);
            SCANdata data = SCANcontroller.controller.getData(vessel.mainBody);
            data.updateImages(sensors);

            if(!repainting) { // Unity gets confused if the layout changes between layout and repaint events
                infotext = "";

                string aoff = "<color=\"grey\">";
                string aon = "<color=\"" + colorHex(c_good) + "\">";
                string abad = "<color=\"" + colorHex(c_bad) + "\">";
                string ano = "<color=\"" + colorHex(c_ugly) + "\">";
                string ac = "</color> ";
                string stat_alo = aon, stat_ahi = aon, stat_biome = aon, stat_ano = aon, stat_btdt = aon;

                minicolor = c_good;
                if(sensors == 0) minicolor = Color.grey;

                SCANcontroller.SCANsensor s;

                s = SCANcontroller.controller.getSensorStatus(vessel, SCANdata.SCANtype.AltimetryLoRes);
                if(s == null) stat_alo = aoff;
                else if(!s.inRange) stat_alo = abad;
                else if(!s.bestRange && (Time.realtimeSinceStartup % 2 < 1)) stat_alo = abad;

                s = SCANcontroller.controller.getSensorStatus(vessel, SCANdata.SCANtype.AltimetryHiRes);
                if(s == null) stat_ahi = aoff;
                else if(!s.inRange) stat_ahi = abad;
                else if(!s.bestRange && (Time.realtimeSinceStartup % 2 < 1)) stat_ahi = abad;

                s = SCANcontroller.controller.getSensorStatus(vessel, SCANdata.SCANtype.Anomaly);
                if(s == null) stat_ano = aoff;
                else if(!s.inRange) stat_ano = abad;
                else if(!s.bestRange && (Time.realtimeSinceStartup % 2 < 1)) stat_ano = abad;

                s = SCANcontroller.controller.getSensorStatus(vessel, SCANdata.SCANtype.Biome);
                if(s == null) stat_biome = aoff;
                else if(!s.inRange) stat_biome = abad;
                else if(!s.bestRange && (Time.realtimeSinceStartup % 2 < 1)) stat_biome = abad;

                s = SCANcontroller.controller.getSensorStatus(vessel, SCANdata.SCANtype.AnomalyDetail);
                if(s == null) stat_btdt = aoff;
                else if(!s.inRange) stat_btdt = abad;
                else if(!s.bestRange && (Time.realtimeSinceStartup % 2 < 1)) stat_btdt = abad;

                infotext = stat_alo + "LO" + ac + stat_ahi + "HI" + ac + stat_biome + "BIO" + ac + stat_ano + "ANOM" + ac + stat_btdt + "BTDT" + ac;

                SCANdata.SCANtype active = SCANcontroller.controller.activeSensorsOnVessel(vessel.id);
                if(active != SCANdata.SCANtype.Nothing) {
                    double cov = data.getCoveragePercentage(active);
                    infotext += " " + cov.ToString("N1") + "%";
                    if(notMappingToday) {
                        infotext = abad + "NO POWER" + ac;
                    }
                } else {
                    if(maptraq_frame < Time.frameCount - 5) {
                        notMappingToday = true;
                        infotext = abad + "NO DATA" + ac;
                    }
                }

                title = "S.C.A.N. Planetary Mapping";

                if(minimode <= 0) title = " ";
            }

            Rect old_infobox = new Rect(pos_infobox);
            pos_infobox = GUILayout.Window(47110001, pos_infobox, gui_infobox_build, title, GUILayout.Width(32), GUILayout.Height(32));

            if(minimode != lastmode && pos_infobox != old_infobox) {
                snapWindow(ref pos_infobox, old_infobox);
                lastmode = minimode;
            }

            if(bigmap_visible) {
                if(bigmap == null) {
                    bigmap = new SCANmap();
                    bigmap.setProjection((SCANmap.MapProjection)SCANcontroller.controller.projection);
                    bigmap.setWidth(SCANcontroller.controller.map_width);
                    pos_bigmap.x = SCANcontroller.controller.map_x;
                    pos_bigmap.y = SCANcontroller.controller.map_y;
                    if(pos_bigmap.x < 0 || pos_bigmap.x >= Screen.width) pos_bigmap.x = 0;
                    if(pos_bigmap.y < 0 || pos_bigmap.y >= Screen.height) pos_bigmap.y = 0;
                } else {
                    SCANcontroller.controller.map_x = (int)pos_bigmap.x;
                    SCANcontroller.controller.map_y = (int)pos_bigmap.y;
                }
                bigmap.setBody(vessel.mainBody);
                string rendering = "";
                if(bigmap_dragging) rendering += " ["+bigmap_drag_w+"x"+(bigmap_drag_w/2)+"]";
                if(!bigmap.isMapComplete()) rendering += " [rendering]";
                pos_bigmap = GUILayout.Window(47110002, pos_bigmap, gui_bigmap_build, "Map of " + vessel.mainBody.theName + rendering, GUILayout.Width(360), GUILayout.Height(180));
            }

            if(instruments_visible) {
                if(pos_instruments.x < 0) {
                    pos_instruments.x = pos_infobox.x;
                    pos_instruments.y = pos_infobox.y + pos_infobox.height + 8;
                }
                pos_instruments = GUILayout.Window(47110003, pos_instruments, gui_instruments_build, "S.C.A.N. Instruments", GUILayout.Width(200), GUILayout.Height(60));
            }

            if(settings_visible) {
                pos_settings = GUILayout.Window(47110004, pos_settings, gui_settings_build, "S.C.A.N. Settings", GUILayout.Width(360), GUILayout.Height(180));
                if(pos_settings.x < 0 && pos_settings.width > 0) {
                    pos_settings.x = Screen.width/2 - pos_settings.width/2;
                    pos_settings.y = Screen.height/3 - pos_settings.height/2;
                    pos_settings = GUILayout.Window(47110004, pos_settings, gui_settings_build, "S.C.A.N. Settings", GUILayout.Width(360), GUILayout.Height(180));
                }
            }
        }
コード例 #9
0
ファイル: SCANui.cs プロジェクト: BenChung/SCAN
 private static bool mapPosAtT(Rect maprect, SCANmap map, ref Rect r, Vessel vessel, Orbit o, double dT)
 {
     double UT = startUT + dT;
     if(double.IsNaN(UT)) return false;
     try {
         if(double.IsNaN(o.getObtAtUT(UT))) return false;
         Vector3d pos = o.getPositionAtUT(UT);
         double rotation = 0;
         if(vessel.mainBody.rotates) {
             rotation = (360 * (dT / vessel.mainBody.rotationPeriod)) % 360;
         }
         double lo = (vessel.mainBody.GetLongitude(pos) - rotation);
         double la = (vessel.mainBody.GetLatitude(pos));
         double lon = (map.projectLongitude(lo, la) + 180) % 360;
         double lat = (map.projectLatitude(lo, la) + 90) % 180;
         lat = map.scaleLatitude(lat);
         lon = map.scaleLongitude(lon);
         if(lat < 0 || lon < 0 || lat > 180 || lon > 360) return false;
         lon = lon * maprect.width / 360f;
         lat = maprect.height - lat * maprect.height / 180f;
         r.x = maprect.x + (float)lon;
         r.y = maprect.y + (float)lat;
         return true;
     } catch(Exception) {
         return false;
     }
 }
コード例 #10
0
ファイル: SCANui.cs プロジェクト: BenChung/SCAN
        private static void gui_bigmap_build(int wid)
        {
            bool repainting = Event.current.type == EventType.Repaint;
            GUI.skin = null;

            // Handle dragging independently of mouse events: MouseDrag doesn't work
            // so well if the resizer widget can't follow the mouse because the map
            // aspect ratio is constrained.
            if(bigmap_dragging && !repainting) {
                if(Input.GetMouseButtonUp(0)) {
                    bigmap_dragging = false;
                    if(bigmap_drag_w < 400) bigmap_drag_w = 400;
                    bigmap.setWidth((int)bigmap_drag_w);
                    overlay_static = null;
                    SCANcontroller.controller.map_width = bigmap.mapwidth;
                } else {
                    float xx = Input.mousePosition.x;
                    bigmap_drag_w += xx - bigmap_drag_x;
                    bigmap_drag_x = xx;
                }
                if(Event.current.isMouse) Event.current.Use();
            }

            Vessel vessel = FlightGlobals.ActiveVessel;
            GUILayout.BeginVertical();

            SCANdata data = SCANcontroller.controller.getData(vessel.mainBody);
            Texture2D map = bigmap.getPartialMap();

            float dw = bigmap_drag_w;
            if(dw < 400) dw = 400;
            float dh = dw / 2f;
            if(bigmap_dragging) {
                GUILayout.Label("", GUILayout.Width(dw), GUILayout.Height(dh));
            } else {
                GUILayout.Label("", GUILayout.Width(map.width), GUILayout.Height(map.height));
            }
            Rect maprect = GUILayoutUtility.GetLastRect();
            maprect.width = bigmap.mapwidth;
            maprect.height = bigmap.mapheight;

            if(overlay_static == null) {
                overlay_static = new Texture2D((int)bigmap.mapwidth, (int)bigmap.mapheight, TextureFormat.ARGB32, false);
                overlay_static_dirty = true;
            }

            if(overlay_static_dirty) {
                clearTexture(overlay_static);
                if(SCANcontroller.controller.map_grid) {
                    drawGrid(maprect, bigmap);
                }
                overlay_static.Apply();
                overlay_static_dirty = false;
            }

            if(bigmap_dragging) {
                maprect.width = dw;
                maprect.height = dh;
                GUI.DrawTexture(maprect, map, ScaleMode.StretchToFill);
            } else {
                GUI.DrawTexture(maprect, map);
            }

            if(overlay_static != null) {
                GUI.DrawTexture(maprect, overlay_static, ScaleMode.StretchToFill);
            }

            if(bigmap.projection == SCANmap.MapProjection.Polar) {
                rc.x = maprect.x + maprect.width / 2 - maprect.width / 8;
                rc.y = maprect.y + maprect.height / 8;
                drawLabel(rc, Color.white, "S", true, true);
                rc.x = maprect.x + maprect.width / 2 + maprect.width / 8;
                drawLabel(rc, Color.white, "N", true, true);
            }

            if(SCANcontroller.controller.map_orbit && !notMappingToday) {
                drawOrbit(maprect, bigmap, vessel);
            }

            GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
            GUILayout.BeginHorizontal(GUILayout.Width(300));

            GUILayout.BeginVertical();
            if(GUILayout.Button("Close")) {
                bigmap_visible = false;
            }
            GUILayout.FlexibleSpace();
            style_button.normal.textColor = Color.grey;
            if(bigmap.isMapComplete()) style_button.normal.textColor = Color.white;
            if(GUILayout.Button("Export PNG", style_button)) {
                if(bigmap.isMapComplete()) {
                    bigmap.exportPNG();
                }
            }
            GUILayout.EndVertical();

            GUILayout.BeginVertical();
            style_button.normal.textColor = SCANcontroller.controller.colours == 1 ? c_good : Color.white;
            if(GUILayout.Button("Grey", style_button)) {
                SCANcontroller.controller.colours = 1;
                data.resetImages();
                bigmap.resetMap();
            }
            style_button.normal.textColor = SCANcontroller.controller.colours == 0 ? c_good : Color.white;
            if(GUILayout.Button("Colour", style_button)) {
                SCANcontroller.controller.colours = 0;
                data.resetImages();
                bigmap.resetMap();
            }
            style_button.normal.textColor = SCANcontroller.controller.legend ? c_good : Color.white;
            if(GUILayout.Button("Legend", style_button)) {
                SCANcontroller.controller.legend = !SCANcontroller.controller.legend;
            }
            GUILayout.EndVertical();

            GUILayout.BeginVertical();
            style_button.normal.textColor = bigmap.mapmode == 0 ? c_good : Color.white;
            if(GUILayout.Button("Altimetry", style_button)) {
                bigmap.resetMap(0);
            }
            style_button.normal.textColor = bigmap.mapmode == 1 ? c_good : Color.white;
            if(GUILayout.Button("Slope", style_button)) {
                bigmap.resetMap(1);
            }
            style_button.normal.textColor = bigmap.mapmode == 2 ? c_good : Color.white;
            if(GUILayout.Button("Biome", style_button)) {
                bigmap.resetMap(2);
            }
            GUILayout.EndVertical();

            GUILayout.BeginVertical();
            GUILayout.BeginHorizontal();
            style_button.normal.textColor = SCANcontroller.controller.map_markers ? c_good : Color.white;
            if(GUILayout.Button("Markers", style_button)) {
                SCANcontroller.controller.map_markers = !SCANcontroller.controller.map_markers;
            }
            style_button.normal.textColor = SCANcontroller.controller.map_flags ? c_good : Color.white;
            if(GUILayout.Button("Flags", style_button)) {
                SCANcontroller.controller.map_flags = !SCANcontroller.controller.map_flags;
            }
            GUILayout.EndHorizontal();
            style_button.normal.textColor = SCANcontroller.controller.map_orbit ? c_good : Color.white;
            if(GUILayout.Button("Orbit", style_button)) {
                SCANcontroller.controller.map_orbit = !SCANcontroller.controller.map_orbit;
            }
            style_button.normal.textColor = SCANcontroller.controller.map_grid ? c_good : Color.white;
            if(GUILayout.Button("Grid", style_button)) {
                SCANcontroller.controller.map_grid = !SCANcontroller.controller.map_grid;
                overlay_static_dirty = true;
            }
            GUILayout.EndVertical();

            GUILayout.BeginVertical();
            for(int i=0; i<SCANmap.projectionNames.Length; ++i) {
                style_button.normal.textColor = (int)bigmap.projection == i ? c_good : Color.white;
                if(GUILayout.Button(SCANmap.projectionNames[i], style_button)) {
                    bigmap.setProjection((SCANmap.MapProjection)i);
                    SCANcontroller.controller.projection = i;
                    overlay_static_dirty = true;
                }
            }
            GUILayout.EndVertical();
            GUILayout.EndHorizontal();

            string info = "";
            float mx = Event.current.mousePosition.x - maprect.x;
            float my = Event.current.mousePosition.y - maprect.y;
            bool in_map = false, in_spotmap = false;
            double mlon = 0, mlat = 0;
            if(mx >= 0 && my >= 0 && mx < map.width && my < map.height && !bigmap_dragging) {
                double mlo = (mx * 360f / map.width) - 180;
                double mla = 90 - (my * 180f / map.height);
                mlon = bigmap.unprojectLongitude(mlo, mla);
                mlat = bigmap.unprojectLatitude(mlo, mla);

                if(spotmap != null) {
                    if(mx >= pos_spotmap.x - maprect.x && my >= pos_spotmap.y - maprect.y && mx <= pos_spotmap.x + pos_spotmap.width - maprect.x && my <= pos_spotmap.y + pos_spotmap.height - maprect.y) {
                        in_spotmap = true;
                        mlon = spotmap.lon_offset + ((mx - pos_spotmap.x + maprect.x) / spotmap.mapscale) - 180;
                        mlat = spotmap.lat_offset + ((pos_spotmap.height - (my - pos_spotmap.y + maprect.y)) / spotmap.mapscale) - 90;
                        if(mlat > 90) {
                            mlon = (mlon + 360) % 360 - 180;
                            mlat = 180 - mlat;
                        } else if(mlat < -90) {
                            mlon = (mlon + 360) % 360 - 180;
                            mlat = -180 - mlat;
                        }
                    }
                }

                if(mlon >= -180 && mlon <= 180 && mlat >= -90 && mlat <= 90) {
                    in_map = true;
                    if(data.isCovered(mlon, mlat, SCANdata.SCANtype.AltimetryLoRes)) {
                        if(vessel.mainBody.pqsController == null) info += colored(c_ugly, "LO ");
                        else info += colored(c_good, "LO ");
                    } else info += "<color=\"grey\">LO</color> ";
                    if(data.isCovered(mlon, mlat, SCANdata.SCANtype.AltimetryHiRes)) {
                        if(vessel.mainBody.pqsController == null) info += colored(c_ugly, "HI ");
                        else info += colored(c_good, "HI ");
                    } else info += "<color=\"grey\">HI</color> ";
                    if(data.isCovered(mlon, mlat, SCANdata.SCANtype.Biome)) {
                        if(vessel.mainBody.BiomeMap == null || vessel.mainBody.BiomeMap.Map == null) info += colored(c_ugly, "BIO ");
                        else info += colored(c_good, "BIO ");
                    } else info += "<color=\"grey\">BIO</color> ";
                    if(data.isCovered(mlon, mlat, SCANdata.SCANtype.Anomaly)) info += colored(c_good, "ANOM ");
                    else info += "<color=\"grey\">ANOM</color> ";
                    if(data.isCovered(mlon, mlat, SCANdata.SCANtype.AnomalyDetail)) info += colored(c_good, "BTDT ");
                    else info += "<color=\"grey\">BTDT</color> ";
                    if(data.isCovered(mlon, mlat, SCANdata.SCANtype.AltimetryHiRes)) {
                        info += "<b>" + data.getElevation(mlon, mlat).ToString("N2") + "m</b> ";
                    } else if(data.isCovered(mlon, mlat, SCANdata.SCANtype.AltimetryLoRes)) {
                        info += "<b>~" + (((int)data.getElevation(mlon, mlat) / 500) * 500).ToString() + "m</b> ";
                    }
                    if(data.isCovered(mlon, mlat, SCANdata.SCANtype.Biome)) {
                        info += data.getBiomeName(mlon, mlat) + " ";
                    }
                    info += "\n" + toDMS(mlat, mlon) + " (lat: " + mlat.ToString("F2") + " lon: " + mlon.ToString("F2") + ") ";
                    if(in_spotmap) info += " " + spotmap.mapscale.ToString("F1") + "x";
                } else {
                    info += " " + mlat.ToString("F") + " " + mlon.ToString("F"); // uncomment for debugging projections
                }
            }
            if(maprect.width < 720) {
                GUILayout.EndHorizontal();
                readableLabel(info, Color.white);
                drawLegend();
            } else {
                GUILayout.BeginVertical();
                readableLabel(info, Color.white);
                drawLegend();
                GUILayout.EndVertical();
                GUILayout.EndHorizontal();
            }

            if(!notMappingToday) drawMapLabels(maprect, vessel, bigmap, data);

            if(spotmap != null) {
                spotmap.setBody(vessel.mainBody);
                GUI.Box(pos_spotmap, spotmap.getPartialMap());
                if(!notMappingToday) {
                    drawOrbit(pos_spotmap, spotmap, vessel);
                    drawMapLabels(pos_spotmap, vessel, spotmap, data);
                }
                pos_spotmap_x.x = pos_spotmap.x + pos_spotmap.width + 4;
                pos_spotmap_x.y = pos_spotmap.y;
                style_button.normal.textColor = cb_vermillion;
                if(GUI.Button(pos_spotmap_x, SCANcontroller.controller.closeBox, style_button)) {
                    spotmap = null;
                }
            }

            Rect fpswidget = new Rect(maprect.x + maprect.width - 32, maprect.y + maprect.height + 32, 32, 24);
            GUI.Label(fpswidget, fps.ToString("N1"));

            Rect resizer = new Rect(maprect.x + maprect.width - 24, maprect.y + maprect.height + 8, 24, 24);
            GUI.Box(resizer, "//");
            if(Event.current.isMouse) {
                if(Event.current.type == EventType.MouseUp) {
                    if(bigmap_dragging) {
                    } else if(Event.current.button == 1) {
                        if(in_map || in_spotmap) {
                            if(spotmap == null) {
                                spotmap = new SCANmap();
                                spotmap.setSize(180, 180);
                            }
                            if(in_spotmap) {
                                spotmap.mapscale = spotmap.mapscale * 1.25f;
                            } else {
                                spotmap.mapscale = 10;
                            }
                            spotmap.centerAround(mlon, mlat);
                            spotmap.resetMap(bigmap.mapmode);
                            pos_spotmap.width = 180;
                            pos_spotmap.height = 180;
                            if(!in_spotmap) {
                                pos_spotmap.x = Event.current.mousePosition.x - pos_spotmap.width / 2;
                                pos_spotmap.y = Event.current.mousePosition.y - pos_spotmap.height / 2;
                                if(mx > maprect.width / 2) pos_spotmap.x -= pos_spotmap.width;
                                else pos_spotmap.x += pos_spotmap.height;
                                pos_spotmap.x = Math.Max(maprect.x, Math.Min(maprect.x + maprect.width - pos_spotmap.width, pos_spotmap.x));
                                pos_spotmap.y = Math.Max(maprect.y, Math.Min(maprect.y + maprect.height - pos_spotmap.height, pos_spotmap.y));
                            }
                        }
                    } else if(Event.current.button == 0) {
                        if(spotmap != null && in_spotmap) {
                            spotmap.mapscale = spotmap.mapscale / 1.25f;
                            if(spotmap.mapscale < 10) spotmap.mapscale = 10;
                            spotmap.resetMap(spotmap.mapmode);
                            Event.current.Use();
                        }
                    }
                    Event.current.Use();
                } else if(Event.current.type == EventType.MouseDown) {
                    if(Event.current.button == 0) {
                        if(resizer.Contains(Event.current.mousePosition)) {
                            bigmap_dragging = true;
                            bigmap_drag_x = Input.mousePosition.x;
                            bigmap_drag_w = bigmap.mapwidth;
                            Event.current.Use();
                        }
                    }
                }
            }

            GUILayout.EndVertical();
            GUI.DragWindow();
        }
コード例 #11
0
ファイル: JSISCANsatRPM.cs プロジェクト: rhrlfkaus11/SCANsat
        private void RedrawMap()
        {
            map = new SCANmap();
            map.setProjection(SCANmap.MapProjection.Rectangular);
            orbitingBody = vessel.mainBody;
            map.setBody(vessel.mainBody);
            map.setSize(screenWidth, screenHeight);
            map.mapscale *= (zoomLevel * zoomLevel + zoomModifier);
            mapCenterLong = vessel.longitude;
            mapCenterLat = vessel.latitude;
            // That's really just sweeping the problem under the carpet instead of fixing it, but meh.
            if (zoomLevel == 0)
                mapCenterLat = 0;
            map.centerAround(mapCenterLong, mapCenterLat);
            map.resetMap(mapMode,1);

            // Compute and store the map scale factors in mapSizeScale.  We
            // use these values for every segment when drawing trails, so it
            // makes sense to compute it only when it changes.
            mapSizeScale = new Vector2d(360.0 * map.mapscale / map.mapwidth, 180.0 * map.mapscale / map.mapheight);
            redrawDeviation = redrawEdge * 180 / (zoomLevel * zoomLevel + zoomModifier);
            try {
                localAnomalies = SCANcontroller.controller.getData(vessel.mainBody).getAnomalies();
            } catch {
                Debug.Log("JSISCANsatRPM: Could not get a list of anomalies, what happened?");
            }
            // MATH!
            double kmPerDegreeLon = (2 * Math.PI * (orbitingBody.Radius / 1000d)) / 360d;
            double pixelsPerDegree = Math.Abs(longitudeToPixels(mapCenterLong + (((mapCenterLong + 1) > 360) ? -1 : 1), mapCenterLat) - longitudeToPixels(mapCenterLong, mapCenterLat));
            pixelsPerKm = pixelsPerDegree / kmPerDegreeLon;
        }