SLGLOVRWorkaround.h File Reference

Wrapper around Oculus Rift. More...

#include <SLGLOculus.h>
#include <SLGLVertexArray.h>
#include <SLScene.h>

Include dependency graph for SLGLOVRWorkaround.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	LensConfig
struct	ovrSizei
struct	ovrSizef
struct	HmdRenderInfo
struct	HmdRenderInfo::ShutterInfo
struct	HmdRenderInfo::EyeConfig
struct	DistortionRenderDesc
struct	ovrDistortionVertex_
struct	ovrDistortionMesh_
struct	DistortionMeshVertexData
struct	ovrFovPort_
struct	ScaleAndOffset2D

Macros
#define	TPH_SPLINE_STATISTICS   0

Typedefs
typedef struct ovrDistortionVertex_	ovrDistortionVertex
typedef struct ovrDistortionMesh_	ovrDistortionMesh
typedef struct ovrFovPort_	ovrFovPort

Enumerations
enum	DistortionEqnType { Distortion_No_Override = -1 , Distortion_Poly4 = 0 , Distortion_RecipPoly4 = 1 , Distortion_CatmullRom10 = 2 , Distortion_LAST }
enum	HmdTypeEnum {   HmdType_None , HmdType_DKProto , HmdType_DK1 , HmdType_DKHDProto , HmdType_DKHD2Proto , HmdType_DKHDProto566Mi ,   HmdType_CrystalCoveProto , HmdType_DK2 , HmdType_Unknown , HmdType_LAST }
enum	HmdShutterTypeEnum { HmdShutteRT_global , HmdShutter_RollingTopToBottom , HmdShutter_RollingLeftToRight , HmdShutter_RollingRightToLeft , HmdShutter_LAST }
enum	EyeCupType {   EyeCup_DK1A = 0 , EyeCup_DK1B = 1 , EyeCup_DK1C = 2 , EyeCup_DK2A = 3 , EyeCup_DKHD2A , EyeCup_OrangeA ,   EyeCup_RedA , EyeCup_PinkA , EyeCup_BlueA , EyeCup_Delilah1A , EyeCup_Delilah2A , EyeCup_JamesA ,   EyeCup_SunMandalaA , EyeCup_LAST }
enum	{ NumCoefficients = 11 }

Functions
bool	FitCubicPolynomial (float *pResult, const float *pFitX, const float *pFitY)
float	EvalCatmullRom10Spline (float const *K, float scaledVal)
SLMat4f	ovrMatrix4f_OrthoSubProjection (SLMat4f projection, SLVec2f orthoScale, float orthoDistance, float eyeViewAdjustX)
SLVec2f	TransformTanFovSpaceToScreenNDC (DistortionRenderDesc const &distortion, const SLVec2f &tanEyeAngle, bool usePolyApprox)
void	TransformScreenNDCToTanFovSpaceChroma (SLVec2f *resultR, SLVec2f *resultG, SLVec2f *resultB, DistortionRenderDesc const &distortion, const SLVec2f &framebufferNDC)
SLVec2f	TransformTanFovSpaceToRendertargetNDC (ScaleAndOffset2D const &eyeToSourceNDC, SLVec2f const &tanEyeAngle)
SLVec2f	TransformRendertargetNDCToTanFovSpace (const ScaleAndOffset2D &eyeToSourceNDC, const SLVec2f &textureNDC)
ScaleAndOffset2D	CreateNDCScaleAndOffsetFromFov (ovrFovPort tanHalfFov)
SLMat4f	CreateProjection (bool rightHanded, ovrFovPort tanHalfFov, float zNear, float zFar)
void	createSLDistortionMesh (DistortionMeshVertexData **ppVertices, uint16_t **ppTriangleListIndices, SLuint *pNumVertices, SLuint *pNumTriangles, bool rightEye, const HmdRenderInfo &hmdRenderInfo, const DistortionRenderDesc &distortion, const ScaleAndOffset2D &eyeToSourceNDC)
void	createSLDistortionMesh (SLGLProgram *stereoOculusDistProgram, SLEyeType eye, SLGLVertexArray &vao)

Detailed Description

Wrapper around Oculus Rift.

Date

July 2014

Authors

Marc Wacker, Roman Kuehne, Marcus Hudritsch

Copyright

http://opensource.org/licenses/GPL-3.0

Remarks

Please use clangformat to format the code. See more code style on https://github.com/cpvrlab/SLProject4/wiki/SLProject-Coding-Style

Definition in file SLGLOVRWorkaround.h.

Macro Definition Documentation

TPH_SPLINE_STATISTICS

#define TPH_SPLINE_STATISTICS   0

Definition at line 133 of file SLGLOVRWorkaround.h.

Typedef Documentation

ovrDistortionMesh

typedef struct ovrDistortionMesh_ ovrDistortionMesh

ovrDistortionVertex

typedef struct ovrDistortionVertex_ ovrDistortionVertex

ovrFovPort

typedef struct ovrFovPort_ ovrFovPort

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
NumCoefficients

Definition at line 129 of file SLGLOVRWorkaround.h.

{
    NumCoefficients = 11
};

DistortionEqnType

enum DistortionEqnType

Enumerator
Distortion_No_Override
Distortion_Poly4
Distortion_RecipPoly4
Distortion_CatmullRom10
Distortion_LAST

Definition at line 19 of file SLGLOVRWorkaround.h.

{
    Distortion_No_Override = -1,
    // These two are legacy and deprecated.
    Distortion_Poly4      = 0, // scale = (K0 + K1*r^2 + K2*r^4 + K3*r^6)
    Distortion_RecipPoly4 = 1, // scale = 1/(K0 + K1*r^2 + K2*r^4 + K3*r^6)
 
    // CatmullRom10 is the preferred distortion format.
    Distortion_CatmullRom10 = 2, // scale = Catmull-Rom spline through points (1.0, K[1]...K[9])
    Distortion_LAST              // For ease of enumeration.
};

