TiltFive.Display Class Reference

Inheritance diagram for TiltFive.Display:

Static Public Member Functions
static bool	SetApplicationInfo ()
static bool	GetGlassesAvailability ()
	Get whether any glasses are available More...
static bool	PresentStereoImages (PlayerIndex playerIndex, IntPtr leftTexHandle, IntPtr rightTexHandle, int texWidth_PIX, int texHeight_PIX, bool isSrgb, float fovYDegrees, float widthToHeightRatio, Quaternion rotToUGBD_ULVC, Vector3 posOfULVC_UGBD, Quaternion rotToUGBD_URVC, Vector3 posOfURVC_UGBD)
static bool	GetDisplayDimensions (ref Vector2Int displayDimensions)
static bool	GetGlassesIPD (UInt64 glassesHandle, ref float glassesIPD)

Protected Member Functions
override void	Awake ()

Private Member Functions
void	LogVersion ()
bool	PresentStereoImagesImpl (UInt64 glassesHandle, IntPtr leftTexHandle, IntPtr rightTexHandle, int texWidth_PIX, int texHeight_PIX, bool isSrgb, float fovYDegrees, float widthToHeightRatio, Quaternion rotToUGBD_ULVC, Vector3 posOfULVC_UGBD, Quaternion rotToUGBD_URVC, Vector3 posOfURVC_UGBD)
bool	GetDisplayDimensionsImpl (ref Vector2Int displayDimensions)
bool	GetGlassesIPDImpl (UInt64 glassesHandle, ref float glassesIPD)

Private Attributes
int[]	_displaySettings = new int[2]
IntPtr	_sendFrameCallback = IntPtr.Zero

Additional Inherited Members
Properties inherited from TiltFive.SingletonComponent< Display >
static T	Instance [get]

Detailed Description

Definition at line 65 of file Display.cs.

Member Function Documentation

Awake()

override void TiltFive.Display.Awake ( )

protectedvirtual

Reimplemented from TiltFive.SingletonComponent< Display >.

Definition at line 74 of file Display.cs.

        {
            base.Awake();
 
            try
            {
                _sendFrameCallback = NativePlugin.GetSendFrameCallback();
            }
            catch (System.DllNotFoundException e)
            {
                Log.Info("Could not connect to Tilt Five plugin to get callback: {0}", e);
            }
            catch (Exception e)
            {
                Log.Error(e.Message);
            }
 
            LogVersion();
 
            QualitySettings.vSyncCount = 0;
            QualitySettings.maxQueuedFrames = 0;
        }

References TiltFive.Display._sendFrameCallback, TiltFive.Logging.Log.Error(), TiltFive.Logging.Log.Info(), and TiltFive.Display.LogVersion().

GetDisplayDimensions()

static bool TiltFive.Display.GetDisplayDimensions ( ref Vector2Int  displayDimensions )

static

Definition at line 326 of file Display.cs.

        {
            return Instance.GetDisplayDimensionsImpl(ref displayDimensions);
        }

References TiltFive.SingletonComponent< Display >.Instance.

Referenced by TiltFive.DisplaySettings.DisplaySettings().

GetDisplayDimensionsImpl()

bool TiltFive.Display.GetDisplayDimensionsImpl ( ref Vector2Int  displayDimensions )

private

Definition at line 331 of file Display.cs.

        {
            int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
            try
            {
                result = NativePlugin.GetMaxDisplayDimensions(_displaySettings);
 
                if(result == NativePlugin.T5_RESULT_SUCCESS)
                {
                    displayDimensions = new Vector2Int(_displaySettings[0], _displaySettings[1]);
                }
                else Log.Warn("Display.cs: Failed to retrieve display settings from plugin.");
            }
            catch (Exception e)
            {
                Log.Error(e.Message);
            }
 
            return result == NativePlugin.T5_RESULT_SUCCESS;
        }

References TiltFive.Display._displaySettings, TiltFive.Logging.Log.Error(), and TiltFive.Logging.Log.Warn().

GetGlassesAvailability()

static bool TiltFive.Display.GetGlassesAvailability ( )

static

Get whether any glasses are available

If you want to check whether glasses for a specific player index are available, use T:TiltFive.Player.IsConnected instead.

Returns

true if glasses are available, false otherwise.

Definition at line 144 of file Display.cs.

        {
            return Player.IsConnected(PlayerIndex.One) || Player.IsConnected(PlayerIndex.Two) ||
                Player.IsConnected(PlayerIndex.Three) || Player.IsConnected(PlayerIndex.Four);
        }

References TiltFive.Player.IsConnected().

Referenced by TiltFive.Display.GetGlassesIPDImpl().

GetGlassesIPD()

static bool TiltFive.Display.GetGlassesIPD ( UInt64  glassesHandle, ref float  glassesIPD  )

