cMapPatch.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cMapPatch_H
#define _INC_cMapPatch_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cMapBase.h"
#include "CMapChanSurface.h"
#include "CMapChanHeight.h"
#include "GrayLib/include/XObject/cXObjDef.h"
#include "GrayLib/include/ScriptExec/cScriptSection.h"
#include "GrayCore/include/cNewPtr.h"
 
namespace GrayMapData
{
        class GRAYMAPDATA_LINK cMapPatch
                : public cXObjDef 
        {
                //
                typedef cXObjDef SUPER_t;
        public:
                cMapPatch(UID_t rid, cMapPatch* pParentLOD, MAP_METERI_t x, MAP_METERI_t y, MAP_LOD_TYPE eLod);
                virtual ~cMapPatch(void);
 
                // Must be overloaded at higher level.
                virtual HRESULT s_LoadStaticSection(cScriptSection* pScriptSection = nullptr) = 0; // load object or create default object.
                virtual cMapBase* get_MapBase() const = 0;
 
                STDMETHOD_(XOBJTID_t, get_XObjTypeId)() const
                {
                        // return a FOURCC code identifying the object type. ASSUME registered with cXObjMgr
                        return cFourCC('M', 'p', 'a', 't');             // RESC_Mpatch
                }
 
                bool isChannelLoaded(MAP_CHANNEL_t wChannel) const
                {
                        return((m_ChannelsLoaded & wChannel) ? true : false);
                }
                bool isChannelDirty(MAP_CHANNEL_t wChannel) const
                {
                        return((m_ChannelsDirty & wChannel) ? true : false);
                }
                void addChannelLoaded(MAP_CHANNEL_t wChannel);
                void addChannelDirty(MAP_CHANNEL_t wChannel);
                void clearChannelDirty(MAP_CHANNEL_t wChannel)
                {
                        m_ChannelsDirty &= ~wChannel;
                }
 
                void addChannelDirtyR(MAP_CHANNEL_t wChannel);
 
                bool isSkirtChild() const;
 
                virtual HRESULT DisposeThis();
                STDMETHOD_(cString, get_Name)() const;
                StrLen_t GetNameFormat(char* pszName, bool bDir) const;
                static StrLen_t GRAYCALL GetNameByCoord(char* pszName, MAP_METERI_t iCoordX, MAP_METERI_t iCoordY, MAP_METERI_t iSize, bool bDir);
                cStringF GetFilePath(const FILECHAR_t* pszPostfix) const;
 
                cMapPatchPtr LoadPatchNeighbor(int dnx, int dny, MAP_CHANNEL_t uLoadChannels) const;
 
                // parents and children
                MAP_METERI_t get_ScaleXY() const
                {
                        // The size in meters of each height point. (MAP_PATCH_POINTS)
                        // MAP_SCALE(MAP_LOD_BLOCK)=1, MAP_SCALE(MAP_LOD_SECTOR)=8, MAP_SCALE(MAP_LOD_OCTANT)=64, Zone=
                        return MAP_SCALE(m_eLod);
                }
                MAP_METERI_t get_SizeXY() const
                {
                        return MAP_SIZE(m_eLod);
                }
 
                // allow objects to overlap to next patch this far! else it must get kicked up to parent.
                // PATCH_OVERLAP_MARGIN = 30 in the old code.
#define PATCH_OVERLAP_DIV 4
 
                MAP_METERI_t get_URX() const
                {
                        return m_ptUR.x;
                }
                MAP_METERI_t get_URY() const
                {
                        return m_ptUR.y;
                }
 
                void GetURPoint(cPoint3f& ptw) const
                {
                        // Get upper right point in world meters.
                        ptw.m_x = (D3DVALUE)m_ptUR.x;
                        ptw.m_y = (D3DVALUE)m_ptUR.y;
                        ptw.m_z = 0;
                }
                void GetCenterPoint(cPoint3f& ptw) const
                {
                        MAP_METERI_t iSize2 = get_SizeXY() / 2;
                        ptw.m_x = (D3DVALUE)m_ptUR.x + iSize2;
                        ptw.m_y = (D3DVALUE)m_ptUR.y + iSize2;
                        ptw.m_z = 0;
                }
                void GetURPPoint(cPoint2i& pt) const
                {
                        // Get Upper right X in patch coords.
                        // Get Upper right Y in patch coords.
                        const MAP_METERI_t size = get_SizeXY();
                        pt.x = m_ptUR.x / size;
                        pt.y = m_ptUR.y / size;
                }
                void GetURPoint(cVector3f& vPt) const
                {
                        // Get the upper right point (origin) in D3D space.
                        vPt.x = (float)(m_ptUR.x) - g_Coords.m_d3dOffset.x;
                        vPt.y = 0;      // height is not relevant.
                        vPt.z = (float)(m_ptUR.y) - g_Coords.m_d3dOffset.z;
                }
                void GetCenterPoint(cVector3f& vPt) const
                {
                        // Get world meters.
                        GetURPoint(vPt);
                        MAP_METERI_t iSize2 = get_SizeXY() / 2;
                        vPt.x += iSize2;
                        vPt.z += iSize2;
                }
 
                bool isPointInPatch(MAP_METERI_t x, MAP_METERI_t y) const
                {
                        x -= get_URX();
                        y -= get_URY();
                        const MAP_METERI_t size = get_SizeXY();
                        if (IS_INDEX_BAD(x, size) || IS_INDEX_BAD(y, size))
                                return false;
                        return true;
                }
                bool isPointInPatch(const cVector3f& vPt) const;
 
                void GetPatchRect(cRectI& rect) const
                {
                        // Get rectangle in meters
                        const MAP_METERI_t size = get_SizeXY();
                        rect.SetRectWH(m_ptUR.x, m_ptUR.y, size, size);
                }
                void GetPatchRect(cRectf& rect) const
                {
                        const MAP_METERI_t size = get_SizeXY();
                        rect.SetRectWH((float)m_ptUR.x, (float)m_ptUR.y, (float)size, (float)size);
                }
 
                void CvtPatchToWorld(const cVector3f& vIn, cPoint3f& ptWOut) const;
 
                cMapPatchPtr get_ParentPatch() const
                {
                        return m_pParentPatch;
                }
                cMapPatchPtr GetChildPatch(int rx8, int ry8, MAP_CHANNEL_t uLoadFlags) const;
 
                // Height Map
                MAP_HEIGHT_t* GetHPtr(MAP_PATCH_POINT_t x, MAP_PATCH_POINT_t y)
                {
                        ASSERT(IS_INDEX_GOOD(x, MAP_PATCH_SIZE1));
                        ASSERT(IS_INDEX_GOOD(y, MAP_PATCH_SIZE1));
                        ASSERT(isChannelLoaded(MAP_CHANNEL_Height));
                        //ASSERT(m_Height.m_pImage==nullptr);
                        return &m_Height.m_Grid[(x)+((y)*(MAP_PATCH_SIZE1))];
                }
                MAP_HEIGHT_t GetH(MAP_PATCH_POINT_t x, MAP_PATCH_POINT_t y) const
                {
                        // get raw height at a point.
                        // ARGS: x,y = coords offset in the patch
                        ASSERT(IS_INDEX_GOOD(x, MAP_PATCH_SIZE1));
                        ASSERT(IS_INDEX_GOOD(y, MAP_PATCH_SIZE1));
                        ASSERT(isChannelLoaded(MAP_CHANNEL_Height));
                        //ASSERT(m_Height.m_pImage==nullptr);
                        return m_Height.m_Grid[(x)+((y)*(MAP_PATCH_SIZE1))];
                }
                bool SetH(MAP_PATCH_POINT_t x, MAP_PATCH_POINT_t y, MAP_HEIGHT_t h)
                {
                        ASSERT(isChannelLoaded(MAP_CHANNEL_Height));
                        //ASSERT(m_Height.m_pImage==nullptr);
                        ASSERT(IS_INDEX_GOOD(x, MAP_PATCH_SIZE1));
                        ASSERT(IS_INDEX_GOOD(y, MAP_PATCH_SIZE1));
                        if (m_Height.m_Grid[(x)+((y)*(MAP_PATCH_SIZE1))] == h)
                                return false;
                        m_Height.m_Grid[(x)+((y)*(MAP_PATCH_SIZE1))] = h;
                        return true;
                }
 
                MAP_METERf_t GetHX(float x, float y);
                bool SetHX(float x, float y, MAP_METERf_t fHeight);
                MAP_METERf_t GetHeightX(float x, float y);
                bool SetHeightX(float x, float y, MAP_METERf_t fHeight);
 
                float GetNormalP(float x, float y, cVector3f& vNorm);
 
                GINTERSECT_TYPE GetHeightRayContactSegment(const cPoint3f& ptW1, const cVector3f& vDir, cVector3f& vPos1, cVector3f& vPos2, float fMaxRange);
                bool GetHeightRayContact2(cVector3f& vContact, const cVector3f& vPos1, const cVector3f& vPos2);
 
                MAP_METERf_t get_WaterLevel() const
                {
                        return m_fWaterLevel;
                }
                virtual void put_WaterLevel(MAP_METERf_t fWaterLevel);
                MAP_METERf_t GetWaterLevelX(float x, float y) const;
 
                static MAP_TERRAIN_TYPE GRAYCALL GetTerrainType(MAP_METERf_t z, MAP_METERf_t fGroundLevel, MAP_METERf_t fWaterLevel, MAP_METERf_t fCharHeight);
                MAP_TERRAIN_TYPE GetTerrainType(const cPoint3f& pt, MAP_METERf_t fCharHeight, cVector3f* pvNorm,
                        MAP_METERf_t* pfGroundLevel = nullptr, MAP_METERf_t* pfWaterLevel = nullptr);
 
                // objects in the patch
                HRESULT s_Invoke_Save(const cVariant& vArgs, cVariant& vValRet, cScriptContext* pContext);
                HRESULT s_Invoke_Reload(const cVariant& vArgs, cVariant& vValRet, cScriptContext* pContext);
                HRESULT s_Invoke_HeightUpdateSector(const cVariant& vArgs, cVariant& vValRet, cScriptContext* pContext);
                HRESULT s_Invoke_HeightChange(const cVariant& vArgs, cVariant& vValRet, cScriptContext* pContext);
                HRESULT s_Invoke_HeightUpdateSkirt(const cVariant& vArgs, cVariant& vValRet, cScriptContext* pContext);
 
                // Scripting the patch
                STDMETHOD(s_PropPut)(const cScriptableProp* pProp, const cVariant& vVal);
                STDMETHOD(s_PropGet)(const cScriptableProp* pProp, OUT cVariant& vValRet);
                STDMETHOD(s_Invoke)(const cScriptableMethod* pMethod, const cVariant& vArgs, cVariant& vValRet);
 
                virtual HRESULT LoadXObject();
                virtual void UnloadXObject();
                virtual HRESULT ReloadXObject();
                virtual HRESULT SaveXObject();
 
                // this does the actual loading/saving of the needed channels only
                // only new channels here now, old can be moved here later
                virtual HRESULT LoadChannels(MAP_CHANNEL_t uLoadFlags);
                virtual void UnloadChannels(MAP_CHANNEL_t uLoadFlags);
                virtual HRESULT WriteChannels(MAP_CHANNEL_t uWriteFlags, bool bCheckParent = true);
 
                // Heights in the patch.
                static MAP_METERf_t HeightRandomFunc(const float x, const float y);
 
                HRESULT HeightsImageWrite(bool bCheckParent = true);
                bool    HeightsImageLoad();
                bool    HeightsImageLock(bool bWrite);
                void    HeightsImageUnlock();
 
                void    HeightsAddRandom(float fScaler);
                void    HeightsGenerateRandom();
                bool    HeightsUpdateFromParent(bool bDoSkirt, bool bUpdate);
                bool    HeightsUpdateFromChildren(bool bDoSkirt, bool bUpdate);
                bool    HeightsUpdateChildren(bool bDoSkirt, bool bUpdate);
                bool    HeightsUpdateParent(bool bDoSkirt, bool bUpdate);
 
                bool    HeightsMakeSectorFromBlocks(bool bDoSkirt = true, bool bUpdate = false);
                bool    HeightsMakeBlockFromSector(bool bDoSkirt = true, bool bUpdate = false);
 
                bool    HeightsSkirtUpdate(bool bAllOrNothing, bool bChildren);
                void    HeightsSkirtCheck(bool bChanges);
                void    HeightsOffset(float fOffset, bool bUpdate);
 
                bool NormalMap_Build(D3DCOLOR normalMap[MAP_PATCH_SIZE1][MAP_PATCH_SIZE1]); // builds the normal map
 
                STDMETHOD(s_WriteProps)(IScriptableSetter& reg);
                bool    s_LoadPatch();
 
                virtual HRESULT UpdateChanges()
                {
                        return S_OK;
                }
 
                // Surface Map
 
                HRESULT SurfaceMapLoad();
                HRESULT SurfaceMapWrite();
                size_t SurfaceAllocateMap(bool bInit); // returns linear size
 
                inline MAP_SURFACE_ID_t GetSurfacePtInt(MAP_METERI_t px, MAP_METERI_t py)
                {
                        // get raw surface map id at a point.
                        // ARGS: x,y = coords offset in the patch
                        return m_Surface.GetSurf(px, py);
                }
 
                bool SurfacePtNoUpdate(int px, int py, MAP_SURFACE_ID_t eSurfaceID);
                bool SetSurfacePtInt(int px, int py, MAP_SURFACE_ID_t eSurfaceID);
 
                inline MAP_SURFACE_ID_t GetSurfacePt(MAP_METERI_t x, MAP_METERI_t y)
                {
                        ASSERT(m_eLod == MAP_LOD_SECTOR);
                        x -= m_ptUR.x;
                        y -= m_ptUR.y;
                        x /= MAP_SCALE(MAP_LOD_SECTOR);
                        y /= MAP_SCALE(MAP_LOD_SECTOR);
                        return GetSurfacePtInt(x, y);
                }
 
                inline bool SetSurfacePt(MAP_METERI_t x, MAP_METERI_t y, MAP_SURFACE_ID_t eSurfaceID)
                {
                        ASSERT(m_eLod == MAP_LOD_SECTOR);
                        x -= m_ptUR.x;
                        y -= m_ptUR.y;
                        x /= MAP_SCALE(MAP_LOD_SECTOR);
                        y /= MAP_SCALE(MAP_LOD_SECTOR);
                        return SetSurfacePtInt(x, y, eSurfaceID);
                }
 
                // coords conversion
                template<class _TYPE> inline void WorldToPatch(_TYPE& x, _TYPE& y)
                {
                        x -= m_ptUR.x;
                        y -= m_ptUR.y;
                        MAP_METERI_t iScale = get_ScaleXY();
                        if (iScale > 1)
                        {
                                x /= iScale;
                                y /= iScale;
                        }
                }
 
        private:
                HRESULT HeightsImageLoadJpg();
                HRESULT HeightsImageWriteJpg();
                HRESULT HeightsImageUpdateJpg();
 
        public:
                CHEAPOBJECT_IMPL;
                CSCRIPT_CLASS_DEF1(MapPatch, cXObjDef);
                enum P_TYPE_
                {
#define cMapPatchProp(a,b,c,d,e) P_##a,
#include "cMapPatchProps.tbl"
#undef cMapPatchProp
                        P_QTY,
                };
                static cScriptableProp sm_Props[P_QTY + 1];
                enum M_TYPE_
                {
#define cMapPatchMethod(a,b,c) M_##a,
#include "cMapPatchMethods.tbl"
#undef cMapPatchMethod
                        M_QTY,
                };
                static cScriptableMethod sm_Methods[M_QTY + 1];
 
                int m_iChildPatchesLoaded;                      // how many of my children have been loaded into the cXObjMgr. <= 8x8 = MAP_LOD_RATIO^2
                MAP_CHANNEL_t m_ChannelsToLoad;         // What is requested to be loaded.
                MAP_CHANNEL_t m_ChannelsLoaded;         // What types of data are loaded for the patch now.
                MAP_CHANNEL_t m_ChannelsDirty;          // What types of data need to saved back to disk.
 
                MAP_CHANNEL_t m_ChannelsDerived;        // Channels derived from random data or from parent or child. NOT saved.
 
                CMapChanHeight  m_Height;               
                CMapChanSurface m_Surface;              
 
                MAP_KEY_TYPE m_dwKeyCode;               
 
        protected:
                MAP_METERf_t    m_fWaterLevel;          // Default water level for the whole patch. MAP_HEIGHT_SEA. may also have 3d water objects above this.
 
        private:
                cMapPatchPtr m_pParentPatch;    
                const cPoint2i m_ptUR;                  
                const MAP_LOD_TYPE m_eLod;              
        };
};
 
#endif