EyeCupType

enum EyeCupType

Enumerator
EyeCup_DK1A
EyeCup_DK1B
EyeCup_DK1C
EyeCup_DK2A
EyeCup_DKHD2A
EyeCup_OrangeA
EyeCup_RedA
EyeCup_PinkA
EyeCup_BlueA
EyeCup_Delilah1A
EyeCup_Delilah2A
EyeCup_JamesA
EyeCup_SunMandalaA
EyeCup_LAST

Definition at line 70 of file SLGLOVRWorkaround.h.

{
    // Public lenses
    EyeCup_DK1A = 0,
    EyeCup_DK1B = 1,
    EyeCup_DK1C = 2,
    EyeCup_DK2A = 3,
 
    // Internal R&D code names.
    // Reminder - this header file is public - code names only!
    EyeCup_DKHD2A,
    EyeCup_OrangeA,
    EyeCup_RedA,
    EyeCup_PinkA,
    EyeCup_BlueA,
    EyeCup_Delilah1A,
    EyeCup_Delilah2A,
    EyeCup_JamesA,
    EyeCup_SunMandalaA,
 
    EyeCup_LAST
};

HmdShutterTypeEnum

enum HmdShutterTypeEnum

Enumerator
HmdShutteRT_global
HmdShutter_RollingTopToBottom
HmdShutter_RollingLeftToRight
HmdShutter_RollingRightToLeft
HmdShutter_LAST

Definition at line 52 of file SLGLOVRWorkaround.h.

{
    HmdShutteRT_global,
    HmdShutter_RollingTopToBottom,
    HmdShutter_RollingLeftToRight,
    HmdShutter_RollingRightToLeft,
    // TODO:
    // color-sequential e.g. LCOS?
    // alternate eyes?
    // alternate columns?
    // outside-in?
 
    HmdShutter_LAST
};

HmdTypeEnum

enum HmdTypeEnum

Enumerator
HmdType_None
HmdType_DKProto
HmdType_DK1
HmdType_DKHDProto
HmdType_DKHD2Proto
HmdType_DKHDProto566Mi
HmdType_CrystalCoveProto
HmdType_DK2
HmdType_Unknown
HmdType_LAST

Definition at line 34 of file SLGLOVRWorkaround.h.

{
    HmdType_None,
    HmdType_DKProto,          // First duct-tape model, never sold.
    HmdType_DK1,              // DevKit1 - on sale to developers.
    HmdType_DKHDProto,        // DKHD - shown at various shows, never sold.
    HmdType_DKHD2Proto,       // DKHD2, 5.85-inch panel, never sold.
    HmdType_DKHDProto566Mi,   // DKHD, 5.66-inch panel, never sold.
    HmdType_CrystalCoveProto, // Crystal Cove, 5.66-inch panel, shown at shows but never sold.
    HmdType_DK2,
 
    // Reminder - this header file is public - code names only!
    HmdType_Unknown, // Used for unnamed HW lab experiments.
    HmdType_LAST
};

Function Documentation

CreateNDCScaleAndOffsetFromFov()

ScaleAndOffset2D CreateNDCScaleAndOffsetFromFov

(

ovrFovPort

tanHalfFov

)

Definition at line 750 of file SLGLOVRWorkaround.h.

{
    float projXScale  = 2.0f / (tanHalfFov.LeftTan + tanHalfFov.RightTan);
    float projXOffset = (tanHalfFov.LeftTan - tanHalfFov.RightTan) * projXScale * 0.5f;
    float projYScale  = 2.0f / (tanHalfFov.UpTan + tanHalfFov.DownTan);
    float projYOffset = (tanHalfFov.UpTan - tanHalfFov.DownTan) * projYScale * 0.5f;
 
    ScaleAndOffset2D result;
    result.Scale  = SLVec2f(projXScale, projYScale);
    result.Offset = SLVec2f(projXOffset, projYOffset);
    // Hey - why is that Y.Offset negated?
    // It's because a projection matrix transforms from world coords with Y=up,
    // whereas this is from NDC which is Y=down.
 
    return result;
}

CreateProjection()

SLMat4f CreateProjection	(	bool	rightHanded,
		ovrFovPort	tanHalfFov,
		float	zNear,
		float	zFar
	)

Definition at line 769 of file SLGLOVRWorkaround.h.

{
    // A projection matrix is very like a scaling from NDC, so we can start with that.
    ScaleAndOffset2D scaleAndOffset = CreateNDCScaleAndOffsetFromFov(tanHalfFov);
 
    float handednessScale = 1.0f;
    if (rightHanded)
    {
        handednessScale = -1.0f;
    }
 
    float proj[4][4] = {{1, 0, 0, 0},
                        {0, 1, 0, 0},
                        {0, 0, 1, 0},
                        {0, 0, 0, 1}};
 
    // Produces X result, mapping clip edges to [-w,+w]
    proj[0][0] = scaleAndOffset.Scale.x;
    proj[0][1] = 0.0f;
    proj[0][2] = handednessScale * scaleAndOffset.Offset.x;
    proj[0][3] = 0.0f;
 
    // Produces Y result, mapping clip edges to [-w,+w]
    // Hey - why is that YOffset negated?
    // It's because a projection matrix transforms from world coords with Y=up,
    // whereas this is derived from an NDC scaling, which is Y=down.
    proj[1][0] = 0.0f;
    proj[1][1] = scaleAndOffset.Scale.y;
    proj[1][2] = handednessScale * -scaleAndOffset.Offset.y;
    proj[1][3] = 0.0f;
 
    // Produces Z-buffer result - app needs to fill this in with whatever Z range it wants.
    // We'll just use some defaults for now.
    proj[2][0] = 0.0f;
    proj[2][1] = 0.0f;
    proj[2][2] = -handednessScale * zFar / (zNear - zFar);
    proj[2][3] = (zFar * zNear) / (zNear - zFar);
 
    // Produces W result (= Z in)
    proj[3][0] = 0.0f;
    proj[3][1] = 0.0f;
    proj[3][2] = handednessScale;
    proj[3][3] = 0.0f;
 
    SLMat4f projection((SLfloat*)proj);
    projection.transpose();
 
    return projection;
}

