rabidus-test/Assets/SCSM/SciFiShipController/Scripts/Misc/ShipDisplayModule.cs

using scsmmedia;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

// Sci-Fi Ship Controller. Copyright (c) 2018-2023 SCSM Pty Ltd. All rights reserved.
namespace SciFiShipController
{
    /// <summary>
    /// Heads Up Display - typically used from an in-cockpit player view or setup.
    /// The general approach here is to use RectTransforms that are NOT stretched
    /// and are anchored at the centre.
    /// Setup Notes:
    /// HUDPanel should be anchored at four corners of screen (stretched)
    /// Display Reticle panel should be anchored at the centre of HUD
    /// Altitude Panel should be anchored to centre
    /// Altitude Text pivot point should be 0,0 (left bottom corner of textbox)
    /// </summary>
    [AddComponentMenu("Sci-Fi Ship Controller/Misc/Ship Display Module")]
    [HelpURL("http://scsmmedia.com/ssc-documentation")]
    public class ShipDisplayModule : MonoBehaviour
    {
        #region Enumerations

        #endregion

        #region Public Static Variables
        public readonly static string hudPanelName = "HUDPanel";
        public readonly static string targetsPanelName = "TargetsPanel";
        public readonly static string gaugesPanelName = "GaugesPanel";
        public readonly static string attitudePanelName = "AttitudePanel";
        public readonly static string headingPanelName = "HeadingPanel";
        public readonly static string overlayPanelName = "OverlayPanel";
        public readonly static string attitudeScrollName = "AttitudeScroll";
        public readonly static string headingScrollName = "HeadingScroll";
        public readonly static string headingIndicatorName = "HeadingIndicator";

        [System.NonSerialized] public static readonly AnimationCurve easeInOutCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);

        #endregion

        #region Public Variables and Properties - General

        /// <summary>
        /// If enabled, the Initialise() will be called as soon as Start() runs. This should be disabled if you are
        /// instantiating the HUD through code.
        /// </summary>
        public bool initialiseOnStart = false;

        /// <summary>
        /// Show or Hide the HUD when it is first Initialised
        /// </summary>
        public bool isShowOnInitialise = true;

        /// <summary>
        /// Show overlay image on HUD. At runtime call ShowOverlay() or HideOverlay()
        /// </summary>
        public bool showOverlay = true;

        /// <summary>
        /// The head-up display's normalised width of the screen. 1.0 is full width, 0.5 is half width.
        /// At runtime call shipDisplayModule.SetHUDSize(..)
        /// </summary>
        [Range(0.1f, 1f)] public float displayWidth = 0.5f;

        /// <summary>
        /// The head-up display's normalised height of the screen. 1.0 is full height, 0.5 is half height.
        /// At runtime call shipDisplayModule.SetHUDSize(..)
        /// </summary>
        [Range(0.1f, 1f)] public float displayHeight = 0.75f;

        /// <summary>
        /// The head-up display's normalised offset between the left (-1) and the right (1) from the centre (0) of the screen.
        /// At runtime call shipDisplayModule.SetHUDOffset(..)
        /// </summary>
        [Range(-1f, 1f)] public float displayOffsetX = 0f;

        /// <summary>
        /// The head-up display's normalised offset between the bottom (-1) and the top (1) from the centre (0) of the screen.
        /// At runtime call shipDisplayModule.SetHUDOffset(..)
        /// </summary>
        [Range(-1f, 1f)] public float displayOffsetY = 0f;

        /// <summary>
        /// Primary colour of the heads-up display.
        /// At runtime call shipDisplayModule.SetPrimaryColour(..)
        /// </summary>
        public Color32 primaryColour = Color.grey;

        /// <summary>
        /// Automatically hide the screen cursor or mouse pointer after it has been stationary
        /// for a fixed period of time. Automatically show the cursor if the mouse if moved
        /// provided that the Display Reticle is on shown.
        /// </summary>
        public bool autoHideCursor = true;

        /// <summary>
        /// The number of seconds to wait until after the cursor has not moved before hiding it
        /// </summary>
        public float hideCursorTime = 3f;

        /// <summary>
        /// Is the ship display module initialised? Gets set at runtime when Initialise() is called.
        /// </summary>
        public bool IsInitialised { get; private set; }

        /// <summary>
        /// Is the heads-up display shown? To set use ShowHUD() or HideHUD().
        /// IsHUDShown should never be true at runtime if IsInitialised is false
        /// </summary>
        public bool IsHUDShown { get; private set; }

        /// <summary>
        /// Get a reference to the HUD canvas
        /// </summary>
        public Canvas GetCanvas { get { return IsInitialised ? canvas : GetComponent<Canvas>(); } }

        /// <summary>
        /// The overall brightness of the HUD. At runtime use
        /// SetBrightness(value)
        /// </summary>
        [Range(0f, 1f)] public float brightness = 1f;

        /// <summary>
        /// The sort order of the canvas in the scene. Higher numbers are on top.
        /// At runtime call shipDisplayModule.SetCanvasSortOrder(..)
        /// </summary>
        public int canvasSortOrder = 2;

        /// <summary>
        /// The default size the HUD was designed with. This should always
        /// return 1920x1080
        /// </summary>
        public Vector2 ReferenceResolution { get { return refResolution; } }

        /// <summary>
        /// The current scaled resolution of the HUD canvas
        /// </summary>
        public Vector2 CanvasResolution { get { return cvsResolutionFull; } }

        /// <summary>
        /// The current scale factor of the HUD canvas
        /// </summary>
        public Vector3 CanvasScaleFactor { get { return cvsScaleFactor; } }

        /// <summary>
        /// The current actual screen resolution. This may be different from
        /// what the 
        /// </summary>
        public Vector2 ScreenResolution { get { return screenResolution; } }

        #endregion

        #region Public Variables and Properties - Flicker

        /// <summary>
        /// Whenever the HUD is shown, should it flicker on?
        /// </summary>
        public bool isShowHUDWithFlicker = false;

        /// <summary>
        /// Whenever the HUD is hidden, should it flicker off?
        /// </summary>
        public bool isHideHUDWithFlicker = false;

        /// <summary>
        /// The time, in seconds, the effect takes to reach a steady state
        /// </summary>
        [Range(0.01f, 5f)] public float flickerDefaultDuration = 1f;

        /// <summary>
        /// The minimum time, in seconds, that the effect is inactive or off
        /// </summary>
        [Range(0f, 2f)] public float flickerMinInactiveTime = 0.1f;

        /// <summary>
        /// The maximum time, in seconds, that the effect is inactive or off
        /// </summary>
        [Range(0f, 2f)] public float flickerMaxInactiveTime = 0.2f;

        /// <summary>
        /// The minimum time, in seconds, that the effect is active or on
        /// </summary>
        [Range(0f, 2f)] public float flickerMinActiveTime = 0.1f;

        /// <summary>
        /// The maximum time, in seconds, that the effect is active or on
        /// </summary>
        [Range(0f, 2f)] public float flickerMaxActiveTime = 0.2f;

        /// <summary>
        /// Smooth the flickering effect. Higher values give a smoother effect
        /// </summary>
        [Range(0, 5)] public float flickerSmoothing = 3f;

        /// <summary>
        /// The intensity of the effect will randomly change
        /// </summary>
        public bool flickerVariableIntensity = false;

        /// <summary>
        /// The maximum intensity of the effect used during the on cycle when
        /// flickerVariableIntensity is enabled.
        /// This is a multiplier of the starting intensity of the effect.
        /// Value must be between 0.01 and 1.0.
        /// </summary>
        [Range(0.01f, 1f)] public float flickerMaxIntensity = 1f;

        #endregion

        #region Public Variables and Properties - Reticles

        /// <summary>
        /// The guidHash of the currently selected / displayed reticle
        /// </summary>
        public int guidHashActiveDisplayReticle = 0;

        /// <summary>
        /// The list of display reticles that can be used with
        /// this Ship Display. Call ReinitialiseVariables() if
        /// you modify the list at runtime.
        /// </summary>
        public List<DisplayReticle> displayReticleList;

        /// <summary>
        /// Get the current number of display reticles
        /// </summary>
        public int GetNumberDisplayReticles { get { return IsInitialised ? numDisplayReticles : displayReticleList == null ? 0 : displayReticleList.Count; } }

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// </summary>
        public bool isDisplayReticleListExpanded = true;

        /// <summary>
        /// For consistency, is the display reticle currently shown when the
        /// module has already been initialised?
        /// </summary>
        public bool IsDisplayReticleShown { get { return showActiveDisplayReticle; } }

        /// <summary>
        /// Get the Display Reticle position on the screen in Viewport coordinates. x = 0.0-1.0, y = 0.0-1.0. 0,0 is bottom left corner.
        /// </summary>
        public Vector2 DisplayReticleViewportPoint { get { return new Vector2((displayReticleOffsetX + 1f) * 0.5f, (displayReticleOffsetY + 1f) * 0.5f); } }

        /// <summary>
        /// Show the current (active) Display Reticle
        /// on the HUD. At runtime use ShowDisplayReticle()
        /// or HideDisplayReticle().
        /// </summary>
        public bool showActiveDisplayReticle = false;

        /// <summary>
        /// The Display Reticle's normalised offset between the left (-1) and the right (1) from the centre (0) of the screen.
        /// At runtime call shipDisplayModule.SetDisplayReticleOffset(..)
        /// </summary>
        [Range(-1f, 1f)] public float displayReticleOffsetX = 0f;

        /// <summary>
        /// The Display Reticle's normalised offset between the bottom (-1) and the top (1) from the centre (0) of the screen.
        /// At runtime call shipDisplayModule.SetDisplayReticleOffset(..)
        /// </summary>
        [Range(-1f, 1f)] public float displayReticleOffsetY = 0f;

        /// <summary>
        /// Should the Display Reticle follow the cursor or mouse screen position?
        /// </summary>
        public bool lockDisplayReticleToCursor = false;

        /// <summary>
        /// Colour of the active Display Reticle.
        /// At runtime call shipDisplayModule.SetDisplayReticleColour(..)
        /// </summary>
        public Color32 activeDisplayReticleColour = Color.white;

        /// <summary>
        /// This is the main camera that HUD will reference. If left empty, this will
        /// be auto-populated with your first Camera with a tag of MainCamera.
        /// Can be changed at runtime with shipDisplayModule.SetCamera(..).
        /// </summary>
        public Camera mainCamera = null;

        #endregion

        #region Public Variables and Properties - Altitude and Speed

        /// <summary>
        /// The ship in the scene that will supply the data for this HUD
        /// </summary>
        public ShipControlModule sourceShip = null;

        /// <summary>
        /// Show the Altitude indicator on the HUD. At runtime use ShowAltitude() or HideAltitude().
        /// Typically only used when near the surface of a planet. See also groundPlaneHeight.
        /// </summary>
        public bool showAltitude = false;

        /// <summary>
        /// Used to determine altitude when near a planet's surface. On Earth this would typically
        /// be sea-level but it can be used to set an artificial zero-height which may be useful
        /// when flying over the surface of a planet.
        /// </summary>
        public float groundPlaneHeight = 0f;

        /// <summary>
        /// The colour of the Altitude text (number).
        /// At runtime call shipDisplayModule.SetAltitudeTextColour(..)
        /// </summary>
        public Color32 altitudeTextColour = Color.grey;

        /// <summary>
        /// Show the air speed indicator on the HUD. At runtime use ShowAirSpeed() or HideAirSpeed().
        /// </summary>
        public bool showAirspeed = false;

        /// <summary>
        /// The colour of the Air Speed text (number).
        /// At runtime call shipDisplayModule.SetAirSpeedTextColour(..)
        /// </summary>
        public Color32 airspeedTextColour = Color.grey;

        #endregion

        #region Public Variables and Properties - Attitude

        /// <summary>
        /// Show or hide the Attitude.
        /// At runtime use ShowAttitude() or HideAttitude()
        /// </summary>
        public bool showAttitude = false;

        /// <summary>
        /// Primary colour of the scrollable heading
        /// At runtime call shipDisplayModule.SetDisplayAttitudePrimaryColour(..)
        /// </summary>
        public Color attitudePrimaryColour = Color.white;

        #endregion

        #region Public Variables and Properties - Heading

        /// <summary>
        /// Show or hide the Heading or direction as a scrollable ribbon in the UI.
        /// At runtime use ShowHeading() or HideHeading()
        /// </summary>
        public bool showHeading = false;

        /// <summary>
        /// Show or hide the small heading indicator
        /// At runtime use ShowHeadingIndictor() or HideHeadingIndicator()
        /// </summary>
        public bool showHeadingIndicator = true;

        /// <summary>
        /// Primary colour of the scrollable heading
        /// At runtime call shipDisplayModule.SetDisplayHeadingPrimaryColour(..)
        /// </summary>
        public Color headingPrimaryColour = Color.white;

        /// <summary>
        /// The small indicator colour of the scrollable heading
        /// At runtime call shipDisplayModule.SetDisplayHeadingIndicatorColour(..)
        /// </summary>
        public Color headingIndicatorColour = Color.green;

        #endregion

        #region Public Variables and Properties - Gauges

        /// <summary>
        /// The list of display gauges that can be used with
        /// this Ship Display. Call ReinitialiseVariables() if
        /// you modify this list at runtime. Where possible use the API
        /// methods to Add, Delete, or set gauge attributes.
        /// </summary>
        public List<DisplayGauge> displayGaugeList;

        /// <summary>
        /// Get the current number of display gauge
        /// </summary>
        public int GetNumberDisplayGauges { get { return IsInitialised ? numDisplayGauges : displayGaugeList == null ? 0 : displayGaugeList.Count; } }

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// </summary>
        public bool isDisplayGaugeListExpanded = true;

        #endregion

        #region Public Variables and Properties - Messages

        /// <summary>
        /// The list of display messages that can be used with
        /// this Ship Display. Call ReinitialiseVariables() if
        /// you modify this list at runtime. Where possible use the API
        /// methods to Add, Delete, or set messages attributes.
        /// </summary>
        public List<DisplayMessage> displayMessageList;

        /// <summary>
        /// Get the current number of display messages
        /// </summary>
        public int GetNumberDisplayMessages { get { return IsInitialised ? numDisplayMessages : displayMessageList == null ? 0 : displayMessageList.Count; } }

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// </summary>
        public bool isDisplayMessageListExpanded = true;

        #endregion

        #region Public Variables and Properties - Targets

        /// <summary>
        /// The list of display targets that can be used with
        /// this Ship Display. Call ReinitialiseVariables() if
        /// you modify this list at runtime. Where possible use the API
        /// methods to Add, Delete, or set target attributes.
        /// </summary>
        public List<DisplayTarget> displayTargetList;

        /// <summary>
        /// Get the current number of Display Targets.
        /// </summary>
        public int GetNumberDisplayTargets { get { return IsInitialised ? numDisplayTargets : displayTargetList == null ? 0 : displayTargetList.Count; } }

        /// <summary>
        /// Get the size of the Targets viewport as a normalised (0.0-1.0) value of the current screensize
        /// </summary>
        public Vector2 GetTargetsViewportSize { get { return new Vector2(targetsViewWidth, targetsViewHeight); } }

        /// <summary>
        /// Get the offset from the screen centre of the Targets viewport. Values are -1.0 to 1.0
        /// </summary>
        public Vector2 GetTargetsViewportOffset { get { return new Vector2(targetsViewOffsetX, targetsViewOffsetY); } }

        /// <summary>
        /// When DisplayTarget slots have an active RadarItem assigned to them, should the reticles be automatically
        /// moved on the HUD?
        /// </summary>
        public bool autoUpdateTargetPositions = true;

        /// <summary>
        /// The Targets normalised viewable width of the screen.
        /// 1.0 is full width, 0.5 is half width.
        /// At runtime call shipDisplayModule.SetTargetsViewportSize(..)
        /// </summary>
        [Range(0.1f, 1f)] public float targetsViewWidth = 1.0f;

        /// <summary>
        /// The Targets normalised viewable height of the screen.
        /// 1.0 is full height, 0.5 is half height.
        /// At runtime call shipDisplayModule.SetTargetsViewportSize(..)
        /// </summary>
        [Range(0.1f, 1f)] public float targetsViewHeight = 0.5f;

        /// <summary>
        /// The X offset from centre of the screen for the Targets viewport
        /// At runtime call shipDisplayModule.SetTargetsViewportOffset(..)
        /// </summary>
        [Range(-1f, 1f)] public float targetsViewOffsetX = 0f;

        /// <summary>
        /// The Y offset from centre of the screen for the Targets viewport
        /// At runtime call shipDisplayModule.SetTargetsViewportOffset(..)
        /// </summary>
        [Range(-1f, 1f)] public float targetsViewOffsetY = 0.5f;

        /// <summary>
        /// The maximum distance, in metres, that targets can be away from the ship
        /// </summary>
        public float targetingRange = 5000f;

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// </summary>
        public bool isDisplayTargetListExpanded = true;

        #endregion

        #region Public Variables and Properties - FUTURE FEATURES

        /// <summary>
        /// FUTURE
        /// </summary>
        //public bool showArtificialHorizon = false;

        // FUTURE - FPV indicator
        //public bool showFlightPathVector = false;

        // FUTURE - wing's angle relative to airflow
        //public bool showAngleOfAttack = false;

        // FUTURE - target designation indicator
        //public bool showTargetDesignator = false;

        // Other options could be closing (target) velocity, range (to target), selected weapons, amno available etc.

        #endregion

        #region Public Variables and Properties - INTERNAL ONLY

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        [HideInInspector] public bool allowRepaint = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool showGeneralSettingsInEditor = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool showReticleSettingsInEditor = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool showAltSpeedSettingsInEditor = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool showAttitudeSettingsInEditor = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool showFlickerSettingsInEditor = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool showHeadingSettingsInEditor = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool showGaugeSettingsInEditor = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool showMessageSettingsInEditor = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool showTargetSettingsInEditor = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// Outside play mode, show a bounding box for where the HUD will be placed
        /// </summary>
        public bool showHUDOutlineInScene = true;

        /// <summary>
        /// [INTERNAL ONLY]
        /// Outside play mode, show a bounding box for where Targets can be displayed
        /// </summary>
        public bool showTargetsOutlineInScene = false;
        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool IsEditorMode { get { return editorMode; } }

        #endregion

        #region Public Delegates

        public delegate void CallbackOnBrightnessChange(float newBrightness);
        public delegate void CallbackOnSizeChange(float newWidth, float newHeight);

        /// <summary>
        /// The name of the custom method that is called immediately
        /// after brightness has changed. Your method must take 1 float
        /// parameter. This should be a lightweight method to avoid
        /// performance issues. It could be used to update your custom
        /// HUD elements.
        /// </summary>
        public CallbackOnBrightnessChange callbackOnBrightnessChange = null;

        /// <summary>
        /// The name of the custom method that is called immediately after the
        /// HUD size has changed. This method must take 2 float parameters. It
        /// should be a lightweight method to avoid performance issues. It could
        /// be used to update your custom HUD elements.
        /// </summary>
        public CallbackOnSizeChange callbackOnSizeChange = null;

        #endregion

        #region Private Variables - General
        private Canvas canvas = null;
        private CanvasScaler canvasScaler = null;

        // Scaled canvas resolution. See CheckHUDResize()
        private Vector2 cvsResolutionFull = Vector2.one;
        private Vector2 cvsResolutionHalf = Vector2.one;
        private Vector2 prevResolutionFull = Vector2.one;
        // Default reference resolution e.g. 1920x1080
        private Vector2 refResolution = Vector2.one;
        private Vector3 cvsScaleFactor = Vector3.one;
        private Vector2 screenResolution = Vector2.one;

        private Transform hudPanel = null;
        private bool isMainCameraAssigned = false;
        private Color tempColour = Color.clear;

        // Used to update HUD from the editor when not in play mode
        private bool editorMode = false;

        private List<Text> tempTextList = null;
        private List<UnityEngine.UI.Image> tempImgList = null;

        #endregion

        #region Private Variables - Attitude
        private RectTransform attitudeRectTfrm = null;
        private RectTransform attitudeScrollPanel = null;
        private UnityEngine.UI.Image attitudeScrollImg = null;
        private UnityEngine.UI.Image attitudeMaskImg = null;
        private bool isAttitudeScrolling = false;
        private Vector3 tempAttitudeOffset = Vector3.zero;
        private Vector3 attitudeInitPosition = Vector3.zero;

        /// <summary>
        /// This gets calculated in InitialiseAttitude(..) at runtime.
        /// </summary>
        private float attitudePixelsPerDegree = 1080f / 180f;

        /// <summary>
        /// The attitude normalised offset between the left (-1) and the right (1) from the centre (0) of the screen.
        /// At runtime call shipDisplayModule.SetAttitudeOffset(..)
        /// </summary>
        [SerializeField, Range(-1f, 1f)] private float attitudeOffsetX = 0f;

        /// <summary>
        /// The attitude normalised offset between the bottom (-1) and the top (1) from the centre (0) of the screen.
        /// At runtime call shipDisplayModule.SetAttitudeOffset(..)
        /// </summary>
        [SerializeField, Range(-1f, 1f)] private float attitudeOffsetY = 0f;

        /// <summary>
        /// The normalised masked width of the scrollable attitude. 1.0 is full width of the screen, 0.5 is half width. 
        /// </summary>
        [SerializeField, Range(0.1f, 1f)] private float attitudeWidth = 0.75f;

        /// <summary>
        /// The normalised masked height of the scrollable attitude. 1.0 is full height of the screen, 0.5 is half height.
        /// </summary>
        [SerializeField, Range(0.1f, 1f)] private float attitudeHeight = 1f;

        /// <summary>
        /// The sprite (texture) that will scroll up/down
        /// </summary>
        [SerializeField] private Sprite attitudeScrollSprite = null;

        /// <summary>
        /// The sprite (texture) that will mask the scrollable attitude sprite
        /// </summary>
        [SerializeField] private Sprite attitudeMaskSprite = null;

        /// <summary>
        /// The number of pixels between the top of the scroll sprite and the first (90) pitch line.
        /// It is assumed that this is the same for between the bottom and the -90 pitch line.
        /// </summary>
        [SerializeField, Range(0f, 1000f)] private float attitudeScrollSpriteBorderWidth = 250f;

        #endregion

        #region Private Variables - Flickering
        /// <summary>
        /// Is the HUD currently flickering and will it end in the Shown state?
        /// This tracks if flickering is currently happening.
        /// </summary>
        private bool isFlickeringEndStateOn = false;
        /// <summary>
        /// Is the HUD currently flickering and will it end in the Hidden state?
        /// This tracks if flickering is currently happening.
        /// </summary>
        private bool isFlickeringEndStateOff = false;

        private float flickerDurationTimer = 0f;
        private float flickerInactiveTimer = 0f;
        private float flickerActiveTimer = 0f;
        private float flickerDuration = 0f;
        private float flickerActiveTime = 0f;
        private float flickerInactiveTime = 0f;
        private bool isFlickerWaiting = false;
        private SSCRandom hudRandom = null;
        private float flickerIntensity = 0f;
        private float flickerStartIntensity = 0f;
        private Queue<float> flickerHistory = null;
        private float flickerHistoryTotal = 0f;

        #endregion

        #region Private Variables - Brightness
        private SSCColour baseReticleColour;
        private SSCColour baseOverlayColour;
        private SSCColour baseAltitudeTextColour;
        private SSCColour baseAirspeedTextColour;
        private SSCColour baseAttitudePrimaryColour;
        private SSCColour baseHeadingPrimaryColour;
        private SSCColour baseHeadingIndicatorColour;
        #endregion

        #region Private Variables - Heading
        private RectTransform headingRectTfrm = null;
        private RectTransform headingScrollPanel = null;
        private RectTransform headingIndicatorPanel = null;
        private UnityEngine.UI.Image headingScrollImg = null;
        private UnityEngine.UI.Image headingMaskImg = null;
        private UnityEngine.UI.Image headingIndicatorImg = null;

        private bool isHeadingScrolling = false;
        private Vector3 headingInitPosition = Vector3.zero;
        private Vector3 tempHeadingOffset = Vector3.zero;

        /// <summary>
        /// This gets calculated in InitialiseHeading(..) at runtime.
        /// </summary>
        private float headingPixelsPerDegree = 1920f / 360f;

        /// <summary>
        /// The heading normalised offset between the left (-1) and the right (1) from the centre (0) of the screen.
        /// At runtime call shipDisplayModule.SetHeadingOffset(..)
        /// </summary>
        [SerializeField, Range(-1f, 1f)] private float headingOffsetX = 0f;

        /// <summary>
        /// The heading normalised offset between the bottom (-1) and the top (1) from the centre (0) of the screen.
        /// At runtime call shipDisplayModule.SetHeadingOffset(..)
        /// </summary>
        [SerializeField, Range(-1f, 1f)] private float headingOffsetY = 0f;

        /// <summary>
        /// The normalised masked width of the scrollable heading. 1.0 is full width of the screen, 0.5 is half width. 
        /// </summary>
        [SerializeField, Range(0.1f, 1f)] private float headingWidth = 0.75f;

        /// <summary>
        /// The normalised masked height of the scrollable heading. 1.0 is full height of the screen, 0.5 is half height.
        /// </summary>
        [SerializeField, Range(0.1f, 1f)] private float headingHeight = 1f;

        /// <summary>
        /// The sprite (texture) that will scroll left/right
        /// </summary>
        [SerializeField] private Sprite headingScrollSprite = null;

        /// <summary>
        /// The sprite (texture) that will mask the scrollable heading sprite
        /// </summary>
        [SerializeField] private Sprite headingMaskSprite = null;

        /// <summary>
        /// The small sprite (texture) that will indicate or point to the heading on the HUD
        /// </summary>
        [SerializeField] private Sprite headingIndicatorSprite = null;

        #endregion

        #region Private Variables - Reticle
        private RectTransform hudRectTfrm = null;
        private Transform reticlePanel = null;
        private float reticleWidth = 1f;
        private float reticleHeight = 1f;
        private DisplayReticle currentDisplayReticle = null;
        private UnityEngine.UI.Image displayReticleImg = null;
        private int numDisplayReticles = 0;
        #endregion

        #region Private Variables - Gauges
        private int numDisplayGauges = 0;
        private RectTransform gaugesRectTfrm = null;
        private Vector3 tempGaugeOffset = Vector3.zero;
        #endregion

        #region Private Variables - Message
        private int numDisplayMessages = 0;       
        private Vector3 tempMessageOffset;
        #endregion

        #region Private Variables - Cursor
        private bool isCursorVisible = true;
        private float cursorTimer = 0f;

        // Switch to using the New Input System if it is available
#if SSC_UIS
        private Vector2 currentMousePosition = Vector2.zero;
        private Vector2 lastMousePosition = Vector2.zero;
#else
        private Vector3 currentMousePosition = Vector3.zero;
        private Vector3 lastMousePosition = Vector3.zero;
#endif
        #endregion

        #region Private Variables - Altitude and Speed
        private UnityEngine.UI.Image primaryOverlayImg = null;
        private RectTransform overlayPanel = null;
        private RectTransform altitudeTextRectTfrm = null;
        private Text altitudeText = null;
        private Vector3 altitudeInitPosition;
        private Vector3 altitudeCurrentPosition;
        private SCSMString altitudeString = null;
        private RectTransform airspeedTextRectTfrm = null;
        private Text airspeedText = null;
        private Vector3 airspeedInitPosition;
        private Vector3 airspeedCurrentPosition;
        private SCSMString airspeedString = null;
        #endregion

        #region Private Variables - Targets
        private int numDisplayTargets = 0;
        private RectTransform targetsRectTfrm = null;
        private Vector3 tempTargetOffset;
        private List<int> tempIncludeFactionList = null;
        private List<int> tempIncludeSquadronList = null;
        private SSCRadar sscRadar = null;
        #endregion

        #region Private Initialisation Methods

        // Start is called before the first frame update
        void Start()
        {
            if (initialiseOnStart) { Initialise(); }
        }

        #endregion

        #region Update Methods

