Пример #1
0
        /// <summary>
        /// Called when the trigger ends
        /// </summary>
        /// <param name="poi"></param>
        public override void OnEnd(PegasusPoi poi)
        {
            if (poi == null)
            {
                Debug.LogWarning(string.Format("Poi was not supplied on {0} - exiting", name));
                return;
            }

            if (m_targetAnimation == null)
            {
                Debug.LogWarning(string.Format("Animation was not supplied on {0} - exiting", name));
                return;
            }

            if (m_triggerAtEnd)
            {
                if (m_actionOnStart == PegasusConstants.PoiAnimationTriggerAction.PlayAnimation)
                {
                    m_targetAnimation.Play(m_animations[m_startAnimationIdx].name);
                }
                else if (m_actionOnStart == PegasusConstants.PoiAnimationTriggerAction.StopAnimation)
                {
                    m_targetAnimation.Stop();
                }
            }
        }
Пример #2
0
        public float m_weatherTransitionTime = 10f; //Seconds

        /// <summary>
        /// Called when the trigger starts
        /// </summary>
        /// <param name="poi"></param>
        public override void OnStart(PegasusPoi poi)
        {
            if (poi == null)
            {
                Debug.LogWarning(string.Format("Poi was not supplied on {0} - exiting", name));
                return;
            }

            if (m_enviroSky == null)
            {
                m_enviroSky = GameObject.FindObjectOfType <EnviroSkyMgr>();
            }

            if (m_enviroSky == null)
            {
                Debug.LogWarning(string.Format("EnviroSky Manager was not located on {0} - exiting", name));
                return;
            }

            if (m_controlTime)
            {
                m_enviroSky.SetTimeOfDay(m_startTime);
            }

            if (m_controlWeather)
            {
                m_enviroSky.EnviroWeatherSettings.effectTransitionSpeed = m_weatherTransitionTime;
                m_enviroSky.ChangeWeather(m_weatherID);
            }
        }
Пример #3
0
 /// <summary>
 /// Called when the trigger ends
 /// </summary>
 /// <param name="poi"></param>
 public virtual void OnEnd(PegasusPoi poi)
 {
     if (poi != null && m_triggerAtEnd)
     {
         if (poi.m_manager.m_displayDebug == true)
         {
             Debug.Log(string.Format("Ended trigger on {0} - {1}", poi.m_manager.name, poi.name));
         }
     }
 }
Пример #4
0
 /// <summary>
 /// Called when the trigger is updated
 /// </summary>
 /// <param name="poi"></param>
 public virtual void OnUpdate(PegasusPoi poi, float progress)
 {
     if (poi != null && m_triggerOnUpdate)
     {
         if (poi.m_manager.m_displayDebug == true)
         {
             Debug.Log(string.Format("Udpated trigger on {0} - {1} {2:0.00}", poi.m_manager.name, poi.name, progress));
         }
     }
 }
Пример #5
0
 /// <summary>
 /// Return true if the other object is the same as this one
 /// </summary>
 /// <param name="poi">The other object to check</param>
 /// <returns></returns>
 public bool IsSameObject(PegasusPoi poi)
 {
     if (poi == null)
     {
         return(false);
     }
     if (this.GetInstanceID() == poi.GetInstanceID())
     {
         return(true);
     }
     return(false);
 }
Пример #6
0
        /// <summary>
        /// Called when the trigger is updated
        /// </summary>
        /// <param name="poi"></param>
        public override void OnUpdate(PegasusPoi poi, float progress)
        {
            if (m_enviroSky == null)
            {
                return;
            }

            if (m_controlTime)
            {
                m_enviroSky.SetTimeOfDay(m_startTime + ((m_endTime - m_startTime) * progress));
            }
        }
 /// <summary>
 /// Called when the trigger is updated
 /// </summary>
 /// <param name="poi"></param>
 public override void OnUpdate(PegasusPoi poi, float progress)
 {
     if ((poi != null) && (m_actionOnEnd != PegasusConstants.PoiHeliosTriggerAction.DoNothing))
     {
         if ((m_endProcessStarted != true) && ((Time.time * 1000f) >= m_endTimeStartMS))
         {
             m_endProcessStarted = true;
             if (m_actionOnEnd == PegasusConstants.PoiHeliosTriggerAction.FadeIn)
             {
                 StartCoroutine(FadeIn(m_endColour, m_endDuration));
             }
             else if (m_actionOnEnd == PegasusConstants.PoiHeliosTriggerAction.FadeOut)
             {
                 StartCoroutine(FadeOut(m_endColour, m_endDuration));
             }
         }
     }
 }
        /// <summary>
        /// Called when the trigger starts
        /// </summary>
        /// <param name="poi"></param>
        public override void OnStart(PegasusPoi poi)
        {
            if (poi == null)
            {
                Debug.LogWarning(string.Format("Poi was not supplied on {0} - exiting", name));
                return;
            }

            if (m_heliosUtility == null)
            {
                m_heliosUtility = GameObject.FindObjectOfType <HeliosUtility>();
            }

            if (m_heliosUtility == null)
            {
                Debug.LogWarning(string.Format("Helios was not located on {0} - exiting", name));
                return;
            }

            if (m_triggerAtStart)
            {
                if (m_actionOnStart == PegasusConstants.PoiHeliosTriggerAction.FadeIn)
                {
                    StartCoroutine(FadeIn(m_startColour, m_startDuration));
                }
                else if (m_actionOnStart == PegasusConstants.PoiHeliosTriggerAction.FadeOut)
                {
                    StartCoroutine(FadeOut(m_startColour, m_startDuration));
                }
            }

            //Set up when the end fade starts - work it backwards from the segment time
            if (m_triggerAtEnd && m_actionOnEnd != PegasusConstants.PoiHeliosTriggerAction.DoNothing)
            {
                //Calculate when end start time should kick in
                m_endProcessStarted = false;
                m_endTimeStartMS    = (float)poi.m_segmentDuration.TotalMilliseconds;
                if (m_endTimeStartMS > (m_endDuration * 1000f))
                {
                    m_endTimeStartMS = m_endDuration * 1000f;
                }
                m_endTimeStartMS = Time.time + (float)poi.m_segmentDuration.TotalMilliseconds - m_endTimeStartMS;
            }
        }
Пример #9
0
        /// <summary>
        /// This is called when we select the poi in the editor
        /// </summary>
        private void OnEnable()
        {
            if (target == null)
            {
                return;
            }

            //Get the control id
            m_editor_control_id = GUIUtility.GetControlID(this.GetHashCode(), FocusType.Passive);

            //Get our poi
            m_poi = (PegasusPoi)target;

            //And select us
            if (m_poi != null)
            {
                m_poi.m_manager.SelectPoi(m_poi);
                m_poi.m_manager.MoveTargetToPoi(m_poi);
            }
        }
        //TODO: Create an editor that only shows the appropriate variable value field

        public override void OnStart(PegasusPoi poi)
        {
            // TODO: convert string name to an animation ID for performance reasons
            switch (m_variableType)
            {
            case AnimationVariableType.Float:
                m_animator.SetFloat(m_variableName, m_floatValue);
                break;

            case AnimationVariableType.Int:
                m_animator.SetInteger(m_variableName, m_intValue);
                break;

            case AnimationVariableType.Bool:
                m_animator.SetBool(m_variableName, m_boolValue);
                break;

            case AnimationVariableType.Trigger:
                m_animator.SetTrigger(m_variableName);
                break;
            }
        }
