---

GXInteroplationTemplates.h

Go to the documentation of this file.

//todo, test these


#ifndef __INTERPTEMPLATES
#define __INTERPTEMPLATES



#include "GXStandardDefines.h"



template<typename type> 
inline void BlakeUtilLerp(float fWeight, 
                                                   const type* pInput1, 
                                                   const type* pInput2, 
                                                   type* pOut)
{
        if(pOut)
        {
                *pOut=(type) (((*pInput1)*(1-fWeight))+(*pInput2)*(fWeight));

        }
}


/*

A    B

C    D
*/
template<typename type> 
inline void BlakeUtil2DLerp(float fWeightX, float fWeightY, type& Input1, type& Input2, type& Input3, type& Input4, type* pOut)
{
        float fOneMinusX=1-fWeightX;
        float fOneMinusY=1-fWeightY;


        if(pOut)
        {
                *pOut=(Input1*(fOneMinusX)*(fOneMinusY))+
                          (Input2*(fWeightX)*(fOneMinusY))+
                          (Input3*(fOneMinusX)*(fWeightY))+
                          (Input4*(fWeightX)*(fWeightY));
        }
}

//todo, either auto array, or better yet, not news
template<typename type>
bool BlakeUtil2DSpline(float fWeightX, float fWeightY, type* pControlPoints, UINT uControlPointCount, type* pOut)
{
        if(4==uControlPointCount)
        {
                BlakeUtil2DLerp(fWeightX, fWeightY,pControlPoints[0],pControlPoints[1],
                                                pControlPoints[2],pControlPoints[3],pOut);
                return (NULL!=pOut);
        }

        if(uControlPointCount<4)
        {
                return false;
        }


        UINT uSideSize=sqrt(uControlPointCount);

        type* pNewControlPoints=new type[(uSideSize-1)*(uSideSize-1)];
        if(!pNewControlPoints)
        {
                return false;
        }

        for(UINT x=0;x<(uSideSize-1);x++)
        {
                for(UINT y=0;y<(uSideSize-1);y++)
                {
                        type Input1, Input2, Input3, Input4;
                        Input1=pControlPoints[x+(y*uSideSize)];
                        Input2=pControlPoints[(x+1)+(y*uSideSize)];
                        Input3=pControlPoints[x+((y+1)*uSideSize)];
                        Input4=pControlPoints[(x+1)+((y+1)*uSideSize)];

                        BlakeUtil2DLerp(fWeightX, fWeightY,Input1,Input2,
                                        Input3,Input4,&(pNewControlPoints[x+((uSideSize-1)*y)]));
                }
        }

        bool bRet=BlakeUtil2DSpline(fWeightX,fWeightY,pNewControlPoints,
                                                                (uSideSize-1)*(uSideSize-1),pOut);

        delete[] pNewControlPoints;
        return bRet;
}



        

//todo, rederive this to make sure it is correct

//quadratic interpolation
//f=Input1*(1-fWeight)^2
//fWeight=0, output=Input1
//fweight=1, output=input2
//fWeight=.5,, MiddleInput
template<typename type>
void BlakeUtilQuaderp(float fWeight, type* Input1, type* Input2, type* MiddleInput, type* pOut)
{
        if(pOut)
        {
                *pOut=((*Input1)*pow((1-fWeight),2.0f))+((*Input2)*(pow(fWeight,2.0f))) + (*MiddleInput)*(2.0f*fWeight*(1-fWeight)); 
        }
}


//todo, redo this without millions of news
//Todo, make this a bool
template<class type> 
void BlakeUtilSpline(float fWeight, type* zControlPoints, DWORD dwControlPointCount, type* pOut)
{
        if(1>=dwControlPointCount)
        {
                *pOut=zControlPoints[0];
                return;
        }

        type *pNewPoints=new type[dwControlPointCount-1];

        if(!pNewPoints)
        {
                return;
        }

        for(UINT ctr=0;ctr<(dwControlPointCount-1);ctr++)
        {
                BlakeUtilLerp(fWeight,&(zControlPoints[ctr]),(&zControlPoints[ctr+1]),&(pNewPoints[ctr]));
        }

        BlakeUtilSpline(fWeight,pNewPoints,dwControlPointCount-1,pOut);

        delete[] pNewPoints;
}



inline float BlakeUtilRandomFloat(float fMin, float fMax)
{
        //generate a random float between [0,1]
        float fRand=(rand()%RAND_MAX)/(float)RAND_MAX;

        return fMin+(fRand*(fMax-fMin));
}



#endif

---