public void UpdateRotor(float dps, IP_Input_Controller input)
        {
            //Debug.Log("Blurring Main Rotor");
            float normalizedDPS = Mathf.InverseLerp(0f, maxDps, dps);
            int   blurTexID     = Mathf.FloorToInt(normalizedDPS * blurTextures.Count - 1);

            blurTexID = Mathf.Clamp(blurTexID, 0, blurTextures.Count - 1);

            //check to see if we have Blur Textures and A blur Mat
            if (blurMat && blurTextures.Count > 0)
            {
                blurMat.SetTexture("_MainTex", blurTextures[blurTexID]);
            }

            //Handle the Geo Blades Visibility
            if (blurTexID > 2 && blades.Count > 0)
            {
                HandleGeoBladeViz(false);
            }
            else
            {
                HandleGeoBladeViz(true);
            }

            //Handle the Blur Geo Visibility
            if (blurTexID > 1)
            {
                HandleBlurGeo(true);
            }
            else
            {
                HandleBlurGeo(false);
            }
        }
        public void UpdateCharacteristics(Rigidbody rb, IP_Input_Controller input)
        {
            HandleLift(rb, input);
            HandleCyclic(rb, input);
            HandlePedals(rb, input);

            CalculateAngles();
            AutoLevel(rb);
        }
 protected virtual void HandleLift(Rigidbody rb, IP_Input_Controller input)
 {
     //Debug.Log("Handling Lift");
     if (mainRotor)
     {
         Vector3 liftForce      = transform.up * (Physics.gravity.magnitude + maxLiftForce) * rb.mass;
         float   normalizedRPMs = mainRotor.CurrentRPMs / 500f;
         rb.AddForce(liftForce * Mathf.Pow(normalizedRPMs, 2f) * Mathf.Pow(input.StickyCollectiveInput, 2f), ForceMode.Force);
     }
 }
 protected override void HandlePhysics()
 {
     input = GetComponent <IP_Input_Controller>();
     if (input)
     {
         HandleEngines();
         HandleRotors();
         HandleCharacteristics();
     }
 }
        public void UpdateRotor(float dps, IP_Input_Controller input)
        {
            //Debug.Log("Updating Tail Rotor");
            transform.Rotate(Vector3.right, dps * rotationSpeedModifier * Time.deltaTime);

            //Pitch the blased up and down
            if (lRotor && rRotor)
            {
                lRotor.localRotation = Quaternion.Euler(0f, input.PedalInput * maxPitch, 0f);
                rRotor.localRotation = Quaternion.Euler(0f, -input.PedalInput * maxPitch, 0f);
            }
        }
        public void UpdateRotors(IP_Input_Controller input, float curentRPMs)
        {
            //Debug.Log("Updating Rotor Controller");
            //Degrees per second calculation
            float dps = ((curentRPMs * 360f) / 60f);

            dps = Mathf.Clamp(dps, 0f, maxDps);


            //Update our Rotors
            if (rotors.Count > 0)
            {
                foreach (var rotor in rotors)
                {
                    rotor.UpdateRotor(dps, input);
                }
            }
        }
        public void UpdateRotor(float dps, IP_Input_Controller input)
        {
            //Debug.Log("Updating Main Rotor");
            currentRPMs = (dps / 360) * 60f;
            //Debug.Log(currentRPMs);
            transform.Rotate(Vector3.up, dps * Time.deltaTime * 0.5f);

            //Figure out the Swash blade effect
            Vector3 discNormal = Vector3.Normalize(transform.up + new Vector3(-cyclicVal.x, 0f, -cyclicVal.y));

            //Pitch the blades up and down
            if (lRotor && rRotor)
            {
                cyclicVal = input.CyclicInput;

                lRotor.localRotation = Quaternion.Euler(-input.StickyCollectiveInput * maxPitch, 0f, 0f);
                rRotor.localRotation = Quaternion.Euler(input.StickyCollectiveInput * maxPitch, 0f, 0f);
            }
        }
        protected virtual void HandleCyclic(Rigidbody rb, IP_Input_Controller input)
        {
            //Debug.Log("Handling Cyclic");
            float cyclicZForce = input.CyclicInput.x * cyclicForce;

            rb.AddRelativeTorque(Vector3.forward * cyclicZForce, ForceMode.Acceleration);

            float cyclicXForce = -input.CyclicInput.y * cyclicForce;

            rb.AddRelativeTorque(Vector3.right * cyclicXForce, ForceMode.Acceleration);


            //Apply force based off of the Dot Product values
            Vector3 forwardVec     = flatFwd * forwardDot;
            Vector3 rightVec       = flatRight * rightDot;
            Vector3 finalCyclicDir = Vector3.ClampMagnitude(forwardVec + rightVec, 1f) * (cyclicForce * cyclicForceMultiplier);

            //Debug.DrawRay(transform.position, finalCyclicDir, Color.green);
            rb.AddForce(finalCyclicDir, ForceMode.Force);
        }
 protected virtual void HandlePedals(Rigidbody rb, IP_Input_Controller input)
 {
     //Debug.Log("Handling Pedals");
     rb.AddTorque(Vector3.up * input.PedalInput * tailForce, ForceMode.Acceleration);
 }