---

GXSquareTemplate.h

Go to the documentation of this file.

#ifndef __SQUARETEMPLATE
#define __SQUARETEMPLATE


#include "GXStandardDefines.h"
#include "GXStreamFunctions.h"

#define LEFT_SIDE 0
#define RIGHT_SIDE 1
#define UP_SIDE 2
#define DOWN_SIDE 3



template<typename type>
class CGXSquare
{
public:
        CGXSquare()
        {
                m_uSideSize=0;
                m_pArray=NULL;
        }


        ~CGXSquare()
        {
                Cleanup();
        }

        bool Fill(type& Val)
        {
                for(UINT x=0;x<m_uSideSize;x++)
                {
                        for(UINT y=0;y<m_uSideSize;y++)
                        {
                                SetVal(Val,x,y);
                        }
                }

                return true;
        }

        //todo , auto array here
        /*bool Clone(CGXSquare<type>** pOut)
        {
                if(!pOut)
                {
                        return false;
                }

                CGXSquare<type>* pNew=new CGXSquare<type>();
                if(!pNew)
                {
                        *pOut=NULL;
                        return false;
                }

                if(!pNew->Init(GetSideSize(), NULL))
                {
                        *pOut=NULL;
                        delete pNew;
                        return false;
                }

                
                memcpy(pNew->GetArrayPointer(),m_pArray,sizeof(type)*m_uSideSize*m_uSideSize);
                *pOut=pNew;
                return true;
        }*/

        void Cleanup()
        {
                SAFE_ARRAY_DELETE(m_pArray);
                m_uSideSize=0;
        }


        bool Init(UINT uSideSize, type* pInitialValue)
        {
                if(0==uSideSize)
                {
                        return false;
                }

                Cleanup();
                
                m_pArray=new type[uSideSize*uSideSize];
                if(!m_pArray)
                {
                        return false;
                }
                m_uSideSize=uSideSize;

                if(pInitialValue)
                {
                        for(UINT xctr=0;xctr<m_uSideSize;xctr++)
                        {
                                for(UINT yctr=0;yctr<m_uSideSize;yctr++)
                                {
                                        m_pArray[GetIndex(xctr,yctr)]=*pInitialValue;
                                }
                        }
                }

                return true;
        }

        bool Smooth(float fAmt, bool bSmoothEdges)
        {
                UINT uArea=m_uSideSize*m_uSideSize;

                CGXAutoArray<type> TempType;
                if(!TempType.Init(uArea))
                {
                        return false;
                }

                //type* pTempType=new type[uArea];



                memcpy(TempType,m_pArray,sizeof(type)*uArea);

                for(UINT xctr=1;xctr<m_uSideSize-1;xctr++)
                {
                        for(UINT yctr=1;yctr<m_uSideSize-1;yctr++)
                        {
                                type Total=TempType[GetIndex(xctr-1,yctr-1)];
                                Total+=TempType[GetIndex(xctr-1,yctr)];
                                Total+=TempType[GetIndex(xctr-1,yctr+1)];

                                Total+=TempType[GetIndex(xctr,yctr-1)];
                                Total+=TempType[GetIndex(xctr,yctr)];
                                Total+=TempType[GetIndex(xctr,yctr+1)];

                                Total+=TempType[GetIndex(xctr+1,yctr-1)];
                                Total+=TempType[GetIndex(xctr+1,yctr)];
                                Total+=TempType[GetIndex(xctr+1,yctr+1)];

                                Total/=9;
                                BlakeUtilLerp(fAmt,&(TempType[GetIndex(xctr,yctr)]),&(Total),&(m_pArray[GetIndex(xctr,yctr)]));

                        }
                }


                if(bSmoothEdges)
                {
                        //all four sides
                        UINT ctr;
                        for(ctr=0;ctr<m_uSideSize;ctr++)
                        {
                                //left
                                m_pArray[GetIndex(0,ctr)]=m_pArray[GetIndex(1,ctr)];
                                
                                //right
                                m_pArray[GetIndex(m_uSideSize-1,ctr)]=m_pArray[GetIndex(m_uSideSize-2,ctr)];
                        
                                //top
                                m_pArray[GetIndex(ctr,0)]=m_pArray[GetIndex(ctr,1)];

                                //bottom
                                m_pArray[GetIndex(ctr,m_uSideSize-1)]=m_pArray[GetIndex(ctr,m_uSideSize-2)];
                                
                        }
                }


                //BLAKE_ARRAY_DELETE(pTempType);
                return true;
        }


