Terrain.h

#pragma once
#include "IAttributeFields.h"
#include "TerrainBuffer.h"
#define INVALID_TEXTURE_ID      (1000000)

namespace ParaTerrain
{
    class ReloadMaskRequest;
    class CRegionLayer;
    class CTerrainRegions;


    enum DIRECTION
    {
        DIR_CENTER = 0,
        DIR_NORTH = 1,
        DIR_NORTHEAST = 2,
        DIR_EAST = 3,
        DIR_SOUTHEAST = 4,
        DIR_SOUTH = 5,
        DIR_SOUTHWEST = 6,
        DIR_WEST = 7,
        DIR_NORTHWEST = 8,
        DIR_INVALID = 9
    };

    enum TERRAIN_MODIFIED_BITS
    {
        MODIFIED_NONE = 0,

        // detailed terrain texture(with mask) has been modified.
        MODIFIED_TEXTURE = 0x1,
        // height map has modified
        MODIFIED_HEIGHTMAP = 0x1<<1,
        // configuration such as base texture, common file, holes, etc has been modified.
        MODIFIED_CONFIGURATION = 0x1<<2,
        // holes have been changed. this should mean the same thing as MODIFIED_CONFIGURATION
        MODIFIED_HOLES = 0x1<<3,
        // if static objects have been modified, so that we will need to update the on load script
        MODIFIED_ON_LOAD_SCRIPT = 0x1<<4,

        MODIFIED_ALL = 0xffff
    };

    class TerrainBlock;
    class Terrain;
    class Texture;
    class TextureFactory;
    class TextureSet;
    class TextureCell;
    class TriangleStrip;
    class TriangleFan;
    class TextureGenerator;
    class DetailTexture;
}

#include "TerrainCommon.h"
#include "TerrainException.h"
#include "Settings.h"
#include "Texture.h"
#include "ShapeAABB.h"
#include "TextureFactory.h"
#include "TextureCell.h"
#include "TextureSet.h"
#include "TextureGenerator.h"
#include "TerrainBlock.h"
#include "TriangleStrip.h"
#include "TriangleFan.h"
#include "TerrainLattice.h"
#include "TerrainVertex.h"
#include "DetailTextureFactory.h"
#include "IAttributeFields.h"
#include <vector>
#include <set>

namespace ParaEngine
{
    struct TextureEntity;
    class CShapeAABB;
    class CShapeFrustum;
    struct AssetFileEntry;
}
namespace ParaTerrain
{
    using namespace ParaEngine;
    class Terrain;
    class CDetailTextureFactory;
    
    class CTerrainMaskFileCallbackData : public boost::signals2::trackable
    {
    public:
        CTerrainMaskFileCallbackData(Terrain *pTerrain) : m_pTerrain(pTerrain){}

        Terrain * m_pTerrain;

        void OnMaskFileDownloaded(int nResult, AssetFileEntry* pAssetFileEntry);
        // void operator()(int nResult, AssetFileEntry* pAssetFileEntry);
    };

    enum TerrainInfoType
    {
        tit_none = 0,
        tit_walkRegion = 1,
        tit_walkWaypoint = 2,
    };


    class Terrain : public IAttributeFields
    {
    public:
        Terrain();

        Terrain(const float *pElevations, int elevWidth, int elevHeight, const uint8 * pTextureImage, int textureWidth, int textureHeight, const uint8 * pDetailTextureImage, int detailWidth, int detailHeight, float vertexSpacing, float elevationScale, int maxNumTriangles, float offsetX = 0.0f, float offsetY = 0.0f);

          Terrain(int widthVertices, int heightVertices, float vertexSpacing, int maxNumTriangles);
          Terrain(int maxNumTriangles, float offsetX, float offsetY);
         ~Terrain();
    public:
         // implementation of IAttributeFields

         virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_CTerrainObject;}
         virtual const char* GetAttributeClassName(){static const char name[] = "CTerrain"; return name;}
         virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
         virtual int InstallFields(CAttributeClass* pClass, bool bOverride);
         virtual bool InvokeEditor(int nFieldID, const string& sParameters);
         
