示例#1
0
        public Atmosphere(GameObject spaceCraft, OrbitalSystem rootObject, string name,
            int idx, float dist, float spin, float offset, Vector3 hdg,
            bool enterable, Texture2D txtr = null,
            AtmosphereTriggerScript.AtmosphereEntryHandler entryHandler = null)
        {
            SpinSum = 0; Name = name; Index = idx; Distance = dist; Spin = spin; SpinOffset = offset;
            Texture = txtr;
            Distance = dist;
            Shape = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            Shape.name = name;
            SphereCollider sc = Shape.GetComponent<SphereCollider>();
            //sc.radius = 1;
            float baseSize = rootObject.SimulationRadius;
            baseSize += Distance;
            Shape.transform.parent = rootObject.Root.transform;
            Shape.transform.position = rootObject.Root.transform.position;
            Shape.transform.rotation = rootObject.Root.transform.rotation;
            if (!enterable)
            {
                Rigidbody rb = Shape.AddComponent<Rigidbody>();
                rb.drag = 0.0f;
                rb.mass = 0;
                rb.angularDrag = 0;
                rb.useGravity = false;
                rb.isKinematic = true;
            }

            if (enterable)
            {
                sc.isTrigger = true;
                AtmosphereTriggerScript ts = Shape.AddComponent<AtmosphereTriggerScript>();
                ts.SpaceCraft = spaceCraft;
                ts.EntryHandler = entryHandler;
            }
            if (Texture == null)
            {
                Shape.GetComponent<MeshRenderer>().enabled = false;
            }
            else
            {
                MeshRenderer mr = Shape.GetComponent<MeshRenderer>();
                mr.enabled = true;
                //mr.material.SetOverrideTag("RenderType", "Transparent");
                mr.material.SetFloat("_Mode", 2);
                mr.material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                mr.material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
                mr.material.SetInt("_ZWrite", 0);
                mr.material.DisableKeyword("_ALPHATEST_ON");
                mr.material.DisableKeyword("_ALPHABLEND_ON");
                mr.material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
                mr.material.renderQueue = 3000;

                mr.material.mainTexture = Texture;
            }
            Shape.transform.localScale = new Vector3(baseSize, baseSize, baseSize);

            // m_shape->SetOrderHint(idx + 1);
            BaseHeading = hdg;
        }
示例#2
0
        public void HandleOrbitalTransition(OrbitalSystem target, bool enteringOrbit)
        {
            if (enteringOrbit)
            {
                if (target == null)
                    return;
                Destination = null;
                //mOrbitElevation = (target.GetBody().transform.position - SpaceCraft.transform.position).magnitude;
                OrbitElevation = (target.mSimulationRadius / 2) + Math.Max(target.mSimulationRadius * 0.1f, 1.3f);
                Orbit = target;
                Vector3 dirv = Vector3.Normalize(Orbit.Root.transform.position * -1.0f);

                SpaceCraft.transform.position = Orbit.Root.transform.position + (dirv * OrbitElevation);
                SpaceCraft.transform.LookAt(Orbit.Root.transform.position + Orbit.LastRelativeMove, Orbit.Root.transform.up);
                float tp = (float)(2.0f * Math.PI);
                // compute matching velocity from spin rate
                float circumference = tp * Orbit.mSimulationRadius;
                float velRat = Orbit.Spin / tp;
                Velocity = circumference * velRat;

                float x = SpaceCraft.transform.position.x - Orbit.Root.transform.position.x;
                float y = SpaceCraft.transform.position.x - Orbit.Root.transform.position.x;

                float dp = Vector2.Dot(new Vector2(1, 0), new Vector2(x, y));
                mLastOrbitAngle = (float)Math.Acos(dp / (x * y));
                SpeechToText.Speak("now orbiting " + Orbit.GetName());
                SolarSystem.PoseController.transform.LookAt(Orbit.Body.transform.position + Orbit.LastRelativeMove, Orbit.Root.transform.up);
                mObject = target;
            }
            else
            {
                if (Orbit == null)
                    return;
                Vector3 crv = OrbitalSystem.OrbitRotationVector(ref mLastOrbitAngle, Orbit.mSimulationRadius, 0, OrbitElevation);
                Vector3 dvPc = Vector3.Normalize(crv);
                Vector3 up = Orbit.Body.transform.up;
                Vector3 vv = Vector3.Cross(up, dvPc);
                SpaceCraft.transform.forward = vv;
                //SpaceCraft.transform.LookAt(mOrbit.GetBody().transform.position + mOrbit.LastAbsoluteDisplacement);
                // convert velocity to orbited bodies rotation
                //SolarSystem.PoseController.Transform.position = SpaceCraft.transform.position;
                //SolarSystem.PoseController.Transform.rotation = SpaceCraft.transform.rotation;
                float scaler = (Orbit.Radius / 160) * (Orbit.SimulationRadius / 64);
                Velocity = Orbit.SumOfAbsoluteDisplacementDistance * scaler;
                string theName = Orbit.GetName();
                Orbit = null;
                SpeechToText.Speak("leaving orbit of " + theName);
            }
        }