        inline void GetVal(type& Out, UINT x, UINT y)
        {
                Out=m_pArray[GetIndex(x,y)];
        }

        inline void SetVal(type& In, UINT x, UINT y)
        {
                m_pArray[GetIndex(x,y)]=In;
        }

        inline void SetVal(type& In, UINT index)
        {
                m_pArray[index]=In;
        }

        void SetBigVal(type& In,UINT x, UINT y, UINT uRadius)
        {
                for(UINT xctr=0;xctr<uRadius;xctr++)
                {
                        for(UINT yctr=0;yctr<uRadius;yctr++)
                        {
                                if(x>=xctr)
                                {
                                        if(y>=yctr)
                                        {
                                                SetVal(In,x-xctr,y-yctr);
                                        }
                                }

                                if(m_uSideSize>(x+xctr))
                                {
                                        if(m_uSideSize>(y+yctr))
                                        {
                                                SetVal(In,x+xctr,y+yctr);
                                        }
                                }
                        }
                }
        }






        inline UINT GetIndex(UINT x, UINT y)
        {
                return ((m_uSideSize*y)+x);
        }

        inline UINT GetSideSize()
        {
                return m_uSideSize;
        }

        inline type* GetArrayPointer()
        {
                return m_pArray;
        }

        inline bool IsNull()
        {
                return (NULL==m_pArray);
        }

        //inline void BlakeUtilLerp(float fWeight, type* Input1, type* Input2, type* pOut)
        void Lerp(float fAmt, CGXSquare<type> One, CGXSquare<type> Two)
        {
                if(One.GetSideSize()!=Two.GetSideSize())
                {
                        return;
                }

                if(One.GetSideSize()!=m_uSideSize)
                {
                        return;
                }

                for(UINT xctr=0;xctr<m_uSideSize;xctr++)
                {
                        for(UINT yctr=0;yctr<m_uSideSize;yctr++)
                        {
                                type ValOne, ValTwo, Result;
                                One.GetVal(ValOne,xctr,yctr);
                                Two.GetVal(ValTwo,xctr,yctr);

                                BlakeUtilLerp(fAmt,&ValOne,&ValTwo,&Result);
                                SetVal(Result,xctr,yctr);
                        }
                }
        }


        //uSide==the side of the target
        void MakeSideSimilarTo(CGXSquare<type>& Target, UINT uSide)
        {
                if(Target.GetSideSize()!=m_uSideSize)
                {
                        return;
                }

                for(UINT ctr=0;ctr<m_uSideSize;ctr++)
                {
                        type TargetVal;
                        switch(uSide)
                        {
                        case LEFT_SIDE:
                                Target.GetVal(TargetVal,0,ctr);
                                m_pArray[GetIndex(m_uSideSize-1,ctr)]=TargetVal;
                                break;
                        
                        case RIGHT_SIDE:
                                Target.GetVal(TargetVal,m_uSideSize-1,ctr);
                                m_pArray[GetIndex(0,ctr)]=TargetVal;
                                break;

                        case UP_SIDE:
                                Target.GetVal(TargetVal,ctr,0);
                                m_pArray[GetIndex(ctr,m_uSideSize-1)]=TargetVal;
                                break;


                        case DOWN_SIDE:
                                Target.GetVal(TargetVal,ctr,m_uSideSize-1);
                                m_pArray[GetIndex(ctr,0)]=TargetVal;
                                break;
                        }
                }

        }






        void operator+=(CGXSquare<type>& Target)
        {
                for(UINT x=0;x<m_uSideSize;x++)
                {
                        for(UINT y=0;y<m_uSideSize;y++)
                        {
                                float fTargetX, fTargetY;

                                fTargetX= x/((float)m_uSideSize);
                                fTargetY= y/((float)m_uSideSize);


                                type Add;
                                Target.GetFilteredVal(Add,fTargetX,fTargetY);
                                m_pArray[GetIndex(x,y)]+=Add;
                        }
                }
        }