static

Definition at line 352 of file Display.cs.

        {
            return Instance.GetGlassesIPDImpl(glassesHandle, ref glassesIPD);
        }

References TiltFive.SingletonComponent< Display >.Instance.

Referenced by TiltFive.Glasses.GlassesCore.Update().

GetGlassesIPDImpl()

bool TiltFive.Display.GetGlassesIPDImpl ( UInt64  glassesHandle, ref float  glassesIPD  )

private

Definition at line 357 of file Display.cs.

        {
            int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
            try
            {
                result = NativePlugin.GetGlassesIPD(glassesHandle, ref glassesIPD);
 
                if(result != NativePlugin.T5_RESULT_SUCCESS && GetGlassesAvailability())
                {
                    Log.Warn("Display.cs: Failed to retrieve glasses IPD");
                }
            }
            catch (Exception e)
            {
                Log.Error(e.Message);
            }
 
            return result == NativePlugin.T5_RESULT_SUCCESS;
        }

References TiltFive.Logging.Log.Error(), TiltFive.Display.GetGlassesAvailability(), and TiltFive.Logging.Log.Warn().

LogVersion()

void TiltFive.Display.LogVersion ( )

private

Definition at line 97 of file Display.cs.

        {
            string version = "NOT VERSIONED";
 
            // load version file and get the string value
            TextAsset asset = (TextAsset)Resources.Load("pluginversion", typeof(TextAsset));
            if (asset != null)
            {
                version = asset.text;
            }
 
            // turn on logging if it was turned off
            bool logEnabled = Debug.unityLogger.logEnabled;
            if (!logEnabled)
            {
                Debug.unityLogger.logEnabled = true;
            }
 
            // get previous setting
            StackTraceLogType logType = Application.GetStackTraceLogType(LogType.Log);
 
            // turn off stacktrace logging for our messaging
            Application.SetStackTraceLogType(LogType.Log, StackTraceLogType.None);
 
            Log.Info("\n********************************" +
                  "\n* Tilt Five: Unity SDK Version - " +
                  version +
                  "\n********************************");
 
            // reset to initial log settings
            Application.SetStackTraceLogType(LogType.Log, logType);
 
            // reset logging enabled to previous
            Debug.unityLogger.logEnabled = logEnabled;
        }

References TiltFive.Logging.Log.Info().

Referenced by TiltFive.Display.Awake().

PresentStereoImages()

static bool TiltFive.Display.PresentStereoImages ( PlayerIndex  playerIndex, IntPtr  leftTexHandle, IntPtr  rightTexHandle, int  texWidth_PIX, int  texHeight_PIX, bool  isSrgb, float  fovYDegrees, float  widthToHeightRatio, Quaternion  rotToUGBD_ULVC, Vector3  posOfULVC_UGBD, Quaternion  rotToUGBD_URVC, Vector3  posOfURVC_UGBD  )

static

Definition at line 150 of file Display.cs.

                                        {
            return Player.TryGetGlassesHandle(playerIndex, out var glassesHandle)
                && PresentStereoImages(glassesHandle,
                                        leftTexHandle,
                                        rightTexHandle,
                                        texWidth_PIX,
                                        texHeight_PIX,
                                        isSrgb,
                                        fovYDegrees,
                                        widthToHeightRatio,
                                        rotToUGBD_ULVC,
                                        posOfULVC_UGBD,
                                        rotToUGBD_URVC,
                                        posOfURVC_UGBD);
        }

Referenced by TiltFive.SplitStereoCamera.PresentStereoImages().

PresentStereoImagesImpl()

bool TiltFive.Display.PresentStereoImagesImpl ( UInt64  glassesHandle, IntPtr  leftTexHandle, IntPtr  rightTexHandle, int  texWidth_PIX, int  texHeight_PIX, bool  isSrgb, float  fovYDegrees, float  widthToHeightRatio, Quaternion  rotToUGBD_ULVC, Vector3  posOfULVC_UGBD, Quaternion  rotToUGBD_URVC, Vector3  posOfURVC_UGBD  )

private

