cMapBase.h

Go to the documentation of this file.

//
 
#ifndef _INC_cMapBase_H
#define _INC_cMapBase_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "GrayMapData.h"
#include "CMapKeys.h"
#include "cMapTime.h"
 
#include "Gray3D/include/Map/cMapCommon.h"
#include "GrayLib/include/Math/cValueRange.h"
#include "GrayLib/include/Geometry/cPoint3.h"
#include "GrayLib/include/Geometry/cCoordSpace.h"
#include "GrayLib/include/Geometry/cSphere.h"
#include "GrayLib/include/Scriptable/cScriptableObj.h"
#include "GrayCore/include/cThreadLockRef.h"
 
namespace GrayMapData
{
        enum MAP_LOD_TYPE               // 
        {
                // (Zone (64K), Oct (8192), Sector (1024), Block (128))
 
                MAP_LOD_BLOCK = 0,      // 1 meter per height point. smallest patch unit for map. 128 meters across.
                MAP_LOD_SECTOR,         // 8 meters per height point. 1K
                MAP_LOD_OCTANT,         // 8K
                MAP_LOD_ZONE,           // 64K
                MAP_LOD_WORLD,          // Max size of the world map
        };
 
        const int MAP_LOD_RATIO = 8;                            
 
        typedef int MAP_PATCH_POINT_t;                          
        const MAP_PATCH_POINT_t MAP_PATCH_POINTS = 128;                         
 
#define MAP_SCALE(lod)          (1<<((lod)*3))          
#define MAP_SIZE(lod)           (MAP_SCALE(lod) * MAP_PATCH_POINTS)     
 
        enum MAP_LIMITS_TYPE    // various limits in meters. (MAP_METERI_t)
        {
                MAP_MIN_X = 0,  // meters
                MAP_MAX_X = MAP_SIZE(MAP_LOD_WORLD),    // MAP_METERI_t = arbitrary max size.
 
                MAP_MIN_Y = 0,  // meters
                MAP_MAX_Y = MAP_SIZE(MAP_LOD_WORLD),    // MAP_METERI_t = arbitrary max size. 
 
                MAP_MIN_Z = -1000,              // meters height        // arbitrary for objects (not just height map). MAP_METERf_t
                MAP_MAX_Z = 10000,              // meters height        // arbitrary for objects (not just height map)
                MAP_BAD_Z = -10000,             // a bad height means the patch didn't load! MAP_METERf_t
 
                MAP_HEIGHT_MIN = -100,  // (in meters) this just applies to the height map. MAP_METERf_t
                MAP_HEIGHT_SEA = 0,    // (in meters) for sea level. MAP_METERf_t
                MAP_HEIGHT_MAX = 2521,    // (in meters) = 65536*MAP_HEIGHT_SCALE + MAP_HEIGHT_MIN. This just applies to the height map
 
                MAP_VIEWDIST_TER_MAX = 10000,   // farthest we will see terrain. (MAP_METERI_t)
                MAP_VIEWDIST_OBJ_MAX = 2000,            // farthest distance server will send objects to us. (MAP_METERI_t)
 
                MAP_VIEWDIST_TER_DEF = 1000,            // default FAR default. MAP_METERI_t MAP_VIEWDIST_TER_MAX
                MAP_VIEWDIST_OBJ_DEF = 300,             // default distance server will send objects to us. MAP_METERI_t MAP_VIEWDIST_OBJ_MAX
        };
 
        const D3DVALUE MAP_VIEWDIST_NEAR_DEF = 0.3f;            // near plane.
        const D3DVALUE MAP_VIEWDIST_MIN = 0.1f;                         // Inside viewers head.
 
        enum MAP_CHANNEL_TYPE_  // m_ChannelsLoaded
        {
 
                MAP_CHANNEL_NONE = 0,
 
