ovr_sdk: 1b39a1b46319 LibOVR/Src/OVR

906 LensConfig GenerateLensConfigFromEyeRelief ( float eyeReliefInMeters, HmdRenderInfo const &hmd, DistortionEqnType distortionType /*= Distortion_CatmullRom10*/ )

907 {

908 struct DistortionDescriptor

909 {

910 float EyeRelief;

911 // The three places we're going to sample & lerp the curve at.

912 // One sample is always at 0.0, and the distortion scale should be 1.0 or else!

913 // Only use for poly4 numbers - CR has an implicit scale.

914 float SampleRadius[3];

915 // Where the distortion has actually been measured/calibrated out to.

916 // Don't try to hallucinate data out beyond here.

917 float MaxRadius;

918 // The config itself.

919 LensConfig Config;

920 };

921

922 static const int MaxDistortions = 10;

923 DistortionDescriptor distortions[MaxDistortions];

924 for (int i = 0; i < MaxDistortions; i++)

925 {

926 distortions[i].EyeRelief = 0.0f;

927 memset(distortions[i].SampleRadius, 0, sizeof(distortions[i].SampleRadius));

928 distortions[i].MaxRadius = 1.0f;

929 distortions[i].Config.SetToIdentity(); // Note: This line causes a false Microsoft static analysis error -cat

930 }

931 int numDistortions = 0;

932 int defaultDistortion = 0; // index of the default distortion curve to use if zero eye relief supplied

933

934 if ( ( hmd.EyeCups == EyeCup_DK1A ) ||

935 ( hmd.EyeCups == EyeCup_DK1B ) ||

936 ( hmd.EyeCups == EyeCup_DK1C ) )

937 {

938

939 numDistortions = 0;

940

941 // Tuned at minimum dial setting - extended to r^2 == 1.8

942 distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;

943 distortions[numDistortions].EyeRelief = 0.012760465f - 0.005f;

944 distortions[numDistortions].Config.MetersPerTanAngleAtCenter = 0.0425f;

945 distortions[numDistortions].Config.K[0] = 1.0000f;

946 distortions[numDistortions].Config.K[1] = 1.06505f;

947 distortions[numDistortions].Config.K[2] = 1.14725f;

948 distortions[numDistortions].Config.K[3] = 1.2705f;

949 distortions[numDistortions].Config.K[4] = 1.48f;

950 distortions[numDistortions].Config.K[5] = 1.87f;

951 distortions[numDistortions].Config.K[6] = 2.534f;

952 distortions[numDistortions].Config.K[7] = 3.6f;

953 distortions[numDistortions].Config.K[8] = 5.1f;

954 distortions[numDistortions].Config.K[9] = 7.4f;

955 distortions[numDistortions].Config.K[10] = 11.0f;

956 distortions[numDistortions].MaxRadius = sqrt(1.8f);

957 defaultDistortion = numDistortions; // this is the default

958 numDistortions++;

959

960 // Tuned at middle dial setting

961 distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;

962 distortions[numDistortions].EyeRelief = 0.012760465f; // my average eye-relief

963 distortions[numDistortions].Config.MetersPerTanAngleAtCenter = 0.0425f;

964 distortions[numDistortions].Config.K[0] = 1.0f;

965 distortions[numDistortions].Config.K[1] = 1.032407264f;

966 distortions[numDistortions].Config.K[2] = 1.07160462f;

967 distortions[numDistortions].Config.K[3] = 1.11998388f;

968 distortions[numDistortions].Config.K[4] = 1.1808606f;

969 distortions[numDistortions].Config.K[5] = 1.2590494f;

970 distortions[numDistortions].Config.K[6] = 1.361915f;

971 distortions[numDistortions].Config.K[7] = 1.5014339f;

972 distortions[numDistortions].Config.K[8] = 1.6986004f;

973 distortions[numDistortions].Config.K[9] = 1.9940577f;

974 distortions[numDistortions].Config.K[10] = 2.4783147f;

975 distortions[numDistortions].MaxRadius = 1.0f;

976 numDistortions++;

977

978 // Tuned at maximum dial setting

979 distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;

980 distortions[numDistortions].EyeRelief = 0.012760465f + 0.005f;

981 distortions[numDistortions].Config.MetersPerTanAngleAtCenter = 0.0425f;

982 distortions[numDistortions].Config.K[0] = 1.0102f;

983 distortions[numDistortions].Config.K[1] = 1.0371f;

984 distortions[numDistortions].Config.K[2] = 1.0831f;

985 distortions[numDistortions].Config.K[3] = 1.1353f;

986 distortions[numDistortions].Config.K[4] = 1.2f;

987 distortions[numDistortions].Config.K[5] = 1.2851f;

988 distortions[numDistortions].Config.K[6] = 1.3979f;

989 distortions[numDistortions].Config.K[7] = 1.56f;

990 distortions[numDistortions].Config.K[8] = 1.8f;

991 distortions[numDistortions].Config.K[9] = 2.25f;

992 distortions[numDistortions].Config.K[10] = 3.0f;

993 distortions[numDistortions].MaxRadius = 1.0f;

994 numDistortions++;

995

996

997

998 // Chromatic aberration doesn't seem to change with eye relief.

999 for ( int i = 0; i < numDistortions; i++ )

1000 {

1001 distortions[i].Config.ChromaticAberration[0] = -0.006f;

1002 distortions[i].Config.ChromaticAberration[1] = 0.0f;

1003 distortions[i].Config.ChromaticAberration[2] = 0.014f;

1004 distortions[i].Config.ChromaticAberration[3] = 0.0f;

1005 }

1006 }

1007 else if ( hmd.EyeCups == EyeCup_DKHD2A )

1008 {

1009 // Tuned DKHD2 lens

1010 numDistortions = 0;

1011

1012 distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;

1013 distortions[numDistortions].EyeRelief = 0.010f;

1014 distortions[numDistortions].Config.MetersPerTanAngleAtCenter = 0.0425f;

1015 distortions[numDistortions].Config.K[0] = 1.0f;

1016 distortions[numDistortions].Config.K[1] = 1.0425f;

1017 distortions[numDistortions].Config.K[2] = 1.0826f;

1018 distortions[numDistortions].Config.K[3] = 1.130f;

1019 distortions[numDistortions].Config.K[4] = 1.185f;

1020 distortions[numDistortions].Config.K[5] = 1.250f;

1021 distortions[numDistortions].Config.K[6] = 1.338f;

1022 distortions[numDistortions].Config.K[7] = 1.455f;

1023 distortions[numDistortions].Config.K[8] = 1.620f;

1024 distortions[numDistortions].Config.K[9] = 1.840f;

1025 distortions[numDistortions].Config.K[10] = 2.200f;

1026 distortions[numDistortions].MaxRadius = 1.0f;

1027

1028 defaultDistortion = numDistortions; // this is the default

1029 numDistortions++;

1030

1031 distortions[numDistortions] = distortions[0];

1032 distortions[numDistortions].EyeRelief = 0.020f;

1033 numDistortions++;

1034

1035 // Chromatic aberration doesn't seem to change with eye relief.

1036 for ( int i = 0; i < numDistortions; i++ )

1037 {

1038 distortions[i].Config.ChromaticAberration[0] = -0.006f;

1039 distortions[i].Config.ChromaticAberration[1] = 0.0f;

1040 distortions[i].Config.ChromaticAberration[2] = 0.014f;

1041 distortions[i].Config.ChromaticAberration[3] = 0.0f;

1042 }

1043 }

1044 else if ( hmd.EyeCups == EyeCup_PinkA || hmd.EyeCups == EyeCup_DK2A )

1045 {

1046 // Tuned Crystal Cove & DK2 Lens (CES & GDC)

1047 numDistortions = 0;

1048

1049

1050 distortions[numDistortions].EyeRelief = 0.008f;

1051 distortions[numDistortions].Config.MetersPerTanAngleAtCenter = 0.036f;

1052 // TODO: Need to retune this distortion for minimum eye relief

1053 distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;

1054 distortions[numDistortions].Config.K[0] = 1.003f;

1055 distortions[numDistortions].Config.K[1] = 1.02f;

1056 distortions[numDistortions].Config.K[2] = 1.042f;

1057 distortions[numDistortions].Config.K[3] = 1.066f;

1058 distortions[numDistortions].Config.K[4] = 1.094f;

1059 distortions[numDistortions].Config.K[5] = 1.126f;

1060 distortions[numDistortions].Config.K[6] = 1.162f;

1061 distortions[numDistortions].Config.K[7] = 1.203f;

1062 distortions[numDistortions].Config.K[8] = 1.25f;

1063 distortions[numDistortions].Config.K[9] = 1.31f;

1064 distortions[numDistortions].Config.K[10] = 1.38f;

1065 distortions[numDistortions].MaxRadius = 1.0f;

1066

1067 distortions[numDistortions].Config.ChromaticAberration[0] = -0.0112f;

1068 distortions[numDistortions].Config.ChromaticAberration[1] = -0.015f;

1069 distortions[numDistortions].Config.ChromaticAberration[2] = 0.0187f;

1070 distortions[numDistortions].Config.ChromaticAberration[3] = 0.015f;

1071

1072 numDistortions++;

1073

1074

1075

1076

1077

1078 distortions[numDistortions].EyeRelief = 0.018f;

1079 distortions[numDistortions].Config.MetersPerTanAngleAtCenter = 0.036f;

1080

1081 distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;

1082 distortions[numDistortions].Config.K[0] = 1.003f;

1083 distortions[numDistortions].Config.K[1] = 1.02f;

1084 distortions[numDistortions].Config.K[2] = 1.042f;

1085 distortions[numDistortions].Config.K[3] = 1.066f;

1086 distortions[numDistortions].Config.K[4] = 1.094f;

1087 distortions[numDistortions].Config.K[5] = 1.126f;

1088 distortions[numDistortions].Config.K[6] = 1.162f;

1089 distortions[numDistortions].Config.K[7] = 1.203f;

1090 distortions[numDistortions].Config.K[8] = 1.25f;

1091 distortions[numDistortions].Config.K[9] = 1.31f;

1092 distortions[numDistortions].Config.K[10] = 1.38f;

1093 distortions[numDistortions].MaxRadius = 1.0f;

1094

1095 distortions[numDistortions].Config.ChromaticAberration[0] = -0.015f;

1096 distortions[numDistortions].Config.ChromaticAberration[1] = -0.02f;

1097 distortions[numDistortions].Config.ChromaticAberration[2] = 0.025f;

1098 distortions[numDistortions].Config.ChromaticAberration[3] = 0.02f;

1099

1100 defaultDistortion = numDistortions; // this is the default

1101 numDistortions++;

1102

1103 /*

1104 // Orange Lens on DK2

1105 distortions[numDistortions].EyeRelief = 0.010f;

1106 distortions[numDistortions].Config.MetersPerTanAngleAtCenter = 0.031f;

1107

1108 distortions[numDistortions].Config.Eqn = Distortion_CatmullRom10;

1109 distortions[numDistortions].Config.K[0] = 1.00f;

1110 distortions[numDistortions].Config.K[1] = 1.0169f;

1111 distortions[numDistortions].Config.K[2] = 1.0378f;

1112 distortions[numDistortions].Config.K[3] = 1.0648f;

1113 distortions[numDistortions].Config.K[4] = 1.0990f;

1114 distortions[numDistortions].Config.K[5] = 1.141f;

1115 distortions[numDistortions].Config.K[6] = 1.192f;

1116 distortions[numDistortions].Config.K[7] = 1.255f;

1117 distortions[numDistortions].Config.K[8] = 1.335f;

1118 distortions[numDistortions].Config.K[9] = 1.435f;

1119 distortions[numDistortions].Config.K[10] = 1.56f;

1120 distortions[numDistortions].MaxRadius = 1.0f;

1121 */

1122 }

1123 else

1124 {

1125 // Unknown lens.

1126 // Use DK1 black lens settings, just so we can continue to run with something.

1127 distortions[0].EyeRelief = 0.005f;

1128 distortions[0].Config.MetersPerTanAngleAtCenter = 0.043875f;

1129 distortions[0].Config.Eqn = Distortion_RecipPoly4;

1130 distortions[0].Config.K[0] = 1.0f;

1131 distortions[0].Config.K[1] = -0.3999f;

1132 distortions[0].Config.K[2] = 0.2408f;

1133 distortions[0].Config.K[3] = -0.4589f;

1134 distortions[0].SampleRadius[0] = 0.2f;

1135 distortions[0].SampleRadius[1] = 0.4f;

1136 distortions[0].SampleRadius[2] = 0.6f;

1137

1138 distortions[1] = distortions[0];

1139 distortions[1].EyeRelief = 0.010f;

1140 numDistortions = 2;

1141

1142 // Chromatic aberration doesn't seem to change with eye relief.

1143 for ( int i = 0; i < numDistortions; i++ )

1144 {

1145 // These are placeholder, they have not been tuned!

1146 distortions[i].Config.ChromaticAberration[0] = 0.0f;

1147 distortions[i].Config.ChromaticAberration[1] = 0.0f;

1148 distortions[i].Config.ChromaticAberration[2] = 0.0f;

1149 distortions[i].Config.ChromaticAberration[3] = 0.0f;

1150 }

1151 }

1152

1153 OVR_ASSERT(numDistortions < MaxDistortions);

1154

1155 DistortionDescriptor *pUpper = NULL;

1156 DistortionDescriptor *pLower = NULL;

1157 float lerpVal = 0.0f;

1158 if (eyeReliefInMeters == 0)

1159 { // Use a constant default distortion if an invalid eye-relief is supplied

1160 pLower = &(distortions[defaultDistortion]);

1161 pUpper = &(distortions[defaultDistortion]);

1162 lerpVal = 0.0f;

1163 }

1164 else

1165 {

1166 for ( int i = 0; i < numDistortions-1; i++ )

1167 {

1168 OVR_ASSERT ( distortions[i].EyeRelief < distortions[i+1].EyeRelief );

1169 if ( ( distortions[i].EyeRelief <= eyeReliefInMeters ) && ( distortions[i+1].EyeRelief > eyeReliefInMeters ) )

1170 {

1171 pLower = &(distortions[i]);

1172 pUpper = &(distortions[i+1]);

1173 lerpVal = ( eyeReliefInMeters - pLower->EyeRelief ) / ( pUpper->EyeRelief - pLower->EyeRelief );

1174 // No break here - I want the ASSERT to check everything every time!

1175 }

1176 }

1177 }

1178

1179 if ( pUpper == NULL )

1180 {

1181 #if 0

1182 // Outside the range, so extrapolate rather than interpolate.

1183 if ( distortions[0].EyeRelief > eyeReliefInMeters )

1184 {

1185 pLower = &(distortions[0]);

1186 pUpper = &(distortions[1]);

1187 }

1188 else

1189 {

1190 OVR_ASSERT ( distortions[numDistortions-1].EyeRelief <= eyeReliefInMeters );

1191 pLower = &(distortions[numDistortions-2]);

1192 pUpper = &(distortions[numDistortions-1]);

1193 }

1194 lerpVal = ( eyeReliefInMeters - pLower->EyeRelief ) / ( pUpper->EyeRelief - pLower->EyeRelief );

1195 #else

1196 // Do not extrapolate, just clamp - slightly worried about people putting in bogus settings.

1197 if ( distortions[0].EyeRelief > eyeReliefInMeters )

1198 {

1199 pLower = &(distortions[0]);

1200 pUpper = &(distortions[0]);

1201 }

1202 else

1203 {

1204 OVR_ASSERT ( distortions[numDistortions-1].EyeRelief <= eyeReliefInMeters );

1205 pLower = &(distortions[numDistortions-1]);

1206 pUpper = &(distortions[numDistortions-1]);

1207 }

1208 lerpVal = 0.0f;

1209 #endif

1210 }

1211 float invLerpVal = 1.0f - lerpVal;

1212

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

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

1215

1216 LensConfig result;

1217 // Where is the edge of the lens - no point modelling further than this.

1218 float maxValidRadius = invLerpVal * pLower->MaxRadius + lerpVal * pUpper->MaxRadius;

1219 result.MaxR = maxValidRadius;

1220

1221 switch ( distortionType )

1222 {

1223 case Distortion_Poly4:

1224 // Deprecated

1225 OVR_ASSERT ( false );

1226 break;

1227 case Distortion_RecipPoly4:{

1228 // Lerp control points and fit an equation to them.

1229 float fitX[4];

1230 float fitY[4];

1231 fitX[0] = 0.0f;

1232 fitY[0] = 1.0f;

1233 for ( int ctrlPt = 1; ctrlPt < 4; ctrlPt ++ )

1234 {

1235 // SampleRadius is not valid for Distortion_RecipPoly4 types.

1236 float radiusLerp = ( invLerpVal * pLower->MaxRadius + lerpVal * pUpper->MaxRadius ) * ( (float)ctrlPt / 4.0f );

1237 float radiusLerpSq = radiusLerp * radiusLerp;

1238 float fitYLower = pLower->Config.DistortionFnScaleRadiusSquared ( radiusLerpSq );

1239 float fitYUpper = pUpper->Config.DistortionFnScaleRadiusSquared ( radiusLerpSq );

1240 fitX[ctrlPt] = radiusLerpSq;

1241 fitY[ctrlPt] = 1.0f / ( invLerpVal * fitYLower + lerpVal * fitYUpper );

1242 }

1243

1244 result.Eqn = Distortion_RecipPoly4;

1245 bool bSuccess = FitCubicPolynomial ( result.K, fitX, fitY );

1246 OVR_ASSERT ( bSuccess );

1247 OVR_UNUSED ( bSuccess );

1248

1249 // Set up the fast inverse.

1250 float maxRDist = result.DistortionFn ( maxValidRadius );

1251 result.MaxInvR = maxRDist;

1252 result.SetUpInverseApprox();

1253

1254 }break;

1255

1256 case Distortion_CatmullRom10:{

1257

1258 // Evenly sample & lerp points on the curve.

1259 const int NumSegments = LensConfig::NumCoefficients;

1260 result.MaxR = maxValidRadius;

1261 // Directly interpolate the K0 values

1262 result.K[0] = invLerpVal * pLower->Config.K[0] + lerpVal * pUpper->Config.K[0];

1263

1264 // Sample and interpolate the distortion curves to derive K[1] ... K[n]

1265 for ( int ctrlPt = 1; ctrlPt < NumSegments; ctrlPt++ )

1266 {

1267 float radiusSq = ( (float)ctrlPt / (float)(NumSegments-1) ) * maxValidRadius * maxValidRadius;

1268 float fitYLower = pLower->Config.DistortionFnScaleRadiusSquared ( radiusSq );

1269 float fitYUpper = pUpper->Config.DistortionFnScaleRadiusSquared ( radiusSq );

1270 float fitLerp = invLerpVal * fitYLower + lerpVal * fitYUpper;

1271 result.K[ctrlPt] = fitLerp;

1272 }

1273

1274 result.Eqn = Distortion_CatmullRom10;

1275

1276 for ( int ctrlPt = 1; ctrlPt < NumSegments; ctrlPt++ )

1277 {

1278 float radiusSq = ( (float)ctrlPt / (float)(NumSegments-1) ) * maxValidRadius * maxValidRadius;

1279 float val = result.DistortionFnScaleRadiusSquared ( radiusSq );

1280 OVR_ASSERT ( Alg::Abs ( val - result.K[ctrlPt] ) < 0.0001f );

1281 OVR_UNUSED1(val); // For release build.

1282 }

1283

1284 // Set up the fast inverse.

1285 float maxRDist = result.DistortionFn ( maxValidRadius );

1286 result.MaxInvR = maxRDist;

1287 result.SetUpInverseApprox();

1288

1289 }break;

1290

1291 default: OVR_ASSERT ( false ); break;

1292 }

1293

1294

1295 // Chromatic aberration.

1296 result.ChromaticAberration[0] = invLerpVal * pLower->Config.ChromaticAberration[0] + lerpVal * pUpper->Config.ChromaticAberration[0];

1297 result.ChromaticAberration[1] = invLerpVal * pLower->Config.ChromaticAberration[1] + lerpVal * pUpper->Config.ChromaticAberration[1];

1298 result.ChromaticAberration[2] = invLerpVal * pLower->Config.ChromaticAberration[2] + lerpVal * pUpper->Config.ChromaticAberration[2];

1299 result.ChromaticAberration[3] = invLerpVal * pLower->Config.ChromaticAberration[3] + lerpVal * pUpper->Config.ChromaticAberration[3];

1300

1301 // Scale.

1302 result.MetersPerTanAngleAtCenter = pLower->Config.MetersPerTanAngleAtCenter * invLerpVal +

1303 pUpper->Config.MetersPerTanAngleAtCenter * lerpVal;

1304 /*

1305 // Commented out - Causes ASSERT with no HMD plugged in

1306 #ifdef OVR_BUILD_DEBUG

1307 if ( distortionType == Distortion_CatmullRom10 )

1308 {

1309 TestSaveLoadLensConfig ( result );

1310 }

1311 #endif

1312 */

1313 return result;

1314 }