        void GetFilteredVal(type& Out, float fX, float fY)
        {

                fX*=m_uSideSize;
                fY*=m_uSideSize;

                type UpperLeft;
                type UpperRight;
                type LowerLeft;
                type LowerRight;

                /*UINT uFloorX=(UINT)floor(fX);
                UINT uCeilX=(UINT)ceil(fX);
                UINT uFloorY=(UINT)floor(fY);
                UINT uCeilY=(UINT)ceil(fY);*/

                UINT uFloorX;
                UINT uCeilX;
                UINT uFloorY;
                UINT uCeilY;

                float fFloorX=(float)floor(fX);
                float fCeilX=(float)ceil(fX);
                float fFloorY=(float)floor(fY);
                float fCeilY=(float)ceil(fY);

                FloatToInt((int*)&uFloorX, fFloorX);
                FloatToInt((int*)&uCeilX, fCeilX);
                FloatToInt((int*)&uFloorY, fFloorY);
                FloatToInt((int*)&uCeilY, fCeilY);


                if(uCeilY>=GetSideSize())
                {
                        if(uFloorY>=GetSideSize())
                        {
                                uFloorY=GetSideSize()-1;
                        }
                        uCeilY=uFloorY;
                }

                
                if(uCeilX>=GetSideSize())
                {
                        if(uFloorX>=GetSideSize())
                        {
                                uFloorX=GetSideSize()-1;
                        }
                        uCeilX=uFloorX;
                }

                GetVal(UpperLeft, uFloorX, uFloorY);
                GetVal(UpperRight, uCeilX, uFloorY);
                GetVal(LowerLeft, uFloorX, uCeilY);
                GetVal(LowerRight, uCeilX, uCeilY);

                
                float fU=(fX-uFloorX);
                float fV=(fY-uFloorY);

                float fOneMinusU=1-fU;
                float fOneMinusV=1-fV;

                UpperLeft*=(fOneMinusU*fOneMinusV);
                UpperRight*=(fU*fOneMinusV);
                LowerLeft*=(fOneMinusU*fV);
                LowerRight*=(fU*fV);


                UpperLeft+=UpperRight;
                UpperLeft+=LowerLeft;
                UpperLeft+=LowerRight;

                Out=UpperLeft;
        }


        void operator+=(float fAmt)
        {
                for(UINT x=0;x<m_uSideSize;x++)
                {
                        for(UINT y=0;y<m_uSideSize;y++)
                        {
                                m_pArray[GetIndex(x,y)]+=fAmt;
                        }
                }
        }


        void operator*=(float fAmt)
        {
                for(UINT x=0;x<m_uSideSize;x++)
                {
                        for(UINT y=0;y<m_uSideSize;y++)
                        {
                                m_pArray[GetIndex(x,y)]*=fAmt;
                        }
                }
        }



        bool WriteToStream(IStream* pStream)
        {
                if(!pStream)
                {
                        return false;
                }


                if(!GXWriteToStream(pStream, &m_uSideSize, sizeof(m_uSideSize)))
                {
                        return false;
                }

                for(UINT xctr=0;xctr<m_uSideSize;xctr++)
                {
                        for(UINT yctr=0;yctr<m_uSideSize;yctr++)
                        {

                                if(!GXWriteToStream(pStream, 
                                                                        &m_pArray[GetIndex(xctr,yctr)], 
                                                                        sizeof(type)))
                                {
                                        return false;
                                }
                        }
                }

                return true;
        }
        



        bool ReadFromStream(IStream* pStream)
        {
                Cleanup();

                if(!GXReadFromStream(pStream, 
                                                        &m_uSideSize, 
                                                        sizeof(m_uSideSize)))
                {
                        return false;
                }

                m_pArray=new type[m_uSideSize*m_uSideSize];

                if(!m_pArray)
                {
                        return false;
                }

                for(UINT xctr=0;xctr<m_uSideSize;xctr++)
                {
                        for(UINT yctr=0;yctr<m_uSideSize;yctr++)
                        {
                                UINT uIndex=GetIndex(xctr,yctr);

                                if(!GXReadFromStream(pStream, 
                                                                        &(m_pArray[uIndex]), 
                                                                        sizeof(type)))
                                {
                                        SAFE_DELETE(m_pArray);
                                        return false;
                                }
                        }
                }

                return true;
        }


                






private:
        UINT m_uSideSize;
        type* m_pArray;
};

#endif

---