示例#1
0
        //Standard update, taken out of Relativistic Object
        public void Update()
        {
            //Grab our renderer.
            MeshRenderer tempRenderer = GetComponent <MeshRenderer>();

            if (meshFilter != null && !state.MovementFrozen)
            {
                #region meshDensity
                //This is where I'm going to change our mesh density.
                //I'll take the model, and pass MeshDensity the mesh and unchanged vertices
                //If it comes back as having changed something, I'll edit the mesh.

                ObjectMeshDensity density = GetComponent <ObjectMeshDensity>();

                if (density != null)
                {
                    //Only run MeshDensity if the mesh needs to change, and if it's passed a threshold distance.
                    if (rawVerts != null && density.change != null)
                    {
                        //This checks if we're within our large range, first mesh density circle
                        //If we're within a distance of 40, split this mesh
                        if (density.state == false && RecursiveTransform(rawVerts[0], meshFilter.transform).magnitude < 21000)
                        {
                            if (density.ReturnVerts(meshFilter.mesh, true))
                            {
                                rawVerts = new Vector3[meshFilter.mesh.vertices.Length];
                                System.Array.Copy(meshFilter.mesh.vertices, rawVerts, meshFilter.mesh.vertices.Length);
                            }
                        }

                        //If the object leaves our wide range, revert mesh to original state
                        else if (density.state == true && RecursiveTransform(rawVerts[0], meshFilter.transform).magnitude > 21000)
                        {
                            if (density.ReturnVerts(meshFilter.mesh, false))
                            {
                                rawVerts = new Vector3[meshFilter.mesh.vertices.Length];
                                System.Array.Copy(meshFilter.mesh.vertices, rawVerts, meshFilter.mesh.vertices.Length);
                            }
                        }
                    }
                }
                #endregion


                //Send our object's v/c (Velocity over the Speed of Light) to the shader
                if (tempRenderer != null)
                {
                    Vector3 tempViw = viw.ToMinkowski4Viw() / (float)state.SpeedOfLight;
                    tempRenderer.materials[0].SetVector("_viw", tempViw);
                    Matrix4x4 minkowski = Matrix4x4.identity;
                    minkowski.m33 = 1;
                    minkowski.m00 = -1;
                    minkowski.m11 = -1;
                    minkowski.m22 = -1;
                    tempRenderer.materials[0].SetMatrix("_MixedMetric", minkowski);
                }

                //As long as our object is actually alive, perform these calculations
                if (transform != null)// && deathTime != 0)
                {
                    //Here I take the angle that the player's velocity vector makes with the z axis
                    float rotationAroundZ = RAD_2_DEG * Mathf.Acos(Vector3.Dot(state.PlayerVelocityVector, Vector3.forward) / state.PlayerVelocityVector.magnitude);

                    if (state.PlayerVelocityVector.sqrMagnitude == 0)
                    {
                        rotationAroundZ = 0;
                    }

                    //Now we turn that rotation into a quaternion

                    Quaternion rotateZ = Quaternion.AngleAxis(-rotationAroundZ, Vector3.Cross(state.PlayerVelocityVector, Vector3.forward));
                    //******************************************************************

                    //Place the vertex to be changed in a new Vector3
                    Vector3 riw = new Vector3(transform.position.x, transform.position.y, transform.position.z);
                    riw -= state.playerTransform.position;


                    //And we rotate our point that much to make it as if our magnitude of velocity is in the Z direction
                    riw = rotateZ * riw;


                    //Here begins the original code, made by the guys behind the Relativity game

                    /****************************
                     * Start Part 6 Bullet 1
                     *
                     */

                    //Rotate that velocity!
                    Vector3 storedViw = rotateZ * viw;

                    float c = -Vector3.Dot(riw, riw);             //first get position squared (position dotted with position)

                    float b = -(2 * Vector3.Dot(riw, storedViw)); //next get position dotted with velocity, should be only in the Z direction

                    float a = (float)state.SpeedOfLightSqrd - Vector3.Dot(storedViw, storedViw);

                    /****************************
                    * Start Part 6 Bullet 2
                    * **************************/

                    float tisw = (float)(((-b - (Math.Sqrt((b * b) - 4f * a * c))) / (2f * a)));
                    //If we're past our death time (in the player's view, as seen by tisw)
                    if (state.TotalTimeWorld + tisw > deathTime && deathTime != 0)
                    {
                        KillObject();
                    }
                    if (state.TotalTimeWorld + tisw > startTime && !tempRenderer.enabled)
                    {
                        tempRenderer.enabled = true;
                    }
                }

                //make our rigidbody's velocity the same as viw
                if (GetComponent <Rigidbody>() != null && !isParticle)
                {
                    if (!double.IsNaN((double)state.SqrtOneMinusVSquaredCWDividedByCSquared) && (float)state.SqrtOneMinusVSquaredCWDividedByCSquared != 0)
                    {
                        Vector3 tempViw = viw;
                        tempViw /= (float)state.SqrtOneMinusVSquaredCWDividedByCSquared;
                        //Attempt to correct for acceleration:
                        Vector3 playerPos = state.playerTransform.position;
                        Vector3 playerVel = state.PlayerVelocityVector;
                        tempViw /= (float)(1.0 + 1.0 / state.SpeedOfLightSqrd * Vector3.Dot(state.PlayerAccelerationVector, transform.position - playerPos));
                        GetComponent <Rigidbody>().velocity = tempViw;
                    }

                    //if (!double.IsNaN((double)state.InverseAcceleratedGamma) && (float)state.InverseAcceleratedGamma != 0)
                    //{
                    //    Vector3 tempViw = viw;
                    //    tempViw /= (float)state.InverseAcceleratedGamma;
                    //    GetComponent<Rigidbody>().velocity = tempViw;
                    //}
                }
                else if (isParticle)
                {
                    Vector3 tempViw = viw;
                    tempViw /= (float)state.SqrtOneMinusVSquaredCWDividedByCSquared;
                    //Attempt to correct for acceleration:
                    Vector3 playerPos = state.playerTransform.position;
                    Vector3 playerVel = state.PlayerVelocityVector;
                    tempViw           /= (float)(1.0 + 1.0 / state.SpeedOfLightSqrd * Vector3.Dot(state.PlayerAccelerationVector, transform.position - playerPos));
                    transform.position = transform.position + tempViw * Time.deltaTime;
                }
                //else if (isParticle)
                //{
                //    Vector3 tempViw = viw;
                //    tempViw /= (float)state.InverseAcceleratedGamma;
                //    transform.position = transform.position + tempViw * Time.deltaTime;
                //}
            }
            //If nothing is null, then set the object to standstill, but make sure its rigidbody actually has a velocity.
            else if (meshFilter != null && tempRenderer != null && GetComponent <Rigidbody>() != null)
            {
                GetComponent <Rigidbody>().velocity = Vector3.zero;
            }

            //This time transformation goes from world time to this objects personal time
            timer -= (float)(state.DeltaTimeWorld * (Math.Sqrt(1 - (viw.sqrMagnitude) / state.SpeedOfLightSqrd)));
            //If we've passed the time to explode, blow it up
            if (timer <= 0)
            {
                SetDeathTime();

                timer = float.MaxValue;
            }
        }