Пример #11
0
        /// <summary>
        /// Draw the POI gui
        /// </summary>
        public override void OnInspectorGUI()
        {
            //Get our trigger
            m_trigger = (TriggerControlAnimation)target;

            //Set up the box style
            if (m_boxStyle == null)
            {
                m_boxStyle = new GUIStyle(GUI.skin.box);
                m_boxStyle.normal.textColor = GUI.skin.label.normal.textColor;
                m_boxStyle.fontStyle        = FontStyle.Bold;
                m_boxStyle.alignment        = TextAnchor.UpperLeft;
            }

            //Setup the wrap style
            if (m_wrapStyle == null)
            {
                m_wrapStyle          = new GUIStyle(GUI.skin.label);
                m_wrapStyle.wordWrap = true;
            }

            //Create a nice text intro
            GUILayout.BeginVertical("Pegasus Animation Trigger", m_boxStyle);
            GUILayout.Space(20);
            EditorGUILayout.LabelField("This trigger controls animations.", m_wrapStyle);
            GUILayout.EndVertical();

            EditorGUI.BeginChangeCheck();

            GUILayout.Space(5);

            //See if we can grab the animation off the manager target object if there is no animation
            if (m_trigger.m_targetAnimation == null)
            {
                PegasusPoi poi = m_trigger.gameObject.GetComponentInChildren <PegasusPoi>();
                if (poi != null)
                {
                    if (poi.m_manager.m_target != null)
                    {
                        m_trigger.m_targetAnimation = poi.m_manager.m_target.GetComponentInChildren <Animation>();
                    }
                }
            }

            //As
            Animation targetAnimation = (Animation)EditorGUILayout.ObjectField(GetLabel("Target"), m_trigger.m_targetAnimation, typeof(Animation), true);

            PegasusConstants.PoiAnimationTriggerAction actionOnStart = m_trigger.m_actionOnStart;
            int startAnimationIdx = m_trigger.m_startAnimationIdx;

            PegasusConstants.PoiAnimationTriggerAction actionOnEnd = m_trigger.m_actionOnEnd;

            if (targetAnimation != null)
            {
                actionOnStart = (PegasusConstants.PoiAnimationTriggerAction)EditorGUILayout.EnumPopup(GetLabel("Action On Start"), actionOnStart);

                if (actionOnStart == PegasusConstants.PoiAnimationTriggerAction.PlayAnimation)
                {
                    int          assetIdx     = 0;
                    GUIContent[] assetChoices = null;
                    assetChoices = new GUIContent[targetAnimation.GetClipCount()];
                    foreach (AnimationState anim in targetAnimation)
                    {
                        assetChoices[assetIdx++] = new GUIContent(anim.name);
                    }
                    startAnimationIdx = EditorGUILayout.Popup(GetLabel("Animation"), startAnimationIdx, assetChoices);
                }
                actionOnEnd = (PegasusConstants.PoiAnimationTriggerAction)EditorGUILayout.EnumPopup(GetLabel("Action On End"), actionOnEnd);
            }


            /*
             * GUILayout.BeginVertical("Target Lookat", m_boxStyle);
             *  GUILayout.Space(20);
             *  PegasusConstants.LookatType lookatType = (PegasusConstants.LookatType)EditorGUILayout.EnumPopup(GetLabel("Target"), m_poi.m_lookatType);
             *  float lookAtAngle = m_poi.m_lookAtAngle;
             *  float lookAtDistance = m_poi.m_lookAtDistance;
             *  float lookAtHeight = m_poi.m_lookAtHeight;
             *  if (lookatType == PegasusConstants.LookatType.Path)
             *  {
             *      GUI.enabled = false;
             *  }
             *  lookAtAngle = EditorGUILayout.Slider(GetLabel("  Angle"), m_poi.m_lookAtAngle, 0f, 359.9f);
             *  lookAtDistance = EditorGUILayout.FloatField(GetLabel("  Distance"), m_poi.m_lookAtDistance);
             *  lookAtHeight = EditorGUILayout.FloatField(GetLabel("  Height"), m_poi.m_lookAtHeight);
             *  GUI.enabled = true;
             *  GUILayout.Space(3);
             * GUILayout.EndVertical();
             */

            GUILayout.Space(5);

            //Check for changes, make undo record, make changes and let editor know we are dirty
            if (EditorGUI.EndChangeCheck())
            {
                Undo.RecordObject(m_trigger, "Made trigger changes");

                m_trigger.m_triggerAtStart    = true;
                m_trigger.m_triggerOnUpdate   = false;
                m_trigger.m_triggerAtEnd      = true;
                m_trigger.m_targetAnimation   = targetAnimation;
                m_trigger.m_actionOnStart     = actionOnStart;
                m_trigger.m_startAnimationIdx = startAnimationIdx;
                m_trigger.m_actionOnEnd       = actionOnEnd;

                //Mark it as dirty
                EditorUtility.SetDirty(m_trigger);
            }
        }
Пример #12
0
        /// <summary>
        /// Draw the gizmos
        /// </summary>
        /// <param name="isSelected"></param>
        private void DrawGizmos(bool isSelected)
        {
            //Determine whether to drop out
            if (!isSelected && !m_alwaysShowGizmos)
            {
                return;
            }

            //Check to see if we have a change in the state of our list - force an initialise if so
            if (transform.parent.childCount != m_manager.m_poiList.Count)
            {
                m_manager.InitialiseFlythrough();
            }

            #if UNITY_EDITOR
            //Make a check to see if we are selected - disable if not
            if (Selection.activeGameObject != null && Selection.activeGameObject.GetInstanceID() != this.gameObject.GetInstanceID())
            {
                m_isSelected = false;
            }
            #endif

            //Now draw the gizmos

            //Segment path spline
            float velRange = PegasusConstants.SpeedReallyFast - PegasusConstants.SpeedReallySlow;
            if (m_nextPoi != null)
            {
                //See if we need to draw the segments for this
                bool drawSegments = true;
                if (m_isLastPOI && m_manager.m_flythroughType == PegasusConstants.FlythroughType.SingleShot)
                {
                    drawSegments = false;
                }

                if (drawSegments)
                {
                    float   inc = 0.05f;
                    float   vel1, vel2;
                    Vector3 pos1, pos2;

                    pos1 = CalculatePositionSpline(0f);
                    vel1 = CalculateVelocity(0f);
                    for (float pct = inc; pct <= 1.02f; pct += inc)
                    {
                        //pos2 = CalculatePositionSpline(pct);
                        pos2 = CalculatePositionLinear(pct);
                        vel2 = CalculateVelocity(pct);
                        if (m_isSelected)
                        {
                            Gizmos.color = Color.magenta * Color.Lerp(Color.cyan, Color.red, ((vel1 + vel2 / 2f) - PegasusConstants.SpeedReallySlow) / velRange);
                        }
                        else
                        {
                            Gizmos.color = Color.Lerp(Color.cyan, Color.red, ((vel1 + vel2 / 2f) - PegasusConstants.SpeedReallySlow) / velRange);
                        }
                        Gizmos.DrawLine(pos1, pos2);
                        vel1 = vel2;
                        pos1 = pos2;
                    }
                }
            }


            /*
             * Vector3 point1 = m_poiList[segment + 1].m_targetLocation;
             *
             * Vector3 point2 = m_poiList[segment + 2].m_targetLocation;
             *
             * Vector3 tangent2 = m_poiList[segment + 3].m_targetLocation;
             *
             * Vector3 t2 = Vector3.Normalize(m_poiList[segment + 2].m_targetLocation - m_poiList[segment + 3].m_targetLocation) * smooth;
             *
             * Gizmos.color = Color.magenta;
             * Gizmos.DrawLine(m_poiList[segment + 2].m_targetLocation, m_poiList[segment + 2].m_targetLocation + t2);
             *
             *
             * tangent2 = m_poiList[segment + 2].m_targetLocation + t2;
             *
             * Gizmos.color = Color.green;
             *
             * for (int i = 0; i < 30; i++)
             * {
             *  Gizmos.DrawLine(Hermite(point1, tangent1, point2, tangent2, (float) i/40f),
             *      Hermite(point1, tangent1, point2, tangent2, (float)(i + 1)/40f));
             * }
             */

            //Only dray this in correct scenario
            if (m_lookatType == PegasusConstants.LookatType.Target)
            {
                //Line to lookat location
                Gizmos.color = Color.Lerp(Color.cyan, Color.red, (m_startSpeed - PegasusConstants.SpeedReallySlow) / velRange);
                Gizmos.DrawLine(transform.position, m_lookatLocation);

                //Lookat sphere
                Gizmos.color = Color.cyan;
                Gizmos.DrawSphere(m_lookatLocation, 0.25f);
            }

            //Are we last one, and is play next chosen
            Gizmos.color = Color.yellow;
            if (m_isLastPOI == true && m_manager.m_flythroughType == PegasusConstants.FlythroughType.SingleShot &&
                m_manager.m_flythroughEndAction == PegasusConstants.FlythroughEndAction.PlayNextPegasus &&
                m_manager.m_nextPegasus != null)
            {
                PegasusPoi nextPoi = m_manager.m_nextPegasus.GetFirstPOI();
                if (nextPoi != null)
                {
                    Gizmos.DrawLine(transform.position, nextPoi.transform.position);
                }
            }

            //Flythrough location
            Gizmos.DrawSphere(transform.position, m_manager.m_poiGizmoSize);
        }