Definition at line 206 of file Display.cs.

        {
            // Unity reference frames:
            //
            // ULVC / URVC - Unity Left/Right Virtual Camera space.
            //               +x right, +y up, +z forward
            // UGBD        - Unity Gameboard space.
            //               +x right, +y up, +z forward
            //
            // Tilt Five reference frames:
            //
            // DC          - Our right-handed version of Unity's default camera space
            //               (the LVC/RVC if there is no transform set on ULVC/URVC).
            //               +x right, +y up, +z backward
            // LVC / RVC   - Left/Right Virtual Camera space.
            //               +x right, +y up, +z backward
            // GBD         - Gameboard space.
            //               +x right, +y forward, +z up
 
            Quaternion rotToDC_GBD = Quaternion.AngleAxis(-90f, Vector3.right);
 
            // Calculate the VCI (the image rectangle in the normalized (z=1) image space of the virtual cameras)
            float startY_VCI = -Mathf.Tan(fovYDegrees * (0.5f * Mathf.PI / 180.0f));
            float startX_VCI = startY_VCI * widthToHeightRatio;
            float width_VCI = -2f * startX_VCI;
            float height_VCI = -2f * startY_VCI;
            Rect vci = new Rect(startX_VCI, startY_VCI, width_VCI, height_VCI);
 
            // Swizzle the left-handed Unity-based coordinates into our right-handed reference frames
            Quaternion rotToLVC_DC = new Quaternion(rotToUGBD_ULVC.x, rotToUGBD_ULVC.y, -rotToUGBD_ULVC.z, rotToUGBD_ULVC.w);
            Quaternion rotToRVC_DC = new Quaternion(rotToUGBD_URVC.x, rotToUGBD_URVC.y, -rotToUGBD_URVC.z, rotToUGBD_URVC.w);
 
            Quaternion rotToLVC_GBD = rotToLVC_DC * rotToDC_GBD;
            Quaternion rotToRVC_GBD = rotToRVC_DC * rotToDC_GBD;
 
            // Swap the Y and Z axes to switch from left-handed to right-handed coords
            Vector3 posOfLVC_GBD = new Vector3(posOfULVC_UGBD.x, posOfULVC_UGBD.z, posOfULVC_UGBD.y);
            Vector3 posOfRVC_GBD = new Vector3(posOfURVC_UGBD.x, posOfURVC_UGBD.z, posOfURVC_UGBD.y);
 
            // Build our frame info struct now that we're finished converting from Unity's coord space
            T5_FrameInfo frameInfo = new T5_FrameInfo();
 
            frameInfo.LeftTexHandle = leftTexHandle;
            frameInfo.RightTexHandle = rightTexHandle;
 
            frameInfo.TexWidth_PIX = (UInt16) texWidth_PIX;
            frameInfo.TexHeight_PIX = (UInt16) texHeight_PIX;
 
            frameInfo.IsSrgb = isSrgb;
            frameInfo.IsUpsideDown = false;     // False for Unity, but possibly true for other engines
 
            frameInfo.VCI = vci;
 
            frameInfo.RotToLVC_GBD = rotToLVC_GBD;
            frameInfo.PosOfLVC_GBD = posOfLVC_GBD;
 
            frameInfo.RotToRVC_GBD = rotToRVC_GBD;
            frameInfo.PosOfRVC_GBD = posOfRVC_GBD;
 
            int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
            try
            {
                result = NativePlugin.QueueStereoImages(glassesHandle, frameInfo);
            }
            catch (Exception e)
            {
                Log.Error(e.Message);
            }
 
            if (result != NativePlugin.T5_RESULT_SUCCESS) {
                return false;
            }
 
            if(_sendFrameCallback == IntPtr.Zero)
            {
                // We failed to set _sendFrameCallback during Awake() - let's try again
                try
                {
                    _sendFrameCallback = NativePlugin.GetSendFrameCallback();
                }
                catch (Exception)
                {
                    Log.Error("Unable to send frame - the native plugin DLL may be failing to load");
                    return false;
                }
 
                if (_sendFrameCallback == IntPtr.Zero)
                {
                    // If we reach this point, the native plugin loaded, but erroneously gave us a null callback
                    Log.Error("Unable to send frame - the native plugin returned a null SendFrame callback");
                    return false;
                }
            }
 
            try
            {
                GL.IssuePluginEvent(_sendFrameCallback, 0);
                GL.InvalidateState();
            }
            catch (Exception e)
            {
                Log.Error($"Failed to execute sendFrame callback: {e.Message}");
                return false;
            }
 
            return true;
        }

References TiltFive.Display._sendFrameCallback, and TiltFive.Logging.Log.Error().

SetApplicationInfo()

static bool TiltFive.Display.SetApplicationInfo ( )

static

Definition at line 134 of file Display.cs.

        {
            return SystemControl.SetApplicationInfo();
        }

Member Data Documentation

_displaySettings

int [] TiltFive.Display._displaySettings = new int[2]

private

Definition at line 68 of file Display.cs.

Referenced by TiltFive.Display.GetDisplayDimensionsImpl().

_sendFrameCallback

IntPtr TiltFive.Display._sendFrameCallback = IntPtr.Zero

private

Definition at line 72 of file Display.cs.

Referenced by TiltFive.Display.Awake(), and TiltFive.Display.PresentStereoImagesImpl().

---

The documentation for this class was generated from the following file:

• Display.cs