1315

1316

1317 DistortionRenderDesc CalculateDistortionRenderDesc ( StereoEye eyeType, HmdRenderInfo const &hmd,

1318 const LensConfig *pLensOverride /*= NULL */ )

1319 {

1320 // From eye relief, IPD and device characteristics, we get the distortion mapping.

1321 // This distortion does the following things:

1322 // 1. It undoes the distortion that happens at the edges of the lens.

1323 // 2. It maps the undistorted field into "retina" space.

1324 // So the input is a pixel coordinate - the physical pixel on the display itself.

1325 // The output is the real-world direction of the ray from this pixel as it comes out of the lens and hits the eye.

1326 // However we typically think of rays "coming from" the eye, so the direction (TanAngleX,TanAngleY,1) is the direction

1327 // that the pixel appears to be in real-world space, where AngleX and AngleY are relative to the straight-ahead vector.

1328 // If your renderer is a raytracer, you can use this vector directly (normalize as appropriate).

1329 // However in standard rasterisers, we have rendered a 2D image and are putting it in front of the eye,

1330 // so we then need a mapping from this space to the [-1,1] UV coordinate space, which depends on exactly

1331 // where "in space" the app wants to put that rendertarget.

1332 // Where in space, and how large this rendertarget is, is completely up to the app and/or user,

1333 // though of course we can provide some useful hints.

1334

1335 // TODO: Use IPD and eye relief to modify distortion (i.e. non-radial component)

1336 // TODO: cope with lenses that don't produce collimated light.

1337 // This means that IPD relative to the lens separation changes the light vergence,

1338 // and so we actually need to change where the image is displayed.

1339

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

1341

1342 DistortionRenderDesc localDistortion;

1343 localDistortion.Lens = hmdEyeConfig.Distortion;

1344

1345 if ( pLensOverride != NULL )

1346 {

1347 localDistortion.Lens = *pLensOverride;

1348 }

1349

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

1351 hmd.ResolutionInPixels.h / hmd.ScreenSizeInMeters.h);