示例#3
0
        public ECommandCompletionState HandleAutopilotCommand(string command, OrbitalSystem sObj)
        {
            switch (command)
            {
                case "fly":
                    goto case "go";
                case "go":
                    FlyTo(sObj);
                    break;

                case "look":
                    SpaceCraft.transform.LookAt(sObj.Root.transform);
                    SolarSystem.PoseController.transform.LookAt(sObj.Root.transform);
                    break;

                case "orbit":
                    HandleOrbitalTransition(sObj, true);
                    break;

                case "track":
                    Track = sObj;
                    break;

                case "follow":
                    mFollowDistance = (sObj.Root.transform.position - SpaceCraft.transform.position).magnitude;
                    Follow = sObj;
                    break;

                case "jump":
                    HandleOrbitalTransition(sObj, true);
                    //Vector3 dirVec = mselectedTarget.GetBody().transform.position - SpaceCraft.transform.position;
                    //float orbrad = mselectedTarget.mSimulationRadius + (mselectedTarget.mSimulationRadius * 0.021f);
                    //Vector3 dvn = dirVec;
                    //dvn.Normalize();
                    //float mag = (mselectedTarget.GetBody().transform.position - SpaceCraft.transform.position).magnitude;
                    //Vector3 pos = SpaceCraft.transform.position + (dvn * (mag - orbrad));
                    //SpaceCraft.transform.position = pos;
                    //SpaceCraft.transform.LookAt(mselectedTarget.GetBody().transform);
                    break;

                default:
                    return ECommandCompletionState.What;
            }
            mObject = sObj;
            return ECommandCompletionState.Ok;
        }
示例#4
0
 public void FlyTo(OrbitalSystem os)
 {
     mObject = os;
     if (Orbit != null)
         HandleOrbitalTransition(null, false);
     Orbit = null;
     Destination = os;
 }
