/*

 * KJL 15:13:43 7/17/97 - frustrum.c

 *

 * Contains all the functions connected

 * to the view frustrum and clipping

 *

 */

#include "system.h"

#include "prototyp.h"

#include <assert.h>

#include "gamedef.h"

#include "frustum.h"

extern VECTORCH RotatedPts[];

static RENDERVERTEX VerticesClipped[9];

#define  FAR_Z_CLIP 0

#define ZCLIPPINGVALUE 64

#define FAR_Z_CLIP_RANGE 49000

/* clipping code macros - these are used as building blocks to assemble

clipping fns for different polygon types with the minimum of fuss */

#define Clip_PX_Test(v) ((v)->X <= (v)->Z)

#define Clip_NY_Test(v) (-(v)->Y <= (v)->Z)

#define Clip_PY_Test(v) ((v)->Y <= (v)->Z)      

#define Clip_Wide_NX_Test(v) (-(v)->X <= (v)->Z*2)

#define Clip_Wide_PX_Test(v) ((v)->X <= (v)->Z*2)

#define Clip_Wide_NY_Test(v) (-(v)->Y <= (v)->Z*2)

#define Clip_Wide_PY_Test(v) ((v)->Y <= (v)->Z*2)      

#define Clip_LoopStart(b) \

    \

    do \

    { \

        RENDERVERTEX *nextVertexPtr; \

 \

        /* setup pointer to next vertex, wrapping round if necessary */ \

        if (!--verticesLeft) \

            nextVertexPtr = (b); \

        else  \

            nextVertexPtr = curVertexPtr+1; \

 \

        /* if current vertex is inside the plane, output it */ \

        if (curVertexInside) \

        { \

            numberOfPointsOutputted++; \

            *outputVerticesPtr++ = *curVertexPtr; \

          } \

 \

        /* test if next vertex is inside the plane */ \

            int nextVertexInside =  

#define Clip_OutputI \

            outputVerticesPtr->U = curVertexPtr->U + MUL_FIXED(lambda, nextVertexPtr->U - curVertexPtr->U); \

            outputVerticesPtr->V = curVertexPtr->V + MUL_FIXED(lambda, nextVertexPtr->V - curVertexPtr->V); \

            outputVerticesPtr->A = curVertexPtr->A + MUL_FIXED(lambda, nextVertexPtr->A - curVertexPtr->A); \

            outputVerticesPtr->R = curVertexPtr->R + MUL_FIXED(lambda, nextVertexPtr->R - curVertexPtr->R); \

            outputVerticesPtr->G = curVertexPtr->G + MUL_FIXED(lambda, nextVertexPtr->G - curVertexPtr->G); \

            outputVerticesPtr->B = curVertexPtr->B + MUL_FIXED(lambda, nextVertexPtr->B - curVertexPtr->B); \

            outputVerticesPtr->SpecularR = curVertexPtr->SpecularR + MUL_FIXED(lambda, nextVertexPtr->SpecularR - curVertexPtr->SpecularR); \

            outputVerticesPtr->SpecularG = curVertexPtr->SpecularG + MUL_FIXED(lambda, nextVertexPtr->SpecularG - curVertexPtr->SpecularG); \

            outputVerticesPtr->SpecularB = curVertexPtr->SpecularB + MUL_FIXED(lambda, nextVertexPtr->SpecularB - curVertexPtr->SpecularB); \

\

            numberOfPointsOutputted++; \

            outputVerticesPtr++; \

        } \

 \

        /* okay, now the current vertex becomes what was the next vertex */ \

        curVertexPtr = nextVertexPtr; \

        curVertexInside = nextVertexInside; \

    } while(verticesLeft); \

 \

    RenderPolygon.NumberOfVertices = numberOfPointsOutputted; 