createSLDistortionMesh() [1/2]

void createSLDistortionMesh	(	DistortionMeshVertexData **	ppVertices,
		uint16_t **	ppTriangleListIndices,
		SLuint *	pNumVertices,
		SLuint *	pNumTriangles,
		bool	rightEye,
		const HmdRenderInfo &	hmdRenderInfo,
		const DistortionRenderDesc &	distortion,
		const ScaleAndOffset2D &	eyeToSourceNDC
	)

Definition at line 820 of file SLGLOVRWorkaround.h.

{
    static const int DMA_GridSizeLog2   = 6;
    static const int DMA_GridSize       = 1 << DMA_GridSizeLog2;
    static const int DMA_NumVertsPerEye = (DMA_GridSize + 1) * (DMA_GridSize + 1);
    static const int DMA_NumTrisPerEye  = (DMA_GridSize) * (DMA_GridSize)*2;
 
    // When does the fade-to-black edge start? Chosen heuristically.
    const float fadeOutBorderFraction = 0.075f;
 
    // Populate vertex buffer info
    float xOffset = 0.0f;
 
    if (rightEye)
    {
        xOffset = 1.0f;
    }
    *pNumVertices  = DMA_NumVertsPerEye;
    *pNumTriangles = DMA_NumTrisPerEye;
 
    *ppVertices            = (DistortionMeshVertexData*)(new DistortionMeshVertexData[sizeof(DistortionMeshVertexData) * (*pNumVertices)]);
    *ppTriangleListIndices = (uint16_t*)(new uint16_t[sizeof(uint16_t) * (*pNumTriangles) * 3]);
 
    // First pass - build up raw vertex data.
    DistortionMeshVertexData* pcurVert = *ppVertices;
 
    for (int y = 0; y <= DMA_GridSize; y++)
    {
        for (int x = 0; x <= DMA_GridSize; x++)
        {
 
            SLVec2f sourceCoordNDC;
            // NDC texture coords [-1,+1]
            sourceCoordNDC.x    = 2.0f * ((float)x / (float)DMA_GridSize) - 1.0f;
            sourceCoordNDC.y    = 2.0f * ((float)y / (float)DMA_GridSize) - 1.0f;
            SLVec2f tanEyeAngle = TransformRendertargetNDCToTanFovSpace(eyeToSourceNDC, sourceCoordNDC);
 
            // Find a corresponding screen position.
            // Note - this function does not have to be precise - we're just trying to match the mesh tessellation
            // with the shape of the distortion to minimize the number of triangles needed.
            SLVec2f screenNDC = TransformTanFovSpaceToScreenNDC(distortion, tanEyeAngle, false);
            // ...but don't let verts overlap to the other eye.
            screenNDC.x = std::max(-1.0f, std::min(screenNDC.x, 1.0f));
            screenNDC.y = std::max(-1.0f, std::min(screenNDC.y, 1.0f));
 
            // From those screen positions, we then need (effectively) RGB UVs.
            // This is the function that actually matters when doing the distortion calculation.
            SLVec2f tanEyeAnglesR, tanEyeAnglesG, tanEyeAnglesB;
            TransformScreenNDCToTanFovSpaceChroma(&tanEyeAnglesR, &tanEyeAnglesG, &tanEyeAnglesB, distortion, screenNDC);
 
            pcurVert->TanEyeAnglesR = tanEyeAnglesR;
            pcurVert->TanEyeAnglesG = tanEyeAnglesG;
            pcurVert->TanEyeAnglesB = tanEyeAnglesB;
 
            HmdShutterTypeEnum shutterType = hmdRenderInfo.Shutter.Type;
            switch (shutterType)
            {
                case HmdShutteRT_global:
                    pcurVert->TimewarpLerp = 0.0f;
                    break;
                case HmdShutter_RollingLeftToRight:
                    // Retrace is left to right - left eye goes 0.0 -> 0.5, then right goes 0.5 -> 1.0
                    pcurVert->TimewarpLerp = screenNDC.x * 0.25f + 0.25f;
                    if (rightEye)
                    {
                        pcurVert->TimewarpLerp += 0.5f;
                    }
                    break;
                case HmdShutter_RollingRightToLeft:
                    // Retrace is right to left - right eye goes 0.0 -> 0.5, then left goes 0.5 -> 1.0
                    pcurVert->TimewarpLerp = 0.75f - screenNDC.x * 0.25f;
                    if (rightEye)
                    {
                        pcurVert->TimewarpLerp -= 0.5f;
                    }
                    break;
                case HmdShutter_RollingTopToBottom:
                    // Retrace is top to bottom on both eyes at the same time.
                    pcurVert->TimewarpLerp = screenNDC.y * 0.5f + 0.5f;
                    break;
                default: assert(false); break;
            }
 
            // Fade out at texture edges.
            // The furthest out will be the blue channel, because of chromatic aberration (true of any standard lens)
            SLVec2f sourceTexCoordBlueNDC = TransformTanFovSpaceToRendertargetNDC(eyeToSourceNDC, tanEyeAnglesB);
            float   edgeFadeIn            = (1.0f / fadeOutBorderFraction) *
                               (1.0f - std::max(Utils::abs(sourceTexCoordBlueNDC.x), Utils::abs(sourceTexCoordBlueNDC.y)));
            // Also fade out at screen edges.
            float edgeFadeInScreen = (2.0f / fadeOutBorderFraction) *
                                     (1.0f - std::max(Utils::abs(screenNDC.x), Utils::abs(screenNDC.y)));
            edgeFadeIn = std::min(edgeFadeInScreen, edgeFadeIn);
 
            pcurVert->Shade          = std::max(0.0f, std::min(edgeFadeIn, 1.0f));
            pcurVert->ScreenPosNDC.x = 0.5f * screenNDC.x - 0.5f + xOffset;
            pcurVert->ScreenPosNDC.y = -screenNDC.y;
 
            pcurVert++;
        }
    }
 
    // Populate index buffer info
    uint16_t* pcurIndex = *ppTriangleListIndices;
 
    for (int triNum = 0; triNum < DMA_GridSize * DMA_GridSize; triNum++)
    {
        // Use a Morton order to help locality of FB, texture and vertex cache.
        // (0.325ms raster order -> 0.257ms Morton order)
        assert(DMA_GridSize <= 256);
        int x = ((triNum & 0x0001) >> 0) |
                ((triNum & 0x0004) >> 1) |
                ((triNum & 0x0010) >> 2) |
                ((triNum & 0x0040) >> 3) |
                ((triNum & 0x0100) >> 4) |
                ((triNum & 0x0400) >> 5) |
                ((triNum & 0x1000) >> 6) |
                ((triNum & 0x4000) >> 7);
        int y = ((triNum & 0x0002) >> 1) |
                ((triNum & 0x0008) >> 2) |
                ((triNum & 0x0020) >> 3) |
                ((triNum & 0x0080) >> 4) |
                ((triNum & 0x0200) >> 5) |
                ((triNum & 0x0800) >> 6) |
                ((triNum & 0x2000) >> 7) |
                ((triNum & 0x8000) >> 8);
        int FirstVertex = x * (DMA_GridSize + 1) + y;
        // Another twist - we want the top-left and bottom-right quadrants to
        // have the triangles split one way, the other two split the other.
        // +---+---+---+---+
        // |  /|  /|\  |\  |
        // | / | / | \ | \ |
        // |/  |/  |  \|  \|
        // +---+---+---+---+
        // |  /|  /|\  |\  |
        // | / | / | \ | \ |
        // |/  |/  |  \|  \|
        // +---+---+---+---+
        // |\  |\  |  /|  /|
        // | \ | \ | / | / |
        // |  \|  \|/  |/  |
        // +---+---+---+---+
        // |\  |\  |  /|  /|
        // | \ | \ | / | / |
        // |  \|  \|/  |/  |
        // +---+---+---+---+
        // This way triangle edges don't span long distances over the distortion function,
        // so linear interpolation works better & we can use fewer tris.
        if ((x < DMA_GridSize / 2) != (y < DMA_GridSize / 2)) // != is logical XOR
        {
            *pcurIndex++ = (uint16_t)FirstVertex;
            *pcurIndex++ = (uint16_t)FirstVertex + 1;
            *pcurIndex++ = (uint16_t)FirstVertex + (DMA_GridSize + 1) + 1;
 
            *pcurIndex++ = (uint16_t)FirstVertex + (DMA_GridSize + 1) + 1;
            *pcurIndex++ = (uint16_t)FirstVertex + (DMA_GridSize + 1);
            *pcurIndex++ = (uint16_t)FirstVertex;
        }
        else
        {
            *pcurIndex++ = (uint16_t)FirstVertex;
            *pcurIndex++ = (uint16_t)FirstVertex + 1;
            *pcurIndex++ = (uint16_t)FirstVertex + (DMA_GridSize + 1);
 
            *pcurIndex++ = (uint16_t)FirstVertex + 1;
            *pcurIndex++ = (uint16_t)FirstVertex + (DMA_GridSize + 1) + 1;
            *pcurIndex++ = (uint16_t)FirstVertex + (DMA_GridSize + 1);
        }
    }
}