Пример #13
0
        void OnSceneGUI()
        {
            //Exit if we dont have an event
            if (Event.current == null)
            {
                return;
            }

            //Exit if we dont have poi or manager
            if (m_poi == null || m_poi.m_manager == null)
            {
                return;
            }

            //Check for and handle attempts to push transform under ground - this is generally accidental
            if (m_poi.transform.hasChanged)
            {
                Undo.RecordObject(m_poi, "Made changes");

                //The rotation was changed
                if (m_poi.transform.localEulerAngles != m_poi.m_lastRotation)
                {
                    m_poi.m_autoRollOn   = false;
                    m_poi.m_lastRotation = m_poi.transform.localEulerAngles;
                }

                m_poi.transform.position = m_poi.m_manager.GetValidatedPoiPosition(m_poi.transform.position, m_poi.m_heightCheckType);
                m_poi.GetRelativeOffsets(m_poi.transform.position, m_poi.m_lookatLocation, out m_poi.m_lookAtDistance, out m_poi.m_lookAtHeight, out m_poi.m_lookAtAngle);
                m_poi.m_manager.UpdateSegmentWithDependencies(m_poi);
                m_poi.m_manager.MoveTargetToPoi(m_poi);
                m_poi.transform.hasChanged = false;
                EditorUtility.SetDirty(m_poi);
                return;
            }

            //Now handle manual lookat location changes
            if (m_poi.m_lookatType == PegasusConstants.LookatType.Target)
            {
                Vector3 lookAtLocation = m_poi.m_manager.GetValidatedLookatPosition(Handles.DoPositionHandle(m_poi.m_lookatLocation, Quaternion.identity), m_poi.m_heightCheckType);
                if (lookAtLocation != m_poi.m_lookatLocation)
                {
                    Undo.RecordObject(m_poi, "Made changes");
                    m_poi.m_lookatLocation = lookAtLocation;
                    m_poi.m_lookatType     = PegasusConstants.LookatType.Target;
                    m_poi.GetRelativeOffsets(m_poi.transform.position, m_poi.m_lookatLocation, out m_poi.m_lookAtDistance, out m_poi.m_lookAtHeight, out m_poi.m_lookAtAngle);
                    m_poi.m_manager.UpdateSegmentWithDependencies(m_poi);
                    m_poi.m_manager.MoveTargetToPoi(m_poi);
                    EditorUtility.SetDirty(m_poi);
                    return;
                }
            }

            //Ignore layout and repaint events
            //if (Event.current.type == EventType.Layout || Event.current.type == EventType.Repaint)
            //{
            //    return;
            //}

            //Make sure we have defaults for key presses
            if (m_poi.m_manager.m_defaults == null)
            {
                m_poi.m_manager.m_defaults = PegasusManagerEditor.GetDefaults();
            }

            //Keyboard events
            if (Event.current.control == true && Event.current.type == EventType.KeyDown)
            {
                //Up key
                if (Event.current.keyCode == m_poi.m_manager.m_defaults.m_keyUp)
                {
                    GUIUtility.hotControl = m_editor_control_id;

                    //Plain control is the POI
                    if (Event.current.shift != true)
                    {
                        m_poi.m_manager.MovePoi(m_poi, Vector3.up * 0.5f);
                    }
                    else
                    //Shift is the POI target
                    {
                        m_poi.m_manager.MovePoiLookat(m_poi, Vector3.up * 0.5f);
                    }
                    m_poi.m_manager.MoveTargetToPoi(m_poi);

                    EditorUtility.SetDirty(m_poi);
                    Event.current.Use();
                    GUIUtility.hotControl = 0;
                    return;
                }

                //Down key
                if (Event.current.keyCode == m_poi.m_manager.m_defaults.m_keyDown)
                {
                    GUIUtility.hotControl = m_editor_control_id;

                    //Plain control is the POI
                    if (Event.current.shift != true)
                    {
                        m_poi.m_manager.MovePoi(m_poi, Vector3.down * 0.5f);
                    }
                    else
                    //Shift is the POI target
                    {
                        m_poi.m_manager.MovePoiLookat(m_poi, Vector3.down * 0.5f);
                    }
                    m_poi.m_manager.MoveTargetToPoi(m_poi);

                    EditorUtility.SetDirty(m_poi);
                    Event.current.Use();
                    GUIUtility.hotControl = 0;
                    return;
                }

                //Left key
                if (Event.current.keyCode == m_poi.m_manager.m_defaults.m_keyLeft)
                {
                    GUIUtility.hotControl = m_editor_control_id;

                    Vector3 movement = Quaternion.Euler(0F, SceneView.lastActiveSceneView.rotation.eulerAngles.y, 0f) * Vector3.left;

                    //Plain control is the POI
                    if (Event.current.shift != true)
                    {
                        m_poi.m_manager.MovePoi(m_poi, movement * 0.5f);
                    }
                    else
                    //Shift is the POI target
                    {
                        m_poi.m_manager.MovePoiLookat(m_poi, movement * 0.5f);
                    }
                    m_poi.m_manager.MoveTargetToPoi(m_poi);

                    EditorUtility.SetDirty(m_poi);
                    Event.current.Use();
                    GUIUtility.hotControl = 0;
                    return;
                }

                //Forward key
                if (Event.current.keyCode == m_poi.m_manager.m_defaults.m_keyForward)
                {
                    GUIUtility.hotControl = m_editor_control_id;

                    Vector3 movement = Quaternion.Euler(0F, SceneView.lastActiveSceneView.rotation.eulerAngles.y, 0f) * Vector3.forward;

                    //Plain control is the POI
                    if (Event.current.shift != true)
                    {
                        m_poi.m_manager.MovePoi(m_poi, movement * 0.5f);
                    }
                    else
                    //Shift is the POI target
                    {
                        m_poi.m_manager.MovePoiLookat(m_poi, movement * 0.5f);
                    }
                    m_poi.m_manager.MoveTargetToPoi(m_poi);

                    EditorUtility.SetDirty(m_poi);
                    Event.current.Use();
                    GUIUtility.hotControl = 0;
                    return;
                }

                //Right
                if (Event.current.keyCode == m_poi.m_manager.m_defaults.m_keyRight)
                {
                    GUIUtility.hotControl = m_editor_control_id;

                    Vector3 movement = Quaternion.Euler(0F, SceneView.lastActiveSceneView.rotation.eulerAngles.y, 0f) * Vector3.right;

                    //Plain control is the POI
                    if (Event.current.shift != true)
                    {
                        m_poi.m_manager.MovePoi(m_poi, movement * 0.5f);
                    }
                    else
                    //Shift is the POI target
                    {
                        m_poi.m_manager.MovePoiLookat(m_poi, movement * 0.5f);
                    }
                    m_poi.m_manager.MoveTargetToPoi(m_poi);

                    EditorUtility.SetDirty(m_poi);
                    Event.current.Use();
                    GUIUtility.hotControl = 0;
                    return;
                }

                //Backward
                if (Event.current.keyCode == m_poi.m_manager.m_defaults.m_keyBackward)
                {
                    GUIUtility.hotControl = m_editor_control_id;

                    Vector3 movement = Quaternion.Euler(0F, SceneView.lastActiveSceneView.rotation.eulerAngles.y, 0f) * Vector3.back;

                    //Plain control is the POI
                    if (Event.current.shift != true)
                    {
                        m_poi.m_manager.MovePoi(m_poi, movement * 0.5f);
                    }
                    else
                    //Shift is the POI target
                    {
                        m_poi.m_manager.MovePoiLookat(m_poi, movement * 0.5f);
                    }
                    m_poi.m_manager.MoveTargetToPoi(m_poi);

                    EditorUtility.SetDirty(m_poi);
                    Event.current.Use();
                    GUIUtility.hotControl = 0;
                    return;
                }

                //Next POI
                if (Event.current.keyCode == m_poi.m_manager.m_defaults.m_keyPrevPoi)
                {
                    GUIUtility.hotControl = m_editor_control_id;

                    PegasusPoi poi = m_poi.m_manager.GetPrevPOI(m_poi);
                    if (poi != null)
                    {
                        if (Selection.activeTransform != null)
                        {
                            Selection.activeTransform = poi.transform;
                        }
                        if (SceneView.lastActiveSceneView != null)
                        {
                            SceneView.lastActiveSceneView.pivot = poi.transform.position;
                        }
                        m_poi = poi;
                        m_poi.m_manager.MoveTargetToPoi(m_poi);
                    }
                    Event.current.Use();
                    GUIUtility.hotControl = 0;
                    return;
                }

                //Prev POI
                if (Event.current.keyCode == m_poi.m_manager.m_defaults.m_keyNextPoi)
                {
                    GUIUtility.hotControl = m_editor_control_id;

                    PegasusPoi poi = m_poi.m_manager.GetNextPOI(m_poi);
                    if (poi != null)
                    {
                        if (Selection.activeTransform != null)
                        {
                            Selection.activeTransform = poi.transform;
                        }
                        if (SceneView.lastActiveSceneView != null)
                        {
                            SceneView.lastActiveSceneView.pivot = poi.transform.position;
                        }
                        m_poi = poi;
                        m_poi.m_manager.MoveTargetToPoi(m_poi);
                    }
                    Event.current.Use();
                    GUIUtility.hotControl = 0;
                    return;
                }
            }

            //Now handle mouse clicks that would add new pegasus poi
            if (Event.current.control == true && Event.current.isMouse == true)
            {
                if (Event.current.type == EventType.MouseDown && Event.current.button == 0)
                {
                    GUIUtility.hotControl = m_editor_control_id;

                    Ray        ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
                    RaycastHit hitInfo;
                    if (Physics.Raycast(ray, out hitInfo, 10000f))
                    {
                        Vector3 newPoint = m_poi.m_manager.GetValidatedPoiPosition(hitInfo.point);
                        if (newPoint != m_lastHitPoint)
                        {
                            m_lastHitPoint = newPoint;
                            m_poi.m_manager.AddPOI(m_lastHitPoint, m_lastHitPoint);
                        }
                    }
                    else
                    {
                        if (SceneView.lastActiveSceneView != null)
                        {
                            float dist = Vector3.Distance(ray.origin, SceneView.lastActiveSceneView.pivot);
                            m_lastHitPoint = Vector3.MoveTowards(ray.origin, SceneView.lastActiveSceneView.pivot, dist / 2f);
                        }
                        else
                        {
                            m_lastHitPoint = ray.origin;
                        }
                        if (m_poi.m_manager.m_poiList.Count == 0)
                        {
                            m_poi.m_manager.m_heightCheckType = PegasusConstants.HeightCheckType.None;
                        }
                        m_poi.m_manager.AddPOI(m_lastHitPoint, m_lastHitPoint);
                    }

                    SceneView.RepaintAll();
                }
                else if (GUIUtility.hotControl == m_editor_control_id && Event.current.type == EventType.MouseUp && Event.current.button == 0)
                {
                    GUIUtility.hotControl = 0;
                }
                return;
            }
        }
