/******************************************************************************
|
|
@File PVRTMisc.cpp
|
|
@Title PVRTMisc
|
|
@Version
|
|
@Copyright Copyright (c) Imagination Technologies Limited.
|
|
@Platform ANSI compatible
|
|
@Description Miscellaneous functions used in 3D rendering.
|
|
******************************************************************************/
|
#include <string.h>
|
#include <stdlib.h>
|
#include <ctype.h>
|
#include <limits.h>
|
#include <math.h>
|
#include "PVRTGlobal.h"
|
#include "PVRTContext.h"
|
#include "PVRTFixedPoint.h"
|
#include "PVRTMatrix.h"
|
#include "PVRTMisc.h"
|
|
|
|
/*!***************************************************************************
|
@Function PVRTMiscCalculateIntersectionLinePlane
|
@Input pfPlane Length 4 [A,B,C,D], values for plane
|
equation
|
@Input pv0 A point on the line
|
@Input pv1 Another point on the line
|
@Output pvIntersection The point of intersection
|
@Description Calculates coords of the intersection of a line and an
|
infinite plane
|
*****************************************************************************/
|
void PVRTMiscCalculateIntersectionLinePlane(
|
PVRTVECTOR3 * const pvIntersection,
|
const VERTTYPE pfPlane[4],
|
const PVRTVECTOR3 * const pv0,
|
const PVRTVECTOR3 * const pv1)
|
{
|
PVRTVECTOR3 vD;
|
VERTTYPE fN, fD, fT;
|
|
/* Calculate vector from point0 to point1 */
|
vD.x = pv1->x - pv0->x;
|
vD.y = pv1->y - pv0->y;
|
vD.z = pv1->z - pv0->z;
|
|
/* Denominator */
|
fD =
|
VERTTYPEMUL(pfPlane[0], vD.x) +
|
VERTTYPEMUL(pfPlane[1], vD.y) +
|
VERTTYPEMUL(pfPlane[2], vD.z);
|
|
/* Numerator */
|
fN =
|
VERTTYPEMUL(pfPlane[0], pv0->x) +
|
VERTTYPEMUL(pfPlane[1], pv0->y) +
|
VERTTYPEMUL(pfPlane[2], pv0->z) +
|
pfPlane[3];
|
|
fT = VERTTYPEDIV(-fN, fD);
|
|
/* And for a finale, calculate the intersection coordinate */
|
pvIntersection->x = pv0->x + VERTTYPEMUL(fT, vD.x);
|
pvIntersection->y = pv0->y + VERTTYPEMUL(fT, vD.y);
|
pvIntersection->z = pv0->z + VERTTYPEMUL(fT, vD.z);
|
}
|
|
|
/*!***************************************************************************
|
@Function PVRTMiscCalculateInfinitePlane
|
@Input nStride Size of each vertex structure containing pfVtx
|
@Input pvPlane Length 4 [A,B,C,D], values for plane equation
|
@Input pmViewProjInv The inverse of the View Projection matrix
|
@Input pFrom Position of the camera
|
@Input fFar Far clipping distance
|
@Output pfVtx Position of the first of 3 floats to receive
|
the position of vertex 0; up to 5 vertex positions
|
will be written (5 is the maximum number of vertices
|
required to draw an infinite polygon clipped to screen
|
and far clip plane).
|
@Returns Number of vertices in the polygon fan (Can be 0, 3, 4 or 5)
|
@Description Calculates world-space coords of a screen-filling
|
representation of an infinite plane The resulting vertices run
|
counter-clockwise around the screen, and can be simply drawn using
|
non-indexed TRIANGLEFAN
|
*****************************************************************************/
|
int PVRTMiscCalculateInfinitePlane(
|
VERTTYPE * const pfVtx,
|
const int nStride,
|
const PVRTVECTOR4 * const pvPlane,
|
const PVRTMATRIX * const pmViewProjInv,
|
const PVRTVECTOR3 * const pFrom,
|
const VERTTYPE fFar)
|
{
|
PVRTVECTOR3 pvWorld[5];
|
PVRTVECTOR3 *pvPolyPtr;
|
unsigned int dwCount;
|
bool bClip;
|
int nVert;
|
VERTTYPE fDotProduct;
|
|
/*
|
Check whether the plane faces the camera
|
*/
|
fDotProduct =
|
VERTTYPEMUL((pFrom->x + VERTTYPEMUL(pvPlane->x, pvPlane->w)), pvPlane->x) +
|
VERTTYPEMUL((pFrom->y + VERTTYPEMUL(pvPlane->y, pvPlane->w)), pvPlane->y) +
|
VERTTYPEMUL((pFrom->z + VERTTYPEMUL(pvPlane->z, pvPlane->w)), pvPlane->z);
|
|
if(fDotProduct < 0) {
|
/* Camera is behind plane, hence it's not visible */
|
return 0;
|
}
|
|
/*
|
Back transform front clipping plane into world space,
|
to give us a point on the line through each corner of the screen
|
(from the camera).
|
*/
|
|
/* x = -1.0f; y = -1.0f; z = 1.0f; w = 1.0f */
|
pvWorld[0].x = VERTTYPEMUL((-pmViewProjInv->f[ 0] - pmViewProjInv->f[ 4] + pmViewProjInv->f[ 8] + pmViewProjInv->f[12]), fFar);
|
pvWorld[0].y = VERTTYPEMUL((-pmViewProjInv->f[ 1] - pmViewProjInv->f[ 5] + pmViewProjInv->f[ 9] + pmViewProjInv->f[13]), fFar);
|
pvWorld[0].z = VERTTYPEMUL((-pmViewProjInv->f[ 2] - pmViewProjInv->f[ 6] + pmViewProjInv->f[10] + pmViewProjInv->f[14]), fFar);
|
/* x = 1.0f, y = -1.0f, z = 1.0f; w = 1.0f */
|
pvWorld[1].x = VERTTYPEMUL(( pmViewProjInv->f[ 0] - pmViewProjInv->f[ 4] + pmViewProjInv->f[ 8] + pmViewProjInv->f[12]), fFar);
|
pvWorld[1].y = VERTTYPEMUL(( pmViewProjInv->f[ 1] - pmViewProjInv->f[ 5] + pmViewProjInv->f[ 9] + pmViewProjInv->f[13]), fFar);
|
pvWorld[1].z = VERTTYPEMUL(( pmViewProjInv->f[ 2] - pmViewProjInv->f[ 6] + pmViewProjInv->f[10] + pmViewProjInv->f[14]), fFar);
|
/* x = 1.0f, y = 1.0f, z = 1.0f; w = 1.0f */
|
pvWorld[2].x = VERTTYPEMUL(( pmViewProjInv->f[ 0] + pmViewProjInv->f[ 4] + pmViewProjInv->f[ 8] + pmViewProjInv->f[12]), fFar);
|
pvWorld[2].y = VERTTYPEMUL(( pmViewProjInv->f[ 1] + pmViewProjInv->f[ 5] + pmViewProjInv->f[ 9] + pmViewProjInv->f[13]), fFar);
|
pvWorld[2].z = VERTTYPEMUL(( pmViewProjInv->f[ 2] + pmViewProjInv->f[ 6] + pmViewProjInv->f[10] + pmViewProjInv->f[14]), fFar);
|
/* x = -1.0f, y = 1.0f, z = 1.0f; w = 1.0f */
|
pvWorld[3].x = VERTTYPEMUL((-pmViewProjInv->f[ 0] + pmViewProjInv->f[ 4] + pmViewProjInv->f[ 8] + pmViewProjInv->f[12]), fFar);
|
pvWorld[3].y = VERTTYPEMUL((-pmViewProjInv->f[ 1] + pmViewProjInv->f[ 5] + pmViewProjInv->f[ 9] + pmViewProjInv->f[13]), fFar);
|
pvWorld[3].z = VERTTYPEMUL((-pmViewProjInv->f[ 2] + pmViewProjInv->f[ 6] + pmViewProjInv->f[10] + pmViewProjInv->f[14]), fFar);
|
|
/* We need to do a closed loop of the screen vertices, so copy the first vertex into the last */
|
pvWorld[4] = pvWorld[0];
|
|
/*
|
Now build a pre-clipped polygon
|
*/
|
|
/* Lets get ready to loop */
|
dwCount = 0;
|
bClip = false;
|
pvPolyPtr = (PVRTVECTOR3*)pfVtx;
|
|
nVert = 5;
|
while(nVert)
|
{
|
nVert--;
|
|
/*
|
Check which side of the Plane this corner of the far clipping
|
plane is on. [A,B,C] of plane equation is the plane normal, D is
|
distance from origin; hence [pvPlane->x * -pvPlane->w,
|
pvPlane->y * -pvPlane->w,
|
pvPlane->z * -pvPlane->w]
|
is a point on the plane
|
*/
|
fDotProduct =
|
VERTTYPEMUL((pvWorld[nVert].x + VERTTYPEMUL(pvPlane->x, pvPlane->w)), pvPlane->x) +
|
VERTTYPEMUL((pvWorld[nVert].y + VERTTYPEMUL(pvPlane->y, pvPlane->w)), pvPlane->y) +
|
VERTTYPEMUL((pvWorld[nVert].z + VERTTYPEMUL(pvPlane->z, pvPlane->w)), pvPlane->z);
|
|
if(fDotProduct < 0)
|
{
|
/*
|
Behind plane; Vertex does NOT need clipping
|
*/
|
if(bClip == true)
|
{
|
/* Clipping finished */
|
bClip = false;
|
|
/*
|
We've been clipping, so we need to add an additional
|
point on the line to this point, where clipping was
|
stopped.
|
*/
|
PVRTMiscCalculateIntersectionLinePlane(pvPolyPtr, &pvPlane->x, &pvWorld[nVert+1], &pvWorld[nVert]);
|
pvPolyPtr = (PVRTVECTOR3*)((char*)pvPolyPtr + nStride);
|
dwCount++;
|
}
|
|
if(!nVert)
|
{
|
/* Abort, abort: we've closed the loop with the clipped point */
|
break;
|
}
|
|
/* Add the current point */
|
PVRTMiscCalculateIntersectionLinePlane(pvPolyPtr, &pvPlane->x, pFrom, &pvWorld[nVert]);
|
pvPolyPtr = (PVRTVECTOR3*)((char*)pvPolyPtr + nStride);
|
dwCount++;
|
}
|
else
|
{
|
/*
|
Before plane; Vertex DOES need clipping
|
*/
|
if(bClip == true)
|
{
|
/* Already in clipping, skip point */
|
continue;
|
}
|
|
/* Clipping initiated */
|
bClip = true;
|
|
/* Don't bother with entry point on first vertex; will take care of it on last vertex (which is a repeat of first vertex) */
|
if(nVert != 4)
|
{
|
/* We need to add an additional point on the line to this point, where clipping was started */
|
PVRTMiscCalculateIntersectionLinePlane(pvPolyPtr, &pvPlane->x, &pvWorld[nVert+1], &pvWorld[nVert]);
|
pvPolyPtr = (PVRTVECTOR3*)((char*)pvPolyPtr + nStride);
|
dwCount++;
|
}
|
}
|
}
|
|
/* Valid vertex counts are 0, 3, 4, 5 */
|
_ASSERT(dwCount <= 5);
|
_ASSERT(dwCount != 1);
|
_ASSERT(dwCount != 2);
|
|
return dwCount;
|
}
|
|
|
/*!***************************************************************************
|
@Function SetVertex
|
@Modified Vertices
|
@Input index
|
@Input x
|
@Input y
|
@Input z
|
@Description Writes a vertex in a vertex array
|
*****************************************************************************/
|
static void SetVertex(VERTTYPE** Vertices, int index, VERTTYPE x, VERTTYPE y, VERTTYPE z)
|
{
|
(*Vertices)[index*3+0] = x;
|
(*Vertices)[index*3+1] = y;
|
(*Vertices)[index*3+2] = z;
|
}
|
|
/*!***************************************************************************
|
@Function SetUV
|
@Modified UVs
|
@Input index
|
@Input u
|
@Input v
|
@Description Writes a texture coordinate in a texture coordinate array
|
*****************************************************************************/
|
static void SetUV(VERTTYPE** UVs, int index, VERTTYPE u, VERTTYPE v)
|
{
|
(*UVs)[index*2+0] = u;
|
(*UVs)[index*2+1] = v;
|
}
|
|
/*!***************************************************************************
|
@Function PVRTCreateSkybox
|
@Input scale Scale the skybox
|
@Input adjustUV Adjust or not UVs for PVRT compression
|
@Input textureSize Texture size in pixels
|
@Output Vertices Array of vertices
|
@Output UVs Array of UVs
|
@Description Creates the vertices and texture coordinates for a skybox
|
*****************************************************************************/
|
void PVRTCreateSkybox(float scale, bool adjustUV, int textureSize, VERTTYPE** Vertices, VERTTYPE** UVs)
|
{
|
*Vertices = new VERTTYPE[24*3];
|
*UVs = new VERTTYPE[24*2];
|
|
VERTTYPE unit = f2vt(1);
|
VERTTYPE a0 = 0, a1 = unit;
|
|
if (adjustUV)
|
{
|
VERTTYPE oneover = f2vt(1.0f / textureSize);
|
a0 = VERTTYPEMUL(f2vt(4.0f), oneover);
|
a1 = unit - a0;
|
}
|
|
// Front
|
SetVertex(Vertices, 0, -unit, +unit, -unit);
|
SetVertex(Vertices, 1, +unit, +unit, -unit);
|
SetVertex(Vertices, 2, -unit, -unit, -unit);
|
SetVertex(Vertices, 3, +unit, -unit, -unit);
|
SetUV(UVs, 0, a0, a1);
|
SetUV(UVs, 1, a1, a1);
|
SetUV(UVs, 2, a0, a0);
|
SetUV(UVs, 3, a1, a0);
|
|
// Right
|
SetVertex(Vertices, 4, +unit, +unit, -unit);
|
SetVertex(Vertices, 5, +unit, +unit, +unit);
|
SetVertex(Vertices, 6, +unit, -unit, -unit);
|
SetVertex(Vertices, 7, +unit, -unit, +unit);
|
SetUV(UVs, 4, a0, a1);
|
SetUV(UVs, 5, a1, a1);
|
SetUV(UVs, 6, a0, a0);
|
SetUV(UVs, 7, a1, a0);
|
|
// Back
|
SetVertex(Vertices, 8 , +unit, +unit, +unit);
|
SetVertex(Vertices, 9 , -unit, +unit, +unit);
|
SetVertex(Vertices, 10, +unit, -unit, +unit);
|
SetVertex(Vertices, 11, -unit, -unit, +unit);
|
SetUV(UVs, 8 , a0, a1);
|
SetUV(UVs, 9 , a1, a1);
|
SetUV(UVs, 10, a0, a0);
|
SetUV(UVs, 11, a1, a0);
|
|
// Left
|
SetVertex(Vertices, 12, -unit, +unit, +unit);
|
SetVertex(Vertices, 13, -unit, +unit, -unit);
|
SetVertex(Vertices, 14, -unit, -unit, +unit);
|
SetVertex(Vertices, 15, -unit, -unit, -unit);
|
SetUV(UVs, 12, a0, a1);
|
SetUV(UVs, 13, a1, a1);
|
SetUV(UVs, 14, a0, a0);
|
SetUV(UVs, 15, a1, a0);
|
|
// Top
|
SetVertex(Vertices, 16, -unit, +unit, +unit);
|
SetVertex(Vertices, 17, +unit, +unit, +unit);
|
SetVertex(Vertices, 18, -unit, +unit, -unit);
|
SetVertex(Vertices, 19, +unit, +unit, -unit);
|
SetUV(UVs, 16, a0, a1);
|
SetUV(UVs, 17, a1, a1);
|
SetUV(UVs, 18, a0, a0);
|
SetUV(UVs, 19, a1, a0);
|
|
// Bottom
|
SetVertex(Vertices, 20, -unit, -unit, -unit);
|
SetVertex(Vertices, 21, +unit, -unit, -unit);
|
SetVertex(Vertices, 22, -unit, -unit, +unit);
|
SetVertex(Vertices, 23, +unit, -unit, +unit);
|
SetUV(UVs, 20, a0, a1);
|
SetUV(UVs, 21, a1, a1);
|
SetUV(UVs, 22, a0, a0);
|
SetUV(UVs, 23, a1, a0);
|
|
for (int i=0; i<24*3; i++) (*Vertices)[i] = VERTTYPEMUL((*Vertices)[i], f2vt(scale));
|
}
|
|
/*!***************************************************************************
|
@Function PVRTDestroySkybox
|
@Input Vertices Vertices array to destroy
|
@Input UVs UVs array to destroy
|
@Description Destroy the memory allocated for a skybox
|
*****************************************************************************/
|
void PVRTDestroySkybox(VERTTYPE* Vertices, VERTTYPE* UVs)
|
{
|
delete [] Vertices;
|
delete [] UVs;
|
}
|
|
/*!***************************************************************************
|
@Function PVRTGetPOTHigher
|
@Input uiOriginalValue Base value
|
@Input iTimesHigher Multiplier
|
@Description When iTimesHigher is one, this function will return the closest
|
power-of-two value above the base value.
|
For every increment beyond one for the iTimesHigher value,
|
the next highest power-of-two value will be calculated.
|
*****************************************************************************/
|
unsigned int PVRTGetPOTHigher(unsigned int uiOriginalValue, int iTimesHigher)
|
{
|
if(uiOriginalValue == 0 || iTimesHigher < 0)
|
{
|
return 0;
|
}
|
|
unsigned int uiSize = 1;
|
while (uiSize < uiOriginalValue) uiSize *= 2;
|
|
// Keep increasing the POT value until the iTimesHigher value has been met
|
for(int i = 1 ; i < iTimesHigher; ++i)
|
{
|
uiSize *= 2;
|
}
|
|
return uiSize;
|
}
|
|
/*!***************************************************************************
|
@Function PVRTGetPOTLower
|
@Input uiOriginalValue Base value
|
@Input iTimesLower Multiplier
|
@Description When iTimesLower is one, this function will return the closest
|
power-of-two value below the base value.
|
For every increment beyond one for the iTimesLower value,
|
the next lowest power-of-two value will be calculated. The lowest
|
value that can be reached is 1.
|
*****************************************************************************/
|
// NOTE: This function should be optimised
|
unsigned int PVRTGetPOTLower(unsigned int uiOriginalValue, int iTimesLower)
|
{
|
if(uiOriginalValue == 0 || iTimesLower < 0)
|
{
|
return 0;
|
}
|
unsigned int uiSize = PVRTGetPOTHigher(uiOriginalValue,1);
|
uiSize >>= 1;//uiSize /=2;
|
|
for(int i = 1; i < iTimesLower; ++i)
|
{
|
uiSize >>= 1;//uiSize /=2;
|
if(uiSize == 1)
|
{
|
// Lowest possible value has been reached, so break
|
break;
|
}
|
}
|
return uiSize;
|
}
|
|
|
|
/*****************************************************************************
|
End of file (PVRTMisc.cpp)
|
*****************************************************************************/
|