createSLDistortionMesh() [2/2]

void createSLDistortionMesh	(	SLGLProgram *	stereoOculusDistProgram,
		SLEyeType	eye,
		SLGLVertexArray &	vao
	)

Definition at line 998 of file SLGLOVRWorkaround.h.

{
    // fill the variables below with useful data from dk2
    HmdRenderInfo hmdri;
    hmdri.HmdType                             = HmdType_DK2;
    hmdri.ResolutionInPixels.w                = 1920;
    hmdri.ResolutionInPixels.h                = 1080;
    hmdri.ScreenSizeInMeters.w                = 0.125760004f;
    hmdri.ScreenSizeInMeters.h                = 0.0707399994f;
    hmdri.ScreenGapSizeInMeters               = 0.0f;
    hmdri.CenterFromTopInMeters               = 0.0353f;
    hmdri.LensSeparationInMeters              = 0.0635f;
    hmdri.LensDiameterInMeters                = 0.0399f;
    hmdri.LensSurfaceToMidplateInMeters       = 0.01964f;
    hmdri.EyeCups                             = EyeCup_DK2A;
    hmdri.Shutter.Type                        = HmdShutter_RollingRightToLeft;
    hmdri.Shutter.VsyncToNextVsync            = 0.013157f;
    hmdri.Shutter.VsyncToFirstScanline        = 2.73000005e-005f;
    hmdri.Shutter.FirstScanlineToLastScanline = 0.0131f;
    hmdri.Shutter.PixelSettleTime             = 0.0f;
    hmdri.Shutter.PixelPersistence            = 0.0023f;
 
    hmdri.EyeLeft.ReliefInMeters                       = 0.0109f;
    hmdri.EyeLeft.NoseToPupilInMeters                  = 0.032f;
    hmdri.EyeLeft.Distortion.Eqn                       = Distortion_CatmullRom10;
    hmdri.EyeLeft.Distortion.K[0]                      = 1.00300002f;
    hmdri.EyeLeft.Distortion.K[1]                      = 1.01999998f;
    hmdri.EyeLeft.Distortion.K[2]                      = 1.04200006f;
    hmdri.EyeLeft.Distortion.K[3]                      = 1.06599998f;
    hmdri.EyeLeft.Distortion.K[4]                      = 1.09399998f;
    hmdri.EyeLeft.Distortion.K[5]                      = 1.12600005f;
    hmdri.EyeLeft.Distortion.K[6]                      = 1.16199994f;
    hmdri.EyeLeft.Distortion.K[7]                      = 1.20299995f;
    hmdri.EyeLeft.Distortion.K[8]                      = 1.25000000f;
    hmdri.EyeLeft.Distortion.K[9]                      = 1.30999994f;
    hmdri.EyeLeft.Distortion.K[10]                     = 1.38000000f;
    hmdri.EyeLeft.Distortion.MaxR                      = 1.00000000f;
    hmdri.EyeLeft.Distortion.MetersPerTanAngleAtCenter = 0.0359999985f;
    hmdri.EyeLeft.Distortion.ChromaticAberration[0]    = -0.0123399980f;
    hmdri.EyeLeft.Distortion.ChromaticAberration[1]    = -0.0164999980f;
    hmdri.EyeLeft.Distortion.ChromaticAberration[2]    = 0.0205899980f;
    hmdri.EyeLeft.Distortion.ChromaticAberration[3]    = 0.0164999980f;
    hmdri.EyeLeft.Distortion.InvK[0]                   = 1.0f;
    hmdri.EyeLeft.Distortion.InvK[1]                   = 0.964599669f;
    hmdri.EyeLeft.Distortion.InvK[2]                   = 0.931152463f;
    hmdri.EyeLeft.Distortion.InvK[3]                   = 0.898376584f;
    hmdri.EyeLeft.Distortion.InvK[4]                   = 0.867980957f;
    hmdri.EyeLeft.Distortion.InvK[5]                   = 0.839782715f;
    hmdri.EyeLeft.Distortion.InvK[6]                   = 0.813964784f;
    hmdri.EyeLeft.Distortion.InvK[7]                   = 0.789245605f;
    hmdri.EyeLeft.Distortion.InvK[8]                   = 0.765808105f;
    hmdri.EyeLeft.Distortion.InvK[9]                   = 0.745178223f;
    hmdri.EyeLeft.Distortion.InvK[10]                  = 0.724639833f;
    hmdri.EyeLeft.Distortion.MaxInvR                   = 1.38000000f;
 
    hmdri.EyeRight.ReliefInMeters                       = 0.0109f;
    hmdri.EyeRight.NoseToPupilInMeters                  = 0.032f;
    hmdri.EyeRight.Distortion.Eqn                       = Distortion_CatmullRom10;
    hmdri.EyeRight.Distortion.K[0]                      = 1.00300002f;
    hmdri.EyeRight.Distortion.K[1]                      = 1.01999998f;
    hmdri.EyeRight.Distortion.K[2]                      = 1.04200006f;
    hmdri.EyeRight.Distortion.K[3]                      = 1.06599998f;
    hmdri.EyeRight.Distortion.K[4]                      = 1.09399998f;
    hmdri.EyeRight.Distortion.K[5]                      = 1.12600005f;
    hmdri.EyeRight.Distortion.K[6]                      = 1.16199994f;
    hmdri.EyeRight.Distortion.K[7]                      = 1.20299995f;
    hmdri.EyeRight.Distortion.K[8]                      = 1.25000000f;
    hmdri.EyeRight.Distortion.K[9]                      = 1.30999994f;
    hmdri.EyeRight.Distortion.K[10]                     = 1.38000000f;
    hmdri.EyeRight.Distortion.MaxR                      = 1.00000000f;
    hmdri.EyeRight.Distortion.MetersPerTanAngleAtCenter = 0.0359999985f;
    hmdri.EyeRight.Distortion.ChromaticAberration[0]    = -0.0123399980f;
    hmdri.EyeRight.Distortion.ChromaticAberration[1]    = -0.0164999980f;
    hmdri.EyeRight.Distortion.ChromaticAberration[2]    = 0.0205899980f;
    hmdri.EyeRight.Distortion.ChromaticAberration[3]    = 0.0164999980f;
    hmdri.EyeRight.Distortion.InvK[0]                   = 1.0f;
    hmdri.EyeRight.Distortion.InvK[1]                   = 0.964599669f;
    hmdri.EyeRight.Distortion.InvK[2]                   = 0.931152463f;
    hmdri.EyeRight.Distortion.InvK[3]                   = 0.898376584f;
    hmdri.EyeRight.Distortion.InvK[4]                   = 0.867980957f;
    hmdri.EyeRight.Distortion.InvK[5]                   = 0.839782715f;
    hmdri.EyeRight.Distortion.InvK[6]                   = 0.813964784f;
    hmdri.EyeRight.Distortion.InvK[7]                   = 0.789245605f;
    hmdri.EyeRight.Distortion.InvK[8]                   = 0.765808105f;
    hmdri.EyeRight.Distortion.InvK[9]                   = 0.745178223f;
    hmdri.EyeRight.Distortion.InvK[10]                  = 0.724639833f;
    hmdri.EyeRight.Distortion.MaxInvR                   = 1.38000000f;
 
    DistortionRenderDesc distortion;
    distortion.Lens.Eqn                       = Distortion_CatmullRom10;
    distortion.Lens.K[0]                      = 1.00300002f;
    distortion.Lens.K[1]                      = 1.01999998f;
    distortion.Lens.K[2]                      = 1.04200006f;
    distortion.Lens.K[3]                      = 1.06599998f;
    distortion.Lens.K[4]                      = 1.09399998f;
    distortion.Lens.K[5]                      = 1.12600005f;
    distortion.Lens.K[6]                      = 1.16199994f;
    distortion.Lens.K[7]                      = 1.20299995f;
    distortion.Lens.K[8]                      = 1.25000000f;
    distortion.Lens.K[9]                      = 1.30999994f;
    distortion.Lens.K[10]                     = 1.38000000f;
    distortion.Lens.MaxR                      = 1.00000000f;
    distortion.Lens.MetersPerTanAngleAtCenter = 0.0359999985f;
    distortion.Lens.ChromaticAberration[0]    = -0.0123399980f;
    distortion.Lens.ChromaticAberration[1]    = -0.0164999980f;
    distortion.Lens.ChromaticAberration[2]    = 0.0205899980f;
    distortion.Lens.ChromaticAberration[3]    = 0.0164999980f;
    distortion.Lens.InvK[0]                   = 1.0f;
    distortion.Lens.InvK[1]                   = 0.964599669f;
    distortion.Lens.InvK[2]                   = 0.931152463f;
    distortion.Lens.InvK[3]                   = 0.898376584f;
    distortion.Lens.InvK[4]                   = 0.867980957f;
    distortion.Lens.InvK[5]                   = 0.839782715f;
    distortion.Lens.InvK[6]                   = 0.813964784f;
    distortion.Lens.InvK[7]                   = 0.789245605f;
    distortion.Lens.InvK[8]                   = 0.765808105f;
    distortion.Lens.InvK[9]                   = 0.745178223f;
    distortion.Lens.InvK[10]                  = 0.724639833f;
    distortion.Lens.MaxInvR                   = 1.38000000f;
 
    distortion.LensCenter.x                = -0.00986003876f;
    distortion.LensCenter.y                = 0.000000000f;
    distortion.TanEyeAngleScale.x          = 0.873333395f;
    distortion.TanEyeAngleScale.y          = 0.982500017f;
    distortion.PixelsPerTanAngleAtCenter.x = 549.618286f;
    distortion.PixelsPerTanAngleAtCenter.y = 549.618286f;
 
    ovrFovPort fov;
    fov.DownTan  = 1.329f;
    fov.UpTan    = 1.329f;
    fov.LeftTan  = 1.058f;
    fov.RightTan = 1.092f;
 
    ovrDistortionVertex* vertexData;
    SLushort*            indexData;
    SLuint               triangleCount = 0;
    SLuint               vertexCount   = 0;
#ifdef SL_GUI_JAVA
    bool rightEye = (eye == rightEye);
#else
    bool rightEye = (eye == SLEyeType::ET_right);
#endif
    ScaleAndOffset2D eyeToSourceNDC = CreateNDCScaleAndOffsetFromFov(fov);
    eyeToSourceNDC.Scale.x          = 0.929788947f;
    eyeToSourceNDC.Scale.y          = 0.752283394f;
    eyeToSourceNDC.Offset.x         = -0.0156717598f;
    eyeToSourceNDC.Offset.y         = 0.0f;
    if (rightEye)
    {
        eyeToSourceNDC.Offset.x *= -1;
        distortion.LensCenter.x *= -1;
    }
 
    createSLDistortionMesh((DistortionMeshVertexData**)&vertexData,
                           (uint16_t**)&indexData,
                           &vertexCount,
                           &triangleCount,
                           rightEye,
                           hmdri,
                           distortion,
                           eyeToSourceNDC);
 
    SLuint indexCount = triangleCount * 3;
 
    // Now parse the vertex data and create a render ready vertex buffer from it
    SLVVertexOculus verts;
    verts.resize(vertexCount);
 
    SLVuint tempIndex;
 
    ovrDistortionVertex* ov = vertexData;
    for (SLuint vertNum = 0; vertNum < vertexCount; vertNum++)
    {
        verts[vertNum].screenPosNDC.x  = ov->ScreenPosNDC.x;
        verts[vertNum].screenPosNDC.y  = ov->ScreenPosNDC.y;
        verts[vertNum].timeWarpFactor  = ov->TimeWarpFactor;
        verts[vertNum].vignetteFactor  = ov->VignetteFactor;
        verts[vertNum].tanEyeAnglesR.x = ov->TanEyeAnglesR.x;
        verts[vertNum].tanEyeAnglesR.y = ov->TanEyeAnglesR.y;
        verts[vertNum].tanEyeAnglesG.x = ov->TanEyeAnglesG.x;
        verts[vertNum].tanEyeAnglesG.y = ov->TanEyeAnglesG.y;
        verts[vertNum].tanEyeAnglesB.x = ov->TanEyeAnglesB.x;
        verts[vertNum].tanEyeAnglesB.y = ov->TanEyeAnglesB.y;
        ov++;
    }
 
    for (SLuint i = 0; i < indexCount; i++)
        tempIndex.push_back(indexData[i]);
 
    SLGLProgram* sp = stereoOculusDistProgram;
    sp->useProgram();
 
    // set attributes with all the same data pointer to the interleaved array
    vao.setAttrib(AT_position, 2, AT_position, &verts[0]);
    vao.setAttrib(AT_custom1, 1, 1, &verts[0]);
    vao.setAttrib(AT_custom2, 1, 2, &verts[0]);
    vao.setAttrib(AT_custom3, 2, 3, &verts[0]);
    vao.setAttrib(AT_custom4, 2, 4, &verts[0]);
    vao.setAttrib(AT_custom5, 2, 5, &verts[0]);
    vao.setIndices(indexCount, BT_uint, &tempIndex[0]);
    vao.generate(vertexCount);
 
    // dispose temp. arrays
    delete[] vertexData;
    delete[] indexData;
}