Пример #14
0
        /// <summary>
        /// Draw the POI gui
        /// </summary>
        public override void OnInspectorGUI()
        {
            //Get our poi
            m_poi = (PegasusPoi)target;

            //Set up the box style
            if (m_boxStyle == null)
            {
                m_boxStyle = new GUIStyle(GUI.skin.box);
                m_boxStyle.normal.textColor = GUI.skin.label.normal.textColor;
                m_boxStyle.fontStyle        = FontStyle.Bold;
                m_boxStyle.alignment        = TextAnchor.UpperLeft;
            }

            //Setup the wrap style
            if (m_wrapStyle == null)
            {
                m_wrapStyle          = new GUIStyle(GUI.skin.label);
                m_wrapStyle.wordWrap = true;
            }

            //Create a nice text intro
            GUILayout.BeginVertical("Point of Interest", m_boxStyle);
            GUILayout.Space(20);
            EditorGUILayout.LabelField("The yellow sphere will be flown through, and the blue sphere is what the camera is looking at. If the blue sphere is not shown then the camera will look along the path of the flythrough.\n\nClick on POI in scene then...\nCTRL + Keys - Move selected POI.\nSHIFT+CTRL + Keys - Move selected LookAt.\nSee PegasusDefaults for Keys.", m_wrapStyle);
            GUILayout.EndVertical();

            EditorGUI.BeginChangeCheck();

            PegasusConstants.PoiType poiType = m_poi.m_poiType;

            GUILayout.Space(5);

            GUILayout.BeginVertical("Auto Roll", m_boxStyle);
            GUILayout.Space(20);
            bool autoRoll = EditorGUILayout.Toggle(GetLabel("Auto Roll"), m_poi.m_autoRollOn);

            GUILayout.Space(3);
            GUILayout.EndVertical();

            GUILayout.Space(5);

            GUILayout.BeginVertical("Target Lookat", m_boxStyle);
            GUILayout.Space(20);
            PegasusConstants.LookatType lookatType = (PegasusConstants.LookatType)EditorGUILayout.EnumPopup(GetLabel("Target"), m_poi.m_lookatType);
            float lookAtAngle    = m_poi.m_lookAtAngle;
            float lookAtDistance = m_poi.m_lookAtDistance;
            float lookAtHeight   = m_poi.m_lookAtHeight;

            if (lookatType == PegasusConstants.LookatType.Path)
            {
                GUI.enabled = false;
            }
            lookAtAngle    = EditorGUILayout.Slider(GetLabel("  Angle"), m_poi.m_lookAtAngle, 0f, 359.9f);
            lookAtDistance = EditorGUILayout.FloatField(GetLabel("  Distance"), m_poi.m_lookAtDistance);
            lookAtHeight   = EditorGUILayout.FloatField(GetLabel("  Height"), m_poi.m_lookAtHeight);
            GUI.enabled    = true;
            GUILayout.Space(3);
            GUILayout.EndVertical();

            GUILayout.Space(5);

            GUILayout.BeginVertical("Target Speed", m_boxStyle);
            GUILayout.Space(20);
            PegasusConstants.SpeedType speedType = (PegasusConstants.SpeedType)EditorGUILayout.EnumPopup(GetLabel("Type"), m_poi.m_startSpeedType);
            float startSpeed = m_poi.m_startSpeed;

            if (speedType != PegasusConstants.SpeedType.Custom)
            {
                EditorGUILayout.LabelField(GetLabel("Speed"), GetLabel(string.Format("{0:0.00} m/sec", startSpeed)));
            }
            else
            {
                startSpeed = EditorGUILayout.FloatField(GetLabel("Speed"), startSpeed);
                if (startSpeed < 0.0001f)
                {
                    startSpeed = 0.0001f;
                }
            }
            GUILayout.Space(3);
            GUILayout.EndVertical();

            GUILayout.Space(5);

            GUILayout.BeginVertical("Height Constraint", m_boxStyle);
            GUILayout.Space(20);
            PegasusConstants.PoiHeightCheckType heightCheckType = (PegasusConstants.PoiHeightCheckType)EditorGUILayout.EnumPopup(GetLabel("Min Height From"), m_poi.m_heightCheckType);
            GUILayout.Space(3);
            GUILayout.EndVertical();

            GUILayout.Space(5);

            GUILayout.BeginVertical("Statistics", m_boxStyle);
            GUILayout.Space(20);
            EditorGUILayout.LabelField("Distance", string.Format("{0:0.00m}", m_poi.m_segmentDistance));
            EditorGUILayout.LabelField("Start Time", string.Format("{0}:{1:00}.{2:000}", m_poi.m_segmentStartTime.Minutes, m_poi.m_segmentStartTime.Seconds, m_poi.m_segmentStartTime.Milliseconds));
            EditorGUILayout.LabelField("Segment Time", string.Format("{0}:{1:00}.{2:000}", m_poi.m_segmentDuration.Minutes, m_poi.m_segmentDuration.Seconds, m_poi.m_segmentDuration.Milliseconds));
            EditorGUILayout.LabelField("Total Time", string.Format("{0}:{1:00}.{2:000}", m_poi.m_manager.m_totalDuration.Minutes, m_poi.m_manager.m_totalDuration.Seconds, m_poi.m_manager.m_totalDuration.Milliseconds));
            GUILayout.Space(3);
            GUILayout.EndVertical();

            PegasusConstants.EasingType velocityEasing = m_poi.m_velocityEasingType;
            PegasusConstants.EasingType rotationEasing = m_poi.m_rotationEasingType;
            PegasusConstants.EasingType positionEasing = m_poi.m_positionEasingType;

            GUILayout.Space(5);

            GUILayout.BeginVertical("Utilities", m_boxStyle);
            GUILayout.Space(20);

            if (GUILayout.Button(GetLabel("Select Manager")))
            {
                if (Selection.activeTransform != null)
                {
                    Selection.activeTransform = m_poi.m_manager.transform;
                }
            }
            if (GUILayout.Button(GetLabel("Select First POI")))
            {
                PegasusPoi poi = m_poi.m_manager.GetFirstPOI();
                if (poi != null)
                {
                    if (SceneView.lastActiveSceneView != null)
                    {
                        SceneView.lastActiveSceneView.pivot = poi.transform.position;
                    }
                    if (Selection.activeTransform != null)
                    {
                        Selection.activeTransform = poi.transform;
                    }
                    poi.m_manager.SelectPoi(poi);
                    poi.m_manager.MoveTargetToPoi(poi);
                }
            }

            GUILayout.BeginHorizontal();
            if (GUILayout.Button(GetLabel("Select Previous POI")))
            {
                PegasusPoi poi = m_poi.m_manager.GetPrevPOI(m_poi);
                if (poi != null)
                {
                    if (Selection.activeTransform != null)
                    {
                        Selection.activeTransform = poi.transform;
                    }
                    if (SceneView.lastActiveSceneView != null)
                    {
                        SceneView.lastActiveSceneView.pivot = poi.transform.position;
                    }
                    poi.m_manager.SelectPoi(poi);
                    poi.m_manager.MoveTargetToPoi(poi);
                }
            }
            if (GUILayout.Button(GetLabel("Select Next POI")))
            {
                PegasusPoi poi = m_poi.m_manager.GetNextPOI(m_poi);
                if (poi != null)
                {
                    if (Selection.activeTransform != null)
                    {
                        Selection.activeTransform = poi.transform;
                    }
                    if (SceneView.lastActiveSceneView != null)
                    {
                        SceneView.lastActiveSceneView.pivot = poi.transform.position;
                    }
                    poi.m_manager.SelectPoi(poi);
                    poi.m_manager.MoveTargetToPoi(poi);
                }
            }
            GUILayout.EndHorizontal();

            GUILayout.BeginHorizontal();
            if (GUILayout.Button(GetLabel("Add POI Before")))
            {
                PegasusPoi poi = m_poi.m_manager.AddPoiBefore(m_poi);
                if (poi != null)
                {
                    if (Selection.activeTransform != null)
                    {
                        Selection.activeTransform = poi.transform;
                    }
                    if (SceneView.lastActiveSceneView != null)
                    {
                        SceneView.lastActiveSceneView.pivot = poi.transform.position;
                    }
                    poi.m_manager.SelectPoi(poi);
                    poi.m_manager.MoveTargetToPoi(poi);
                }
            }
            if (GUILayout.Button(GetLabel("Add POI After")))
            {
                PegasusPoi poi = m_poi.m_manager.AddPoiAfter(m_poi);
                if (poi != null)
                {
                    if (Selection.activeTransform != null)
                    {
                        Selection.activeTransform = poi.transform;
                    }
                    if (SceneView.lastActiveSceneView != null)
                    {
                        SceneView.lastActiveSceneView.pivot = poi.transform.position;
                    }
                    poi.m_manager.SelectPoi(poi);
                    poi.m_manager.MoveTargetToPoi(poi);
                }
            }
            GUILayout.EndHorizontal();

            GUILayout.Space(3);
            GUILayout.EndVertical();

            //Check for changes, make undo record, make changes and let editor know we are dirty
            if (EditorGUI.EndChangeCheck())
            {
                Undo.RecordObject(m_poi, "Made changes");
                m_poi.m_poiType = poiType;

                m_poi.m_autoRollOn = autoRoll;

                if (m_poi.m_lookatType != lookatType && lookatType == PegasusConstants.LookatType.Target)
                {
                    lookAtHeight   = 0f;
                    lookAtDistance = 5f;
                }
                m_poi.m_lookatType = lookatType;

                if (heightCheckType != m_poi.m_heightCheckType)
                {
                    m_poi.m_heightCheckType = heightCheckType;
                    //m_poi.m_manager.UpdateSegmentWithDependencies(m_poi);
                }

                if (!PegasusPoi.ApproximatelyEqual(m_poi.m_lookAtAngle, lookAtAngle))
                {
                    m_poi.m_lookAtAngle       = lookAtAngle;
                    m_poi.m_lookatLocation    = m_poi.transform.position + (m_poi.transform.localRotation * Quaternion.AngleAxis(m_poi.m_lookAtAngle, Vector3.up)) * new Vector3(0f, 0f, -m_poi.m_lookAtDistance);
                    m_poi.m_lookatLocation    = m_poi.m_manager.GetLowestLookatPosition(m_poi.m_lookatLocation, m_poi.m_heightCheckType);
                    m_poi.m_lookatLocation.y += m_poi.m_lookAtHeight;
                }
                else if (!PegasusPoi.ApproximatelyEqual(m_poi.m_lookAtDistance, lookAtDistance))
                {
                    m_poi.m_lookAtDistance    = lookAtDistance;
                    m_poi.m_lookatLocation    = m_poi.transform.position + (m_poi.transform.localRotation * Quaternion.AngleAxis(m_poi.m_lookAtAngle, Vector3.up)) * new Vector3(0f, 0f, -m_poi.m_lookAtDistance);
                    m_poi.m_lookatLocation    = m_poi.m_manager.GetLowestLookatPosition(m_poi.m_lookatLocation, m_poi.m_heightCheckType);
                    m_poi.m_lookatLocation.y += m_poi.m_lookAtHeight;
                }
                else if (!PegasusPoi.ApproximatelyEqual(m_poi.m_lookAtHeight, lookAtHeight))
                {
                    m_poi.m_lookAtHeight      = lookAtHeight;
                    m_poi.m_lookatLocation    = m_poi.transform.position + (m_poi.transform.localRotation * Quaternion.AngleAxis(m_poi.m_lookAtAngle, Vector3.up)) * new Vector3(0f, 0f, -m_poi.m_lookAtDistance);
                    m_poi.m_lookatLocation    = m_poi.m_manager.GetLowestLookatPosition(m_poi.m_lookatLocation, m_poi.m_heightCheckType);
                    m_poi.m_lookatLocation.y += m_poi.m_lookAtHeight;
                }

                if (m_poi.m_startSpeedType != speedType)
                {
                    m_poi.m_startSpeedType = speedType;
                    m_poi.m_startSpeed     = m_poi.GetStartSpeed(speedType);
                }
                else
                {
                    if (!PegasusPoi.ApproximatelyEqual(m_poi.m_startSpeed, startSpeed))
                    {
                        m_poi.m_startSpeedType = PegasusConstants.SpeedType.Custom;
                        m_poi.m_startSpeed     = startSpeed;
                    }
                }

                m_poi.m_velocityEasingType = velocityEasing;
                m_poi.m_rotationEasingType = rotationEasing;
                m_poi.m_positionEasingType = positionEasing;

                //Update the segment
                m_poi.m_manager.UpdateSegmentWithDependencies(m_poi);

                //Mark it as dirty
                EditorUtility.SetDirty(m_poi);
            }
        }
        public override void OnInspectorGUI()
        {
            //Get our manager
            m_manager = (PegasusManager)target;

            //Set up the box style
            if (m_boxStyle == null)
            {
                m_boxStyle = new GUIStyle(GUI.skin.box);
                m_boxStyle.normal.textColor = GUI.skin.label.normal.textColor;
                m_boxStyle.fontStyle        = FontStyle.Bold;
                m_boxStyle.alignment        = TextAnchor.UpperLeft;
            }

            //Setup the wrap style
            if (m_wrapStyle == null)
            {
                m_wrapStyle           = new GUIStyle(GUI.skin.label);
                m_wrapStyle.fontStyle = FontStyle.Normal;
                m_wrapStyle.wordWrap  = true;
            }

            //Text intro
            GUILayout.BeginVertical(string.Format("Pegasus ({0}.{1})", PegasusConstants.MajorVersion, PegasusConstants.MinorVersion), m_boxStyle);
            GUILayout.Space(20);
            EditorGUILayout.LabelField("Welcome to Pegasus!\nTo visualise flythrough in editor mode select Window->Layouts->2 x 3 so that both Scene & Game windows are showing.\nCtrl + Left Click: Add POI.\nCrtl + ScrollWheel: Scrub timeline.", m_wrapStyle);
            GUILayout.EndVertical();

            EditorGUI.BeginChangeCheck();

            GUILayout.Space(5);

            GUILayout.BeginVertical("Configuration", m_boxStyle);
            GUILayout.Space(20);
            GameObject poiTarget = (GameObject)EditorGUILayout.ObjectField(GetLabel("Target Object"), m_manager.m_target, typeof(GameObject), true);

            PegasusConstants.FlythroughType      flythroughType      = (PegasusConstants.FlythroughType)EditorGUILayout.EnumPopup(GetLabel("Flythrough Type"), m_manager.m_flythroughType);
            PegasusConstants.FlythroughEndAction flythroughEndAction = m_manager.m_flythroughEndAction;
            PegasusManager nextPegasus = m_manager.m_nextPegasus;

            if (flythroughType == PegasusConstants.FlythroughType.SingleShot)
            {
                flythroughEndAction = (PegasusConstants.FlythroughEndAction)EditorGUILayout.EnumPopup(GetLabel("Flythrough End"), flythroughEndAction);
                if (flythroughEndAction == PegasusConstants.FlythroughEndAction.PlayNextPegasus)
                {
                    nextPegasus = (PegasusManager)EditorGUILayout.ObjectField(GetLabel("Next Pegasus"), nextPegasus, typeof(PegasusManager), true);
                }
            }
            bool autoStartAtRuntime = EditorGUILayout.Toggle(GetLabel("Play On Start"), m_manager.m_autoStartAtRuntime);

            PegasusConstants.TargetFrameRate targetFrameRateType = m_manager.m_targetFramerateType;
            PegasusConstants.HeightCheckType heightCheckType     = m_manager.m_heightCheckType;
            float minHeightAboveTerrain = m_manager.m_minHeightAboveTerrain;
            float collisionHeightOffset = m_manager.m_collisionHeightOffset;
            float rotationDamping       = m_manager.m_rotationDamping;
            float positionDamping       = m_manager.m_positionDamping;
            float poiSize = m_manager.m_poiGizmoSize;

            bool showAdvanced = EditorGUILayout.BeginToggleGroup(GetLabel(" Advanced"), m_manager.m_showAdvanced);

            if (showAdvanced)
            {
                EditorGUI.indentLevel++;
                targetFrameRateType = (PegasusConstants.TargetFrameRate)EditorGUILayout.EnumPopup(GetLabel("Framerate"), m_manager.m_targetFramerateType);
                heightCheckType     = (PegasusConstants.HeightCheckType)EditorGUILayout.EnumPopup(GetLabel("Check Height"), m_manager.m_heightCheckType);
                if (heightCheckType != PegasusConstants.HeightCheckType.None)
                {
                    if (heightCheckType == PegasusConstants.HeightCheckType.Collision)
                    {
                        collisionHeightOffset = EditorGUILayout.FloatField(GetLabel("Collision Offset"), collisionHeightOffset);
                    }
                    minHeightAboveTerrain = EditorGUILayout.FloatField(GetLabel("Min POI Height"), minHeightAboveTerrain);
                }
                rotationDamping = EditorGUILayout.Slider(GetLabel("Rotation Damping"), m_manager.m_rotationDamping, 0f, 3f);
                positionDamping = EditorGUILayout.Slider(GetLabel("Position Damping"), m_manager.m_positionDamping, 0f, 3f);
                poiSize         = EditorGUILayout.Slider(GetLabel("Gizmo Size"), poiSize, 0.1f, 5f);
                EditorGUI.indentLevel--;
            }
            EditorGUILayout.EndToggleGroup();
            GUILayout.Space(3);

            GUILayout.Space(3);
            GUILayout.EndVertical();

            GUILayout.Space(5);

            GUILayout.BeginVertical("Statistics", m_boxStyle);
            GUILayout.Space(20);
            EditorGUILayout.LabelField("Distance", string.Format("{0:0.00m}", m_manager.m_totalDistance));
            EditorGUILayout.LabelField("Duration", string.Format("{0}:{1:00}.{2:000}", m_manager.m_totalDuration.Minutes, m_manager.m_totalDuration.Seconds, m_manager.m_totalDuration.Milliseconds));
            GUILayout.Space(3);
            GUILayout.EndVertical();

            GUILayout.Space(5);

            GUILayout.BeginVertical(m_boxStyle);
            float scrubber = m_manager.m_totalDistanceTravelledPct;

            m_manager.m_showScrubber = EditorGUILayout.BeginToggleGroup(GetLabel(" Visualisation"), m_manager.m_showScrubber);
            bool showDebug        = m_manager.m_displayDebug;
            bool alwaysShowGizmos = m_manager.m_alwaysShowGizmos;

            if (m_manager.m_showScrubber)
            {
                EditorGUILayout.LabelField("Switch to Game View and use the Scrubber and Step controls to visualise the flythrough path while in edit mode. This will physically move your Target in the scene so make sure you put it back to its original location afterwards.", m_wrapStyle);
                scrubber = EditorGUILayout.Slider(GetLabel("Scrubber"), scrubber, 0f, 1f);
                GUILayout.BeginHorizontal();
                if (GUILayout.Button(GetLabel("Step Backward")))
                {
                    m_manager.StepTargetBackward(1f);
                    scrubber = m_manager.m_totalDistanceTravelledPct;
                }
                if (GUILayout.Button(GetLabel("Step Forward")))
                {
                    m_manager.StepTargetForward(1f);
                    scrubber = m_manager.m_totalDistanceTravelledPct;
                }
                GUILayout.EndHorizontal();
                alwaysShowGizmos = EditorGUILayout.Toggle(GetLabel("Show Gizmos"), alwaysShowGizmos);
                showDebug        = EditorGUILayout.Toggle(GetLabel("Show debug"), showDebug);
            }
            EditorGUILayout.EndToggleGroup();
            GUILayout.Space(3);
            GUILayout.EndVertical();

            GUILayout.Space(5);

            GUILayout.BeginVertical(m_boxStyle);
            m_manager.m_showPOIHelpers = EditorGUILayout.BeginToggleGroup(GetLabel(" Utilities"), m_manager.m_showPOIHelpers);
            if (m_manager.m_showPOIHelpers)
            {
                if (GUILayout.Button(GetLabel("Go To First POI")))
                {
                    PegasusPoi poi = m_manager.GetPOI(0);
                    if (poi != null)
                    {
                        if (Selection.activeTransform != null)
                        {
                            Selection.activeTransform = poi.transform;
                        }
                        if (SceneView.lastActiveSceneView != null)
                        {
                            SceneView.lastActiveSceneView.pivot = poi.transform.position;
                        }
                        poi.m_manager.SelectPoi(poi);
                        poi.m_manager.MoveTargetToPoi(poi);
                    }
                }
                if (GUILayout.Button(GetLabel("Set POI To Min Height")))
                {
                    m_manager.SetPoiToMinHeight();
                }
                if (GUILayout.Button(GetLabel("Show Debug On POI")))
                {
                    m_manager.CreateDebugObjects();
                }
                if (GUILayout.Button(GetLabel("Hide Debug on POI")))
                {
                    m_manager.DeleteDebugObjects();
                }
            }
            EditorGUILayout.EndToggleGroup();
            GUILayout.Space(3);
            GUILayout.EndVertical();

            GUILayout.Space(5);

            //Display some playback controls
            if (EditorApplication.isPlaying)
            {
                GUILayout.BeginVertical("Playback Status", m_boxStyle);
                GUILayout.Space(20);
                EditorGUILayout.LabelField("Status", m_manager.m_currentState.ToString());
                if (m_manager.m_currentState == PegasusConstants.FlythroughState.Started)
                {
                    EditorGUILayout.LabelField("Delta Time", string.Format("{0:0.000}", m_manager.m_frameUpdateTime));
                    EditorGUILayout.LabelField("Delta Dist", string.Format("{0:0.000}", m_manager.m_frameUpdateDistance));
                    EditorGUILayout.LabelField("Current Speed", string.Format("{0:0.00}", m_manager.m_currentVelocity));
                    EditorGUILayout.LabelField("Distance Travelled", string.Format("{0:0.00}", m_manager.m_totalDistanceTravelled));
                    EditorGUILayout.LabelField("Total Distance", string.Format("{0:0.00}", m_manager.m_totalDistance));
                }
                else
                {
                    EditorGUILayout.LabelField("Delta Time", string.Format("{0:0.000}", 0f));
                    EditorGUILayout.LabelField("Delta Dist", string.Format("{0:0.000}", 0f));
                    EditorGUILayout.LabelField("Current Speed", string.Format("{0:0.00}", 0f));
                    EditorGUILayout.LabelField("Distance Travelled", string.Format("{0:0.00}", m_manager.m_totalDistanceTravelled));
                    EditorGUILayout.LabelField("Total Distance", string.Format("{0:0.00}", m_manager.m_totalDistance));
                }

                if (m_manager.m_currentState == PegasusConstants.FlythroughState.Stopped)
                {
                    if (GUILayout.Button(GetLabel("Play")))
                    {
                        m_manager.StartFlythrough();
                    }
                }
                else
                {
                    GUILayout.BeginHorizontal();
                    if (m_manager.m_currentState == PegasusConstants.FlythroughState.Paused)
                    {
                        if (GUILayout.Button(GetLabel("Resume")))
                        {
                            m_manager.ResumeFlythrough();
                        }
                    }
                    else if (m_manager.m_currentState == PegasusConstants.FlythroughState.Started)
                    {
                        if (GUILayout.Button(GetLabel("Pause")))
                        {
                            m_manager.PauseFlythrough();
                        }
                    }
                    if (GUILayout.Button(GetLabel("Stop")))
                    {
                        m_manager.StopFlythrough();
                    }
                    GUILayout.EndHorizontal();
                }
                GUILayout.Space(3);
                GUILayout.EndVertical();
            }

            if (EditorGUI.EndChangeCheck())
            {
                Undo.RecordObject(m_manager, "Made changes");
                m_manager.m_autoStartAtRuntime    = autoStartAtRuntime;
                m_manager.m_displayDebug          = showDebug;
                m_manager.m_alwaysShowGizmos      = alwaysShowGizmos;
                m_manager.m_collisionHeightOffset = collisionHeightOffset;
                m_manager.m_showAdvanced          = showAdvanced;
                m_manager.m_poiGizmoSize          = poiSize;

                if (m_manager.m_flythroughType != flythroughType)
                {
                    m_manager.m_flythroughType = flythroughType;
                    m_manager.InitialiseFlythrough();
                }
                m_manager.m_nextPegasus = nextPegasus;

                if (m_manager.m_heightCheckType != heightCheckType)
                {
                    m_manager.m_heightCheckType = heightCheckType;
                    m_manager.InitialiseFlythrough();
                }
                m_manager.m_flythroughEndAction = flythroughEndAction;
                m_manager.m_target = poiTarget;

                if (m_manager.m_targetFramerateType != targetFrameRateType)
                {
                    m_manager.ChangeFramerate(targetFrameRateType);
                }
                if (!PegasusPoi.ApproximatelyEqual(scrubber, m_manager.m_totalDistanceTravelledPct))
                {
                    m_manager.MoveTargetTo(scrubber);
                }
                if (!PegasusPoi.ApproximatelyEqual(minHeightAboveTerrain, m_manager.m_minHeightAboveTerrain))
                {
                    m_manager.m_minHeightAboveTerrain = minHeightAboveTerrain;
                    m_manager.InitialiseFlythrough();
                }
                m_manager.m_rotationDamping = rotationDamping;
                m_manager.m_positionDamping = positionDamping;

                EditorUtility.SetDirty(m_manager);
            }
        }