示例#5
0
        public OrbitalSystem(int odepth, string theName, OrbitalSystem root, float mass, float dist, float rad, float inc,
                    float orbitalPeriodDays, float hoursPerRevolution, float gravMPS, float eccRat, GameObject body)
        {
            RotationColumnOffset = 0;
            mOrbitalPeriodOffset = 0;
            mDepth = odepth;
            mImage = null;
            mOrbitalVelocity = convertOrbitalPeriodToRadSec(orbitalPeriodDays);
            mOrbitalPeriodOffset = 0;
            // rotational velocity expressed as orbital period in earth sidereal hours
            Spin = convertOrbitalRevolutionHoursToRadSec(hoursPerRevolution);

            mOrbitObjects = new List<OrbitalSystem>();
            mAtmospheres = new List<Atmosphere>();
            mSiblingImage = null;
            var distance = dist;
            Radius = rad;
            mParentObject = root;
            var inclination = DEGREEMULT * inc;
            mName = theName;
            mBias = Vector3.zero;
            mOrbitalPlane = Vector2.zero;
            mOrbitEccentricity = eccRat;
            mLastOrbitAngle = 0;
            if (distance != 0)
            {
                mObjectDistance = (distance / mParentObject.Radius) + mParentObject.mSimulationRadius;
                mSimulationRadius = (Radius / mParentObject.Radius) * mParentObject.mSimulationRadius;
            }
            else
            {
                mObjectDistance = 0;
                mSimulationRadius = 4800;
            }
            if (mParentObject != null)
                mParentObject.mOrbitObjects.Add(this);

            Root = new GameObject();
            //Construct();
            //Root.transform.position = new Vector3(0, 0, m_objectDistance);
            if (mParentObject != null)
            {
                Root.transform.parent = mParentObject.Root.transform;
                Root.transform.localPosition = new Vector3(0, 0, mObjectDistance);
            }
            else
            {
                Root.transform.position = new Vector3(0, 0, mObjectDistance);
            }
            if (mTrackObject != null)
            {
                mTrackObject.transform.parent = mParentObject.Root.transform;
                var pp = mParentObject.Root.transform.position;
                mTrackObject.transform.position = pp;
            }
            Body = body;
            Body.transform.parent = Root.transform;
            Body.transform.localScale = new Vector3(mSimulationRadius, mSimulationRadius, mSimulationRadius);
            Body.transform.localPosition = new Vector3(0, 0, 0);
            var vector = Quaternion.AngleAxis(inclination / DEGREEMULT, Vector3.right) * Vector3.up;
            Body.transform.up = vector;
            Root.name = mName + "_root";

            //Renderer rend = Body.GetComponent<Renderer>();
            //rend.material.shader = Shader.Find("Specular");
            //rend.material.SetColor("_SpecColor", Color.black);
        }
示例#6
0
 public OrbitalSystem()
 {
     RotationColumnOffset = 0;
     mOrbitalVelocity = 0;
     Spin = 0;
     Radius = 0;
     mParentObject = null;
     mTexture = null;
     mName = "";
     mBias = Vector3.zero;
     mOrbitalPlane = Vector2.zero;
     mOrbitEccentricity = 0;
     mObjectDistance = 0;
     mSimulationRadius = 0;
     Root = null;
     mTrackObject = null;
     mImage = null;
     mSiblingImage = null;
     mDepth = 0;
     mOrbitalPeriodOffset = 0;
 }