EvalCatmullRom10Spline()

float EvalCatmullRom10Spline	(	float const *	K,
		float	scaledVal
	)

Definition at line 147 of file SLGLOVRWorkaround.h.

{
    int const NumSegments = NumCoefficients;
 
#if TPH_SPLINE_STATISTICS
    // Value should be in range of 0 to (NumSegments-1) (typically 10) if spline is valid. Right?
    if (scaledVal > (NumSegments - 1))
    {
        num_out_of_range++;
        average_total_out_of_range += scaledVal;
        average_out_of_range = average_total_out_of_range / ((float)num_out_of_range);
        percent_out_of_range = 100.0f * (num_out_of_range) / num_total;
    }
    if (scaledVal > (NumSegments - 1 + 1)) num_out_of_range_over_1++;
    if (scaledVal > (NumSegments - 1 + 2)) num_out_of_range_over_2++;
    if (scaledVal > (NumSegments - 1 + 3)) num_out_of_range_over_3++;
    num_total++;
    if (scaledVal > max_scaledVal)
    {
        max_scaledVal = scaledVal;
        max_scaledVal = scaledVal;
    }
#endif
 
    float scaledValFloor = floorf(scaledVal);
    scaledValFloor       = std::max(0.0f, std::min((float)(NumSegments - 1), scaledValFloor));
    float t              = scaledVal - scaledValFloor;
    int   k              = (int)scaledValFloor;
 
    float p0, p1;
    float m0, m1;
    switch (k)
    {
        case 0:
            // Curve starts at 1.0 with gradient K[1]-K[0]
            p0 = 1.0f;
            m0 = (K[1] - K[0]); // general case would have been (K[1]-K[-1])/2
            p1 = K[1];
            m1 = 0.5f * (K[2] - K[0]);
            break;
        default:
            // General case
            p0 = K[k];
            m0 = 0.5f * (K[k + 1] - K[k - 1]);
            p1 = K[k + 1];
            m1 = 0.5f * (K[k + 2] - K[k]);
            break;
        case NumSegments - 2:
            // Last tangent is just the slope of the last two points.
            p0 = K[NumSegments - 2];
            m0 = 0.5f * (K[NumSegments - 1] - K[NumSegments - 2]);
            p1 = K[NumSegments - 1];
            m1 = K[NumSegments - 1] - K[NumSegments - 2];
            break;
        case NumSegments - 1:
            // Beyond the last segment it's just a straight line
            p0 = K[NumSegments - 1];
            m0 = K[NumSegments - 1] - K[NumSegments - 2];
            p1 = p0 + m0;
            m1 = m0;
            break;
    }
 
    float omt = 1.0f - t;
    float res = (p0 * (1.0f + 2.0f * t) + m0 * t) * omt * omt + (p1 * (1.0f + 2.0f * omt) - m1 * omt) * t * t;
 
    return res;
}