                // The data channels for a patch.
                MAP_CHANNEL_Height = 0x0001,    
                MAP_CHANNEL_Normal = 0x0002,    
                MAP_CHANNEL_Surface = 0x0004,   
                MAP_CHANNEL_Texture = 0x0008,   
 
                MAP_CHANNEL_Script = 0x0020,    
                MAP_CHANNEL_All = 0x003F,               
 
                // Flags.
                // More specific change info.
                MAP_CHANNEL_Height_LegX = 0x0100,       // this leg/skirt has changed so we need to adjust the skirt of my neighbor. (x=0)
                MAP_CHANNEL_Height_LegY = 0x0200,       // this leg/skirt has changed so we need to adjust the skirt of my neighbor. (y=0)
                MAP_CHANNEL_Surface_LegX = 0x0400,      // this leg/skirt has changed so we need to adjust the skirt of my neighbor.
                MAP_CHANNEL_Surface_LegY = 0x0800,      // this leg/skirt has changed so we need to adjust the skirt of my neighbor.
 
                // special read flags.
                MAP_CHANNEL_NonCrit = 0x1000,   
                MAP_CHANNEL_Placement = 0x2000, 
                MAP_CHANNEL_IgnoreBounds = 0x4000,      
                MAP_CHANNEL_Now = 0x8000,       
        };
        typedef WORD MAP_CHANNEL_t;     // Mask of MAP_CHANNEL_TYPE_.
 
        //**************************************************************
        // MAP_CHANNEL_Height
        // we typically use 16 bit Greyscale height map. MAP_HEIGHT_SEA
        typedef unsigned short MAP_HEIGHT_t;    // Raw 16 bit value from the height map image. use MAP_HEIGHT_SCALE and MAP_HEIGHT_MIN to get meters.
        const MAP_HEIGHT_t MAP_HEIGHT_UNITS = 0xFFFF;           // RAW max for 16 bit units.
        const MAP_METERf_t MAP_HEIGHT_SCALE = 0.04f;            // height map to world meters, 1 height map unit = 4cm
 
        //**************************************************************
 
        typedef BYTE MAP_SURFACE_ID_t;          // high detail texture id in use for this location. from Surfaces.scp
        enum MAP_SURFACE_TYPE
        {
                MAP_SURFACE_Legacy = 0,         // just let the underlying patch MAP_CHANNEL_Texture show thru.
                // Snow, Wood, Ice, Dirt, Grass, Stone, Pavers, etc.
                MAP_SURFACE_Hole = 254, // non blocking hole in the terrain.
                MAP_SURFACE_QTY = 256,
        };
 
        //**************************************************************
 
        enum MAP_TERRAIN_TYPE
        {
                // General class of the terrain at a point. (for physics and footstep noise)
                // Might derive this from MAP_SURFACE_TYPE or MAP_CHANNEL_Texture color at a point ??
                // NOTE: This is NOT how the char is responding to the terrain (flying,swimming,walking,etc)
                MAP_TERRAIN_NONE = 0,   // in the air. (may be flying or falling)
 
                MAP_TERRAIN_STONE,              // faster move ?
                MAP_TERRAIN_WOOD,
                MAP_TERRAIN_DIRT,               // default surface.
                MAP_TERRAIN_GRASS,
                MAP_TERRAIN_MUD,                // swampy
                MAP_TERRAIN_SNOW,
                MAP_TERRAIN_ICE,                // slippery. low traction.
 
                // Not on the terrain anymore.
 
                MAP_TERRAIN_WATER_SHALLOW,              // shallow water. feet splashing.
                MAP_TERRAIN_WATER_SURFACE,              // deep water. but swimming at top
                MAP_TERRAIN_WATER_DEEP,                 // deep water. (may be swimming or dropping)
                MAP_TERRAIN_WATER_BOTTOM,               // deep under water walking on the bottom
 
                MAP_TERRAIN_UnderGround,        // underground in a chamber (object)
                MAP_TERRAIN_BURIED,                     // stuck underground ?
                MAP_TERRAIN_QTY,
 