         ATTRIBUTE_METHOD1(Terrain, IsModified_s, bool*)        {*p1 = cls->IsModified(); return S_OK;}
         ATTRIBUTE_METHOD1(Terrain, SetModified_s, bool)        {cls->SetModified(p1); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, IsEmpty_s, bool*)       {*p1 = cls->IsEmpty(); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetSize_s, float*)      {*p1 = cls->GetWidth(); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetOnloadScript_s, const char**)        {*p1 = cls->GetOnloadScript().c_str(); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetTerrainElevFile_s, const char**)     {*p1 = cls->GetTerrainElevFile().c_str(); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetTerrainConfigFile_s, const char**)       {*p1 = cls->GetTerrainConfigFile().c_str(); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetTerrainBaseTextureFile_s, const char**)      {*p1 = cls->GetTerrainBaseTextureFile().c_str(); return S_OK;}
         ATTRIBUTE_METHOD1(Terrain, SetTerrainBaseTextureFile_s, const char*)   {cls->SetTerrainBaseTextureFile(p1); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetTerrainCommonTextureFile_s, const char**)        {*p1 = cls->GetTerrainCommonTextureFile().c_str(); return S_OK;}
         ATTRIBUTE_METHOD1(Terrain, SetTerrainCommonTextureFile_s, const char*) {cls->SetTerrainCommonTextureFile(p1); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetNumOfRegions_s, int*)        {*p1 = cls->GetNumOfRegions(); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetCurrentRegionIndex_s, int*)      {*p1 = cls->GetCurrentRegionIndex(); return S_OK;}
         ATTRIBUTE_METHOD1(Terrain, SetCurrentRegionIndex_s, int)       {cls->SetCurrentRegionIndex(p1); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetCurrentRegionName_s, const char**)       {*p1 = cls->GetCurrentRegionName().c_str(); return S_OK;}
         ATTRIBUTE_METHOD1(Terrain, SetCurrentRegionName_s, const char*)    {cls->SetCurrentRegionName(p1); return S_OK;}

         ATTRIBUTE_METHOD1(Terrain, GetCurrentRegionFilepath_s, const char**)       {*p1 = cls->GetCurrentRegionFilepath().c_str(); return S_OK;}
         ATTRIBUTE_METHOD1(Terrain, SetCurrentRegionFilepath_s, const char*)    {cls->SetCurrentRegionFilepath(p1); return S_OK;}

         void Cleanup();

        bool IsModified();
        bool IsModified(DWORD dwModifiedBits);
        void SetModified(bool bIsModified, DWORD dwModifiedBits);

        bool IsEmpty();

        void SetModified(bool bIsModified);

        void InitDeviceObjects();
        void DeleteDeviceObjects();
        void InvalidateDeviceObjects();

        int Tessellate();
        void RepairCracks();
        void RebuildRenderBuffer();
        void Render();


        string GetRenderReport();


        void SetDetailThreshold(float threshold);
        float GetDetailThreshold() const;

        void SetMaximumVisibleBlockSize(int stride);
        int GetMaximumVisibleBlockSize();
        int GetWidthVertices() const;
        int GetHeightVertices() const;
        float GetWidth() const;
        float GetHeight() const;
        float GetVertexSpacing() const;
        float GetElevation(float x, float y) const;
        float GetElevationW(float x, float y) const;

        DWORD GetRegionValue(const string& sLayerName, float x, float y);

        DWORD GetRegionValueW(const string& sLayerName, float x, float y);


        float GetElevation(int index) const;
        void GetNormal(float x, float y, float &normalX, float &normalY, float &normalZ) const;
        void GetNormalW(float x, float y, float &normalX, float &normalY, float &normalZ) const;
        float GetMaxElevation() const;
        int GetVertex(float x, float y) const;
        int GetVertexW(float x, float y) const;
        float GetVertexElevation(int index) const;
        void SetVertexElevation(int index, float newElevation, bool recalculate_geometry = true);
        void SetVertexElevation(float x, float y, float newElevation);
        
        void SetHole(float x, float y, bool bIsHold);

        void SetHoleLocal(float x, float y, bool bIsHold);

        void UpdateHoles();

        void SetHoleScale(int nHoleScale);