1352

1353 localDistortion.PixelsPerTanAngleAtCenter = (pixelsPerMeter * localDistortion.Lens.MetersPerTanAngleAtCenter).ToVector();

1354 // Same thing, scaled to [-1,1] for each eye, rather than pixels.

1355

1356 localDistortion.TanEyeAngleScale = Vector2f(0.25f, 0.5f).EntrywiseMultiply(

1357 (hmd.ScreenSizeInMeters / localDistortion.Lens.MetersPerTanAngleAtCenter).ToVector());

1358

1359 // <--------------left eye------------------><-ScreenGapSizeInMeters-><--------------right eye----------------->

1360 // <------------------------------------------ScreenSizeInMeters.Width----------------------------------------->

1361 // <----------------LensSeparationInMeters--------------->

1362 // <--centerFromLeftInMeters->

1363 // ^

1364 // Center of lens

1365

1366 // Find the lens centers in scale of [-1,+1] (NDC) in left eye.

1367 float visibleWidthOfOneEye = 0.5f * ( hmd.ScreenSizeInMeters.w - hmd.ScreenGapSizeInMeters );

1368 float centerFromLeftInMeters = ( hmd.ScreenSizeInMeters.w - hmd.LensSeparationInMeters ) * 0.5f;

1369 localDistortion.LensCenter.x = ( centerFromLeftInMeters / visibleWidthOfOneEye ) * 2.0f - 1.0f;