示例#7
0
        // Use this for initialization
        // ReSharper disable once InconsistentNaming
        // ReSharper disable once UnusedMember.Local
        private void Start()
        {
            mMonoCamera = GameObject.Find("Camera_mono");
            mMonoCamera.SetActive(false);
            mStereoCameraLeft = GameObject.Find("Camera_left");
            mStereoCameraRight = GameObject.Find("Camera_right");
            SSingleton = this;
            StarSphere = GameObject.Find("StarSphere");
            GameObject controller = GameObject.Find("Dive_Camera");
            PoseController = controller.GetComponent<PoseController>();
            StarSphere.transform.localScale = new Vector3(9990, 9990, 9990);

            OrbitalSystem.SetOrbitRange(1, 57910000.0f, 5913520000.0f); // planetary orbits
            OrbitalSystem.SetOrbitRange(2, 9000, 12952000); // lunar orbits
            OrbitalSystem.SetMassRange(1, 1.27E+22f, 1.9E+27f); // pluto to jupiter
            OrbitalSystem.SetMassRange(2, 1.80e15f, 1.48e23f); // deimos to ganymede
            OrbitalSystem.SetRadiusRange(1, 1137, 71492); // pluto to jupiter
            OrbitalSystem.SetRadiusRange(2, 6, 2631); // deimos to ganymede

            mSolarBodies["sun"] = new OrbitalSystem(0, "SunBody", null, 1.989e30f, 0.0f, 695000f, 0.0f, 0.0f, 1.17f, 28 * 9.78f, 1.0f,
                GameObject.Find("Sun"));
            mSolarBodies["mercury"] = new OrbitalSystem(1, "MercuryBody", mSolarBodies["sun"], 3.30000E+23f, 57910000f, 2.44000E+03f, 7f, 87.9f, 1407.6f,
                3.7f, 6.59026E-01f, GameObject.Find("Mercury"));
            mSolarBodies["venus"] = new OrbitalSystem(1, "VenusBody", mSolarBodies["sun"], 9.869E+23f, 108200000, 6051.8f, 3.39f, 224.701f, 5832.5f, 8.87f,
                0.987144169f, GameObject.Find("Venus"));
            mSolarBodies["earth"] = new OrbitalSystem(1, "EarthBody", mSolarBodies["sun"], 5.972E+24f, 179600000, 6378.15f, 9, 365.256f, -23.9345f, 9.78f,
                0.96712689f, GameObject.Find("Earth"));
            //earth->SetAtmosphere("clouds",-1,0.25,0.01 * DEGREEMULT,0,sm_textures[EarthClouds]);
            //CDIB* specChannel = new CDIB(theApp.GetFilePath() + "\\textures\\" +  RESPATH + "EarthBody-seas.bmp");
            //earth->SetHighlightMap(specChannel);

            mSolarBodies["mars"] = new OrbitalSystem(1, "MarsBody", mSolarBodies["sun"], 6.4219E+24f, 427940000, 3397, 1.85f, 686.980f, 24.6229f, 3.69f,
                0.82905297f, GameObject.Find("Mars"));
            mSolarBodies["jupiter"] = new OrbitalSystem(1, "Jupiter", mSolarBodies["sun"], 1.9E+27f, 778330000, 71492, 1.305f, 4332.589f, 9.925f, 23.12f,
                0.907598039f, GameObject.Find("Jupiter"));
            mSolarBodies["saturn"] = new OrbitalSystem(1, "Saturn", mSolarBodies["sun"], 5.68E+26f, 1429400000, 60268, 2.484f, 10759.22f, 10.500f, 8.96f,
                0.894583112f, GameObject.Find("Saturn"));
            //saturn->GenerateRing(96,41,80,true,sm_textures[SaturnRing]);

            mSolarBodies["uranus"] = new OrbitalSystem(1, "Uranus", mSolarBodies["sun"], 8.683E+25f, 2870990000, 25559, 0.7f, 30685.4f, 17.24f, 8.69f,
                0.909756422f, GameObject.Find("Uranus"));
            mSolarBodies["neptune"] = new OrbitalSystem(1, "Neptune", mSolarBodies["sun"], 1.0247E+26f, 4504000000, 24766, 1.7f, 60189, 16.11f, 11,
                0.982977597f, GameObject.Find("Neptune"));
            mSolarBodies["pluto"] = new OrbitalSystem(1, "Pluto", mSolarBodies["sun"], 1.27E+22f, 5913520000, 1137, 17.4f, 90465, 153.2928f, 0.66f,
                0.602313987f, GameObject.Find("Pluto"));

            //OrbitalSystem *moon = new OrbitalSystem(2,"MoonBody",earth,7.35e22,384000,1738,5.145, 27.322,655.728,1.62,sm_textures[Moon]);
            mSolarBodies["moon"] = new OrbitalSystem(2, "MoonBody", mSolarBodies["earth"], 7.35e22f, 384000.0f / 4.0f, 1738, 5.145f, -27.322f, 655.728f, 1.62f,
                0.98f, GameObject.Find("Moon"));

            mSolarBodies["phobos"] = new OrbitalSystem(2, "Phobos", mSolarBodies["mars"], 1.08e16f, 7000, 800, 1.08f, 0.31891f, 0.31891f, 0.01f, 0.98f,
                GameObject.Find("Phobos"));
            mSolarBodies["deimos"] = new OrbitalSystem(2, "Deimos", mSolarBodies["mars"], 1.80e15f, 18000, 400, 1.79f, 1.26244f, 0.07f, 0.01f, 0.98f,
                GameObject.Find("Deimos"));

            //OrbitalSystem amalthea = new OrbitalSystem(2,"Amalthea",jupiter,7.17e18,181000,98,1,0.498179,0.07,0.01,0.98,MercuryBody);
            mSolarBodies["io"] = new OrbitalSystem(2, "Io", mSolarBodies["jupiter"], 8.94e22f, 422000, 1815, 2, 1.769138f, 0.07f, 0.183f * 9.78f, 0.98f,
                GameObject.Find("Io"));
            mSolarBodies["europa"] = new OrbitalSystem(2, "Europa", mSolarBodies["jupiter"], 4.80e22f, 671000, 1569, 3, 3.551810f, 0.07f, 0.145f * 9.78f,
                0.98f, GameObject.Find("Europa"));
            mSolarBodies["ganymede"] = new OrbitalSystem(2, "Ganymede", mSolarBodies["jupiter"], 1.48e23f, 1070000, 2631, 4, 7.154553f, 0.07f, 0.145f * 9.78f,
                0.98f, GameObject.Find("Ganymede"));
            mSolarBodies["callisto"] = new OrbitalSystem(2, "Callisto", mSolarBodies["jupiter"], 1.08e23f, 1883000, 2400, 5, 16.689018f, 0.07f, 0.127f * 9.78f,
                0.98f, GameObject.Find("Callisto"));

            mSolarBodies["mimas"] = new OrbitalSystem(2, "mimas", mSolarBodies["saturn"], 3.80e19f, 186000, 196, 1, 0.9424218f, 0.07f, 0.008f * 9.78f, 0.98f,
                GameObject.Find("Mimas"));
            mSolarBodies["enceladus"] = new OrbitalSystem(2, "enceladus", mSolarBodies["saturn"], 8.40e19f, 238000, 260, 19, 1.370218f, 0.07f, 0.008f * 9.78f,
                0.98f, GameObject.Find("Enceladus"));
            mSolarBodies["tethys"] = new OrbitalSystem(2, "tethys", mSolarBodies["saturn"], 7.55e20f, 295000, 530, 3, 1.887802f, 0.07f, 0.018f * 9.78f, 0.98f,
                GameObject.Find("Tethys"));
            mSolarBodies["dione"] = new OrbitalSystem(2, "dione", mSolarBodies["saturn"], 1.05e21f, 377000, 560, 4, 2.736915f, 0.07f, 0.223f, 0.98f,
                GameObject.Find("Dione"));
            mSolarBodies["rhea"] = new OrbitalSystem(2, "rhea", mSolarBodies["saturn"], 2.49e21f, 527000, 765, 5, 4.517500f, 0.07f, 0.029f * 9.78f, 0.98f,
                GameObject.Find("Rhea"));
            mSolarBodies["titan"] = new OrbitalSystem(2, "titan", mSolarBodies["saturn"], 1.35e23f, 1222000, 2575, 6, 15.945421f, 0.07f, 9.78f * (1.0f / 7.0f),
                0.98f, GameObject.Find("Titan"));
            //OrbitalSystem hyperion = new OrbitalSystem(2,"hyperion",saturn,1.77e19,1481000,143,7,21.276609,0.07,0.107 ,0.98,MercuryBody);
            mSolarBodies["iapetus"] = new OrbitalSystem(2, "iapetus", mSolarBodies["saturn"], 1.88e21f, 3561000, 730, 8, 463, 0.07f, 0.107f, 0.98f,
                GameObject.Find("Iapetus"));
            //OrbitalSystem *phobe = new OrbitalSystem(2,"phobe",saturn,4.00e18,12952000,110,9,79.330183,0.07,0.107 ,0.98,PhobeBody);
            //solarRoot.mSimulationRadius = 400;

            // max distance --- 1222000
            // min orbital distance -- 7000
            // max radius -- 695000
            // min radius -- 196
            // get the spacecraft root frame of reference
            mSpacecraft = GameObject.Find("Spacecraft");
            //mSpacecraft.transform.position = new Vector3(1643.308f, -59.1503f, -83.91498f);
            //Quaternion q = Quaternion.Euler(new Vector3(356.3696f, 81.03871f, 0));
            //mSpacecraft.transform.rotation = q;

            // get the HUD status displays
            GameObject ss = GameObject.Find("SpeechStatus");
            mListeningStatus = ss.GetComponent<Text>();
            ss = GameObject.Find("ADFDisplay");
            mSelectedADF = ss.GetComponent<Text>();
            ss = GameObject.Find("ViewButtonText");
            mViewText = ss.GetComponent<Text>();
            ss = GameObject.Find("AutopilotStatus");
            AutopilotStatus = ss.GetComponent<Text>();
            ss = GameObject.Find("CreditsPanel");
            mCreditsDisplay = ss.GetComponent<Text>();
            mAutopilot = new AutoPilot { SolarBodies = mSolarBodies, SpaceCraft = mSpacecraft, SolarSystem = this };
            OrbitalElements = GameObject.FindGameObjectsWithTag("OrbitalElement");

            OrbitalSystem s = GetOrbitalSystem("saturn");
            GameObject saturnRing = GameObject.Find("SaturnRing");
            MeshFilter viewedModelFilter = (MeshFilter)saturnRing.GetComponent("MeshFilter");
            var mesh = viewedModelFilter.mesh;
            Vector2[] uvs = new Vector2[mesh.vertices.Length];
            double minDist = double.MaxValue;
            double maxDist = double.MinValue;
            for (int i = 0; i < mesh.vertices.Length; i++)
            {
                Vector3 aVertex = mesh.vertices[i];
                double a1 = Math.Atan2(aVertex.x, aVertex.y);
                Vector2 p = new Vector2(aVertex.x, aVertex.y);
                double pd = p.magnitude;
                if (pd < minDist)
                    minDist = pd;
                if (pd > maxDist)
                    maxDist = pd;
                double a2 = (a1 + Math.PI) / (Math.PI * 2);
                float ringAngle = (float)Math.Atan2(aVertex.y, aVertex.x);
                float orbitAngle = (float)Math.Atan2(s.Root.transform.position.z, s.Root.transform.position.x);
                float lightAngle = ringAngle - orbitAngle;
                if (lightAngle > Math.PI)
                    lightAngle = -Mathf.PI + (lightAngle - Mathf.PI);
                else if (lightAngle < -Math.PI)
                    lightAngle = Mathf.PI + (lightAngle - -Mathf.PI);
                if (lightAngle > 0)
                {
                    uvs[i] = new Vector2((float)a2, (pd < 0.5f) ? 0f : 1f);
                    //uvs[i] = new Vector2((float)a2, (pd < 0.5f) ? 0f : (ang > 0.2 || ang < -2) ? 0f : 1f);
                }
                else
                    uvs[i] = new Vector2(1, (pd < 0.5f) ? 0f : 1f);
            }
            mesh.uv = uvs;
            // scale the ring

            saturnRing.transform.position = s.Root.transform.position;
            saturnRing.transform.parent = s.Root.transform;
            saturnRing.transform.localScale = new Vector3(s.SimulationRadius * 1.6f, s.SimulationRadius * 1.6f, s.SimulationRadius * 1.6f);

            OrbitalSystem earth = GetOrbitalSystem("earth");
            earth.AddLiveLightingTexture(Resources.Load<Texture2D>("Textures/earth-land"),
                Resources.Load<Texture2D>("Textures/lightsatnight"), 220, 3);
            earth.AddAtmosphere(mSpacecraft, 2.05f, 0, 0, false, Resources.Load<Texture2D>("Textures/cloud-alpha"));
        }