---

GXAutoArray.h

Go to the documentation of this file.

#ifndef __RENDER_TEMPLATES_H
#define __RENDER_TEMPLATES_H




#include "GXStandardDefines.h"
#include "fastmath.h"



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

        ~CGXAutoArray()
        {
                Cleanup();
        }


        bool Init(UINT uCount)
        {
                Cleanup();

                if(0==uCount)
                {
                        m_pArray=NULL;
                        return true;
                }


                m_pArray=new type[uCount];
                if(!m_pArray)
                {
                        return false;
                }
                else
                {
                        m_uCount=uCount;
                        return true;
                }
        }

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


        inline UINT GetCount()
        {
                return m_uCount;
        }

        inline type* GetPtr()
        {
                return m_pArray;
        }

        inline bool IsNonNull()
        {
                return (NULL!=m_pArray);
        }

        inline bool CopyIn(type* pSrc,UINT uCount)
        {
                if(uCount>m_uCount)
                {
                        if(!Init(uCount))
                        {
                                return false;
                        }
                }
                
                for(UINT uCtr=0;uCtr<uCount;uCtr++)
                {
                        m_pArray[uCtr]=pSrc[uCtr];
                }

                return true;
                
        }


        bool WriteToStream(IStream* pStream)
        {
                assert(pStream!=NULL);
                

                DWORD dwBytesToBeWritten;
                DWORD dwBytesWritten;

                //write number of things that will follow
                dwBytesToBeWritten=sizeof(DWORD);

                UINT uData=GetCount();

                if(FAILED(pStream->Write(&uData, 
                                                                dwBytesToBeWritten, 
                                                                &dwBytesWritten)))
                {
                        return false;
                }

                if(dwBytesWritten!=dwBytesToBeWritten)
                {
                        return false;
                }


                //WriteData
                dwBytesToBeWritten=sizeof(type)*GetCount();
                

                if(FAILED(pStream->Write(GetPtr(), 
                                                                dwBytesToBeWritten,
                                                                &dwBytesWritten)))
                {
                        return false;
                }

                if(dwBytesWritten!=dwBytesToBeWritten)
                {
                        return false;
                }

                return true;
        }


        bool LoadFromStream(IStream* pStream)
        {
                assert(NULL!=pStream);

                DWORD   dwBytesToRead, dwBytesRead;
                
                
                //read number of elements to follow
                dwBytesToRead=sizeof(DWORD);
                DWORD   dwCount;
                        
                if(FAILED(pStream->Read(&dwCount, dwBytesToRead, &dwBytesRead)))
                {
                        return false;
                }

                if(dwBytesRead!=dwBytesToRead)
                {
                        return false;
                }


                //allocate enough space
                if(!Init(dwCount))
                {
                        return false;
                }

                dwBytesToRead=sizeof(type)*GetCount();

                //Read the actual data
                if(FAILED(pStream->Read(GetPtr(), dwBytesToRead, &dwBytesRead)))
                {
                        return false;
                }

                if(dwBytesRead!=dwBytesToRead)
                {
                        return false;
                }

                return true;
        }


        inline void GetValAt(UINT uIndex, type* pOut)
        {
                assert(NULL!=pOut);
                assert(uIndex<GetCount());

                *pOut=m_pArray[uIndex];
        }


        void GetFilteredVal(float fAmt, type* pOut)
        {
                assert(pOut);
                assert(fAmt<=1.0f);
                assert(fAmt>=0.0f);
                assert(m_uCount>0);

                if(m_uCount==1)
                {
                        *pOut=m_pArray[0];
                        return;
                }

                float fCeil=(float)(ceil(fAmt*m_uCount));
                float fFloor=(float)(floor(fAmt*m_uCount));

                UINT uHighIndex;
                UINT uLowIndex;

                FloatToInt((int*)&uHighIndex, fCeil);
                FloatToInt((int*)&uLowIndex, fFloor);

                //UINT uHighIndex=(UINT) (ceil(fAmt*m_uCount));
                //UINT uLowIndex=(UINT) (floor(fAmt*m_uCount));

                if(uHighIndex=m_uCount)
                {
                        uHighIndex--;
                }


                float fLerpAmt=(m_uCount*fAmt)-(float)uLowIndex;
                
                BlakeUtilLerp(fLerpAmt, &(m_pArray[uLowIndex]), &(m_pArray[uHighIndex]), pOut);
        }

        


        //type casting
        inline operator type*()
        {
                return m_pArray;
        }

                
private:                
        type* m_pArray;
        UINT  m_uCount; 
};



#endif

---