Пример #16
0
        /// <summary>
        /// Called when the trigger starts
        /// </summary>
        /// <param name="poi"></param>
        public override void OnStart(PegasusPoi poi)
        {
            if (poi == null)
            {
                Debug.LogWarning(string.Format("Poi was not supplied on {0} - exiting", name));
                return;
            }

            if (m_pegasus == null)
            {
                Debug.LogWarning(string.Format("Pegasus was not supplied on {0} - exiting", name));
                return;
            }

            if (m_disabled)
            {
                return;
            }

            if (m_triggerAtStart)
            {
                switch (m_actionOnStart)
                {
                case PegasusConstants.PoiPegasusTriggerAction.PlayPegasus:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Started flythrough on {0} from {1}", poi.m_manager.name, poi.name));
                    }

                    //Stop playback of the calling pegasus if the new one has the same target
                    if (poi.m_manager.m_target != null && m_pegasus.m_target != null)
                    {
                        if (poi.m_manager.m_target.GetInstanceID() == m_pegasus.m_target.GetInstanceID())
                        {
                            poi.m_manager.StopFlythrough();
                        }
                    }
                    //And start the new one
                    if (m_pegasus.m_currentState == PegasusConstants.FlythroughState.Paused)
                    {
                        m_pegasus.ResumeFlythrough();
                    }
                    else
                    {
                        m_pegasus.StartFlythrough();
                    }
                    if (m_disableAfterActioned)
                    {
                        m_disabled = true;
                    }
                    break;

                case PegasusConstants.PoiPegasusTriggerAction.PausePegasus:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Pausing flythrough on {0} from {1}", poi.m_manager.name, poi.name));
                    }
                    m_pegasus.PauseFlythrough();
                    if (m_disableAfterActioned)
                    {
                        m_disabled = true;
                    }
                    break;

                case PegasusConstants.PoiPegasusTriggerAction.ResumePegasus:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Resuming flythrough on {0} from {1}", poi.m_manager.name, poi.name));
                    }
                    m_pegasus.ResumeFlythrough();
                    if (m_disableAfterActioned)
                    {
                        m_disabled = true;
                    }
                    break;

                case PegasusConstants.PoiPegasusTriggerAction.StopPegasus:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Stopping flythrough on {0} from {1}", poi.m_manager.name, poi.name));
                    }
                    m_pegasus.StopFlythrough();
                    if (m_disableAfterActioned)
                    {
                        m_disabled = true;
                    }
                    break;

                case PegasusConstants.PoiPegasusTriggerAction.DoNothing:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Doing nothing on {0} from {1}", poi.m_manager.name, poi.name));
                    }
                    break;
                }
            }
        }