1370 localDistortion.LensCenter.y = ( hmd.CenterFromTopInMeters / hmd.ScreenSizeInMeters.h ) * 2.0f - 1.0f;

1371 if ( eyeType == StereoEye_Right )

1372 {

1373 localDistortion.LensCenter.x = -localDistortion.LensCenter.x;

1374 }

1375

1376 return localDistortion;

1377 }

1378

1379 FovPort CalculateFovFromEyePosition ( float eyeReliefInMeters,

1380 float offsetToRightInMeters,

1381 float offsetDownwardsInMeters,

1382 float lensDiameterInMeters,

1383 float extraEyeRotationInRadians /*= 0.0f*/ )

1384 {

1385 // 2D view of things:

1386 // |-| <--- offsetToRightInMeters (in this case, it is negative)

1387 // |=======C=======| <--- lens surface (C=center)

1388 // \ | _/

1389 // \ R _/

1390 // \ | _/

1391 // \ | _/

1392 // \|/

1393 // O <--- center of pupil

1394

1395 // (technically the lens is round rather than square, so it's not correct to

1396 // separate vertical and horizontal like this, but it's close enough)

1397 float halfLensDiameter = lensDiameterInMeters * 0.5f;

1398 FovPort fovPort;

1399 fovPort.UpTan = ( halfLensDiameter + offsetDownwardsInMeters ) / eyeReliefInMeters;

1400 fovPort.DownTan = ( halfLensDiameter - offsetDownwardsInMeters ) / eyeReliefInMeters;

1401 fovPort.LeftTan = ( halfLensDiameter + offsetToRightInMeters ) / eyeReliefInMeters;

1402 fovPort.RightTan = ( halfLensDiameter - offsetToRightInMeters ) / eyeReliefInMeters;

1403

1404 if ( extraEyeRotationInRadians > 0.0f )

1405 {

1406 // That's the basic looking-straight-ahead eye position relative to the lens.

1407 // But if you look left, the pupil moves left as the eyeball rotates, which

1408 // means you can see more to the right than this geometry suggests.

1409 // So add in the bounds for the extra movement of the pupil.

1410

1411 // Beyond 30 degrees does not increase FOV because the pupil starts moving backwards more than sideways.

1412 extraEyeRotationInRadians = Alg::Min ( DegreeToRad ( 30.0f ), Alg::Max ( 0.0f, extraEyeRotationInRadians ) );

1413

1414 // The rotation of the eye is a bit more complex than a simple circle. The center of rotation

1415 // at 13.5mm from cornea is slightly further back than the actual center of the eye.

1416 // Additionally the rotation contains a small lateral component as the muscles pull the eye

1417 const float eyeballCenterToPupil = 0.0135f; // center of eye rotation

1418 const float eyeballLateralPull = 0.001f * (extraEyeRotationInRadians / DegreeToRad ( 30.0f)); // lateral motion as linear function

1419 float extraTranslation = eyeballCenterToPupil * sinf ( extraEyeRotationInRadians ) + eyeballLateralPull;

1420 float extraRelief = eyeballCenterToPupil * ( 1.0f - cosf ( extraEyeRotationInRadians ) );

1421

1422 fovPort.UpTan = Alg::Max ( fovPort.UpTan , ( halfLensDiameter + offsetDownwardsInMeters + extraTranslation ) / ( eyeReliefInMeters + extraRelief ) );

1423 fovPort.DownTan = Alg::Max ( fovPort.DownTan , ( halfLensDiameter - offsetDownwardsInMeters + extraTranslation ) / ( eyeReliefInMeters + extraRelief ) );

1424 fovPort.LeftTan = Alg::Max ( fovPort.LeftTan , ( halfLensDiameter + offsetToRightInMeters + extraTranslation ) / ( eyeReliefInMeters + extraRelief ) );

1425 fovPort.RightTan = Alg::Max ( fovPort.RightTan, ( halfLensDiameter - offsetToRightInMeters + extraTranslation ) / ( eyeReliefInMeters + extraRelief ) );

1426 }

1427

1428 return fovPort;

1429 }