FitCubicPolynomial()

bool FitCubicPolynomial	(	float *	pResult,
		const float *	pFitX,
		const float *	pFitY
	)

Definition at line 94 of file SLGLOVRWorkaround.h.

{
    float d0 = ((pFitX[0] - pFitX[1]) * (pFitX[0] - pFitX[2]) * (pFitX[0] - pFitX[3]));
    float d1 = ((pFitX[1] - pFitX[2]) * (pFitX[1] - pFitX[3]) * (pFitX[1] - pFitX[0]));
    float d2 = ((pFitX[2] - pFitX[3]) * (pFitX[2] - pFitX[0]) * (pFitX[2] - pFitX[1]));
    float d3 = ((pFitX[3] - pFitX[0]) * (pFitX[3] - pFitX[1]) * (pFitX[3] - pFitX[2]));
 
    if ((d0 == 0.0f) || (d1 == 0.0f) || (d2 == 0.0f) || (d3 == 0.0f))
    {
        return false;
    }
 
    float f0 = pFitY[0] / d0;
    float f1 = pFitY[1] / d1;
    float f2 = pFitY[2] / d2;
    float f3 = pFitY[3] / d3;
 
    pResult[0] = -(f0 * pFitX[1] * pFitX[2] * pFitX[3] +
                   f1 * pFitX[0] * pFitX[2] * pFitX[3] +
                   f2 * pFitX[0] * pFitX[1] * pFitX[3] +
                   f3 * pFitX[0] * pFitX[1] * pFitX[2]);
    pResult[1] = f0 * (pFitX[1] * pFitX[2] + pFitX[2] * pFitX[3] + pFitX[3] * pFitX[1]) +
                 f1 * (pFitX[0] * pFitX[2] + pFitX[2] * pFitX[3] + pFitX[3] * pFitX[0]) +
                 f2 * (pFitX[0] * pFitX[1] + pFitX[1] * pFitX[3] + pFitX[3] * pFitX[0]) +
                 f3 * (pFitX[0] * pFitX[1] + pFitX[1] * pFitX[2] + pFitX[2] * pFitX[0]);
    pResult[2] = -(f0 * (pFitX[1] + pFitX[2] + pFitX[3]) +
                   f1 * (pFitX[0] + pFitX[2] + pFitX[3]) +
                   f2 * (pFitX[0] + pFitX[1] + pFitX[3]) +
                   f3 * (pFitX[0] + pFitX[1] + pFitX[2]));
    pResult[3] = f0 + f1 + f2 + f3;
 
    return true;
}