Пример #17
0
        /// <summary>
        /// Called when the trigger ends
        /// </summary>
        /// <param name="poi"></param>
        public override void OnEnd(PegasusPoi poi)
        {
            if (poi == null)
            {
                Debug.LogWarning(string.Format("Poi was not supplied on {0} - exiting", name));
                return;
            }

            if (m_pegasus == null)
            {
                Debug.LogWarning(string.Format("Pegasus was not supplied on {0} - exiting", name));
                return;
            }

            if (m_disabled)
            {
                return;
            }

            if (m_triggerAtEnd)
            {
                switch (m_actionOnEnd)
                {
                case PegasusConstants.PoiPegasusTriggerAction.PlayPegasus:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Started flythrough on {0} from {1}", poi.m_manager.name, poi.name));
                    }
                    //Stop current pegasus (hack)
                    poi.m_manager.StopFlythrough();

                    if (m_pegasus.m_currentState == PegasusConstants.FlythroughState.Paused)
                    {
                        m_pegasus.ResumeFlythrough();
                    }
                    else
                    {
                        m_pegasus.StartFlythrough();
                    }
                    if (m_disableAfterActioned)
                    {
                        m_disabled = true;
                    }
                    break;

                case PegasusConstants.PoiPegasusTriggerAction.PausePegasus:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Pausing flythrough on {0} from {1}", poi.m_manager.name, poi.name));
                    }
                    m_pegasus.PauseFlythrough();
                    if (m_disableAfterActioned)
                    {
                        m_disabled = true;
                    }
                    break;

                case PegasusConstants.PoiPegasusTriggerAction.ResumePegasus:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Resuming flythrough on {0} from {1}", poi.m_manager.name, poi.name));
                    }
                    m_pegasus.ResumeFlythrough();
                    if (m_disableAfterActioned)
                    {
                        m_disabled = true;
                    }
                    break;

                case PegasusConstants.PoiPegasusTriggerAction.StopPegasus:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Stopping flythrough on {0} from {1}", poi.m_manager.name, poi.name));
                    }
                    m_pegasus.StopFlythrough();
                    if (m_disableAfterActioned)
                    {
                        m_disabled = true;
                    }
                    break;

                case PegasusConstants.PoiPegasusTriggerAction.DoNothing:
                    if (poi.m_manager.m_displayDebug == true)
                    {
                        Debug.Log(string.Format("Doing nothing on {0} from {1}", poi.m_manager.name, poi.name));
                    }
                    break;
                }
            }
        }