1430

1431

1432

1433 FovPort CalculateFovFromHmdInfo ( StereoEye eyeType,

1434 DistortionRenderDesc const &distortion,

1435 HmdRenderInfo const &hmd,

1436 float extraEyeRotationInRadians /*= 0.0f*/ )

1437 {

1438 FovPort fovPort;

1439 float eyeReliefInMeters;

1440 float offsetToRightInMeters;

1441 if ( eyeType == StereoEye_Right )

1442 {

1443 eyeReliefInMeters = hmd.EyeRight.ReliefInMeters;

1444 offsetToRightInMeters = hmd.EyeRight.NoseToPupilInMeters - 0.5f * hmd.LensSeparationInMeters;

1445 }

1446 else

1447 {

1448 eyeReliefInMeters = hmd.EyeLeft.ReliefInMeters;

1449 offsetToRightInMeters = -(hmd.EyeLeft.NoseToPupilInMeters - 0.5f * hmd.LensSeparationInMeters);

1450 }

1451

1452 // Limit the eye-relief to 6 mm for FOV calculations since this just tends to spread off-screen

1453 // and get clamped anyways on DK1 (but in Unity it continues to spreads and causes

1454 // unnecessarily large render targets)

1455 eyeReliefInMeters = Alg::Max(eyeReliefInMeters, 0.006f);

1456

1457 // Central view.

1458 fovPort = CalculateFovFromEyePosition ( eyeReliefInMeters,

1459 offsetToRightInMeters,

1460 0.0f,

1461 hmd.LensDiameterInMeters,

1462 extraEyeRotationInRadians );

1463

1464 // clamp to the screen

1465 fovPort = ClampToPhysicalScreenFov ( eyeType, distortion, fovPort );

1466

1467 return fovPort;

1468 }

1469

1470

1471

1472 FovPort GetPhysicalScreenFov ( StereoEye eyeType, DistortionRenderDesc const &distortion )

1473 {

1474 OVR_UNUSED1 ( eyeType );

1475

1476 FovPort resultFovPort;

1477

1478 // Figure out the boundaries of the screen. We take the middle pixel of the screen,

1479 // move to each of the four screen edges, and transform those back into TanAngle space.

1480 Vector2f dmiddle = distortion.LensCenter;

1481

1482 // The gotcha is that for some distortion functions, the map will "wrap around"

1483 // for screen pixels that are not actually visible to the user (especially on DK1,

1484 // which has a lot of invisible pixels), and map to pixels that are close to the middle.

1485 // This means the edges of the screen will actually be

1486 // "closer" than the visible bounds, so we'll clip too aggressively.

1487

1488 // Solution - step gradually towards the boundary, noting the maximum distance.

1489 struct FunctionHider

1490 {

1491 static FovPort FindRange ( Vector2f from, Vector2f to, int numSteps,

1492 DistortionRenderDesc const &distortionL )

1493 {

1494 FovPort result;

1495 result.UpTan = 0.0f;

1496 result.DownTan = 0.0f;

1497 result.LeftTan = 0.0f;

1498 result.RightTan = 0.0f;

1499

1500 float stepScale = 1.0f / ( numSteps - 1 );

1501 for ( int step = 0; step < numSteps; step++ )

1502 {

1503 float lerpFactor = stepScale * (float)step;

1504 Vector2f sample = from + (to - from) * lerpFactor;

1505 Vector2f tanEyeAngle = TransformScreenNDCToTanFovSpace ( distortionL, sample );

1506

1507 result.LeftTan = Alg::Max ( result.LeftTan, -tanEyeAngle.x );

1508 result.RightTan = Alg::Max ( result.RightTan, tanEyeAngle.x );

1509 result.UpTan = Alg::Max ( result.UpTan, -tanEyeAngle.y );

1510 result.DownTan = Alg::Max ( result.DownTan, tanEyeAngle.y );

1511 }

1512 return result;

1513 }

1514 };

1515

1516 FovPort leftFovPort = FunctionHider::FindRange( dmiddle, Vector2f( -1.0f, dmiddle.y ), 10, distortion );

1517 FovPort rightFovPort = FunctionHider::FindRange( dmiddle, Vector2f( 1.0f, dmiddle.y ), 10, distortion );

1518 FovPort upFovPort = FunctionHider::FindRange( dmiddle, Vector2f( dmiddle.x, -1.0f ), 10, distortion );

1519 FovPort downFovPort = FunctionHider::FindRange( dmiddle, Vector2f( dmiddle.x, 1.0f ), 10, distortion );

1520

1521 resultFovPort.LeftTan = leftFovPort.LeftTan;

1522 resultFovPort.RightTan = rightFovPort.RightTan;

1523 resultFovPort.UpTan = upFovPort.UpTan;

1524 resultFovPort.DownTan = downFovPort.DownTan;

1525

1526 return resultFovPort;

1527 }