                MAP_TERRAIN_MASK_ANY = 0x7fffffff,
        };
 
        typedef DWORD MAP_TERRAIN_MASK_t;       // Mask of bits from above. _1BITMASK(MAP_TERRAIN_DIRT)
 
        class cMapPatch;
        typedef cRefPtr<cMapPatch> cMapPatchPtr;
        typedef cThreadLockRef<cMapPatch> cMapPatchPtrX;
        class cMapEntity;
 
        extern GRAYMAPDATA_LINK cCoordSpaceDX g_Coords; // convert DX render to/from map/world coord space.
 
        class GRAYMAPDATA_LINK cMapWaterDef
        {
 
        public:
                float m_FadeBias;                       // shader controls for drawing water.
                float m_FadeExp;
                D3DCOLOR m_ColorDef;            // default color for water. can be overloaded by each water object.
 
                MAP_METERf_t m_SeaLevelDef;     // default sea level water height. for new created water blocks. MAP_HEIGHT_SEA
 
        public:
                cMapWaterDef()
                        : m_FadeBias(0.1f)
                        , m_FadeExp(4.0f)
                        , m_ColorDef(D3DCOLOR_ARGB(0xb2, 0, 0, 0))
                        , m_SeaLevelDef(100) // MAP_HEIGHT_SEA
                {
                }
        };
 
        class GRAYMAPDATA_LINK cMapBase : public cHeapObject, public cScriptableObj, public cMapBase1
        {
        public:
                cMapBase(const char* pszMapName = "Map");
                virtual ~cMapBase();
 
                HRESULT LoadMap(const FILECHAR_t* pszInstallPath, const FILECHAR_t* pszMapName = "Map");
 
                static bool GRAYCALL IsValidPatchSize(MAP_METERI_t iSize);
 
                virtual bool isPatchInBounds(const cMapPatch* pPatch) const;    // in current view bounds?
                virtual cMapPatchPtr LoadPatchXY(MAP_METERI_t x, MAP_METERI_t y, MAP_METERI_t iSize, MAP_CHANNEL_t uLoadFlags = 0);
                cMapPatchPtr LoadPatchBest(MAP_METERI_t x, MAP_METERI_t y, MAP_METERI_t iSize, MAP_CHANNEL_t uLoadFlags = 0);
 
                bool ClampPointDynamic(cPoint3f& ptW) const;
 
                // MAP_CHANNEL_Height
                MAP_METERf_t GetHeightAt(MAP_METER_t x, MAP_METER_t y, MAP_METERI_t iSize, MAP_CHANNEL_t uFlags = MAP_CHANNEL_Height);
                MAP_METERf_t GetHeightAt(const cPoint3f& ptW, MAP_METERI_t iSize, MAP_CHANNEL_t uFlags = MAP_CHANNEL_Height)
                {
                        return GetHeightAt(ptW.m_x, ptW.m_y, iSize, uFlags);
                }
                void GetHeightVert(cVector3f& v, DVALUEDEF_t x, DVALUEDEF_t y)
                {
                        v.x = x;
                        v.z = y;
                        v.y = GetHeightAt(g_Coords.CvtRenderToWorld(v), MAP_SIZE(MAP_LOD_BLOCK));
                }
 
                bool SetHeightAt(MAP_METERI_t x, MAP_METERI_t y, MAP_METERf_t iHeight, MAP_METERI_t iSize);
                bool SetHeightAt(const cPoint3f& ptW, MAP_METERI_t iSize)
                {
                        return SetHeightAt((MAP_METERI_t)ptW.m_x, (MAP_METERI_t)ptW.m_y, ptW.m_z, iSize);
                }
 
