---

GXSquareGenerators.h

Go to the documentation of this file.

#ifndef __SQUAREGEN
#define __SQUAREGEN


#include "GXStandardDefines.h"



#include "GXSquareTemplate.h"
#include "GXInteroplationTemplates.h"




inline void BlakeUtilRandom(D3DXCOLOR& Min, D3DXCOLOR& Max, D3DXCOLOR& Out)
{
        Out.r=BlakeUtilRandomFloat(Min.r, Max.r);
        Out.g=BlakeUtilRandomFloat(Min.g, Max.g);
        Out.b=BlakeUtilRandomFloat(Min.b, Max.b);
        Out.a=BlakeUtilRandomFloat(Min.a, Max.a);
}



inline void BlakeUtilRandom(float& Min, float& Max, float& Out)
{
        Out=BlakeUtilRandomFloat(Min, Max);
}




template<typename type>
void MakeRandom(type& Min, type& Max, 
                                CGXSquare<type>& HeightMap,
                                void (*pCallBack)(type*, const type*, const type*, float, void*, const D3DXVECTOR2*),
                                void* pCallBackInfo)
{

        UINT uSideSize=HeightMap.GetSideSize();
        float fSideSize=(float)uSideSize;

        for(UINT x=0;x<uSideSize;x++)
        {
                for(UINT y=0;y<uSideSize;y++)
                {
                        D3DXVECTOR2 vCoords(x/fSideSize, 
                                                                y/fSideSize);
                        type val;

                        if(pCallBack)
                        {
                                pCallBack(&val, &Min, &Max, BlakeUtilRandomFloat(0.0f, 1.0f), pCallBackInfo, &vCoords);
                        }
                        else
                        {
                                BlakeUtilRandom(Min, Max, val);
                        }

                        HeightMap.SetVal(val, x, y);
                }
        }
}


                

template<typename type>
bool TwoDSpline(CGXSquare<type>& ControlPoints, CGXSquare<type>& Map)
{

        type* pArray=ControlPoints.GetArrayPointer();
        if(NULL==pArray)
        {
                return false;
        }

        for(UINT x=0;x<Map.GetSideSize();x++)
        {
                for(UINT y=0;y<Map.GetSideSize();y++)
                {
                        float fWeightX=x/(float)Map.GetSideSize();
                        float fWeightY=y/(float)Map.GetSideSize();

                        type Val;
                        if(!BlakeUtil2DSpline(fWeightX, fWeightY, pArray,
                                                                         (ControlPoints.GetSideSize()*ControlPoints.GetSideSize()),
                                                                         &Val))
                        {
                                return false;
                        }

                        Map.SetVal(Val,x,y);
                }
        }

        return true;
}



/*template<typename type>
bool MakeNoise(type& ZeroVal, type& Max, float fFalloff, CSquare<type>& Map, float fX, float fY)
{
        UINT uMipCount=(UINT)(log(Map.GetSideSize())/log(2)) + 1;
        if(0==uMipCount)
        {
                return false;
        }

        for(UINT x=0;x<Map.GetSideSize();x++)
        {
                for(UINT y=0;y<Map.GetSideSize();y++)
                {
                        type Val;
                        MakeOneNoiseVal(Val, ZeroVal, Max, fFalloff, x, y, uMipCount);
                        Map.SetVal(Val, x, y);
                }
                        
        }


        return true;
}*/







template<typename type>
bool GXGenerateMipMap(UINT uIndex, CGXSquare<type>& Out,
                                        type& ZeroVal, type& Max, 
                                        float fFalloff, UINT uMipCount,
                                        void (*pCallBack)(type*, const type*, const type*, float, void*, const D3DXVECTOR2*),
                                        void* pCallBackInfo)
{
        if(0==uMipCount)
        {
                return false;
        }

        UINT uCtr;

        float fAdjustmentRatio=0;
        for(uCtr=0;uCtr<uMipCount;uCtr++)
        {
                fAdjustmentRatio+=(float)(pow(fFalloff,uCtr));
        }

        type CurrentMax=Max/fAdjustmentRatio;



        UINT uCurrentSize=(UINT)(pow(2,uIndex));
        

        
        for(UINT uInnerCtr=0;uInnerCtr<uIndex;uInnerCtr++)
        {       
                CurrentMax*=fFalloff;
        }
                

        if(!Out.Init(uCurrentSize, &ZeroVal))
        {
                return false;
        }



        MakeRandom(ZeroVal, CurrentMax, Out, 
                                pCallBack, pCallBackInfo);
        
        

        return true;
}




//void (*pCallBack)(void*, float, void*)
//1st param is the return value
//2nd is min
//3rd is max
//4 is [0,1]
//5 is user defined

template<typename type>
bool GXMakeNoise(type& ZeroVal, type& Max, float fFalloff, 
                                UINT uMipCount,
                           CGXSquare<type>& Map,
                           void (*pCallBack)(type*, const type*, const type*, float, void*, const D3DXVECTOR2*),
                           void* pCallBackInfo)
{
        //Zero out the map
        if(!Map.Init(Map.GetSideSize(), &ZeroVal))
        {
                return false;
        }


        if((uMipCount==0))
        {
                uMipCount=(UINT)(log(Map.GetSideSize())/log(2)) + 1;
        }


        if(0==uMipCount)
        {
                return false;
        }

        //todo, auto array here
        CGXSquare<type>* pMipChain=new CGXSquare<type>[uMipCount];
        if(!pMipChain)
        {
                return false;
        }

        UINT uCtr;


        float fAdjustmentRatio=0;
        for(uCtr=0;uCtr<uMipCount;uCtr++)
        {
                fAdjustmentRatio+=(float)(pow(fFalloff,uCtr));
        }




        


        for(uCtr=0;uCtr<uMipCount;uCtr++)
        {
                if(!GXGenerateMipMap(uCtr, pMipChain[uCtr], ZeroVal, Max, fFalloff,
                                                        uMipCount, pCallBack, pCallBackInfo))
                {
                        SAFE_ARRAY_DELETE(pMipChain);
                        return false;
                }
        }
                /*UINT uCurrentSize=(UINT)(pow(2,uCtr));
                type CurrentMax=Max;

                for(UINT uInnerCtr=0;uInnerCtr<=uCtr;uInnerCtr++)
                {       
                        CurrentMax*=fFalloff;
                }
                        

                if(!pMipChain[uCtr].Init(uCurrentSize, &ZeroVal))
                {
                        BLAKE_ARRAY_DELETE(pMipChain);
                        return false;
                }

                if(uCtr<(UINT)(uMipCount*fCosineFactor))
                {
                        MakeCosine(ZeroVal, CurrentMax, pMipChain[uCtr], fMinX, fMinY, fMaxX, fMaxY, fCosineMultiplier);
                }
                else
                {
                        MakeRandom(ZeroVal, CurrentMax, pMipChain[uCtr], Random);
                }
                //MakeSeededRandom(ZeroVal, CurrentMax, pMipChain[uCtr], 
                                                //fX,fY);//todo, change the seed herer
        }*/

        


        for(uCtr=0;uCtr<uMipCount;uCtr++)
        {
                Map+=pMipChain[uCtr];
        }

        //Map+=pMipChain[8];

        SAFE_ARRAY_DELETE(pMipChain);
        return true;
}



                        

#endif

---