#define Clip_NX_OutputXYZ \

        /* if one is in, and the other is out, output a clipped vertex */ \

        if (nextVertexInside != curVertexInside) \

        { \

            int lambda = DIV_FIXED((curVertexPtr->Z + curVertexPtr->X), \

                -(nextVertexPtr->X-curVertexPtr->X) - (nextVertexPtr->Z-curVertexPtr->Z)); \

 \

            outputVerticesPtr->X = curVertexPtr->X + MUL_FIXED(lambda, nextVertexPtr->X - curVertexPtr->X); \

            outputVerticesPtr->Z = -outputVerticesPtr->X; \

            outputVerticesPtr->Y = curVertexPtr->Y + MUL_FIXED(lambda, nextVertexPtr->Y - curVertexPtr->Y);

#define Clip_Wide_NX_OutputXYZ \

        /* if one is in, and the other is out, output a clipped vertex */ \

        if (nextVertexInside != curVertexInside) \

        { \

            int lambda = DIV_FIXED( (-2*curVertexPtr->Z - curVertexPtr->X), \

                (nextVertexPtr->X - curVertexPtr->X) - (-2)*(nextVertexPtr->Z - curVertexPtr->Z)); \

 \

            outputVerticesPtr->X = curVertexPtr->X + MUL_FIXED(lambda, nextVertexPtr->X - curVertexPtr->X); \

            outputVerticesPtr->Z = -outputVerticesPtr->X/2; \

            outputVerticesPtr->Y = curVertexPtr->Y + MUL_FIXED(lambda, nextVertexPtr->Y - curVertexPtr->Y);

#define Clip_NY_OutputXYZ \

        /* if one is in, and the other is out, output a clipped vertex */ \

        if (nextVertexInside != curVertexInside) \

        { \

            int lambda = DIV_FIXED((curVertexPtr->Z + curVertexPtr->Y), \

                -(nextVertexPtr->Y - curVertexPtr->Y) - (nextVertexPtr->Z - curVertexPtr->Z)); \

 \

            outputVerticesPtr->Z = curVertexPtr->Z + MUL_FIXED(lambda, nextVertexPtr->Z - curVertexPtr->Z); \

            outputVerticesPtr->Y = -(outputVerticesPtr->Z); \

            outputVerticesPtr->X = curVertexPtr->X + MUL_FIXED(lambda, nextVertexPtr->X - curVertexPtr->X);

#define Clip_Wide_NY_OutputXYZ \

        /* if one is in, and the other is out, output a clipped vertex */ \

        if (nextVertexInside != curVertexInside) \

        { \

            int lambda = DIV_FIXED((2*curVertexPtr->Z + curVertexPtr->Y), \

                -(nextVertexPtr->Y-curVertexPtr->Y) - 2*(nextVertexPtr->Z - curVertexPtr->Z)); \

 \

            outputVerticesPtr->Z = curVertexPtr->Z + MUL_FIXED(lambda, nextVertexPtr->Z - curVertexPtr->Z); \

            outputVerticesPtr->Y = -(outputVerticesPtr->Z*2); \

            outputVerticesPtr->X = curVertexPtr->X + MUL_FIXED(lambda, nextVertexPtr->X - curVertexPtr->X);

#define Clip_PX_OutputXYZ \

        /* if one is in, and the other is out, output a clipped vertex */ \

        if (nextVertexInside != curVertexInside) \

        { \

            int lambda = DIV_FIXED((curVertexPtr->Z - curVertexPtr->X), \

                (nextVertexPtr->X - curVertexPtr->X) - (nextVertexPtr->Z - curVertexPtr->Z)); \

 \

            outputVerticesPtr->X = curVertexPtr->X + MUL_FIXED(lambda, nextVertexPtr->X - curVertexPtr->X); \

            outputVerticesPtr->Z = outputVerticesPtr->X; \

            outputVerticesPtr->Y = curVertexPtr->Y + MUL_FIXED(lambda, nextVertexPtr->Y - curVertexPtr->Y);

#define Clip_Wide_PX_OutputXYZ \

        /* if one is in, and the other is out, output a clipped vertex */ \

        if (nextVertexInside != curVertexInside) \

        { \

            int lambda = DIV_FIXED((2*curVertexPtr->Z - curVertexPtr->X), \

                (nextVertexPtr->X - curVertexPtr->X) - 2*(nextVertexPtr->Z - curVertexPtr->Z)); \

 \

            outputVerticesPtr->X = curVertexPtr->X + MUL_FIXED(lambda, nextVertexPtr->X - curVertexPtr->X); \

            outputVerticesPtr->Z = outputVerticesPtr->X/2; \

            outputVerticesPtr->Y = curVertexPtr->Y + MUL_FIXED(lambda, nextVertexPtr->Y - curVertexPtr->Y);

#define Clip_PY_OutputXYZ \

        /* if one is in, and the other is out, output a clipped vertex */ \

        if (nextVertexInside != curVertexInside) \

        { \

            int lambda = DIV_FIXED((curVertexPtr->Z - curVertexPtr->Y), \

                (nextVertexPtr->Y - curVertexPtr->Y) - (nextVertexPtr->Z - curVertexPtr->Z)); \

 \

            outputVerticesPtr->Z = curVertexPtr->Z + MUL_FIXED(lambda, nextVertexPtr->Z - curVertexPtr->Z); \

            outputVerticesPtr->Y = (outputVerticesPtr->Z); \

            outputVerticesPtr->X = curVertexPtr->X + MUL_FIXED(lambda, nextVertexPtr->X - curVertexPtr->X);

#define Clip_Wide_PY_OutputXYZ \

        /* if one is in, and the other is out, output a clipped vertex */ \

        if (nextVertexInside != curVertexInside) \

        { \

            int lambda = DIV_FIXED((2*curVertexPtr->Z - curVertexPtr->Y), \

                (nextVertexPtr->Y - curVertexPtr->Y) - 2*(nextVertexPtr->Z - curVertexPtr->Z)); \

 \

            outputVerticesPtr->Z = curVertexPtr->Z + MUL_FIXED(lambda, nextVertexPtr->Z - curVertexPtr->Z); \

            outputVerticesPtr->Y = (outputVerticesPtr->Z*2); \

            outputVerticesPtr->X = curVertexPtr->X + MUL_FIXED(lambda, nextVertexPtr->X - curVertexPtr->X);

#define Clip_Z_OutputXYZ \

        /* if one is in, and the other is out, output a clipped vertex */ \

        if (nextVertexInside != curVertexInside) \

        { \

            int lambda = DIV_FIXED( (ZCLIPPINGVALUE - curVertexPtr->Z), \

                (nextVertexPtr->Z - curVertexPtr->Z)); \

 \

            outputVerticesPtr->X = curVertexPtr->X + MUL_FIXED(lambda,nextVertexPtr->X-curVertexPtr->X); \

            outputVerticesPtr->Y = curVertexPtr->Y + MUL_FIXED(lambda,nextVertexPtr->Y-curVertexPtr->Y); \

            outputVerticesPtr->Z = ZCLIPPINGVALUE; 

static int (*VertexWithinFrustrum)(RENDERVERTEX *vertexPtr);

int (*ClipPolygon)(int NumberOfVertices);

int (*ObjectWithinFrustrum)(DISPLAYBLOCK *dbPtr);

void (*TestVerticesWithFrustrum)(int x);

char FrustrumFlagForVertex[maxrotpts];

/* KJL 16:18:59 7/7/97 - simple vertex test to be used in first pass of subdividing code */

static int VertexWithin_Norm_Frustrum(RENDERVERTEX *vertexPtr)

{

    int vertexFlag = 0;

    if(ZCLIPPINGVALUE <= vertexPtr->Z)

        vertexFlag |= INSIDE_FRUSTRUM_Z_PLANE;

    if(Clip_PX_Test(vertexPtr))    vertexFlag |= INSIDE_FRUSTRUM_PX_PLANE;    

    if(-vertexPtr->X <= vertexPtr->Z)

        vertexFlag |= INSIDE_FRUSTRUM_NX_PLANE;    

    if(Clip_PY_Test(vertexPtr))    vertexFlag |= INSIDE_FRUSTRUM_PY_PLANE;    

    if(Clip_NY_Test(vertexPtr))    vertexFlag |= INSIDE_FRUSTRUM_NY_PLANE;    

    return vertexFlag;

}

static int VertexWithin_Wide_Frustrum(RENDERVERTEX *vertexPtr)

{

    int vertexFlag = 0;

    if(ZCLIPPINGVALUE <= vertexPtr->Z)

        vertexFlag |= INSIDE_FRUSTRUM_Z_PLANE;

    if(Clip_Wide_PX_Test(vertexPtr))    vertexFlag |= INSIDE_FRUSTRUM_PX_PLANE;    

    if(Clip_Wide_NX_Test(vertexPtr))    vertexFlag |= INSIDE_FRUSTRUM_NX_PLANE;    

    if(Clip_Wide_PY_Test(vertexPtr))    vertexFlag |= INSIDE_FRUSTRUM_PY_PLANE;    

    if(Clip_Wide_NY_Test(vertexPtr))    vertexFlag |= INSIDE_FRUSTRUM_NY_PLANE;    

    return vertexFlag;

}

/* KJL 15:32:52 7/17/97 - Test to see if an object is in the view frustrum */

static int ObjectWithin_Norm_Frustrum(DISPLAYBLOCK *dbPtr)

{

#if FAR_Z_CLIP

if(dbPtr->ObView.vz - dbPtr->extent.radius <= FAR_Z_CLIP_RANGE)

#endif

    if (dbPtr->ObView.vz + dbPtr->extent.radius >= ZCLIPPINGVALUE)

    {

        /* scale radius by square root of 2 */

        int radius = MUL_FIXED(92682, dbPtr->extent.radius);

        return

        (((dbPtr->ObView.vx - dbPtr->ObView.vz) <= radius)

        &&

        ((-dbPtr->ObView.vx - dbPtr->ObView.vz) <= radius)

        &&

        ((dbPtr->ObView.vy - dbPtr->ObView.vz) <= radius)

        &&

        ((-dbPtr->ObView.vy - dbPtr->ObView.vz) <= radius));

    }

return 0;

}

static int ObjectWithin_Wide_Frustrum(DISPLAYBLOCK *dbPtr)

{

    if (dbPtr->ObView.vz + dbPtr->extent.radius >= ZCLIPPINGVALUE)

    {

        /* scale radius by square root of 5 */

        int radius = MUL_FIXED(146543, dbPtr->extent.radius);

        return

        (((dbPtr->ObView.vx-2 * dbPtr->ObView.vz) <= radius)

        &&

        ((-dbPtr->ObView.vx-2 * dbPtr->ObView.vz) <= radius)

        &&

        ((dbPtr->ObView.vy-2 * dbPtr->ObView.vz) <= radius)

        &&

        ((-dbPtr->ObView.vy-2 * dbPtr->ObView.vz) <= radius));

    }

return 0;

}

static void TestVerticesWith_Norm_Frustrum(int v)

{

    assert(v > 0);

    while(v--)

    {

        char vertexFlag = 0;

#if FAR_Z_CLIP

if(ZCLIPPINGVALUE <= RotatedPts[v].vz && RotatedPts[v].vz <= FAR_Z_CLIP_RANGE)

#else

        if(ZCLIPPINGVALUE <= RotatedPts[v].vz)

#endif

            vertexFlag |= INSIDE_FRUSTRUM_Z_PLANE;

        if(-RotatedPts[v].vx <= RotatedPts[v].vz)

            vertexFlag |= INSIDE_FRUSTRUM_PX_PLANE;    

        if(RotatedPts[v].vx <= RotatedPts[v].vz)

            vertexFlag |= INSIDE_FRUSTRUM_NX_PLANE;    

        if(-RotatedPts[v].vy <= RotatedPts[v].vz)

            vertexFlag |= INSIDE_FRUSTRUM_PY_PLANE;    

        if(RotatedPts[v].vy <= RotatedPts[v].vz)

            vertexFlag |= INSIDE_FRUSTRUM_NY_PLANE;    

        FrustrumFlagForVertex[v] = vertexFlag;

    }

}

static void TestVerticesWith_Wide_Frustrum(int v)

{

    assert(v > 0);

    while(v--)

    {

        char vertexFlag = 0;

        if(ZCLIPPINGVALUE <= RotatedPts[v].vz)

            vertexFlag |= INSIDE_FRUSTRUM_Z_PLANE;

        if(-RotatedPts[v].vx <= RotatedPts[v].vz * 2)

            vertexFlag |= INSIDE_FRUSTRUM_PX_PLANE;    

        if(RotatedPts[v].vx <= RotatedPts[v].vz * 2)

            vertexFlag |= INSIDE_FRUSTRUM_NX_PLANE;    

        if(-RotatedPts[v].vy <= RotatedPts[v].vz * 2)

            vertexFlag |= INSIDE_FRUSTRUM_PY_PLANE;    

        if(RotatedPts[v].vy <= RotatedPts[v].vz * 2)

            vertexFlag |= INSIDE_FRUSTRUM_NY_PLANE;    

        FrustrumFlagForVertex[v] = vertexFlag;

    }

}

int PolyWithinFrustrum(int NumberOfVertices)

{

    char inFrustrumFlag = 0;

    char noClippingFlag = INSIDE_FRUSTRUM;

    RenderPolygon.NumberOfVertices = NumberOfVertices;

    while(--NumberOfVertices)

    {

        int vertexFlag = VertexWithinFrustrum(VerticesUnClipped + NumberOfVertices);

        if(!vertexFlag)

        return 0;

        inFrustrumFlag |= vertexFlag;

        noClippingFlag &= vertexFlag;

    }

    if(INSIDE_FRUSTRUM == inFrustrumFlag)

    {

        if(INSIDE_FRUSTRUM == noClippingFlag)

        {

            draw_vertices = VerticesUnClipped;

            return RenderPolygon.NumberOfVertices;

        }

        else

        {

            return ClipPolygon(RenderPolygon.NumberOfVertices);

        }

    }

return 0;

}

static int ClipPolygonNorm(int verticesLeft)

{

    int numberOfPointsOutputted = 0;

    int curVertexInside;

    RENDERVERTEX *curVertexPtr;

    RENDERVERTEX *outputVerticesPtr;

//ClipWithZ

//{

    curVertexPtr = VerticesUnClipped;

    outputVerticesPtr = VerticesClipped;

    curVertexInside = (ZCLIPPINGVALUE <= VerticesUnClipped->Z);

    Clip_LoopStart(VerticesUnClipped)

    ZCLIPPINGVALUE <= nextVertexPtr->Z;

    Clip_Z_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

//ClipWithNegativeX

//{

    verticesLeft = numberOfPointsOutputted;

    numberOfPointsOutputted = 0;

    curVertexPtr = VerticesClipped;

    outputVerticesPtr = VerticesUnClipped;

    curVertexInside = (-VerticesClipped->X <= VerticesClipped->Z);

    Clip_LoopStart(VerticesClipped)

    (-nextVertexPtr->X <= nextVertexPtr->Z);

    Clip_NX_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

//ClipWithPositiveY

//{

    verticesLeft = numberOfPointsOutputted;

    numberOfPointsOutputted = 0;

    curVertexPtr = VerticesUnClipped;

    outputVerticesPtr = VerticesClipped;

    curVertexInside = Clip_PY_Test((VerticesUnClipped));

    Clip_LoopStart((VerticesUnClipped))

    Clip_PY_Test(nextVertexPtr);

    Clip_PY_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

//ClipWithNegativeY

//{

    verticesLeft = numberOfPointsOutputted;

    numberOfPointsOutputted = 0;

    curVertexPtr = VerticesClipped;

    outputVerticesPtr = VerticesUnClipped;

    curVertexInside = Clip_NY_Test(VerticesClipped);

    Clip_LoopStart(VerticesClipped)

    Clip_NY_Test(nextVertexPtr);

    Clip_NY_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

//ClipWithPositiveX

//{

    verticesLeft = numberOfPointsOutputted;

    numberOfPointsOutputted = 0;

    curVertexPtr = VerticesUnClipped;

    outputVerticesPtr = VerticesClipped;

    curVertexInside = Clip_PX_Test((VerticesUnClipped));

    Clip_LoopStart((VerticesUnClipped))

    Clip_PX_Test(nextVertexPtr);

    Clip_PX_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

    RenderPolygon.NumberOfVertices = numberOfPointsOutputted;

    draw_vertices = VerticesClipped;

return 1;

}

static int ClipPolygonWide(int verticesLeft)

{

    int numberOfPointsOutputted = 0;

    int curVertexInside;

    RENDERVERTEX *curVertexPtr;

    RENDERVERTEX *outputVerticesPtr;

//Polygon_ClipWithZ()

//{

    curVertexPtr = VerticesUnClipped;

    outputVerticesPtr = VerticesClipped;

    curVertexInside = (ZCLIPPINGVALUE <= VerticesUnClipped->Z);

    Clip_LoopStart(VerticesUnClipped)

    ZCLIPPINGVALUE <= nextVertexPtr->Z;

    Clip_Z_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

//Polygon_Wide_ClipWithNegativeX()

//{

    verticesLeft = numberOfPointsOutputted;

    numberOfPointsOutputted = 0;

    curVertexPtr = VerticesClipped;

    outputVerticesPtr = VerticesUnClipped;

    curVertexInside = Clip_Wide_NX_Test(VerticesClipped);

    Clip_LoopStart(VerticesClipped)

    Clip_Wide_NX_Test(nextVertexPtr);

    Clip_Wide_NX_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

//Polygon_Wide_ClipWithPositiveY()

//{

    verticesLeft = numberOfPointsOutputted;

    numberOfPointsOutputted = 0;

    curVertexPtr = VerticesUnClipped;

    outputVerticesPtr = VerticesClipped;

    curVertexInside = Clip_Wide_PY_Test((VerticesUnClipped));

    Clip_LoopStart((VerticesUnClipped))

    Clip_Wide_PY_Test(nextVertexPtr);

    Clip_Wide_PY_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

//Polygon_Wide_ClipWithNegativeY()

//{

    verticesLeft = numberOfPointsOutputted;

    numberOfPointsOutputted = 0;

    curVertexPtr = VerticesClipped;

    outputVerticesPtr = VerticesUnClipped;

    curVertexInside = Clip_Wide_NY_Test(VerticesClipped);

    Clip_LoopStart(VerticesClipped)

    Clip_Wide_NY_Test(nextVertexPtr);

    Clip_Wide_NY_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

//Polygon_Wide_ClipWithPositiveX()

//{

    verticesLeft = numberOfPointsOutputted;

    numberOfPointsOutputted = 0;

    curVertexPtr = VerticesUnClipped;

    outputVerticesPtr = VerticesClipped;

    curVertexInside = Clip_Wide_PX_Test((VerticesUnClipped));

    Clip_LoopStart((VerticesUnClipped))

    Clip_Wide_PX_Test(nextVertexPtr);

    Clip_Wide_PX_OutputXYZ

    Clip_OutputI

//}

    if(numberOfPointsOutputted < 3)

        return 0;

    RenderPolygon.NumberOfVertices = numberOfPointsOutputted;

    draw_vertices = VerticesClipped;

return 1;

}

void SetFrustrumType(enum FrustrumType frustrumType)

{

    if(FRUSTRUM_TYPE_NORMAL == frustrumType)

    {

        ClipPolygon = ClipPolygonNorm;

        TestVerticesWithFrustrum = TestVerticesWith_Norm_Frustrum;

        ObjectWithinFrustrum = ObjectWithin_Norm_Frustrum;

        VertexWithinFrustrum = VertexWithin_Norm_Frustrum;

    }

    else

    {

        ClipPolygon = ClipPolygonWide;

        TestVerticesWithFrustrum = TestVerticesWith_Wide_Frustrum;

        ObjectWithinFrustrum = ObjectWithin_Wide_Frustrum;

        VertexWithinFrustrum = VertexWithin_Wide_Frustrum;

    }

}