1528

1529 FovPort ClampToPhysicalScreenFov( StereoEye eyeType, DistortionRenderDesc const &distortion,

1530 FovPort inputFovPort )

1531 {

1532 FovPort resultFovPort;

1533 FovPort phsyicalFovPort = GetPhysicalScreenFov ( eyeType, distortion );

1534 resultFovPort.LeftTan = Alg::Min ( inputFovPort.LeftTan, phsyicalFovPort.LeftTan );

1535 resultFovPort.RightTan = Alg::Min ( inputFovPort.RightTan, phsyicalFovPort.RightTan );

1536 resultFovPort.UpTan = Alg::Min ( inputFovPort.UpTan, phsyicalFovPort.UpTan );

1537 resultFovPort.DownTan = Alg::Min ( inputFovPort.DownTan, phsyicalFovPort.DownTan );

1538

1539 return resultFovPort;

1540 }

1541

1542 Sizei CalculateIdealPixelSize ( StereoEye eyeType, DistortionRenderDesc const &distortion,

1543 FovPort tanHalfFov, float pixelsPerDisplayPixel )

1544 {

1545 OVR_UNUSED(eyeType); // might be useful in the future if we do overlapping fovs

1546

1547 Sizei result;

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

1549 result.w = (int)(0.5f + pixelsPerDisplayPixel * distortion.PixelsPerTanAngleAtCenter.x * ( tanHalfFov.LeftTan + tanHalfFov.RightTan ) );

1550 result.h = (int)(0.5f + pixelsPerDisplayPixel * distortion.PixelsPerTanAngleAtCenter.y * ( tanHalfFov.UpTan + tanHalfFov.DownTan ) );

1551 return result;

1552 }

1553

1554 Recti GetFramebufferViewport ( StereoEye eyeType, HmdRenderInfo const &hmd )

1555 {

1556 Recti result;

1557 result.w = hmd.ResolutionInPixels.w/2;

1558 result.h = hmd.ResolutionInPixels.h;

1559 result.x = 0;

1560 result.y = 0;

1561 if ( eyeType == StereoEye_Right )

1562 {

1563 result.x = (hmd.ResolutionInPixels.w+1)/2; // Round up, not down.

1564 }

1565 return result;

1566 }

1567

1568

1569 ScaleAndOffset2D CreateNDCScaleAndOffsetFromFov ( FovPort tanHalfFov )

1570 {

1571 float projXScale = 2.0f / ( tanHalfFov.LeftTan + tanHalfFov.RightTan );

1572 float projXOffset = ( tanHalfFov.LeftTan - tanHalfFov.RightTan ) * projXScale * 0.5f;

1573 float projYScale = 2.0f / ( tanHalfFov.UpTan + tanHalfFov.DownTan );

1574 float projYOffset = ( tanHalfFov.UpTan - tanHalfFov.DownTan ) * projYScale * 0.5f;

1575

1576 ScaleAndOffset2D result;

1577 result.Scale = Vector2f(projXScale, projYScale);

1578 result.Offset = Vector2f(projXOffset, projYOffset);

1579 // Hey - why is that Y.Offset negated?

1580 // It's because a projection matrix transforms from world coords with Y=up,

1581 // whereas this is from NDC which is Y=down.

1582

1583 return result;

1584 }

1585

1586

1587 ScaleAndOffset2D CreateUVScaleAndOffsetfromNDCScaleandOffset ( ScaleAndOffset2D scaleAndOffsetNDC,

1588 Recti renderedViewport,

1589 Sizei renderTargetSize )

1590 {

1591 // scaleAndOffsetNDC takes you to NDC space [-1,+1] within the given viewport on the rendertarget.

1592 // We want a scale to instead go to actual UV coordinates you can sample with,

1593 // which need [0,1] and ignore the viewport.

1594 ScaleAndOffset2D result;

1595 // Scale [-1,1] to [0,1]

1596 result.Scale = scaleAndOffsetNDC.Scale * 0.5f;

1597 result.Offset = scaleAndOffsetNDC.Offset * 0.5f + Vector2f(0.5f);

1598

1599 // ...but we will have rendered to a subsection of the RT, so scale for that.

1600 Vector2f scale( (float)renderedViewport.w / (float)renderTargetSize.w,

1601 (float)renderedViewport.h / (float)renderTargetSize.h );

1602 Vector2f offset( (float)renderedViewport.x / (float)renderTargetSize.w,

1603 (float)renderedViewport.y / (float)renderTargetSize.h );

1604

1605 result.Scale = result.Scale.EntrywiseMultiply(scale);

1606 result.Offset = result.Offset.EntrywiseMultiply(scale) + offset;

1607 return result;

1608 }

1609

1610

1611

1612 Matrix4f CreateProjection( bool rightHanded, FovPort tanHalfFov,

1613 float zNear /*= 0.01f*/, float zFar /*= 10000.0f*/ )