        // Update is called once per frame
        void Update()
        {
            float dTime = Time.deltaTime;

            #region Flickering
            if (isFlickeringEndStateOn || isFlickeringEndStateOff)
            {
                flickerDurationTimer += dTime;
                // Disable flickering
                if (flickerDurationTimer > flickerDuration)
                {
                    flickerHistory.Clear();
                    if (isFlickeringEndStateOn)
                    {
                        isFlickeringEndStateOn = false;
                        // Restore the original brightness
                        SetBrightness(flickerStartIntensity);
                        ShowOrHideHUD(true);
                    }
                    // FlickeringOff
                    else
                    {
                        isFlickeringEndStateOff = false;
                        // Restore the original brightness
                        brightness = flickerStartIntensity;
                        ShowOrHideHUD(false);
                    }                    
                }
                else if (isFlickerWaiting)
                {
                    flickerInactiveTimer += dTime;
                    if (flickerInactiveTimer > flickerInactiveTime)
                    {
                        isFlickerWaiting = false;
                        flickerActiveTimer = 0f;
                        flickerActiveTime = hudRandom != null ? hudRandom.Range(flickerMinActiveTime, flickerMaxActiveTime + 0.001f): 1f;
                        ShowOrHideHUD(true);                       
                    }
                }
                else
                {
                    flickerActiveTimer += dTime;
                    if (flickerActiveTimer > flickerActiveTime)
                    {
                        flickerHistory.Clear();
                        flickerHistory.Enqueue(0f);
                        flickerInactiveTimer = 0f;
                        flickerInactiveTime = hudRandom != null ? hudRandom.Range(flickerMinInactiveTime, flickerMaxInactiveTime + 0.001f) : 1f;
                        isFlickerWaiting = true;
                        ShowOrHideHUD(false);
                    }
                    else if (flickerVariableIntensity)
                    {
                        if (flickerSmoothing > 0)
                        {
                            // Remove the first value from the queue
                            if (flickerHistory.Count > 0 && flickerHistory.Count > flickerSmoothing + 1) { flickerHistoryTotal -= flickerHistory.Dequeue(); }

                            flickerIntensity = hudRandom.Range(0f, flickerStartIntensity * flickerMaxIntensity);
                            flickerHistoryTotal += flickerIntensity;

                            // Add the new value to the end of the queue
                            flickerHistory.Enqueue(flickerIntensity);

                            SetBrightness(flickerHistoryTotal / (float)flickerHistory.Count);
                        }
                        else
                        {
                            // No smoothing
                            flickerIntensity = hudRandom.Range(0f, flickerStartIntensity * flickerMaxIntensity);
                            SetBrightness(flickerIntensity);
                        }
                    }
                }
            }
            #endregion

            #region Check Window Resize
            if (IsHUDShown)
            {
                // Would be nice to not call this so often
                CheckHUDResize(true);
            }
            #endregion

            #region AutoHideCursor and Reticle cursor control
            if (autoHideCursor || (lockDisplayReticleToCursor && showActiveDisplayReticle))
            {
                #if SSC_UIS
                currentMousePosition = UnityEngine.InputSystem.Mouse.current.position.ReadValue();
                #else
                currentMousePosition = Input.mousePosition;
                #endif

                #region Auto-hide Cursor
                if (autoHideCursor)
                {
                    if (isCursorVisible)
                    {
                        cursorTimer += dTime;
                        // If use has move the mouse, reset the timer
                        if (lastMousePosition != currentMousePosition) { lastMousePosition = currentMousePosition; cursorTimer = 0f; }
                        // After hideCursorTime secs, hide it
                        else if (cursorTimer > hideCursorTime) { ShowOrHideCursor(false); }
                    }
                    // Check if mouse has moved (does user wish to click on something?)
                    else if (lastMousePosition != currentMousePosition)
                    {
                        lastMousePosition = currentMousePosition;
                        ShowOrHideCursor(true);
                    }
                }

                #endregion

                #region Local Display Reticle to Cursor
                if (IsInitialised && isMainCameraAssigned && lockDisplayReticleToCursor && showActiveDisplayReticle)
                {
                    // It is safe to switch between Vector3 and Vector2 as each has an expicit
                    // operator which either adds z = 0 or drops the z component.
                    Vector2 viewPoint = mainCamera.ScreenToViewportPoint(currentMousePosition);

                    // Convert 0.0 to 1.0 into -1.0 to 1.0.
                    SetDisplayReticleOffset(viewPoint.x * 2f - 1f, viewPoint.y * 2f - 1f);

                    // v1.2.8+ cursor should be hidden when reticle is following the cursor.
                    if (isCursorVisible && !autoHideCursor && IsHUDShown) { ShowOrHideCursor(false); }
                }
                #endregion
            }
            #endregion

            #region Update Altitude, Speed, Heading

            if ((showAltitude || showAirspeed || isHeadingScrolling || isAttitudeScrolling) && IsHUDShown && sourceShip != null && sourceShip.ShipIsEnabled() && sourceShip.IsInitialised)
            {
                if (showAltitude)
                {
                    /// TODO - round altitude to 100s
                    altitudeString.Set((int)(sourceShip.shipInstance.TransformPosition.y - groundPlaneHeight));
                    if (altitudeText != null) { altitudeText.text = altitudeString.ToString(); }
                }
                if (showAirspeed)
                {
                    // Show in km/h
                    airspeedString.Set((int)(sourceShip.shipInstance.LocalVelocity.z*3.6f));
                    if (airspeedText != null) { airspeedText.text = airspeedString.ToString(); }
                }

                if (isHeadingScrolling)
                {
                    Vector3 _shipFwd = sourceShip.shipInstance.TransformForward;
                    Vector3 _headingPerpendicular = Vector3.Cross(Vector3.forward, _shipFwd);
                    float _headingDir = -Vector3.Dot(_headingPerpendicular, Vector3.up);
                    // Get the forward angle of the ship in WS (ignoring the Up axis)
                    headingScrollImg.transform.position = headingInitPosition + new Vector3(Vector3.Angle(new Vector3(_shipFwd.x, 0f, _shipFwd.z), Vector3.forward) * Mathf.Sign(_headingDir) * headingPixelsPerDegree, 0f, 0f);
                }

                if (isAttitudeScrolling)
                {
                    float _rollAngle = sourceShip.shipInstance.RollAngle;
                    float _rollAngleRAD = -_rollAngle * Mathf.Deg2Rad;
                    float _scrollDistance = -sourceShip.shipInstance.PitchAngle * attitudePixelsPerDegree;
                    float _scrollRadius = _scrollDistance * Mathf.Sqrt(2 * (1 - Mathf.Cos(_rollAngleRAD)));
                    float _scrollX = _scrollRadius * Mathf.Cos(_rollAngleRAD/2f);
                    float _scrollY = _scrollRadius * Mathf.Sin(_rollAngleRAD/2f);

                    if (_rollAngle > 0f)
                    {
                        // Flip values when rolling to the right
                        _scrollX = -_scrollX;
                        _scrollY = -_scrollY;
                    }

                    Vector3 attitudeScrollOffset = new Vector3(_scrollX, _scrollDistance - _scrollY, 0f);

                    // Adjust the position and rotation
                    attitudeScrollImg.transform.position = attitudeInitPosition + attitudeScrollOffset;
                    // Rotate the panel so that the mask rotates at the same time.
                    attitudeRectTfrm.localRotation = Quaternion.Euler(0f, 0f, _rollAngle);

                    // Seems like we can adjust the image WS rotation at the same time, rather than having to do attitudeRectTfrm.localRotation.
                    //attitudeScrollImg.transform.SetPositionAndRotation(attitudeInitPosition + attitudeScrollOffset, Quaternion.Euler(0f, 0f, _rollAngle));

                    //Debug.Log("[DEBUG]  _rollAngle: " + _rollAngle.ToString("0.00") + " _rollAngleRAD: " + _rollAngleRAD.ToString("0.00") +
                    //         " _scrollDistance: " + _scrollDistance.ToString("0.00") + " _scrollRadius: " + _scrollRadius.ToString("0.00") +
                    //         " scrollX: " + _scrollX.ToString("0.00") + " scrollY: " + _scrollY.ToString("0.00"));
                }
            }

            #endregion

            #region Message updates
            if (IsHUDShown)
            {
                // NOTE: It might be cheaper to maintain an int[] of scrollable messages
                for (int dmIdx = 0; dmIdx < numDisplayMessages; dmIdx++)
                {
                    DisplayMessage displayMsg = displayMessageList[dmIdx];

                    #region Fade-in Message
                    if (displayMsg.fadeinTimer > 0f && displayMsg.fadeinDuration > 0f)
                    {
                        displayMsg.fadeinTimer -= dTime;

                        if (displayMsg.fadeinTimer <= 0f)
                        {
                            displayMsg.fadeinTimer = 0f;
                        }

                        SetDisplayMessageTextFade(displayMsg, false);
                        if (displayMsg.showBackground)
                        {
                            SetDisplayMessageBackgroundFade(displayMsg, false);
                        }
                    }
                    #endregion

                    #region Fade-out Message
                    else if (displayMsg.fadeoutTimer > 0f && displayMsg.fadeoutDuration > 0f)
                    {
                        displayMsg.fadeoutTimer -= dTime;

                        if (displayMsg.fadeoutTimer <= 0f)
                        {
                            displayMsg.fadeoutTimer = 0f;
                            displayMsg.showMessage = false;
                        }

                        SetDisplayMessageTextFade(displayMsg, true);
                        if (displayMsg.showBackground)
                        {
                            SetDisplayMessageBackgroundFade(displayMsg, true);
                        }
                    }

                    #endregion

                    if (displayMsg.scrollDirectionInt != DisplayMessage.ScrollDirectionNone)
                    {                     
                        ScrollMessage(displayMessageList[dmIdx]);
                    }
                }
            }

            #endregion

            #region Target Position Updates
            if (autoUpdateTargetPositions && IsHUDShown) { UpdateTargetPositions(); }
            #endregion
        }

        #endregion

        #region Private and Internal Methods - General

        /// <summary>
        /// Show or hide the hardware (mouse) cursor in the game view
        /// NOTE: This will sometimes fail to turn off the cursor in the editor
        /// Game View when it doesn't have focus, but will work fine in a build.
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideCursor(bool isShown)
        {
            Cursor.visible = isShown;
            isCursorVisible = isShown;
            if (isShown) { cursorTimer = 0f; }
        }

        /// <summary>
        /// Show or Hide the HUD.
        /// IsHUDShown should never be true at runtime if IsInitialised is false
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideHUD(bool isShown)
        {
            if (IsInitialised)
            {
                IsHUDShown = isShown;
                hudPanel.gameObject.SetActive(isShown);
            }
            // HUD should never be shown at runtime if IsInitialised is false
            else { IsHUDShown = false; }
        }

        private IEnumerator UnlockCursor()
        {
            yield return new WaitForEndOfFrame();
            Cursor.lockState = CursorLockMode.None;
        }

        /// <summary>
        /// Check to see if the window has been resized. Ideally should be
        /// called a max once per frame (less often would be nice).
        /// TODO - trigger a HUD refresh if changed.
        /// </summary>
        private void CheckHUDResize(bool isRefreshIfChanged)
        {
            cvsResolutionFull = GetHUDFullSize(true);
            cvsResolutionHalf.x = cvsResolutionFull.x * 0.5f;
            cvsResolutionHalf.y = cvsResolutionFull.y * 0.5f;

            if (cvsResolutionFull.x != prevResolutionFull.x || cvsResolutionFull.y != prevResolutionFull.y)
            {
                refResolution = GetHUDFullSize(false);

                cvsScaleFactor = canvas == null ? Vector3.one : canvas.transform.localScale;
                screenResolution = new Vector2(Screen.width, Screen.height);

                if (isRefreshIfChanged) { RefreshHUD(); }
                prevResolutionFull.x = cvsResolutionFull.x;
                prevResolutionFull.y = cvsResolutionFull.y;
            }
        }

        /// <summary>
        /// Return full the width and height of the HUD Panel.
        /// If the module hasn't been initialised it will return 1920x1080.
        /// Assume the dev hasn't changed the CanvasScaler reference resolution settings.
        /// When using the HUD canvas current dimensions, always set isScaled = true.
        /// Returns x,y values in pixels.
        /// </summary>
        /// <param name="isScaled"></param>
        /// <returns></returns>
        private Vector2 GetHUDFullSize(bool isScaled)
        {
            // Default SSC scaler resolution is 1920x1080
            if (isScaled)
            {
                if (IsInitialised || canvas != null)
                {
                    // The default [width, height] * inversed scaled [width, height]
                    //return new Vector2(canvas.pixelRect.width / canvas.scaleFactor, canvas.pixelRect.height / canvas.scaleFactor);
                    return ((RectTransform)canvas.transform).sizeDelta;
                }
                // We don't know, so just return the original size...
                else { return new Vector2(1920f, 1080f); }
            }
            else
            {
                if (IsInitialised || canvasScaler != null)
                {
                    return canvasScaler.referenceResolution;
                }
                else { return new Vector2(1920f, 1080f); }
            }
        }

        /// <summary>
        /// Return half the width and height of the HUD Panel.
        /// If the module hasn't been initialised it will return half 1920x1080.
        /// Assuming the dev hasn't changed it, it should always return the same
        /// when initialised.
        /// When using the HUD canvas current dimensions, always set isScaled = true.
        /// Returns x,y values in pixels.
        /// </summary>
        /// <param name="isScaled"></param>
        /// <returns></returns>
        private Vector2 GetHUDHalfSize(bool isScaled)
        {
            // Default scaler resolution is 1920x1080
            if (isScaled)
            {
                if (IsInitialised || canvas != null)
                {
                    // The default [width, height] * inversed scaled [width, height]
                    //return new Vector2(canvas.pixelRect.width / canvas.scaleFactor * 0.5f, canvas.pixelRect.height / canvas.scaleFactor * 0.5f);
                    return ((RectTransform)canvas.transform).sizeDelta * 0.5f;
                }
                // We don't know, so just return the original half size...
                else { return new Vector2(960f, 540f); }
            }
            else
            {
                if (IsInitialised || canvasScaler != null)
                {
                    return new Vector2(canvasScaler.referenceResolution.x * 0.5f, canvasScaler.referenceResolution.y * 0.5f);
                }
                else { return new Vector2(960f, 540f); }
            }
        }

        /// <summary>
        /// [INTERNAL ONLY]
        /// Call CheckHUDResize(false) before calling this method
        /// </summary>
        private void GetHUDPanels()
        {
            if (hudRectTfrm != null)
            {
                hudPanel = hudRectTfrm.transform;
                reticlePanel = SSCUtils.GetChildTransform(hudPanel, "DisplayReticlePanel", this.name);
                overlayPanel = SSCUtils.GetChildRectTransform(hudPanel, overlayPanelName, this.name);

                // For backward compatibility with earlier versions of the HUD1 prefab
                if (overlayPanel == null)
                {
                    overlayPanel = SSCUtils.GetChildRectTransform(hudPanel, "AltitudePanel", this.name);
                    if (overlayPanel != null) { overlayPanel.name = overlayPanelName; }
                }

                altitudeTextRectTfrm = SSCUtils.GetChildRectTransform(overlayPanel, "AltitudeText", this.name);
                airspeedTextRectTfrm = SSCUtils.GetChildRectTransform(overlayPanel, "AirSpeedText", this.name);

                targetsRectTfrm = GetTargetsPanel();
                gaugesRectTfrm = GetGaugesPanel();
                headingRectTfrm = GetHeadingPanel();
            }
        }

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        private void GetImgComponents()
        {
            if (reticlePanel != null) { displayReticleImg = reticlePanel.GetComponent<Image>(); }
            if (overlayPanel != null) { primaryOverlayImg = overlayPanel.GetComponent<Image>(); }
        }

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        private void GetTextComponents()
        {
            if (altitudeTextRectTfrm != null) { altitudeText = altitudeTextRectTfrm.GetComponent<Text>(); }
            if (airspeedTextRectTfrm != null) { airspeedText = airspeedTextRectTfrm.GetComponent<Text>(); }
        }