        bool IsHole(float x, float y);
        bool IsHoleW(float x, float y);

        void CreateHoleMap(BYTE* pHoleData=NULL, int nLength = 0);

        void RecalcGeometry(int index1, int index2);
        void RecalcGeometry();
        void RecalcNormal(float x, float y);
        void RecalcNormal(int vertexIndex);
        void SetAllElevations(const float *pElevations, int elevWidth, int elevHeight, float fTerrainSize, float elevationScale = 1.0f);
        int GetNumberOfVertices() const;
        float GetTextureTileWidth() const;
        float GetTextureTileHeight() const;
        int GetNumberOfTextureTilesWidth() const;
        int GetNumberOfTextureTilesHeight() const;

        bool SetTexture(const uint8 * pTextureImage, int width, int height);
        bool SetBaseTexture(const string& filename, int numTextureCellsX=8, int numTextureCellsY=8);

        bool SetCommonTexture(const uint8 * pImage, int width, int height);

        void SetCommonTexture(const char* fileName);

        void SetCommonTexture(Texture * pTexture);
        Texture *GetCommonTexture() const;
        
        int ModelViewMatrixChanged();

        int CuboidInFrustum(const CShapeBox & cuboid) const;
        bool CuboidInFogRadius(const CShapeBox & cuboid) const;

        Plane::Side GetCuboidFogSide(const CShapeBox & cuboid) const;

        void BoxToRenderCoordinate(CShapeBox & cuboid) const;

        float GetBoxToEyeMatrics(const CShapeBox & cuboid) const;

        float IntersectRayW(float startX, float startY, float startZ, float dirX, float dirY, float dirZ, float &intersectX, float &intersectY, float &intersectZ, float fMaxDistance = INFINITY);

        float IntersectRay(float startX, float startY, float startZ, float dirX, float dirY, float dirZ, float &intersectX, float &intersectY, float &intersectZ, float fMaxDistance = INFINITY);
        float IntersectRay(float startX, float startY, float startZ, float dirX, float dirY, float dirZ, float &intersectX, float &intersectY, float &intersectZ, int &textureCellX, int &textureCellY, float &texU, float &texV, float fMaxDistance = INFINITY);

        bool Pick(int screenX, int screenY, float &pickedX, float &pickedY, float &pickedZ) const;

        bool Pick(int screenX, int screenY, float &pickedX, float &pickedY, float &pickedZ, int &textureCellX, int &textureCellY, float &texU, float &texV) const;
        void GetTextureCoordinates(float x, float y, int &textureCellX, int &textureCellY, float &texU, float &texV) const;

        void Paint(ParaEngine::TextureEntity* detailTexture, float brushRadius, float brushIntensity, float maxIntensity, bool erase, float x, float y);
        void Paint(int detailTextureIndex, float brushRadius, float brushIntensity, float maxIntensity, bool erase, float x, float y);
        bool IsMultiTextureSupported() const;
        void SetLatticePosition(int x, int y);
        void GetLatticePosition(int &x, int &y);
        void SetTextureFactory(TextureFactory * pFactory);
        TextureCell * GetTextureCell(int index);
        TextureCell * GetTextureCellW(float x, float y);
        TextureCell * GetTextureCell(int textureCellX, int textureCellY);
        void Write(char *szFilename);
        void Read(char *szFilename);
        TextureSet *GetTextureSet();
        void SetTextureSet(TextureSet * pTextureSet);
        void SetTextureCell(int index, TextureCell * pCell);
        void WriteRawTextures(const char *szTerrainName);
        void WriteRawElevations(const char *szFilename);

        void AllocateTextureCells(int numTextureCellsX, int numTextureCellsY);
        void GenerateTexture(int widthTexels, int heightTexels, const char *szGeneratorName);
        void GenerateTexture(int widthTexels, int heightTexels, TextureGenerator * pGenerator);
        static void RegisterTextureGenerator(std::string name, TextureGenerator * pGenerator);
        static void RegisterDefaultGenerators();
        int GetBaseTextureWidth();
        int GetBaseTextureHeight();
        

        inline void ref() const
        {
            ++m_refCount;
        }

