Beispiel #1
0
 private void setAltitudePos()
 {
     altitudeRenderer.SetPosition(0, GeoPlanetMaths.directionFromLatLong(0f, this.latlong.y).ScaleMultiplier(RSDESManager.radiusOfLargerSphere).Translate(RSDESManager.earthPos));
     altitudeRenderer.SetPosition(1, RSDESManager.earthPos);
     altitudeRenderer.SetPosition(2, GeoPlanetMaths.directionFromLatLong(this.latlong).ScaleMultiplier(RSDESManager.radiusOfLargerSphere).Translate(RSDESManager.earthPos));
 }
Beispiel #2
0
        public void updateLatLongLines()
        {
            if (latRenderer == null)
            {
                latRenderer = new LineRenderer[nLatDivisions + specialLatitudeCount];
                for (int i = 0; i < nLatDivisions + specialLatitudeCount; i++)
                {
                    latRenderer[i] = RSDESGeneratedLine();
                    latRenderer[i].positionCount = RSDESManager.LR_Resolution;
                    if (i % 2 == 0 && i < nLatDivisions)
                    {
                        latRenderer[i].startWidth = RSDESManager.LR_width * 3f;
                        latRenderer[i].endWidth   = RSDESManager.LR_width * 3f;
                    }
                    else
                    {
                        latRenderer[i].startWidth = RSDESManager.LR_width;
                        latRenderer[i].endWidth   = RSDESManager.LR_width;
                    }
                    latRenderer[i].useWorldSpace = true;
                }
            }
            if (decRenderer == null)
            {
                decRenderer = new LineRenderer[nLatDivisions + specialLatitudeCount];
                for (int i = 0; i < nLatDivisions + specialLatitudeCount; i++)
                {
                    decRenderer[i] = RSDESGeneratedLine();
                    decRenderer[i].positionCount = RSDESManager.LR_Resolution;
                    if (i % 2 == 0 && i < nLatDivisions)
                    {
                        decRenderer[i].startWidth = RSDESManager.LR_width * 3f;
                        decRenderer[i].endWidth   = RSDESManager.LR_width * 3f;
                    }
                    else
                    {
                        decRenderer[i].startWidth = RSDESManager.LR_width;
                        decRenderer[i].endWidth   = RSDESManager.LR_width;
                    }
                    decRenderer[i].useWorldSpace = true;
                }
            }
            //need to add subdivided grid.
            if (longRenderer == null)
            {
                longRenderer = new LineRenderer[nLongDivisions];
                for (int i = 0; i < nLongDivisions; i++)
                {
                    {
                        longRenderer[i] = RSDESGeneratedLine();
                    }
                    longRenderer[i].positionCount = RSDESManager.LR_Resolution;
                    if (i % 2 == 0)
                    {
                        longRenderer[i].startWidth = RSDESManager.LR_width * 3f;
                        longRenderer[i].endWidth   = RSDESManager.LR_width * 3f;
                    }
                    else
                    {
                        longRenderer[i].startWidth = RSDESManager.LR_width;
                        longRenderer[i].endWidth   = RSDESManager.LR_width;
                    }
                    longRenderer[i].useWorldSpace = true;
                }
            }
            if (ghaRenderer == null)
            {
                ghaRenderer = new LineRenderer[nLongDivisions];
                for (int i = 0; i < nLongDivisions; i++)
                {
                    ghaRenderer[i] = RSDESGeneratedLine();
                    ghaRenderer[i].positionCount = RSDESManager.LR_Resolution;
                    if (i % 2 == 0)
                    {
                        ghaRenderer[i].startWidth = RSDESManager.LR_width * 3f;
                        ghaRenderer[i].endWidth   = RSDESManager.LR_width * 3f;
                    }
                    else
                    {
                        ghaRenderer[i].startWidth = RSDESManager.LR_width;
                        ghaRenderer[i].endWidth   = RSDESManager.LR_width;
                    }
                    ghaRenderer[i].useWorldSpace = true;
                }
            }
            bool lat        = (myLatMode == latitudeMode.both || myLatMode == latitudeMode.incremental);
            bool specialLat = (myLatMode == latitudeMode.both || myLatMode == latitudeMode.special);
            bool dec        = showDeclination.ToggleState && !(myLatMode == latitudeMode.special);
            bool specialDec = showDeclination.ToggleState && specialLat;

            for (int i = 0; i < nLatDivisions + specialLatitudeCount; i++)
            {
                if (lat || dec || specialLat)
                {
                    float theta = (i * 180f / (nLatDivisions - 1)) - 90f;
                    if (i >= nLatDivisions)
                    {
                        theta = _specialLat[i - nLatDivisions];
                    }
                    Vector3[] positions = GeoPlanetMaths.latAtPoint(GeoPlanetMaths.directionFromLatLong(theta, 0) + earthPos, LR_Resolution).Translate(-earthPos).ScaleMultiplier(EarthRadius).Translate(earthPos);
                    latRenderer[i].SetPositions(positions);
                    decRenderer[i].SetPositions(positions.Translate(-earthPos).ScaleMultiplier(radiusOfLargerSphere / EarthRadius).Translate(earthPos));
                }
                if (i < nLatDivisions)
                {
                    latRenderer[i].enabled = lat;
                    decRenderer[i].enabled = dec;
                }
                else
                {
                    latRenderer[i].enabled = specialLat;
                    decRenderer[i].enabled = specialDec;
                }
                //arctics
                latRenderer[nLatDivisions].startColor     = articRenderer;
                latRenderer[nLatDivisions].endColor       = articRenderer;
                decRenderer[nLatDivisions].startColor     = articRenderer;
                decRenderer[nLatDivisions].endColor       = articRenderer;
                latRenderer[nLatDivisions + 1].startColor = articRenderer;
                latRenderer[nLatDivisions + 1].endColor   = articRenderer;
                decRenderer[nLatDivisions + 1].startColor = articRenderer;
                decRenderer[nLatDivisions + 1].endColor   = articRenderer;
                //tropics
                latRenderer[nLatDivisions + 2].startColor = tropicsRenderer;
                latRenderer[nLatDivisions + 2].endColor   = tropicsRenderer;
                decRenderer[nLatDivisions + 2].startColor = tropicsRenderer;
                decRenderer[nLatDivisions + 2].endColor   = tropicsRenderer;
                latRenderer[nLatDivisions + 3].startColor = tropicsRenderer;
                latRenderer[nLatDivisions + 3].endColor   = tropicsRenderer;
                decRenderer[nLatDivisions + 3].startColor = tropicsRenderer;
                decRenderer[nLatDivisions + 3].endColor   = tropicsRenderer;
            }


            bool sLong = showLongitude.ToggleState;
            bool sGHA  = showGHA.ToggleState;

            for (int i = 0; i < nLongDivisions; i++)
            {
                if (sLong || sGHA)
                {
                    //we only need to consider positive longitude since they are great circles.
                    Vector3[] positions = GeoPlanetMaths.longAtPoint(GeoPlanetMaths.directionFromLatLong(new Vector2(0, (180f / (nLongDivisions)) * i)) + earthPos, LR_Resolution);
                    longRenderer[i].SetPositions(positions);
                    ghaRenderer[i].SetPositions(positions.Translate(-earthPos).ScaleMultiplier(radiusOfLargerSphere / EarthRadius).Translate(earthPos));
                }
                longRenderer[i].enabled = sLong;
                ghaRenderer[i].enabled  = sGHA;
            }
        }