OVR_Stereo.cpp

Go to the documentation of this file.

/************************************************************************************

Filename    :   OVR_Stereo.cpp
Content     :   Stereo rendering functions
Created     :   November 30, 2013
Authors     :   Tom Fosyth

Copyright   :   Copyright 2014 Oculus VR, Inc. All Rights reserved.

Licensed under the Oculus VR Rift SDK License Version 3.1 (the "License"); 
you may not use the Oculus VR Rift SDK except in compliance with the License, 
which is provided at the time of installation or download, or which 
otherwise accompanies this software in either electronic or hard copy form.

You may obtain a copy of the License at

http://www.oculusvr.com/licenses/LICENSE-3.1 

Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

*************************************************************************************/

#include "OVR_Stereo.h"
#include "OVR_Profile.h"
#include "Kernel/OVR_Log.h"
#include "Kernel/OVR_Alg.h"

//To allow custom distortion to be introduced to CatMulSpline.
float (*CustomDistortion)(float) = NULL;
float (*CustomDistortionInv)(float) = NULL;


namespace OVR {


using namespace Alg;

//-----------------------------------------------------------------------------------

// Inputs are 4 points (pFitX[0],pFitY[0]) through (pFitX[3],pFitY[3])
// Result is four coefficients in pResults[0] through pResults[3] such that
//      y = pResult[0] + x * ( pResult[1] + x * ( pResult[2] + x * ( pResult[3] ) ) );
// passes through all four input points.
// Return is true if it succeeded, false if it failed (because two control points
// have the same pFitX value).
bool FitCubicPolynomial ( float *pResult, const float *pFitX, const float *pFitY )
{
    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;
}



float EvalCatmullRom10Spline ( float const *K, float scaledVal )
{
    int const NumSegments = LensConfig::NumCoefficients;

    float scaledValFloor = floorf ( scaledVal );
    scaledValFloor = Alg::Max ( 0.0f, Alg::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;
}




// Converts a Profile eyecup string into an eyecup enumeration
void SetEyeCup(HmdRenderInfo* renderInfo, const char* cup)
{
    if (OVR_strcmp(cup, "A") == 0)
        renderInfo->EyeCups = EyeCup_DK1A;
    else if (OVR_strcmp(cup, "B") == 0)
        renderInfo->EyeCups = EyeCup_DK1B;
    else if (OVR_strcmp(cup, "C") == 0)
        renderInfo->EyeCups = EyeCup_DK1C;
    else if (OVR_strcmp(cup, "Orange A") == 0)
        renderInfo->EyeCups =  EyeCup_OrangeA;
    else if (OVR_strcmp(cup, "Red A") == 0)
        renderInfo->EyeCups = EyeCup_RedA;
    else if (OVR_strcmp(cup, "Pink A") == 0)
        renderInfo->EyeCups = EyeCup_PinkA;
    else if (OVR_strcmp(cup, "Blue A") == 0)
        renderInfo->EyeCups = EyeCup_BlueA;
    else
        renderInfo->EyeCups = EyeCup_DK1A;
}



//-----------------------------------------------------------------------------------


// The result is a scaling applied to the distance.
float LensConfig::DistortionFnScaleRadiusSquared (float rsq) const
{
    float scale = 1.0f;
    switch ( Eqn )
    {
    case Distortion_Poly4:
        // This version is deprecated! Prefer one of the other two.
        scale = ( K[0] + rsq * ( K[1] + rsq * ( K[2] + rsq * K[3] ) ) );
        break;
    case Distortion_RecipPoly4:
        scale = 1.0f / ( K[0] + rsq * ( K[1] + rsq * ( K[2] + rsq * K[3] ) ) );
        break;
    case Distortion_CatmullRom10:{
        // A Catmull-Rom spline through the values 1.0, K[1], K[2] ... K[10]
        // evenly spaced in R^2 from 0.0 to MaxR^2
        // K[0] controls the slope at radius=0.0, rather than the actual value.
        const int NumSegments = LensConfig::NumCoefficients;
        OVR_ASSERT ( NumSegments <= NumCoefficients );
        float scaledRsq = (float)(NumSegments-1) * rsq / ( MaxR * MaxR );
        scale = EvalCatmullRom10Spline ( K, scaledRsq );


        //Intercept, and overrule if needed
        if (CustomDistortion)
        {
            scale = CustomDistortion(rsq);
        }

        }break;
    default:
        OVR_ASSERT ( false );
        break;
    }
    return scale;
}

// x,y,z components map to r,g,b
Vector3f LensConfig::DistortionFnScaleRadiusSquaredChroma (float rsq) const
{
    float scale = DistortionFnScaleRadiusSquared ( rsq );
    Vector3f scaleRGB;
    scaleRGB.x = scale * ( 1.0f + ChromaticAberration[0] + rsq * ChromaticAberration[1] );     // Red
    scaleRGB.y = scale;                                                                        // Green
    scaleRGB.z = scale * ( 1.0f + ChromaticAberration[2] + rsq * ChromaticAberration[3] );     // Blue
    return scaleRGB;
}

// DistortionFnInverse computes the inverse of the distortion function on an argument.
float LensConfig::DistortionFnInverse(float r) const
{    
    OVR_ASSERT((r <= 20.0f));

    float s, d;
    float delta = r * 0.25f;

    // Better to start guessing too low & take longer to converge than too high
    // and hit singularities. Empirically, r * 0.5f is too high in some cases.
    s = r * 0.25f;
    d = fabs(r - DistortionFn(s));

    for (int i = 0; i < 20; i++)
    {
        float sUp   = s + delta;
        float sDown = s - delta;
        float dUp   = fabs(r - DistortionFn(sUp));
        float dDown = fabs(r - DistortionFn(sDown));

        if (dUp < d)
        {
            s = sUp;
            d = dUp;
        }
        else if (dDown < d)
        {
            s = sDown;
            d = dDown;
        }
        else
        {
            delta *= 0.5f;
        }
    }

    return s;
}



float LensConfig::DistortionFnInverseApprox(float r) const
{
    float rsq = r * r;
    float scale = 1.0f;
    switch ( Eqn )
    {
    case Distortion_Poly4:
        // Deprecated
        OVR_ASSERT ( false );
        break;
    case Distortion_RecipPoly4:
        scale = 1.0f / ( InvK[0] + rsq * ( InvK[1] + rsq * ( InvK[2] + rsq * InvK[3] ) ) );
        break;
    case Distortion_CatmullRom10:{
        // A Catmull-Rom spline through the values 1.0, K[1], K[2] ... K[9]
        // evenly spaced in R^2 from 0.0 to MaxR^2
        // K[0] controls the slope at radius=0.0, rather than the actual value.
        const int NumSegments = LensConfig::NumCoefficients;
        OVR_ASSERT ( NumSegments <= NumCoefficients );
        float scaledRsq = (float)(NumSegments-1) * rsq / ( MaxInvR * MaxInvR );
        scale = EvalCatmullRom10Spline ( InvK, scaledRsq );

        //Intercept, and overrule if needed
        if (CustomDistortionInv)
        {
            scale = CustomDistortionInv(rsq);
        }

        }break;
    default:
        OVR_ASSERT ( false );
        break;
    }
    return r * scale;
}

void LensConfig::SetUpInverseApprox()
{
    float maxR = MaxInvR;

    switch ( Eqn )
    {
    case Distortion_Poly4:
        // Deprecated
        OVR_ASSERT ( false );
        break;
    case Distortion_RecipPoly4:{

        float sampleR[4];
        float sampleRSq[4];
        float sampleInv[4];
        float sampleFit[4];

        // Found heuristically...
        sampleR[0] = 0.0f;
        sampleR[1] = maxR * 0.4f;
        sampleR[2] = maxR * 0.8f;
        sampleR[3] = maxR * 1.5f;
        for ( int i = 0; i < 4; i++ )
        {
            sampleRSq[i] = sampleR[i] * sampleR[i];
            sampleInv[i] = DistortionFnInverse ( sampleR[i] );
            sampleFit[i] = sampleR[i] / sampleInv[i];
        }
        sampleFit[0] = 1.0f;
        FitCubicPolynomial ( InvK, sampleRSq, sampleFit );

    #if 0
        // Should be a nearly exact match on the chosen points.
        OVR_ASSERT ( fabs ( DistortionFnInverse ( sampleR[0] ) - DistortionFnInverseApprox ( sampleR[0] ) ) / maxR < 0.0001f );
        OVR_ASSERT ( fabs ( DistortionFnInverse ( sampleR[1] ) - DistortionFnInverseApprox ( sampleR[1] ) ) / maxR < 0.0001f );
        OVR_ASSERT ( fabs ( DistortionFnInverse ( sampleR[2] ) - DistortionFnInverseApprox ( sampleR[2] ) ) / maxR < 0.0001f );
        OVR_ASSERT ( fabs ( DistortionFnInverse ( sampleR[3] ) - DistortionFnInverseApprox ( sampleR[3] ) ) / maxR < 0.0001f );
        // Should be a decent match on the rest of the range.
        const int maxCheck = 20;
        for ( int i = 0; i < maxCheck; i++ )
        {
            float checkR = (float)i * maxR / (float)maxCheck;
            float realInv = DistortionFnInverse       ( checkR );
            float testInv = DistortionFnInverseApprox ( checkR );
            float error = fabsf ( realInv - testInv ) / maxR;
            OVR_ASSERT ( error < 0.1f );
        }
    #endif

        }break;
    case Distortion_CatmullRom10:{

        const int NumSegments = LensConfig::NumCoefficients;
        OVR_ASSERT ( NumSegments <= NumCoefficients );
        for ( int i = 1; i < NumSegments; i++ )
        {
            float scaledRsq = (float)i;
            float rsq = scaledRsq * MaxInvR * MaxInvR / (float)( NumSegments - 1);
            float r = sqrtf ( rsq );
            float inv = DistortionFnInverse ( r );
            InvK[i] = inv / r;
            InvK[0] = 1.0f;     // TODO: fix this.
        }

#if 0
        const int maxCheck = 20;
        for ( int i = 0; i <= maxCheck; i++ )
        {
            float checkR = (float)i * MaxInvR / (float)maxCheck;
            float realInv = DistortionFnInverse       ( checkR );
            float testInv = DistortionFnInverseApprox ( checkR );
            float error = fabsf ( realInv - testInv ) / MaxR;
            OVR_ASSERT ( error < 0.01f );
        }
#endif

        }break;

    default:
        break;
    }
}


void LensConfig::SetToIdentity()
{
    for ( int i = 0; i < NumCoefficients; i++ )
    {
        K[i] = 0.0f;
        InvK[i] = 0.0f;
    }
    Eqn = Distortion_RecipPoly4;
    K[0] = 1.0f;
    InvK[0] = 1.0f;
    MaxR = 1.0f;
    MaxInvR = 1.0f;
    ChromaticAberration[0] = 0.0f;
    ChromaticAberration[1] = 0.0f;
    ChromaticAberration[2] = 0.0f;
    ChromaticAberration[3] = 0.0f;
    MetersPerTanAngleAtCenter = 0.05f;
}


enum LensConfigStoredVersion
{
    LCSV_CatmullRom10Version1 = 1
};

// DO NOT CHANGE THESE ONCE THEY HAVE BEEN BAKED INTO FIRMWARE.
// If something needs to change, add a new one!
struct LensConfigStored_CatmullRom10Version1
{
    // All these items must be fixed-length integers - no "float", no "int", etc.
    UInt16      VersionNumber;      // Must be LCSV_CatmullRom10Version1

    UInt16      K[11];
    UInt16      MaxR;
    UInt16      MetersPerTanAngleAtCenter;
    UInt16      ChromaticAberration[4];
    // InvK and MaxInvR are calculated on load.
};

UInt16 EncodeFixedPointUInt16 ( float val, UInt16 zeroVal, int fractionalBits )
{
    OVR_ASSERT ( ( fractionalBits >= 0 ) && ( fractionalBits < 31 ) );
    float valWhole = val * (float)( 1 << fractionalBits );
    valWhole += (float)zeroVal + 0.5f;
    valWhole = floorf ( valWhole );
    OVR_ASSERT ( ( valWhole >= 0.0f ) && ( valWhole < (float)( 1 << 16 ) ) );
    return (UInt16)valWhole;
}

float DecodeFixedPointUInt16 ( UInt16 val, UInt16 zeroVal, int fractionalBits )
{
    OVR_ASSERT ( ( fractionalBits >= 0 ) && ( fractionalBits < 31 ) );
    float valFloat = (float)val;
    valFloat -= (float)zeroVal;
    valFloat *= 1.0f / (float)( 1 << fractionalBits );
    return valFloat;
}


// Returns true on success.
bool LoadLensConfig ( LensConfig *presult, UByte const *pbuffer, int bufferSizeInBytes )
{
    if ( bufferSizeInBytes < 2 )
    {
        // Can't even tell the version number!
        return false;
    }
    UInt16 version = DecodeUInt16 ( pbuffer + 0 );
    switch ( version )
    {
    case LCSV_CatmullRom10Version1:
        {
            if ( bufferSizeInBytes < (int)sizeof(LensConfigStored_CatmullRom10Version1) )
            {
                return false;
            }
            LensConfigStored_CatmullRom10Version1 lcs;
            lcs.VersionNumber               = DecodeUInt16 ( pbuffer + 0 );
            for ( int i = 0; i < 11; i++ )
            {
                lcs.K[i]                    = DecodeUInt16 ( pbuffer + 2 + 2*i );
            }
            lcs.MaxR                        = DecodeUInt16 ( pbuffer + 24 );
            lcs.MetersPerTanAngleAtCenter   = DecodeUInt16 ( pbuffer + 26 );
            for ( int i = 0; i < 4; i++ )
            {
                lcs.ChromaticAberration[i]  = DecodeUInt16 ( pbuffer + 28 + 2*i );
            }
            OVR_COMPILER_ASSERT ( sizeof(lcs) ==                       36 );

            // Convert to the real thing.
            LensConfig result;
            result.Eqn = Distortion_CatmullRom10;
            for ( int i = 0; i < 11; i++ )
            {
                // K[] are mostly 1.something. They may get significantly bigger, but they never hit 0.0.
                result.K[i] = DecodeFixedPointUInt16 ( lcs.K[i], 0, 14 );
            }
            // MaxR is tan(angle), so always >0, typically just over 1.0 (45 degrees half-fov),
            // but may get arbitrarily high. tan(76)=4 is a very reasonable limit!
            result.MaxR = DecodeFixedPointUInt16 ( lcs.MaxR, 0, 14 );
            // MetersPerTanAngleAtCenter is also known as focal length!
            // Typically around 0.04 for our current screens, minimum of 0, sensible maximum of 0.125 (i.e. 3 "extra" bits of fraction)
            result.MetersPerTanAngleAtCenter = DecodeFixedPointUInt16 ( lcs.MetersPerTanAngleAtCenter, 0, 16+3 );
            for ( int i = 0; i < 4; i++ )
            {
                // ChromaticAberration[] are mostly 0.0something, centered on 0.0. Largest seen is 0.04, so set max to 0.125 (i.e. 3 "extra" bits of fraction)
                result.ChromaticAberration[i] = DecodeFixedPointUInt16 ( lcs.ChromaticAberration[i], 0x8000, 16+3 );
            }
            result.MaxInvR = result.DistortionFn ( result.MaxR );
            result.SetUpInverseApprox();

            OVR_ASSERT ( version == lcs.VersionNumber );

            *presult = result;
        }
        break;
    default:
        // Unknown format.
        return false;
        break;
    }
    return true;
}

// Returns number of bytes needed.
int SaveLensConfigSizeInBytes ( LensConfig const &config )
{
    OVR_UNUSED ( config );
    return sizeof ( LensConfigStored_CatmullRom10Version1 );
}

// Returns true on success.
bool SaveLensConfig ( UByte *pbuffer, int bufferSizeInBytes, LensConfig const &config )
{
    if ( bufferSizeInBytes < (int)sizeof ( LensConfigStored_CatmullRom10Version1 ) )
    {
        return false;
    }

    // Construct the values.
    LensConfigStored_CatmullRom10Version1 lcs;
    lcs.VersionNumber = LCSV_CatmullRom10Version1;
    for ( int i = 0; i < 11; i++ )
    {
        // K[] are mostly 1.something. They may get significantly bigger, but they never hit 0.0.
        lcs.K[i] = EncodeFixedPointUInt16 ( config.K[i], 0, 14 );
    }
    // MaxR is tan(angle), so always >0, typically just over 1.0 (45 degrees half-fov),
    // but may get arbitrarily high. tan(76)=4 is a very reasonable limit!
    lcs.MaxR = EncodeFixedPointUInt16 ( config.MaxR, 0, 14 );
    // MetersPerTanAngleAtCenter is also known as focal length!
    // Typically around 0.04 for our current screens, minimum of 0, sensible maximum of 0.125 (i.e. 3 "extra" bits of fraction)
    lcs.MetersPerTanAngleAtCenter = EncodeFixedPointUInt16 ( config.MetersPerTanAngleAtCenter, 0, 16+3 );
    for ( int i = 0; i < 4; i++ )
    {
        // ChromaticAberration[] are mostly 0.0something, centered on 0.0. Largest seen is 0.04, so set max to 0.125 (i.e. 3 "extra" bits of fraction)
        lcs.ChromaticAberration[i] = EncodeFixedPointUInt16 ( config.ChromaticAberration[i], 0x8000, 16+3 );
    }


    // Now store them out, sensitive to endinness.
    EncodeUInt16 (      pbuffer + 0,        lcs.VersionNumber );
    for ( int i = 0; i < 11; i++ )
    {
        EncodeUInt16 (  pbuffer + 2 + 2*i,  lcs.K[i] );
    }
    EncodeUInt16 (      pbuffer + 24,       lcs.MaxR );
    EncodeUInt16 (      pbuffer + 26,       lcs.MetersPerTanAngleAtCenter );
    for ( int i = 0; i < 4; i++ )
    {
        EncodeUInt16 (  pbuffer + 28 + 2*i, lcs.ChromaticAberration[i] );
    }
    OVR_COMPILER_ASSERT (         36        == sizeof(lcs) );

    return true;
}

#ifdef OVR_BUILD_DEBUG
void TestSaveLoadLensConfig ( LensConfig const &config )
{
    OVR_ASSERT ( config.Eqn == Distortion_CatmullRom10 );
    // As a test, make sure this can be encoded and decoded correctly.
    const int bufferSize = 256;
    UByte buffer[bufferSize];
    OVR_ASSERT ( SaveLensConfigSizeInBytes ( config ) < bufferSize );
    bool success;
    success = SaveLensConfig ( buffer, bufferSize, config );
    OVR_ASSERT ( success );
    LensConfig testConfig;
    success = LoadLensConfig ( &testConfig, buffer, bufferSize );
    OVR_ASSERT ( success );
    OVR_ASSERT ( testConfig.Eqn == config.Eqn );
    for ( int i = 0; i < 11; i++ )
    {
        OVR_ASSERT ( fabs ( testConfig.K[i] - config.K[i] ) < 0.0001f );
    }
    OVR_ASSERT ( fabsf ( testConfig.MaxR - config.MaxR ) < 0.0001f );
    OVR_ASSERT ( fabsf ( testConfig.MetersPerTanAngleAtCenter - config.MetersPerTanAngleAtCenter ) < 0.00001f );
    for ( int i = 0; i < 4; i++ )
    {
        OVR_ASSERT ( fabsf ( testConfig.ChromaticAberration[i] - config.ChromaticAberration[i] ) < 0.00001f );
    }
}
#endif



//-----------------------------------------------------------------------------------

// TBD: There is a question of whether this is the best file for CreateDebugHMDInfo. As long as there are many
// constants for HmdRenderInfo here as well it is ok. The alternative would be OVR_Common_HMDDevice.cpp, but
// that's specialized per platform... should probably move it there onces the code is in the common base class.

HMDInfo CreateDebugHMDInfo(HmdTypeEnum hmdType)
{
    HMDInfo info;    

    if ((hmdType != HmdType_DK1) &&
        (hmdType != HmdType_CrystalCoveProto))
    {
        LogText("Debug HMDInfo - HmdType not supported. Defaulting to DK1.\n");
        hmdType = HmdType_DK1;
    }

    // The alternative would be to initialize info.HmdType to HmdType_None instead. If we did that,
    // code wouldn't be "maximally compatible" and devs wouldn't know what device we are
    // simulating... so if differentiation becomes necessary we better add Debug flag in the future.
    info.HmdType      = hmdType;
    info.Manufacturer = "Oculus VR";    

    switch(hmdType)
    {
    case HmdType_DK1:
        info.ProductName                            = "Oculus Rift DK1";
        info.ResolutionInPixels                     = Sizei ( 1280, 800 );
        info.ScreenSizeInMeters                     = Sizef ( 0.1498f, 0.0936f );
        info.ScreenGapSizeInMeters                  = 0.0f;
        info.CenterFromTopInMeters                  = 0.0468f;
        info.LensSeparationInMeters                 = 0.0635f;
        info.Shutter.Type                           = HmdShutter_RollingTopToBottom;
        info.Shutter.VsyncToNextVsync               = ( 1.0f / 60.0f );
        info.Shutter.VsyncToFirstScanline           = 0.000052f;
        info.Shutter.FirstScanlineToLastScanline    = 0.016580f;
        info.Shutter.PixelSettleTime                = 0.015f;
        info.Shutter.PixelPersistence               = ( 1.0f / 60.0f );
        break;

    case HmdType_CrystalCoveProto:
        info.ProductName                            = "Oculus Rift Crystal Cove";        
        info.ResolutionInPixels                     = Sizei ( 1920, 1080 );
        info.ScreenSizeInMeters                     = Sizef ( 0.12576f, 0.07074f );
        info.ScreenGapSizeInMeters                  = 0.0f;
        info.CenterFromTopInMeters                  = info.ScreenSizeInMeters.h * 0.5f;
        info.LensSeparationInMeters                 = 0.0635f;
        info.Shutter.Type                           = HmdShutter_RollingRightToLeft;
        info.Shutter.VsyncToNextVsync               = ( 1.0f / 76.0f );
        info.Shutter.VsyncToFirstScanline           = 0.0000273f;
        info.Shutter.FirstScanlineToLastScanline    = 0.0131033f;
        info.Shutter.PixelSettleTime                = 0.0f;
        info.Shutter.PixelPersistence               = 0.18f * info.Shutter.VsyncToNextVsync;
        break;

    case HmdType_DK2:
        info.ProductName                            = "Oculus Rift DK2";        
        info.ResolutionInPixels                     = Sizei ( 1920, 1080 );
        info.ScreenSizeInMeters                     = Sizef ( 0.12576f, 0.07074f );
        info.ScreenGapSizeInMeters                  = 0.0f;
        info.CenterFromTopInMeters                  = info.ScreenSizeInMeters.h * 0.5f;
        info.LensSeparationInMeters                 = 0.0635f;
        info.Shutter.Type                           = HmdShutter_RollingRightToLeft;
        info.Shutter.VsyncToNextVsync               = ( 1.0f / 76.0f );
        info.Shutter.VsyncToFirstScanline           = 0.0000273f;
        info.Shutter.FirstScanlineToLastScanline    = 0.0131033f;
        info.Shutter.PixelSettleTime                = 0.0f;
        info.Shutter.PixelPersistence               = 0.18f * info.Shutter.VsyncToNextVsync;
        break;

    default:
        break;
    }

    return info;
}



// profile may be NULL, in which case it uses the hard-coded defaults.
HmdRenderInfo GenerateHmdRenderInfoFromHmdInfo ( HMDInfo const &hmdInfo, 
                                                 Profile const *profile /*=NULL*/,
                                                 DistortionEqnType distortionType /*= Distortion_CatmullRom10*/,
                                                 EyeCupType eyeCupOverride /*= EyeCup_LAST*/ )
{
    HmdRenderInfo renderInfo;

    renderInfo.HmdType                              = hmdInfo.HmdType;
    renderInfo.ResolutionInPixels                   = hmdInfo.ResolutionInPixels;
    renderInfo.ScreenSizeInMeters                   = hmdInfo.ScreenSizeInMeters;
    renderInfo.CenterFromTopInMeters                = hmdInfo.CenterFromTopInMeters;
    renderInfo.ScreenGapSizeInMeters                = hmdInfo.ScreenGapSizeInMeters;
    renderInfo.LensSeparationInMeters               = hmdInfo.LensSeparationInMeters;

    OVR_ASSERT ( sizeof(renderInfo.Shutter) == sizeof(hmdInfo.Shutter) );   // Try to keep the files in sync!
    renderInfo.Shutter.Type                         = hmdInfo.Shutter.Type;
    renderInfo.Shutter.VsyncToNextVsync             = hmdInfo.Shutter.VsyncToNextVsync;
    renderInfo.Shutter.VsyncToFirstScanline         = hmdInfo.Shutter.VsyncToFirstScanline;
    renderInfo.Shutter.FirstScanlineToLastScanline  = hmdInfo.Shutter.FirstScanlineToLastScanline;
    renderInfo.Shutter.PixelSettleTime              = hmdInfo.Shutter.PixelSettleTime;
    renderInfo.Shutter.PixelPersistence             = hmdInfo.Shutter.PixelPersistence;

    renderInfo.LensDiameterInMeters                 = 0.035f;
    renderInfo.LensSurfaceToMidplateInMeters        = 0.025f;
    renderInfo.EyeCups                              = EyeCup_DK1A;

#if 0       // Device settings are out of date - don't use them.
    if (Contents & Contents_Distortion)
    {
        memcpy(renderInfo.DistortionK, DistortionK, sizeof(float)*4);
        renderInfo.DistortionEqn = Distortion_RecipPoly4;
    }
#endif

    // Defaults in case of no user profile.
    renderInfo.EyeLeft.NoseToPupilInMeters   = 0.032f;
    renderInfo.EyeLeft.ReliefInMeters        = 0.012f;

    // 10mm eye-relief laser numbers for DK1 lenses.
    // These are a decent seed for finding eye-relief and IPD.
    // These are NOT used for rendering!
    // Rendering distortions are now in GenerateLensConfigFromEyeRelief()
    // So, if you're hacking in new distortions, don't do it here!
    renderInfo.EyeLeft.Distortion.SetToIdentity();
    renderInfo.EyeLeft.Distortion.MetersPerTanAngleAtCenter = 0.0449f;
    renderInfo.EyeLeft.Distortion.Eqn       = Distortion_RecipPoly4;
    renderInfo.EyeLeft.Distortion.K[0]      =  1.0f;
    renderInfo.EyeLeft.Distortion.K[1]      = -0.494165344f;
    renderInfo.EyeLeft.Distortion.K[2]      = 0.587046423f;
    renderInfo.EyeLeft.Distortion.K[3]      = -0.841887126f;
    renderInfo.EyeLeft.Distortion.MaxR      = 1.0f;

    renderInfo.EyeLeft.Distortion.ChromaticAberration[0] = -0.006f;
    renderInfo.EyeLeft.Distortion.ChromaticAberration[1] =  0.0f;
    renderInfo.EyeLeft.Distortion.ChromaticAberration[2] =  0.014f;
    renderInfo.EyeLeft.Distortion.ChromaticAberration[3] =  0.0f;

    renderInfo.EyeRight = renderInfo.EyeLeft;


    // Obtain data from profile.
    if ( profile != NULL )
    {
        char eyecup[16];
        if (profile->GetValue(OVR_KEY_EYE_CUP, eyecup, 16))
            SetEyeCup(&renderInfo, eyecup);
    }

    switch ( hmdInfo.HmdType )
    {
    case HmdType_None:
    case HmdType_DKProto:
    case HmdType_DK1:
        // Slight hack to improve usability.
        // If you have a DKHD-style lens profile enabled,
        // but you plug in DK1 and forget to change the profile,
        // obviously you don't want those lens numbers.
        if ( ( renderInfo.EyeCups != EyeCup_DK1A ) &&
             ( renderInfo.EyeCups != EyeCup_DK1B ) &&
             ( renderInfo.EyeCups != EyeCup_DK1C ) )
        {
            renderInfo.EyeCups = EyeCup_DK1A;
        }
        break;

    case HmdType_DKHD2Proto:
        renderInfo.EyeCups = EyeCup_DKHD2A;
        break;
    case HmdType_CrystalCoveProto:
        renderInfo.EyeCups = EyeCup_PinkA;
        break;
    case HmdType_DK2:
        renderInfo.EyeCups = EyeCup_DK2A;
        break;
    default:
        break;
    }

    if ( eyeCupOverride != EyeCup_LAST )
    {
        renderInfo.EyeCups = eyeCupOverride;
    }

    switch ( renderInfo.EyeCups )
    {
    case EyeCup_DK1A:
    case EyeCup_DK1B:
    case EyeCup_DK1C:
        renderInfo.LensDiameterInMeters                   = 0.035f;
        renderInfo.LensSurfaceToMidplateInMeters          = 0.02357f;
        // Not strictly lens-specific, but still wise to set a reasonable default for relief.
        renderInfo.EyeLeft.ReliefInMeters                 = 0.010f; 
        renderInfo.EyeRight.ReliefInMeters                = 0.010f; 
        break;
    case EyeCup_DKHD2A:
        renderInfo.LensDiameterInMeters                   = 0.035f;
        renderInfo.LensSurfaceToMidplateInMeters          = 0.02357f;
        // Not strictly lens-specific, but still wise to set a reasonable default for relief.
        renderInfo.EyeLeft.ReliefInMeters                 = 0.010f; 
        renderInfo.EyeRight.ReliefInMeters                = 0.010f; 
        break;
    case EyeCup_PinkA:
    case EyeCup_DK2A:
        renderInfo.LensDiameterInMeters                   = 0.04f;      // approximate
        renderInfo.LensSurfaceToMidplateInMeters          = 0.01965f;
        // Not strictly lens-specific, but still wise to set a reasonable default for relief.
        renderInfo.EyeLeft.ReliefInMeters                 = 0.012f;
        renderInfo.EyeRight.ReliefInMeters                = 0.012f;
        break;
    default: OVR_ASSERT ( false ); break;
    }

    if ( profile != NULL )
    {
        // Set the customized user eye position
        // TBD: Maybe we should separate custom camera positioning from custom distortion rendering ??
        if (profile->GetBoolValue(OVR_KEY_CUSTOM_EYE_RENDER, true))
        {
            float eye2nose[2];
            if (profile->GetFloatValues(OVR_KEY_EYE_TO_NOSE_DISTANCE, eye2nose, 2) == 2)
            {   // Load per-eye half-IPD
                renderInfo.EyeLeft.NoseToPupilInMeters = eye2nose[0];
                renderInfo.EyeRight.NoseToPupilInMeters = eye2nose[1];
            }
            else
            {   // Use a centered IPD instead
                float ipd = profile->GetFloatValue(OVR_KEY_IPD, OVR_DEFAULT_IPD);
                renderInfo.EyeLeft.NoseToPupilInMeters = 0.5f * ipd;
                renderInfo.EyeRight.NoseToPupilInMeters = 0.5f * ipd;
            }
        
            float eye2plate[2];
            if (profile->GetFloatValues(OVR_KEY_MAX_EYE_TO_PLATE_DISTANCE, eye2plate, 2) == 2)
            {   // Subtract the eye-cup height from the plate distance to get the eye-to-lens distance
                // This measurement should be the the distance at maximum dial setting
                // We still need to adjust with the dial offset
                renderInfo.EyeLeft.ReliefInMeters = eye2plate[0] - renderInfo.LensSurfaceToMidplateInMeters;
                renderInfo.EyeRight.ReliefInMeters = eye2plate[1] - renderInfo.LensSurfaceToMidplateInMeters;

                // Adjust the eye relief with the dial setting (from the assumed max eye relief)
                int dial = profile->GetIntValue(OVR_KEY_EYE_RELIEF_DIAL, -1);
                if (dial >= 0)
                {
                    renderInfo.EyeLeft.ReliefInMeters -= ((10 - dial) * 0.001f);
                    renderInfo.EyeRight.ReliefInMeters -= ((10 - dial) * 0.001f);
                }
            }
            else
            {
                // Set the eye relief with the user configured dial setting
                int dial = profile->GetIntValue(OVR_KEY_EYE_RELIEF_DIAL, -1);
                if (dial >= 0)
                {   // Assume a default of 7 to 17 mm eye relief based on the dial.  This corresponds
                    // to the sampled and tuned distortion range on the DK1.
                    renderInfo.EyeLeft.ReliefInMeters = 0.007f + (dial * 0.001f);
                    renderInfo.EyeRight.ReliefInMeters = 0.007f + (dial * 0.001f);
                }
            }
        }
    }

    // Now we know where the eyes are relative to the lenses, we can compute a distortion for each.
    // TODO: incorporate lateral offset in distortion generation.
    // TODO: we used a distortion to calculate eye-relief, and now we're making a distortion from that eye-relief. Close the loop!

    for ( int eyeNum = 0; eyeNum < 2; eyeNum++ )
    {
        HmdRenderInfo::EyeConfig *pHmdEyeConfig = ( eyeNum == 0 ) ? &(renderInfo.EyeLeft) : &(renderInfo.EyeRight);

        float eye_relief = pHmdEyeConfig->ReliefInMeters;
        LensConfig distortionConfig = GenerateLensConfigFromEyeRelief ( eye_relief, renderInfo, distortionType );
        pHmdEyeConfig->Distortion = distortionConfig;
    }

    return renderInfo;
}


LensConfig GenerateLensConfigFromEyeRelief ( float eyeReliefInMeters, HmdRenderInfo const &hmd, DistortionEqnType distortionType /*= Distortion_CatmullRom10*/ )
{
    struct DistortionDescriptor
    {
        float EyeRelief;
        // The three places we're going to sample & lerp the curve at.
        // One sample is always at 0.0, and the distortion scale should be 1.0 or else!
        // Only use for poly4 numbers - CR has an implicit scale.
        float SampleRadius[3];
        // Where the distortion has actually been measured/calibrated out to.
        // Don't try to hallucinate data out beyond here.
        float MaxRadius;
        // The config itself.
        LensConfig Config;
    };

    DistortionDescriptor distortions[10];
    for ( unsigned int i = 0; i < sizeof(distortions)/sizeof(distortions[0]); i++ )
    {
        distortions[i].Config.SetToIdentity();
        distortions[i].EyeRelief = 0.0f;
        distortions[i].MaxRadius = 1.0f;
    }
    int numDistortions = 0;
    int defaultDistortion = 0;     // index of the default distortion curve to use if zero eye relief supplied

    if ( ( hmd.EyeCups == EyeCup_DK1A ) ||
         ( hmd.EyeCups == EyeCup_DK1B ) ||
         ( hmd.EyeCups == EyeCup_DK1C ) )
    {

        numDistortions = 0;
       
        // Tuned at minimum dial setting - extended to r^2 == 1.8
        distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;
        distortions[numDistortions].EyeRelief                            = 0.012760465f - 0.005f;
        distortions[numDistortions].Config.MetersPerTanAngleAtCenter     = 0.0425f;
        distortions[numDistortions].Config.K[0]                          = 1.0000f;
        distortions[numDistortions].Config.K[1]                          = 1.06505f;
        distortions[numDistortions].Config.K[2]                          = 1.14725f;
        distortions[numDistortions].Config.K[3]                          = 1.2705f;
        distortions[numDistortions].Config.K[4]                          = 1.48f;
        distortions[numDistortions].Config.K[5]                          = 1.87f;
        distortions[numDistortions].Config.K[6]                          = 2.534f;
        distortions[numDistortions].Config.K[7]                          = 3.6f;
        distortions[numDistortions].Config.K[8]                          = 5.1f;
        distortions[numDistortions].Config.K[9]                          = 7.4f;
        distortions[numDistortions].Config.K[10]                         = 11.0f;
        distortions[numDistortions].SampleRadius[0]                      = 0.222717149f;
        distortions[numDistortions].SampleRadius[1]                      = 0.512249443f;
        distortions[numDistortions].SampleRadius[2]                      = 0.712694878f;
        distortions[numDistortions].MaxRadius                            = sqrt(1.8f);
        defaultDistortion = numDistortions;                      // this is the default
        numDistortions++;
        
        // Tuned at middle dial setting
        distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;
        distortions[numDistortions].EyeRelief                            = 0.012760465f;  // my average eye-relief
        distortions[numDistortions].Config.MetersPerTanAngleAtCenter     = 0.0425f;
        distortions[numDistortions].Config.K[0]                          = 1.0f;
        distortions[numDistortions].Config.K[1]                          = 1.032407264f;
        distortions[numDistortions].Config.K[2]                          = 1.07160462f;
        distortions[numDistortions].Config.K[3]                          = 1.11998388f;
        distortions[numDistortions].Config.K[4]                          = 1.1808606f;
        distortions[numDistortions].Config.K[5]                          = 1.2590494f;
        distortions[numDistortions].Config.K[6]                          = 1.361915f;
        distortions[numDistortions].Config.K[7]                          = 1.5014339f;
        distortions[numDistortions].Config.K[8]                          = 1.6986004f;
        distortions[numDistortions].Config.K[9]                          = 1.9940577f;
        distortions[numDistortions].Config.K[10]                         = 2.4783147f;
        distortions[numDistortions].SampleRadius[0]                      = 0.222717149f;
        distortions[numDistortions].SampleRadius[1]                      = 0.512249443f;
        distortions[numDistortions].SampleRadius[2]                      = 0.712694878f;
        distortions[numDistortions].MaxRadius                            = 1.0f;
        numDistortions++;

        // Tuned at maximum dial setting
        distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;
        distortions[numDistortions].EyeRelief                            = 0.012760465f + 0.005f;
        distortions[numDistortions].Config.MetersPerTanAngleAtCenter     = 0.0425f;
        distortions[numDistortions].Config.K[0]                          = 1.0102f;
        distortions[numDistortions].Config.K[1]                          = 1.0371f;
        distortions[numDistortions].Config.K[2]                          = 1.0831f;
        distortions[numDistortions].Config.K[3]                          = 1.1353f;
        distortions[numDistortions].Config.K[4]                          = 1.2f;
        distortions[numDistortions].Config.K[5]                          = 1.2851f;
        distortions[numDistortions].Config.K[6]                          = 1.3979f;
        distortions[numDistortions].Config.K[7]                          = 1.56f;
        distortions[numDistortions].Config.K[8]                          = 1.8f;
        distortions[numDistortions].Config.K[9]                          = 2.25f;
        distortions[numDistortions].Config.K[10]                         = 3.0f;
        distortions[numDistortions].SampleRadius[0]                      = 0.222717149f;
        distortions[numDistortions].SampleRadius[1]                      = 0.512249443f;
        distortions[numDistortions].SampleRadius[2]                      = 0.712694878f;
        distortions[numDistortions].MaxRadius                            = 1.0f;
        numDistortions++;
        
        // Chromatic aberration doesn't seem to change with eye relief.
        for ( int i = 0; i < numDistortions; i++ )
        {
            distortions[i].Config.ChromaticAberration[0]        = -0.006f;
            distortions[i].Config.ChromaticAberration[1]        =  0.0f;
            distortions[i].Config.ChromaticAberration[2]        =  0.014f;
            distortions[i].Config.ChromaticAberration[3]        =  0.0f;
        }
    }
    else if ( hmd.EyeCups == EyeCup_DKHD2A )
    {
        // Tuned DKHD2 lens
        numDistortions = 0;
       
        distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;
        distortions[numDistortions].EyeRelief                            = 0.010f;
        distortions[numDistortions].Config.MetersPerTanAngleAtCenter     = 0.0425f;
        distortions[numDistortions].Config.K[0]                          = 1.0f;
        distortions[numDistortions].Config.K[1]                          = 1.0425f;
        distortions[numDistortions].Config.K[2]                          = 1.0826f;
        distortions[numDistortions].Config.K[3]                          = 1.130f;
        distortions[numDistortions].Config.K[4]                          = 1.185f;
        distortions[numDistortions].Config.K[5]                          = 1.250f;
        distortions[numDistortions].Config.K[6]                          = 1.338f;
        distortions[numDistortions].Config.K[7]                          = 1.455f;
        distortions[numDistortions].Config.K[8]                          = 1.620f;
        distortions[numDistortions].Config.K[9]                          = 1.840f;
        distortions[numDistortions].Config.K[10]                         = 2.200f;
        distortions[numDistortions].SampleRadius[0]                      = 0.222717149f;
        distortions[numDistortions].SampleRadius[1]                      = 0.512249443f;
        distortions[numDistortions].SampleRadius[2]                      = 0.712694878f;
        distortions[numDistortions].MaxRadius                            = 1.0f;
        
        distortions[numDistortions].SampleRadius[0]                      = 0.405405405f;
        distortions[numDistortions].SampleRadius[1]                      = 0.675675676f;
        distortions[numDistortions].SampleRadius[2]                      = 0.945945946f;
        defaultDistortion = numDistortions;   // this is the default
        numDistortions++;

        distortions[numDistortions] = distortions[0];
        distortions[numDistortions].EyeRelief = 0.020f;
        numDistortions++;

        // Chromatic aberration doesn't seem to change with eye relief.
        for ( int i = 0; i < numDistortions; i++ )
        {
            distortions[i].Config.ChromaticAberration[0]        = -0.006f;
            distortions[i].Config.ChromaticAberration[1]        =  0.0f;
            distortions[i].Config.ChromaticAberration[2]        =  0.014f;
            distortions[i].Config.ChromaticAberration[3]        =  0.0f;
        }
    }
    else if ( hmd.EyeCups == EyeCup_PinkA || hmd.EyeCups == EyeCup_DK2A )
    {
        // Tuned Crystal Cove & DK2 Lens (CES & GDC)
        numDistortions = 0;
       
        distortions[numDistortions].EyeRelief                            = 0.010f;
        distortions[numDistortions].Config.MetersPerTanAngleAtCenter     = 0.036f;

        distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;
        distortions[numDistortions].Config.K[0]                          = 1.003f;
        distortions[numDistortions].Config.K[1]                          = 1.02f;
        distortions[numDistortions].Config.K[2]                          = 1.042f;
        distortions[numDistortions].Config.K[3]                          = 1.066f;
        distortions[numDistortions].Config.K[4]                          = 1.094f;  //1.0945f;
        distortions[numDistortions].Config.K[5]                          = 1.126f;  //1.127f;
        distortions[numDistortions].Config.K[6]                          = 1.162f;  //1.167f;
        distortions[numDistortions].Config.K[7]                          = 1.203f;  //1.218f;
        distortions[numDistortions].Config.K[8]                          = 1.25f;   //1.283f;
        distortions[numDistortions].Config.K[9]                          = 1.31f;   //1.37f;
        distortions[numDistortions].Config.K[10]                         = 1.38f;   //1.48f;
        distortions[numDistortions].MaxRadius                            = 1.0f;
        
        
        distortions[numDistortions].SampleRadius[0]                      = 0.405405405f;
        distortions[numDistortions].SampleRadius[1]                      = 0.675675676f;
        distortions[numDistortions].SampleRadius[2]                      = 0.945945946f;
        defaultDistortion = numDistortions;   // this is the default
        numDistortions++;

        distortions[numDistortions] = distortions[0];
        distortions[numDistortions].EyeRelief = 0.020f;
        numDistortions++;

        // Chromatic aberration doesn't seem to change with eye relief.
        for ( int i = 0; i < numDistortions; i++ )
        {
            distortions[i].Config.ChromaticAberration[0]        = -0.015f;
            distortions[i].Config.ChromaticAberration[1]        = -0.02f;
            distortions[i].Config.ChromaticAberration[2]        =  0.025f;
            distortions[i].Config.ChromaticAberration[3]        =  0.02f;
        }
    }
    else
    {
        // Unknown lens.
        // Use DK1 black lens settings, just so we can continue to run with something.
        distortions[0].EyeRelief = 0.005f;
        distortions[0].Config.MetersPerTanAngleAtCenter = 0.043875f;
        distortions[0].Config.Eqn = Distortion_RecipPoly4;
        distortions[0].Config.K[0] = 1.0f;
        distortions[0].Config.K[1] = -0.3999f;
        distortions[0].Config.K[2] =  0.2408f;
        distortions[0].Config.K[3] = -0.4589f;
        distortions[0].SampleRadius[0] = 0.2f;
        distortions[0].SampleRadius[1] = 0.4f;
        distortions[0].SampleRadius[2] = 0.6f;

        distortions[1] = distortions[0];
        distortions[1].EyeRelief = 0.010f;
        numDistortions = 2;

        // Chromatic aberration doesn't seem to change with eye relief.
        for ( int i = 0; i < numDistortions; i++ )
        {
            // These are placeholder, they have not been tuned!
            distortions[i].Config.ChromaticAberration[0]        =  0.0f;
            distortions[i].Config.ChromaticAberration[1]        =  0.0f;
            distortions[i].Config.ChromaticAberration[2]        =  0.0f;
            distortions[i].Config.ChromaticAberration[3]        =  0.0f;
        }
    }

    OVR_ASSERT ( numDistortions < (sizeof(distortions)/sizeof(distortions[0])) );


    DistortionDescriptor *pUpper = NULL;
    DistortionDescriptor *pLower = NULL;
    float lerpVal = 0.0f;
    if (eyeReliefInMeters == 0)
    {   // Use a constant default distortion if an invalid eye-relief is supplied
        pLower = &(distortions[defaultDistortion]);
        pUpper = &(distortions[defaultDistortion]);
        lerpVal = 0.0f;
    }
    else
    {
        for ( int i = 0; i < numDistortions-1; i++ )
        {
            OVR_ASSERT ( distortions[i].EyeRelief < distortions[i+1].EyeRelief );
            if ( ( distortions[i].EyeRelief <= eyeReliefInMeters ) && ( distortions[i+1].EyeRelief > eyeReliefInMeters ) )
            {
                pLower = &(distortions[i]);
                pUpper = &(distortions[i+1]);
                lerpVal = ( eyeReliefInMeters - pLower->EyeRelief ) / ( pUpper->EyeRelief - pLower->EyeRelief );
                // No break here - I want the ASSERT to check everything every time!
            }
        }
    }

    if ( pUpper == NULL )
    {
#if 0
        // Outside the range, so extrapolate rather than interpolate.
        if ( distortions[0].EyeRelief > eyeReliefInMeters )
        { 
            pLower = &(distortions[0]);
            pUpper = &(distortions[1]);
        }
        else
        {
            OVR_ASSERT ( distortions[numDistortions-1].EyeRelief <= eyeReliefInMeters );
            pLower = &(distortions[numDistortions-2]);
            pUpper = &(distortions[numDistortions-1]);
        }
        lerpVal = ( eyeReliefInMeters - pLower->EyeRelief ) / ( pUpper->EyeRelief - pLower->EyeRelief );
#else
        // Do not extrapolate, just clamp - slightly worried about people putting in bogus settings.
        if ( distortions[0].EyeRelief > eyeReliefInMeters )
        {
            pLower = &(distortions[0]);
            pUpper = &(distortions[0]);
        }
        else
        {
            OVR_ASSERT ( distortions[numDistortions-1].EyeRelief <= eyeReliefInMeters );
            pLower = &(distortions[numDistortions-1]);
            pUpper = &(distortions[numDistortions-1]);
        }
        lerpVal = 0.0f;
#endif
    }
    float invLerpVal = 1.0f - lerpVal;

    pLower->Config.MaxR = pLower->MaxRadius;
    pUpper->Config.MaxR = pUpper->MaxRadius;

    LensConfig result;
    // Where is the edge of the lens - no point modelling further than this.
    float maxValidRadius = invLerpVal * pLower->MaxRadius + lerpVal * pUpper->MaxRadius;
    result.MaxR = maxValidRadius;

    switch ( distortionType )
    {
    case Distortion_Poly4:
        // Deprecated
        OVR_ASSERT ( false );
        break;
    case Distortion_RecipPoly4:{
        // Lerp control points and fit an equation to them.
        float fitX[4];
        float fitY[4];
        fitX[0] = 0.0f;
        fitY[0] = 1.0f;
        for ( int ctrlPt = 1; ctrlPt < 4; ctrlPt ++ )
        {
            float radiusLerp = invLerpVal * pLower->SampleRadius[ctrlPt-1] + lerpVal * pUpper->SampleRadius[ctrlPt-1];
            float radiusLerpSq = radiusLerp * radiusLerp;
            float fitYLower = pLower->Config.DistortionFnScaleRadiusSquared ( radiusLerpSq );
            float fitYUpper = pUpper->Config.DistortionFnScaleRadiusSquared ( radiusLerpSq );
            fitX[ctrlPt] = radiusLerpSq;
            fitY[ctrlPt] = 1.0f / ( invLerpVal * fitYLower + lerpVal * fitYUpper );
        }

        result.Eqn = Distortion_RecipPoly4;
        bool bSuccess = FitCubicPolynomial ( result.K, fitX, fitY );
        OVR_ASSERT ( bSuccess );
        OVR_UNUSED ( bSuccess );

        // Set up the fast inverse.
        float maxRDist = result.DistortionFn ( maxValidRadius );
        result.MaxInvR = maxRDist;
        result.SetUpInverseApprox();

        }break;

    case Distortion_CatmullRom10:{

        // Evenly sample & lerp points on the curve.
        const int NumSegments = LensConfig::NumCoefficients;
        result.MaxR = maxValidRadius;
        // Directly interpolate the K0 values
        result.K[0] = invLerpVal * pLower->Config.K[0] + lerpVal * pUpper->Config.K[0];

        // Sample and interpolate the distortion curves to derive K[1] ... K[n]
        for ( int ctrlPt = 1; ctrlPt < NumSegments; ctrlPt++ )
        {
            float radiusSq = ( (float)ctrlPt / (float)(NumSegments-1) ) * maxValidRadius * maxValidRadius;
            float fitYLower = pLower->Config.DistortionFnScaleRadiusSquared ( radiusSq );
            float fitYUpper = pUpper->Config.DistortionFnScaleRadiusSquared ( radiusSq );
            float fitLerp = invLerpVal * fitYLower + lerpVal * fitYUpper;
            result.K[ctrlPt] = fitLerp;
        }

        result.Eqn = Distortion_CatmullRom10;

        for ( int ctrlPt = 1; ctrlPt < NumSegments; ctrlPt++ )
        {
            float radiusSq = ( (float)ctrlPt / (float)(NumSegments-1) ) * maxValidRadius * maxValidRadius;
            float val = result.DistortionFnScaleRadiusSquared ( radiusSq );            
            OVR_ASSERT ( Alg::Abs ( val - result.K[ctrlPt] ) < 0.0001f );
            OVR_UNUSED1(val); // For release build.
        }

        // Set up the fast inverse.
        float maxRDist = result.DistortionFn ( maxValidRadius );
        result.MaxInvR = maxRDist;
        result.SetUpInverseApprox();

        }break;

    default: OVR_ASSERT ( false ); break;
    }


    // Chromatic aberration.
    result.ChromaticAberration[0] = invLerpVal * pLower->Config.ChromaticAberration[0] + lerpVal * pUpper->Config.ChromaticAberration[0];
    result.ChromaticAberration[1] = invLerpVal * pLower->Config.ChromaticAberration[1] + lerpVal * pUpper->Config.ChromaticAberration[1];
    result.ChromaticAberration[2] = invLerpVal * pLower->Config.ChromaticAberration[2] + lerpVal * pUpper->Config.ChromaticAberration[2];
    result.ChromaticAberration[3] = invLerpVal * pLower->Config.ChromaticAberration[3] + lerpVal * pUpper->Config.ChromaticAberration[3];

    // Scale.
    result.MetersPerTanAngleAtCenter =  pLower->Config.MetersPerTanAngleAtCenter * invLerpVal +
                                        pUpper->Config.MetersPerTanAngleAtCenter * lerpVal;
    /*
    // Commented out - Causes ASSERT with no HMD plugged in
#ifdef OVR_BUILD_DEBUG
    if ( distortionType == Distortion_CatmullRom10 )
    {
        TestSaveLoadLensConfig ( result );
    }
#endif
    */
    return result;
}





DistortionRenderDesc CalculateDistortionRenderDesc ( StereoEye eyeType, HmdRenderInfo const &hmd,
                                                     const LensConfig *pLensOverride /*= NULL */ )
{
    // From eye relief, IPD and device characteristics, we get the distortion mapping.
    // This distortion does the following things:
    // 1. It undoes the distortion that happens at the edges of the lens.
    // 2. It maps the undistorted field into "retina" space.
    // So the input is a pixel coordinate - the physical pixel on the display itself.
    // The output is the real-world direction of the ray from this pixel as it comes out of the lens and hits the eye.
    // However we typically think of rays "coming from" the eye, so the direction (TanAngleX,TanAngleY,1) is the direction
    //      that the pixel appears to be in real-world space, where AngleX and AngleY are relative to the straight-ahead vector.
    // If your renderer is a raytracer, you can use this vector directly (normalize as appropriate).
    // However in standard rasterisers, we have rendered a 2D image and are putting it in front of the eye,
    //      so we then need a mapping from this space to the [-1,1] UV coordinate space, which depends on exactly
    //      where "in space" the app wants to put that rendertarget.
    //      Where in space, and how large this rendertarget is, is completely up to the app and/or user,
    //      though of course we can provide some useful hints.

    // TODO: Use IPD and eye relief to modify distortion (i.e. non-radial component)
    // TODO: cope with lenses that don't produce collimated light.
    //       This means that IPD relative to the lens separation changes the light vergence,
    //       and so we actually need to change where the image is displayed.

    const HmdRenderInfo::EyeConfig &hmdEyeConfig = ( eyeType == StereoEye_Left ) ? hmd.EyeLeft : hmd.EyeRight;

    DistortionRenderDesc localDistortion;
    localDistortion.Lens = hmdEyeConfig.Distortion;

    if ( pLensOverride != NULL )
    {
        localDistortion.Lens = *pLensOverride;
    }

    Sizef pixelsPerMeter(hmd.ResolutionInPixels.w / ( hmd.ScreenSizeInMeters.w - hmd.ScreenGapSizeInMeters ),
                         hmd.ResolutionInPixels.h / hmd.ScreenSizeInMeters.h);

    localDistortion.PixelsPerTanAngleAtCenter = (pixelsPerMeter * localDistortion.Lens.MetersPerTanAngleAtCenter).ToVector();
    // Same thing, scaled to [-1,1] for each eye, rather than pixels.

    localDistortion.TanEyeAngleScale = Vector2f(0.25f, 0.5f).EntrywiseMultiply(
                                       (hmd.ScreenSizeInMeters / localDistortion.Lens.MetersPerTanAngleAtCenter).ToVector());
    
    // <--------------left eye------------------><-ScreenGapSizeInMeters-><--------------right eye----------------->
    // <------------------------------------------ScreenSizeInMeters.Width----------------------------------------->
    //                            <----------------LensSeparationInMeters--------------->
    // <--centerFromLeftInMeters->
    //                            ^
    //                      Center of lens

    // Find the lens centers in scale of [-1,+1] (NDC) in left eye.
    float visibleWidthOfOneEye = 0.5f * ( hmd.ScreenSizeInMeters.w - hmd.ScreenGapSizeInMeters );
    float centerFromLeftInMeters = ( hmd.ScreenSizeInMeters.w - hmd.LensSeparationInMeters ) * 0.5f;
    localDistortion.LensCenter.x = (     centerFromLeftInMeters / visibleWidthOfOneEye          ) * 2.0f - 1.0f;
    localDistortion.LensCenter.y = ( hmd.CenterFromTopInMeters  / hmd.ScreenSizeInMeters.h ) * 2.0f - 1.0f;
    if ( eyeType == StereoEye_Right )
    {
        localDistortion.LensCenter.x = -localDistortion.LensCenter.x;
    }

    return localDistortion;
}

FovPort CalculateFovFromEyePosition ( float eyeReliefInMeters,
                                      float offsetToRightInMeters,
                                      float offsetDownwardsInMeters,
                                      float lensDiameterInMeters,
                                      float extraEyeRotationInRadians /*= 0.0f*/ )
{
    // 2D view of things:
    //       |-|            <--- offsetToRightInMeters (in this case, it is negative)
    // |=======C=======|    <--- lens surface (C=center)
    //  \    |       _/
    //   \   R     _/
    //    \  |   _/
    //     \ | _/
    //      \|/
    //       O  <--- center of pupil

    // (technically the lens is round rather than square, so it's not correct to
    // separate vertical and horizontal like this, but it's close enough)
    float halfLensDiameter = lensDiameterInMeters * 0.5f;
    FovPort fovPort;
    fovPort.UpTan    = ( halfLensDiameter + offsetDownwardsInMeters ) / eyeReliefInMeters;
    fovPort.DownTan  = ( halfLensDiameter - offsetDownwardsInMeters ) / eyeReliefInMeters;
    fovPort.LeftTan  = ( halfLensDiameter + offsetToRightInMeters   ) / eyeReliefInMeters;
    fovPort.RightTan = ( halfLensDiameter - offsetToRightInMeters   ) / eyeReliefInMeters;

    if ( extraEyeRotationInRadians > 0.0f )
    {
        // That's the basic looking-straight-ahead eye position relative to the lens.
        // But if you look left, the pupil moves left as the eyeball rotates, which
        // means you can see more to the right than this geometry suggests.
        // So add in the bounds for the extra movement of the pupil.

        // Beyond 30 degrees does not increase FOV because the pupil starts moving backwards more than sideways.
        extraEyeRotationInRadians = Alg::Min ( DegreeToRad ( 30.0f ), Alg::Max ( 0.0f, extraEyeRotationInRadians ) );
        
        // The rotation of the eye is a bit more complex than a simple circle.  The center of rotation
        // at 13.5mm from cornea is slightly further back than the actual center of the eye.
        // Additionally the rotation contains a small lateral component as the muscles pull the eye
        const float eyeballCenterToPupil = 0.0135f;  // center of eye rotation
        const float eyeballLateralPull = 0.001f * (extraEyeRotationInRadians / DegreeToRad ( 30.0f));  // lateral motion as linear function 
        float extraTranslation = eyeballCenterToPupil * sinf ( extraEyeRotationInRadians ) + eyeballLateralPull;
        float extraRelief = eyeballCenterToPupil * ( 1.0f - cosf ( extraEyeRotationInRadians ) );

        fovPort.UpTan    = Alg::Max ( fovPort.UpTan   , ( halfLensDiameter + offsetDownwardsInMeters + extraTranslation ) / ( eyeReliefInMeters + extraRelief ) );
        fovPort.DownTan  = Alg::Max ( fovPort.DownTan , ( halfLensDiameter - offsetDownwardsInMeters + extraTranslation ) / ( eyeReliefInMeters + extraRelief ) );
        fovPort.LeftTan  = Alg::Max ( fovPort.LeftTan , ( halfLensDiameter + offsetToRightInMeters   + extraTranslation ) / ( eyeReliefInMeters + extraRelief ) );
        fovPort.RightTan = Alg::Max ( fovPort.RightTan, ( halfLensDiameter - offsetToRightInMeters   + extraTranslation ) / ( eyeReliefInMeters + extraRelief ) );
    }

    return fovPort;
}



FovPort CalculateFovFromHmdInfo ( StereoEye eyeType,
                                  DistortionRenderDesc const &distortion,
                                  HmdRenderInfo const &hmd,
                                  float extraEyeRotationInRadians /*= 0.0f*/ )
{
    FovPort fovPort;
    float eyeReliefInMeters;
    float offsetToRightInMeters;
    if ( eyeType == StereoEye_Right )
    {
        eyeReliefInMeters     = hmd.EyeRight.ReliefInMeters;
        offsetToRightInMeters = hmd.EyeRight.NoseToPupilInMeters - 0.5f * hmd.LensSeparationInMeters;
    }
    else
    {
        eyeReliefInMeters     = hmd.EyeLeft.ReliefInMeters;
        offsetToRightInMeters = -(hmd.EyeLeft.NoseToPupilInMeters - 0.5f * hmd.LensSeparationInMeters);
    }

    // Limit the eye-relief to 6 mm for FOV calculations since this just tends to spread off-screen
    // and get clamped anyways on DK1 (but in Unity it continues to spreads and causes 
    // unnecessarily large render targets)
    eyeReliefInMeters = Alg::Max(eyeReliefInMeters, 0.006f);

    // Central view.
    fovPort = CalculateFovFromEyePosition ( eyeReliefInMeters,
                                            offsetToRightInMeters,
                                            0.0f,
                                            hmd.LensDiameterInMeters,
                                            extraEyeRotationInRadians );

    // clamp to the screen
    fovPort = ClampToPhysicalScreenFov ( eyeType, distortion, fovPort );
       
    return fovPort;
}



FovPort GetPhysicalScreenFov ( StereoEye eyeType, DistortionRenderDesc const &distortion )
{
    OVR_UNUSED1 ( eyeType );

    FovPort resultFovPort;

    // Figure out the boundaries of the screen. We take the middle pixel of the screen,
    // move to each of the four screen edges, and transform those back into TanAngle space.
    Vector2f dmiddle = distortion.LensCenter;

    // The gotcha is that for some distortion functions, the map will "wrap around"
    // for screen pixels that are not actually visible to the user (especially on DK1,
    // which has a lot of invisible pixels), and map to pixels that are close to the middle.
    // This means the edges of the screen will actually be
    // "closer" than the visible bounds, so we'll clip too aggressively.

    // Solution - step gradually towards the boundary, noting the maximum distance.
    struct FunctionHider
    {
        static FovPort FindRange ( Vector2f from, Vector2f to, int numSteps,
                                          DistortionRenderDesc const &distortion )
        {
            FovPort result;
            result.UpTan    = 0.0f;
            result.DownTan  = 0.0f;
            result.LeftTan  = 0.0f;
            result.RightTan = 0.0f;

            float stepScale = 1.0f / ( numSteps - 1 );
            for ( int step = 0; step < numSteps; step++ )
            {
                float    lerpFactor  = stepScale * (float)step;
                Vector2f sample      = from + (to - from) * lerpFactor;
                Vector2f tanEyeAngle = TransformScreenNDCToTanFovSpace ( distortion, sample );

                result.LeftTan  = Alg::Max ( result.LeftTan,  -tanEyeAngle.x );
                result.RightTan = Alg::Max ( result.RightTan,  tanEyeAngle.x );
                result.UpTan    = Alg::Max ( result.UpTan,    -tanEyeAngle.y );
                result.DownTan  = Alg::Max ( result.DownTan,   tanEyeAngle.y );
            }
            return result;
        }
    };

    FovPort leftFovPort  = FunctionHider::FindRange( dmiddle, Vector2f( -1.0f, dmiddle.y ), 10, distortion );
    FovPort rightFovPort = FunctionHider::FindRange( dmiddle, Vector2f( 1.0f, dmiddle.y ),  10, distortion );
    FovPort upFovPort    = FunctionHider::FindRange( dmiddle, Vector2f( dmiddle.x, -1.0f ), 10, distortion );
    FovPort downFovPort  = FunctionHider::FindRange( dmiddle, Vector2f( dmiddle.x, 1.0f ),  10, distortion );
    
    resultFovPort.LeftTan  = leftFovPort.LeftTan;
    resultFovPort.RightTan = rightFovPort.RightTan;
    resultFovPort.UpTan    = upFovPort.UpTan;
    resultFovPort.DownTan  = downFovPort.DownTan;

    return resultFovPort;
}

FovPort ClampToPhysicalScreenFov( StereoEye eyeType, DistortionRenderDesc const &distortion,
                                         FovPort inputFovPort )
{
    FovPort resultFovPort;
    FovPort phsyicalFovPort = GetPhysicalScreenFov ( eyeType, distortion );
    resultFovPort.LeftTan  = Alg::Min ( inputFovPort.LeftTan,  phsyicalFovPort.LeftTan );
    resultFovPort.RightTan = Alg::Min ( inputFovPort.RightTan, phsyicalFovPort.RightTan );
    resultFovPort.UpTan    = Alg::Min ( inputFovPort.UpTan,    phsyicalFovPort.UpTan );
    resultFovPort.DownTan  = Alg::Min ( inputFovPort.DownTan,  phsyicalFovPort.DownTan );

    return resultFovPort;
}

Sizei CalculateIdealPixelSize ( StereoEye eyeType, DistortionRenderDesc const &distortion,
                                FovPort tanHalfFov, float pixelsPerDisplayPixel )
{
    OVR_UNUSED(eyeType);   // might be useful in the future if we do overlapping fovs

    Sizei result;    
    // TODO: if the app passes in a FOV that doesn't cover the centre, use the distortion values for the nearest edge/corner to match pixel size.
    result.w  = (int)(0.5f + pixelsPerDisplayPixel * distortion.PixelsPerTanAngleAtCenter.x * ( tanHalfFov.LeftTan + tanHalfFov.RightTan ) );
    result.h = (int)(0.5f + pixelsPerDisplayPixel * distortion.PixelsPerTanAngleAtCenter.y * ( tanHalfFov.UpTan   + tanHalfFov.DownTan  ) );
    return result;
}

Recti GetFramebufferViewport ( StereoEye eyeType, HmdRenderInfo const &hmd )
{
    Recti result;
    result.w = hmd.ResolutionInPixels.w/2;
    result.h = hmd.ResolutionInPixels.h;
    result.x = 0;
    result.y = 0;
    if ( eyeType == StereoEye_Right )
    {
        result.x = (hmd.ResolutionInPixels.w+1)/2;      // Round up, not down.
    }
    return result;
}


ScaleAndOffset2D CreateNDCScaleAndOffsetFromFov ( FovPort tanHalfFov )
{
    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    = Vector2f(projXScale, projYScale);
    result.Offset   = Vector2f(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;
}


ScaleAndOffset2D CreateUVScaleAndOffsetfromNDCScaleandOffset ( ScaleAndOffset2D scaleAndOffsetNDC,
                                                               Recti renderedViewport,
                                                               Sizei renderTargetSize )
{
    // scaleAndOffsetNDC takes you to NDC space [-1,+1] within the given viewport on the rendertarget.
    // We want a scale to instead go to actual UV coordinates you can sample with,
    // which need [0,1] and ignore the viewport.
    ScaleAndOffset2D result;
    // Scale [-1,1] to [0,1]
    result.Scale  = scaleAndOffsetNDC.Scale * 0.5f;
    result.Offset = scaleAndOffsetNDC.Offset * 0.5f + Vector2f(0.5f);
    
    // ...but we will have rendered to a subsection of the RT, so scale for that.
    Vector2f scale(  (float)renderedViewport.w / (float)renderTargetSize.w,
                     (float)renderedViewport.h / (float)renderTargetSize.h );
    Vector2f offset( (float)renderedViewport.x / (float)renderTargetSize.w,
                     (float)renderedViewport.y / (float)renderTargetSize.h );

    result.Scale  = result.Scale.EntrywiseMultiply(scale);
    result.Offset  = result.Offset.EntrywiseMultiply(scale) + offset;
    return result;
}



Matrix4f CreateProjection( bool rightHanded, FovPort tanHalfFov,
                           float zNear /*= 0.01f*/, float zFar /*= 10000.0f*/ )
{
    // 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;
    }

    Matrix4f projection;
    // Produces X result, mapping clip edges to [-w,+w]
    projection.M[0][0] = scaleAndOffset.Scale.x;
    projection.M[0][1] = 0.0f;
    projection.M[0][2] = handednessScale * scaleAndOffset.Offset.x;
    projection.M[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.
    projection.M[1][0] = 0.0f;
    projection.M[1][1] = scaleAndOffset.Scale.y;
    projection.M[1][2] = handednessScale * -scaleAndOffset.Offset.y;
    projection.M[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.
    projection.M[2][0] = 0.0f;
    projection.M[2][1] = 0.0f;
    projection.M[2][2] = -handednessScale * zFar / (zNear - zFar);
    projection.M[2][3] = (zFar * zNear) / (zNear - zFar);

    // Produces W result (= Z in)
    projection.M[3][0] = 0.0f;
    projection.M[3][1] = 0.0f;
    projection.M[3][2] = handednessScale;
    projection.M[3][3] = 0.0f;

    return projection;
}


Matrix4f CreateOrthoSubProjection ( bool rightHanded, StereoEye eyeType,
                                    float tanHalfFovX, float tanHalfFovY,
                                    float unitsX, float unitsY,
                                    float distanceFromCamera, float interpupillaryDistance,
                                    Matrix4f const &projection,
                                    float zNear /*= 0.0f*/, float zFar /*= 0.0f*/ )
{
    OVR_UNUSED1 ( rightHanded );

    float orthoHorizontalOffset = interpupillaryDistance * 0.5f / distanceFromCamera;
    switch ( eyeType )
    {
    case StereoEye_Center:
        orthoHorizontalOffset = 0.0f;
        break;
    case StereoEye_Left:
        break;
    case StereoEye_Right:
        orthoHorizontalOffset = -orthoHorizontalOffset;
        break;
    default: OVR_ASSERT ( false ); break;
    }

    // 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].

    float orthoScaleX = 2.0f * tanHalfFovX / unitsX;
    float orthoScaleY = 2.0f * tanHalfFovY / unitsY;
    Matrix4f ortho;
    ortho.M[0][0] = projection.M[0][0] * orthoScaleX;
    ortho.M[0][1] = 0.0f;
    ortho.M[0][2] = 0.0f;
    ortho.M[0][3] = -projection.M[0][2] + ( orthoHorizontalOffset * projection.M[0][0] );

    ortho.M[1][0] = 0.0f;
    ortho.M[1][1] = -projection.M[1][1] * orthoScaleY;       // Note sign flip (text rendering uses Y=down).
    ortho.M[1][2] = 0.0f;
    ortho.M[1][3] = -projection.M[1][2];

    if ( fabsf ( zNear - zFar ) < 0.001f )
    {
        ortho.M[2][0] = 0.0f;
        ortho.M[2][1] = 0.0f;
        ortho.M[2][2] = 0.0f;
        ortho.M[2][3] = zFar;
    }
    else
    {
        ortho.M[2][0] = 0.0f;
        ortho.M[2][1] = 0.0f;
        ortho.M[2][2] = zFar / (zNear - zFar);
        ortho.M[2][3] = (zFar * zNear) / (zNear - zFar);
    }

    // No perspective correction for ortho.
    ortho.M[3][0] = 0.0f;
    ortho.M[3][1] = 0.0f;
    ortho.M[3][2] = 0.0f;
    ortho.M[3][3] = 1.0f;

    return ortho;
}


//-----------------------------------------------------------------------------------
// A set of "forward-mapping" functions, mapping from framebuffer space to real-world and/or texture space.

// This mimics the first half of the distortion shader's function.
Vector2f TransformScreenNDCToTanFovSpace( DistortionRenderDesc const &distortion,
                                          const Vector2f &framebufferNDC )
{
    // Scale to TanHalfFov space, but still distorted.
    Vector2f 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 );
    float distortionScale = distortion.Lens.DistortionFnScaleRadiusSquared ( radiusSquared );
    Vector2f tanEyeAngle;
    tanEyeAngle.x = tanEyeAngleDistorted.x * distortionScale;
    tanEyeAngle.y = tanEyeAngleDistorted.y * distortionScale;

    return tanEyeAngle;
}

// Same, with chromatic aberration correction.
void TransformScreenNDCToTanFovSpaceChroma ( Vector2f *resultR, Vector2f *resultG, Vector2f *resultB, 
                                             DistortionRenderDesc const &distortion,
                                             const Vector2f &framebufferNDC )
{
    // Scale to TanHalfFov space, but still distorted.
    Vector2f 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 );
    Vector3f distortionScales = distortion.Lens.DistortionFnScaleRadiusSquaredChroma ( radiusSquared );
    *resultR = tanEyeAngleDistorted * distortionScales.x;
    *resultG = tanEyeAngleDistorted * distortionScales.y;
    *resultB = tanEyeAngleDistorted * distortionScales.z;
}

// This mimics the second half of the distortion shader's function.
Vector2f TransformTanFovSpaceToRendertargetTexUV( StereoEyeParams const &eyeParams,
                                                  Vector2f const &tanEyeAngle )
{
    Vector2f textureUV;
    textureUV.x = tanEyeAngle.x * eyeParams.EyeToSourceUV.Scale.x + eyeParams.EyeToSourceUV.Offset.x;
    textureUV.y = tanEyeAngle.y * eyeParams.EyeToSourceUV.Scale.y + eyeParams.EyeToSourceUV.Offset.y;
    return textureUV;
}

Vector2f TransformTanFovSpaceToRendertargetNDC( StereoEyeParams const &eyeParams,
                                                Vector2f const &tanEyeAngle )
{
    Vector2f textureNDC;
    textureNDC.x = tanEyeAngle.x * eyeParams.EyeToSourceNDC.Scale.x + eyeParams.EyeToSourceNDC.Offset.x;
    textureNDC.y = tanEyeAngle.y * eyeParams.EyeToSourceNDC.Scale.y + eyeParams.EyeToSourceNDC.Offset.y;
    return textureNDC;
}

Vector2f TransformScreenPixelToScreenNDC( Recti const &distortionViewport,
                                          Vector2f const &pixel )
{
    // Move to [-1,1] NDC coords.
    Vector2f framebufferNDC;
    framebufferNDC.x = -1.0f + 2.0f * ( ( pixel.x - (float)distortionViewport.x ) / (float)distortionViewport.w );
    framebufferNDC.y = -1.0f + 2.0f * ( ( pixel.y - (float)distortionViewport.y ) / (float)distortionViewport.h );
    return framebufferNDC;
}

Vector2f TransformScreenPixelToTanFovSpace( Recti const &distortionViewport,
                                            DistortionRenderDesc const &distortion,
                                            Vector2f const &pixel )
{
    return TransformScreenNDCToTanFovSpace( distortion,
                TransformScreenPixelToScreenNDC( distortionViewport, pixel ) );
}

Vector2f TransformScreenNDCToRendertargetTexUV( DistortionRenderDesc const &distortion,
                                                StereoEyeParams const &eyeParams,
                                                Vector2f const &pixel )
{
    return TransformTanFovSpaceToRendertargetTexUV ( eyeParams,
                TransformScreenNDCToTanFovSpace ( distortion, pixel ) );
}

Vector2f TransformScreenPixelToRendertargetTexUV( Recti const &distortionViewport,
                                                  DistortionRenderDesc const &distortion,
                                                  StereoEyeParams const &eyeParams,
                                                  Vector2f const &pixel )
{
    return TransformTanFovSpaceToRendertargetTexUV ( eyeParams,
                TransformScreenPixelToTanFovSpace ( distortionViewport, distortion, pixel ) );
}


//-----------------------------------------------------------------------------------
// A set of "reverse-mapping" functions, mapping from real-world and/or texture space back to the framebuffer.

Vector2f TransformTanFovSpaceToScreenNDC( DistortionRenderDesc const &distortion,
                                          const Vector2f &tanEyeAngle, bool usePolyApprox /*= false*/ )
{
    float tanEyeAngleRadius = tanEyeAngle.Length();
    float tanEyeAngleDistortedRadius = distortion.Lens.DistortionFnInverseApprox ( tanEyeAngleRadius );
    if ( !usePolyApprox )
    {
        tanEyeAngleDistortedRadius = distortion.Lens.DistortionFnInverse ( tanEyeAngleRadius );
    }
    Vector2f tanEyeAngleDistorted = tanEyeAngle;
    if ( tanEyeAngleRadius > 0.0f )
    {   
        tanEyeAngleDistorted = tanEyeAngle * ( tanEyeAngleDistortedRadius / tanEyeAngleRadius );
    }

    Vector2f framebufferNDC;
    framebufferNDC.x = ( tanEyeAngleDistorted.x / distortion.TanEyeAngleScale.x ) + distortion.LensCenter.x;
    framebufferNDC.y = ( tanEyeAngleDistorted.y / distortion.TanEyeAngleScale.y ) + distortion.LensCenter.y;

    return framebufferNDC;
}

Vector2f TransformRendertargetNDCToTanFovSpace( const ScaleAndOffset2D &eyeToSourceNDC,
                                                const Vector2f &textureNDC )
{
    Vector2f tanEyeAngle = (textureNDC - eyeToSourceNDC.Offset) / eyeToSourceNDC.Scale;
    return tanEyeAngle;
}



} //namespace OVR

//Just want to make a copy disentangled from all these namespaces!
float ExtEvalCatmullRom10Spline ( float const *K, float scaledVal )
{
    return(OVR::EvalCatmullRom10Spline ( K, scaledVal ));
}