示例#2
0
    public void Update()
    {
        //Grab our renderer.
        MeshRenderer tempRenderer = GetComponent <MeshRenderer>();

        if (meshFilter != null && !state.MovementFrozen)
        {
            bool x = meshFilter != null;
            Debug.Log(x);
            #region meshDensity
            //This is where I'm going to change our mesh density.
            //I'll take the model, and pass MeshDensity the mesh and unchanged vertices
            //If it comes back as having changed something, I'll edit the mesh.

            ObjectMeshDensity density = GetComponent <ObjectMeshDensity>();

            if (density != null)
            {
                //Only run MeshDensity if the mesh needs to change, and if it's passed a threshold distance.
                if (rawVerts != null && density.change != null)
                {
                    //This checks if we're within our large range, first mesh density circle
                    //If we're within a distance of 40, split this mesh
                    if (density.state == false && RecursiveTransform(rawVerts[0], meshFilter.transform).magnitude < 21000)
                    {
                        if (density.ReturnVerts(meshFilter.mesh, true))
                        {
                            rawVerts = new Vector3[meshFilter.mesh.vertices.Length];
                            System.Array.Copy(meshFilter.mesh.vertices, rawVerts, meshFilter.mesh.vertices.Length);
                        }
                    }

                    //If the object leaves our wide range, revert mesh to original state
                    else if (density.state == true && RecursiveTransform(rawVerts[0], meshFilter.transform).magnitude > 21000)
                    {
                        if (density.ReturnVerts(meshFilter.mesh, false))
                        {
                            rawVerts = new Vector3[meshFilter.mesh.vertices.Length];
                            System.Array.Copy(meshFilter.mesh.vertices, rawVerts, meshFilter.mesh.vertices.Length);
                        }
                    }
                }
            }
            #endregion


            //Send our object's v/c (Velocity over the Speed of Light) to the shader
            if (tempRenderer != null)
            {
                Vector3 tempViw = viw / (float)state.SpeedOfLight;
                for (int i = 0; i < tempRenderer.materials.Length; i++)
                {
                    tempRenderer.materials[i].SetVector("_viw", new Vector4(tempViw.x, tempViw.y, tempViw.z, 0));
                }
            }

            //As long as our object is actually alive, perform these calculations
            if (transform != null)
            {
                //Here I take the angle that the player's velocity vector makes with the z axis
                float rotationAroundZ = RAD_2_DEG * Mathf.Acos(Vector3.Dot(state.PlayerVelocityVector, Vector3.forward) / state.PlayerVelocityVector.magnitude);

                if (state.PlayerVelocityVector.sqrMagnitude == 0)
                {
                    rotationAroundZ = 0;
                }

                //Now we turn that rotation into a quaternion

                Quaternion rotateZ = Quaternion.AngleAxis(-rotationAroundZ, Vector3.Cross(state.PlayerVelocityVector, Vector3.forward));
                //******************************************************************

                //Place the vertex to be changed in a new Vector3
                Vector3 riw = new Vector3(transform.position.x, transform.position.y, transform.position.z);
                riw -= state.playerTransform.position;


                //And we rotate our point that much to make it as if our magnitude of velocity is in the Z direction
                riw = rotateZ * riw;


                //Here begins the original code, made by the guys behind the Relativity game

                /****************************
                 * Start Part 6 Bullet 1
                 *
                 */

                //Rotate that velocity!
                Vector3 storedViw = rotateZ * viw;

                float c = -Vector3.Dot(riw, riw);                 //first get position squared (position doted with position)

                float b = -(2 * Vector3.Dot(riw, storedViw));     //next get position doted with velocity, should be only in the Z direction

                float a = (float)state.SpeedOfLightSqrd - Vector3.Dot(storedViw, storedViw);

                /****************************
                * Start Part 6 Bullet 2
                * **************************/

                float tisw = (float)(((-b - (Math.Sqrt((b * b) - 4f * a * c))) / (2f * a)));
                //If we're past our death time (in the player's view, as seen by tisw)
                if (state.TotalTimeWorld + tisw > deathTime && deathTime != 0)
                {
                    KillObject();
                }
                if (state.TotalTimeWorld + tisw > startTime && !tempRenderer.enabled)
                {
                    tempRenderer.enabled = true;
                    if (GetComponent <AudioSource>() != null)
                    {
                        GetComponent <AudioSource>().enabled = true;
                    }
                }
            }

            //make our rigidbody's velocity viw
            if (GetComponent <Rigidbody>() != null)
            {
                if (!double.IsNaN((double)state.SqrtOneMinusVSquaredCWDividedByCSquared) && (float)state.SqrtOneMinusVSquaredCWDividedByCSquared != 0)
                {
                    Vector3 tempViw = viw;
                    //ASK RYAN WHY THESE WERE DIVIDED BY THIS
                    tempViw.x /= (float)state.SqrtOneMinusVSquaredCWDividedByCSquared;
                    tempViw.y /= (float)state.SqrtOneMinusVSquaredCWDividedByCSquared;
                    tempViw.z /= (float)state.SqrtOneMinusVSquaredCWDividedByCSquared;

                    GetComponent <Rigidbody>().velocity = tempViw;
                }
            }
        }
        //If nothing is null, then set the object to standstill, but make sure its rigidbody actually has a velocity.
        else if (meshFilter != null && tempRenderer != null && GetComponent <Rigidbody>() != null)
        {
            GetComponent <Rigidbody>().velocity = Vector3.zero;
        }
    }