        inline void unref() const
        {
            --m_refCount;
            if (m_refCount <= 0)
                delete this;
        }
        uint8 *GetMaskBits(int textureCellX, int textureCellY, int detailIndex, int &maskWidth, int &maskHeight);
        void ReloadMask(int textureCellX, int textureCellY, int detailIndex);

        void LoadMaskFromDisk(bool bForceReload = false);

        int NormalizeMask(int textureCellX, int textureCellY, int detailIndex, bool bReload=true);

        void SetOffset(float x, float y);

        float GetOffsetX() const;

        float GetOffsetY() const;
        
        void DigCrater(float centerX, float centerY, float radius, int textureId = -1);

        void GetVertices(float centerX, float centerY, float radius, std::vector < TerrainVertex > &vertices);

        const string& GetOnloadScript();
        
        const string& GetTerrainElevFile();
        
        const string& GetTerrainConfigFile() {return m_sConfigFile;};
        
        const string& GetTerrainBaseTextureFile(){return m_sBaseTextureFile; };
        void SetTerrainBaseTextureFile(const string& str);

        const string& GetTerrainCommonTextureFile(){return m_sCommonTextureFile; };
        void SetTerrainCommonTextureFile(const string& str);


        CShapeBox GetBoundingBoxW();

        void GetBoundingBoxes(vector<CShapeAABB>& boxes, const Matrix4* modelView, const CShapeFrustum& frustum, int nMaxBoxesNum=1024, int nSmallestBoxStride=4);

        DetailTexture* GetDefaultBaseLayerMask();

        CTerrainRegions* GetRegions();
        CTerrainRegions* CreateGetRegions();

        int GetNumOfRegions();

        void SetCurrentRegionIndex(int nRegion);
        int GetCurrentRegionIndex();

        void SetCurrentRegionName(const string& name);
        
        const string& GetCurrentRegionName();

        void SetCurrentRegionFilepath(const string& filename);

        const string& GetCurrentRegionFilepath();

    private:
        
        // the terrain configuration file.
        string m_sConfigFile;
        // the base terrain texture file.
        string m_sBaseTextureFile;
        // the common terrain texture file.
        string m_sCommonTextureFile;
        // the on load script file name of this terrain
        string m_sOnLoadScript;
        // elevation file 
        string m_sElevFile;

        DetailTexture* m_pDefaultBaseLayerMask;
        CShapeBox m_BoundingBox;
        //void RenderTextureGroup(int i);
        int m_WidthVertices;
        int m_HeightVertices;
        float m_fHighResTextureRadius;
        float m_DetailThreshold;
        float m_VertexSpacing;
        TerrainBlock *m_pRootBlock;
        byte* m_pVertexStatus;
        CTerrainRegions* m_pRegions;
        int m_nNumOfHoleVertices;
        bool*   m_pHolemap;
        short   m_nHoleScale;
        int m_NumberOfVertices;
        Vector3 *m_pVertices;
        std::vector < TextureCell * >m_TextureCells;
        float m_TextureTileWidth, m_TextureTileHeight;
        uint32 m_NumberOfTextureTilesWidth;
        uint32 m_NumberOfTextureTilesHeight;
        int m_TileSize;
        uint8 **m_pTiles;
        uint32 m_NumberOfTextureTiles;
        Texture *m_pCommonTexture;
        float m_FogColorRed, m_FogColorGreen, m_FogColorBlue, m_FogColorAlpha;
        int m_MaximumVisibleBlockSize;
        vector<TriangleStrip> m_pTriangleStrips;
        vector<TriangleFan> m_pTriangleFans;
        uint32 m_CountStrips, m_CountFans;
        bool m_bMultiTextureSupported;
        uint32 m_MaxNumberOfPrimitives;
        float m_MaxElevation;
        float m_OffsetX, m_OffsetY;
        int m_LatticePositionX, m_LatticePositionY;
        float m_fTerrainSize;
        TextureSet *m_pTextureSet;
        float *m_pTextureMain;
        float *m_pTextureDetail;
        Vector3 *m_pNormals;
        mutable int m_refCount;
        CTerrainMaskFileCallbackData* m_pMaskFileCallbackData;
        