ovrMatrix4f_OrthoSubProjection()

SLMat4f ovrMatrix4f_OrthoSubProjection	(	SLMat4f	projection,
		SLVec2f	orthoScale,
		float	orthoDistance,
		float	eyeViewAdjustX
	)

Definition at line 548 of file SLGLOVRWorkaround.h.

{
 
    float orthoHorizontalOffset = eyeViewAdjustX / orthoDistance;
 
    // Current projection maps real-world vector (x,y,1) to the RT.
    // We want to find the projection that maps the range [-FovPixels/2,FovPixels/2] to
    // the physical [-orthoHalfFov,orthoHalfFov]
    // Note moving the offset from M[0][2]+M[1][2] to M[0][3]+M[1][3] - this means
    // we don't have to feed in Z=1 all the time.
    // The horizontal offset math is a little hinky because the destination is
    // actually [-orthoHalfFov+orthoHorizontalOffset,orthoHalfFov+orthoHorizontalOffset]
    // So we need to first map [-FovPixels/2,FovPixels/2] to
    //                         [-orthoHalfFov+orthoHorizontalOffset,orthoHalfFov+orthoHorizontalOffset]:
    // x1 = x0 * orthoHalfFov/(FovPixels/2) + orthoHorizontalOffset;
    //    = x0 * 2*orthoHalfFov/FovPixels + orthoHorizontalOffset;
    // But then we need the sam mapping as the existing projection matrix, i.e.
    // x2 = x1 * Projection.M[0][0] + Projection.M[0][2];
    //    = x0 * (2*orthoHalfFov/FovPixels + orthoHorizontalOffset) * Projection.M[0][0] + Projection.M[0][2];
    //    = x0 * Projection.M[0][0]*2*orthoHalfFov/FovPixels +
    //      orthoHorizontalOffset*Projection.M[0][0] + Projection.M[0][2];
    // So in the new projection matrix we need to scale by Projection.M[0][0]*2*orthoHalfFov/FovPixels and
    // offset by orthoHorizontalOffset*Projection.M[0][0] + Projection.M[0][2].
 
    SLfloat orthoData[16] = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
 
    orthoData[0]  = projection.m(0) * orthoScale.x;
    orthoData[4]  = 0.0f;
    orthoData[8]  = 0.0f;
    orthoData[12] = -projection.m(8) + (orthoHorizontalOffset * projection.m(0));
 
    orthoData[1]  = 0.0f;
    orthoData[5]  = -projection.m(5) * orthoScale.y; // Note sign flip (text rendering uses Y=down).
    orthoData[9]  = 0.0f;
    orthoData[13] = -projection.m(9);
 
    // mA: Undo effect of sign
    orthoData[2] = 0.0f;
    orthoData[1] = 0.0f;
    // orthoData[2][2] = projection.m[2][2] * projection.m[3][2] * -1.0f; // reverse right-handedness
    orthoData[10] = 0.0f;
    orthoData[14] = 0.0f;
    // projection.m[2][3];
 
    // No perspective correction for ortho.
    orthoData[3]  = 0.0f;
    orthoData[7]  = 0.0f;
    orthoData[11] = 0.0f;
    orthoData[15] = 1.0f;
 
    SLMat4f ortho(orthoData);
 
    return ortho;
}