示例#3
0
    // Token: 0x06000080 RID: 128 RVA: 0x0000AD70 File Offset: 0x00008F70
    private void Update()
    {
        MeshRenderer component = base.GetComponent <MeshRenderer>();

        if (this.meshFilter != null && !this.state.MovementFrozen)
        {
            ObjectMeshDensity component2 = base.GetComponent <ObjectMeshDensity>();
            if (component2 != null && this.rawVerts != null && component2.change != null)
            {
                if (!component2.state && this.RecursiveTransform(this.rawVerts[0], this.meshFilter.transform).magnitude < 21000f)
                {
                    if (component2.ReturnVerts(this.meshFilter.mesh, true))
                    {
                        this.rawVerts = new Vector3[this.meshFilter.mesh.vertices.Length];
                        Array.Copy(this.meshFilter.mesh.vertices, this.rawVerts, this.meshFilter.mesh.vertices.Length);
                    }
                }
                else if (component2.state && this.RecursiveTransform(this.rawVerts[0], this.meshFilter.transform).magnitude > 21000f && component2.ReturnVerts(this.meshFilter.mesh, false))
                {
                    this.rawVerts = new Vector3[this.meshFilter.mesh.vertices.Length];
                    Array.Copy(this.meshFilter.mesh.vertices, this.rawVerts, this.meshFilter.mesh.vertices.Length);
                }
            }
            if (component != null)
            {
                Vector3 vector = this.viw / (float)this.state.SpeedOfLight;
                component.materials[0].SetVector("_viw", new Vector4(vector.x, vector.y, vector.z, 0f));
            }
            if (base.transform != null && this.deathTime != 0f)
            {
                float num = 57.29578f * Mathf.Acos(Vector3.Dot(this.state.PlayerVelocityVector, Vector3.forward) / this.state.PlayerVelocityVector.magnitude);
                if (this.state.PlayerVelocityVector.sqrMagnitude == 0f)
                {
                    num = 0f;
                }
                Quaternion rotation = Quaternion.AngleAxis(-num, Vector3.Cross(this.state.PlayerVelocityVector, Vector3.forward));
                Vector3    vector2  = new Vector3(base.transform.position.x, base.transform.position.y, base.transform.position.z);
                vector2 -= this.state.playerTransform.position;
                vector2  = rotation * vector2;
                Vector3 vector3 = rotation * this.viw;
                float   num2    = -Vector3.Dot(vector2, vector2);
                float   num3    = -(2f * Vector3.Dot(vector2, vector3));
                float   num4    = (float)this.state.SpeedOfLightSqrd - Vector3.Dot(vector3, vector3);
                float   num5    = (float)(((double)(-(double)num3) - Math.Sqrt((double)(num3 * num3 - 4f * num4 * num2))) / (double)(2f * num4));
                if (this.state.TotalTimeWorld + (double)num5 > (double)this.deathTime)
                {
                    UnityEngine.Object.Destroy(base.gameObject);
                }
            }
            if (base.GetComponent <Rigidbody>() != null && !double.IsNaN(this.state.SqrtOneMinusVSquaredCWDividedByCSquared) && (float)this.state.SqrtOneMinusVSquaredCWDividedByCSquared != 0f)
            {
                Vector3 velocity = this.viw;
                velocity.x /= (float)this.state.SqrtOneMinusVSquaredCWDividedByCSquared;
                velocity.y /= (float)this.state.SqrtOneMinusVSquaredCWDividedByCSquared;
                velocity.z /= (float)this.state.SqrtOneMinusVSquaredCWDividedByCSquared;
                base.GetComponent <Rigidbody>().velocity = velocity;
            }
        }
        else if (this.meshFilter != null && component != null && base.GetComponent <Rigidbody>() != null)
        {
            base.GetComponent <Rigidbody>().velocity = Vector3.zero;
        }
    }