        static std::map < std::string, TextureGenerator * >m_TextureGenerators;
        int m_BaseTextureWidth, m_BaseTextureHeight;
        std::map < std::string, ReloadMaskRequest * >m_ReloadMaskRequests;
        float m_fLowestVisibleHeight;
        DWORD m_dwModified;
        static float m_DetailTextureRepeats;
        // whether to draw terrain in the fog in the distance
        bool m_bFogEnabled;
        bool m_bMaskFileInited;

        
        TerrainBuffer m_TerrainBuffer;
        Vector3 m_vEye;
        Vector3 m_vRenderOffset;
        Vector3 m_vRenderOffset_internal;

        inline void SetRenderOffset(const Vector3& vOffset)
        {
            m_vRenderOffset = vOffset;
            m_vRenderOffset_internal.x = vOffset.x;
            m_vRenderOffset_internal.y = vOffset.z;
            m_vRenderOffset_internal.z = vOffset.y;
        }
        void SetEyePosition(const Vector3& vEye);

        void Init(int maxNumPrims, float offX, float offY);
        void Init(const uint8 * pTextureImage, int textureWidth, int textureHeight, const uint8 * pDetailTextureImage, int detailWidth, int detailHeight, float offsetX = 0.0f, float offsetY = 0.0f);
        void UpdateNeighbor(Terrain * pTerrain, DIRECTION direction);

        inline void SetVertexStatus(int index, byte status){if(m_pVertexStatus != NULL) m_pVertexStatus[index] = status;};
        inline byte GetVertexStatus(int index){return m_pVertexStatus[index];};

        void BuildBlocks();
        void ChopTexture(const uint8 * pImage, int width, int height, int tileSize);
        void PreloadTextures();
        void BuildVertices(int widthVertices, int heightVertices, float vertexSpacing);
        inline void GetRenderVertex(int nIndex, Vector3& v){
            Vector3& vec = m_pVertices[nIndex];
            v.x = vec.x+m_vRenderOffset.x;
            v.y = vec.z+m_vRenderOffset.y;
            v.z = vec.y+m_vRenderOffset.z;
        }
        void GetRenderNorm(int nIndex, Vector3& v)
        {
            Vector3& vec= m_pNormals[nIndex];
            v.x = vec.x;
            v.y = vec.z;
            v.z = vec.y;
        }

        inline TriangleStrip* GetTriStrip(int nIndex){return &(m_pTriangleStrips[nIndex]);}
        inline TriangleStrip* GetSafeTriStrip(int nIndex){
            if(nIndex< (int)m_pTriangleStrips.size())
                return &(m_pTriangleStrips[nIndex]);
            else{
                m_pTriangleStrips.resize(nIndex+100);
                return &(m_pTriangleStrips[nIndex]);
            }
        }
        inline TriangleFan* GetTriFan(int nIndex){return &(m_pTriangleFans[nIndex]);}
        inline TriangleFan* GetSafeTriFan(int nIndex){
            if(nIndex< (int)m_pTriangleFans.size())
                return &(m_pTriangleFans[nIndex]);
            else{
                m_pTriangleFans.resize(nIndex+100);
                return &(m_pTriangleFans[nIndex]);
            }
        }
    public:
        
        int GetTextureIDbyPoint(float x, float y, float& tileX, float& tileY);
        
        //void LoadDetailedTextures(const char * filename);
        inline void GetLowResTexCord(int nIndex, float& u, float& v){
            const Vector2& uv = s_LowResTexCords[nIndex];
            u = uv.x;
            v = uv.y;
        }
        inline void GetHighResTexCord(int nIndex, float& u, float& v){
            const Vector2& uv = s_HighResTexCords[nIndex];
            u = uv.x;
            v = uv.y;
        }
        inline void GetTexCord(int nIndex, float& lowU, float& lowV, float& detailU, float& detailV){
            const Vector2& uv = s_LowResTexCords[nIndex];
            lowU = uv.x;
            lowV = uv.y;
            const Vector2& uv2 = s_HighResTexCords[nIndex];
            detailU = uv2.x;
            detailV = uv2.y;
        }
        
        static Vector2* s_LowResTexCords;
        static Vector2* s_HighResTexCords;