TransformRendertargetNDCToTanFovSpace()

SLVec2f TransformRendertargetNDCToTanFovSpace	(	const ScaleAndOffset2D &	eyeToSourceNDC,
		const SLVec2f &	textureNDC
	)

Definition at line 739 of file SLGLOVRWorkaround.h.

{
    SLVec2f tanEyeAngle;
    tanEyeAngle.x = (textureNDC.x - eyeToSourceNDC.Offset.x) / eyeToSourceNDC.Scale.x;
    tanEyeAngle.y = (textureNDC.y - eyeToSourceNDC.Offset.y) / eyeToSourceNDC.Scale.y;
    return tanEyeAngle;
}

TransformScreenNDCToTanFovSpaceChroma()

void TransformScreenNDCToTanFovSpaceChroma	(	SLVec2f *	resultR,
		SLVec2f *	resultG,
		SLVec2f *	resultB,
		DistortionRenderDesc const &	distortion,
		const SLVec2f &	framebufferNDC
	)

Definition at line 687 of file SLGLOVRWorkaround.h.

{
    // Scale to TanHalfFov space, but still distorted.
    SLVec2f tanEyeAngleDistorted;
    tanEyeAngleDistorted.x = (framebufferNDC.x - distortion.LensCenter.x) * distortion.TanEyeAngleScale.x;
    tanEyeAngleDistorted.y = (framebufferNDC.y - distortion.LensCenter.y) * distortion.TanEyeAngleScale.y;
    // Distort.
    float   radiusSquared    = (tanEyeAngleDistorted.x * tanEyeAngleDistorted.x) + (tanEyeAngleDistorted.y * tanEyeAngleDistorted.y);
    SLVec3f distortionScales = distortion.Lens.DistortionFnScaleRadiusSquaredChroma(radiusSquared);
    *resultR                 = tanEyeAngleDistorted * distortionScales.x;
    *resultG                 = tanEyeAngleDistorted * distortionScales.y;
    *resultB                 = tanEyeAngleDistorted * distortionScales.z;
}

TransformTanFovSpaceToRendertargetNDC()

SLVec2f TransformTanFovSpaceToRendertargetNDC	(	ScaleAndOffset2D const &	eyeToSourceNDC,
		SLVec2f const &	tanEyeAngle
	)

Definition at line 728 of file SLGLOVRWorkaround.h.

{
    SLVec2f textureNDC;
    textureNDC.x = tanEyeAngle.x * eyeToSourceNDC.Scale.x + eyeToSourceNDC.Offset.x;
    textureNDC.y = tanEyeAngle.y * eyeToSourceNDC.Scale.y + eyeToSourceNDC.Offset.y;
    return textureNDC;
}

TransformTanFovSpaceToScreenNDC()

SLVec2f TransformTanFovSpaceToScreenNDC	(	DistortionRenderDesc const &	distortion,
		const SLVec2f &	tanEyeAngle,
		bool	usePolyApprox
	)

Definition at line 662 of file SLGLOVRWorkaround.h.

{
    float tanEyeAngleRadius          = tanEyeAngle.length();
    float tanEyeAngleDistortedRadius = distortion.Lens.DistortionFnInverseApprox(tanEyeAngleRadius);
    if (!usePolyApprox)
    {
        tanEyeAngleDistortedRadius = distortion.Lens.DistortionFnInverse(tanEyeAngleRadius);
    }
    SLVec2f tanEyeAngleDistorted = tanEyeAngle;
    if (tanEyeAngleRadius > 0.0f)
    {
        tanEyeAngleDistorted = tanEyeAngle * (tanEyeAngleDistortedRadius / tanEyeAngleRadius);
    }
 
    SLVec2f framebufferNDC;
    framebufferNDC.x = (tanEyeAngleDistorted.x / distortion.TanEyeAngleScale.x) + distortion.LensCenter.x;
    framebufferNDC.y = (tanEyeAngleDistorted.y / distortion.TanEyeAngleScale.y) + distortion.LensCenter.y;
 
    return framebufferNDC;
}