        /// <summary>
        /// [INTERNAL ONLY]
        /// Used to change HUD outside play mode
        /// </summary>
        public void InitialiseEditorEssentials()
        {
            if (canvas == null) { canvas = GetCanvas; }

            hudRectTfrm = SSCUtils.GetChildRectTransform(transform, hudPanelName, this.name);

            if (hudRectTfrm != null)
            {
                // Call before GetHUDPanels()
                CheckHUDResize(false);

                GetHUDPanels();
                GetImgComponents();
                GetTextComponents();

                InitialiseAttitude(true);
                InitialiseHeading(true);
                InitialiseMessages();
                InitialiseTargets();
                editorMode = true;

                ShowOrHideAttitude(showAttitude);
                ShowOrHideHeading(showHeading);
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: ShipDisplayModule.InitialiseEditorEssentials() could not find canvas HUDPanel. Did you start with the sample HUD prefab from Prefabs/Visuals folder?"); }
            #endif
        }

        /// <summary>
        /// The Overlay Panel contains the Overlay image and child objects
        /// Altitude Text and Airspeed Text.
        /// </summary>
        private void ShowOrHideOverlayPanel()
        {
            // Should the Overlay panel be enabled?
            if ((showAltitude || showAirspeed || showOverlay) && !overlayPanel.gameObject.activeSelf)
            {
                overlayPanel.gameObject.SetActive(true);
            }
            else if (!showAltitude && !showAirspeed && !showOverlay && overlayPanel.gameObject.activeSelf)
            {
                overlayPanel.gameObject.SetActive(false);
            }
        }

        /// <summary>
        /// Show or Hide the Overlay image on the HUD. Turn on HUD if required
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideOverlay(bool isShown)
        {
            if (IsInitialised)
            {
                showOverlay = isShown;

                ShowOrHideOverlayPanel();

                if (primaryOverlayImg != null) { primaryOverlayImg.enabled = isShown; }

                if (showOverlay && !IsHUDShown) { ShowOrHideHUD(true); }
            }
        }

        #endregion

        #region Private and Internal Methods - Brightness

        /// <summary>
        /// Remembers the starting colours of various elements so that they can be
        /// used to apply brightness to those elements at runtime.
        /// Sets the initial brightness.
        /// NOTE: Brightness doesn't work so well if colour has low alpha to begin with.
        /// </summary>
        private void InitialiseBrightness()
        {
            if (displayReticleImg != null) { baseReticleColour = displayReticleImg.color; }
            if (primaryOverlayImg != null) { baseOverlayColour = primaryOverlayImg.color; }
            if (altitudeText != null) { baseAltitudeTextColour = altitudeText.color; }
            if (airspeedText != null) { baseAirspeedTextColour = airspeedText.color; }
            if (attitudeScrollImg != null) { baseAttitudePrimaryColour = attitudeScrollImg.color; }
            if (headingScrollImg != null) { baseHeadingPrimaryColour = headingScrollImg.color; }
            if (headingIndicatorImg != null) { baseHeadingIndicatorColour = headingIndicatorImg.color; }

            SetBrightness(brightness);
        }

        private void SetOverlayBrightness()
        {
            if (primaryOverlayImg != null)
            {
                // Skip more expensive HSV->RGBA and new Color op if possible
                if (brightness == 1f)
                {
                    SSCUtils.Color32toColorNoAlloc(ref primaryColour, ref tempColour);
                    primaryOverlayImg.color = tempColour;
                }
                else
                {
                    primaryOverlayImg.color = baseOverlayColour.GetColorWithBrightness(brightness);
                }
            }
        }

        private void SetReticleBrightness()
        {
            if (displayReticleImg != null)
            {
                // Skip more expensive HSV->RGBA and new Color op if possible
                if (brightness == 1f)
                {
                    SSCUtils.Color32toColorNoAlloc(ref activeDisplayReticleColour, ref tempColour);
                    displayReticleImg.color = tempColour;
                }
                else
                {
                    displayReticleImg.color = baseReticleColour.GetColorWithBrightness(brightness);
                }
            }
        }

        private void SetAltitudeTextBrightness()
        {
            if (altitudeText != null)
            {
                // Skip more expensive HSV->RGBA and new Color op if possible
                if (brightness == 1f)
                {
                    SSCUtils.Color32toColorNoAlloc(ref altitudeTextColour, ref tempColour);
                    altitudeText.color = tempColour;
                }
                else
                {
                    altitudeText.color = baseAltitudeTextColour.GetColorWithBrightness(brightness);
                }
            }
        }

        private void SetAirSpeedTextBrightness()
        {
            if (airspeedText != null)
            {
                // Skip more expensive HSV->RGBA and new Color op if possible
                if (brightness == 1f)
                {
                    SSCUtils.Color32toColorNoAlloc(ref airspeedTextColour, ref tempColour);
                    airspeedText.color = tempColour;
                }
                else
                {
                    airspeedText.color = baseAirspeedTextColour.GetColorWithBrightness(brightness);
                }
            }
        }

        private void SetAttitudeBrightness()
        {
            if (attitudeScrollImg != null)
            {
                // Skip more expensive HSV->RGBA and new Color op if possible
                if (brightness == 1f)
                {
                    attitudeScrollImg.color = attitudePrimaryColour;
                }
                else
                {
                    attitudeScrollImg.color = baseAttitudePrimaryColour.GetColorWithBrightness(brightness);
                }
            }
        }

        private void SetHeadingBrightness()
        {
            if (headingScrollImg != null)
            {
                // Skip more expensive HSV->RGBA and new Color op if possible
                if (brightness == 1f)
                {
                    headingScrollImg.color = headingPrimaryColour;
                    headingIndicatorImg.color = headingIndicatorColour;
                }
                else
                {
                    headingScrollImg.color = baseHeadingPrimaryColour.GetColorWithBrightness(brightness);
                    headingIndicatorImg.color = baseHeadingIndicatorColour.GetColorWithBrightness(brightness);
                }
            }
        }

        private void SetDisplayGaugeForegroundBrightness(DisplayGauge displayGauge)
        {
            if (displayGauge != null)
            {
                if (IsInitialised || editorMode)
                {
                    if (displayGauge.CachedFgImgComponent != null)
                    {
                        if (brightness == 1f) { displayGauge.CachedFgImgComponent.color = displayGauge.foregroundColour; }
                        else { displayGauge.CachedFgImgComponent.color = displayGauge.baseForegroundColour.GetColorWithBrightness(brightness); }
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeForegroundBrightness - displayGauge.CachedFgImgComponent is null"); }
                    #endif
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeForegroundBrightness - displayGauge is null"); }
            #endif
        }

        private void SetDisplayGaugeBackgroundBrightness(DisplayGauge displayGauge)
        {
            if (displayGauge != null)
            {
                if (IsInitialised || editorMode)
                {
                    if (displayGauge.CachedBgImgComponent != null)
                    {
                        if (brightness == 1f) { displayGauge.CachedBgImgComponent.color = displayGauge.backgroundColour; }
                        else { displayGauge.CachedBgImgComponent.color = displayGauge.baseBackgroundColour.GetColorWithBrightness(brightness); }
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeBackgroundBrightness - displayGauge.CachedBgImgComponent is null"); }
                    #endif
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeBackgroundBrightness - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Adjust the brightness of the gauge text. If it is a numeric gauge with a label,
        /// also adjust the brightness of the label.
        /// </summary>
        /// <param name="displayGauge"></param>
        private void SetDisplayGaugeTextBrightness(DisplayGauge displayGauge)
        {
            if (displayGauge != null)
            {
                if (IsInitialised || editorMode)
                {
                    if (displayGauge.CachedTextComponent != null)
                    {
                        if (brightness == 1f) { displayGauge.CachedTextComponent.color = displayGauge.textColour; }
                        else { displayGauge.CachedTextComponent.color = displayGauge.baseTextColour.GetColorWithBrightness(brightness); }
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeTextBrightness - displayGauge.CachedTextComponent is null"); }
                    #endif

                    if (displayGauge.CachedLabelTextComponent != null)
                    {
                        if (brightness == 1f) { displayGauge.CachedLabelTextComponent.color = displayGauge.textColour; }
                        else { displayGauge.CachedLabelTextComponent.color = displayGauge.baseTextColour.GetColorWithBrightness(brightness); }
                    }
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeTextBrightness - displayGauge is null"); }
            #endif
        }

        private void SetDisplayMessageBackgroundBrightness(DisplayMessage displayMessage)
        {
            if (displayMessage != null)
            {
                if (IsInitialised || editorMode)
                {
                    if (displayMessage.CachedBgImgComponent != null)
                    {
                        if (brightness == 1f) { displayMessage.CachedBgImgComponent.color = displayMessage.backgroundColour; }
                        else { displayMessage.CachedBgImgComponent.color = displayMessage.baseBackgroundColour.GetColorWithBrightness(brightness); }
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageBackgroundBrightness - displayMessage.CachedBgImgComponent is null"); }
                    #endif
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageBackgroundBrightness - displayMessage is null"); }
            #endif
        }

        private void SetDisplayMessageBackgroundFade (DisplayMessage displayMessage, bool isFadeOut)
        {
            if (displayMessage != null)
            {
                if (IsInitialised || editorMode)
                {
                    if (displayMessage.CachedBgImgComponent != null)
                    {
                        float fadeValue = easeInOutCurve.Evaluate(isFadeOut ? displayMessage.GetFadeOutValue() : displayMessage.GetFadeInValue());

                        displayMessage.CachedBgImgComponent.color = displayMessage.baseBackgroundColour.GetColorWithFadedBrightness(brightness, fadeValue);
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageBackgroundFade - displayMessage.CachedBgImgComponent is null"); }
                    #endif
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageBackgroundFade - displayMessage is null"); }
            #endif
        }

        private void SetDisplayMessageTextBrightness(DisplayMessage displayMessage)
        {
            if (displayMessage != null)
            {
                if (IsInitialised || editorMode)
                {
                    if (displayMessage.CachedTextComponent != null)
                    {
                        if (brightness == 1f) { displayMessage.CachedTextComponent.color = displayMessage.textColour; }
                        else { displayMessage.CachedTextComponent.color = displayMessage.baseTextColour.GetColorWithBrightness(brightness); }
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageTextBrightness - displayMessage.CachedTextComponent is null"); }
                    #endif
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageTextBrightness - displayMessage is null"); }
            #endif
        }

        private void SetDisplayMessageTextFade (DisplayMessage displayMessage, bool isFadeOut)
        {
            if (displayMessage != null)
            {
                if (IsInitialised || editorMode)
                {
                    if (displayMessage.CachedTextComponent != null)
                    {
                        float fadeValue = easeInOutCurve.Evaluate(isFadeOut ? displayMessage.GetFadeOutValue() : displayMessage.GetFadeInValue());

                        //Debug.Log("[DEBUG] msg fadeinTimer: " + displayMessage.fadeinTimer + " fadeValue: " + fadeValue);

                        displayMessage.CachedTextComponent.color = displayMessage.baseTextColour.GetColorWithFadedBrightness(brightness, fadeValue);
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageTextFade - displayMessage.CachedTextComponent is null"); }
                    #endif
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageTextFade - displayMessage is null"); }
            #endif
        }

        /// <summary>
        /// Set the brightness of all slots (copies) of a DisplayTarget
        /// </summary>
        /// <param name="displayTarget"></param>
        private void SetDisplayTargetBrightness(DisplayTarget displayTarget)
        {
            if (displayTarget != null)
            {
                if (IsInitialised || editorMode)
                {
                    for (int sIdx = 0; sIdx < displayTarget.maxNumberOfTargets; sIdx++)
                    {
                        if (displayTarget.displayTargetSlotList[sIdx].CachedImgComponent != null)
                        {
                            if (brightness == 1f) { displayTarget.displayTargetSlotList[sIdx].CachedImgComponent.color = displayTarget.reticleColour; }
                            else { displayTarget.displayTargetSlotList[sIdx].CachedImgComponent.color = displayTarget.baseReticleColour.GetColorWithBrightness(brightness); }
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayTargetBrightness - displayTarget slot " + sIdx + " CachedImgComponent is null"); }
                        #endif
                    }
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayTargetBrightness - displayTarget is null"); }
            #endif
        }

        #endregion

        #region Private or Internal Methods - Reticle

        /// <summary>
        /// Show or Hide the reticle. Turn on the HUD if required.
        /// Always hide the cursor (hardware pointer) when the reticle is shown.
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideReticle(bool isShown)
        {
            if (IsInitialised)
            {
                showActiveDisplayReticle = isShown;

                if (isShown)
                {
                    // Check the active display reticle
                    if (guidHashActiveDisplayReticle == 0)
                    {
                        showActiveDisplayReticle = false;
                        currentDisplayReticle = null;
                        LoadDisplayReticleSprite(currentDisplayReticle);

                        #if UNITY_EDITOR
                        Debug.LogWarning("ShipDisplayModule - could not show the Display Rectile because there was no active rectile");
                        #endif
                    }
                    // If there is no current reticle, or if we need to change the reticle,
                    // look up the hash value and load the sprite (if there is a match)
                    else if (currentDisplayReticle == null || (currentDisplayReticle.guidHash != guidHashActiveDisplayReticle))
                    {
                        currentDisplayReticle = displayReticleList.Find(dr => dr.guidHash == guidHashActiveDisplayReticle);
                        LoadDisplayReticleSprite(currentDisplayReticle);
                    }
                }

                if (showActiveDisplayReticle && lockDisplayReticleToCursor) { Cursor.visible = false; }

                reticlePanel.gameObject.SetActive(showActiveDisplayReticle);

                if (showActiveDisplayReticle && !IsHUDShown) { ShowOrHideHUD(true); }
            }
        }

        /// <summary>
        /// Load the reticle sprite into the UI image on the panel
        /// </summary>
        /// <param name="displayReticle"></param>
        private void LoadDisplayReticleSprite(DisplayReticle displayReticle)
        {
            if (displayReticle != null)
            {
                displayReticleImg.sprite = displayReticle.primarySprite;
            }
            else
            {
                displayReticleImg.sprite = null;
            }
        }

        #endregion

        #region Private or Internal Methods - Overlay, Altitude and Speed

        /// <summary>
        /// Show or Hide the Altitude indicator on the HUD. Turn on HUD if required.
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideAltitude(bool isShown)
        {
            if (IsInitialised)
            {
                showAltitude = isShown;

                ShowOrHideOverlayPanel();

                if (altitudeText != null) { altitudeText.gameObject.SetActive(showAltitude); }

                if (showAltitude && !IsHUDShown) { ShowOrHideHUD(true); }
            }
        }

        /// <summary>
        /// Show or Hide the Air Speed indicator on the HUD. Turn on HUD if required
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideAirSpeed(bool isShown)
        {
            if (IsInitialised)
            {
                showAirspeed = isShown;

                ShowOrHideOverlayPanel();

                if (airspeedText != null) { airspeedText.gameObject.SetActive(showAirspeed); }

                if (showAirspeed && !IsHUDShown) { ShowOrHideHUD(true); }
            }
        }

        #endregion

        #region Private or Internal Methods - Attitude

        /// <summary>
        /// Get or Create the scrollable attitude.
        /// The attitude image is masked by the parent mask image.
        /// </summary>
        private void GetOrCreateAttitude()
        {
            if (attitudeRectTfrm == null) { attitudeRectTfrm = GetAttitudePanel(); }

            if (attitudeRectTfrm != null)
            {
                // Find or create the Mask for the scrollable attitude
                if (attitudeMaskImg == null)
                {
                    attitudeMaskImg = attitudeRectTfrm.GetComponent<UnityEngine.UI.Image>();

                    if (attitudeMaskImg == null)
                    {
                        attitudeMaskImg = attitudeRectTfrm.gameObject.AddComponent<UnityEngine.UI.Image>();
                        UnityEngine.UI.Mask attitudeMask = attitudeRectTfrm.gameObject.AddComponent<UnityEngine.UI.Mask>();

                        if (attitudeMaskImg != null)
                        {
                            attitudeMaskImg.raycastTarget = false;
                            attitudeMaskImg.preserveAspect = false;
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.GetOrCreateAttitude() - could not add mask image component to Attitude panel"); }
                        #endif

                        if (attitudeMask != null)
                        {
                            attitudeMask.showMaskGraphic = false;
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.GetOrCreateAttitude() - could not add mask component to Attitude panel"); }
                        #endif
                    }
                }
            }

            // Find or create the scrollable panel and image. This is a child of the attitude panel and mask
            if (attitudeScrollImg == null)
            {
                // The panel width and height are 1.0 which is the full resolution e.g. 1920x1080
                attitudeScrollPanel = SSCUtils.GetOrCreateChildRectTransform(attitudeRectTfrm, cvsResolutionFull, attitudeScrollName,
                                                    0f, 0f, 1f, 1f, 0.5f, 0.5f, 0.5f, 0.5f);

                if (attitudeScrollPanel != null)
                {
                    attitudeScrollImg = attitudeScrollPanel.GetComponent<UnityEngine.UI.Image>();

                    if (attitudeScrollImg == null)
                    {
                        attitudeScrollImg = attitudeScrollPanel.gameObject.AddComponent<UnityEngine.UI.Image>();

                        if (attitudeScrollImg != null)
                        {
                            attitudeScrollImg.raycastTarget = false;
                            attitudeScrollImg.preserveAspect = true;
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.GetOrCreateAttitude() - could not add background to Attitude panel"); }
                        #endif
                    }
                }
            }


            // TODO - Find or create the small indicator panel and image (NOT SURE IF WE NEED THIS YET).
        }

        /// <summary>
        /// Initialise the scrollable Attitude.
        /// </summary>
        /// <param name="isInitialising"></param>
        private void InitialiseAttitude(bool isInitialising)
        {
            GetOrCreateAttitude();

            SetDisplayAttitudeScrollSprite(attitudeScrollSprite);
            SetDisplayAttitudeMaskSprite(attitudeMaskSprite);

            SetDisplayAttitudeOffset(attitudeOffsetX, attitudeOffsetY);
            SetDisplayAttitudeSize(attitudeWidth, attitudeHeight);

            if (attitudeScrollImg != null)
            {
                if (isInitialising)
                {
                    attitudeInitPosition = attitudeScrollImg.transform.position;
                }

                RefreshAttitudeAfterResize();
            }
        }

        /// <summary>
        /// Show or hide the scrollable Attitude display. Turn on HUD if required.
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideAttitude(bool isShown)
        {
            if (IsInitialised || IsEditorMode)
            {
                showAttitude = isShown;

                if (attitudeRectTfrm != null) { attitudeRectTfrm.gameObject.SetActive(showAttitude); }

                if (attitudeScrollImg != null)
                {
                    attitudeScrollImg.enabled = isShown;
                    isAttitudeScrolling = isShown;
                }
                else
                {
                    isAttitudeScrolling = false;
                }

                if (showAttitude && !IsHUDShown) { ShowOrHideHUD(true); }
            }
        }

        #endregion

        #region Private or Internal Methods - Gauges

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// Create a new Gauge RectTransform under the HUD GaugesPanel in the hierarchy
        /// Add a background Image
        /// Add a (foreground) fillable iamge
        /// Add a text panel
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <returns></returns>
        public RectTransform CreateGaugePanel(DisplayGauge displayGauge)
        {
            RectTransform gaugePanel = null;

            if (gaugesRectTfrm == null) { gaugesRectTfrm = GetGaugesPanel(); }

            if (gaugesRectTfrm != null && displayGauge != null)
            {
                float panelWidth = displayGauge.displayWidth;
                float panelHeight = displayGauge.displayHeight;

                gaugePanel = SSCUtils.GetOrCreateChildRectTransform(gaugesRectTfrm, cvsResolutionFull, "Gauge_" + displayGauge.guidHash, 0f, 0f,
                                                                        panelWidth, panelHeight, 0.5f, 0.5f, 0.5f, 0.5f);

                if (gaugePanel != null)
                {
                    Image bgimgComponent = gaugePanel.gameObject.AddComponent<Image>();
                    if (bgimgComponent != null)
                    {
                        bgimgComponent.raycastTarget = false;
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.CreateGaugePanel() - could not add background to Gauge panel"); }
                    #endif

                    RectTransform gaugeAmtPanel = SSCUtils.GetOrCreateChildRectTransform(gaugePanel, cvsResolutionFull, "GaugeAmount", 0f, 0f,
                                                                        panelWidth, panelHeight, 0.5f, 0.5f, 0.5f, 0.5f);

                    if (gaugeAmtPanel != null)
                    {
                        Image amtimgComponent = gaugeAmtPanel.gameObject.AddComponent<Image>();
                        if (amtimgComponent != null)
                        {
                            amtimgComponent.raycastTarget = false;
                            amtimgComponent.type = Image.Type.Filled;
                            amtimgComponent.fillMethod = (Image.FillMethod)displayGauge.fillMethod;
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.CreateGaugePanel() - could not add fill image to Gauge panel"); }
                        #endif
                    }

                    RectTransform gaugeTxtPanel = SSCUtils.GetOrCreateChildRectTransform(gaugePanel, cvsResolutionFull, "GaugeText", 0f, 0f,
                                                                        panelWidth, panelHeight, 0.5f, 0.5f, 0.5f, 0.5f);

                    if (gaugeTxtPanel != null)
                    {
                        UnityEngine.UI.Text textComponent = gaugeTxtPanel.gameObject.AddComponent<UnityEngine.UI.Text>();
                        if (textComponent != null)
                        {
                            textComponent.raycastTarget = false;
                            textComponent.resizeTextForBestFit = true;
                            // Text is add in InitialiseGauge().
                            textComponent.text = string.Empty;
                            if (Application.isPlaying)
                            {
                                textComponent.font = SSCUtils.GetDefaultFont();
                            }
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.CreateGaugePanel() - could not add text to Gauge panel"); }
                        #endif
                    }

                    if (IsInitialised || editorMode)
                    {
                        // Update the number of gauges. Count the list rather than assume the gauge didn't already exist.
                        numDisplayGauges = displayGaugeList == null ? 0 : displayGaugeList.Count;
                        InitialiseGauge(displayGauge);
                    }
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: ShipDisplayModule.CreateGaugePanel() - displayGauge is null or could not find or create " + gaugesPanelName); }
            #endif

            return gaugePanel;
        }

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// Find the Gauge RectTransform under the HUD in the hierarchy.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <returns></returns>
        private RectTransform GetGaugePanel(int guidHash)
        {
            if (gaugesRectTfrm == null) { gaugesRectTfrm = GetGaugesPanel(); }
            if (gaugesRectTfrm != null)
            {
                return SSCUtils.GetChildRectTransform(gaugesRectTfrm.transform, "Gauge_" + guidHash, this.name);
            }
            else { return null; }
        }

        /// <summary>
        /// Get or create a gauge label. This only applies to numeric gauges with an additional
        /// text component or label.
        /// If it is the wrong gauge type, remove any secondary label.
        /// This will set or update the displayGauge.CachedLabelTextComponent.
        /// </summary>
        /// <param name="guidHash"></param>
        private void GetOrCreateOrRemoveGaugeLabel(DisplayGauge displayGauge)
        {
            UnityEngine.UI.Text textComponent = null;

            if (displayGauge != null)
            {
                int gaugeTypeInt = (int)displayGauge.gaugeType;

                // Is the component already cached?
                if (displayGauge.CachedLabelTextComponent != null)
                {
                    // If this gauge should have a secondary label, set it to the cached component
                    if (gaugeTypeInt == DisplayGauge.DGTypeNumberWithLabel1Int)
                    {
                        textComponent = displayGauge.CachedLabelTextComponent;
                    }
                    else
                    {
                        // A secondary label (Text component) does not apply to this gauge, so remove it.
                        if (Application.isPlaying) { Destroy(displayGauge.CachedLabelTextComponent.gameObject); }
                        else
                        {
                            #if UNITY_EDITOR
                            UnityEditor.Undo.DestroyObjectImmediate(displayGauge.CachedLabelTextComponent.gameObject);
                            #else
                            DestroyImmediate(displayGauge.CachedLabelTextComponent.gameObject);
                            #endif
                        }

                        // Clear the cached component
                        displayGauge.CachedLabelTextComponent = null;
                    }                  
                }
                else if (gaugeTypeInt == DisplayGauge.DGTypeNumberWithLabel1Int)
                {
                    // Not cached, so attempt to find it
                    RectTransform gaugePanel = displayGauge.CachedGaugePanel == null ? GetGaugePanel(displayGauge.guidHash) : displayGauge.CachedGaugePanel;

                    if (gaugePanel != null)
                    {
                        float panelWidth = displayGauge.displayWidth;
                        float panelHeight = displayGauge.displayHeight / 2f;

                        RectTransform gaugeLabelPanel = SSCUtils.GetOrCreateChildRectTransform(gaugePanel, cvsResolutionFull, "GaugeLabel", 0f, 0f,
                                                        panelWidth, panelHeight, 0.5f, 0.5f, 0.5f, 0.5f);

                        if (gaugeLabelPanel != null)
                        {
                            textComponent = gaugeLabelPanel.GetComponent<UnityEngine.UI.Text>();

                            if (textComponent == null)
                            {
                                // Text component doesn't exist, so add and configure it
                                textComponent = gaugeLabelPanel.gameObject.AddComponent<UnityEngine.UI.Text>();

                                if (textComponent != null)
                                {
                                    textComponent.raycastTarget = false;
                                    textComponent.resizeTextForBestFit = true;

                                    textComponent.text = displayGauge.gaugeLabel;
                                    if (Application.isPlaying)
                                    {
                                        textComponent.font = SSCUtils.GetDefaultFont();
                                    }

                                    displayGauge.CachedLabelTextComponent = textComponent;
                                }
                                #if UNITY_EDITOR
                                else { Debug.LogWarning("ERROR: shipDisplayModule.CreateGaugePanel() - could not add text to Gauge panel"); }
                                #endif
                            }
                            else
                            {
                                displayGauge.CachedLabelTextComponent = textComponent;
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Cache the DisplayGauge RectTransform, Image and Text component.
        /// Set the Text colour.
        /// </summary>
        /// <param name="displayGauge"></param>
        private void InitialiseGauge(DisplayGauge displayGauge)
        {
            displayGauge.CachedGaugePanel = GetGaugePanel(displayGauge.guidHash);
            // Cache FillMethod is None to avoid enum lookup at runtime
            displayGauge.isFillMethodNone = displayGauge.fillMethod == DisplayGauge.DGFillMethod.None;

            if (displayGauge.CachedGaugePanel != null)
            {
                displayGauge.CachedBgImgComponent = displayGauge.CachedGaugePanel.GetComponent<Image>();

                if (displayGauge.CachedBgImgComponent != null)
                {
                    // If there is a sprite but it hasn't been loaded into the image, do it now
                    if (displayGauge.backgroundSprite != null && displayGauge.CachedBgImgComponent.sprite == null)
                    {
                        SetDisplayGaugeBackgroundSprite(displayGauge, displayGauge.backgroundSprite);
                    }

                    // Cache the gauge foreground Image component
                    if (tempImgList == null) { tempImgList = new List<Image>(1); }
                    displayGauge.CachedGaugePanel.GetComponentsInChildren(tempImgList);
                    if (tempImgList.Count > 0)
                    {
                        // GetComponentsInChildren will also return the background image which we don't want
                        tempImgList.Remove(displayGauge.CachedBgImgComponent);

                        if (tempImgList.Count > 0)
                        {
                            displayGauge.CachedFgImgComponent = tempImgList[0];

                            // If there is a sprite but it hasn't been loaded into the image, do it now
                            if (displayGauge.foregroundSprite != null && displayGauge.CachedFgImgComponent.sprite == null)
                            {
                                SetDisplayGaugeForegroundSprite(displayGauge, displayGauge.foregroundSprite);
                            }

                            SetDisplayGaugeValue(displayGauge, displayGauge.gaugeValue);
                        }
                    }
                }

                // Cache the gauge Text component
                if (tempTextList == null) { tempTextList = new List<Text>(2); }
                displayGauge.CachedGaugePanel.GetComponentsInChildren(tempTextList);
                if (tempTextList.Count > 0)
                {
                    displayGauge.CachedTextComponent = tempTextList[0];

                    // NOTE: The order may not be guaranteed here so this might or might not be an issue
                    // with numeric gauges.
                    if (tempTextList.Count > 1)
                    {
                        displayGauge.CachedLabelTextComponent = tempTextList[1];
                    }
                }

                // SetDisplayGaugeForegroundColour does not update the baseForegroundColour if the foregroundColour has not changed. So do it in here instead
                displayGauge.baseForegroundColour.Set(displayGauge.foregroundColour.r, displayGauge.foregroundColour.g, displayGauge.foregroundColour.b, displayGauge.foregroundColour.a, true);
                SetDisplayGaugeForegroundBrightness(displayGauge);

                // SetDisplayGaugeBackgroundColour does not update the baseBackgroundColour if the backgroundColour has not changed. So do it in here instead
                displayGauge.baseBackgroundColour.Set(displayGauge.backgroundColour.r, displayGauge.backgroundColour.g, displayGauge.backgroundColour.b, displayGauge.backgroundColour.a, true);
                SetDisplayGaugeBackgroundBrightness(displayGauge);

                // SetDisplayGaugeTextColour does not update the baseTextColour if the textColour has not changed. So do it in here instead
                displayGauge.baseTextColour.Set(displayGauge.textColour.r, displayGauge.textColour.g, displayGauge.textColour.b, displayGauge.textColour.a, true);
                SetDisplayGaugeTextBrightness(displayGauge);

                SetDisplayGaugeText(displayGauge, displayGauge.gaugeString);
                SetDisplayGaugeTextAlignment(displayGauge, displayGauge.textAlignment);
                SetDisplayGaugeTextFontStyle(displayGauge, (UnityEngine.FontStyle)displayGauge.fontStyle);
                SetDisplayGaugeTextFontSize(displayGauge, displayGauge.isBestFit, displayGauge.fontMinSize, displayGauge.fontMaxSize);

                if (displayGauge.CachedLabelTextComponent != null)
                {
                    SetDisplayGaugeLabel(displayGauge, displayGauge.gaugeLabel);
                    SetDisplayGaugeLabelAlignment(displayGauge, displayGauge.labelAlignment);
                }

                SetDisplayGaugeSize(displayGauge, displayGauge.displayWidth, displayGauge.displayHeight);

                SetDisplayGaugeOffset(displayGauge, displayGauge.offsetX, displayGauge.offsetY);

                // By default gauges are initialised off. This is to prevent them suddenly appearing when first created.
                if (Application.isPlaying)
                {
                    displayGauge.CachedGaugePanel.gameObject.SetActive(false);
                }
            }
        }

        /// <summary>
        /// Initialise all the DisplayGauges by caching the RectTransforms.
        /// </summary>
        private void InitialiseGauges()
        {
            int _numDisplayGauges = GetNumberDisplayGauges;
            
            if (_numDisplayGauges > 0)
            {
                RectTransform hudRectTfrm = GetHUDPanel();
                if (hudRectTfrm != null)
                {
                    CheckHUDResize(false);
                    for (int dgIdx = 0; dgIdx < _numDisplayGauges; dgIdx++)
                    {
                        InitialiseGauge(displayGaugeList[dgIdx]);
                    }

                    if (_numDisplayGauges > 0) { RefreshGaugesSortOrder(); }
                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("ShipDisplayModule.InitialiseGauges() - could not find HUD Panel"); }
                #endif
            }
        }

        /// <summary>
        /// Show or Hide the Display Gauge on the HUD. Turn on the HUD if required.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="isShown"></param>
        private void ShowOrHideGauge(DisplayGauge displayGauge, bool isShown)
        {
            if (IsInitialised)
            {
                if (displayGauge.CachedGaugePanel != null)
                {
                    displayGauge.showGauge = isShown;
                    displayGauge.CachedGaugePanel.gameObject.SetActive(isShown);
                }

                if (isShown && !IsHUDShown) { ShowOrHideHUD(true); }
            }
        }

        /// <summary>
        /// Show or hide all gauges
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideGauges(bool isShown)
        {
            if (IsInitialised)
            {
                for (int dmIdx = 0; dmIdx < numDisplayGauges; dmIdx++)
                {
                    ShowOrHideGauge(displayGaugeList[dmIdx], isShown);
                }
            }
        }

        /// <summary>
        /// Show or Hide all gauges based on their current settings
        /// </summary>
        private void ShowOrHideGauges()
        {
            if (IsInitialised)
            {
                for (int dmIdx = 0; dmIdx < numDisplayGauges; dmIdx++)
                {
                    DisplayGauge displayGauge = displayGaugeList[dmIdx];
                    ShowOrHideGauge(displayGauge, displayGauge.showGauge);
                }
            }
        }

        #endregion

        #region Private or Internal Methods - Heading

        /// <summary>
        /// Initialise the scrollable heading or compass.
        /// </summary>
        /// <param name="isInitialising"></param>
        private void InitialiseHeading(bool isInitialising)
        {
            GetOrCreateHeading();

            SetDisplayHeadingScrollSprite(headingScrollSprite);
            SetDisplayHeadingMaskSprite(headingMaskSprite);
            SetDisplayHeadingIndicatorSprite(headingIndicatorSprite);

            SetDisplayHeadingOffset(headingOffsetX, headingOffsetY);
            SetDisplayHeadingSize(headingWidth, headingHeight);

            if (isInitialising && headingScrollImg != null)
            {
                headingInitPosition = headingScrollImg.transform.position;

                // The heading img should have 2 sets of 0-360 deg to avoid scrolling partly out of view.
                // The image is autoscaled to the full width of the default HUD screen size.
                headingPixelsPerDegree = cvsResolutionFull.x / 720f;
            }
        }

        /// <summary>
        /// Get or Create the scrollable heading.
        /// The heading image is masked by the parent mask image.
        /// </summary>
        private void GetOrCreateHeading()
        {
            if (headingRectTfrm == null) { headingRectTfrm = GetHeadingPanel(); }

            if (headingRectTfrm != null)
            {
                // Find or create the Mask for the scrollable heading
                if (headingMaskImg == null)
                {
                    headingMaskImg = headingRectTfrm.GetComponent<UnityEngine.UI.Image>();

                    if (headingMaskImg == null)
                    {
                        headingMaskImg = headingRectTfrm.gameObject.AddComponent<UnityEngine.UI.Image>();
                        UnityEngine.UI.Mask headingMask = headingRectTfrm.gameObject.AddComponent<UnityEngine.UI.Mask>();

                        if (headingMaskImg != null)
                        {
                            headingMaskImg.raycastTarget = false;
                            headingMaskImg.preserveAspect = false;
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.GetOrCreateHeading() - could not add mask image component to Heading panel"); }
                        #endif

                        if (headingMask != null)
                        {
                            headingMask.showMaskGraphic = false;
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.GetOrCreateHeading() - could not add mask component to Heading panel"); }
                        #endif
                    }
                }

                // Find or create the scrollable panel and image. This is a child of the heading panel and mask
                if (headingScrollImg == null)
                {
                    // The panel width and height are 1.0 which is the full resolution e.g. 1920x1080
                    headingScrollPanel = SSCUtils.GetOrCreateChildRectTransform(headingRectTfrm, cvsResolutionFull, headingScrollName,
                                                        0f, 0f, 1f, 1f, 0.5f, 0.5f, 0.5f, 0.5f);

                    if (headingScrollPanel != null)
                    {
                        headingScrollImg = headingScrollPanel.GetComponent<UnityEngine.UI.Image>();

                        if (headingScrollImg == null)
                        {
                            headingScrollImg = headingScrollPanel.gameObject.AddComponent<UnityEngine.UI.Image>();

                            if (headingScrollImg != null)
                            {
                                headingScrollImg.raycastTarget = false;
                                headingScrollImg.preserveAspect = true;
                            }
                            #if UNITY_EDITOR
                            else { Debug.LogWarning("ERROR: shipDisplayModule.GetOrCreateHeading() - could not add background to Heading panel"); }
                            #endif
                        }
                    }
                }

                // Find or create the small indicator panel and image.
                if (headingIndicatorImg == null)
                {
                    // The panel width and height are 1.0 which is the full resolution e.g. 1920x1080
                    headingIndicatorPanel = SSCUtils.GetOrCreateChildRectTransform(headingRectTfrm, cvsResolutionFull, headingIndicatorName,
                                                        0f, 0f, 16f / cvsResolutionFull.x, 16f / cvsResolutionFull.y, 0.5f, 0.5f, 0.5f, 0.5f);

                    if (headingIndicatorPanel != null)
                    {
                        headingIndicatorImg = headingIndicatorPanel.GetComponent<UnityEngine.UI.Image>();

                        if (headingIndicatorImg == null)
                        {
                            headingIndicatorImg = headingIndicatorPanel.gameObject.AddComponent<UnityEngine.UI.Image>();

                            if (headingIndicatorImg != null)
                            {
                                headingIndicatorImg.raycastTarget = false;
                                headingIndicatorImg.preserveAspect = true;
                            }
                            #if UNITY_EDITOR
                            else { Debug.LogWarning("ERROR: shipDisplayModule.GetOrCreateHeading() - could not add indicator to Heading panel"); }
                            #endif
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Show or Hide the scrollable Heading on the HUD. Turn on HUD if required.
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideHeading(bool isShown)
        {
            if (IsInitialised || IsEditorMode)
            {
                showHeading = isShown;

                if (headingRectTfrm != null) { headingRectTfrm.gameObject.SetActive(showHeading); }

                if (headingScrollImg != null)
                {
                    headingScrollImg.enabled = isShown;
                    isHeadingScrolling = isShown;
                }
                else 
                {
                    isHeadingScrolling = false;
                }

                if (showHeading && !IsHUDShown) { ShowOrHideHUD(true); }
            }
        }

        /// <summary>
        /// Show or Hide the small Heading indicator on the HUD.
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideHeadingIndicator(bool isShown)
        {
            if (IsInitialised || IsEditorMode)
            {
                showHeadingIndicator = isShown;

                if (headingIndicatorImg != null)
                {
                    headingIndicatorImg.enabled = isShown;
                }
            }
        }

        #endregion

        #region Private or Internal Methods - Messages

        /// <summary>
        /// Cache the DisplayMessage RectTransform, Image and Text component.
        /// Set the Text colour.
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="hudRectTfrm"></param>
        private void InitialiseMessage(DisplayMessage displayMessage, RectTransform hudRectTfrm)
        {
            displayMessage.CachedMessagePanel = GetMessagePanel(displayMessage.guidHash, hudRectTfrm);

            displayMessage.scrollDirectionInt = (int)displayMessage.scrollDirection;
            displayMessage.scrollOffsetX = 0f;
            displayMessage.scrollOffsetY = 0f;

            if (displayMessage.CachedMessagePanel != null)
            {
                displayMessage.CachedBgImgComponent = displayMessage.CachedMessagePanel.GetComponent<Image>();

                if (displayMessage.CachedBgImgComponent != null)
                {
                    displayMessage.CachedBgImgComponent.enabled = displayMessage.showBackground;
                }

                // Cache the message Text component
                if (tempTextList == null) { tempTextList = new List<Text>(1); }
                displayMessage.CachedMessagePanel.GetComponentsInChildren(tempTextList);
                if (tempTextList.Count > 0)
                {
                    displayMessage.CachedTextComponent = tempTextList[0];
                }

                // SetDisplayMessageBackgroundColour does not update the baseBackgroundColour if the backgroundColour has not changed. So do it in here instead
                displayMessage.baseBackgroundColour.Set(displayMessage.backgroundColour.r, displayMessage.backgroundColour.g, displayMessage.backgroundColour.b, displayMessage.backgroundColour.a, true);
                SetDisplayMessageBackgroundBrightness(displayMessage);

                // SetDisplayMessageTextColour does not update the baseTextColour if the textColour has not changed. So do it in here instead
                displayMessage.baseTextColour.Set(displayMessage.textColour.r, displayMessage.textColour.g, displayMessage.textColour.b, displayMessage.textColour.a, true);
                SetDisplayMessageTextBrightness(displayMessage);

                SetDisplayMessageText(displayMessage, displayMessage.messageString);
                SetDisplayMessageTextAlignment(displayMessage, displayMessage.textAlignment);
                SetDisplayMessageTextFontSize(displayMessage, displayMessage.isBestFit, displayMessage.fontMinSize, displayMessage.fontMaxSize);
                SetDisplayMessageSize(displayMessage, displayMessage.displayWidth, displayMessage.displayHeight);

                if (displayMessage.scrollDirectionInt != DisplayMessage.ScrollDirectionNone)
                {
                    // scrollWidth/Height should be the same as those used in ScrollMessage(..)
                    // The left/right and top/bottom scroll limits can be ignored OR can consider the width/height of the message.
                    // Fullscreen scrolling = +/- half width of message + half the width of canvas
                    float scrollWidth = displayMessage.isScrollFullscreen ? displayMessage.displayWidth * cvsResolutionHalf.x + cvsResolutionHalf.x : displayMessage.displayWidth * cvsResolutionFull.x;

                    // Fullscreen scrolling = +/- half height of message + half the height of canvas
                    float scrollHeight = displayMessage.isScrollFullscreen ? displayMessage.displayHeight * cvsResolutionHalf.y + cvsResolutionHalf.y : displayMessage.displayHeight * cvsResolutionFull.y;

                    // Start at beginning of scrolling position (e.g. Offscreen left/right)
                    if (displayMessage.scrollDirectionInt == DisplayMessage.ScrollDirectionLR)
                    {
                        displayMessage.scrollOffsetX = -scrollWidth;
                    }
                    else if (displayMessage.scrollDirectionInt == DisplayMessage.ScrollDirectionRL)
                    {
                        displayMessage.scrollOffsetX = scrollWidth;
                    }
                    if (displayMessage.scrollDirectionInt == DisplayMessage.ScrollDirectionBT)
                    {
                        displayMessage.scrollOffsetY = -scrollHeight;
                    }
                    else if (displayMessage.scrollDirectionInt == DisplayMessage.ScrollDirectionTB)
                    {
                        displayMessage.scrollOffsetY = scrollHeight;
                    }
                }
                SetDisplayMessageOffset(displayMessage, displayMessage.offsetX, displayMessage.offsetY);
                
                // By default messages are initialised off. This is to prevent them suddenly appearing when first created.
                if (Application.isPlaying)
                {
                    displayMessage.CachedMessagePanel.gameObject.SetActive(false);
                }
            }
        }

        /// <summary>
        /// Initialise all the DisplayMessages by caching the RectTransforms.
        /// </summary>
        private void InitialiseMessages()
        {
            int _numDisplayMessages = GetNumberDisplayMessages;
            
            if (_numDisplayMessages > 0)
            {
                RectTransform hudRectTfrm = GetHUDPanel();
                if (hudRectTfrm != null)
                {
                    CheckHUDResize(false);
                    for (int dmIdx = 0; dmIdx < _numDisplayMessages; dmIdx++)
                    {
                        InitialiseMessage(displayMessageList[dmIdx], hudRectTfrm);
                    }

                    if (_numDisplayMessages > 0) { RefreshMessagesSortOrder(); }
                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("ShipDisplayModule.InitialiseMessages() - could not find HUD Panel"); }
                #endif
            }
        }

        /// <summary>
        /// Show or Hide the Display Message on the HUD. Turn on the HUD if required.
        /// When fading out a message, it isn't instantly turned off.
        /// Option to override the fade settings and instantly hide or show the message.
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="isShown"></param>
        /// <param name="isOverrideFade"></param>
        private void ShowOrHideMessage(DisplayMessage displayMessage, bool isShown, bool isOverrideFade = false)
        {
            if (IsInitialised)
            {
                if (displayMessage.CachedMessagePanel != null)
                {
                    if (isShown)
                    {
                        if (isOverrideFade)
                        {
                            displayMessage.fadeinTimer = 0f;
                        }
                        // Is a fade-out already in progress?
                        else if (displayMessage.fadeoutDuration > 0f && displayMessage.fadeoutTimer > 0f)
                        {
                            // (1 - Normalise amount faded out) * fade in duration.
                            displayMessage.fadeinTimer = (1f - (displayMessage.fadeoutTimer / displayMessage.fadeoutDuration)) * displayMessage.fadeinDuration;
                        }
                        else
                        {
                            displayMessage.fadeinTimer = displayMessage.fadeinDuration;

                            if (displayMessage.fadeinTimer > 0f)
                            {
                                // Instantly update to avoid flashing the faded in message before Update() is called.
                                SetDisplayMessageTextFade(displayMessage, false);
                                if (displayMessage.showBackground)
                                {
                                    SetDisplayMessageBackgroundFade(displayMessage, false);
                                }
                            }
                        }

                        // Should never be fading out when turning the message on
                        displayMessage.fadeoutTimer = 0f;
                    }
                    else if (isOverrideFade)
                    {
                        displayMessage.fadeoutTimer = 0f;
                    }
                    else if (displayMessage.fadeoutDuration > 0f)
                    {
                        // Is a fade-in already in progress?
                        if (displayMessage.fadeinDuration > 0f && displayMessage.fadeinTimer > 0f)
                        {
                            // (1 - Normalise amount faded in) * fade out duration.
                            displayMessage.fadeoutTimer = (1f - (displayMessage.fadeinTimer / displayMessage.fadeinDuration)) * displayMessage.fadeoutDuration;
                        }
                        else
                        {
                            displayMessage.fadeoutTimer = displayMessage.fadeoutDuration;
                        }

                        // Should never be fading in when turning the message off
                        displayMessage.fadeinTimer = 0f;

                        // Override instantly turning off the message
                        isShown = true;
                    }
                    else
                    {
                        displayMessage.showMessage = false;
                    }

                    displayMessage.showMessage = isShown;

                    displayMessage.CachedMessagePanel.gameObject.SetActive(isShown);
                }

                if (isShown && !IsHUDShown) { ShowOrHideHUD(true); }
            }
        }

        /// <summary>
        /// Show or hide all messages.
        /// Option to override fade settings and instantly show or hide.
        /// </summary>
        /// <param name="isShown"></param>
        /// <param name="isOverrideFade"></param>
        private void ShowOrHideMessages(bool isShown, bool isOverrideFade = false)
        {
            if (IsInitialised)
            {
                for (int dmIdx = 0; dmIdx < numDisplayMessages; dmIdx++)
                {
                    ShowOrHideMessage(displayMessageList[dmIdx], isShown, isOverrideFade);
                }
            }
        }

        /// <summary>
        /// Show or Hide all messages based on their current settings.
        /// This is called by 
        /// </summary>
        private void ShowOrHideMessages()
        {
            if (IsInitialised)
            {
                for (int dmIdx = 0; dmIdx < numDisplayMessages; dmIdx++)
                {
                    DisplayMessage displayMessage = displayMessageList[dmIdx];
                    // Shown messages should fade in if required.
                    // Hidden messages should be instantly hidden.
                    ShowOrHideMessage(displayMessage, displayMessage.showMessage, !displayMessage.showMessage);
                }
            }
        }

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// Find the Message RectTransform under the HUD in the hierarchy.
        /// If hudRectTrfm is null, it will attempt to find it.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <param name="hudRectTrfm"></param>
        /// <returns></returns>
        private RectTransform GetMessagePanel(int guidHash, RectTransform hudRectTrfm)
        {
            if (hudRectTfrm == null) { hudRectTfrm = GetHUDPanel(); }
            if (hudRectTfrm != null)
            {
                return SSCUtils.GetChildRectTransform(hudRectTfrm.transform, "Message_" + guidHash, this.name);
            }
            else { return null; }
        }

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// Create a new Message RectTransform under the HUD in the hierarchy
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="hudRectTfrm"></param>
        /// <returns></returns>
        public RectTransform CreateMessagePanel(DisplayMessage displayMessage, RectTransform hudRectTfrm)
        {
            RectTransform messagePanel = null;

            if (displayMessage != null)
            {
                float panelWidth = displayMessage.displayWidth;
                float panelHeight = displayMessage.displayHeight;

                //Canvas _canvas = GetCanvas;
                //Vector3 _canvasScale = _canvas == null ? Vector3.one : _canvas.transform.localScale;

                if (IsInitialised) { numDisplayMessages++; }
                messagePanel = SSCUtils.GetOrCreateChildRectTransform(hudRectTfrm, cvsResolutionFull, "Message_" + displayMessage.guidHash, 0f, 0f,
                                                                        panelWidth, panelHeight, 0.5f, 0.5f, 0.5f, 0.5f);

                if (messagePanel != null)
                {
                    Image imgComponent = messagePanel.gameObject.AddComponent<Image>();
                    if (imgComponent != null)
                    {
                        imgComponent.raycastTarget = false;
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.CreateMessagePanel() - could not add background to Message panel"); }
                    #endif

                    RectTransform messageTxtPanel = SSCUtils.GetOrCreateChildRectTransform(messagePanel, cvsResolutionFull, "MessageText", 0f, 0f,
                                                                        panelWidth, panelHeight, 0.5f, 0.5f, 0.5f, 0.5f);

                    if (messageTxtPanel != null)
                    {
                        Text textComponent = messageTxtPanel.gameObject.AddComponent<Text>();
                        if (textComponent != null)
                        {
                            textComponent.raycastTarget = false;
                            textComponent.resizeTextForBestFit = true;
                            // Text is addd in InitialiseMessage().
                            textComponent.text = string.Empty;
                            if (Application.isPlaying)
                            {
                                textComponent.font = SSCUtils.GetDefaultFont();
                            }
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.CreateMessagePanel() - could not add text to Message panel"); }
                        #endif
                    }

                    if (IsInitialised || editorMode) { InitialiseMessage(displayMessage, hudRectTfrm); }
                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("ERROR: shipDisplayModule.CreateMessagePanel() - could not create Message panel"); }
                #endif
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: ShipDisplayModule.CreateMessagePanel() - displayMessage is null"); }
            #endif

            return messagePanel;
        }

        /// <summary>
        /// Show or hide the message background by enabling or disabling the image script
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="isShown"></param>
        private void ShowOrHideDisplayMessageBackground(DisplayMessage displayMessage, bool isShown)
        {
            if (IsInitialised || editorMode)
            {
                if (!editorMode) { displayMessage.showBackground = isShown; }
                displayMessage.CachedBgImgComponent.enabled = isShown;
            }
        }

        /// <summary>
        /// Scroll message across the display. Assumes module is initialised, message is not null,
        /// and scrollDirection is not None.
        /// </summary>
        /// <param name="displayMessage"></param>
        private void ScrollMessage(DisplayMessage displayMessage)
        {
            if (displayMessage.showMessage)
            {
                // Determine the distance to scroll
                float scrollFactor = displayMessage.scrollSpeed * Time.deltaTime * canvas.scaleFactor * 0.1f;
                float deltaX = scrollFactor * cvsResolutionFull.x;
                float deltaY = scrollFactor * cvsResolutionFull.y;

                // scrollWidth/Height should be the same as starting positions set in InitialiseMessage(..)
                // The left/right and top/bottom scroll limits can be ignored OR can consider the width/height of the message.
                // Fullscreen scrolling = +/- half width of message + half the width of canvas
                float scrollWidth = displayMessage.isScrollFullscreen ? displayMessage.displayWidth * cvsResolutionHalf.x + cvsResolutionHalf.x : displayMessage.displayWidth * cvsResolutionFull.x;

                // Fullscreen scrolling = +/- half height of message + half the height of canvas
                float scrollHeight = displayMessage.isScrollFullscreen ? displayMessage.displayHeight * cvsResolutionHalf.y + cvsResolutionHalf.y : displayMessage.displayHeight * cvsResolutionFull.y;

                // Calc the localPosition of the message
                tempMessageOffset.x = displayMessage.offsetX * cvsResolutionHalf.x;
                tempMessageOffset.y = displayMessage.offsetY * cvsResolutionHalf.y;

                if (displayMessage.scrollDirectionInt == DisplayMessage.ScrollDirectionLR)
                {
                    if (displayMessage.isScrollFullscreen) { tempMessageOffset.x = 0f; }
                    displayMessage.scrollOffsetX += deltaX;
                    displayMessage.scrollOffsetY = 0f;

                    if (displayMessage.scrollOffsetX > scrollWidth) { displayMessage.scrollOffsetX = -scrollWidth; }
                }
                else if (displayMessage.scrollDirectionInt == DisplayMessage.ScrollDirectionRL)
                {
                    if (displayMessage.isScrollFullscreen) { tempMessageOffset.x = 0f; }
                    displayMessage.scrollOffsetX -= deltaX;
                    displayMessage.scrollOffsetY = 0f;

                    if (displayMessage.scrollOffsetX < -scrollWidth) { displayMessage.scrollOffsetX = scrollWidth; }
                }
                else if (displayMessage.scrollDirectionInt == DisplayMessage.ScrollDirectionBT)
                {
                    if (displayMessage.isScrollFullscreen) { tempMessageOffset.y = 0f; }
                    displayMessage.scrollOffsetX = 0f;
                    displayMessage.scrollOffsetY += deltaY;

                    if (displayMessage.scrollOffsetY > scrollHeight) { displayMessage.scrollOffsetY = -scrollHeight; }
                }
                else // Top to Bottom
                {
                    if (displayMessage.isScrollFullscreen) { tempMessageOffset.y = 0f; }
                    displayMessage.scrollOffsetX = 0f;
                    displayMessage.scrollOffsetY -= deltaY;

                    if (displayMessage.scrollOffsetY < -scrollHeight) { displayMessage.scrollOffsetY = scrollHeight; }
                }

                Transform dmTrfm = displayMessage.CachedMessagePanel.transform;

                tempMessageOffset.x += displayMessage.scrollOffsetX;
                tempMessageOffset.y += displayMessage.scrollOffsetY;
                tempMessageOffset.z = dmTrfm.localPosition.z;
                dmTrfm.localPosition = tempMessageOffset;
            }
        }

        #endregion

        #region Private or Internal Methods - Targets

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// Create a new Target RectTransform under the HUD in the hierarchy for the give slot
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <param name="slotIndex"></param>
        /// <returns></returns>
        public RectTransform CreateTargetPanel(DisplayTarget displayTarget, int slotIndex)
        {
            RectTransform targetPanel = null;

            if (targetsRectTfrm == null) { targetsRectTfrm = GetTargetsPanel(); }

            if (displayTarget != null && targetsRectTfrm != null)
            {
                if (slotIndex >= 0 && slotIndex < DisplayTarget.MAX_DISPLAYTARGET_SLOTS)
                {
                    // Convert into 0.0 to 1.0 value. The width/height values assume default 1920x1080.
                    float panelWidth = displayTarget.width / refResolution.x;
                    float panelHeight = displayTarget.height / refResolution.y;

                    //if (IsInitialised && slotIndex == 0) { numDisplayTargets++; }
                    targetPanel = SSCUtils.GetOrCreateChildRectTransform(targetsRectTfrm, cvsResolutionFull, "Target_" + displayTarget.guidHash + "_" + slotIndex.ToString(), 0f, 0f,
                                                                            panelWidth, panelHeight, 0.5f, 0.5f, 0.5f, 0.5f);

                    if (targetPanel != null)
                    {
                        Image imgComponent = targetPanel.gameObject.AddComponent<Image>();
                        if (imgComponent != null)
                        {
                            imgComponent.raycastTarget = false;
                        }
                        #if UNITY_EDITOR
                        else { Debug.LogWarning("ERROR: shipDisplayModule.CreateTargetPanel() - could not add image to Target panel"); }
                        #endif

                        if ((IsInitialised || editorMode) && !displayTarget.isInitialised) { InitialiseTarget(displayTarget); }
                    }
                    #if UNITY_EDITOR
                    else { Debug.LogWarning("ERROR: shipDisplayModule.CreateTargetPanel() - could not create Target panel"); }
                    #endif
                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("ERROR: shipDisplayModule.CreateTargetPanel() - could not create Target panel. Slot number is outside the range 0 to " + DisplayTarget.MAX_DISPLAYTARGET_SLOTS.ToString()); }
                #endif
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: ShipDisplayModule.CreateTargetPanel() - displayTarget is null or could not find or create " + targetsPanelName); }
            #endif

            return targetPanel;
        }

        /// <summary>
        /// [INTERNAL USE ONLY]
        /// Find the Target RectTransform under the HUD in the hierarchy.
        /// If the parent targetsRectTfrm is null, it will attempt to find or create it.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <param name="slotIndex"></param>
        /// <returns></returns>
        private RectTransform GetTargetPanel(int guidHash, int slotIndex)
        {
            if (targetsRectTfrm == null) { targetsRectTfrm = GetTargetsPanel(); }
            if (targetsRectTfrm != null)
            {
                return SSCUtils.GetChildRectTransform(targetsRectTfrm.transform, "Target_" + guidHash + "_" + slotIndex, this.name);
            }
            else { return null; }
        }

        /// <summary>
        /// [INTERNAL ONLY]
        /// Used by the editor when moving DisplayTargets around in the list.
        /// </summary>
        /// <param name="displayTargetIndex"></param>
        public void RefreshDisplayTargetSlots()
        {
            numDisplayTargets = displayTargetList == null ? 0 : displayTargetList.Count;

            for (int dtIdx = 0; dtIdx < numDisplayTargets; dtIdx++)
            {
                DisplayTarget displayTarget = displayTargetList[dtIdx];

                // Initialise the Display Target slots
                displayTarget.displayTargetSlotList = new List<DisplayTargetSlot>(displayTarget.maxNumberOfTargets);

                for (int slotIdx = 0; slotIdx < displayTarget.maxNumberOfTargets; slotIdx++)
                {
                    DisplayTargetSlot displayTargetSlot = InitialiseTargetSlot(displayTarget, slotIdx);

                    displayTarget.displayTargetSlotList.Add(displayTargetSlot);
                }

                // InitialiseTargetSlot will turn all the reticles off, so update the DisplayTarget property too
                displayTarget.showTarget = false;
            }
        }

        /// <summary>
        /// Initialise the display target
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <param name="hudRectTfrm"></param>
        private void InitialiseTarget(DisplayTarget displayTarget)
        {
            if (displayTarget.maxNumberOfTargets < 0) { displayTarget.maxNumberOfTargets = 1; }
            else if (displayTarget.maxNumberOfTargets > DisplayTarget.MAX_DISPLAYTARGET_SLOTS) { displayTarget.maxNumberOfTargets = DisplayTarget.MAX_DISPLAYTARGET_SLOTS; }

            // Initialise the Display Target slots
            displayTarget.displayTargetSlotList = new List<DisplayTargetSlot>(displayTarget.maxNumberOfTargets);

            for (int slotIdx = 0; slotIdx < displayTarget.maxNumberOfTargets; slotIdx++)
            {
                DisplayTargetSlot displayTargetSlot = InitialiseTargetSlot(displayTarget, slotIdx);

                displayTarget.displayTargetSlotList.Add(displayTargetSlot);
            }

            SetDisplayTargetSize(displayTarget, displayTarget.width, displayTarget.height);

            // SetDisplayTargetReticleColour does not update the baseReticleColour if the reticleColour has not changed. So do it in here instead
            displayTarget.baseReticleColour.Set(displayTarget.reticleColour.r, displayTarget.reticleColour.g, displayTarget.reticleColour.b, displayTarget.reticleColour.a, true);
            SetDisplayTargetBrightness(displayTarget);

            displayTarget.isInitialised = true;
        }

        /// <summary>
        /// Initialise a DisplayTarget Slot. This includes:
        /// 1. caching the panel and image component
        /// 2. Loading the reticle sprite
        /// 3. Setting the offset to 0,0
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <param name="slotIdx"></param>
        /// <returns></returns>
        private DisplayTargetSlot InitialiseTargetSlot(DisplayTarget displayTarget, int slotIdx)
        {
            DisplayTargetSlot displayTargetSlot = new DisplayTargetSlot();

            displayTargetSlot.CachedTargetPanel = GetTargetPanel(displayTarget.guidHash, slotIdx);

            if (displayTargetSlot.CachedTargetPanel != null)
            {
                displayTargetSlot.CachedImgComponent = displayTargetSlot.CachedTargetPanel.GetComponent<Image>();

                // Add the Reticle sprite to the image for this Display Target
                if (displayTargetSlot.CachedImgComponent != null)
                {
                    // TODO - consider getting the sprite only once per DisplayTarget
                    displayTargetSlot.CachedImgComponent.sprite = GetDisplayReticleSprite(displayTarget.guidHashDisplayReticle);
                }

                SetDisplayTargetOffset(displayTargetSlot, 0f, 0f);

                // By default targets are initialised off. This is to prevent them suddenly appearing when first created.
                if (Application.isPlaying)
                {
                    displayTargetSlot.showTargetSlot = false;
                    displayTargetSlot.CachedTargetPanel.gameObject.SetActive(false);
                }
            }

            return displayTargetSlot;
        }

        /// <summary>
        /// Initialise all the DisplayTargets by caching the RectTransforms.
        /// </summary>
        private void InitialiseTargets()
        {
            int _numDisplayTargets = GetNumberDisplayTargets;
            
            if (_numDisplayTargets > 0)
            {
                if (targetsRectTfrm == null) { targetsRectTfrm = GetTargetsPanel(); }
                if (targetsRectTfrm != null)
                {
                    CheckHUDResize(false);

                    for (int dmIdx = 0; dmIdx < _numDisplayTargets; dmIdx++)
                    {
                        InitialiseTarget(displayTargetList[dmIdx]);
                    }

                    if (_numDisplayTargets > 0) { RefreshTargetsSortOrder(); }
                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("ShipDisplayModule.InitialiseTargets() - could not find " + targetsPanelName); }
                #endif
            }
        }

        /// <summary>
        /// Show or Hide DisplayTarget slot on the HUD.
        /// By design, if the HUD is not shown, the Target slot will not be show.
        /// </summary>
        /// <param name="displayTargetSlot"></param>
        /// <param name="isShown"></param>
        private void ShowOrHideTargetSlot(DisplayTargetSlot displayTargetSlot, bool isShown)
        {
            if ((IsInitialised || editorMode) && displayTargetSlot != null && displayTargetSlot.CachedTargetPanel != null)
            {
                displayTargetSlot.showTargetSlot = isShown;
                displayTargetSlot.CachedTargetPanel.gameObject.SetActive(isShown);
            }
        }

        /// <summary>
        /// Show or Hide all slots of a Display Target on the HUD.
        /// By design, if the HUD is not shown, the Targets will not be show.
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <param name="isShown"></param>
        private void ShowOrHideTarget(DisplayTarget displayTarget, bool isShown)
        {
            if (IsInitialised || editorMode)
            {
                displayTarget.showTarget = isShown;

                for (int sIdx = 0; sIdx < displayTarget.maxNumberOfTargets; sIdx++)
                {
                    ShowOrHideTargetSlot(displayTarget.displayTargetSlotList[sIdx], isShown);
                }
            }
        }

        /// <summary>
        /// Show or hide all targets
        /// </summary>
        /// <param name="isShown"></param>
        private void ShowOrHideTargets(bool isShown)
        {
            if (IsInitialised)
            {
                for (int dmIdx = 0; dmIdx < numDisplayTargets; dmIdx++)
                {
                    ShowOrHideTarget(displayTargetList[dmIdx], isShown);
                }
            }
        }

        /// <summary>
        /// Show or Hide all targets based on their current settings
        /// </summary>
        private void ShowOrHideTargets()
        {
            if (IsInitialised)
            {
                for (int dmIdx = 0; dmIdx < numDisplayTargets; dmIdx++)
                {
                    DisplayTarget displayTarget = displayTargetList[dmIdx];
                    ShowOrHideTarget(displayTarget, displayTarget.showTarget);
                }
            }
        }

        /// <summary>
        /// Update the position on the HUD for each of the Display Target slots
        /// that are shown.
        /// </summary>
        private void UpdateTargetPositions()
        {
            if (IsInitialised)
            {
                if (sscRadar == null) { sscRadar = SSCRadar.GetOrCreateRadar(); }

                if (sscRadar != null)
                {
                    // Loop through the display targets
                    for (int dtgtIdx = 0; dtgtIdx < numDisplayTargets; dtgtIdx++)
                    {
                        DisplayTarget displayTarget = displayTargetList[dtgtIdx];

                        if (displayTarget.showTarget)
                        {
                            // Loop through the display target slots
                            for (int slotIdx = 0; slotIdx < displayTarget.maxNumberOfTargets; slotIdx++)
                            {
                                DisplayTargetSlot displayTargetSlot = displayTarget.displayTargetSlotList[slotIdx];

                                if (displayTargetSlot.radarItemKey.radarItemIndex >= 0 && displayTargetSlot.showTargetSlot)
                                {
                                    SSCRadarItem radarItem = sscRadar.GetRadarItem(displayTargetSlot.radarItemKey);

                                    if (radarItem != null)
                                    {
                                        SetDisplayTargetPosition(displayTarget, slotIdx, radarItem.position);
                                    }
                                    //#if UNITY_EDITOR
                                    //else
                                    //{
                                    //    // This could be a timing issue
                                    //    Debug.LogWarning("ShipDisplayModule.UpdateTargetPositions - could not find radar item with index " + displayTargetSlot.radarItemKey.radarItemIndex + " for DisplayTarget " + (dtgtIdx+1).ToString("000") + " slot " + slotIdx);
                                    //}
                                    //#endif
                                }
                            }
                        }
                    }
                }
            }
        }

        #endregion

        #region Public API Methods - General

        /// <summary>
        /// Initialise the ShipDisplayModule. Either set initialiseOnStart to false and call this
        /// method in your code, or set initialiseOnStart to true in the inspector and don't call
        /// this method.
        /// </summary>
        public void Initialise()
        {
            // calling this method twice may incorrectly set the positions of the Altitude and speed panels.
            if (IsInitialised) { return; }

            canvas = GetComponent<Canvas>();
            canvasScaler = GetComponent<CanvasScaler>();

            hudRectTfrm = SSCUtils.GetChildRectTransform(transform, hudPanelName, this.name);

            if (canvas != null && hudRectTfrm != null)
            {
                canvas.sortingOrder = canvasSortOrder;

                // Get the reference resolution from the canvas scaler. If it hasn't been changed this should
                // always be 1920x1080 for SSC.
                //if (canvasScaler != null) { refResolutionFull = canvasScaler.referenceResolution; }
                //else { refResolutionFull.x = 1920f; refResolutionFull.y = 1080f; }

                // use the scaled size rather than the original reference resolution size.
                CheckHUDResize(false);

                GetHUDPanels();

                if (reticlePanel != null && overlayPanel != null && altitudeTextRectTfrm != null && airspeedTextRectTfrm != null)
                {
                    GetImgComponents();
                    GetTextComponents();

                    // Store the starting position of the Altitude text
                    altitudeInitPosition = altitudeTextRectTfrm.localPosition;
                    altitudeCurrentPosition = altitudeInitPosition;   
                    // Initialise the string used to store the Altitude value and reduce GC.
                    altitudeString = new SCSMString(6);
                    altitudeString.SetMaxIntLength(6);

                    // Store the starting position of the Air speed text
                    airspeedInitPosition = airspeedTextRectTfrm.localPosition;
                    airspeedCurrentPosition = airspeedInitPosition;
                    // Initialise the string used to store the Airspeed value and reduce GC.
                    airspeedString = new SCSMString(6);
                    airspeedString.SetMaxIntLength(6);

                    // Create an empty array of integers to use when processing
                    tempIncludeFactionList = new List<int>(20);
                    tempIncludeSquadronList = new List<int>(20);

                    InitialiseAttitude(true);
                    InitialiseHeading(true);

                    ReinitialiseVariables();

                    hudRandom = new SSCRandom();
                    // Set the seed to an arbitary prime number (but it could be anything really)
                    if (hudRandom != null) { hudRandom.SetSeed(691); }
                    flickerHistory = new Queue<float>(5);

                    #if UNITY_EDITOR
                    if (!isMainCameraAssigned) { Debug.LogWarning("ShipDisplayModule could not find a camera with the MainCamera tag set"); }
                    #endif

                    IsInitialised = displayReticleImg != null && isMainCameraAssigned;

                    RefreshHUD();

                    if (isShowHUDWithFlicker && isShowOnInitialise) { FlickerOn(flickerDefaultDuration); }
                    else  { ShowOrHideHUD(isShowOnInitialise); }
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: ShipDisplayModule.Initialise() could not find canvas HUDPanel. Did you start with the sample HUD prefab from Prefabs/Visuals folder?"); }
            #endif
        }

        /// <summary>
        /// Check to see if the ship is the same as the sourceShip currently assigned to the HUD.
        /// If either are null, the method will return false.
        /// </summary>
        /// <param name="shipControlModule"></param>
        /// <returns></returns>
        public bool IsSourceShip(ShipControlModule shipControlModule)
        {
            if (sourceShip == null || shipControlModule == null) { return false; }
            else { return shipControlModule.GetShipId == sourceShip.GetShipId; }
        }

        /// <summary>
        /// Check to see if the ship is the same as the soureShip currently assigned to the HUD.
        /// If either are null, the method will return false.
        /// </summary>
        /// <param name="ship"></param>
        /// <returns></returns>
        public bool IsSourceShip(Ship ship)
        {
            if (sourceShip == null || ship == null) { return false; }
            else { return ship.shipId == sourceShip.GetShipId; }
        }

        /// <summary>
        /// Call this if you modify any of the following at runtime.
        /// 1) displayReticleList
        /// 2) The DisplayReticlePanel size
        /// 3) Add or remove the MainCamera tag from a camera
        /// 4) displayMessageList
        /// 5) displayTargetList
        /// </summary>
        public void ReinitialiseVariables()
        {
            ValidateReticleList();
            numDisplayReticles = displayReticleList == null ? 0 : displayReticleList.Count;

            if (reticlePanel != null)
            {
                RectTransform reticleRectTransform = reticlePanel.GetComponent<RectTransform>();
                if (reticleRectTransform != null)
                {
                    reticleWidth = reticleRectTransform.sizeDelta.x;
                    reticleHeight = reticleRectTransform.sizeDelta.y;
                }
            }

            // If the camera hasn't been assigned, attempt to use the first camera with the MainCamera tag.
            if (mainCamera == null && Camera.main != null) { mainCamera = Camera.main; }

            isMainCameraAssigned = mainCamera != null;

            ValidateGaugeList();
            numDisplayGauges = displayGaugeList == null ? 0 : displayGaugeList.Count;

            ValidateMessageList();
            numDisplayMessages = displayMessageList == null ? 0 : displayMessageList.Count;

            ValidateTargetList();
            numDisplayTargets = displayTargetList == null ? 0 : displayTargetList.Count;
        }

        /// <summary>
        /// Refresh all components of the HUD. Typically called after the screen has been resized.
        /// </summary>
        public void RefreshHUD()
        {
            if (IsInitialised || editorMode)
            {
                // Set the initial position
                SetDisplayReticleOffset(displayReticleOffsetX, displayReticleOffsetY);

                SetHUDSize(displayWidth, displayHeight);
                SetHUDOffset(displayOffsetX, displayOffsetY);

                // Show or Hide initial setup
                ShowOrHideReticle(showActiveDisplayReticle);
                ShowOrHideAltitude(showAltitude);
                SetPrimaryColour(primaryColour);
                SetDisplayReticleColour(activeDisplayReticleColour);
                SetAltitudeTextColour(altitudeTextColour);
                ShowOrHideAirSpeed(showAirspeed);
                SetAirSpeedTextColour(airspeedTextColour);
                ShowOrHideOverlay(showOverlay);
                InitialiseAttitude(false);
                ShowOrHideAttitude(showAttitude);
                InitialiseHeading(false);
                ShowOrHideHeading(showHeading);
                InitialiseMessages();
                ShowOrHideMessages();
                InitialiseTargets();
                ShowOrHideTargets();
                InitialiseGauges();
                ShowOrHideGauges();

                // Set brightness after the colours have been set.
                InitialiseBrightness();
            }
        }

        /// <summary>
        /// Show the heads-up display. Has no effect if IsInitialised is false.
        /// </summary>
        public void ShowHUD()
        {
            // Prob makes sense to start in a non-flickering state.
            StopFlickering();

            if (isShowHUDWithFlicker) { FlickerOn(flickerDefaultDuration); }
            else { ShowOrHideHUD(true); }
        }

        /// <summary>
        /// Hide the heads-up display. Has no effect if IsInitialised is false.
        /// </summary>
        public void HideHUD()
        {
            // Prob makes sense to start in a non-flickering state.
            StopFlickering();

            if (isHideHUDWithFlicker) { FlickerOff(flickerDefaultDuration); }
            else { ShowOrHideHUD(false); }
        }

        /// <summary>
        /// Show the Overlay image on the heads-up display. Has no effect if IsInitialised is false.
        /// </summary>
        public void ShowOverlay()
        {
            ShowOrHideOverlay(true);
        }

        /// <summary>
        /// Hide the Overlay image on the heads-up display. Has no effect if IsInitialised is false.
        /// </summary>
        public void HideOverlay()
        {
            ShowOrHideOverlay(false);
        }

        /// <summary>
        /// Set or assign the main camera used by the heads-up display for calculations.
        /// </summary>
        /// <param name="camera"></param>
        public void SetCamera(Camera camera)
        {
            mainCamera = camera;
            isMainCameraAssigned = camera != null;
        }

        /// <summary>
        /// Set the HUD to use a particular display. Displays or monitors are numbered from 1 to 8.
        /// </summary>
        /// <param name="displayNumber">1 to 8</param>
        public void SetCanvasTargetDisplay (int displayNumber)
        {
            if (IsInitialised && SSCUtils.VerifyTargetDisplay(displayNumber, true))
            {
                Canvas _canvas = GetCanvas;

                if (_canvas != null) { _canvas.targetDisplay = displayNumber - 1; }
            }
        }

        /// <summary>
        /// Set the offset (position) of the HUD.
        /// If the module has been initialised, this will also re-position the HUD.
        /// </summary>
        /// <param name="offsetX">Horizontal offset from centre. Range between -1 and 1</param>
        /// <param name="offsetY">Vertical offset from centre. Range between -1 and 1</param>
        public void SetHUDOffset(float offsetX, float offsetY)
        {
            // Clamp the x,y values -1 to 1.
            if (offsetX < -1f) { displayOffsetX = -1f; }
            else if (offsetX > 1f) { displayOffsetX = 1f; }
            else { if (offsetX != displayOffsetX) { displayOffsetX = offsetX; } }

            if (offsetY < -1f) { displayOffsetY = -1f; }
            else if (offsetY > 1f) { displayOffsetY = 1f; }
            else { if (offsetY != displayOffsetY) { displayOffsetY = offsetY; } }

            if (IsInitialised)
            {
                // Here we use the half original (reference) HUD size as it doesn't need to be scaled in any way.
                // The parent HUD canvas is correctly scaled and sized to the actual monitor or device display.
                overlayPanel.localPosition = new Vector3(offsetX * cvsResolutionFull.x, offsetY * cvsResolutionFull.y, overlayPanel.localPosition.z);
            }
        }

        /// <summary>
        /// Set the size of the HUD overlay image and text.
        /// If the module has been initialised, this will also resize the HUD.
        /// The values are only updated if they are outside the range 0.0 to 1.0 or have changed.
        /// </summary>
        /// <param name="width"></param>
        /// <param name="height"></param>
        public void SetHUDSize(float width, float height)
        {
            // Clamp the x,y values 0.0 to 1.0
            if (width < 0f) { displayWidth = 0f; }
            else if (width > 1f) { displayWidth = 1f; }
            else if (width != displayWidth) { displayWidth = width; }

            if (height < 0f) { displayHeight = 0f; }
            else if (height > 1f) { displayHeight = 1f; }
            else if (height != displayHeight) { displayHeight = height; }

            if (IsInitialised)
            {
                // Here we use the original (reference) HUD size as it doesn't need to be scaled in any way.
                // The parent HUD canvas is correctly scaled and sized to the actual monitor or device display.
                overlayPanel.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, displayWidth * cvsResolutionFull.x);
                overlayPanel.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, displayHeight * cvsResolutionFull.y);

                // altitudeInitPosition is in 1920x1080 sizing. Convert into canvas space with cvsResolutionFull.x / refResolution.x

                // Move the altitude text relative to the resized overlay image
                altitudeCurrentPosition.x = altitudeInitPosition.x * displayWidth * cvsResolutionFull.x / refResolution.x;
                altitudeCurrentPosition.y = altitudeInitPosition.y * displayHeight * cvsResolutionFull.y / refResolution.y;
                altitudeTextRectTfrm.localPosition = altitudeCurrentPosition;

                // Move the airspeed text relative to the resized overlay image
                airspeedCurrentPosition.x = airspeedInitPosition.x * displayWidth * cvsResolutionFull.x / refResolution.x;
                airspeedCurrentPosition.y = airspeedInitPosition.y * displayHeight * cvsResolutionFull.y / refResolution.y;
                airspeedTextRectTfrm.localPosition = airspeedCurrentPosition;

                if (callbackOnSizeChange != null) { callbackOnSizeChange(displayWidth, displayHeight); }
            }
        }

        /// <summary>
        /// Set the primary colour of the heads-up display. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the HUD with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetPrimaryColour(Color32 newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref primaryColour, ref baseOverlayColour, true);

            if (IsInitialised || editorMode)
            {
                if (primaryOverlayImg != null)
                {
                    SetOverlayBrightness();
                }
            }
        }

        /// <summary>
        /// Set the primary colour of the heads-up display. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the HUD with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetPrimaryColour(Color newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref primaryColour, ref baseOverlayColour, true);

            if (IsInitialised || editorMode)
            {
                if (primaryOverlayImg != null)
                {
                    if (brightness == 1f) { primaryOverlayImg.color = newColour; }
                    else { primaryOverlayImg.color = baseOverlayColour.GetColorWithBrightness(brightness); }
                }
            }
        }

        /// <summary>
        /// Set the overall brightness of the HUD.
        /// </summary>
        /// <param name="newBrightness">Range 0.0 to 1.0</param>
        public void SetBrightness(float newBrightness)
        {
            // Clamp 0.0 to 1.0
            if (newBrightness < 0f) { brightness = 0f; }
            else if (newBrightness > 1f) { brightness = 1f; }

            brightness = newBrightness;

            if (IsInitialised || editorMode)
            {
                SetOverlayBrightness();
                SetReticleBrightness();
                SetAltitudeTextBrightness();
                SetAirSpeedTextBrightness();
                SetAttitudeBrightness();
                SetHeadingBrightness();

                int _numDisplayMessages = GetNumberDisplayMessages;

                // Set the brightness of all the messages
                for (int dmIdx = 0; dmIdx < _numDisplayMessages; dmIdx++)
                {
                    SetDisplayMessageBackgroundBrightness(displayMessageList[dmIdx]);
                    SetDisplayMessageTextBrightness(displayMessageList[dmIdx]);
                }

                int _numDisplayTargets = GetNumberDisplayTargets;

                // Set the brightness for all the targets
                for (int dtgtIdx = 0; dtgtIdx < _numDisplayTargets; dtgtIdx++)
                {
                    SetDisplayTargetBrightness(displayTargetList[dtgtIdx]);
                }

                int _numDisplayGauges = GetNumberDisplayGauges;

                // Set the brightness for all the gauges
                for (int dgIdx = 0; dgIdx < _numDisplayGauges; dgIdx++)
                {
                    SetDisplayGaugeForegroundBrightness(displayGaugeList[dgIdx]);
                    SetDisplayGaugeBackgroundBrightness(displayGaugeList[dgIdx]);
                    SetDisplayGaugeTextBrightness(displayGaugeList[dgIdx]);
                }
            }

            if (callbackOnBrightnessChange != null) { callbackOnBrightnessChange(brightness); }
        }

        /// <summary>
        /// Set the sort order in the scene of the HUD. Higher values appear on top.
        /// </summary>
        /// <param name="newSortOrder"></param>
        public void SetCanvasSortOrder(int newSortOrder)
        {
            canvasSortOrder = newSortOrder;

            if (IsInitialised || editorMode)
            {
                Canvas _canvas = GetCanvas;
                if (_canvas != null) { _canvas.sortingOrder = newSortOrder; }
            }
        }

        /// <summary>
        /// Turn on or off the HUD. Has no effect if not initialised. See also ShowHUD() and HideHUD()
        /// </summary>
        public void ToggleHUD()
        {
            // Prob makes sense to start in a non-flickering state.
            StopFlickering();

            IsHUDShown = !IsHUDShown;

            if (isShowHUDWithFlicker && IsHUDShown) { FlickerOn(flickerDefaultDuration); }
            else if (isHideHUDWithFlicker && !IsHUDShown) { FlickerOff(flickerDefaultDuration); }
            else { ShowOrHideHUD(IsHUDShown); }
        }

        #endregion

        #region Public API Methods - Panels

        /// <summary>
        /// Get the Attitude Panel
        /// Create it if it does not already exist
        /// </summary>
        /// <returns></returns>
        public RectTransform GetAttitudePanel()
        {
            if (hudRectTfrm == null) { hudRectTfrm = GetHUDPanel(); }

            if (hudRectTfrm != null)
            {
                //if (cvsResolutionFull.x == 0f) { cvsResolutionFull = ReferenceResolution; }

                // Centred panel (like messages)
                return SSCUtils.GetOrCreateChildRectTransform(hudRectTfrm, cvsResolutionFull, attitudePanelName, 0f, 0f, 1f, 1f, 0.5f, 0.5f, 0.5f, 0.5f);
            }
            else { return null; }
        }

        /// <summary>
        /// Get the HUD RectTransform or panel
        /// </summary>
        /// <returns></returns>
        public RectTransform GetHUDPanel()
        {
            return SSCUtils.GetChildRectTransform(transform, hudPanelName, this.name);
        }

        /// <summary>
        /// Get the Heading Panel
        /// Create it if it does not already exist
        /// </summary>
        /// <returns></returns>
        public RectTransform GetHeadingPanel()
        {
            if (hudRectTfrm == null) { hudRectTfrm = GetHUDPanel(); }

            if (hudRectTfrm != null)
            {
                // Stretched panel
                //return SSCUtils.GetOrCreateChildRectTransform(hudRectTfrm, cvsResolutionFull, headingPanelName, 0f, 0f, 1f, 1f, 0f, 0f, 1f, 1f);
                // Centred panel (like messages)
                return SSCUtils.GetOrCreateChildRectTransform(hudRectTfrm, cvsResolutionFull, headingPanelName, 0f, 0f, 1f, 1f, 0.5f, 0.5f, 0.5f, 0.5f);
            }
            else { return null; }
        }

        /// <summary>
        /// Get the parent panel for the Display Targets.
        /// Create it if it does not already exist
        /// </summary>
        /// <returns></returns>
        public RectTransform GetTargetsPanel()
        {
            if (hudRectTfrm == null) { hudRectTfrm = GetHUDPanel(); }

            if (hudRectTfrm != null)
            {
                // Stretched panel
                return SSCUtils.GetOrCreateChildRectTransform(hudRectTfrm, cvsResolutionFull, targetsPanelName, 0f, 0f, 1f, 1f, 0f, 0f, 1f, 1f);
            }
            else { return null; }
        }

        /// <summary>
        /// Get the parent panel for the Display Gauges.
        /// Create it if it does not already exist
        /// </summary>
        /// <returns></returns>
        public RectTransform GetGaugesPanel()
        {
            if (hudRectTfrm == null) { hudRectTfrm = GetHUDPanel(); }

            if (hudRectTfrm != null)
            {
                // Stretched panel
                return SSCUtils.GetOrCreateChildRectTransform(hudRectTfrm, cvsResolutionFull, gaugesPanelName, 0f, 0f, 1f, 1f, 0f, 0f, 1f, 1f);
            }
            else { return null; }
        }

        #endregion

        #region Public API Methods - Cursor

        /// <summary>
        /// Show the hardware (mouse) cursor.
        /// This also restarts the countdown auto-hide
        /// timer if that is enabled.
        /// </summary>
        public void ShowCursor()
        {
            ShowOrHideCursor(true);
        }

        /// <summary>
        /// Hide the hardware (mouse) cursor.
        /// NOTE: This will sometimes fail to turn off the cursor in the editor
        /// Game View when it doesn't have focus, but will work fine in a build.
        /// </summary>
        public void HideCursor()
        {
            ShowOrHideCursor(false);
        }

        /// <summary>
        /// Centre the hardware (mouse) cursor in the centre of the screen.
        /// WARNING: This will wait until the next frame before it returns.
        /// </summary>
        public void CentreCursor()
        {
            Cursor.lockState = CursorLockMode.Locked;
            StartCoroutine(UnlockCursor());
        }

        /// <summary>
        /// Toggle the hardware (mouse) cursor on or off.
        /// NOTE: This will sometimes fail to turn off the cursor in the editor
        /// Game View when it doesn't have focus, but will work fine in a build.
        /// </summary>
        public void ToggleCursor()
        {
            ShowOrHideCursor(!Cursor.visible);
        }

        #endregion

        #region Public API Methods - Display Reticle

        /// <summary>
        /// Returns the guidHash of the Reticle in the list given the index or
        /// zero-based position in the list. Will return 0 if no matching Reticle
        /// is found.
        /// Will return 0 if the module hasn't been initialised.
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public int GetDisplayReticleGuidHash(int index)
        {
            int guidHash = 0;

            if (IsInitialised || editorMode)
            {
                if (index >= 0 && index < GetNumberDisplayReticles)
                {
                    if (displayReticleList[index] != null) { guidHash = displayReticleList[index].guidHash; }
                }
            }

            return guidHash;
        }

        /// <summary>
        /// Returns the guidHash of the Reticle in the list given the name of the sprite.
        /// Will return 0 if no matching Reticle is found.
        /// WARNING: This will increase GC. Use GetDisplayReticleGuidHash(int index) where possible.
        /// </summary>
        /// <param name="spriteName"></param>
        /// <returns></returns>
        public int GetDisplayReticleGuidHash(string spriteName)
        {
            int guidHash = 0;
            DisplayReticle _tempDR = null;

            if ((IsInitialised || editorMode) && !string.IsNullOrEmpty(spriteName))
            {
                int _numDisplayReticles = GetNumberDisplayReticles;
                string _spriteNameLowerCase = spriteName.ToLower();

                for (int drIdx = 0; drIdx < _numDisplayReticles; drIdx++)
                {
                    _tempDR = displayReticleList[drIdx];
                    if (_tempDR != null && _tempDR.primarySprite != null && _tempDR.primarySprite.name.ToLower() == _spriteNameLowerCase)
                    {
                        guidHash = _tempDR.guidHash;
                        break;
                    }
                }
            }

            return guidHash;
        }

        /// <summary>
        /// Get a DisplayReticle given its guidHash.
        /// See also GetDisplayReticleGuidHash(..).
        /// Will return null if guidHash parameter is 0, it cannot be found
        /// or the module has not been initialised.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <returns></returns>
        public DisplayReticle GetDisplayReticle(int guidHash)
        {
            DisplayReticle displayReticle = null;
            DisplayReticle _tempDR = null;

            if (IsInitialised || editorMode)
            {
                int _numDisplayReticles = GetNumberDisplayReticles;

                for (int drIdx = 0; drIdx < _numDisplayReticles; drIdx++)
                {
                    _tempDR = displayReticleList[drIdx];
                    if (_tempDR != null && _tempDR.guidHash == guidHash)
                    {
                        displayReticle = _tempDR;
                        break;
                    }
                }
            }

            return displayReticle;
        }

        /// <summary>
        /// Get the UI sprite (image) for a DisplayReticle.
        /// See also GetDisplayReticleGuidHash(..).
        /// </summary>
        /// <param name="guidHash"></param>
        /// <returns></returns>
        public Sprite GetDisplayReticleSprite(int guidHash)
        {
            Sprite sprite = null;
            DisplayReticle _tempDR = null;

            if (IsInitialised || editorMode)
            {
                int _numDisplayReticles = GetNumberDisplayReticles;

                for (int drIdx = 0; drIdx < _numDisplayReticles; drIdx++)
                {
                    _tempDR = displayReticleList[drIdx];
                    if (_tempDR != null && _tempDR.guidHash == guidHash)
                    {
                        sprite = _tempDR.primarySprite;
                        break;
                    }
                }
            }

            return sprite;
        }

        /// <summary>
        /// Change the DiplayReticle sprite on the UI panel.
        /// See also GetDisplayReticleGuidHash(..).
        /// NOTE: The module must be initialised.
        /// </summary>
        /// <param name="guidHash"></param>
        public void ChangeDisplayReticle(int guidHash)
        {
            if (IsInitialised || editorMode)
            {
                guidHashActiveDisplayReticle = guidHash;
                currentDisplayReticle = GetDisplayReticle(guidHash);

                LoadDisplayReticleSprite(currentDisplayReticle);
            }
        }

        /// <summary>
        /// Hide or turn off the Display Reticle
        /// </summary>
        public void HideDisplayReticle()
        {
            ShowOrHideReticle(false);
        }

        /// <summary>
        /// Set the offset (position) of the Display Reticle on the HUD.
        /// If the module has been initialised, this will also re-position the Display Reticle.
        /// Same as SetDisplayReticleOffset(offset.x, offset.y)
        /// </summary>
        /// <param name="offset">Horizontal and Vertical offset from centre. Values should be between -1 and 1</param>
        public void SetDisplayReticleOffset(Vector2 offset)
        {
            SetDisplayReticleOffset(offset.x, offset.y);
        }

        /// <summary>
        /// Set the offset (position) of the Display Reticle on the HUD.
        /// If the module has been initialised, this will also re-position the Display Reticle.
        /// </summary>
        /// <param name="offsetX">Horizontal offset from centre. Range between -1 and 1</param>
        /// <param name="offsetY">Vertical offset from centre. Range between -1 and 1</param>
        public void SetDisplayReticleOffset(float offsetX, float offsetY)
        {
            // Verify the x,y values are within range -1 to 1.
            if (offsetX >= -1f && offsetX <= 1f)
            {
                displayReticleOffsetX = offsetX;
            }

            if (offsetY >= -1f && offsetY <= 1f)
            {
                displayReticleOffsetY = offsetY;
            }

            if (IsInitialised || editorMode)
            {
                Vector2 halfHUDSize = GetHUDHalfSize(true);

                if (lockDisplayReticleToCursor)
                {
                    // Centre on mouse pointer more accurately (reticle can go half outside screen dimensions on edges)
                    displayReticleImg.transform.localPosition = new Vector3(offsetX * halfHUDSize.x, offsetY * halfHUDSize.y, displayReticleImg.transform.localPosition.z);
                }
                else
                {
                    // Original default behaviour - reticle remains within screen dimensions.
                    displayReticleImg.transform.localPosition = new Vector3(offsetX * (halfHUDSize.x - (reticleWidth / 2f)), offsetY * (halfHUDSize.y - (reticleHeight / 2f)), displayReticleImg.transform.localPosition.z);
                }
            }
        }

        /// <summary>
        /// Set the active Display Reticle colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the reticle with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayReticleColour(Color32 newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref activeDisplayReticleColour, ref baseReticleColour, true);

            if (IsInitialised)
            {
                if (displayReticleImg != null)
                {
                    SetReticleBrightness();
                }
            }
        }

        /// <summary>
        /// Set the active Display Reticle colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the reticle with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayReticleColour(Color newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref activeDisplayReticleColour, ref baseReticleColour, true);

            if (IsInitialised || editorMode)
            {
                if (displayReticleImg != null)
                {
                    if (brightness == 1f) { displayReticleImg.color = newColour; }
                    else { displayReticleImg.color = baseReticleColour.GetColorWithBrightness(brightness); }
                }
            }
        }

        /// <summary>
        /// Show the Display Reticle on the HUD. The HUD will automatically be shown if it is not already visible.
        /// </summary>
        public void ShowDisplayReticle()
        {
            ShowOrHideReticle(true);
        }

        /// <summary>
        /// Show or Hide the Display Reticle on the HUD. The HUD will automatically be shown if required.
        /// </summary>
        public void ToggleDisplayReticle()
        {
            ShowOrHideReticle(!showActiveDisplayReticle);
        }

        /// <summary>
        /// Create a new list if required
        /// </summary>
        public void ValidateReticleList()
        {
            if (displayReticleList == null) { displayReticleList = new List<DisplayReticle>(1); }
        }

        #endregion

        #region Public API Methods - Altitude

        /// <summary>
        /// Attempt to show the Altitude indicator. Turn on HUD if required.
        /// </summary>
        public void ShowAltitude()
        {
            ShowOrHideAltitude(true);
        }

        /// <summary>
        /// Attempt to turn off the Altitude indicator
        /// </summary>
        public void HideAltitude()
        {
            ShowOrHideAltitude(false);
        }

        /// <summary>
        /// Set the altitude text colour on the heads-up display. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the HUD with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetAltitudeTextColour(Color32 newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref altitudeTextColour, ref baseAltitudeTextColour, true);

            if (IsInitialised || editorMode)
            {
                if (altitudeText != null)
                {
                    SetAltitudeTextBrightness();
                }
            }
        }

        /// <summary>
        /// Set the altitude text colour on the heads-up display. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the HUD with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetAltitudeTextColour(Color newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref altitudeTextColour, ref baseAltitudeTextColour, true);

            if (IsInitialised || editorMode)
            {
                if (altitudeText != null)
                {
                    if (brightness == 1f) { altitudeText.color = newColour; }
                    else { altitudeText.color = baseAltitudeTextColour.GetColorWithBrightness(brightness); }
                }
            }
        }

        #endregion

        #region Public API Methods - Air Speed

        /// <summary>
        /// Attempt to show the Air speed indicator. Turn on HUD if required.
        /// </summary>
        public void ShowAirSpeed()
        {
            ShowOrHideAirSpeed(true);
        }

        /// <summary>
        /// Attempt to turn off the AirSpeed indicator
        /// </summary>
        public void HideAirSpeed()
        {
            ShowOrHideAirSpeed(false);
        }

        /// <summary>
        /// Set the airspeed text colour on the heads-up display. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the HUD with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetAirSpeedTextColour(Color32 newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref airspeedTextColour, ref baseAirspeedTextColour, true);

            if (IsInitialised || editorMode)
            {
                if (airspeedText != null)
                {
                    SetAirSpeedTextBrightness();
                }
            }
        }

        /// <summary>
        /// Set the airspeed text colour on the heads-up display. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the HUD with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetAirSpeedTextColour(Color newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref airspeedTextColour, ref baseAirspeedTextColour, true);

            if (IsInitialised || editorMode)
            {
                if (airspeedText != null)
                {
                    if (brightness == 1f) { airspeedText.color = newColour; }
                    else { airspeedText.color = baseAirspeedTextColour.GetColorWithBrightness(brightness); }
                }
            }
        }

        #endregion

        #region Public API Methods - Attitude

        /// <summary>
        /// Attempt to turn off the Attitude display
        /// </summary>
        public void HideAttitude()
        {
            ShowOrHideAttitude(false);
        }

        /// <summary>
        /// Set the sprite that will mask the Display Attitude scrollable sprite
        /// </summary>
        /// <param name="newSprite"></param>
        public void SetDisplayAttitudeMaskSprite (Sprite newSprite)
        {
            attitudeMaskSprite = newSprite;

            if (attitudeMaskImg != null)
            {
                attitudeMaskImg.sprite = attitudeMaskSprite;
            }
        }

        /// <summary>
        /// This is called when the HUD is resized or some elements of the Attitude control are modified
        /// </summary>
        public void RefreshAttitudeAfterResize()
        {
            // Recalculate the pixels per degree in the pitch ladder
            if (attitudeScrollImg != null && attitudeScrollImg.mainTexture != null)
            {
                // The attitude scroll img should be -90 to 90 deg. Ideally it should have a "border"
                // at the top and bottom of blank (transparent) space to prevent +-90 being right
                // at the top/bottom of the HUD.
                // The image is autoscaled to the full height of the default HUD screen size.

                float imgHeight = attitudeScrollImg.mainTexture.height;

                // If the image
                if (imgHeight < 10f) { imgHeight = 1024f; }

                attitudePixelsPerDegree = cvsResolutionFull.y * ((imgHeight - attitudeScrollSpriteBorderWidth * 2f) / imgHeight) / 180f;
            }
            #if UNITY_EDITOR
            else
            {
                Debug.LogWarning("RefreshAttitudeAfterResize - Attitude scroll sprite has no UI texture");
            }
            #endif
        }

        /// <summary>
        /// Set the Display Attitude primary colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the attitude with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayAttitudePrimaryColour (Color newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref attitudePrimaryColour, ref baseAttitudePrimaryColour, true);

            SetAttitudeBrightness();
        }

        /// <summary>
        /// Set the Display Attitude scroll sprite.
        /// </summary>
        /// <param name="newSprite"></param>
        public void SetDisplayAttitudeScrollSprite (Sprite newSprite)
        {
            attitudeScrollSprite = newSprite;

            if (attitudeScrollImg != null)
            {
                attitudeScrollImg.sprite = attitudeScrollSprite;

                // Recalculate the pixels per degree for scrolling.
                RefreshAttitudeAfterResize();
            }
        }

        /// <summary>
        /// Set the normalised size of the scrollable Display Attitude.
        /// Currently width is always 1.0
        /// </summary>
        /// <param name="width"></param>
        /// <param name="height"></param>
        public void SetDisplayAttitudeSize (float width, float height)
        {
            // Verify the width,height values are within range 0.1 to 1.
            if (height >= 0.1f && height <= 1f)
            {
                attitudeHeight = height;
            }

            attitudeWidth = 1f;

            if (IsInitialised || editorMode)
            {
                #if UNITY_EDITOR
                if (editorMode)
                {
                    CheckHUDResize(false);
                    UnityEditor.Undo.RecordObject(attitudeRectTfrm.transform, string.Empty);
                }
                #endif

                // Here we use the original (reference) HUD size as it doesn't need to be scaled in any way.
                // The parent HUD canvas is correctly scaled and sized to the actual monitor or device display.
                attitudeRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, attitudeWidth * cvsResolutionFull.x);
                attitudeRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, attitudeHeight * cvsResolutionFull.y);
            }
        }

        /// <summary>
        /// Set the normalised offset (position) of the Display Attitude on the HUD.
        /// If the module has been initialised, this will also re-position the Display Attitude.
        /// </summary>
        /// <param name="offsetX">Horizontal offset from centre. Range between -1 and 1</param>
        /// <param name="offsetY">Vertical offset from centre. Range between -1 and 1</param>
        public void SetDisplayAttitudeOffset (float offsetX, float offsetY)
        {
            // Verify the x,y values are within range -1 to 1.
            if (offsetX >= -1f && offsetX <= 1f)
            {
                attitudeOffsetX = offsetX;
            }

            if (offsetY >= -1f && offsetY <= 1f)
            {
                attitudeOffsetY = offsetY;
            }

            if (IsInitialised || editorMode)
            {
                Transform attTrfm = attitudeRectTfrm.transform;

                #if UNITY_EDITOR
                if (editorMode)
                {
                    CheckHUDResize(false);
                    UnityEditor.Undo.RecordObject(attTrfm, string.Empty);
                }
                #endif

                // Use the scaled HUD size. This works in and out of play mode
                tempAttitudeOffset.x = attitudeOffsetX * cvsResolutionHalf.x;
                tempAttitudeOffset.y = attitudeOffsetY * cvsResolutionHalf.y;
                tempAttitudeOffset.z = attTrfm.localPosition.z;

                attTrfm.localPosition = tempAttitudeOffset;

                // Reset the position of the scrollable image
                if (attitudeScrollPanel != null)
                {
                    attitudeScrollPanel.localPosition = Vector3.zero;
                    attitudeInitPosition = attitudeScrollPanel.transform.position;

                    //if (showAttitudeIndicator && attitudeIndicatorPanel != null)
                    //{
                    //    attitudeIndicatorPanel.localPosition = new Vector3(attitudeScrollPanel.localPosition.x, attitudeScrollPanel.localPosition.y - 20f, attitudeScrollPanel.localPosition.z);
                    //}
                }
            }
        }

        /// <summary>
        /// Set the border width of the Scroll Sprite (texture) in pixels
        /// </summary>
        /// <param name="newBorderWidth"></param>
        public void SetDisplayAttitudeSpriteBorderWidth (float newBorderWidth)
        {
            if (newBorderWidth >= 0f)
            {
                attitudeScrollSpriteBorderWidth = newBorderWidth;

                RefreshAttitudeAfterResize();
            }
        }

        /// <summary>
        /// Attempt to show the scrollable Attitude. Turn on HUD if required.
        /// </summary>
        public void ShowAttitude()
        {
            ShowOrHideAttitude(true);
        }

        #endregion

        #region Public API Methods - Flickering

        /// <summary>
        /// Flicker the HUD on/off. Override the Flicker Default Duration.
        /// Show the HUD when flickering finishes.
        /// </summary>
        /// <param name="duration"></param>
        public void FlickerOn (float duration)
        {
            if (duration > 0f)
            {
                flickerDuration = duration;
                flickerDurationTimer = 0f;
                isFlickerWaiting = false;

                isFlickeringEndStateOn = true;
                // If the HUD is flickering to the Shown state, it cannot also be flickering off.
                isFlickeringEndStateOff = false;

                if (flickerHistory != null) { flickerHistory.Clear(); }

                // Remember the current overall HUD brightness setting
                flickerStartIntensity = brightness;

                if (!flickerVariableIntensity) { flickerIntensity = flickerStartIntensity; }
            }
        }

        /// <summary>
        /// Flicker the HUD on/off. Override the Flicker Default Duration.
        /// Hide the HUD when flickering finishers.
        /// </summary>
        /// <param name="duration"></param>
        public void FlickerOff (float duration)
        {
            if (duration > 0f)
            {
                flickerDuration = duration;
                flickerDurationTimer = 0f;
                isFlickerWaiting = false;

                isFlickeringEndStateOff = true;
                // If the HUD is flickering to the Hidden state, it cannot also be flickering on.
                isFlickeringEndStateOn = false;

                if (flickerHistory != null) { flickerHistory.Clear(); }

                // Remember the current overall HUD brightness setting
                flickerStartIntensity = brightness;

                if (!flickerVariableIntensity) { flickerIntensity = flickerStartIntensity; }
            }
        }


        public void StopFlickering()
        {
            isFlickeringEndStateOn = false;
            isFlickeringEndStateOff = false;
        }

        #endregion

        #region Public API Methods - Gauges

        /// <summary>
        /// Add a new gauge to the HUD. By design, they are not visible at runtime when first added.
        /// </summary>
        /// <param name="gaugeName"></param>
        /// <param name="gaugeText"></param>
        /// <returns></returns>
        public DisplayGauge AddGauge(string gaugeName, string gaugeText)
        {
            DisplayGauge displayGauge = null;

            if (GetHUDPanel() == null)
            {
                #if UNITY_EDITOR
                Debug.LogWarning("ERROR: ShipDisplayModule.AddGauge() - could not find HUDPanel for the HUD. Did you use the prefab from Prefabs/Visuals folder?");
                #endif
            }
            else
            {
                displayGauge = new DisplayGauge();
                if (displayGauge != null)
                {
                    displayGauge.gaugeName = gaugeName;
                    displayGauge.gaugeString = gaugeText;
                    ValidateGaugeList();
                    displayGaugeList.Add(displayGauge);

                    numDisplayGauges = displayGaugeList.Count;

                    RectTransform gaugePanel = CreateGaugePanel(displayGauge);
                    if (gaugePanel != null)
                    {
                        #if UNITY_EDITOR
                        // Make sure we can rollback the creation of the new gauge panel for this slot
                        UnityEditor.Undo.RegisterCreatedObjectUndo(gaugePanel.gameObject, string.Empty);
                        #endif
                    }
                 }
            }

            return displayGauge;
        }

        /// <summary>
        /// Add a gauge to the HUD using a displayGauge instance. Typically, this is used
        /// with CopyDisplayGauge(..).
        /// </summary>
        /// <param name="displayGauge"></param>
        public void AddGauge(DisplayGauge displayGauge)
        {
            if (displayGauge != null)
            {
                if (GetHUDPanel() == null)
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("ERROR: ShipDisplayModule.AddGauge() - could not find HUDPanel for the HUD. Did you use the prefab from Prefabs/Visuals folder?");
                    #endif
                }
                else
                {
                    ValidateGaugeList();
                    displayGaugeList.Add(displayGauge);

                    numDisplayGauges = displayGaugeList.Count;

                    RectTransform gaugePanel = CreateGaugePanel(displayGauge);
                    if (gaugePanel != null)
                    {
                        #if UNITY_EDITOR
                        // Make sure we can rollback the creation of the new gauge panel for this slot
                        UnityEditor.Undo.RegisterCreatedObjectUndo(gaugePanel.gameObject, string.Empty);
                        #endif
                    }
                }
            }
        }

        /// <summary>
        /// Delete a gauge from the HUD.
        /// NOTE: It is much cheaper to HideDisplayGauge(..) than completely remove it.
        /// </summary>
        /// <param name="guidHash"></param>
        public void DeleteGauge(int guidHash)
        {
            #if UNITY_EDITOR
            bool isRecordUndo = !Application.isPlaying;
            int undoGroup=0;
            #else
            bool isRecordUndo = false;
            #endif

            RectTransform gaugeRectTfrm = GetGaugePanel(guidHash);
            int _dgIndex = GetDisplayGaugeIndex(guidHash);

            // Only record undo if in the editor AND is not playing AND something needs to be recorded
            isRecordUndo = isRecordUndo && (gaugeRectTfrm != null || _dgIndex >= 0);

            #if UNITY_EDITOR
            if (isRecordUndo)
            {
                UnityEditor.Undo.SetCurrentGroupName("Delete Display Gauge " + (_dgIndex + 1).ToString());
                undoGroup = UnityEditor.Undo.GetCurrentGroup();

                if (_dgIndex >= 0)
                {
                    UnityEditor.Undo.RecordObject(this, string.Empty);
                }
            }
            #endif

            // Check that the gauge exists and it is within the list constraints
            // NOTE: The script element must be modified BEFORE the Undo.DestroyObjectImmediate is called
            // in order for Undo to correctly undo both the gauge change AND the destroy of the panel.
            if (_dgIndex >= 0 && _dgIndex < (displayGaugeList == null ? 0 : displayGaugeList.Count))
            {
                displayGaugeList.RemoveAt(_dgIndex);
                numDisplayGauges = displayGaugeList.Count;
            }

            if (gaugeRectTfrm != null)
            {
                if (Application.isPlaying) { Destroy(gaugeRectTfrm.gameObject); }
                else
                {
                    #if UNITY_EDITOR
                    UnityEditor.Undo.DestroyObjectImmediate(gaugeRectTfrm.gameObject);
                    #else
                    DestroyImmediate(gaugeRectTfrm.gameObject);
                    #endif
                }
            }

            #if UNITY_EDITOR
            if (isRecordUndo)
            {               
                UnityEditor.Undo.CollapseUndoOperations(undoGroup);
            }
            #endif
        }

        /// <summary>
        /// Create a copy of an existing DisplayGauge, and give it a new name.
        /// Call AddGauge(newDisplayGauge) to make it useable in the game.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="NameOfCopy"></param>
        /// <returns></returns>
        public DisplayGauge CopyDisplayGauge(DisplayGauge displayGauge, string NameOfCopy)
        {
            DisplayGauge dgCopy = new DisplayGauge(displayGauge);

            if (dgCopy != null)
            {
                // make it unique
                dgCopy.guidHash = SSCMath.GetHashCodeFromGuid();
                dgCopy.gaugeName = NameOfCopy;
            }
            return dgCopy;
        }

        /// <summary>
        /// Returns the guidHash of the Gauge in the list given the index or zero-based position in the list.
        /// Will return 0 if no matching Gauge is found.
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public int GetDisplayGaugeGuidHash(int index)
        {
            int guidHash = 0;

            if (index >= 0 && index < GetNumberDisplayGauges)
            {
                if (displayGaugeList[index] != null) { guidHash = displayGaugeList[index].guidHash; }
            }

            return guidHash;
        }

        /// <summary>
        /// Get the zero-based index of the Gauge in the list. Will return -1 if not found.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <returns></returns>
        public int GetDisplayGaugeIndex(int guidHash)
        {
            int index = -1;

            int _numDisplayGauges = GetNumberDisplayGauges;

            for (int dgIdx = 0; dgIdx < _numDisplayGauges; dgIdx++)
            {
                if (displayGaugeList[dgIdx] != null && displayGaugeList[dgIdx].guidHash == guidHash) { index = dgIdx; break; }
            }

            return index;
        }

        /// <summary>
        /// Get a DisplayGauge given its guidHash.
        /// See also GetDisplayGaugeGuidHash(..).
        /// Will return null if guidHash parameter is 0, it cannot be found.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <returns></returns>
        public DisplayGauge GetDisplayGauge(int guidHash)
        {
            DisplayGauge displayGauge = null;
            DisplayGauge _tempDG = null;

            int _numDisplayGauges = GetNumberDisplayGauges;

            for (int dgIdx = 0; dgIdx < _numDisplayGauges; dgIdx++)
            {
                _tempDG = displayGaugeList[dgIdx];
                if (_tempDG != null && _tempDG.guidHash == guidHash)
                {
                    displayGauge = _tempDG;
                    break;
                }
            }

            return displayGauge;
        }

        /// <summary>
        /// Get the display gauge give the description title of the gauge.
        /// WARNING: This will increase Garbage Collection (GC). Where possible
        /// use GetDisplayGauge(guidHash) and/or GetDisplayGaugeGuidHash(index)
        /// </summary>
        /// <param name="displayGaugeName"></param>
        /// <returns></returns>
        public DisplayGauge GetDisplayGauge(string displayGaugeName)
        {
            DisplayGauge displayGauge = null;
            DisplayGauge _tempDG = null;

            if (!string.IsNullOrEmpty(displayGaugeName))
            {
                int _numDisplayGauges = GetNumberDisplayGauges;

                for (int dgIdx = 0; dgIdx < _numDisplayGauges; dgIdx++)
                {
                    _tempDG = displayGaugeList[dgIdx];
                    if (_tempDG != null && !string.IsNullOrEmpty(_tempDG.gaugeName))
                    {
                        if (_tempDG.gaugeName.ToLower() == displayGaugeName.ToLower())
                        {
                            displayGauge = _tempDG;
                            break;
                        }
                    }
                }
            }
            return displayGauge;
        }

        /// <summary>
        /// Hide or turn off the Display Gauge
        /// </summary>
        /// <param name="guidHash"></param>
        public void HideDisplayGauge(int guidHash)
        {
            DisplayGauge displayGauge = GetDisplayGauge(guidHash);
            if (displayGauge != null) { ShowOrHideGauge(displayGauge, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayGauge - Could not find gauge with guidHash: " + guidHash); }
            #endif
        }

        /// <summary>
        /// Hide or turn off the Display Gauge
        /// </summary>
        /// <param name="displayGauge"></param>
        public void HideDisplayGauge(DisplayGauge displayGauge)
        {
            if (displayGauge != null) { ShowOrHideGauge(displayGauge, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayGauge - Could not find gauge - parameter was null"); }
            #endif
        }

        /// <summary>
        /// Hide or turn off all Display Gauges. ShipDisplayModule must be initialised.
        /// </summary>
        public void HideDisplayGauges()
        {
            ShowOrHideGauges(false);
        }

        /// <summary>
        /// After adding or moving DisplayGauges, they may need to be sorted to
        /// have the correct z-order in on the HUD.
        /// </summary>
        public void RefreshGaugesSortOrder()
        {
            if (gaugesRectTfrm != null)
            {
                // Gauges should begin at index 0.
                int zIndex = -1;

                // Update number of DisplayGauges. This can help issues in the Editor, like moving DislayGauges
                // up or down in the list while in play mode.
                numDisplayGauges = displayGaugeList == null ? 0 : displayGaugeList.Count;

                for (int dtIdx = 0; dtIdx < numDisplayGauges; dtIdx++)
                {
                    DisplayGauge displayGauge = displayGaugeList[dtIdx];

                    if (displayGauge != null)
                    {
                        RectTransform _rt = displayGauge.CachedGaugePanel;

                        if (_rt != null)
                        {
                            _rt.SetSiblingIndex(++zIndex);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Import a json file from disk and return as DisplayGauge
        /// </summary>
        /// <param name="folderPath"></param>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public DisplayGauge ImportGaugeFromJson (string folderPath, string fileName)
        {
            DisplayGauge displayGauge = null;

            if (!string.IsNullOrEmpty(folderPath) && !string.IsNullOrEmpty(fileName))
            {
                try
                {
                    string filePath = System.IO.Path.Combine(folderPath, fileName);
                    if (System.IO.File.Exists(filePath))
                    {
                        string jsonText = System.IO.File.ReadAllText(filePath);

                        displayGauge = new DisplayGauge();
                        int displayGaugeGuidHash = displayGauge.guidHash;

                        JsonUtility.FromJsonOverwrite(jsonText, displayGauge);

                        if (displayGauge != null)
                        {
                            // make hash code unique
                            displayGauge.guidHash = displayGaugeGuidHash;
                        }
                    }
                    #if UNITY_EDITOR
                    else
                    {
                        Debug.LogWarning("ERROR: Import Gauge. Could not find file at " + filePath);
                    }
                    #endif
                }
                catch (System.Exception ex)
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("ERROR: ShipDisplayModule - could not import gauge from: " + folderPath + " PLEASE REPORT - " + ex.Message);
                    #else
                    // Keep compiler happy
                    if (ex != null) { }
                    #endif
                }
            }

            return displayGauge;
        }

        /// <summary>
        /// Save the Gauge to a json file on disk.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="filePath"></param>
        public bool SaveGaugeAsJson (DisplayGauge displayGauge, string filePath)
        {
            bool isSuccessful = false;

            if (displayGauge != null && !string.IsNullOrEmpty(filePath))
            {
                try
                {
                    string jsonGaugeData = JsonUtility.ToJson(displayGauge);

                    if (!string.IsNullOrEmpty(jsonGaugeData) && !string.IsNullOrEmpty(filePath))
                    {
                        System.IO.File.WriteAllText(filePath, jsonGaugeData);
                        isSuccessful = true;
                    }
                }
                catch (System.Exception ex)
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("ERROR: ShipDisplayModule SaveGaugeAsJson - could not export: " + displayGauge.gaugeName + " PLEASE REPORT - " + ex.Message);
                    #else
                    // Keep compiler happy
                    if (ex != null) { }
                    #endif
                }
            }

            return isSuccessful;
        }

        /// <summary>
        /// The foreground colour of the gauge will be determined by the gauge value and the low, medium and high colours.
        /// LowColour = value of 0, MediumColour when value is 0.5, and HighColour when value is 1.0
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="lowColour"></param>
        /// <param name="mediumColour"></param>
        /// <param name="highColour"></param>
        public void SetDisplayGaugeValueAffectsColourOn(DisplayGauge displayGauge, Color lowColour, Color mediumColour, Color highColour)
        {
            if (displayGauge != null)
            {
                SSCUtils.ColortoColorNoAlloc(ref lowColour, ref displayGauge.foregroundLowColour);
                SSCUtils.ColortoColorNoAlloc(ref mediumColour, ref displayGauge.foregroundMediumColour);
                SSCUtils.ColortoColorNoAlloc(ref highColour, ref displayGauge.foregroundHighColour);

                displayGauge.isColourAffectByValue = true;

                if (IsInitialised || editorMode)
                {
                    SetDisplayGaugeValue(displayGauge, displayGauge.gaugeValue);
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeValueAffectsColour - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// The value of the gauge does not affect the foreground colour.
        /// When turning off this feature the new foreground colour would typically be the old foregroundHighColour.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="newForegroundColour"></param>
        public void SetDisplayGaugeValueAffectsColourOff(DisplayGauge displayGauge, Color newForegroundColour)
        {
            if (displayGauge != null)
            {
                displayGauge.isColourAffectByValue = false;

                if (IsInitialised || editorMode)
                {
                    SetDisplayGaugeForegroundColour(displayGauge, newForegroundColour);
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeValueAffectsColour - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the gauge value at which the foreground medium colour should be set.
        /// The default value is 0.5.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="newValue"></param>
        public void SetDisplayGaugeMediumColourValue (DisplayGauge displayGauge, float newValue)
        {
            if (displayGauge != null)
            {
                if (newValue > 0f && newValue < 1f)
                {
                    displayGauge.mediumColourValue = newValue;
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeMediumColourValue - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the offset (position) of the Display Gauge on the HUD.
        /// If the module has been initialised, this will also re-position the Display Gauge.
        /// </summary>
        /// <param name="offsetX">Horizontal offset from centre. Range between -1 and 1</param>
        /// <param name="offsetY">Vertical offset from centre. Range between -1 and 1</param>
        public void SetDisplayGaugeOffset(DisplayGauge displayGauge, float offsetX, float offsetY)
        {
            // Verify the x,y values are within range -1 to 1.
            if (offsetX >= -1f && offsetX <= 1f)
            {
                displayGauge.offsetX = offsetX;
            }

            if (offsetY >= -1f && offsetY <= 1f)
            {
                displayGauge.offsetY = offsetY;
            }

            if (IsInitialised || editorMode)
            {
                Transform dgTrfm = displayGauge.CachedGaugePanel.transform;

                #if UNITY_EDITOR
                if (editorMode)
                {
                    CheckHUDResize(false);
                    UnityEditor.Undo.RecordObject(dgTrfm, string.Empty);
                }
                #endif

                // Use the scaled HUD size. This works in and out of play mode
                tempGaugeOffset.x = displayGauge.offsetX * cvsResolutionHalf.x;
                tempGaugeOffset.y = displayGauge.offsetY * cvsResolutionHalf.y;
                tempGaugeOffset.z = dgTrfm.localPosition.z;

                dgTrfm.localPosition = tempGaugeOffset;
            }
        }

        /// <summary>
        /// Set the size of the Gauge Panel.
        /// If the module has been initialised, this will also resize the Gauge Panel.
        /// The values are only updated if they are outside the range 0.0 to 1.0 or have changed.
        /// Also updates the Text direction
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="width">Range between 0.0 and 1.0</param>
        /// <param name="height">Range between 0.0 and 1.0</param>
        public void SetDisplayGaugeSize(DisplayGauge displayGauge, float width, float height)
        {
            // Clamp the x,y values 0.0 to 1.0
            if (width < 0f) { displayGauge.displayWidth = 0f; }
            else if (width > 1f) { displayGauge.displayWidth = 1f; }
            else if (width != displayGauge.displayWidth) { displayGauge.displayWidth = width; }

            if (height < 0f) { displayGauge.displayHeight = 0f; }
            else if (height > 1f) { displayGauge.displayHeight = 1f; }
            else if (height != displayGauge.displayHeight) { displayGauge.displayHeight = height; }

            if (IsInitialised || editorMode)
            {
                #if UNITY_EDITOR
                if (editorMode) { CheckHUDResize(false); }
                #endif

                RectTransform dgRectTfrm = displayGauge.CachedGaugePanel;

                float pixelWidth = displayGauge.displayWidth * cvsResolutionFull.x;
                float pixelHeight = displayGauge.displayHeight * cvsResolutionFull.y;

                if (dgRectTfrm != null)
                {
                    // Here we use the original (reference) HUD size as it doesn't need to be scaled in any way.
                    // The parent HUD canvas is correctly scaled and sized to the actual monitor or device display.
                    dgRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, pixelWidth);
                    dgRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, pixelHeight);
                }

                if (displayGauge.CachedFgImgComponent != null)
                {
                    RectTransform dgFgImgRectTfrm = displayGauge.CachedFgImgComponent.rectTransform;

                    dgFgImgRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, pixelWidth);
                    dgFgImgRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, pixelHeight);
                }

                SetDisplayGaugeTextDirection(displayGauge, displayGauge.textDirection);
            }
        }

        /// <summary>
        /// Set the type or style of the gauge.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="dgType"></param>
        public void SetDisplayGaugeType (DisplayGauge displayGauge, DisplayGauge.DGType dgType)
        {
            if (displayGauge != null)
            {
                displayGauge.gaugeType = dgType;

                GetOrCreateOrRemoveGaugeLabel(displayGauge);

                if (displayGauge.HasLabel)
                {
                    // Refresh the label
                    SetDisplayGaugeTextBrightness(displayGauge);

                    SetDisplayGaugeTextFontStyle(displayGauge, (UnityEngine.FontStyle)displayGauge.fontStyle);
                    SetDisplayGaugeTextFontSize(displayGauge, displayGauge.isBestFit, displayGauge.fontMinSize, displayGauge.fontMaxSize);

                    SetDisplayGaugeLabelAlignment(displayGauge, displayGauge.labelAlignment);
                }

                // Refresh the Text direction which also does the sizing for gauges with and without labels
                SetDisplayGaugeTextDirection(displayGauge, displayGauge.textDirection);

                SetDisplayGaugeValue(displayGauge, displayGauge.gaugeValue);
            }
        }

        /// <summary>
        /// Update the value or reading of the gauge. If Value Affects Colour (isColourAffectByValue)
        /// is enabled, the foreground colour of the gauge will also be updated.
        /// Values should be in range 0.0 to 1.0.
        /// NOTE: Numeric gauges can increase GC at runtime. Where possible, only call this method when
        /// the value changes.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="gaugeValue"></param>
        public void SetDisplayGaugeValue (DisplayGauge displayGauge, float gaugeValue)
        {
            if (displayGauge != null)
            {
                // Clamp 0.0 to 1.0
                float _gaugeValue = gaugeValue < 0f ? 0f : gaugeValue > 1f ? 1f : gaugeValue;

                displayGauge.gaugeValue = _gaugeValue;
                UnityEngine.UI.Image fgImg = displayGauge.CachedFgImgComponent;

                if (fgImg != null)
                {
                    fgImg.fillAmount = displayGauge.isFillMethodNone ? 0f : _gaugeValue;

                    if (displayGauge.isColourAffectByValue)
                    {
                        if (_gaugeValue > displayGauge.mediumColourValue)
                        {
                            Color _newColour = Color.Lerp(displayGauge.foregroundMediumColour, displayGauge.foregroundHighColour, SSCMath.Normalise(_gaugeValue,  displayGauge.mediumColourValue, 1f));

                            SSCUtils.UpdateColour(ref _newColour, ref displayGauge.foregroundColour, ref displayGauge.baseForegroundColour, false);
                            SetDisplayGaugeForegroundBrightness(displayGauge);
                        }
                        else
                        {
                            Color _newColour = Color.Lerp(displayGauge.foregroundLowColour, displayGauge.foregroundMediumColour, SSCMath.Normalise(_gaugeValue, 0f, displayGauge.mediumColourValue));

                            SSCUtils.UpdateColour(ref _newColour, ref displayGauge.foregroundColour, ref displayGauge.baseForegroundColour, true);
                            SetDisplayGaugeForegroundBrightness(displayGauge);
                        }
                    }
                }

                int gaugeTypeInt = (int)displayGauge.gaugeType;

                // If this is a numeric gauge, update the text with the numeric value
                if (gaugeTypeInt == DisplayGauge.DGTypeFilledNumber1Int || gaugeTypeInt == DisplayGauge.DGTypeNumberWithLabel1Int)
                {
                    float _displayTxtValue = displayGauge.isNumericPercentage ? _gaugeValue * 100f : _gaugeValue * displayGauge.gaugeMaxValue;

                    displayGauge.gaugeString = SSCUtils.GetNumericString(_displayTxtValue, displayGauge.gaugeDecimalPlaces, displayGauge.isNumericPercentage);

                    // Update the text field for the gauge on the HUD UI
                    Text uiText = displayGauge.CachedTextComponent;

                    if (uiText != null) { uiText.text = displayGauge.gaugeString; }
                }

            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeValue - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Update the text of the gauge label. This only applies to numeric gauges with labels.
        /// For non-numeric gauges see SetDisplayGaugeText(..).
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="gaugeLabel"></param>
        public void SetDisplayGaugeLabel (DisplayGauge displayGauge, string gaugeLabel)
        {
            if (displayGauge != null)
            {
                displayGauge.gaugeLabel = gaugeLabel;
                Text uiText = displayGauge.CachedLabelTextComponent;

                if (uiText != null) { uiText.text = gaugeLabel; }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeLabel - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Update the position of the label within the gauge panel.
        /// Only applies to numeric gauges with a label.
        /// See also SetDisplayGaugeTextAlignment(..)
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="textAlignment"></param>
        public void SetDisplayGaugeLabelAlignment (DisplayGauge displayGauge, TextAnchor textAlignment)
        {
            if (displayGauge != null)
            {
                if (!editorMode) { displayGauge.labelAlignment = textAlignment; }

                // If this is not a numeric gauge with a label, this will return null.
                Text uiText = displayGauge.CachedLabelTextComponent;

                if (uiText != null) { uiText.alignment = textAlignment; }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeLabelAlignment - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Update the text of the gauge. For numeric gauges with labels, see
        /// SetDisplayGaugeLabel(..).
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="gaugeText"></param>
        public void SetDisplayGaugeText (DisplayGauge displayGauge, string gaugeText)
        {
            if (displayGauge != null)
            {
                displayGauge.gaugeString = gaugeText;
                Text uiText = displayGauge.CachedTextComponent;

                if (uiText != null) { uiText.text = gaugeText; }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeText - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Update the position of the text within the gauge panel
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="textAlignment"></param>
        public void SetDisplayGaugeTextAlignment(DisplayGauge displayGauge, TextAnchor textAlignment)
        {
            if (displayGauge != null)
            {
                if (!editorMode) { displayGauge.textAlignment = textAlignment; }

                Text uiText = displayGauge.CachedTextComponent;

                if (uiText != null) { uiText.alignment = textAlignment; }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeTextAlignment - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the font of the DisplayGauge Text component
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="font"></param>
        public void SetDisplayGaugeTextFont(DisplayGauge displayGauge, Font font)
        {
            if (displayGauge != null)
            {
                Text uiText = displayGauge.CachedTextComponent;

                if (uiText != null)
                {
                    uiText.font = font;
                }

                // If this is numeric gauge with a label, also set the label
                if (displayGauge.HasLabel && displayGauge.CachedLabelTextComponent != null)
                {
                    displayGauge.CachedLabelTextComponent.font = font;
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeTextFont - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the font style of the DisplayGauge Text component
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="font"></param>
        public void SetDisplayGaugeTextFontStyle(DisplayGauge displayGauge, FontStyle fontStyle)
        {
            if (displayGauge != null)
            {
                displayGauge.fontStyle = (DisplayGauge.DGFontStyle)fontStyle;

                Text uiText = displayGauge.CachedTextComponent;

                if (uiText != null)
                {
                    uiText.fontStyle = fontStyle;
                }

                // If this is numeric gauge with a label, also set the label
                if (displayGauge.HasLabel && displayGauge.CachedLabelTextComponent != null)
                {
                    displayGauge.CachedLabelTextComponent.fontStyle = fontStyle;
                }

            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeTextFontStyle - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the font size of the display gauge text. If isBestFit is false, maxSize is the font size set.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="isBestFit"></param>
        /// <param name="minSize"></param>
        /// <param name="maxSize"></param>
        public void SetDisplayGaugeTextFontSize(DisplayGauge displayGauge, bool isBestFit, int minSize, int maxSize)
        {
            if (displayGauge != null)
            {
                if (!editorMode)
                {
                    displayGauge.isBestFit = isBestFit;
                    displayGauge.fontMinSize = minSize;
                    displayGauge.fontMaxSize = maxSize;
                }

                Text uiText = displayGauge.CachedTextComponent;

                if (uiText != null)
                {
                    uiText.resizeTextForBestFit = isBestFit;
                    uiText.resizeTextMinSize = minSize;
                    uiText.resizeTextMaxSize = maxSize;
                    uiText.fontSize = maxSize;
                }

                // If this is numeric gauge with a label, also set the label
                if (displayGauge.HasLabel && displayGauge.CachedLabelTextComponent != null)
                {
                    Text uiLabelText = displayGauge.CachedLabelTextComponent;
                    uiLabelText.resizeTextForBestFit = isBestFit;
                    uiLabelText.resizeTextMinSize = minSize;
                    uiLabelText.resizeTextMaxSize = maxSize;
                    uiLabelText.fontSize = maxSize;
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeTextFontSize - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the Display Gauge text colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the gauge text with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayGaugeTextColour(DisplayGauge displayGauge, Color newColour)
        {
            if (displayGauge != null)
            {
                SSCUtils.UpdateColour(ref newColour, ref displayGauge.textColour, ref displayGauge.baseTextColour, true);

                SetDisplayGaugeTextBrightness(displayGauge);
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeTextColour - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Update the direction of the text within the gauge panel
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="textDirection"></param>
        public void SetDisplayGaugeTextDirection(DisplayGauge displayGauge, DisplayGauge.DGTextDirection textDirection)
        {
            if (displayGauge != null)
            {
                if (!editorMode) { displayGauge.textDirection = textDirection; }

                Text uiText = displayGauge.CachedTextComponent;
                Text uiLabelText = displayGauge.CachedLabelTextComponent;

                bool hasLabel = uiLabelText != null && displayGauge.HasLabel;

                if (uiText != null)
                {
                    #if UNITY_EDITOR
                    if (editorMode) { CheckHUDResize(false); }
                    #endif

                    float pixelWidth = displayGauge.displayWidth * cvsResolutionFull.x;
                    float pixelHeight = displayGauge.displayHeight * cvsResolutionFull.y;
                    float textRotation = 0f;

                    RectTransform dgTextRectTfrm = displayGauge.CachedTextComponent.rectTransform;
                    RectTransform dgLabelRectTfrm = hasLabel ? displayGauge.CachedLabelTextComponent.rectTransform : null;

                    if (textDirection == DisplayGauge.DGTextDirection.Horizontal)
                    {
                        if (hasLabel)
                        {
                            pixelHeight *= 0.5f;
                            dgLabelRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, pixelWidth);
                            dgLabelRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, pixelHeight);
                        }

                        dgTextRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, pixelWidth);
                        dgTextRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, pixelHeight);
                    }
                    else
                    {
                        if (textDirection == DisplayGauge.DGTextDirection.BottomTop)
                        {
                            textRotation = 90f;
                        }
                        else { textRotation = 270f; }

                        if (hasLabel)
                        {
                            pixelWidth *= 0.5f;
                            dgLabelRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, pixelHeight);
                            dgLabelRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, pixelWidth);
                        }

                        dgTextRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, pixelHeight);
                        dgTextRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, pixelWidth);
                    }

                    uiText.transform.localRotation = Quaternion.Euler(uiText.transform.localRotation.x, uiText.transform.localRotation.y, textRotation);

                    if (hasLabel)
                    {
                        uiLabelText.transform.localRotation = Quaternion.Euler(uiLabelText.transform.localRotation.x, uiLabelText.transform.localRotation.y, textRotation);

                        if (textDirection == DisplayGauge.DGTextDirection.Horizontal)
                        {
                            uiLabelText.transform.localPosition = new Vector3(0f, pixelHeight / 2f, 0f);
                            uiText.transform.localPosition = new Vector3(0f, -pixelHeight / 2f, 0f);
                        }
                        else if (textDirection == DisplayGauge.DGTextDirection.BottomTop)
                        {
                            uiLabelText.transform.localPosition = new Vector3(-pixelWidth / 2f, 0f, 0f);
                            uiText.transform.localPosition = new Vector3(pixelWidth / 2f, 0f, 0f);
                        }
                        else
                        {
                            uiLabelText.transform.localPosition = new Vector3(pixelWidth / 2f, 0f, 0f);
                            uiText.transform.localPosition = new Vector3(-pixelWidth / 2f, 0f, 0f);
                        }
                    }
                    else
                    {
                        // This will correct the position if the dev has (incorrectly) moved the panel manually in the scene
                        uiText.transform.localPosition = Vector3.zero;
                    }
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeTextRotation - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the Display Gauge foreground colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the gauge foreground with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayGaugeForegroundColour(DisplayGauge displayGauge, Color newColour)
        {
            if (displayGauge != null)
            {
                SSCUtils.UpdateColour(ref newColour, ref displayGauge.foregroundColour, ref displayGauge.baseForegroundColour, true);

                SetDisplayGaugeForegroundBrightness(displayGauge);
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeForegroundColour - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the Display Gauge foreground sprite. This is used to render the gauge value by partially filling it.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="newSprite"></param>
        public void SetDisplayGaugeForegroundSprite(DisplayGauge displayGauge, Sprite newSprite)
        {
            if (displayGauge != null)
            {
                displayGauge.foregroundSprite = newSprite;

                UnityEngine.UI.Image fgImg = displayGauge.CachedFgImgComponent;

                if (fgImg != null)
                {
                    fgImg.sprite = newSprite;
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeForegroundSprite - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the Display Gauge background colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the gauge background with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayGaugeBackgroundColour(DisplayGauge displayGauge, Color newColour)
        {
            if (displayGauge != null)
            {
                SSCUtils.UpdateColour(ref newColour, ref displayGauge.backgroundColour, ref displayGauge.baseBackgroundColour, true);

                SetDisplayGaugeBackgroundBrightness(displayGauge);
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeBackgroundColour - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the Display Gauge background sprite. This is used to render the background image of the gauge.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="newSprite"></param>
        public void SetDisplayGaugeBackgroundSprite(DisplayGauge displayGauge, Sprite newSprite)
        {
            if (displayGauge != null)
            {
                displayGauge.backgroundSprite = newSprite;

                UnityEngine.UI.Image bgImg = displayGauge.CachedBgImgComponent;

                if (bgImg != null)
                {
                    bgImg.sprite = newSprite;
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeBackgroundSprite - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Set the Display Gauge fill method. This determines how the gauge is filled
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="fillMethod"></param>
        public void SetDisplayGaugeFillMethod(DisplayGauge displayGauge, DisplayGauge.DGFillMethod fillMethod)
        {
            if (displayGauge != null)
            {
                UnityEngine.UI.Image fgImg = displayGauge.CachedFgImgComponent;

                if (fgImg != null)
                {
                    displayGauge.isFillMethodNone = displayGauge.fillMethod == DisplayGauge.DGFillMethod.None;

                    fgImg.fillMethod = displayGauge.isFillMethodNone ? Image.FillMethod.Horizontal : (UnityEngine.UI.Image.FillMethod)fillMethod;

                    // Refresh the gauge if case changing from/to Fill Method None.
                    SetDisplayGaugeValue(displayGauge, displayGauge.gaugeValue);
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeFillMethod - displayGauge is null"); }
            #endif
        }

        /// <summary>
        /// Sets whether or not the foreground and background sprites keep their original texture aspect ratio.
        /// This can be useful when creating circular gauges.
        /// </summary>
        /// <param name="displayGauge"></param>
        /// <param name="fillMethod"></param>
        public void SetDisplayGaugeKeepAspectRatio(DisplayGauge displayGauge, bool isKeepAspectRatio)
        {
            if (displayGauge != null)
            {
                UnityEngine.UI.Image fgImg = displayGauge.CachedFgImgComponent;
                UnityEngine.UI.Image bgImg = displayGauge.CachedBgImgComponent;

                if (fgImg != null)
                {
                    fgImg.preserveAspect = isKeepAspectRatio;
                }

                if (bgImg != null)
                {
                    bgImg.preserveAspect = isKeepAspectRatio;
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayGaugeKeepAspectRatio - displayGauge is null"); }
            #endif
        }
      
        /// <summary>
        /// Show the Display Gauge on the HUD. The HUD will automatically be shown if it is not already visible.
        /// </summary>
        /// <param name="guidHash"></param>
        public void ShowDisplayGauge(int guidHash)
        {
            DisplayGauge displayGauge = GetDisplayGauge(guidHash);
            if (displayGauge != null) { ShowOrHideGauge(displayGauge, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayGauge - Could not find gauge with guidHash: " + guidHash); }
            #endif
        }

        /// <summary>
        /// Show the Display Gauge on the HUD. The HUD will automatically be shown if it is not already visible.
        /// </summary>
        /// <param name="displayGauge"></param>
        public void ShowDisplayGauge(DisplayGauge displayGauge)
        {
            if (displayGauge != null) { ShowOrHideGauge(displayGauge, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayGauge - Could not find gauge - parameter was null"); }
            #endif
        }

        /// <summary>
        /// Show or turn on all Display Gauges. ShipDisplayModule must be initialised.
        /// The HUD will automatically be shown if it is not already visible.
        /// </summary>
        public void ShowDisplayGauges()
        {
            ShowOrHideGauges(true);
        }

        /// <summary>
        /// Create a new list if required
        /// </summary>
        public void ValidateGaugeList()
        {
            if (displayGaugeList == null) { displayGaugeList = new List<DisplayGauge>(1); }
        }

        #endregion

        #region Public API Methods - Heading

        /// <summary>
        /// Set the small sprite that will indicate or point to the heading on the HUD
        /// </summary>
        /// <param name="newSprite"></param>
        public void SetDisplayHeadingIndicatorSprite (Sprite newSprite)
        {
            headingIndicatorSprite = newSprite;

            if (headingIndicatorImg != null)
            {
                headingIndicatorImg.sprite = headingIndicatorSprite;
            }
        }

        /// <summary>
        /// Set the sprite that will mask the Display Heading scrollable sprite
        /// </summary>
        /// <param name="newSprite"></param>
        public void SetDisplayHeadingMaskSprite (Sprite newSprite)
        {
            headingMaskSprite = newSprite;

            if (headingMaskImg != null)
            {
                headingMaskImg.sprite = headingMaskSprite;
            }
        }

        /// <summary>
        /// Set the Display Heading small indicator colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the heading with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayHeadingIndicatorColour (Color newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref headingIndicatorColour, ref baseHeadingIndicatorColour, true);

            SetHeadingBrightness();
        }

        /// <summary>
        /// Set the Display Heading primary colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the heading with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayHeadingPrimaryColour (Color newColour)
        {
            SSCUtils.UpdateColour(ref newColour, ref headingPrimaryColour, ref baseHeadingPrimaryColour, true);

            SetHeadingBrightness();
        }

        /// <summary>
        /// Set the Display Heading scroll sprite.
        /// </summary>
        /// <param name="newSprite"></param>
        public void SetDisplayHeadingScrollSprite (Sprite newSprite)
        {
            headingScrollSprite = newSprite;

            if (headingScrollImg != null)
            {
                headingScrollImg.sprite = headingScrollSprite;
            }
        }

        /// <summary>
        /// Set the normalised size of the scrollable Display Heading.
        /// Currently height is always 1.0
        /// </summary>
        /// <param name="width"></param>
        /// <param name="height"></param>
        public void SetDisplayHeadingSize (float width, float height)
        {
            // Verify the width,height values are within range 0.1 to 1.
            if (width >= 0.1f && width <= 1f)
            {
                headingWidth = width;
            }

            headingHeight = 1f;

            if (IsInitialised || editorMode)
            {
                #if UNITY_EDITOR
                if (editorMode)
                {
                    CheckHUDResize(false);
                    UnityEditor.Undo.RecordObject(headingRectTfrm.transform, string.Empty);
                }
                #endif

                // Here we use the original (reference) HUD size as it doesn't need to be scaled in any way.
                // The parent HUD canvas is correctly scaled and sized to the actual monitor or device display.
                headingRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, headingWidth * cvsResolutionFull.x);
                headingRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, headingHeight * cvsResolutionFull.y);
            }
        }

         /// <summary>
        /// Set the normalised offset (position) of the Display Heading on the HUD.
        /// If the module has been initialised, this will also re-position the Display Heading.
        /// </summary>
        /// <param name="offsetX">Horizontal offset from centre. Range between -1 and 1</param>
        /// <param name="offsetY">Vertical offset from centre. Range between -1 and 1</param>
        public void SetDisplayHeadingOffset (float offsetX, float offsetY)
        {
            // Verify the x,y values are within range -1 to 1.
            if (offsetX >= -1f && offsetX <= 1f)
            {
                headingOffsetX = offsetX;
            }

            if (offsetY >= -1f && offsetY <= 1f)
            {
                headingOffsetY = offsetY;
            }

            if (IsInitialised || editorMode)
            {
                Transform hdgTrfm = headingRectTfrm.transform;

                #if UNITY_EDITOR
                if (editorMode)
                {
                    CheckHUDResize(false);
                    UnityEditor.Undo.RecordObject(hdgTrfm, string.Empty);
                }
                #endif

                // Use the scaled HUD size. This works in and out of play mode
                tempHeadingOffset.x = headingOffsetX * cvsResolutionHalf.x;
                tempHeadingOffset.y = headingOffsetY * cvsResolutionHalf.y;
                tempHeadingOffset.z = hdgTrfm.localPosition.z;

                hdgTrfm.localPosition = tempHeadingOffset;

                // Reset the position of the scrollable image
                if (headingScrollPanel != null)
                {
                    headingScrollPanel.localPosition = Vector3.zero;
                    headingInitPosition = headingScrollPanel.transform.position;

                    if (showHeadingIndicator && headingIndicatorPanel != null)
                    {
                        headingIndicatorPanel.localPosition = new Vector3(headingScrollPanel.localPosition.x, headingScrollPanel.localPosition.y - 20f, headingScrollPanel.localPosition.z);
                    }
                }
            }
        }

        /// <summary>
        /// Attempt to turn off the scrollable Heading
        /// </summary>
        public void HideHeading()
        {
            ShowOrHideHeading(false);
        }

        /// <summary>
        /// Attempt to turn off the Heading indicator
        /// </summary>
        public void HideHeadingIndicator()
        {
            ShowOrHideHeadingIndicator(false);
        }

        /// <summary>
        /// Attempt to show the scrollable Heading. Turn on HUD if required.
        /// </summary>
        public void ShowHeading()
        {
            ShowOrHideHeading(true);
        }

        /// <summary>
        /// Attempt to turn on the Heading indicator
        /// </summary>
        public void ShowHeadingIndicator()
        {
            ShowOrHideHeadingIndicator(true);
        }

        #endregion

        #region Public API Methods - Messages

        /// <summary>
        /// Add a new message to the HUD. By design, they are not visible at runtime when first added.
        /// </summary>
        /// <param name="messageName"></param>
        /// <param name="messageText"></param>
        /// <returns></returns>
        public DisplayMessage AddMessage(string messageName, string messageText)
        {
            DisplayMessage displayMessage = null;

            Canvas canvas = GetCanvas;
            hudRectTfrm = GetHUDPanel();

            if (canvas == null)
            {
                #if UNITY_EDITOR
                Debug.LogWarning("ERROR: ShipDisplayModule.AddMessage() - could not find canvas for the HUD. Did you use the prefab from Prefabs/Visuals folder?");
                #endif
            }
            else if (hudRectTfrm == null)
            {
                #if UNITY_EDITOR
                Debug.LogWarning("ERROR: ShipDisplayModule.AddMessage() - could not find HUDPanel for the HUD. Did you use the prefab from Prefabs/Visuals folder?");
                #endif
            }
            else
            {
                displayMessage = new DisplayMessage();
                if (displayMessage != null)
                {
                    displayMessage.messageName = messageName;
                    displayMessage.messageString = messageText;
                    ValidateMessageList();
                    displayMessageList.Add(displayMessage);

                    CreateMessagePanel(displayMessage, hudRectTfrm);

                    numDisplayMessages = displayMessageList.Count;
                 }
            }

            return displayMessage;
        }

        /// <summary>
        /// Add a message to the HUD using a displayMessage instance. Typically, this is used
        /// with CopyDisplayMessage(..).
        /// </summary>
        /// <param name="displayMessage"></param>
        public void AddMessage(DisplayMessage displayMessage)
        {
            if (displayMessage != null)
            {
                RectTransform hudRectTfrm = SSCUtils.GetChildRectTransform(transform, hudPanelName, this.name);

                if (hudRectTfrm == null)
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("ERROR: ShipDisplayModule.AddMessage() - could not find HUDPanel for the HUD. Did you use the prefab from Prefabs/Visuals folder?");
                    #endif
                }
                else
                {
                    ValidateMessageList();
                    displayMessageList.Add(displayMessage);

                    CreateMessagePanel(displayMessage, hudRectTfrm);

                    numDisplayMessages = displayMessageList.Count;
                }
            }
        }

        /// <summary>
        /// Delete a message from the HUD.
        /// NOTE: It is much cheaper to HideDisplayMessage(..) than completely remove it.
        /// </summary>
        /// <param name="guidHash"></param>
        public void DeleteMessage(int guidHash)
        {
            #if UNITY_EDITOR
            bool isRecordUndo = !Application.isPlaying;
            int undoGroup=0;
            #else
            bool isRecordUndo = false;
            #endif

            RectTransform msgRectTfrm = GetMessagePanel(guidHash, null);
            int _msgIndex = GetDisplayMessageIndex(guidHash);

            // Only record undo if in the editor AND is not playing AND something needs to be recorded
            isRecordUndo = isRecordUndo && (msgRectTfrm != null || _msgIndex >= 0);

            #if UNITY_EDITOR
            if (isRecordUndo)
            {
                UnityEditor.Undo.SetCurrentGroupName("Delete Display Message " + (_msgIndex + 1).ToString());
                undoGroup = UnityEditor.Undo.GetCurrentGroup();

                if (_msgIndex >= 0)
                {
                    UnityEditor.Undo.RecordObject(this, string.Empty);
                }
            }
            #endif

            // Check that the message exists and it is within the list constraints
            // NOTE: The script element must be modified BEFORE the Undo.DestroyObjectImmediate is called
            // in order for Undo to correctly undo both the message change AND the destroy of the panel.
            if (_msgIndex >= 0 && _msgIndex < (displayMessageList == null ? 0 : displayMessageList.Count))
            {
                displayMessageList.RemoveAt(_msgIndex);
                numDisplayMessages = displayMessageList.Count;
            }

            if (msgRectTfrm != null)
            {
                if (Application.isPlaying) { Destroy(msgRectTfrm.gameObject); }
                else
                {
                    #if UNITY_EDITOR
                    UnityEditor.Undo.DestroyObjectImmediate(msgRectTfrm.gameObject);
                    #else
                    DestroyImmediate(msgRectTfrm.gameObject);
                    #endif
                }
            }

            #if UNITY_EDITOR
            if (isRecordUndo)
            {               
                UnityEditor.Undo.CollapseUndoOperations(undoGroup);
            }
            #endif
        }

        /// <summary>
        /// Create a copy of an existing DisplayMessage, and give it a new name.
        /// Call AddMessage(newDisplayMessage) to make it useable in the game.
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="NameOfCopy"></param>
        /// <returns></returns>
        public DisplayMessage CopyDisplayMessage(DisplayMessage displayMessage, string NameOfCopy)
        {
            DisplayMessage dmCopy = new DisplayMessage(displayMessage);

            if (dmCopy != null)
            {
                // make it unique
                dmCopy.guidHash = SSCMath.GetHashCodeFromGuid();
                dmCopy.messageName = NameOfCopy;
            }
            return dmCopy;
        }

        /// <summary>
        /// Returns the guidHash of the Message in the list given the index or
        /// zero-based position in the list. Will return 0 if no matching Message
        /// is found.
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public int GetDisplayMessageGuidHash(int index)
        {
            int guidHash = 0;

            if (index >= 0 && index < GetNumberDisplayMessages)
            {
                if (displayMessageList[index] != null) { guidHash = displayMessageList[index].guidHash; }
            }

            return guidHash;
        }

        /// <summary>
        /// Get the zero-based index of the Message in the list. Will return -1 if not found.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <returns></returns>
        public int GetDisplayMessageIndex(int guidHash)
        {
            int index = -1;

            int _numDisplayMessages = GetNumberDisplayMessages;

            for (int dmIdx = 0; dmIdx < _numDisplayMessages; dmIdx++)
            {
                if (displayMessageList[dmIdx] != null && displayMessageList[dmIdx].guidHash == guidHash) { index = dmIdx; break; }
            }

            return index;
        }

        /// <summary>
        /// Get a DisplayMessage given its guidHash.
        /// See also GetDisplayMessageGuidHash(..).
        /// Will return null if guidHash parameter is 0, it cannot be found.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <returns></returns>
        public DisplayMessage GetDisplayMessage(int guidHash)
        {
            DisplayMessage displayMessage = null;
            DisplayMessage _tempDM = null;

            int _numDisplayMessages = GetNumberDisplayMessages;

            for (int dmIdx = 0; dmIdx < _numDisplayMessages; dmIdx++)
            {
                _tempDM = displayMessageList[dmIdx];
                if (_tempDM != null && _tempDM.guidHash == guidHash)
                {
                    displayMessage = _tempDM;
                    break;
                }
            }

            return displayMessage;
        }

        /// <summary>
        /// Get the display message give the description title of the message.
        /// WARNING: This will increase Garbage Collection (GC). Where possible
        /// use GetDisplayMessage(guidHash) and/or GetDisplayMessageGuidHash(index)
        /// </summary>
        /// <param name="displayMessageName"></param>
        /// <returns></returns>
        public DisplayMessage GetDisplayMessage(string displayMessageName)
        {
            DisplayMessage displayMessage = null;
            DisplayMessage _tempDM = null;

            if (!string.IsNullOrEmpty(displayMessageName))
            {
                int _numDisplayMessages = GetNumberDisplayMessages;

                for (int dmIdx = 0; dmIdx < _numDisplayMessages; dmIdx++)
                {
                    _tempDM = displayMessageList[dmIdx];
                    if (_tempDM != null && !string.IsNullOrEmpty(_tempDM.messageName))
                    {
                        if (_tempDM.messageName.ToLower() == displayMessageName.ToLower())
                        {
                            displayMessage = _tempDM;
                            break;
                        }
                    }
                }
            }
            return displayMessage;
        }

        /// <summary>
        /// Is the Display Message currently being shown on the HUD?
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <returns></returns>
        public bool IsDisplayMessageShown (DisplayMessage displayMessage)
        {
            if (displayMessage != null)
            {
                return IsHUDShown && displayMessage.showMessage;
            }
            else { return false; }
        }

        /// <summary>
        /// After adding or moving DisplayMessages, they may need to be sorted to
        /// have the correct z-order in on the HUD.
        /// </summary>
        public void RefreshMessagesSortOrder()
        {
            if (hudPanel != null)
            {
                // Messages should begin after index 1.
                int zIndex = 1;

                // Start messages after Altitude in hierarchy.
                if (overlayPanel != null) { zIndex = overlayPanel.GetSiblingIndex(); }

                int _numDisplayMessages = GetNumberDisplayMessages;

                for (int dmIdx = 0; dmIdx < _numDisplayMessages; dmIdx++)
                {
                    DisplayMessage displayMessage = displayMessageList[dmIdx];

                    if (displayMessage != null)
                    {
                        RectTransform _rt = displayMessage.CachedMessagePanel;

                        if (_rt != null)
                        {
                            _rt.SetSiblingIndex(++zIndex);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Import a json file from disk and return as DisplayMessage
        /// </summary>
        /// <param name="folderPath"></param>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public DisplayMessage ImportMessageFromJson (string folderPath, string fileName)
        {
            DisplayMessage displayMessage = null;

            if (!string.IsNullOrEmpty(folderPath) && !string.IsNullOrEmpty(fileName))
            {
                try
                {
                    string filePath = System.IO.Path.Combine(folderPath, fileName);
                    if (System.IO.File.Exists(filePath))
                    {
                        string jsonText = System.IO.File.ReadAllText(filePath);

                        displayMessage = new DisplayMessage();
                        int displayGaugeGuidHash = displayMessage.guidHash;

                        JsonUtility.FromJsonOverwrite(jsonText, displayMessage);

                        if (displayMessage != null)
                        {
                            // make hash code unique
                            displayMessage.guidHash = displayGaugeGuidHash;
                        }
                    }
                    #if UNITY_EDITOR
                    else
                    {
                        Debug.LogWarning("ERROR: Import Message. Could not find file at " + filePath);
                    }
                    #endif
                }
                catch (System.Exception ex)
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("ERROR: ShipDisplayModule - could not import message from: " + folderPath + " PLEASE REPORT - " + ex.Message);
                    #else
                    // Keep compiler happy
                    if (ex != null) { }
                    #endif
                }
            }

            return displayMessage;
        }

        /// <summary>
        /// Save the Message to a json file on disk.
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="filePath"></param>
        public bool SaveMessageAsJson (DisplayMessage displayMessage, string filePath)
        {
            bool isSuccessful = false;

            if (displayMessage != null && !string.IsNullOrEmpty(filePath))
            {
                try
                {
                    string jsonMessageData = JsonUtility.ToJson(displayMessage);

                    if (!string.IsNullOrEmpty(jsonMessageData) && !string.IsNullOrEmpty(filePath))
                    {
                        System.IO.File.WriteAllText(filePath, jsonMessageData);
                        isSuccessful = true;
                    }
                }
                catch (System.Exception ex)
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("ERROR: ShipDisplayModule SaveMessageAsJson - could not export: " + displayMessage.messageName + " PLEASE REPORT - " + ex.Message);
                    #else
                    // Keep compiler happy
                    if (ex != null) { }
                    #endif
                }
            }

            return isSuccessful;
        }

        /// <summary>
        /// Set the offset (position) of the Display Message on the HUD.
        /// If the module has been initialised, this will also re-position the Display Message.
        /// </summary>
        /// <param name="offsetX">Horizontal offset from centre. Range between -1 and 1</param>
        /// <param name="offsetY">Vertical offset from centre. Range between -1 and 1</param>
        public void SetDisplayMessageOffset(DisplayMessage displayMessage, float offsetX, float offsetY)
        {
            // Verify the x,y values are within range -1 to 1.
            if (offsetX >= -1f && offsetX <= 1f)
            {
                displayMessage.offsetX = offsetX;
            }

            if (offsetY >= -1f && offsetY <= 1f)
            {
                displayMessage.offsetY = offsetY;
            }

            if (IsInitialised || editorMode)
            {
                Transform dmTrfm = displayMessage.CachedMessagePanel.transform;

                #if UNITY_EDITOR
                if (editorMode)
                {
                    CheckHUDResize(false);
                    UnityEditor.Undo.RecordObject(dmTrfm, string.Empty);
                }
                #endif

                // Use original refResolution rather than the scaled size of the HUD. This works in and out of play mode
                //tempMessageOffset.x = displayMessage.offsetX * (refResolutionHalf.x - (displayMessage.displayWidth / 2f));
                //tempMessageOffset.y = displayMessage.offsetY * (refResolutionHalf.y - (displayMessage.displayHeight / 2f));

                // Use the scaled HUD size. This works in and out of play mode
                tempMessageOffset.x = displayMessage.offsetX * cvsResolutionHalf.x;
                tempMessageOffset.y = displayMessage.offsetY * cvsResolutionHalf.y;
                tempMessageOffset.z = dmTrfm.localPosition.z;

                dmTrfm.localPosition = tempMessageOffset;
            }
        }

        /// <summary>
        /// Set the size of the Message Panel.
        /// If the module has been initialised, this will also resize the Message Panel.
        /// The values are only updated if they are outside the range 0.0 to 1.0 or have changed.
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="width">Range between 0.0 and 1.0</param>
        /// <param name="height">Range between 0.0 and 1.0</param>
        public void SetDisplayMessageSize(DisplayMessage displayMessage, float width, float height)
        {
            // Clamp the x,y values 0.0 to 1.0
            if (width < 0f) { displayMessage.displayWidth = 0f; }
            else if (width > 1f) { displayMessage.displayWidth = 1f; }
            else if (width != displayMessage.displayWidth) { displayMessage.displayWidth = width; }

            if (height < 0f) { displayMessage.displayHeight = 0f; }
            else if (height > 1f) { displayMessage.displayHeight = 1f; }
            else if (height != displayMessage.displayHeight) { displayMessage.displayHeight = height; }

            if (IsInitialised || editorMode)
            {
                #if UNITY_EDITOR
                if (editorMode) { CheckHUDResize(false); }
                #endif

                RectTransform dmRectTfrm = displayMessage.CachedMessagePanel;    

                if (dmRectTfrm != null)
                {
                    // Here we use the original (reference) HUD size as it doesn't need to be scaled in any way.
                    // The parent HUD canvas is correctly scaled and sized to the actual monitor or device display.
                    dmRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, displayMessage.displayWidth * cvsResolutionFull.x);
                    dmRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, displayMessage.displayHeight * cvsResolutionFull.y);
                }

                if (displayMessage.CachedTextComponent != null)
                {
                    RectTransform dmTextRectTfrm = displayMessage.CachedTextComponent.rectTransform;

                    dmTextRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, displayMessage.displayWidth * cvsResolutionFull.x);
                    dmTextRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, displayMessage.displayHeight * cvsResolutionFull.y);
                }
            }
        }

        /// <summary>
        /// Update the text of the message
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="messageText"></param>
        public void SetDisplayMessageText(DisplayMessage displayMessage, string messageText)
        {
            if (displayMessage != null)
            {
                displayMessage.messageString = messageText;
                Text uiText = displayMessage.CachedTextComponent;

                if (uiText != null) { uiText.text = messageText; }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageText - displayMessage is null"); }
            #endif
        }

        /// <summary>
        /// Update the position of the text within the message panel
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="textAlignment"></param>
        public void SetDisplayMessageTextAlignment(DisplayMessage displayMessage, TextAnchor textAlignment)
        {
            if (displayMessage != null)
            {
                if (!editorMode) { displayMessage.textAlignment = textAlignment; }

                Text uiText = displayMessage.CachedTextComponent;

                if (uiText != null) { uiText.alignment = textAlignment; }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageTextAlignment - displayMessage is null"); }
            #endif
        }

        /// <summary>
        /// Set the font of the DisplayMessage Text component
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="font"></param>
        public void SetDisplayMessageTextFont(DisplayMessage displayMessage, Font font)
        {
            if (displayMessage != null)
            {
                Text uiText = displayMessage.CachedTextComponent;

                if (uiText != null)
                {
                    uiText.font = font;
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageTextFont - displayMessage is null"); }
            #endif
        }

        /// <summary>
        /// Set the font size of the display message text. If isBestFit is false, maxSize is the font size set.
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="isBestFit"></param>
        /// <param name="minSize"></param>
        /// <param name="maxSize"></param>
        public void SetDisplayMessageTextFontSize(DisplayMessage displayMessage, bool isBestFit, int minSize, int maxSize)
        {
            if (displayMessage != null)
            {
                if (!editorMode)
                {
                    displayMessage.isBestFit = isBestFit;
                    displayMessage.fontMinSize = minSize;
                    displayMessage.fontMaxSize = maxSize;
                }

                Text uiText = displayMessage.CachedTextComponent;

                if (uiText != null)
                {
                    uiText.resizeTextForBestFit = isBestFit;
                    uiText.resizeTextMinSize = minSize;
                    uiText.resizeTextMaxSize = maxSize;
                    uiText.fontSize = maxSize;
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageTextFontSize - displayMessage is null"); }
            #endif
        }

        /// <summary>
        /// Set the Display Message background colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the message background with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayMessageBackgroundColour(DisplayMessage displayMessage, Color newColour)
        {
            if (displayMessage != null)
            {
                SSCUtils.UpdateColour(ref newColour, ref displayMessage.backgroundColour, ref displayMessage.baseBackgroundColour, true);

                SetDisplayMessageBackgroundBrightness(displayMessage);
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageBackgroundColour - displayMessage is null"); }
            #endif
        }

        /// <summary>
        /// Set the Display Message scroll direction.
        /// USAGE: SetDisplayMessageScrollDirection(displayMessage, DisplayMessage.ScrollDirectionLR)
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="scrollDirection"></param>
        public void SetDisplayMessageScrollDirection(DisplayMessage displayMessage, int scrollDirection)
        {
            if (displayMessage != null)
            {
                if (scrollDirection >= 0 && scrollDirection < 5)
                {
                    displayMessage.scrollDirectionInt = scrollDirection;
                    displayMessage.scrollDirection = (DisplayMessage.ScrollDirection)scrollDirection;
                    if (scrollDirection == DisplayMessage.ScrollDirectionNone)
                    {
                        displayMessage.scrollOffsetX = 0f;
                        displayMessage.scrollOffsetY = 0f;
                        SetDisplayMessageOffset(displayMessage, displayMessage.offsetX, displayMessage.offsetY);
                    }
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageScrollDirection - displayMessage is null"); }
            #endif
        }

        /// <summary>
        /// Set the Display Message to scroll across or up/down the full screen regardless of the message width and height.
        /// Can also be set directly with displayMessage.isScrollFullscreen = true;
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="isScrollFullscreen"></param>
        public void SetDisplayMessageScrollFullscreen(DisplayMessage displayMessage, bool isScrollFullscreen)
        {
            if (displayMessage != null) { displayMessage.isScrollFullscreen = isScrollFullscreen; }
        }

        /// <summary>
        /// Set the Display Message scroll speed.
        /// Can also be set directly with displayMessage.scrollSpeed = scrollSpeed;
        /// </summary>
        /// <param name="displayMessage"></param>
        /// <param name="scrollSpeed"></param>
        public void SetDisplayMessageScrollSpeed(DisplayMessage displayMessage, float scrollSpeed)
        {
            if (displayMessage != null) { displayMessage.scrollSpeed = scrollSpeed; }
        }

        /// <summary>
        /// Set the Display Message text colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the message text with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayMessageTextColour(DisplayMessage displayMessage, Color newColour)
        {
            if (displayMessage != null)
            {
                SSCUtils.UpdateColour(ref newColour, ref displayMessage.textColour, ref displayMessage.baseTextColour, true);

                SetDisplayMessageTextBrightness(displayMessage);
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayMessageTextColour - displayMessage is null"); }
            #endif
        }

        /// <summary>
        /// Show the Display Message on the HUD. The HUD will automatically be shown if it is not already visible.
        /// </summary>
        /// <param name="guidHash"></param>
        public void ShowDisplayMessage (int guidHash)
        {
            DisplayMessage displayMessage = GetDisplayMessage(guidHash);
            if (displayMessage != null) { ShowOrHideMessage(displayMessage, true, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayMessage - Could not find message with guidHash: " + guidHash); }
            #endif
        }

        /// <summary>
        /// Show the Display Message on the HUD. The HUD will automatically be shown if it is not already visible.
        /// </summary>
        /// <param name="displayMessage"></param>
        public void ShowDisplayMessage (DisplayMessage displayMessage)
        {
            if (displayMessage != null) { ShowOrHideMessage(displayMessage, true, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayMessage - Could not find message - parameter was null"); }
            #endif
        }

        /// <summary>
        /// Show the Display Message on the HUD instantly by ignoring fade settings. The HUD will automatically be shown if it is not already visible.
        /// </summary>
        /// <param name="guidHash"></param>
        public void ShowDisplayMessageInstant (int guidHash)
        {
            DisplayMessage displayMessage = GetDisplayMessage(guidHash);
            if (displayMessage != null) { ShowOrHideMessage(displayMessage, true, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayMessageInstant - Could not find message with guidHash: " + guidHash); }
            #endif
        }

        /// <summary>
        /// Show the Display Message on the HUD instantly by ignoring fade settings. The HUD will automatically be shown if it is not already visible.
        /// </summary>
        /// <param name="displayMessage"></param>
        public void ShowDisplayMessageInstant (DisplayMessage displayMessage)
        {
            if (displayMessage != null) { ShowOrHideMessage(displayMessage, true, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayMessageInstant - Could not find message - parameter was null"); }
            #endif
        }

        /// <summary>
        /// Show or turn on all Display Messages. ShipDisplayModule must be initialised.
        /// The HUD will automatically be shown if it is not already visible.
        /// </summary>
        public void ShowDisplayMessages()
        {
            ShowOrHideMessages(true, false);
        }

        /// <summary>
        /// Show the Display Message background on the HUD. The display the actual message, you would
        /// need to call ShowDisplayMessage(..).
        /// </summary>
        /// <param name="displayMessage"></param>
        public void ShowDisplayMessageBackground(DisplayMessage displayMessage)
        {
            if (displayMessage != null) { ShowOrHideDisplayMessageBackground(displayMessage, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayMessageBackground - Could not find message - parameter was null"); }
            #endif
        }

        /// <summary>
        /// Hide or turn off the Display Message
        /// </summary>
        /// <param name="guidHash"></param>
        public void HideDisplayMessage(int guidHash)
        {
            DisplayMessage displayMessage = GetDisplayMessage(guidHash);
            if (displayMessage != null) { ShowOrHideMessage(displayMessage, false, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayMessage - Could not find message with guidHash: " + guidHash); }
            #endif
        }

        /// <summary>
        /// Hide or turn off the Display Message
        /// </summary>
        /// <param name="displayMessage"></param>
        public void HideDisplayMessage (DisplayMessage displayMessage)
        {
            if (displayMessage != null) { ShowOrHideMessage(displayMessage, false, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayMessage - Could not find message - parameter was null"); }
            #endif
        }

        /// <summary>
        /// Hide or turn off the Display Message instantly and ignore any fade-out settings.
        /// </summary>
        /// <param name="guidHash"></param>
        public void HideDisplayMessageInstant (int guidHash)
        {
            DisplayMessage displayMessage = GetDisplayMessage(guidHash);
            if (displayMessage != null) { ShowOrHideMessage(displayMessage, false, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayMessageInstant - Could not find message with guidHash: " + guidHash); }
            #endif
        }

        /// <summary>
        /// Hide or turn off the Display Message instantly and ignore any fade-out settings.
        /// </summary>
        /// <param name="displayMessage"></param>
        public void HideDisplayMessageInstant (DisplayMessage displayMessage)
        {
            if (displayMessage != null) { ShowOrHideMessage(displayMessage, false, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayMessageInstant - Could not find message - parameter was null"); }
            #endif
        }

        /// <summary>
        /// Hide or turn off all Display Messages.
        /// ShipDisplayModule must be initialised.
        /// </summary>
        public void HideDisplayMessages()
        {
            ShowOrHideMessages(false, false);
        }

        /// <summary>
        /// Hide the Display Message background on the HUD. The hide the actual message, you would
        /// need to call HideDisplayMessage(..).
        /// </summary>
        /// <param name="displayMessage"></param>
        public void HideDisplayMessageBackground(DisplayMessage displayMessage)
        {
            if (displayMessage != null) { ShowOrHideDisplayMessageBackground(displayMessage, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: HideDisplayMessageBackground - Could not find message - parameter was null"); }
            #endif
        }

        /// <summary>
        /// Create a new list if required
        /// </summary>
        public void ValidateMessageList()
        {
            if (displayMessageList == null) { displayMessageList = new List<DisplayMessage>(1); }
        }

        #endregion

        #region Public API Methods - Targets

        /// <summary>
        /// Add a new Display Target to the HUD. By design, they are not visible at runtime when first added.
        /// </summary>
        /// <param name="guidHashDisplayReticle"></param>
        /// <returns></returns>
        public DisplayTarget AddTarget(int guidHashDisplayReticle)
        {
            DisplayTarget displayTarget = null;

            if (GetHUDPanel() == null)
            {
                #if UNITY_EDITOR
                Debug.LogWarning("ERROR: ShipDisplayModule.AddTarget() - could not find HUDPanel for the HUD. Did you use the prefab from Prefabs/Visuals folder?");
                #endif
            }
            else
            {
                displayTarget = new DisplayTarget();
                if (displayTarget != null)
                {
                    displayTarget.guidHashDisplayReticle = guidHashDisplayReticle;

                    ValidateTargetList();
                    displayTargetList.Add(displayTarget);

                    numDisplayTargets = displayTargetList.Count;

                    RectTransform targetSlotPanel = CreateTargetPanel(displayTarget, 0);
                    if (targetSlotPanel != null)
                    {
                        #if UNITY_EDITOR
                        // Make sure we can rollback the creation of the new target panel for this slot
                        UnityEditor.Undo.RegisterCreatedObjectUndo(targetSlotPanel.gameObject, string.Empty);
                        #endif
                    }
                }
            }
            return displayTarget;
        }

        /// <summary>
        /// Add another DisplayTarget slot to a DisplayTarget. This allows you to display another
        /// copy of the target on the HUD.
        /// If the DisplayTarget has not been initialised, the new slot panel will be added to the
        /// scene but this method will return null.
        /// This automatically updates displayTarget.maxNumberOfTargets.
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <param name="numberToAdd"></param>
        /// <returns></returns>
        public DisplayTargetSlot AddTargetSlots(DisplayTarget displayTarget, int numberToAdd)
        {
            DisplayTargetSlot displayTargetSlot = null;

            if (displayTarget != null)
            {
                if (displayTarget.maxNumberOfTargets + numberToAdd <= DisplayTarget.MAX_DISPLAYTARGET_SLOTS)
                {
                    int numberAdded = 0;

                    // slotIndex is zero-based so start to 1 beyond the end of the existing list
                    for (int slotIndex = displayTarget.maxNumberOfTargets; slotIndex < displayTarget.maxNumberOfTargets + numberToAdd; slotIndex++)
                    {
                        RectTransform targetSlotPanel = CreateTargetPanel(displayTarget, slotIndex);

                        // If the DisplayTarget has already been initialised, this slot will need to be initialised
                        if (targetSlotPanel != null)
                        {
                            numberAdded++;

                            #if UNITY_EDITOR
                            // Make sure we can rollback the creation of the new target panel for this slot
                            UnityEditor.Undo.RegisterCreatedObjectUndo(targetSlotPanel.gameObject, string.Empty);
                            #endif

                            if (displayTarget.isInitialised)
                            {
                                displayTargetSlot = InitialiseTargetSlot(displayTarget, slotIndex);
                                displayTarget.displayTargetSlotList.Add(displayTargetSlot);

                                // Refresh the size of the slot reticle panel
                                #if UNITY_EDITOR
                                if (editorMode) { CheckHUDResize(false); }
                                #endif

                                RectTransform dtRectTfrm = displayTargetSlot.CachedTargetPanel;
                                if (dtRectTfrm != null)
                                {
                                    float pixelWidth = (float)displayTarget.width * screenResolution.x / refResolution.x;
                                    float pixelHeight = (float)displayTarget.height * screenResolution.y / refResolution.y;

                                    // Target size is in pixels - this will result in non-square scaling.
                                    // (Future) provide an option to keep aspect ratio of original 64x64 reticle
                                    dtRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, pixelWidth);
                                    dtRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, pixelHeight);
                                }

                                // Refresh brightness of this slot
                                if (displayTargetSlot.CachedImgComponent != null)
                                {
                                    if (brightness == 1f) { displayTargetSlot.CachedImgComponent.color = displayTarget.reticleColour; }
                                    else { displayTargetSlot.CachedImgComponent.color = displayTarget.baseReticleColour.GetColorWithBrightness(brightness); }
                                }
                            }
                        }
                    }
                    displayTarget.maxNumberOfTargets += numberAdded;
                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("WARNING: shipDisplayModule.AddTargetSlot - not enough empty DisplayTarget slots"); }
                #endif
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.AddTargetSlot - displayTarget is null"); }
            #endif

            return displayTargetSlot;
        }

        /// <summary>
        /// Delete a target from the HUD.
        /// NOTE: It is much cheaper to HideDisplayTarget(..) than completely remove it.
        /// </summary>
        /// <param name="guidHash"></param>
        public void DeleteTarget(int guidHash)
        {
            #if UNITY_EDITOR
            bool isRecordUndo = !Application.isPlaying;
            int undoGroup=0;
            #else
            bool isRecordUndo = false;
            #endif

            DisplayTarget displayTarget = GetDisplayTarget(guidHash);

            List<RectTransform> tgtRectTfrmList = null;

            // Get a list of DisplayTarget slot panels
            if (displayTarget != null)
            {
                tgtRectTfrmList = new List<RectTransform>(displayTarget.maxNumberOfTargets);
                for (int sIdx = 0; sIdx < displayTarget.maxNumberOfTargets; sIdx++)
                {
                    RectTransform tgtRectTfrm = GetTargetPanel(guidHash, sIdx);
                    if (tgtRectTfrm != null)
                    {
                        tgtRectTfrmList.Add(tgtRectTfrm);
                    }
                }
            }

            int _numPanels = tgtRectTfrmList == null ? 0 : tgtRectTfrmList.Count;
            int _tgtIndex = GetDisplayTargetIndex(guidHash);

            // Only record undo if in the editor AND is not playing AND something needs to be recorded
            isRecordUndo = isRecordUndo && (_numPanels > 0 || _tgtIndex >= 0);

            #if UNITY_EDITOR
            if (isRecordUndo)
            {
                UnityEditor.Undo.SetCurrentGroupName("Delete Display Target " + (_tgtIndex + 1).ToString());
                undoGroup = UnityEditor.Undo.GetCurrentGroup();

                if (_tgtIndex >= 0)
                {
                    UnityEditor.Undo.RecordObject(this, string.Empty);
                }
            }
            #endif

            // Check that the display target exists and it is within the list constraints
            // NOTE: The script element must be modified BEFORE the Undo.DestroyObjectImmediate is called
            // in order for Undo to correctly undo both the target change AND the destroy of the panels.
            if (_tgtIndex >= 0 && _tgtIndex < (displayTargetList == null ? 0 : displayTargetList.Count))
            {
                displayTargetList.RemoveAt(_tgtIndex);
                numDisplayTargets = displayTargetList.Count;
            }

            if (_numPanels > 0)
            {
                if (Application.isPlaying)
                {
                    // Destroy all the slot panels
                    for (int sIdx = _numPanels - 1; sIdx >= 0; sIdx--)
                    {
                        Destroy(tgtRectTfrmList[sIdx].gameObject);
                        tgtRectTfrmList.RemoveAt(sIdx);
                    }
                }
                else
                {
                    // Destroy all the slot panels
                    for (int sIdx = _numPanels - 1; sIdx >= 0; sIdx--)
                    {
                        #if UNITY_EDITOR
                        UnityEditor.Undo.DestroyObjectImmediate(tgtRectTfrmList[sIdx].gameObject);
                        #else
                        DestroyImmediate(tgtRectTfrmList[sIdx].gameObject);
                        #endif
                        tgtRectTfrmList.RemoveAt(sIdx);
                    }
                }
            }

            #if UNITY_EDITOR
            if (isRecordUndo)
            {               
                UnityEditor.Undo.CollapseUndoOperations(undoGroup);
            }
            #endif
        }

        /// <summary>
        /// Delete or remove a DisplayTarget slot from the HUD. This is an expensive operation.
        /// It is much cheaper to HideDisplayTargetSlot(..) than completely remove it.
        /// Automatically updates displayTarget.maxNumberOfTargets.
        /// NOTE: You cannot remove slot 0.
        /// </summary>
        /// <param name="guidHash">guidHash of the DisplayTarget</param>
        /// <returns></returns>
        public void DeleteTargetSlots(int guidHash, int numberToDelete)
        {
            DisplayTarget displayTarget = GetDisplayTarget(guidHash);

            if (displayTarget != null)
            {
                int remainingTargets = displayTarget.maxNumberOfTargets - numberToDelete;

                if (remainingTargets > 0)
                {
                    #if UNITY_EDITOR
                    bool isRecordUndo = !Application.isPlaying;
                    int undoGroup=0;
                    #else
                    bool isRecordUndo = false;
                    #endif

                    List<RectTransform> tgtRectTfrmList = null;

                    // Get a list of DisplayTarget slot panels to remove
                    if (displayTarget != null)
                    {
                        tgtRectTfrmList = new List<RectTransform>(displayTarget.maxNumberOfTargets);
                        for (int sIdx = remainingTargets; sIdx < displayTarget.maxNumberOfTargets; sIdx++)
                        {
                            RectTransform tgtRectTfrm = GetTargetPanel(guidHash, sIdx);
                            if (tgtRectTfrm != null)
                            {
                                tgtRectTfrmList.Add(tgtRectTfrm);
                            }
                        }
                    }

                    int _numPanels = tgtRectTfrmList == null ? 0 : tgtRectTfrmList.Count;
                    int _tgtIndex = GetDisplayTargetIndex(guidHash);

                    // Only record undo if in the editor AND is not playing AND something needs to be recorded
                    isRecordUndo = isRecordUndo && (_numPanels > 0 || _tgtIndex >= 0);

                    #if UNITY_EDITOR
                    if (isRecordUndo)
                    {
                        UnityEditor.Undo.SetCurrentGroupName("Delete Display Target " + (_tgtIndex + 1).ToString() + " slots");
                        undoGroup = UnityEditor.Undo.GetCurrentGroup();

                        if (_tgtIndex >= 0)
                        {
                            UnityEditor.Undo.RecordObject(this, string.Empty);
                        }
                    }
                    #endif

                    // NOTE: The script element must be modified BEFORE the Undo.DestroyObjectImmediate is called
                    // in order for Undo to correctly undo both the target change AND the destroy of the panels.
                    if (displayTarget.isInitialised)
                    {
                        for (int sIdx = displayTarget.maxNumberOfTargets - 1; sIdx >= remainingTargets; sIdx--)
                        {
                            if (sIdx < displayTarget.displayTargetSlotList.Count)
                            {
                                displayTarget.displayTargetSlotList[sIdx] = null;
                                displayTarget.displayTargetSlotList.RemoveAt(sIdx);
                            }
                            #if UNITY_EDITOR
                            else { Debug.LogWarning("ERROR: shipDisplayModule.DeleteTargetSlot - tried to remove initialised slot " + sIdx + " but only " + displayTarget.displayTargetSlotList.Count + " exist."); }
                            #endif
                        }
                    }

                    displayTarget.maxNumberOfTargets = remainingTargets;

                    if (_numPanels > 0)
                    {
                        if (Application.isPlaying)
                        {
                            // Destroy the slot panels
                            for (int sIdx = _numPanels - 1; sIdx >= 0; sIdx--)
                            {
                                Destroy(tgtRectTfrmList[sIdx].gameObject);
                                tgtRectTfrmList.RemoveAt(sIdx);
                            }
                        }
                        else
                        {
                            // Destroy the slot panels
                            for (int sIdx = _numPanels - 1; sIdx >= 0; sIdx--)
                            {
                                #if UNITY_EDITOR
                                UnityEditor.Undo.DestroyObjectImmediate(tgtRectTfrmList[sIdx].gameObject);
                                #else
                                DestroyImmediate(tgtRectTfrmList[sIdx].gameObject);
                                #endif
                                tgtRectTfrmList.RemoveAt(sIdx);
                            }
                        }
                    }

                    #if UNITY_EDITOR
                    if (isRecordUndo)
                    {               
                        UnityEditor.Undo.CollapseUndoOperations(undoGroup);
                    }
                    #endif

                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("WARNING: shipDisplayModule.DeleteTargetSlot - cannot delete that many DisplayTarget slots"); }
                #endif
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.DeleteTargetSlot - displayTarget cannot be found with guidHash: " + guidHash); }
            #endif
        }

        /// <summary>
        /// Assign a radar target to a DisplayTarget's slot.
        /// See also GetAssignedDisplayTarget(..)
        /// </summary>
        /// <param name="displayTargetIndex"></param>
        /// <param name="instanceIndex"></param>
        /// <param name="radarItemIndex"></param>
        /// <param name="radarItemSequenceNumber"></param>
        public void AssignDisplayTargetSlot(int displayTargetIndex, int slotIndex, int radarItemIndex, uint radarItemSequenceNumber, bool isAutoShow)
        {
            if (displayTargetIndex >= 0 && displayTargetIndex < GetNumberDisplayTargets)
            {
                DisplayTarget displayTarget = displayTargetList[displayTargetIndex];
                if (displayTarget != null && slotIndex >= 0 && slotIndex < displayTarget.maxNumberOfTargets)
                {
                    DisplayTargetSlot displayTargetSlot = displayTarget.displayTargetSlotList[slotIndex];

                    displayTargetSlot.radarItemKey.radarItemIndex = radarItemIndex;
                    displayTargetSlot.radarItemKey.radarItemSequenceNumber = radarItemSequenceNumber;

                    if (isAutoShow)
                    {
                        // Should the DisplayTarget be shown?
                        if (radarItemIndex >= 0)
                        {
                            // If not already shown, turn it on.
                            if (!displayTargetSlot.showTargetSlot)
                            {
                                ShowOrHideTargetSlot(displayTargetSlot, true);
                                // If one slot is on, mark the displayTarget as shown also.
                                displayTarget.showTarget = true;
                            }
                        }
                        // If should not be shown, but currently is, turn it off
                        else if (displayTargetSlot.showTargetSlot) { ShowOrHideTargetSlot(displayTargetSlot, false); }
                    }
                }
            }
        }

        /// <summary>
        /// Get the radarItemKey for a DisplayTarget's slot.
        /// SSCRadarItemKey.radarItemIndex will be -1 if there is no target.
        /// </summary>
        /// <param name="displayTargetIndex"></param>
        /// <param name="slotIndex"></param>
        /// <returns></returns>
        public SSCRadarItemKey GetAssignedDisplayTarget(int displayTargetIndex, int slotIndex)
        {
            if (displayTargetIndex >= 0 && displayTargetIndex < GetNumberDisplayTargets)
            {
                DisplayTarget displayTarget = displayTargetList[displayTargetIndex];
                if (displayTarget != null && slotIndex >= 0 && slotIndex < displayTarget.maxNumberOfTargets)
                {
                    return displayTarget.displayTargetSlotList[slotIndex].radarItemKey;
                }
                else
                {
                    return new SSCRadarItemKey() { radarItemIndex = -1, radarItemSequenceNumber = 0 };
                }
            }
            else { return new SSCRadarItemKey() { radarItemIndex = -1, radarItemSequenceNumber = 0 }; }
        }

        /// <summary>
        /// Get the SSCRadarItem currently assigned to a DisplayTarget slot (instance).
        /// </summary>
        /// <param name="displayTargetSlot"></param>
        /// <returns></returns>
        public SSCRadarItem GetAssignedDisplayTargetRadarItem (DisplayTargetSlot displayTargetSlot)
        {
            if (displayTargetSlot != null && displayTargetSlot.radarItemKey.radarItemIndex >= 0 && sscRadar != null)
            {
                return sscRadar.GetRadarItem(displayTargetSlot.radarItemKey.radarItemIndex);
            }
            else { return null; }
        }

        /// <summary>
        /// Returns the guidHash of the Target in the list given the index or
        /// zero-based position in the list. Will return 0 if no matching Target
        /// is found.
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public int GetDisplayTargetGuidHash(int index)
        {
            int guidHash = 0;

            if (index >= 0 && index < GetNumberDisplayTargets)
            {
                if (displayTargetList[index] != null) { guidHash = displayTargetList[index].guidHash; }
            }

            return guidHash;
        }

        /// <summary>
        /// Get the zero-based index of the Target in the list. Will return -1 if not found.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <returns></returns>
        public int GetDisplayTargetIndex(int guidHash)
        {
            int index = -1;

            int _numDisplayTargets = GetNumberDisplayTargets;

            for (int dmIdx = 0; dmIdx < _numDisplayTargets; dmIdx++)
            {
                if (displayTargetList[dmIdx] != null && displayTargetList[dmIdx].guidHash == guidHash) { index = dmIdx; break; }
            }

            return index;
        }

        /// <summary>
        /// Get a DisplayTarget given its guidHash.
        /// See also GetDisplayTargetGuidHash(..).
        /// Will return null if guidHash parameter is 0, it cannot be found.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <returns></returns>
        public DisplayTarget GetDisplayTarget(int guidHash)
        {
            DisplayTarget displayTarget = null;
            DisplayTarget _tempDM = null;

            int _numDisplayTargets = GetNumberDisplayTargets;

            for (int dmIdx = 0; dmIdx < _numDisplayTargets; dmIdx++)
            {
                _tempDM = displayTargetList[dmIdx];
                if (_tempDM != null && _tempDM.guidHash == guidHash)
                {
                    displayTarget = _tempDM;
                    break;
                }
            }

            return displayTarget;
        }

        /// <summary>
        /// Get a DisplayTarget given a zero-based index in the list.
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public DisplayTarget GetDisplayTargetByIndex(int index)
        {
            if (index >= 0 && index < GetNumberDisplayTargets)
            {
                return displayTargetList[index];
            }
            else { return null; }
        }

        /// <summary>
        /// Get the (sprite) name of the DisplayTarget.
        /// WARNING: This will create GC, so not recommended to be called each frame.
        /// This is typically used for debugging purposes only.
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <returns></returns>
        public string GetDisplayTargetName(DisplayTarget displayTarget)
        {
            if (displayTarget != null && displayReticleList != null)
            {
                int _selectedIdx = displayReticleList.FindIndex(dr => dr.guidHash == displayTarget.guidHashDisplayReticle);

                if (_selectedIdx >= 0)
                {
                    string tempDisplayReticleName = displayReticleList[_selectedIdx].primarySprite == null ? "no texture in reticle" : displayReticleList[_selectedIdx].primarySprite.name;
                    return string.IsNullOrEmpty(tempDisplayReticleName) ? "no texture name" : tempDisplayReticleName;
                }
                else { return "--"; }
            }
            else { return "--"; }
        }

        /// <summary>
        /// Get the (sprite) name of the DisplayTarget.
        /// WARNING: This will create GC, so not recommended to be called each frame.
        /// This is typically used for debugging purposes only.
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public string GetDisplayTargetName(int index)
        {
            return GetDisplayTargetName(GetDisplayTargetByIndex(index));            
        }

        /// <summary>
        /// Get a DisplayTargetSlot given the zero-based slot index. This is an instance of a DisplayTarget.
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <param name="slotIndex"></param>
        /// <returns></returns>
        public DisplayTargetSlot GetDisplayTargetSlotByIndex (DisplayTarget displayTarget, int slotIndex)
        {
            if (IsInitialised && displayTarget != null && slotIndex > -1 && slotIndex < displayTarget.maxNumberOfTargets)
            {
                return displayTarget.displayTargetSlotList[slotIndex];
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// Show the Display Target slots on the HUD. By design, if the HUD is not shown, the Targets will not be show.
        /// </summary>
        /// <param name="guidHash"></param>
        public void ShowDisplayTarget(int guidHash)
        {
            DisplayTarget displayTarget = GetDisplayTarget(guidHash);
            if (displayTarget != null) { ShowOrHideTarget(displayTarget, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayTarget - Could not find displayTarget with guidHash: " + guidHash); }
            #endif
        }

        /// <summary>
        /// Show the Display Target slots on the HUD. By design, if the HUD is not shown, the Targets will not be show.
        /// </summary>
        /// <param name="displayTarget"></param>
        public void ShowDisplayTarget(DisplayTarget displayTarget)
        {
            if (displayTarget != null) { ShowOrHideTarget(displayTarget, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayTarget - displayTarget parameter was null"); }
            #endif
        }

        /// <summary>
        /// Show the Display Target slot on the HUD. By design, if the HUD is not shown, the Target in this slot will not be show.
        /// </summary>
        /// <param name="displayTargetSlot"></param>
        public void ShowDisplayTargetSlot(DisplayTargetSlot displayTargetSlot)
        {
            if (displayTargetSlot != null) { ShowOrHideTargetSlot(displayTargetSlot, true); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayTargetSlot - displayTargetSlot parameter was null"); }
            #endif
        }

        /// <summary>
        /// Show or turn on all Display Targets.
        /// ShipDisplayModule must be initialised.
        /// </summary>
        public void ShowDisplayTargets()
        {
            ShowOrHideTargets(true);
        }

        /// <summary>
        /// Hide or turn off all slots the Display Target
        /// </summary>
        /// <param name="guidHash"></param>
        public void HideDisplayTarget(int guidHash)
        {
            DisplayTarget displayTarget = GetDisplayTarget(guidHash);
            if (displayTarget != null) { ShowOrHideTarget(displayTarget, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayTarget - Could not find message with guidHash: " + guidHash); }
            #endif
        }

        /// <summary>
        /// Hide or turn off all slots of the Display Target
        /// </summary>
        /// <param name="displayTarget"></param>
        public void HideDisplayTarget(DisplayTarget displayTarget)
        {
            if (displayTarget != null) { ShowOrHideTarget(displayTarget, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: ShowDisplayTarget - Could not find message - parameter was null"); }
            #endif
        }

        /// <summary>
        /// Hide the Display Target slot on the HUD. By design, if the HUD is not shown, the Target in this slot will not be show.
        /// </summary>
        /// <param name="displayTargetSlot"></param>
        public void HideDisplayTargetSlot(DisplayTargetSlot displayTargetSlot)
        {
            if (displayTargetSlot != null) { ShowOrHideTargetSlot(displayTargetSlot, false); }
            #if UNITY_EDITOR
            else { Debug.LogWarning("WARNING: HideDisplayTargetSlot - displayTargetSlot parameter was null"); }
            #endif
        }

        /// <summary>
        /// Hide or turn off all all slots of all Display Targets.
        /// ShipDisplayModule must be initialised.
        /// </summary>
        public void HideDisplayTargets()
        {
            ShowOrHideTargets(false);
        }

        /// <summary>
        /// Given a radar query, add rules based on the current DisplayTargets.
        /// TODO - WARNING - NEED TO PERFORMANCE TEST THIS
        /// </summary>
        public void PopulateTargetingRadarQuery(SSCRadarQuery sscRadarQuery)
        {
            // Build a common list of factions and squadrons to include
            if (IsInitialised)
            {
                int _numDisplayTargets = GetNumberDisplayTargets;

                if (_numDisplayTargets > 0)
                {
                    tempIncludeFactionList.Clear();
                    tempIncludeSquadronList.Clear();

                    for (int dtIdx = 0; dtIdx < _numDisplayTargets; dtIdx++)
                    {
                        DisplayTarget _tempDT = displayTargetList[dtIdx];

                        if (_tempDT != null)
                        {
                            int _numFactionsToInclude = _tempDT.factionsToInclude == null ? 0 : _tempDT.factionsToInclude.Length;
                            int _numSquadronsToInclude = _tempDT.squadronsToInclude == null ? 0 : _tempDT.squadronsToInclude.Length;

                            // By default there is no exclude
                            sscRadarQuery.factionsToExclude = null;
                            sscRadarQuery.squadronsToExclude = null;

                            // Determine which Factions (if any) to include as a filter
                            for (int fIdx = 0; fIdx < _numFactionsToInclude; fIdx++)
                            {
                                // If faction is not already in list add it.
                                int _factionId = _tempDT.factionsToInclude[fIdx];
                                if (tempIncludeFactionList.FindIndex(f => f == _factionId) < 0)
                                {
                                    tempIncludeFactionList.Add(_factionId);
                                }
                            }

                            // Determine which Squadrons (if any) to include as a filter
                            for (int sqIdx = 0; sqIdx < _numSquadronsToInclude; sqIdx++)
                            {
                                // If squadron is not already in list add it.
                                int _squadronId = _tempDT.squadronsToInclude[sqIdx];
                                if (tempIncludeSquadronList.FindIndex(sq => sq == _squadronId) < 0)
                                {
                                    tempIncludeSquadronList.Add(_squadronId);
                                }
                            }

                            if (tempIncludeFactionList.Count > 0)
                            {
                                // Check if this generates work for GC
                                sscRadarQuery.factionsToInclude = tempIncludeFactionList.ToArray();
                            }
                            else { sscRadarQuery.factionsToInclude = null; }

                            if (tempIncludeSquadronList.Count > 0)
                            {
                                // Check if this generates work for GC
                                sscRadarQuery.squadronsToInclude = tempIncludeSquadronList.ToArray();
                            }
                            else { sscRadarQuery.squadronsToInclude = null; }
                        }
                    }
                }

                sscRadarQuery.range = targetingRange;
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: PopulateTargetingRadarQuery - shipDisplayModule is not initialised"); }
            #endif
        }

        /// <summary>
        /// Set or change the Reticle assigned to a DisplayTarget.
        /// The Reticle must belong to the list of available reticles for the HUD.
        /// </summary>
        /// <param name="guidHash"></param>
        /// <param name="guidHashDisplayReticle"></param>
        public void SetDisplayTargetReticle(int guidHash, int guidHashDisplayReticle)
        {
            if (IsInitialised || editorMode)
            {
                DisplayTarget displayTarget = GetDisplayTarget(guidHash);

                if (displayTarget != null)
                {
                    displayTarget.guidHashDisplayReticle = guidHashDisplayReticle;

                    DisplayReticle _displayReticle = GetDisplayReticle(guidHashDisplayReticle);

                    // Set the reticle for all slots of this DisplayTarget
                    for (int sIdx = 0; sIdx < displayTarget.maxNumberOfTargets; sIdx++)
                    {
                        if (displayTarget.displayTargetSlotList[sIdx].CachedImgComponent != null)
                        {
                            displayTarget.displayTargetSlotList[sIdx].CachedImgComponent.sprite = _displayReticle == null ? null : _displayReticle.primarySprite;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Set the Display Target Reticle colour. Only update the colour if it has actually changed.
        /// If the module has been initialised, this will also re-colour the reticle with the appropriate brightness.
        /// </summary>
        /// <param name="newColour"></param>
        public void SetDisplayTargetReticleColour(DisplayTarget displayTarget, Color newColour)
        {
            if (displayTarget != null)
            {
                SSCUtils.UpdateColour(ref newColour, ref displayTarget.reticleColour, ref displayTarget.baseReticleColour, true);

                SetDisplayTargetBrightness(displayTarget);
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayTargetReticleColour - displayTarget is null"); }
            #endif
        }

        /// <summary>
        /// Set the offset (position) of the Display Target slot on the HUD.
        /// If the module has been initialised, this will also re-position the Display Target.
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <param name="slotIndex"></param>
        /// <param name="offsetX"></param>
        /// <param name="offsetY"></param>
        public void SetDisplayTargetOffset(DisplayTarget displayTarget, int slotIndex, float offsetX, float offsetY)
        {
            if (displayTarget != null)
            {
                int numSlots = displayTarget.displayTargetSlotList == null ? 0 : displayTarget.displayTargetSlotList.Count;

                if (slotIndex >= 0 & slotIndex < numSlots)
                {
                    SetDisplayTargetOffset(displayTarget.displayTargetSlotList[slotIndex], offsetX, offsetY);
                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayTargetOffset - the displayTarget slot is out-of-range (" + slotIndex + ")"); }
                #endif
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayTargetOffset - displayTarget is null"); }
            #endif
        }

        /// <summary>
        /// Set the offset (position) of the Display Target slot on the HUD.
        /// If the module has been initialised, this will also re-position the Display Target.
        /// </summary>
        /// <param name="displayTargetSlot"></param>
        /// <param name="offsetX">Horizontal offset from centre. Range between -1 and 1</param>
        /// <param name="offsetY">Vertical offset from centre. Range between -1 and 1</param>
        public void SetDisplayTargetOffset(DisplayTargetSlot displayTargetSlot, float offsetX, float offsetY)
        {
            if (displayTargetSlot != null)
            {
                // Verify the x,y values are within range -1 to 1.
                if (offsetX < -1f) { displayTargetSlot.offsetX = -1f; }
                else if (offsetX > 1f) { displayTargetSlot.offsetX = 1f; }
                else
                {
                    displayTargetSlot.offsetX = offsetX;
                }

                if (offsetY < -1f) { displayTargetSlot.offsetY = -1f; }
                else if (offsetY > 1f) { displayTargetSlot.offsetY = 1f; }
                else
                {
                    displayTargetSlot.offsetY = offsetY;
                }

                if (IsInitialised || editorMode)
                {
                    Transform dtgtTrfm = displayTargetSlot.CachedTargetPanel.transform;

                    #if UNITY_EDITOR
                    if (editorMode)
                    {
                        CheckHUDResize(false);
                        UnityEditor.Undo.RecordObject(dtgtTrfm, string.Empty);
                    }
                    #endif

                    // Use the scaled HUD size. This works in and out of play mode
                    tempTargetOffset.x = displayTargetSlot.offsetX * cvsResolutionHalf.x;
                    tempTargetOffset.y = displayTargetSlot.offsetY * cvsResolutionHalf.y;
                    tempTargetOffset.z = dtgtTrfm.localPosition.z;

                    dtgtTrfm.localPosition = tempTargetOffset;
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayTargetOffset - displayTargetSlot is null"); }
            #endif
        }

        /// <summary>
        /// Move the DisplayTarget Slot to the correct 2D position on the HUD, based on a 3D world space position.
        /// If the camera has not been automatically or manually assigned, the DisplayTarget will not be moved.
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <param name="slotIndex"></param>
        /// <param name="wsPosition"></param>
        public void SetDisplayTargetPosition(DisplayTarget displayTarget, int slotIndex, Vector3 wsPosition)
        {
            if (isMainCameraAssigned)
            {
                if (displayTarget != null)
                {
                    Vector3 screenPosition = mainCamera.WorldToScreenPoint(wsPosition);

                    // NOTE: cvsResolutionFull.x / cvsScaleFactor.x is NOT the same as Screen.width
                    // x 2 and subtracting 1 moves it into our HUD -1 to 1 space.
                    SetDisplayTargetOffset(displayTarget, slotIndex, 2f * screenPosition.x / cvsResolutionFull.x / cvsScaleFactor.x - 1f, 2f * screenPosition.y / cvsResolutionFull.y / cvsScaleFactor.y - 1f);
                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("ERROR: shipDisplayModule.SetDisplayTargetPosition - displayTarget is null"); }
                #endif
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: ShipDisplayModule.SetDisplayTargetPosition - Could not find mainCamera."); }
            #endif
        }

        /// <summary>
        /// Set the size of the Target Reticle in each slot.
        /// If the module has been initialised, this will also resize the Target Reticle.
        /// The values are only updated if they are outside the range 8 to 256 or have changed.
        /// The size is based on a screen resolution of 1920x1080
        /// </summary>
        /// <param name="displayTarget"></param>
        /// <param name="width">Range between 8 and 256</param>
        /// <param name="height">Range between 8 and 256</param>
        public void SetDisplayTargetSize(DisplayTarget displayTarget, int width, int height)
        {
            // Clamp the x,y values 8 to 256
            if (width < 8) { displayTarget.width = 8; }
            else if (width > 256) { displayTarget.width = 256; }
            else if (width != displayTarget.width) { displayTarget.width = width; }

            if (height < 8) { displayTarget.height = 8; }
            else if (height > 256) { displayTarget.height = 256; }
            else if (height != displayTarget.height) { displayTarget.height = height; }

            if (IsInitialised || editorMode)
            {
                #if UNITY_EDITOR
                if (editorMode) { CheckHUDResize(false); }
                #endif

                float pixelWidth = (float)displayTarget.width * screenResolution.x / refResolution.x;
                float pixelHeight = (float)displayTarget.height * screenResolution.y / refResolution.y;

                // Set the size of all the reticles in the DisplayTarget slots
                // There can be multiple copies or slots of the same DisplayTarget.
                for (int sIdx = 0; sIdx < displayTarget.maxNumberOfTargets; sIdx++)
                {
                    RectTransform dtRectTfrm = displayTarget.displayTargetSlotList[sIdx].CachedTargetPanel;

                    if (dtRectTfrm != null)
                    {
                        // Target size is in pixels - this will result in non-square scaling.
                        // (Future) provide an option to keep aspect ratio of original 64x64 reticle
                        dtRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, pixelWidth);
                        dtRectTfrm.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, pixelHeight);
                    }
                }
            }
        }

        /// <summary>
        /// Sets the clipped viewable area of the screen that DisplayTargets can be shown. When Targets
        /// are outside this area, they will be hidden.
        /// See also SetTargetsViewportOffset(..).
        /// </summary>
        /// <param name="width">Range between 0.1 and 1.0</param>
        /// <param name="height">Range between 0.1 and 1.0</param>
        public void SetTargetsViewportSize(float width, float height)
        {
            // Currently we just set the values after basic validation. This may change in future versions

            // Perform basic validation
            if (width >= 0.1f && width <= 1.0f) { targetsViewWidth = width; }
            if (height >= 0.1f && height <= 1.0f) { targetsViewHeight = height; }
        }

        /// <summary>
        /// Sets the Targets viewport offset from the centre of the screen.
        /// Values can be between -1.0 and 1.0 with 0,0 depicting the centre of the screen.
        /// See also SetTargetsViewportSize(..).
        /// </summary>
        /// <param name="offsetX">Range between -1.0 and 1.0</param>
        /// <param name="offsetY">Range between -1.0 and 1.0</param>
        public void SetTargetsViewportOffset(float offsetX, float offsetY)
        {
            // Currently we just set the values after basic validation. This may change in future versions

            if (offsetX >= -1f && offsetX <= 1.0f) { targetsViewOffsetX = offsetX; }
            if (offsetY >= -1f && offsetY <= 1.0f) { targetsViewOffsetY = offsetY; }
        }

        /// <summary>
        /// After adding or moving DisplayTargets, they may need to be sorted to
        /// have the correct z-order in on the HUD.
        /// </summary>
        public void RefreshTargetsSortOrder()
        {
            if (targetsRectTfrm != null)
            {
                // Targets should begin at index 0.
                int zIndex = -1;

                // Update number of DisplayTargets. This can help issues in the Editor, like moving DislayTargets
                // up or down in the list while in play mode.
                numDisplayTargets = displayTargetList == null ? 0 : displayTargetList.Count;

                for (int dtIdx = 0; dtIdx < numDisplayTargets; dtIdx++)
                {
                    DisplayTarget displayTarget = displayTargetList[dtIdx];

                    if (displayTarget != null)
                    {
                        //Debug.Log("[DEBUG] dt: " + dtIdx + " maxNum: " + displayTarget.maxNumberOfTargets + " actual: " + displayTarget.displayTargetSlotList.Count);

                        // Loop through all the slots for this DisplayTarget
                        for (int sIdx = 0; sIdx < displayTarget.maxNumberOfTargets; sIdx++)
                        {
                            RectTransform _rt = displayTarget.displayTargetSlotList[sIdx].CachedTargetPanel;

                            if (_rt != null)
                            {
                                _rt.SetSiblingIndex(++zIndex);
                            }
                        }
                    }
                }
            }
        }

         /// <summary>
        /// Create a new list if required
        /// </summary>
        public void ValidateTargetList()
        {
            if (displayTargetList == null) { displayTargetList = new List<DisplayTarget>(1); }
        }

        #endregion
    }
}