        static void StaticInitUV(int nWidthVertices, int nNumberOfTextureTiles, int nDetailTextureRepeats);

        struct DestroyStaticObject_
        {
            DestroyStaticObject_(){}
            ~DestroyStaticObject_()
            {
                SAFE_DELETE_ARRAY(Terrain::s_LowResTexCords);
                SAFE_DELETE_ARRAY(Terrain::s_HighResTexCords);
            }
        };

        void SetHighResTextureRadius(float radius);
        float GetHighResTextureRadius();
        void SetDetailTextureRepeats(float repeats);
        float GetDetailTextureRepeats();

        void  SetLowestVisibleHeight(float fHeight);
        float GetLowestVisibleHeight();
        void GetMaskFile(string& sMaskFile, const string& sConfigFile);

        bool SaveConfig(const string& filePath);

        bool SaveElevation(const string& filePath);

        bool SaveDetailTexture(const string& filePath);

        bool LoadFromConfigFile(const char* sFileName, float fSize=0, const char* relativePath=NULL);

        void OnLoad();

        bool SaveToFile(const char* filename=NULL);

        bool ReadMaskFile(CParaFile& fileMask);

        void ResizeTextureMaskWidth(int nWidth);

        ParaTerrain::CDetailTextureFactory* m_pDetailedTextureFactory;
    protected:
        bool GenerateTerrainNormal(bool bForceRegenerate=false);

        friend class Triangle;
        friend class TriangleStrip;
        friend class TerrainBlock;
        friend class TriangleFan;
        friend class TerrainLattice;
        friend class TerrainBuffer;
        friend class Loader;
        friend class TextureSet;


        private:
            GeoMipmapIndicesGroup* m_pGeoMipmapIndicesGroup;
            TerrainBlock* m_pBlocks;
        private:
            ParaIndexBuffer m_pIndexBuffer;
            ParaVertexBuffer m_pCollisionBuffer;
            ParaVertexBuffer m_pEditorMeshVB;
        public:
            void SetSharedIB(ParaIndexBuffer ib){ m_pIndexBuffer = ib; }
            void SwitchLodStyle(bool useGeoMipmap, ParaIndexBuffer pSharedIndices, GeoMipmapIndicesGroup* geoMipmapIndicesGroup);
            
        public:
            bool m_useGeoMipmap;
            void SetSharedIndexInfoGroup(GeoMipmapIndicesGroup* geoMipmapIndicesGroup){m_pGeoMipmapIndicesGroup = geoMipmapIndicesGroup;}
            void BuildGeoMipmapBuffer();
            void RenderGeoMipmap();
            void TessellateGeoMipmap();
            void BuildGeoMipmapBlocks();
            void SetBlockLod(int indexX,int indexY,int level,GeoMipmapChunkType chunkType);

            bool IsWalkable(float x,float y) const;
            bool IsWalkableW(float x,float y) const;

        //terrain editor code  --clayman
        private:
            bool m_isEditorMode;
            bool m_enableTerrainCollision;
            bool m_bChopBaseTexture;
            string m_terrInfoFile;

                

            uint32* m_pTerrainInfoData;

            void BuildHelperMeshBuffer();
            void SaveInfoData(const string& filePath);
            void CreateTerrainInfoData();

            int m_visibleEditorMeshFlag;
            uint32 m_visibleDataMask;
            uint8 m_visibleDataBitOffset;

        public:
            void SetTerrainInfoData(const uint32* pInfoData,int width);
            void SetVertexInfo(int idx,uint32 data,uint32 bitMask,uint32 bitOffset);
            uint32 GetVertexInfo(int idx,uint32 bitMask,uint8 bitOffset);
            void RefreshTerrainInfo();
            bool IsWalkable(float x, float y,Vector3& oNormal) const;
            void SetVisibleDataMask(uint32 mask,uint8 bitOffset);
            void SetEditorMode(bool enable);
    };

     
    class ReloadMaskRequest
    {
          public:
        ReloadMaskRequest(int textureCellX, int textureCellY, int detailIndex);
         ~ReloadMaskRequest();
        int m_TextureCellX, m_TextureCellY, m_DetailIndex;
    };
}