1614 {

1615 // A projection matrix is very like a scaling from NDC, so we can start with that.

1616 ScaleAndOffset2D scaleAndOffset = CreateNDCScaleAndOffsetFromFov ( tanHalfFov );

1617

1618 float handednessScale = 1.0f;

1619 if ( rightHanded )

1620 {

1621 handednessScale = -1.0f;

1622 }

1623

1624 Matrix4f projection;

1625 // Produces X result, mapping clip edges to [-w,+w]

1626 projection.M[0][0] = scaleAndOffset.Scale.x;

1627 projection.M[0][1] = 0.0f;

1628 projection.M[0][2] = handednessScale * scaleAndOffset.Offset.x;

1629 projection.M[0][3] = 0.0f;

1630

1631 // Produces Y result, mapping clip edges to [-w,+w]

1632 // Hey - why is that YOffset negated?

1633 // It's because a projection matrix transforms from world coords with Y=up,

1634 // whereas this is derived from an NDC scaling, which is Y=down.

1635 projection.M[1][0] = 0.0f;

1636 projection.M[1][1] = scaleAndOffset.Scale.y;

1637 projection.M[1][2] = handednessScale * -scaleAndOffset.Offset.y;

1638 projection.M[1][3] = 0.0f;

1639

1640 // Produces Z-buffer result - app needs to fill this in with whatever Z range it wants.

1641 // We'll just use some defaults for now.

1642 projection.M[2][0] = 0.0f;

1643 projection.M[2][1] = 0.0f;

1644 projection.M[2][2] = -handednessScale * zFar / (zNear - zFar);

1645 projection.M[2][3] = (zFar * zNear) / (zNear - zFar);

1646

1647 // Produces W result (= Z in)

1648 projection.M[3][0] = 0.0f;

1649 projection.M[3][1] = 0.0f;

1650 projection.M[3][2] = handednessScale;

1651 projection.M[3][3] = 0.0f;

1652

1653 return projection;

1654 }

1655

1656

1657 Matrix4f CreateOrthoSubProjection ( bool rightHanded, StereoEye eyeType,

1658 float tanHalfFovX, float tanHalfFovY,

1659 float unitsX, float unitsY,

1660 float distanceFromCamera, float interpupillaryDistance,

1661 Matrix4f const &projection,

1662 float zNear /*= 0.0f*/, float zFar /*= 0.0f*/ )

1663 {

1664 OVR_UNUSED1 ( rightHanded );

1665

1666 float orthoHorizontalOffset = interpupillaryDistance * 0.5f / distanceFromCamera;

1667 switch ( eyeType )

1668 {

1669 case StereoEye_Center:

1670 orthoHorizontalOffset = 0.0f;

1671 break;

1672 case StereoEye_Left:

1673 break;

1674 case StereoEye_Right:

1675 orthoHorizontalOffset = -orthoHorizontalOffset;

1676 break;

1677 default: OVR_ASSERT ( false ); break;

1678 }

1679

1680 // Current projection maps real-world vector (x,y,1) to the RT.

1681 // We want to find the projection that maps the range [-FovPixels/2,FovPixels/2] to

1682 // the physical [-orthoHalfFov,orthoHalfFov]

1683 // Note moving the offset from M[0][2]+M[1][2] to M[0][3]+M[1][3] - this means

1684 // we don't have to feed in Z=1 all the time.

1685 // The horizontal offset math is a little hinky because the destination is

1686 // actually [-orthoHalfFov+orthoHorizontalOffset,orthoHalfFov+orthoHorizontalOffset]

1687 // So we need to first map [-FovPixels/2,FovPixels/2] to

1688 // [-orthoHalfFov+orthoHorizontalOffset,orthoHalfFov+orthoHorizontalOffset]:

1689 // x1 = x0 * orthoHalfFov/(FovPixels/2) + orthoHorizontalOffset;

1690 // = x0 * 2*orthoHalfFov/FovPixels + orthoHorizontalOffset;

1691 // But then we need the sam mapping as the existing projection matrix, i.e.

1692 // x2 = x1 * Projection.M[0][0] + Projection.M[0][2];

1693 // = x0 * (2*orthoHalfFov/FovPixels + orthoHorizontalOffset) * Projection.M[0][0] + Projection.M[0][2];

1694 // = x0 * Projection.M[0][0]*2*orthoHalfFov/FovPixels +

1695 // orthoHorizontalOffset*Projection.M[0][0] + Projection.M[0][2];

1696 // So in the new projection matrix we need to scale by Projection.M[0][0]*2*orthoHalfFov/FovPixels and

1697 // offset by orthoHorizontalOffset*Projection.M[0][0] + Projection.M[0][2].

1698

1699 float orthoScaleX = 2.0f * tanHalfFovX / unitsX;

1700 float orthoScaleY = 2.0f * tanHalfFovY / unitsY;

1701 Matrix4f ortho;

1702 ortho.M[0][0] = projection.M[0][0] * orthoScaleX;

1703 ortho.M[0][1] = 0.0f;

1704 ortho.M[0][2] = 0.0f;

1705 ortho.M[0][3] = -projection.M[0][2] + ( orthoHorizontalOffset * projection.M[0][0] );

1706

1707 ortho.M[1][0] = 0.0f;

1708 ortho.M[1][1] = -projection.M[1][1] * orthoScaleY; // Note sign flip (text rendering uses Y=down).

1709 ortho.M[1][2] = 0.0f;

1710 ortho.M[1][3] = -projection.M[1][2];

1711

1712 if ( fabsf ( zNear - zFar ) < 0.001f )

1713 {

1714 ortho.M[2][0] = 0.0f;

1715 ortho.M[2][1] = 0.0f;

1716 ortho.M[2][2] = 0.0f;

1717 ortho.M[2][3] = zFar;

1718 }

1719 else

1720 {

1721 ortho.M[2][0] = 0.0f;

1722 ortho.M[2][1] = 0.0f;

1723 ortho.M[2][2] = zFar / (zNear - zFar);

1724 ortho.M[2][3] = (zFar * zNear) / (zNear - zFar);

1725 }

1726

1727 // No perspective correction for ortho.

1728 ortho.M[3][0] = 0.0f;

1729 ortho.M[3][1] = 0.0f;

1730 ortho.M[3][2] = 0.0f;

1731 ortho.M[3][3] = 1.0f;

1732

1733 return ortho;

1734 }

1735

1736

1737 //-----------------------------------------------------------------------------------

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

1739

1740 // This mimics the first half of the distortion shader's function.

1741 Vector2f TransformScreenNDCToTanFovSpace( DistortionRenderDesc const &distortion,

1742 const Vector2f &framebufferNDC )

1743 {

1744 // Scale to TanHalfFov space, but still distorted.

1745 Vector2f tanEyeAngleDistorted;

1746 tanEyeAngleDistorted.x = ( framebufferNDC.x - distortion.LensCenter.x ) * distortion.TanEyeAngleScale.x;

1747 tanEyeAngleDistorted.y = ( framebufferNDC.y - distortion.LensCenter.y ) * distortion.TanEyeAngleScale.y;

1748 // Distort.

1749 float radiusSquared = ( tanEyeAngleDistorted.x * tanEyeAngleDistorted.x )

1750 + ( tanEyeAngleDistorted.y * tanEyeAngleDistorted.y );

1751 float distortionScale = distortion.Lens.DistortionFnScaleRadiusSquared ( radiusSquared );

1752 Vector2f tanEyeAngle;

1753 tanEyeAngle.x = tanEyeAngleDistorted.x * distortionScale;

1754 tanEyeAngle.y = tanEyeAngleDistorted.y * distortionScale;

1755

1756 return tanEyeAngle;

1757 }