                GINTERSECT_TYPE GetHeightRayContactPatch(cPoint3f& ptWContact, const cPoint3f& ptWOrigin, const cVector3f& avDir, cPoint3f& ptWPosNext, float fMaxRange, MAP_METERI_t iSize = MAP_SIZE(MAP_LOD_BLOCK));
                bool GetHeightRayContact(cPoint3f& ptWContact, const cPoint3f& ptWOrigin, const cVector3f& avDir, float fMaxRange = 1000.0f, MAP_METERI_t iSize = MAP_SIZE(MAP_LOD_BLOCK));
 
                // MAP_CHANNEL_Surface
                MAP_SURFACE_ID_t GetSurfacePt(MAP_METERI_t x, MAP_METERI_t y);
                bool SetSurfacePt(MAP_METERI_t x, MAP_METERI_t y, MAP_SURFACE_ID_t eSurfaceID);
 
                // MAP_CHANNEL_Normal
                float GetNormalAt(OUT cVector3f& vNorm, MAP_METER_t x, MAP_METER_t y, MAP_METERI_t iSize);
                float GetNormalAt(OUT cVector3f& vNorm, const cPoint3f& ptW, MAP_METERI_t iSize)
                {
                        return GetNormalAt(vNorm, ptW.m_x, ptW.m_y, iSize);
                }
 
                float GetNormalGradeAt(MAP_METER_t x, MAP_METER_t y, MAP_METERI_t iSize);       // terrain grade at a point. 0 to 1
                float GetNormalGradeAt(const cPoint3f& ptW, MAP_METERI_t iSize) // terrain grade at a point. 0 to 1
                {
                        return GetNormalGradeAt(ptW.m_x, ptW.m_y, iSize);
                }
                void GetNormalBounce(MAP_METER_t x, MAP_METER_t y, const cVector3f& vApproach, cVector3f& vBounce);
 
                // MAP_CHANNEL_Water
                MAP_METER_t GetWaterLevel(MAP_METER_t x, MAP_METER_t y, MAP_METERI_t iSize);
                MAP_METER_t GetWaterLevel(const cPoint3f& ptW, MAP_METERI_t iSize)
                {
                        return GetWaterLevel(ptW.m_x, ptW.m_y, iSize);
                }
 
                // Derived
                MAP_TERRAIN_TYPE GetTerrainType(const cPoint3f& pt, MAP_METERf_t fCharHeight, cVector3f* pvNorm, MAP_METERf_t* pfGroundLevel = nullptr, MAP_METERf_t* pfWaterLevel = nullptr);
 
                STDMETHOD(s_PropPut)(const cScriptableProp* pProp, const cVariant& vVal);
                STDMETHOD(s_PropGet)(const cScriptableProp* pProp, OUT cVariant& vValRet);
                STDMETHOD(SetObjStateLoaded)(); // extra cleanup at the end of the load.
 
                UNITTEST_FRIEND(cMapBase);
 
        public:
                CHEAPOBJECT_IMPL;
                CSCRIPT_CLASS_DEF0(MapBase);
                enum P_TYPE_
                {
#define cMapBaseProp(a,b,c,d,e) P_##a,
#include "cMapBaseProps.tbl"
#undef cMapBaseProp
                        P_QTY,
                };
                static cScriptableProp sm_Props[P_QTY + 1];
 
                cValueRange<MAP_METERI_t> m_SizeHeight; // min/max patch sizes for patches that have height maps. MAP_SIZE(MAP_LOD_SECTOR),MAP_SIZE(MAP_LOD_OCTANT)
 
                // real bounds of the map. (GM's can go outside this?)
                cWinSize m_MapSize;                             // max size of the map in meters. ASSUME % MAP_SIZE(MAP_LOD_SECTOR) = 0
                cRectI m_MapDynamic;            // Restrict the player/dynamic objects to this rect of map.
 
                cMapWaterDef m_WaterDef;        // default params for water to be displayed.
 
                // For map SCP file crypting.
                CMapKeys m_MapKeys;                     // cache the crypt keys for reading parts of this map.
        };
};
#endif