1758

1759 // Same, with chromatic aberration correction.

1760 void TransformScreenNDCToTanFovSpaceChroma ( Vector2f *resultR, Vector2f *resultG, Vector2f *resultB,

1761 DistortionRenderDesc const &distortion,

1762 const Vector2f &framebufferNDC )

1763 {

1764 // Scale to TanHalfFov space, but still distorted.

1765 Vector2f tanEyeAngleDistorted;

1766 tanEyeAngleDistorted.x = ( framebufferNDC.x - distortion.LensCenter.x ) * distortion.TanEyeAngleScale.x;

1767 tanEyeAngleDistorted.y = ( framebufferNDC.y - distortion.LensCenter.y ) * distortion.TanEyeAngleScale.y;

1768 // Distort.

1769 float radiusSquared = ( tanEyeAngleDistorted.x * tanEyeAngleDistorted.x )

1770 + ( tanEyeAngleDistorted.y * tanEyeAngleDistorted.y );

1771 Vector3f distortionScales = distortion.Lens.DistortionFnScaleRadiusSquaredChroma ( radiusSquared );

1772 *resultR = tanEyeAngleDistorted * distortionScales.x;

1773 *resultG = tanEyeAngleDistorted * distortionScales.y;

1774 *resultB = tanEyeAngleDistorted * distortionScales.z;

1775 }

1776

1777 // This mimics the second half of the distortion shader's function.

1778 Vector2f TransformTanFovSpaceToRendertargetTexUV( ScaleAndOffset2D const &eyeToSourceUV,

1779 Vector2f const &tanEyeAngle )

1780 {

1781 Vector2f textureUV;

1782 textureUV.x = tanEyeAngle.x * eyeToSourceUV.Scale.x + eyeToSourceUV.Offset.x;

1783 textureUV.y = tanEyeAngle.y * eyeToSourceUV.Scale.y + eyeToSourceUV.Offset.y;

1784 return textureUV;

1785 }

1786

1787 Vector2f TransformTanFovSpaceToRendertargetNDC( ScaleAndOffset2D const &eyeToSourceNDC,

1788 Vector2f const &tanEyeAngle )

1789 {

1790 Vector2f textureNDC;

1791 textureNDC.x = tanEyeAngle.x * eyeToSourceNDC.Scale.x + eyeToSourceNDC.Offset.x;

1792 textureNDC.y = tanEyeAngle.y * eyeToSourceNDC.Scale.y + eyeToSourceNDC.Offset.y;

1793 return textureNDC;

1794 }

1795

1796 Vector2f TransformScreenPixelToScreenNDC( Recti const &distortionViewport,

1797 Vector2f const &pixel )

1798 {

1799 // Move to [-1,1] NDC coords.

1800 Vector2f framebufferNDC;

1801 framebufferNDC.x = -1.0f + 2.0f * ( ( pixel.x - (float)distortionViewport.x ) / (float)distortionViewport.w );

1802 framebufferNDC.y = -1.0f + 2.0f * ( ( pixel.y - (float)distortionViewport.y ) / (float)distortionViewport.h );

1803 return framebufferNDC;

1804 }

1805

1806 Vector2f TransformScreenPixelToTanFovSpace( Recti const &distortionViewport,

1807 DistortionRenderDesc const &distortion,

1808 Vector2f const &pixel )

1809 {

1810 return TransformScreenNDCToTanFovSpace( distortion,

1811 TransformScreenPixelToScreenNDC( distortionViewport, pixel ) );

1812 }

1813

1814 Vector2f TransformScreenNDCToRendertargetTexUV( DistortionRenderDesc const &distortion,

1815 StereoEyeParams const &eyeParams,

1816 Vector2f const &pixel )

1817 {

1818 return TransformTanFovSpaceToRendertargetTexUV ( eyeParams,

1819 TransformScreenNDCToTanFovSpace ( distortion, pixel ) );

1820 }

1821

1822 Vector2f TransformScreenPixelToRendertargetTexUV( Recti const &distortionViewport,

1823 DistortionRenderDesc const &distortion,

1824 StereoEyeParams const &eyeParams,

1825 Vector2f const &pixel )

1826 {

1827 return TransformTanFovSpaceToRendertargetTexUV ( eyeParams,

1828 TransformScreenPixelToTanFovSpace ( distortionViewport, distortion, pixel ) );

1829 }

1830

1831

1832 //-----------------------------------------------------------------------------------

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

1834

1835 Vector2f TransformTanFovSpaceToScreenNDC( DistortionRenderDesc const &distortion,

1836 const Vector2f &tanEyeAngle, bool usePolyApprox /*= false*/ )

1837 {

1838 float tanEyeAngleRadius = tanEyeAngle.Length();

1839 float tanEyeAngleDistortedRadius = distortion.Lens.DistortionFnInverseApprox ( tanEyeAngleRadius );

1840 if ( !usePolyApprox )

1841 {

1842 tanEyeAngleDistortedRadius = distortion.Lens.DistortionFnInverse ( tanEyeAngleRadius );

1843 }

1844 Vector2f tanEyeAngleDistorted = tanEyeAngle;

1845 if ( tanEyeAngleRadius > 0.0f )

1846 {

1847 tanEyeAngleDistorted = tanEyeAngle * ( tanEyeAngleDistortedRadius / tanEyeAngleRadius );

1848 }

1849

1850 Vector2f framebufferNDC;

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

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

1853

1854 return framebufferNDC;

1855 }

1856

1857 Vector2f TransformRendertargetNDCToTanFovSpace( const ScaleAndOffset2D &eyeToSourceNDC,

1858 const Vector2f &textureNDC )

1859 {

1860 Vector2f tanEyeAngle = (textureNDC - eyeToSourceNDC.Offset) / eyeToSourceNDC.Scale;

1861 return tanEyeAngle;

1862 }

1863

1864

1865

1866 } //namespace OVR

1867

1868 //Just want to make a copy disentangled from all these namespaces!

1869 float ExtEvalCatmullRom10Spline ( float const *K, float scaledVal )

1870 {

1871 return(OVR::EvalCatmullRom10Spline ( K, scaledVal ));

1872 }

1873

1874