Skip to end of metadata
Go to start of metadata
STerrainInfo Structure
C++
struct STerrainInfo {
  int nHeightMapSize_InUnits;
  int nUnitSize_InMeters;
  int nSectorSize_InMeters;
  int nSectorsTableSize_InSectors;
  float fHeightmapZRatio;
  float fOceanWaterLevel;
  struct STerrainChunkHeader {
    int8 nVersion;
    int8 nDummy;
    int8 nFlags;
    int8 nFlags2;
    int32 nChunkSize;
    STerrainInfo TerrainInfo;
    struct SVisAreaManChunkHeader {
      int8 nVersion;
      int8 nDummy;
      int8 nFlags;
      int8 nFlags2;
      int nChunkSize;
      int nVisAreasNum;
      int nPortalsNum;
      int nOcclAreasNum;
      struct SOcTreeNodeChunk {
        int16 nChunkVersion;
        int16 ucChildsMask;
        AABB nodeBox;
        int32 nObjectsBlockSize;
        struct IGetLayerIdAtCallback {
        };
        struct IVoxTerrain {
        };
        struct SHotUpdateInfo {
          uint32 nHeigtmap;
          uint32 nObjTypeMask;
          const uint8* pVisibleLayerMask;
          const uint16* pLayerIdTranslation;
          AABB areaBox;
          struct ITerrain {
            struct SExportInfo {
              bool bHeigtmap;
              bool bObjects;
              AABB areaBox;
            };
          };
          struct ISegmentsManager {
            enum ESegmentLoadFlags {
              slfTerrain = BIT(1),
              slfVisArea = BIT(2),
              slfEntity = BIT(3),
              slfNavigation = BIT(4),
              slfAll = slfTerrain|slfVisArea|slfEntity|slfNavigation
            };
          };
          struct IVisAreaCallback {
          };
          struct IVisAreaManager {
          };
          struct IMergedMeshesManager {
            struct SInstanceSector {
              DynArray<uint8> data;
              string id;
            };
          };
          struct ITimeOfDay {
            enum ETimeOfDayParamID {
              PARAM_HDR_DYNAMIC_POWER_FACTOR,
              PARAM_TERRAIN_OCCL_MULTIPLIER,
              PARAM_GI_MULTIPLIER,
              PARAM_SUN_COLOR,
              PARAM_SUN_COLOR_MULTIPLIER,
              PARAM_SUN_SPECULAR_MULTIPLIER,
              PARAM_FOG_COLOR,
              PARAM_FOG_COLOR_MULTIPLIER,
              PARAM_VOLFOG_HEIGHT,
              PARAM_VOLFOG_DENSITY,
              PARAM_FOG_COLOR2,
              PARAM_FOG_COLOR2_MULTIPLIER,
              PARAM_VOLFOG_HEIGHT2,
              PARAM_VOLFOG_DENSITY2,
              PARAM_VOLFOG_HEIGHT_OFFSET,
              PARAM_FOG_RADIAL_COLOR,
              PARAM_FOG_RADIAL_COLOR_MULTIPLIER,
              PARAM_VOLFOG_RADIAL_SIZE,
              PARAM_VOLFOG_RADIAL_LOBE,
              PARAM_VOLFOG_FINAL_DENSITY_CLAMP,
              PARAM_VOLFOG_GLOBAL_DENSITY,
              PARAM_VOLFOG_RAMP_START,
              PARAM_VOLFOG_RAMP_END,
              PARAM_VOLFOG_RAMP_INFLUENCE,
              PARAM_VOLFOG_SHADOW_DARKENING,
              PARAM_VOLFOG_SHADOW_DARKENING_SUN,
              PARAM_VOLFOG_SHADOW_DARKENING_AMBIENT,
              PARAM_VOLFOG_SHADOW_RANGE,
              PARAM_SKYLIGHT_SUN_INTENSITY,
              PARAM_SKYLIGHT_SUN_INTENSITY_MULTIPLIER,
              PARAM_SKYLIGHT_KM,
              PARAM_SKYLIGHT_KR,
              PARAM_SKYLIGHT_G,
              PARAM_SKYLIGHT_WAVELENGTH_R,
              PARAM_SKYLIGHT_WAVELENGTH_G,
              PARAM_SKYLIGHT_WAVELENGTH_B,
              PARAM_NIGHSKY_HORIZON_COLOR,
              PARAM_NIGHSKY_HORIZON_COLOR_MULTIPLIER,
              PARAM_NIGHSKY_ZENITH_COLOR,
              PARAM_NIGHSKY_ZENITH_COLOR_MULTIPLIER,
              PARAM_NIGHSKY_ZENITH_SHIFT,
              PARAM_NIGHSKY_START_INTENSITY,
              PARAM_NIGHSKY_MOON_COLOR,
              PARAM_NIGHSKY_MOON_COLOR_MULTIPLIER,
              PARAM_NIGHSKY_MOON_INNERCORONA_COLOR,
              PARAM_NIGHSKY_MOON_INNERCORONA_COLOR_MULTIPLIER,
              PARAM_NIGHSKY_MOON_INNERCORONA_SCALE,
              PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR,
              PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR_MULTIPLIER,
              PARAM_NIGHSKY_MOON_OUTERCORONA_SCALE,
              PARAM_CLOUDSHADING_SUNLIGHT_MULTIPLIER,
              PARAM_CLOUDSHADING_SKYLIGHT_MULTIPLIER,
              PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR,
              PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_MULTIPLIER,
              PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_INFLUENCE,
              PARAM_SUN_SHAFTS_VISIBILITY,
              PARAM_SUN_RAYS_VISIBILITY,
              PARAM_SUN_RAYS_ATTENUATION,
              PARAM_SUN_RAYS_SUNCOLORINFLUENCE,
              PARAM_SUN_RAYS_CUSTOMCOLOR,
              PARAM_OCEANFOG_COLOR,
              PARAM_OCEANFOG_COLOR_MULTIPLIER,
              PARAM_OCEANFOG_DENSITY,
              PARAM_SKYBOX_MULTIPLIER,
              PARAM_HDR_FILMCURVE_SHOULDER_SCALE,
              PARAM_HDR_FILMCURVE_LINEAR_SCALE,
              PARAM_HDR_FILMCURVE_TOE_SCALE,
              PARAM_HDR_FILMCURVE_WHITEPOINT,
              PARAM_HDR_COLORGRADING_COLOR_SATURATION,
              PARAM_HDR_COLORGRADING_COLOR_BALANCE,
              PARAM_HDR_EYEADAPTATION_SCENEKEY,
              PARAM_HDR_EYEADAPTATION_MIN_EXPOSURE,
              PARAM_HDR_EYEADAPTATION_MAX_EXPOSURE,
              PARAM_HDR_BLOOM_AMOUNT,
              PARAM_COLORGRADING_FILTERS_GRAIN,
              PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR,
              PARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY,
              PARAM_COLORGRADING_DOF_FOCUSRANGE,
              PARAM_COLORGRADING_DOF_BLURAMOUNT,
              PARAM_SHADOWSC0_BIAS,
              PARAM_SHADOWSC0_SLOPE_BIAS,
              PARAM_SHADOWSC1_BIAS,
              PARAM_SHADOWSC1_SLOPE_BIAS,
              PARAM_SHADOWSC2_BIAS,
              PARAM_SHADOWSC2_SLOPE_BIAS,
              PARAM_SHADOWSC3_BIAS,
              PARAM_SHADOWSC3_SLOPE_BIAS,
              PARAM_SHADOWSC4_BIAS,
              PARAM_SHADOWSC4_SLOPE_BIAS,
              PARAM_SHADOWSC5_BIAS,
              PARAM_SHADOWSC5_SLOPE_BIAS,
              PARAM_SHADOWSC6_BIAS,
              PARAM_SHADOWSC6_SLOPE_BIAS,
              PARAM_SHADOWSC7_BIAS,
              PARAM_SHADOWSC7_SLOPE_BIAS,
              PARAM_SHADOW_JITTERING,
              PARAM_TOTAL
            };
            enum EVariableType {
              TYPE_FLOAT,
              TYPE_COLOR
            };
            struct SVariableInfo {
              const char * name;
              const char * displayName;
              const char * group;
              int nParamId;
              EVariableType type;
              float fValue[3];
              ISplineInterpolator* pInterpolator;
              unsigned int bSelected : 1;
            };
            struct SAdvancedInfo {
              float fStartTime;
              float fEndTime;
              float fAnimSpeed;
            };
            struct SEnvironmentInfo {
              bool bSunLinkedToTOD;
              float sunRotationLatitude;
              float sunRotationLongitude;
            };
            const int NETSER_FORCESET = BIT(0);
            const int NETSER_COMPENSATELAG = BIT(1);
            const int NETSER_STATICPROPS = BIT(2);
          };
          struct ITimeOfDayUpdateCallback {
          };
          struct IFoliage {
            enum EFoliageFlags {
              FLAG_FROZEN = 1
            };
          };
          struct SSkyLightRenderParams {
            const int skyDomeTextureWidth = 64;
            const int skyDomeTextureHeight = 32;
            const int skyDomeTextureSize = 64 * 32;
            const int skyDomeTextureWidthBy8 = 8;
            const int skyDomeTextureWidthBy4Log = 4;
            const int skyDomeTextureHeightBy2Log = 4;
            _smart_ptr<IRenderMesh> m_pSkyDomeMesh;
            uint32 dummy0;
            uint32 dummy1;
            const void* m_pSkyDomeTextureDataMie;
            const void* m_pSkyDomeTextureDataRayleigh;
            size_t m_skyDomeTexturePitch;
            int m_skyDomeTextureTimeStamp;
            int pad;
            Vec4 m_partialMieInScatteringConst;
            Vec4 m_partialRayleighInScatteringConst;
            Vec4 m_sunDirection;
            Vec4 m_phaseFunctionConsts;
            Vec4 m_hazeColor;
            Vec4 m_hazeColorMieNoPremul;
            Vec4 m_hazeColorRayleighNoPremul;
            Vec3 m_skyColorTop;
            Vec3 m_skyColorNorth;
            Vec3 m_skyColorEast;
            Vec3 m_skyColorSouth;
            Vec3 m_skyColorWest;
          };
          struct sRAEColdData {
            Vec4 m_RAEPortalInfos[96];
          };
          struct SVisAreaInfo {
            float fHeight;
            Vec3 vAmbientColor;
            bool bAffectedByOutLights;
            bool bIgnoreSkyColor;
            bool bSkyOnly;
            float fViewDistRatio;
            bool bDoubleSide;
            bool bUseDeepness;
            bool bUseInIndoors;
            bool bOceanIsVisible;
            bool bIgnoreGI;
          };
          struct SDebugFPSInfo {
            float fAverageFPS;
            float fMinFPS;
            float fMaxFPS;
          };
          struct SRainParams {
            Matrix44 matOccTrans;
            Matrix44 matOccTransRender;
            Quat qRainRotation;
            AABB areaAABB;
            Vec3 vWorldPos;
            Vec3 vColor;
            float fAmount;
            float fCurrentAmount;
            float fRadius;
            float fFakeGlossiness;
            float fFakeReflectionAmount;
            float fDiffuseDarkening;
            float fRainDropsAmount;
            float fRainDropsSpeed;
            float fRainDropsLighting;
            float fMistAmount;
            float fMistHeight;
            float fPuddlesAmount;
            float fPuddlesMaskAmount;
            float fPuddlesRippleAmount;
            float fSplashesAmount;
            int nUpdateFrameID;
            bool bApplyOcclusion;
            bool bIgnoreVisareas;
            bool bDisableOcclusion;
          };
          struct SSnowParams {
            Vec3 m_vWorldPos;
            float m_fRadius;
            float m_fSnowAmount;
            float m_fFrostAmount;
            float m_fSurfaceFreezing;
            int m_nSnowFlakeCount;
            float m_fSnowFlakeSize;
            float m_fSnowFallBrightness;
            float m_fSnowFallGravityScale;
            float m_fSnowFallWindScale;
            float m_fSnowFallTurbulence;
            float m_fSnowFallTurbulenceFreq;
          };
          struct IScreenshotCallback {
          };
          class IStreamedObjectListener;
          struct SLightVolume {
            struct SLightData {
              Vec4 vPos;
              Vec4 vColor;
              Vec4 vParams;
            };
          };
          struct I3DEngine : public IProcess {
            struct SObjectsStreamingStatus {
              int nReady;
              int nInProgress;
              int nTotal;
              int nActive;
              int nAllocatedBytes;
              int nMemRequired;
              int nMeshPoolSize;
            };
            struct SStremaingBandwidthData {
              float fBandwidthActual;
              float fBandwidthRequested;
            };
            enum eStreamingSubsystem {
              eStreamingSubsystem_Textures,
              eStreamingSubsystem_Objects,
              eStreamingSubsystem_Audio
            };
            enum EChunkFileFormat {
              eChunkFileFormat_0x745,
              eChunkFileFormat_0x746
            };
          };
          enum EFileTypes {
            eTerrainTextureFile = 100
          };
          struct SCommonFileHeader {
            char signature[4];
            uint8 file_type;
            uint8 flags;
            uint16 version;
            struct STerrainTextureFileHeader_old {
              uint16 nSectorSizeMeters;
              uint16 nLodsNum;
              uint16 nLayerCount;
              uint16 nReserved;
              struct STerrainTextureFileHeader {
                uint16 nLayerCount;
                uint16 dwFlags;
                float fBrMultiplier;
                struct STerrainTextureLayerFileHeader {
                  uint16 nSectorSizePixels;
                  uint16 nReserved;
                  ETEX_Format eTexFormat;
                  uint32 nSectorSizeBytes;
                  struct SRenderingPassInfo {
                    enum EShadowMapType {
                      SHADOW_MAP_NONE = 0,
                      SHADOW_MAP_GSM0,
                      SHADOW_MAP_GSM1,
                      SHADOW_MAP_GSM2,
                      SHADOW_MAP_GSM3,
                      SHADOW_MAP_GSM4,
                      SHADOW_MAP_GSM5,
                      SHADOW_MAP_GSM6,
                      SHADOW_MAP_GSM7,
                      SHADOW_MAP_LOCAL,
                      SHADOW_MAP_REFLECTIVE,
                      SHADOW_MAP_STATIC,
                      SHADOW_MAP_STATIC_MGPU_COPY
                    };
                    enum ESkipRenderingFlags {
                      SHADOWS = BIT(0),
                      BRUSHES = BIT(1),
                      VEGETATION = BIT(2),
                      ENTITIES = BIT(3),
                      TERRAIN = BIT(4),
                      WATEROCEAN = BIT(5),
                      PARTICLES = BIT(6),
                      DECALS = BIT(7),
                      TERRAIN_DETAIL_MATERIALS = BIT(8),
                      FAR_SPRITES = BIT(9),
                      WATER_WAVES = BIT(12),
                      ROADS = BIT(13),
                      WATER_VOLUMES = BIT(14),
                      CLOUDS = BIT(15),
                      CUBEMAP_GEN = BIT(16),
                      GEOM_CACHES = BIT(17),
                      STATIC_OBJECTS = BRUSHES|VEGETATION,
                      DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
                      DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
                    };
                  };
                  struct SRendItemSorter {
                    enum EDeferredPreprocess {
                      eLPVPass = 0,
                      eDeferredShadingPass = BIT(30)
                    };
public:
                    enum {
                    };
public:
                    enum {
                    };
public:
                    enum {
                    };
public:
                    enum {
                    };
public:
                    enum {
                    };
                  };
                };
              };
            };
          };
        };
      };
    };
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader Structure
C++
struct STerrainChunkHeader {
  int8 nVersion;
  int8 nDummy;
  int8 nFlags;
  int8 nFlags2;
  int32 nChunkSize;
  STerrainInfo TerrainInfo;
  struct SVisAreaManChunkHeader {
    int8 nVersion;
    int8 nDummy;
    int8 nFlags;
    int8 nFlags2;
    int nChunkSize;
    int nVisAreasNum;
    int nPortalsNum;
    int nOcclAreasNum;
    struct SOcTreeNodeChunk {
      int16 nChunkVersion;
      int16 ucChildsMask;
      AABB nodeBox;
      int32 nObjectsBlockSize;
      struct IGetLayerIdAtCallback {
      };
      struct IVoxTerrain {
      };
      struct SHotUpdateInfo {
        uint32 nHeigtmap;
        uint32 nObjTypeMask;
        const uint8* pVisibleLayerMask;
        const uint16* pLayerIdTranslation;
        AABB areaBox;
        struct ITerrain {
          struct SExportInfo {
            bool bHeigtmap;
            bool bObjects;
            AABB areaBox;
          };
        };
        struct ISegmentsManager {
          enum ESegmentLoadFlags {
            slfTerrain = BIT(1),
            slfVisArea = BIT(2),
            slfEntity = BIT(3),
            slfNavigation = BIT(4),
            slfAll = slfTerrain|slfVisArea|slfEntity|slfNavigation
          };
        };
        struct IVisAreaCallback {
        };
        struct IVisAreaManager {
        };
        struct IMergedMeshesManager {
          struct SInstanceSector {
            DynArray<uint8> data;
            string id;
          };
        };
        struct ITimeOfDay {
          enum ETimeOfDayParamID {
            PARAM_HDR_DYNAMIC_POWER_FACTOR,
            PARAM_TERRAIN_OCCL_MULTIPLIER,
            PARAM_GI_MULTIPLIER,
            PARAM_SUN_COLOR,
            PARAM_SUN_COLOR_MULTIPLIER,
            PARAM_SUN_SPECULAR_MULTIPLIER,
            PARAM_FOG_COLOR,
            PARAM_FOG_COLOR_MULTIPLIER,
            PARAM_VOLFOG_HEIGHT,
            PARAM_VOLFOG_DENSITY,
            PARAM_FOG_COLOR2,
            PARAM_FOG_COLOR2_MULTIPLIER,
            PARAM_VOLFOG_HEIGHT2,
            PARAM_VOLFOG_DENSITY2,
            PARAM_VOLFOG_HEIGHT_OFFSET,
            PARAM_FOG_RADIAL_COLOR,
            PARAM_FOG_RADIAL_COLOR_MULTIPLIER,
            PARAM_VOLFOG_RADIAL_SIZE,
            PARAM_VOLFOG_RADIAL_LOBE,
            PARAM_VOLFOG_FINAL_DENSITY_CLAMP,
            PARAM_VOLFOG_GLOBAL_DENSITY,
            PARAM_VOLFOG_RAMP_START,
            PARAM_VOLFOG_RAMP_END,
            PARAM_VOLFOG_RAMP_INFLUENCE,
            PARAM_VOLFOG_SHADOW_DARKENING,
            PARAM_VOLFOG_SHADOW_DARKENING_SUN,
            PARAM_VOLFOG_SHADOW_DARKENING_AMBIENT,
            PARAM_VOLFOG_SHADOW_RANGE,
            PARAM_SKYLIGHT_SUN_INTENSITY,
            PARAM_SKYLIGHT_SUN_INTENSITY_MULTIPLIER,
            PARAM_SKYLIGHT_KM,
            PARAM_SKYLIGHT_KR,
            PARAM_SKYLIGHT_G,
            PARAM_SKYLIGHT_WAVELENGTH_R,
            PARAM_SKYLIGHT_WAVELENGTH_G,
            PARAM_SKYLIGHT_WAVELENGTH_B,
            PARAM_NIGHSKY_HORIZON_COLOR,
            PARAM_NIGHSKY_HORIZON_COLOR_MULTIPLIER,
            PARAM_NIGHSKY_ZENITH_COLOR,
            PARAM_NIGHSKY_ZENITH_COLOR_MULTIPLIER,
            PARAM_NIGHSKY_ZENITH_SHIFT,
            PARAM_NIGHSKY_START_INTENSITY,
            PARAM_NIGHSKY_MOON_COLOR,
            PARAM_NIGHSKY_MOON_COLOR_MULTIPLIER,
            PARAM_NIGHSKY_MOON_INNERCORONA_COLOR,
            PARAM_NIGHSKY_MOON_INNERCORONA_COLOR_MULTIPLIER,
            PARAM_NIGHSKY_MOON_INNERCORONA_SCALE,
            PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR,
            PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR_MULTIPLIER,
            PARAM_NIGHSKY_MOON_OUTERCORONA_SCALE,
            PARAM_CLOUDSHADING_SUNLIGHT_MULTIPLIER,
            PARAM_CLOUDSHADING_SKYLIGHT_MULTIPLIER,
            PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR,
            PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_MULTIPLIER,
            PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_INFLUENCE,
            PARAM_SUN_SHAFTS_VISIBILITY,
            PARAM_SUN_RAYS_VISIBILITY,
            PARAM_SUN_RAYS_ATTENUATION,
            PARAM_SUN_RAYS_SUNCOLORINFLUENCE,
            PARAM_SUN_RAYS_CUSTOMCOLOR,
            PARAM_OCEANFOG_COLOR,
            PARAM_OCEANFOG_COLOR_MULTIPLIER,
            PARAM_OCEANFOG_DENSITY,
            PARAM_SKYBOX_MULTIPLIER,
            PARAM_HDR_FILMCURVE_SHOULDER_SCALE,
            PARAM_HDR_FILMCURVE_LINEAR_SCALE,
            PARAM_HDR_FILMCURVE_TOE_SCALE,
            PARAM_HDR_FILMCURVE_WHITEPOINT,
            PARAM_HDR_COLORGRADING_COLOR_SATURATION,
            PARAM_HDR_COLORGRADING_COLOR_BALANCE,
            PARAM_HDR_EYEADAPTATION_SCENEKEY,
            PARAM_HDR_EYEADAPTATION_MIN_EXPOSURE,
            PARAM_HDR_EYEADAPTATION_MAX_EXPOSURE,
            PARAM_HDR_BLOOM_AMOUNT,
            PARAM_COLORGRADING_FILTERS_GRAIN,
            PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR,
            PARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY,
            PARAM_COLORGRADING_DOF_FOCUSRANGE,
            PARAM_COLORGRADING_DOF_BLURAMOUNT,
            PARAM_SHADOWSC0_BIAS,
            PARAM_SHADOWSC0_SLOPE_BIAS,
            PARAM_SHADOWSC1_BIAS,
            PARAM_SHADOWSC1_SLOPE_BIAS,
            PARAM_SHADOWSC2_BIAS,
            PARAM_SHADOWSC2_SLOPE_BIAS,
            PARAM_SHADOWSC3_BIAS,
            PARAM_SHADOWSC3_SLOPE_BIAS,
            PARAM_SHADOWSC4_BIAS,
            PARAM_SHADOWSC4_SLOPE_BIAS,
            PARAM_SHADOWSC5_BIAS,
            PARAM_SHADOWSC5_SLOPE_BIAS,
            PARAM_SHADOWSC6_BIAS,
            PARAM_SHADOWSC6_SLOPE_BIAS,
            PARAM_SHADOWSC7_BIAS,
            PARAM_SHADOWSC7_SLOPE_BIAS,
            PARAM_SHADOW_JITTERING,
            PARAM_TOTAL
          };
          enum EVariableType {
            TYPE_FLOAT,
            TYPE_COLOR
          };
          struct SVariableInfo {
            const char * name;
            const char * displayName;
            const char * group;
            int nParamId;
            EVariableType type;
            float fValue[3];
            ISplineInterpolator* pInterpolator;
            unsigned int bSelected : 1;
          };
          struct SAdvancedInfo {
            float fStartTime;
            float fEndTime;
            float fAnimSpeed;
          };
          struct SEnvironmentInfo {
            bool bSunLinkedToTOD;
            float sunRotationLatitude;
            float sunRotationLongitude;
          };
          const int NETSER_FORCESET = BIT(0);
          const int NETSER_COMPENSATELAG = BIT(1);
          const int NETSER_STATICPROPS = BIT(2);
        };
        struct ITimeOfDayUpdateCallback {
        };
        struct IFoliage {
          enum EFoliageFlags {
            FLAG_FROZEN = 1
          };
        };
        struct SSkyLightRenderParams {
          const int skyDomeTextureWidth = 64;
          const int skyDomeTextureHeight = 32;
          const int skyDomeTextureSize = 64 * 32;
          const int skyDomeTextureWidthBy8 = 8;
          const int skyDomeTextureWidthBy4Log = 4;
          const int skyDomeTextureHeightBy2Log = 4;
          _smart_ptr<IRenderMesh> m_pSkyDomeMesh;
          uint32 dummy0;
          uint32 dummy1;
          const void* m_pSkyDomeTextureDataMie;
          const void* m_pSkyDomeTextureDataRayleigh;
          size_t m_skyDomeTexturePitch;
          int m_skyDomeTextureTimeStamp;
          int pad;
          Vec4 m_partialMieInScatteringConst;
          Vec4 m_partialRayleighInScatteringConst;
          Vec4 m_sunDirection;
          Vec4 m_phaseFunctionConsts;
          Vec4 m_hazeColor;
          Vec4 m_hazeColorMieNoPremul;
          Vec4 m_hazeColorRayleighNoPremul;
          Vec3 m_skyColorTop;
          Vec3 m_skyColorNorth;
          Vec3 m_skyColorEast;
          Vec3 m_skyColorSouth;
          Vec3 m_skyColorWest;
        };
        struct sRAEColdData {
          Vec4 m_RAEPortalInfos[96];
        };
        struct SVisAreaInfo {
          float fHeight;
          Vec3 vAmbientColor;
          bool bAffectedByOutLights;
          bool bIgnoreSkyColor;
          bool bSkyOnly;
          float fViewDistRatio;
          bool bDoubleSide;
          bool bUseDeepness;
          bool bUseInIndoors;
          bool bOceanIsVisible;
          bool bIgnoreGI;
        };
        struct SDebugFPSInfo {
          float fAverageFPS;
          float fMinFPS;
          float fMaxFPS;
        };
        struct SRainParams {
          Matrix44 matOccTrans;
          Matrix44 matOccTransRender;
          Quat qRainRotation;
          AABB areaAABB;
          Vec3 vWorldPos;
          Vec3 vColor;
          float fAmount;
          float fCurrentAmount;
          float fRadius;
          float fFakeGlossiness;
          float fFakeReflectionAmount;
          float fDiffuseDarkening;
          float fRainDropsAmount;
          float fRainDropsSpeed;
          float fRainDropsLighting;
          float fMistAmount;
          float fMistHeight;
          float fPuddlesAmount;
          float fPuddlesMaskAmount;
          float fPuddlesRippleAmount;
          float fSplashesAmount;
          int nUpdateFrameID;
          bool bApplyOcclusion;
          bool bIgnoreVisareas;
          bool bDisableOcclusion;
        };
        struct SSnowParams {
          Vec3 m_vWorldPos;
          float m_fRadius;
          float m_fSnowAmount;
          float m_fFrostAmount;
          float m_fSurfaceFreezing;
          int m_nSnowFlakeCount;
          float m_fSnowFlakeSize;
          float m_fSnowFallBrightness;
          float m_fSnowFallGravityScale;
          float m_fSnowFallWindScale;
          float m_fSnowFallTurbulence;
          float m_fSnowFallTurbulenceFreq;
        };
        struct IScreenshotCallback {
        };
        class IStreamedObjectListener;
        struct SLightVolume {
          struct SLightData {
            Vec4 vPos;
            Vec4 vColor;
            Vec4 vParams;
          };
        };
        struct I3DEngine : public IProcess {
          struct SObjectsStreamingStatus {
            int nReady;
            int nInProgress;
            int nTotal;
            int nActive;
            int nAllocatedBytes;
            int nMemRequired;
            int nMeshPoolSize;
          };
          struct SStremaingBandwidthData {
            float fBandwidthActual;
            float fBandwidthRequested;
          };
          enum eStreamingSubsystem {
            eStreamingSubsystem_Textures,
            eStreamingSubsystem_Objects,
            eStreamingSubsystem_Audio
          };
          enum EChunkFileFormat {
            eChunkFileFormat_0x745,
            eChunkFileFormat_0x746
          };
        };
        enum EFileTypes {
          eTerrainTextureFile = 100
        };
        struct SCommonFileHeader {
          char signature[4];
          uint8 file_type;
          uint8 flags;
          uint16 version;
          struct STerrainTextureFileHeader_old {
            uint16 nSectorSizeMeters;
            uint16 nLodsNum;
            uint16 nLayerCount;
            uint16 nReserved;
            struct STerrainTextureFileHeader {
              uint16 nLayerCount;
              uint16 dwFlags;
              float fBrMultiplier;
              struct STerrainTextureLayerFileHeader {
                uint16 nSectorSizePixels;
                uint16 nReserved;
                ETEX_Format eTexFormat;
                uint32 nSectorSizeBytes;
                struct SRenderingPassInfo {
                  enum EShadowMapType {
                    SHADOW_MAP_NONE = 0,
                    SHADOW_MAP_GSM0,
                    SHADOW_MAP_GSM1,
                    SHADOW_MAP_GSM2,
                    SHADOW_MAP_GSM3,
                    SHADOW_MAP_GSM4,
                    SHADOW_MAP_GSM5,
                    SHADOW_MAP_GSM6,
                    SHADOW_MAP_GSM7,
                    SHADOW_MAP_LOCAL,
                    SHADOW_MAP_REFLECTIVE,
                    SHADOW_MAP_STATIC,
                    SHADOW_MAP_STATIC_MGPU_COPY
                  };
                  enum ESkipRenderingFlags {
                    SHADOWS = BIT(0),
                    BRUSHES = BIT(1),
                    VEGETATION = BIT(2),
                    ENTITIES = BIT(3),
                    TERRAIN = BIT(4),
                    WATEROCEAN = BIT(5),
                    PARTICLES = BIT(6),
                    DECALS = BIT(7),
                    TERRAIN_DETAIL_MATERIALS = BIT(8),
                    FAR_SPRITES = BIT(9),
                    WATER_WAVES = BIT(12),
                    ROADS = BIT(13),
                    WATER_VOLUMES = BIT(14),
                    CLOUDS = BIT(15),
                    CUBEMAP_GEN = BIT(16),
                    GEOM_CACHES = BIT(17),
                    STATIC_OBJECTS = BRUSHES|VEGETATION,
                    DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
                    DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
                  };
                };
                struct SRendItemSorter {
                  enum EDeferredPreprocess {
                    eLPVPass = 0,
                    eDeferredShadingPass = BIT(30)
                  };
public:
                  enum {
                  };
public:
                  enum {
                  };
public:
                  enum {
                  };
public:
                  enum {
                  };
public:
                  enum {
                  };
                };
              };
            };
          };
        };
      };
    };
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader Structure
C++
struct SVisAreaManChunkHeader {
  int8 nVersion;
  int8 nDummy;
  int8 nFlags;
  int8 nFlags2;
  int nChunkSize;
  int nVisAreasNum;
  int nPortalsNum;
  int nOcclAreasNum;
  struct SOcTreeNodeChunk {
    int16 nChunkVersion;
    int16 ucChildsMask;
    AABB nodeBox;
    int32 nObjectsBlockSize;
    struct IGetLayerIdAtCallback {
    };
    struct IVoxTerrain {
    };
    struct SHotUpdateInfo {
      uint32 nHeigtmap;
      uint32 nObjTypeMask;
      const uint8* pVisibleLayerMask;
      const uint16* pLayerIdTranslation;
      AABB areaBox;
      struct ITerrain {
        struct SExportInfo {
          bool bHeigtmap;
          bool bObjects;
          AABB areaBox;
        };
      };
      struct ISegmentsManager {
        enum ESegmentLoadFlags {
          slfTerrain = BIT(1),
          slfVisArea = BIT(2),
          slfEntity = BIT(3),
          slfNavigation = BIT(4),
          slfAll = slfTerrain|slfVisArea|slfEntity|slfNavigation
        };
      };
      struct IVisAreaCallback {
      };
      struct IVisAreaManager {
      };
      struct IMergedMeshesManager {
        struct SInstanceSector {
          DynArray<uint8> data;
          string id;
        };
      };
      struct ITimeOfDay {
        enum ETimeOfDayParamID {
          PARAM_HDR_DYNAMIC_POWER_FACTOR,
          PARAM_TERRAIN_OCCL_MULTIPLIER,
          PARAM_GI_MULTIPLIER,
          PARAM_SUN_COLOR,
          PARAM_SUN_COLOR_MULTIPLIER,
          PARAM_SUN_SPECULAR_MULTIPLIER,
          PARAM_FOG_COLOR,
          PARAM_FOG_COLOR_MULTIPLIER,
          PARAM_VOLFOG_HEIGHT,
          PARAM_VOLFOG_DENSITY,
          PARAM_FOG_COLOR2,
          PARAM_FOG_COLOR2_MULTIPLIER,
          PARAM_VOLFOG_HEIGHT2,
          PARAM_VOLFOG_DENSITY2,
          PARAM_VOLFOG_HEIGHT_OFFSET,
          PARAM_FOG_RADIAL_COLOR,
          PARAM_FOG_RADIAL_COLOR_MULTIPLIER,
          PARAM_VOLFOG_RADIAL_SIZE,
          PARAM_VOLFOG_RADIAL_LOBE,
          PARAM_VOLFOG_FINAL_DENSITY_CLAMP,
          PARAM_VOLFOG_GLOBAL_DENSITY,
          PARAM_VOLFOG_RAMP_START,
          PARAM_VOLFOG_RAMP_END,
          PARAM_VOLFOG_RAMP_INFLUENCE,
          PARAM_VOLFOG_SHADOW_DARKENING,
          PARAM_VOLFOG_SHADOW_DARKENING_SUN,
          PARAM_VOLFOG_SHADOW_DARKENING_AMBIENT,
          PARAM_VOLFOG_SHADOW_RANGE,
          PARAM_SKYLIGHT_SUN_INTENSITY,
          PARAM_SKYLIGHT_SUN_INTENSITY_MULTIPLIER,
          PARAM_SKYLIGHT_KM,
          PARAM_SKYLIGHT_KR,
          PARAM_SKYLIGHT_G,
          PARAM_SKYLIGHT_WAVELENGTH_R,
          PARAM_SKYLIGHT_WAVELENGTH_G,
          PARAM_SKYLIGHT_WAVELENGTH_B,
          PARAM_NIGHSKY_HORIZON_COLOR,
          PARAM_NIGHSKY_HORIZON_COLOR_MULTIPLIER,
          PARAM_NIGHSKY_ZENITH_COLOR,
          PARAM_NIGHSKY_ZENITH_COLOR_MULTIPLIER,
          PARAM_NIGHSKY_ZENITH_SHIFT,
          PARAM_NIGHSKY_START_INTENSITY,
          PARAM_NIGHSKY_MOON_COLOR,
          PARAM_NIGHSKY_MOON_COLOR_MULTIPLIER,
          PARAM_NIGHSKY_MOON_INNERCORONA_COLOR,
          PARAM_NIGHSKY_MOON_INNERCORONA_COLOR_MULTIPLIER,
          PARAM_NIGHSKY_MOON_INNERCORONA_SCALE,
          PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR,
          PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR_MULTIPLIER,
          PARAM_NIGHSKY_MOON_OUTERCORONA_SCALE,
          PARAM_CLOUDSHADING_SUNLIGHT_MULTIPLIER,
          PARAM_CLOUDSHADING_SKYLIGHT_MULTIPLIER,
          PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR,
          PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_MULTIPLIER,
          PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_INFLUENCE,
          PARAM_SUN_SHAFTS_VISIBILITY,
          PARAM_SUN_RAYS_VISIBILITY,
          PARAM_SUN_RAYS_ATTENUATION,
          PARAM_SUN_RAYS_SUNCOLORINFLUENCE,
          PARAM_SUN_RAYS_CUSTOMCOLOR,
          PARAM_OCEANFOG_COLOR,
          PARAM_OCEANFOG_COLOR_MULTIPLIER,
          PARAM_OCEANFOG_DENSITY,
          PARAM_SKYBOX_MULTIPLIER,
          PARAM_HDR_FILMCURVE_SHOULDER_SCALE,
          PARAM_HDR_FILMCURVE_LINEAR_SCALE,
          PARAM_HDR_FILMCURVE_TOE_SCALE,
          PARAM_HDR_FILMCURVE_WHITEPOINT,
          PARAM_HDR_COLORGRADING_COLOR_SATURATION,
          PARAM_HDR_COLORGRADING_COLOR_BALANCE,
          PARAM_HDR_EYEADAPTATION_SCENEKEY,
          PARAM_HDR_EYEADAPTATION_MIN_EXPOSURE,
          PARAM_HDR_EYEADAPTATION_MAX_EXPOSURE,
          PARAM_HDR_BLOOM_AMOUNT,
          PARAM_COLORGRADING_FILTERS_GRAIN,
          PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR,
          PARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY,
          PARAM_COLORGRADING_DOF_FOCUSRANGE,
          PARAM_COLORGRADING_DOF_BLURAMOUNT,
          PARAM_SHADOWSC0_BIAS,
          PARAM_SHADOWSC0_SLOPE_BIAS,
          PARAM_SHADOWSC1_BIAS,
          PARAM_SHADOWSC1_SLOPE_BIAS,
          PARAM_SHADOWSC2_BIAS,
          PARAM_SHADOWSC2_SLOPE_BIAS,
          PARAM_SHADOWSC3_BIAS,
          PARAM_SHADOWSC3_SLOPE_BIAS,
          PARAM_SHADOWSC4_BIAS,
          PARAM_SHADOWSC4_SLOPE_BIAS,
          PARAM_SHADOWSC5_BIAS,
          PARAM_SHADOWSC5_SLOPE_BIAS,
          PARAM_SHADOWSC6_BIAS,
          PARAM_SHADOWSC6_SLOPE_BIAS,
          PARAM_SHADOWSC7_BIAS,
          PARAM_SHADOWSC7_SLOPE_BIAS,
          PARAM_SHADOW_JITTERING,
          PARAM_TOTAL
        };
        enum EVariableType {
          TYPE_FLOAT,
          TYPE_COLOR
        };
        struct SVariableInfo {
          const char * name;
          const char * displayName;
          const char * group;
          int nParamId;
          EVariableType type;
          float fValue[3];
          ISplineInterpolator* pInterpolator;
          unsigned int bSelected : 1;
        };
        struct SAdvancedInfo {
          float fStartTime;
          float fEndTime;
          float fAnimSpeed;
        };
        struct SEnvironmentInfo {
          bool bSunLinkedToTOD;
          float sunRotationLatitude;
          float sunRotationLongitude;
        };
        const int NETSER_FORCESET = BIT(0);
        const int NETSER_COMPENSATELAG = BIT(1);
        const int NETSER_STATICPROPS = BIT(2);
      };
      struct ITimeOfDayUpdateCallback {
      };
      struct IFoliage {
        enum EFoliageFlags {
          FLAG_FROZEN = 1
        };
      };
      struct SSkyLightRenderParams {
        const int skyDomeTextureWidth = 64;
        const int skyDomeTextureHeight = 32;
        const int skyDomeTextureSize = 64 * 32;
        const int skyDomeTextureWidthBy8 = 8;
        const int skyDomeTextureWidthBy4Log = 4;
        const int skyDomeTextureHeightBy2Log = 4;
        _smart_ptr<IRenderMesh> m_pSkyDomeMesh;
        uint32 dummy0;
        uint32 dummy1;
        const void* m_pSkyDomeTextureDataMie;
        const void* m_pSkyDomeTextureDataRayleigh;
        size_t m_skyDomeTexturePitch;
        int m_skyDomeTextureTimeStamp;
        int pad;
        Vec4 m_partialMieInScatteringConst;
        Vec4 m_partialRayleighInScatteringConst;
        Vec4 m_sunDirection;
        Vec4 m_phaseFunctionConsts;
        Vec4 m_hazeColor;
        Vec4 m_hazeColorMieNoPremul;
        Vec4 m_hazeColorRayleighNoPremul;
        Vec3 m_skyColorTop;
        Vec3 m_skyColorNorth;
        Vec3 m_skyColorEast;
        Vec3 m_skyColorSouth;
        Vec3 m_skyColorWest;
      };
      struct sRAEColdData {
        Vec4 m_RAEPortalInfos[96];
      };
      struct SVisAreaInfo {
        float fHeight;
        Vec3 vAmbientColor;
        bool bAffectedByOutLights;
        bool bIgnoreSkyColor;
        bool bSkyOnly;
        float fViewDistRatio;
        bool bDoubleSide;
        bool bUseDeepness;
        bool bUseInIndoors;
        bool bOceanIsVisible;
        bool bIgnoreGI;
      };
      struct SDebugFPSInfo {
        float fAverageFPS;
        float fMinFPS;
        float fMaxFPS;
      };
      struct SRainParams {
        Matrix44 matOccTrans;
        Matrix44 matOccTransRender;
        Quat qRainRotation;
        AABB areaAABB;
        Vec3 vWorldPos;
        Vec3 vColor;
        float fAmount;
        float fCurrentAmount;
        float fRadius;
        float fFakeGlossiness;
        float fFakeReflectionAmount;
        float fDiffuseDarkening;
        float fRainDropsAmount;
        float fRainDropsSpeed;
        float fRainDropsLighting;
        float fMistAmount;
        float fMistHeight;
        float fPuddlesAmount;
        float fPuddlesMaskAmount;
        float fPuddlesRippleAmount;
        float fSplashesAmount;
        int nUpdateFrameID;
        bool bApplyOcclusion;
        bool bIgnoreVisareas;
        bool bDisableOcclusion;
      };
      struct SSnowParams {
        Vec3 m_vWorldPos;
        float m_fRadius;
        float m_fSnowAmount;
        float m_fFrostAmount;
        float m_fSurfaceFreezing;
        int m_nSnowFlakeCount;
        float m_fSnowFlakeSize;
        float m_fSnowFallBrightness;
        float m_fSnowFallGravityScale;
        float m_fSnowFallWindScale;
        float m_fSnowFallTurbulence;
        float m_fSnowFallTurbulenceFreq;
      };
      struct IScreenshotCallback {
      };
      class IStreamedObjectListener;
      struct SLightVolume {
        struct SLightData {
          Vec4 vPos;
          Vec4 vColor;
          Vec4 vParams;
        };
      };
      struct I3DEngine : public IProcess {
        struct SObjectsStreamingStatus {
          int nReady;
          int nInProgress;
          int nTotal;
          int nActive;
          int nAllocatedBytes;
          int nMemRequired;
          int nMeshPoolSize;
        };
        struct SStremaingBandwidthData {
          float fBandwidthActual;
          float fBandwidthRequested;
        };
        enum eStreamingSubsystem {
          eStreamingSubsystem_Textures,
          eStreamingSubsystem_Objects,
          eStreamingSubsystem_Audio
        };
        enum EChunkFileFormat {
          eChunkFileFormat_0x745,
          eChunkFileFormat_0x746
        };
      };
      enum EFileTypes {
        eTerrainTextureFile = 100
      };
      struct SCommonFileHeader {
        char signature[4];
        uint8 file_type;
        uint8 flags;
        uint16 version;
        struct STerrainTextureFileHeader_old {
          uint16 nSectorSizeMeters;
          uint16 nLodsNum;
          uint16 nLayerCount;
          uint16 nReserved;
          struct STerrainTextureFileHeader {
            uint16 nLayerCount;
            uint16 dwFlags;
            float fBrMultiplier;
            struct STerrainTextureLayerFileHeader {
              uint16 nSectorSizePixels;
              uint16 nReserved;
              ETEX_Format eTexFormat;
              uint32 nSectorSizeBytes;
              struct SRenderingPassInfo {
                enum EShadowMapType {
                  SHADOW_MAP_NONE = 0,
                  SHADOW_MAP_GSM0,
                  SHADOW_MAP_GSM1,
                  SHADOW_MAP_GSM2,
                  SHADOW_MAP_GSM3,
                  SHADOW_MAP_GSM4,
                  SHADOW_MAP_GSM5,
                  SHADOW_MAP_GSM6,
                  SHADOW_MAP_GSM7,
                  SHADOW_MAP_LOCAL,
                  SHADOW_MAP_REFLECTIVE,
                  SHADOW_MAP_STATIC,
                  SHADOW_MAP_STATIC_MGPU_COPY
                };
                enum ESkipRenderingFlags {
                  SHADOWS = BIT(0),
                  BRUSHES = BIT(1),
                  VEGETATION = BIT(2),
                  ENTITIES = BIT(3),
                  TERRAIN = BIT(4),
                  WATEROCEAN = BIT(5),
                  PARTICLES = BIT(6),
                  DECALS = BIT(7),
                  TERRAIN_DETAIL_MATERIALS = BIT(8),
                  FAR_SPRITES = BIT(9),
                  WATER_WAVES = BIT(12),
                  ROADS = BIT(13),
                  WATER_VOLUMES = BIT(14),
                  CLOUDS = BIT(15),
                  CUBEMAP_GEN = BIT(16),
                  GEOM_CACHES = BIT(17),
                  STATIC_OBJECTS = BRUSHES|VEGETATION,
                  DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
                  DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
                };
              };
              struct SRendItemSorter {
                enum EDeferredPreprocess {
                  eLPVPass = 0,
                  eDeferredShadingPass = BIT(30)
                };
public:
                enum {
                };
public:
                enum {
                };
public:
                enum {
                };
public:
                enum {
                };
public:
                enum {
                };
              };
            };
          };
        };
      };
    };
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk Structure
C++
struct SOcTreeNodeChunk {
  int16 nChunkVersion;
  int16 ucChildsMask;
  AABB nodeBox;
  int32 nObjectsBlockSize;
  struct IGetLayerIdAtCallback {
  };
  struct IVoxTerrain {
  };
  struct SHotUpdateInfo {
    uint32 nHeigtmap;
    uint32 nObjTypeMask;
    const uint8* pVisibleLayerMask;
    const uint16* pLayerIdTranslation;
    AABB areaBox;
    struct ITerrain {
      struct SExportInfo {
        bool bHeigtmap;
        bool bObjects;
        AABB areaBox;
      };
    };
    struct ISegmentsManager {
      enum ESegmentLoadFlags {
        slfTerrain = BIT(1),
        slfVisArea = BIT(2),
        slfEntity = BIT(3),
        slfNavigation = BIT(4),
        slfAll = slfTerrain|slfVisArea|slfEntity|slfNavigation
      };
    };
    struct IVisAreaCallback {
    };
    struct IVisAreaManager {
    };
    struct IMergedMeshesManager {
      struct SInstanceSector {
        DynArray<uint8> data;
        string id;
      };
    };
    struct ITimeOfDay {
      enum ETimeOfDayParamID {
        PARAM_HDR_DYNAMIC_POWER_FACTOR,
        PARAM_TERRAIN_OCCL_MULTIPLIER,
        PARAM_GI_MULTIPLIER,
        PARAM_SUN_COLOR,
        PARAM_SUN_COLOR_MULTIPLIER,
        PARAM_SUN_SPECULAR_MULTIPLIER,
        PARAM_FOG_COLOR,
        PARAM_FOG_COLOR_MULTIPLIER,
        PARAM_VOLFOG_HEIGHT,
        PARAM_VOLFOG_DENSITY,
        PARAM_FOG_COLOR2,
        PARAM_FOG_COLOR2_MULTIPLIER,
        PARAM_VOLFOG_HEIGHT2,
        PARAM_VOLFOG_DENSITY2,
        PARAM_VOLFOG_HEIGHT_OFFSET,
        PARAM_FOG_RADIAL_COLOR,
        PARAM_FOG_RADIAL_COLOR_MULTIPLIER,
        PARAM_VOLFOG_RADIAL_SIZE,
        PARAM_VOLFOG_RADIAL_LOBE,
        PARAM_VOLFOG_FINAL_DENSITY_CLAMP,
        PARAM_VOLFOG_GLOBAL_DENSITY,
        PARAM_VOLFOG_RAMP_START,
        PARAM_VOLFOG_RAMP_END,
        PARAM_VOLFOG_RAMP_INFLUENCE,
        PARAM_VOLFOG_SHADOW_DARKENING,
        PARAM_VOLFOG_SHADOW_DARKENING_SUN,
        PARAM_VOLFOG_SHADOW_DARKENING_AMBIENT,
        PARAM_VOLFOG_SHADOW_RANGE,
        PARAM_SKYLIGHT_SUN_INTENSITY,
        PARAM_SKYLIGHT_SUN_INTENSITY_MULTIPLIER,
        PARAM_SKYLIGHT_KM,
        PARAM_SKYLIGHT_KR,
        PARAM_SKYLIGHT_G,
        PARAM_SKYLIGHT_WAVELENGTH_R,
        PARAM_SKYLIGHT_WAVELENGTH_G,
        PARAM_SKYLIGHT_WAVELENGTH_B,
        PARAM_NIGHSKY_HORIZON_COLOR,
        PARAM_NIGHSKY_HORIZON_COLOR_MULTIPLIER,
        PARAM_NIGHSKY_ZENITH_COLOR,
        PARAM_NIGHSKY_ZENITH_COLOR_MULTIPLIER,
        PARAM_NIGHSKY_ZENITH_SHIFT,
        PARAM_NIGHSKY_START_INTENSITY,
        PARAM_NIGHSKY_MOON_COLOR,
        PARAM_NIGHSKY_MOON_COLOR_MULTIPLIER,
        PARAM_NIGHSKY_MOON_INNERCORONA_COLOR,
        PARAM_NIGHSKY_MOON_INNERCORONA_COLOR_MULTIPLIER,
        PARAM_NIGHSKY_MOON_INNERCORONA_SCALE,
        PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR,
        PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR_MULTIPLIER,
        PARAM_NIGHSKY_MOON_OUTERCORONA_SCALE,
        PARAM_CLOUDSHADING_SUNLIGHT_MULTIPLIER,
        PARAM_CLOUDSHADING_SKYLIGHT_MULTIPLIER,
        PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR,
        PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_MULTIPLIER,
        PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_INFLUENCE,
        PARAM_SUN_SHAFTS_VISIBILITY,
        PARAM_SUN_RAYS_VISIBILITY,
        PARAM_SUN_RAYS_ATTENUATION,
        PARAM_SUN_RAYS_SUNCOLORINFLUENCE,
        PARAM_SUN_RAYS_CUSTOMCOLOR,
        PARAM_OCEANFOG_COLOR,
        PARAM_OCEANFOG_COLOR_MULTIPLIER,
        PARAM_OCEANFOG_DENSITY,
        PARAM_SKYBOX_MULTIPLIER,
        PARAM_HDR_FILMCURVE_SHOULDER_SCALE,
        PARAM_HDR_FILMCURVE_LINEAR_SCALE,
        PARAM_HDR_FILMCURVE_TOE_SCALE,
        PARAM_HDR_FILMCURVE_WHITEPOINT,
        PARAM_HDR_COLORGRADING_COLOR_SATURATION,
        PARAM_HDR_COLORGRADING_COLOR_BALANCE,
        PARAM_HDR_EYEADAPTATION_SCENEKEY,
        PARAM_HDR_EYEADAPTATION_MIN_EXPOSURE,
        PARAM_HDR_EYEADAPTATION_MAX_EXPOSURE,
        PARAM_HDR_BLOOM_AMOUNT,
        PARAM_COLORGRADING_FILTERS_GRAIN,
        PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR,
        PARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY,
        PARAM_COLORGRADING_DOF_FOCUSRANGE,
        PARAM_COLORGRADING_DOF_BLURAMOUNT,
        PARAM_SHADOWSC0_BIAS,
        PARAM_SHADOWSC0_SLOPE_BIAS,
        PARAM_SHADOWSC1_BIAS,
        PARAM_SHADOWSC1_SLOPE_BIAS,
        PARAM_SHADOWSC2_BIAS,
        PARAM_SHADOWSC2_SLOPE_BIAS,
        PARAM_SHADOWSC3_BIAS,
        PARAM_SHADOWSC3_SLOPE_BIAS,
        PARAM_SHADOWSC4_BIAS,
        PARAM_SHADOWSC4_SLOPE_BIAS,
        PARAM_SHADOWSC5_BIAS,
        PARAM_SHADOWSC5_SLOPE_BIAS,
        PARAM_SHADOWSC6_BIAS,
        PARAM_SHADOWSC6_SLOPE_BIAS,
        PARAM_SHADOWSC7_BIAS,
        PARAM_SHADOWSC7_SLOPE_BIAS,
        PARAM_SHADOW_JITTERING,
        PARAM_TOTAL
      };
      enum EVariableType {
        TYPE_FLOAT,
        TYPE_COLOR
      };
      struct SVariableInfo {
        const char * name;
        const char * displayName;
        const char * group;
        int nParamId;
        EVariableType type;
        float fValue[3];
        ISplineInterpolator* pInterpolator;
        unsigned int bSelected : 1;
      };
      struct SAdvancedInfo {
        float fStartTime;
        float fEndTime;
        float fAnimSpeed;
      };
      struct SEnvironmentInfo {
        bool bSunLinkedToTOD;
        float sunRotationLatitude;
        float sunRotationLongitude;
      };
      const int NETSER_FORCESET = BIT(0);
      const int NETSER_COMPENSATELAG = BIT(1);
      const int NETSER_STATICPROPS = BIT(2);
    };
    struct ITimeOfDayUpdateCallback {
    };
    struct IFoliage {
      enum EFoliageFlags {
        FLAG_FROZEN = 1
      };
    };
    struct SSkyLightRenderParams {
      const int skyDomeTextureWidth = 64;
      const int skyDomeTextureHeight = 32;
      const int skyDomeTextureSize = 64 * 32;
      const int skyDomeTextureWidthBy8 = 8;
      const int skyDomeTextureWidthBy4Log = 4;
      const int skyDomeTextureHeightBy2Log = 4;
      _smart_ptr<IRenderMesh> m_pSkyDomeMesh;
      uint32 dummy0;
      uint32 dummy1;
      const void* m_pSkyDomeTextureDataMie;
      const void* m_pSkyDomeTextureDataRayleigh;
      size_t m_skyDomeTexturePitch;
      int m_skyDomeTextureTimeStamp;
      int pad;
      Vec4 m_partialMieInScatteringConst;
      Vec4 m_partialRayleighInScatteringConst;
      Vec4 m_sunDirection;
      Vec4 m_phaseFunctionConsts;
      Vec4 m_hazeColor;
      Vec4 m_hazeColorMieNoPremul;
      Vec4 m_hazeColorRayleighNoPremul;
      Vec3 m_skyColorTop;
      Vec3 m_skyColorNorth;
      Vec3 m_skyColorEast;
      Vec3 m_skyColorSouth;
      Vec3 m_skyColorWest;
    };
    struct sRAEColdData {
      Vec4 m_RAEPortalInfos[96];
    };
    struct SVisAreaInfo {
      float fHeight;
      Vec3 vAmbientColor;
      bool bAffectedByOutLights;
      bool bIgnoreSkyColor;
      bool bSkyOnly;
      float fViewDistRatio;
      bool bDoubleSide;
      bool bUseDeepness;
      bool bUseInIndoors;
      bool bOceanIsVisible;
      bool bIgnoreGI;
    };
    struct SDebugFPSInfo {
      float fAverageFPS;
      float fMinFPS;
      float fMaxFPS;
    };
    struct SRainParams {
      Matrix44 matOccTrans;
      Matrix44 matOccTransRender;
      Quat qRainRotation;
      AABB areaAABB;
      Vec3 vWorldPos;
      Vec3 vColor;
      float fAmount;
      float fCurrentAmount;
      float fRadius;
      float fFakeGlossiness;
      float fFakeReflectionAmount;
      float fDiffuseDarkening;
      float fRainDropsAmount;
      float fRainDropsSpeed;
      float fRainDropsLighting;
      float fMistAmount;
      float fMistHeight;
      float fPuddlesAmount;
      float fPuddlesMaskAmount;
      float fPuddlesRippleAmount;
      float fSplashesAmount;
      int nUpdateFrameID;
      bool bApplyOcclusion;
      bool bIgnoreVisareas;
      bool bDisableOcclusion;
    };
    struct SSnowParams {
      Vec3 m_vWorldPos;
      float m_fRadius;
      float m_fSnowAmount;
      float m_fFrostAmount;
      float m_fSurfaceFreezing;
      int m_nSnowFlakeCount;
      float m_fSnowFlakeSize;
      float m_fSnowFallBrightness;
      float m_fSnowFallGravityScale;
      float m_fSnowFallWindScale;
      float m_fSnowFallTurbulence;
      float m_fSnowFallTurbulenceFreq;
    };
    struct IScreenshotCallback {
    };
    class IStreamedObjectListener;
    struct SLightVolume {
      struct SLightData {
        Vec4 vPos;
        Vec4 vColor;
        Vec4 vParams;
      };
    };
    struct I3DEngine : public IProcess {
      struct SObjectsStreamingStatus {
        int nReady;
        int nInProgress;
        int nTotal;
        int nActive;
        int nAllocatedBytes;
        int nMemRequired;
        int nMeshPoolSize;
      };
      struct SStremaingBandwidthData {
        float fBandwidthActual;
        float fBandwidthRequested;
      };
      enum eStreamingSubsystem {
        eStreamingSubsystem_Textures,
        eStreamingSubsystem_Objects,
        eStreamingSubsystem_Audio
      };
      enum EChunkFileFormat {
        eChunkFileFormat_0x745,
        eChunkFileFormat_0x746
      };
    };
    enum EFileTypes {
      eTerrainTextureFile = 100
    };
    struct SCommonFileHeader {
      char signature[4];
      uint8 file_type;
      uint8 flags;
      uint16 version;
      struct STerrainTextureFileHeader_old {
        uint16 nSectorSizeMeters;
        uint16 nLodsNum;
        uint16 nLayerCount;
        uint16 nReserved;
        struct STerrainTextureFileHeader {
          uint16 nLayerCount;
          uint16 dwFlags;
          float fBrMultiplier;
          struct STerrainTextureLayerFileHeader {
            uint16 nSectorSizePixels;
            uint16 nReserved;
            ETEX_Format eTexFormat;
            uint32 nSectorSizeBytes;
            struct SRenderingPassInfo {
              enum EShadowMapType {
                SHADOW_MAP_NONE = 0,
                SHADOW_MAP_GSM0,
                SHADOW_MAP_GSM1,
                SHADOW_MAP_GSM2,
                SHADOW_MAP_GSM3,
                SHADOW_MAP_GSM4,
                SHADOW_MAP_GSM5,
                SHADOW_MAP_GSM6,
                SHADOW_MAP_GSM7,
                SHADOW_MAP_LOCAL,
                SHADOW_MAP_REFLECTIVE,
                SHADOW_MAP_STATIC,
                SHADOW_MAP_STATIC_MGPU_COPY
              };
              enum ESkipRenderingFlags {
                SHADOWS = BIT(0),
                BRUSHES = BIT(1),
                VEGETATION = BIT(2),
                ENTITIES = BIT(3),
                TERRAIN = BIT(4),
                WATEROCEAN = BIT(5),
                PARTICLES = BIT(6),
                DECALS = BIT(7),
                TERRAIN_DETAIL_MATERIALS = BIT(8),
                FAR_SPRITES = BIT(9),
                WATER_WAVES = BIT(12),
                ROADS = BIT(13),
                WATER_VOLUMES = BIT(14),
                CLOUDS = BIT(15),
                CUBEMAP_GEN = BIT(16),
                GEOM_CACHES = BIT(17),
                STATIC_OBJECTS = BRUSHES|VEGETATION,
                DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
                DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
              };
            };
            struct SRendItemSorter {
              enum EDeferredPreprocess {
                eLPVPass = 0,
                eDeferredShadingPass = BIT(30)
              };
public:
              enum {
              };
public:
              enum {
              };
public:
              enum {
              };
public:
              enum {
              };
public:
              enum {
              };
            };
          };
        };
      };
    };
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IGetLayerIdAtCallback Structure
C++
struct IGetLayerIdAtCallback {
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IGetLayerIdAtCallback::~IGetLayerIdAtCallback Destructor
C++
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IGetLayerIdAtCallback::GetColorAtPosition Method
C++
virtual ColorB GetColorAtPosition(const float x, const float y, bool bBilinear) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IGetLayerIdAtCallback::GetElevationAtPosition Method
C++
virtual float GetElevationAtPosition(const float x, const float y) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IGetLayerIdAtCallback::GetHoleAtPosition Method
C++
virtual bool GetHoleAtPosition(const int x, const int y) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IGetLayerIdAtCallback::GetLayerIdAtPosition Method
C++
virtual uint32 GetLayerIdAtPosition(const int x, const int y) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IGetLayerIdAtCallback::GetRGBMultiplier Method
C++
virtual float GetRGBMultiplier() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IGetLayerIdAtCallback::GetSurfaceTypeIdAtPosition Method
C++
virtual uint32 GetSurfaceTypeIdAtPosition(const int x, const int y) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain Structure

Interface to terrain engine

C++
struct IVoxTerrain {
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::~IVoxTerrain Destructor
C++
virtual ~IVoxTerrain();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::DrawEditingHelper Method
C++
virtual void DrawEditingHelper(const Sphere & sp, EVoxelEditOperation eOperation, IMaterial * pHelperMat) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::GetCompiledData Method
C++
virtual IMemoryBlock * GetCompiledData(bool bSaveMesh, EEndian eEndian, bool bSaveForEditing, AABB * pAreaBox, int nSID = 0) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::GetLayerData Method
C++
virtual void GetLayerData(void ** pData, int & nDataSize) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::GetNodesForUpdate Method
C++
virtual PodArray<IRenderNode*> * GetNodesForUpdate() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::OnMouse Method
C++
virtual void OnMouse(bool bUp) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::PaintLayerId Method
C++
virtual void PaintLayerId(const float fpx, const float fpy, const float radius, const float hardness, const uint32 dwLayerId) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::SetCompiledData Method
C++
virtual bool SetCompiledData(byte * pData, int nDataSize, bool bUpdateMesh, EEndian eEndian, AABB * pAreaBox, int nSID = 0) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::SetLayerData Method
C++
virtual void SetLayerData(void * pData, int nDataSize) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::IVoxTerrain::SetTextureArea Method
C++
virtual void SetTextureArea(Vec3 * pPoints, int nPointsCount, int nShapePartId) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo Structure
C++
struct SHotUpdateInfo {
  uint32 nHeigtmap;
  uint32 nObjTypeMask;
  const uint8* pVisibleLayerMask;
  const uint16* pLayerIdTranslation;
  AABB areaBox;
  struct ITerrain {
    struct SExportInfo {
      bool bHeigtmap;
      bool bObjects;
      AABB areaBox;
    };
  };
  struct ISegmentsManager {
    enum ESegmentLoadFlags {
      slfTerrain = BIT(1),
      slfVisArea = BIT(2),
      slfEntity = BIT(3),
      slfNavigation = BIT(4),
      slfAll = slfTerrain|slfVisArea|slfEntity|slfNavigation
    };
  };
  struct IVisAreaCallback {
  };
  struct IVisAreaManager {
  };
  struct IMergedMeshesManager {
    struct SInstanceSector {
      DynArray<uint8> data;
      string id;
    };
  };
  struct ITimeOfDay {
    enum ETimeOfDayParamID {
      PARAM_HDR_DYNAMIC_POWER_FACTOR,
      PARAM_TERRAIN_OCCL_MULTIPLIER,
      PARAM_GI_MULTIPLIER,
      PARAM_SUN_COLOR,
      PARAM_SUN_COLOR_MULTIPLIER,
      PARAM_SUN_SPECULAR_MULTIPLIER,
      PARAM_FOG_COLOR,
      PARAM_FOG_COLOR_MULTIPLIER,
      PARAM_VOLFOG_HEIGHT,
      PARAM_VOLFOG_DENSITY,
      PARAM_FOG_COLOR2,
      PARAM_FOG_COLOR2_MULTIPLIER,
      PARAM_VOLFOG_HEIGHT2,
      PARAM_VOLFOG_DENSITY2,
      PARAM_VOLFOG_HEIGHT_OFFSET,
      PARAM_FOG_RADIAL_COLOR,
      PARAM_FOG_RADIAL_COLOR_MULTIPLIER,
      PARAM_VOLFOG_RADIAL_SIZE,
      PARAM_VOLFOG_RADIAL_LOBE,
      PARAM_VOLFOG_FINAL_DENSITY_CLAMP,
      PARAM_VOLFOG_GLOBAL_DENSITY,
      PARAM_VOLFOG_RAMP_START,
      PARAM_VOLFOG_RAMP_END,
      PARAM_VOLFOG_RAMP_INFLUENCE,
      PARAM_VOLFOG_SHADOW_DARKENING,
      PARAM_VOLFOG_SHADOW_DARKENING_SUN,
      PARAM_VOLFOG_SHADOW_DARKENING_AMBIENT,
      PARAM_VOLFOG_SHADOW_RANGE,
      PARAM_SKYLIGHT_SUN_INTENSITY,
      PARAM_SKYLIGHT_SUN_INTENSITY_MULTIPLIER,
      PARAM_SKYLIGHT_KM,
      PARAM_SKYLIGHT_KR,
      PARAM_SKYLIGHT_G,
      PARAM_SKYLIGHT_WAVELENGTH_R,
      PARAM_SKYLIGHT_WAVELENGTH_G,
      PARAM_SKYLIGHT_WAVELENGTH_B,
      PARAM_NIGHSKY_HORIZON_COLOR,
      PARAM_NIGHSKY_HORIZON_COLOR_MULTIPLIER,
      PARAM_NIGHSKY_ZENITH_COLOR,
      PARAM_NIGHSKY_ZENITH_COLOR_MULTIPLIER,
      PARAM_NIGHSKY_ZENITH_SHIFT,
      PARAM_NIGHSKY_START_INTENSITY,
      PARAM_NIGHSKY_MOON_COLOR,
      PARAM_NIGHSKY_MOON_COLOR_MULTIPLIER,
      PARAM_NIGHSKY_MOON_INNERCORONA_COLOR,
      PARAM_NIGHSKY_MOON_INNERCORONA_COLOR_MULTIPLIER,
      PARAM_NIGHSKY_MOON_INNERCORONA_SCALE,
      PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR,
      PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR_MULTIPLIER,
      PARAM_NIGHSKY_MOON_OUTERCORONA_SCALE,
      PARAM_CLOUDSHADING_SUNLIGHT_MULTIPLIER,
      PARAM_CLOUDSHADING_SKYLIGHT_MULTIPLIER,
      PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR,
      PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_MULTIPLIER,
      PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_INFLUENCE,
      PARAM_SUN_SHAFTS_VISIBILITY,
      PARAM_SUN_RAYS_VISIBILITY,
      PARAM_SUN_RAYS_ATTENUATION,
      PARAM_SUN_RAYS_SUNCOLORINFLUENCE,
      PARAM_SUN_RAYS_CUSTOMCOLOR,
      PARAM_OCEANFOG_COLOR,
      PARAM_OCEANFOG_COLOR_MULTIPLIER,
      PARAM_OCEANFOG_DENSITY,
      PARAM_SKYBOX_MULTIPLIER,
      PARAM_HDR_FILMCURVE_SHOULDER_SCALE,
      PARAM_HDR_FILMCURVE_LINEAR_SCALE,
      PARAM_HDR_FILMCURVE_TOE_SCALE,
      PARAM_HDR_FILMCURVE_WHITEPOINT,
      PARAM_HDR_COLORGRADING_COLOR_SATURATION,
      PARAM_HDR_COLORGRADING_COLOR_BALANCE,
      PARAM_HDR_EYEADAPTATION_SCENEKEY,
      PARAM_HDR_EYEADAPTATION_MIN_EXPOSURE,
      PARAM_HDR_EYEADAPTATION_MAX_EXPOSURE,
      PARAM_HDR_BLOOM_AMOUNT,
      PARAM_COLORGRADING_FILTERS_GRAIN,
      PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR,
      PARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY,
      PARAM_COLORGRADING_DOF_FOCUSRANGE,
      PARAM_COLORGRADING_DOF_BLURAMOUNT,
      PARAM_SHADOWSC0_BIAS,
      PARAM_SHADOWSC0_SLOPE_BIAS,
      PARAM_SHADOWSC1_BIAS,
      PARAM_SHADOWSC1_SLOPE_BIAS,
      PARAM_SHADOWSC2_BIAS,
      PARAM_SHADOWSC2_SLOPE_BIAS,
      PARAM_SHADOWSC3_BIAS,
      PARAM_SHADOWSC3_SLOPE_BIAS,
      PARAM_SHADOWSC4_BIAS,
      PARAM_SHADOWSC4_SLOPE_BIAS,
      PARAM_SHADOWSC5_BIAS,
      PARAM_SHADOWSC5_SLOPE_BIAS,
      PARAM_SHADOWSC6_BIAS,
      PARAM_SHADOWSC6_SLOPE_BIAS,
      PARAM_SHADOWSC7_BIAS,
      PARAM_SHADOWSC7_SLOPE_BIAS,
      PARAM_SHADOW_JITTERING,
      PARAM_TOTAL
    };
    enum EVariableType {
      TYPE_FLOAT,
      TYPE_COLOR
    };
    struct SVariableInfo {
      const char * name;
      const char * displayName;
      const char * group;
      int nParamId;
      EVariableType type;
      float fValue[3];
      ISplineInterpolator* pInterpolator;
      unsigned int bSelected : 1;
    };
    struct SAdvancedInfo {
      float fStartTime;
      float fEndTime;
      float fAnimSpeed;
    };
    struct SEnvironmentInfo {
      bool bSunLinkedToTOD;
      float sunRotationLatitude;
      float sunRotationLongitude;
    };
    const int NETSER_FORCESET = BIT(0);
    const int NETSER_COMPENSATELAG = BIT(1);
    const int NETSER_STATICPROPS = BIT(2);
  };
  struct ITimeOfDayUpdateCallback {
  };
  struct IFoliage {
    enum EFoliageFlags {
      FLAG_FROZEN = 1
    };
  };
  struct SSkyLightRenderParams {
    const int skyDomeTextureWidth = 64;
    const int skyDomeTextureHeight = 32;
    const int skyDomeTextureSize = 64 * 32;
    const int skyDomeTextureWidthBy8 = 8;
    const int skyDomeTextureWidthBy4Log = 4;
    const int skyDomeTextureHeightBy2Log = 4;
    _smart_ptr<IRenderMesh> m_pSkyDomeMesh;
    uint32 dummy0;
    uint32 dummy1;
    const void* m_pSkyDomeTextureDataMie;
    const void* m_pSkyDomeTextureDataRayleigh;
    size_t m_skyDomeTexturePitch;
    int m_skyDomeTextureTimeStamp;
    int pad;
    Vec4 m_partialMieInScatteringConst;
    Vec4 m_partialRayleighInScatteringConst;
    Vec4 m_sunDirection;
    Vec4 m_phaseFunctionConsts;
    Vec4 m_hazeColor;
    Vec4 m_hazeColorMieNoPremul;
    Vec4 m_hazeColorRayleighNoPremul;
    Vec3 m_skyColorTop;
    Vec3 m_skyColorNorth;
    Vec3 m_skyColorEast;
    Vec3 m_skyColorSouth;
    Vec3 m_skyColorWest;
  };
  struct sRAEColdData {
    Vec4 m_RAEPortalInfos[96];
  };
  struct SVisAreaInfo {
    float fHeight;
    Vec3 vAmbientColor;
    bool bAffectedByOutLights;
    bool bIgnoreSkyColor;
    bool bSkyOnly;
    float fViewDistRatio;
    bool bDoubleSide;
    bool bUseDeepness;
    bool bUseInIndoors;
    bool bOceanIsVisible;
    bool bIgnoreGI;
  };
  struct SDebugFPSInfo {
    float fAverageFPS;
    float fMinFPS;
    float fMaxFPS;
  };
  struct SRainParams {
    Matrix44 matOccTrans;
    Matrix44 matOccTransRender;
    Quat qRainRotation;
    AABB areaAABB;
    Vec3 vWorldPos;
    Vec3 vColor;
    float fAmount;
    float fCurrentAmount;
    float fRadius;
    float fFakeGlossiness;
    float fFakeReflectionAmount;
    float fDiffuseDarkening;
    float fRainDropsAmount;
    float fRainDropsSpeed;
    float fRainDropsLighting;
    float fMistAmount;
    float fMistHeight;
    float fPuddlesAmount;
    float fPuddlesMaskAmount;
    float fPuddlesRippleAmount;
    float fSplashesAmount;
    int nUpdateFrameID;
    bool bApplyOcclusion;
    bool bIgnoreVisareas;
    bool bDisableOcclusion;
  };
  struct SSnowParams {
    Vec3 m_vWorldPos;
    float m_fRadius;
    float m_fSnowAmount;
    float m_fFrostAmount;
    float m_fSurfaceFreezing;
    int m_nSnowFlakeCount;
    float m_fSnowFlakeSize;
    float m_fSnowFallBrightness;
    float m_fSnowFallGravityScale;
    float m_fSnowFallWindScale;
    float m_fSnowFallTurbulence;
    float m_fSnowFallTurbulenceFreq;
  };
  struct IScreenshotCallback {
  };
  class IStreamedObjectListener;
  struct SLightVolume {
    struct SLightData {
      Vec4 vPos;
      Vec4 vColor;
      Vec4 vParams;
    };
  };
  struct I3DEngine : public IProcess {
    struct SObjectsStreamingStatus {
      int nReady;
      int nInProgress;
      int nTotal;
      int nActive;
      int nAllocatedBytes;
      int nMemRequired;
      int nMeshPoolSize;
    };
    struct SStremaingBandwidthData {
      float fBandwidthActual;
      float fBandwidthRequested;
    };
    enum eStreamingSubsystem {
      eStreamingSubsystem_Textures,
      eStreamingSubsystem_Objects,
      eStreamingSubsystem_Audio
    };
    enum EChunkFileFormat {
      eChunkFileFormat_0x745,
      eChunkFileFormat_0x746
    };
  };
  enum EFileTypes {
    eTerrainTextureFile = 100
  };
  struct SCommonFileHeader {
    char signature[4];
    uint8 file_type;
    uint8 flags;
    uint16 version;
    struct STerrainTextureFileHeader_old {
      uint16 nSectorSizeMeters;
      uint16 nLodsNum;
      uint16 nLayerCount;
      uint16 nReserved;
      struct STerrainTextureFileHeader {
        uint16 nLayerCount;
        uint16 dwFlags;
        float fBrMultiplier;
        struct STerrainTextureLayerFileHeader {
          uint16 nSectorSizePixels;
          uint16 nReserved;
          ETEX_Format eTexFormat;
          uint32 nSectorSizeBytes;
          struct SRenderingPassInfo {
            enum EShadowMapType {
              SHADOW_MAP_NONE = 0,
              SHADOW_MAP_GSM0,
              SHADOW_MAP_GSM1,
              SHADOW_MAP_GSM2,
              SHADOW_MAP_GSM3,
              SHADOW_MAP_GSM4,
              SHADOW_MAP_GSM5,
              SHADOW_MAP_GSM6,
              SHADOW_MAP_GSM7,
              SHADOW_MAP_LOCAL,
              SHADOW_MAP_REFLECTIVE,
              SHADOW_MAP_STATIC,
              SHADOW_MAP_STATIC_MGPU_COPY
            };
            enum ESkipRenderingFlags {
              SHADOWS = BIT(0),
              BRUSHES = BIT(1),
              VEGETATION = BIT(2),
              ENTITIES = BIT(3),
              TERRAIN = BIT(4),
              WATEROCEAN = BIT(5),
              PARTICLES = BIT(6),
              DECALS = BIT(7),
              TERRAIN_DETAIL_MATERIALS = BIT(8),
              FAR_SPRITES = BIT(9),
              WATER_WAVES = BIT(12),
              ROADS = BIT(13),
              WATER_VOLUMES = BIT(14),
              CLOUDS = BIT(15),
              CUBEMAP_GEN = BIT(16),
              GEOM_CACHES = BIT(17),
              STATIC_OBJECTS = BRUSHES|VEGETATION,
              DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
              DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
            };
          };
          struct SRendItemSorter {
            enum EDeferredPreprocess {
              eLPVPass = 0,
              eDeferredShadingPass = BIT(30)
            };
public:
            enum {
            };
public:
            enum {
            };
public:
            enum {
            };
public:
            enum {
            };
public:
            enum {
            };
          };
        };
      };
    };
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::EFileTypes Enumeration

Types of binary files used by 3dengine

C++
enum EFileTypes {
  eTerrainTextureFile = 100
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine Structure

Interface to the 3d Engine.

C++
struct I3DEngine : public IProcess {
  struct SObjectsStreamingStatus {
    int nReady;
    int nInProgress;
    int nTotal;
    int nActive;
    int nAllocatedBytes;
    int nMemRequired;
    int nMeshPoolSize;
  };
  struct SStremaingBandwidthData {
    float fBandwidthActual;
    float fBandwidthRequested;
  };
  enum eStreamingSubsystem {
    eStreamingSubsystem_Textures,
    eStreamingSubsystem_Objects,
    eStreamingSubsystem_Audio
  };
  enum EChunkFileFormat {
    eChunkFileFormat_0x745,
    eChunkFileFormat_0x746
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::EChunkFileFormat Enumeration
C++
enum EChunkFileFormat {
  eChunkFileFormat_0x745,
  eChunkFileFormat_0x746
};
File

I3DEngine.h

Description

Chunk file writer.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::eStreamingSubsystem Enumeration
C++
enum eStreamingSubsystem {
  eStreamingSubsystem_Textures,
  eStreamingSubsystem_Objects,
  eStreamingSubsystem_Audio
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SObjectsStreamingStatus Structure
C++
struct SObjectsStreamingStatus {
  int nReady;
  int nInProgress;
  int nTotal;
  int nActive;
  int nAllocatedBytes;
  int nMemRequired;
  int nMeshPoolSize;
};
File

I3DEngine.h

Members
Members 
Description 
int nMeshPoolSize; 
in MB 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SStremaingBandwidthData Structure
C++
struct SStremaingBandwidthData {
  float fBandwidthActual;
  float fBandwidthRequested;
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SStremaingBandwidthData::fBandwidthActual Data Member
C++
float fBandwidthActual;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SStremaingBandwidthData::fBandwidthRequested Data Member
C++
float fBandwidthRequested;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SStremaingBandwidthData::SStremaingBandwidthData Constructor
C++
SStremaingBandwidthData();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ActivateObjectsLayer Method
C++
virtual void ActivateObjectsLayer(uint16 nLayerId, bool bActivate, bool bPhys, bool bObjects, bool bStaticLights, const char * pLayerName, IGeneralMemoryHeap* pHeap = NULL, bool bCheckLayerActivation = true) = 0;
Description

Show/Hide objects by layer (useful for streaming and performance)

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ActivatePortal Method

Enables or disables portal at a specified position.

C++
virtual void ActivatePortal(const Vec3 & vPos, bool bActivate, const char * szEntityName) = 0;
Parameters
Parameters 
Description 
const Vec3 & vPos 
Position to place the portal 
bool bActivate 
Set to true in order to enable the portal, or to false to disable szEntityName - 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::AddPrecachePoint Method
C++
virtual int AddPrecachePoint(const Vec3& vPos, const Vec3& vDir, float fTimeOut = 3.f, float fImportanceFactor = 1.0f) = 0;
Description

begin streaming of meshes and textures for specified position, pre-cache stops after fTimeOut seconds

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ApplyForceToEnvironment Method

Applies physics in a specified area

C++
virtual void ApplyForceToEnvironment(Vec3 vPos, float fRadius, float fAmountOfForce) = 0;
Parameters
Parameters 
Description 
Vec3 vPos 
Center position to apply physics 
float fRadius 
Radius which specify the size of the area to apply physics 
float fAmountOfForce 
The amount of force, should be at least of 1.0f 
Description

Physics applied to the area will apply to vegetations and allow it to move/blend.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CheckIntersectClouds Method
C++
virtual bool CheckIntersectClouds(const Vec3 & p1, const Vec3 & p2) = 0;
Description

Returns true if input line segment intersect clouds sprites.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CheckMemoryHeap Method

In debug mode check memory heap and makes assert, do nothing in release

C++
virtual void CheckMemoryHeap() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CheckPhysicalized Method

Physicalizes area if not physicalized yet.

C++
virtual void CheckPhysicalized(const Vec3 & vBoxMin, const Vec3 & vBoxMax) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ClearAllPrecachePoints Method
C++
virtual void ClearAllPrecachePoints() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ClearPrecachePoint Method
C++
virtual void ClearPrecachePoint(int id) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ClipToVisAreas Method
C++
virtual bool ClipToVisAreas(IVisArea* pInside, Sphere& sphere, Vec3 const& vNormal, void* pNodeCache = 0) = 0;
Parameters
Parameters 
Description 
IVisArea* pInside 
Vis Area to clip inside of. If 0, clip outside all Vis Areas. 
Sphere& sphere 
vNormal - 
pNodeChache 
 
Returns

Whether it was clipped

Description

Clips geometry against the boundaries of VisAreas.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CloseTerrainTextureFile Method

Closes terrain texture file handle and allows to replace/update it.

C++
virtual void CloseTerrainTextureFile(int nSID = DEFAULT_SID) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CompleteObjectsGeometry Method

Finishes objects geometery generation/loading.

C++
virtual void CompleteObjectsGeometry() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateChunkFile Method
C++
virtual IChunkFile * CreateChunkFile(bool bReadOnly = false) = 0;
Description

Creates ChunkFile.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateChunkfileContent Method
C++
virtual CContentCGF* CreateChunkfileContent(const char * filename) = 0;
Description

CGF Loader. /////////////////////////////////////////////////////////////////////// 

Creates a chunkfile content instance Returns 'NULL' if the memory for the instance could not be allocated

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateChunkFileWriter Method
C++
virtual ChunkFile::IChunkFileWriter* CreateChunkFileWriter(EChunkFileFormat eFormat, ICryPak* pPak, const char* filename) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateDecal Method

Creates new decals on the walls, static objects, terrain and entities.

C++
virtual void CreateDecal(const CryEngineDecalInfo & Decal) = 0;
Parameters
Parameters 
Description 
const CryEngineDecalInfo & Decal 
Structure describing the decal effect to be applied 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateIndexedMesh Method

Creates the instance of the indexed mesh.

C++
virtual IIndexedMesh* CreateIndexedMesh() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateLightSource Method

Creates a new light source.

C++
virtual struct ILightSource * CreateLightSource() = 0;
Returns

Pointer to newly created light or -1 if it fails.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateRenderNode Method

Creates instance of IRenderNode object with specified type.

C++
virtual IRenderNode* CreateRenderNode(EERType type) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateStatObj Method

Creates static object containing empty IndexedMesh.

C++
virtual IStatObj * CreateStatObj() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateStatObjOptionalIndexedMesh Method
C++
virtual IStatObj * CreateStatObjOptionalIndexedMesh(bool createIndexedMesh) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateTerrain Method
C++
virtual ITerrain * CreateTerrain(const STerrainInfo & TerrainInfo) = 0;
Description

Creates terrain engine

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::CreateVisArea Method

Creates a new VisArea.

C++
virtual IVisArea * CreateVisArea(uint64 visGUID) = 0;
Returns

A pointer to a newly created VisArea object

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DebugDraw_UpdateDebugNode Method
C++
virtual void DebugDraw_UpdateDebugNode() = 0;
Description

Used to highlight an object under the reticule

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DeleteDecalsInRange Method

Removes decals in a specified range.

C++
virtual void DeleteDecalsInRange(AABB * pAreaBox, IRenderNode * pEntity) = 0;
Parameters
Parameters 
Description 
IRenderNode * pEntity 
if not NULL will only delete decals attached to this entity 
vAreaBox 
Specify the area in which the decals will be removed 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DeleteEntityDecals Method

Removes all decals attached to specified entity.

C++
virtual void DeleteEntityDecals(IRenderNode * pEntity) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DeleteLightSource Method

Deletes a light.

C++
virtual void DeleteLightSource(ILightSource * pLightSource) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DeleteRenderNode Method

Delete RenderNode object.

C++
virtual void DeleteRenderNode(IRenderNode * pRenderNode) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DeleteTerrain Method
C++
virtual void DeleteTerrain() = 0;
Description

Deletes terrain

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DeleteVisArea Method

Deletes a VisArea.

C++
virtual void DeleteVisArea(IVisArea * pVisArea) = 0;
Parameters
Parameters 
Description 
IVisArea * pVisArea 
A pointer to the VisArea to delete 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DisplayInfo Method

Displays statistic on the 3d Engine.

C++
virtual void DisplayInfo(float & fTextPosX, float & fTextPosY, float & fTextStepY, const bool bEnhanced) = 0;
Parameters
Parameters 
Description 
float & fTextPosX 
X position for the text 
float & fTextPosY 
Y position for the text 
float & fTextStepY 
Amount of pixels to distance each line 
const bool bEnhanced 
false=normal, true=more interesting information 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DrawDeferredCoverageBufferDebug Method
C++
virtual void DrawDeferredCoverageBufferDebug() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DrawTextRightAligned Method (float, float, char *, ...)

Draws text right aligned at the y pixel precision.

C++
virtual void DrawTextRightAligned(const float x, const float y, const char * format, ...);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::DrawTextRightAligned Method (float, float, float, ColorF &, char *, ...)
C++
virtual void DrawTextRightAligned(const float x, const float y, const float scale, const ColorF & color, const char * format, ...);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::EnableOceanRendering Method

Enables or disables ocean rendering.

C++
virtual void EnableOceanRendering(bool bOcean) = 0;
Parameters
Parameters 
Description 
bool bOcean 
Will enable or disable the rendering of ocean 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::EndOcclusion Method
C++
virtual void EndOcclusion() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::FillDebugFPSInfo Method
C++
virtual void FillDebugFPSInfo(SDebugFPSInfo&) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::FindStatObjectByFilename Method

Finds a static object created from the given filename

C++
virtual IStatObj * FindStatObjectByFilename(const char * filename) = 0;
Parameters
Parameters 
Description 
szFileName 
CGF Filename - should not be 0 or "" 
Returns

A pointer to an object derived from IStatObj.

See Also

IStatObj

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::FreeRenderNodeState Method

Frees entity render info.

C++
virtual void FreeRenderNodeState(IRenderNode * pEntity) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::FreeRNTmpData Method
C++
virtual void FreeRNTmpData(CRNTmpData ** ppInfo) = 0;
Description

Frees lod transition state

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetAccurateOceanHeight Method

Gets the ocean water level for a specified position.

  • Use with caution the accurate query - SLOW

Notes: This function only takes into account ocean water.

C++
virtual float GetAccurateOceanHeight(const Vec3 & pCurrPos) const = 0;
Parameters
Parameters 
Description 
const Vec3 & pCurrPos 
Position to check water level 
Returns

A float value which indicate the water level.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetBottomLevel Method (Vec3 &, float)
C++
virtual float GetBottomLevel(const Vec3 & referencePos, float maxRelevantDepth = 10.0f) = 0;
Description

A set of overloads for enabling users to use different sets of input params. Basically, only referencePos is mandatory. The overloads as such don't need to be virtual but this seems to be a purely virtual interface.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetBottomLevel Method (Vec3 &, float, int)

Gets the closest walkable bottom z straight beneath the given reference position. Notes: This function will take into account both the global terrain elevation and local voxel (or other solid walkable object).

C++
virtual float GetBottomLevel(const Vec3 & referencePos, float maxRelevantDepth, int objtypes) = 0;
Parameters
Parameters 
Description 
const Vec3 & referencePos 
Position from where to start searching downwards. 
float maxRelevantDepth 
Max depth caller is interested in relative to referencePos (for ray casting performance reasons). 
int objtypes 
expects physics entity flags. Use this to specify what object types make a valid bottom for you. 
Returns

A float value which indicate the global world z of the bottom level beneath the referencePos. If the referencePos is below terrain but not inside any voxel area BOTTOM_LEVEL_UNKNOWN is returned.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetBottomLevel Method (Vec3 &, int)
C++
virtual float GetBottomLevel(const Vec3 & referencePos, int objflags) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetCausticsParams Method

Gets caustics parameters.

C++
virtual Vec4 GetCausticsParams() const = 0;
Returns

A Vec4 value which constains: x = unused, y = distance attenuation, z = caustics multiplier, w = caustics darkening multiplier

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetDeferredPhysicsEventManager Method
C++
virtual IDeferredPhysicsEventManager* GetDeferredPhysicsEventManager() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetDynamicLightSources Method
C++
virtual PodArray<CDLight*>* GetDynamicLightSources() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetFogColor Method

Gets the fog color.

C++
virtual Vec3 GetFogColor() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetGIAmount Method

Retrieves the current GI multiplier Notes:

C++
virtual float GetGIAmount() const = 0;
Returns

scalar value

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetGlobalParameter Method (E3DEngineParameter)
C++
float GetGlobalParameter(E3DEngineParameter param);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetGlobalParameter Method (E3DEngineParameter, Vec3 &)
C++
virtual void GetGlobalParameter(E3DEngineParameter param, Vec3 & v) = 0;
Description

Retrieves global 3d engine parameter.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetGlobalWind Method

Gets the global wind vector.

C++
virtual Vec3 GetGlobalWind(bool bIndoors) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetHDRSetupParams Method

Gets HDR setup parameters.

C++
virtual void GetHDRSetupParams(Vec4 pParams[4]) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetHeightMapUnitSize Method

Gets the unit size of the terrain Notes: The value should currently be 2.

C++
virtual int GetHeightMapUnitSize() = 0;
Returns

A int value representing the terrain unit size in meters.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetIMergedMeshesManager Method
C++
virtual IMergedMeshesManager * GetIMergedMeshesManager() = 0;
Description

Returns interface to the mergedmeshes subsystem

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetITerrain Method
C++
virtual ITerrain * GetITerrain() = 0;
Description

Returns interface to terrain engine

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetIVisAreaManager Method
C++
virtual IVisAreaManager * GetIVisAreaManager() = 0;
Description

Returns interface to visarea manager.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetIVoxTerrain Method
C++
virtual IVoxTerrain * GetIVoxTerrain() = 0;
Description

Deprecated

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetLayerMemoryUsage Method
C++
virtual void GetLayerMemoryUsage(uint16 nLayerId, ICrySizer* pSizer, int* pNumBrushes, int* pNumDecals) const = 0;
Description

Get object layer memory usage

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetLevelFilePath Method

Adds the level's path to a specified filename.

C++
virtual const char * GetLevelFilePath(const char * szFileName) = 0;
Parameters
Parameters 
Description 
const char * szFileName 
The filename for which we need to add the path 
Returns

Full path for the filename; including the level path and the filename appended after.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetLightAmountInRange Method
C++
virtual float GetLightAmountInRange(const Vec3 & pPos, float fRange, bool bAccurate = 0) = 0;
Description

Returns amount of light affecting a point in space inside a specific range (0 means no light affecting, 1 is completely affected by light). Use accurate parameter for a more expensive but with higher accuracy computation.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetLightEntities Method
C++
virtual const PodArray<ILightSource*> * GetLightEntities() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetLightsHDRDynamicPowerFactor Method
C++
virtual float GetLightsHDRDynamicPowerFactor() const = 0;
Returns

In logarithmic scale -4.0 .. 4.0

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetLightVolumes Method

Gives access to list holding all lighting volumes

C++
virtual void GetLightVolumes(threadID nThreadID, SLightVolume *& pLightVols, uint32 & nNumVols) = 0;
Returns

An array holding all the SLightVolume pointers.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetLoadedObjectCount Method

Gets the amount of loaded objects.

C++
virtual int GetLoadedObjectCount();
Returns

An integer representing the amount of loaded objects.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetLoadedStatObjArray Method

Fills pObjectsArray with pointers to loaded static objects if pObjectsArray is NULL only fills nCount parameter with amount of loaded objects.

C++
virtual void GetLoadedStatObjArray(IStatObj** pObjectsArray, int & nCount) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetMaterialManager Method
C++
virtual IMaterialManager* GetMaterialManager() = 0;
Description

Retrieve pointer to the material manager interface.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetMatMan Method

Gives access to materials library.

C++
virtual class CMatMan * GetMatMan() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetMaxViewDistance Method

Gets the view distance.

C++
virtual float GetMaxViewDistance(bool bScaled = true) = 0;
Returns

A float value representing the maximum view distance.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetObjectsByType Method
C++
virtual uint32 GetObjectsByType(EERType objType, IRenderNode ** pObjects = 0) = 0;
Parameters
Parameters 
Description 
IRenderNode ** pObjects = 0 
0 if only the count is required 
Returns

Count returned

Description

Call function 2 times (first to get the size then to fill in the data)

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetObjectsByTypeInBox Method (EERType, AABB &, IRenderNode **)
C++
virtual uint32 GetObjectsByTypeInBox(EERType objType, const AABB & bbox, IRenderNode ** pObjects = 0) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetObjectsByTypeInBox Method (EERType, AABB &, PodArray<IRenderNode*> *)
C++
virtual void GetObjectsByTypeInBox(EERType objType, const AABB & bbox, PodArray<IRenderNode*> * pLstObjects) = 0;
Description

variant which takes a POD array which is resized in the function itself

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetObjectsInBox Method
C++
virtual uint32 GetObjectsInBox(const AABB & bbox, IRenderNode ** pObjects = 0) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetObjectsStreamingStatus Method

Gets stats on streamed objects

C++
virtual void GetObjectsStreamingStatus(SObjectsStreamingStatus & outStatus) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetOceanAnimationCausticsParams Method

Gets ocean animation caustics parameters.

C++
virtual Vec4 GetOceanAnimationCausticsParams() const = 0;
Returns

A Vec4 value which constains: x = unused, y = height, z = depth, w = intensity

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetOceanAnimationParams Method

Gets ocean animation parameters.

C++
virtual void GetOceanAnimationParams(Vec4 & pParams0, Vec4 & pParams1) const = 0;
Returns

2 Vec4 which constain: 0: x = ocean wind direction, y = wind speed, z = waves speed, w = waves amount 1: x = waves size, y = free, z = free, w = free

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetOceanRenderFlags Method
C++
virtual uint8 GetOceanRenderFlags() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetOceanVisiblePixelsCount Method
C++
virtual uint32 GetOceanVisiblePixelsCount() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetOpticsManager Method
C++
virtual IOpticsManager * GetOpticsManager() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetParticleManager Method
C++
virtual IParticleManager * GetParticleManager() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetPhysMaterialEnumerator Method

Gets the physics material enumerator

C++
virtual IPhysMaterialEnumerator * GetPhysMaterialEnumerator() = 0;
Returns

A pointer to an IPhysMaterialEnumerator derived object.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetPostEffectID Method
C++
virtual int32 GetPostEffectID(const char* pPostEffectName) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetPostEffectParam Method
C++
virtual void GetPostEffectParam(const char * pParam, float & fValue) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetPostEffectParamString Method
C++
virtual void GetPostEffectParamString(const char * pParam, const char* & pszArg) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetPostEffectParamVec4 Method
C++
virtual void GetPostEffectParamVec4(const char * pParam, Vec4 & pValue) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetPrecacheRoundIds Method
C++
virtual void GetPrecacheRoundIds(int pRoundIds[MAX_STREAM_PREDICTION_ZONES]) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetPrevZoomFactor Method
C++
virtual float GetPrevZoomFactor() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetRainParams Method

Gets the validity and fills current rain parameters.

C++
virtual bool GetRainParams(SRainParams & rainParams) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetRenderingCamera Method

Returns the Camera used for Rendering on 3DEngine Side, normaly equal to the view camera, except if frozen with e_camerafreeze Notes: Only valid during RenderWorld(else the camera of the last frame is used) This is the camera which should be used for all Engine side culling (since e_camerafreeze allows easy debugging then)

C++
virtual const CCamera& GetRenderingCamera() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetRenderingPassCamera Method
C++
virtual CCamera* GetRenderingPassCamera(const CCamera & rCamera) = 0;
Description

following functions are used by SRenderingPassInfo

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSegmentsManager Method
C++
virtual ISegmentsManager * GetSegmentsManager() = 0;
Description

pointer to ISegmentsManager interface

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetShadowMode Method
C++
virtual EShadowMode GetShadowMode() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSkyBrightness Method

Retrieves the current sky brightening multiplier Notes:

C++
virtual float GetSkyBrightness() const = 0;
Returns

Scalar value

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSkyColor Method

Gets the environment ambient color. Notes: Should have been specified in the editor.

C++
virtual Vec3 GetSkyColor() const = 0;
Returns

An rgb value contained in a Vec3 object.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSkyLightParameters Method

Gets various sky light parameters.

C++
virtual void GetSkyLightParameters(Vec3& sunDir, Vec3& sunIntensity, float& Km, float& Kr, float& g, Vec3& rgbWaveLengths) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSkyMaterial Method
C++
virtual IMaterial* GetSkyMaterial() = 0;
Description

Returns SkyBox material.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSnowFallParams Method

Gets current snow parameters.

C++
VIRTUAL bool GetSnowFallParams(int & nSnowFlakeCount, float & fSnowFlakeSize, float & fSnowFallBrightness, float & fSnowFallGravityScale, float & fSnowFallWindScale, float & fSnowFallTurbulence, float & fSnowFallTurbulenceFreq) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSnowSurfaceParams Method

Gets current snow surface parameters.

C++
VIRTUAL bool GetSnowSurfaceParams(Vec3 & vCenter, float & fRadius, float & fSnowAmount, float & fFrostAmount, float & fSurfaceFreezing) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSSAOAmount Method

Retrieves the current SSAO multiplier Notes:

C++
virtual float GetSSAOAmount() const = 0;
Returns

scalar value

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSSAOContrast Method

Retrieves the current SSAO contrast multiplier Notes:

C++
virtual float GetSSAOContrast() const = 0;
Returns

scalar value

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetStaticLightSources Method

Gives access to the list holding all static light sources

C++
virtual const PodArray<CDLight*> * GetStaticLightSources() = 0;
Returns

An array holding all the CDLight pointers.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetStreamingSubsystemData Method

Gets stats on the streaming bandwidth requests from subsystems

C++
virtual void GetStreamingSubsystemData(int subsystem, SStremaingBandwidthData & outData) = 0;
Parameters
Parameters 
Description 
int subsystem 
the streaming subsystem we want bandwidth data for 
SStremaingBandwidthData & outData 
structure containing the bandwidth data for the subsystem requested 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSunColor Method

Gets the sun color Notes: Should have been specified in the editor.

C++
virtual Vec3 GetSunColor() const = 0;
Returns

An rgb value contained in a Vec3 object.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetSunRel Method

Gets the current sun/sky color relation.

C++
virtual float GetSunRel() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetTempRenderObjectModifier Method
C++
virtual SRenderObjectModifier* GetTempRenderObjectModifier(const SRenderObjectModifier & rRenderObjectModifier, const SRenderingPassInfo & passInfo) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetTerrainElevation Method

Gets the interpolated terrain elevation for a specified location. Notes: All x,y values are valid.

C++
virtual float GetTerrainElevation(float x, float y, int nSID = DEFAULT_SID) = 0;
Parameters
Parameters 
Description 
float x 
X coordinate of the location 
float y 
Y coordinate of the location 
Returns

A float which indicate the elevation level.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetTerrainHole Method

Gets the terrain hole flag for a specified location. Notes: Only values between 0 and WORLD_SIZE.

C++
virtual bool GetTerrainHole(int x, int y) = 0;
Parameters
Parameters 
Description 
int x 
X coordinate of the location 
int y 
Y coordinate of the location 
Returns

A bool which indicate is there hole or not.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetTerrainSectorSize Method

Gets the size of the terrain sectors Notes: The value should be 64 by default.

C++
virtual int GetTerrainSectorSize() = 0;
Returns

An int representing the size of a sector in meters.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetTerrainSize Method

Gets the size of the terrain Notes: The value should be 2048 by default.

C++
virtual int GetTerrainSize() = 0;
Returns

An int representing the terrain size in meters.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetTerrainSurfaceNormal Method

Gets the terrain surface normal for a specified location.

C++
virtual Vec3 GetTerrainSurfaceNormal(Vec3 vPos) = 0;
Returns

A terrain surface normal.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetTerrainTextureMultiplier Method

Returns terrain texture multiplier.

C++
virtual float GetTerrainTextureMultiplier(int nSID = 0) const = 0;
Returns

Scalar value

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetTerrainZ Method

Gets the terrain elevation for a specified location. Notes: Only values between 0 and WORLD_SIZE.

C++
virtual float GetTerrainZ(int x, int y) = 0;
Parameters
Parameters 
Description 
int x 
X coordinate of the location 
int y 
Y coordinate of the location 
Returns

A float which indicate the elevation level.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetTimeOfDay Method
C++
virtual ITimeOfDay* GetTimeOfDay() = 0;
Description

Returns TOD interface.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetVisAreaFromPos Method
C++
virtual IVisArea * GetVisAreaFromPos(const Vec3 & vPos) = 0;
Parameters
Parameters 
Description 
const Vec3 & vPos 
 
Returns

VisArea containing point, if any. 0 otherwise.

Description

Gets the VisArea which is present at a specified point.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetVoxelEditOperationName Method
C++
virtual const char * GetVoxelEditOperationName(EVoxelEditOperation eOperation) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetWaterLevel Method ()

Gets the ocean water level. Fastest option, always prefer is only ocean height required. Notes: This function will take into account just the global water level.

C++
virtual float GetWaterLevel() = 0;
Returns

A float value which indicate the water level. In case no water was found at the specified location, the value WATER_LEVEL_UNKNOWN will be returned.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetWaterLevel Method (Vec3 *, IPhysicalEntity *, bool)

Gets the closest walkable bottom z straight beneath the given reference position.

  • Use with caution the accurate query - SLOW

Notes: This function will take into account both the global water level and any water volume present. Function is provided twice for performance with diff. arguments.

C++
virtual float GetWaterLevel(const Vec3 * pvPos, IPhysicalEntity * pent = NULL, bool bAccurate = false) = 0;
Parameters
Parameters 
Description 
const Vec3 * pvPos 
Desired position to inspect the water level 
IPhysicalEntity * pent = NULL 
Pointer to return the physical entity to test against (optional) 
Returns

A float value which indicate the water level. In case no water was found at the specified location, the value WATER_LEVEL_UNKNOWN will be returned.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetWind Method

Gets wind direction and force, averaged within a box.

C++
virtual Vec3 GetWind(const AABB & box, bool bIndoors) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetZoomFactor Method
C++
virtual float GetZoomFactor() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::GetZoomMode Method
C++
virtual int GetZoomMode() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::Init Method

Initializes the 3D Engine.

C++
virtual bool Init() = 0;
See Also

ShutDown Notes: Only call once, after creating the instance.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::InitLevelForEditor Method
C++
virtual bool InitLevelForEditor(const char * szFolderName, const char * szMissionName) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::IntersectsVisAreas Method
C++
virtual bool IntersectsVisAreas(const AABB& box, void** pNodeCache = 0) = 0;
Parameters
Parameters 
Description 
const AABB& box 
Volume to test for intersection. pNodeCache (out, optional): Set to a cached pointer, for quicker calls to ClipToVisAreas
Returns

Whether box intersects any vis areas.

Description

Tests for intersection against Vis Areas.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::IsAmbientOcclusionEnabled Method
C++
virtual bool IsAmbientOcclusionEnabled() = 0;
Returns

True if e_ambient_occlusion is ON and AO data is valid

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::IsAreaActivationInUse Method
C++
virtual bool IsAreaActivationInUse() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::IsSegmentOperationInProgress Method
C++
virtual bool IsSegmentOperationInProgress() = 0;
Description

true if segmented world is performing an operation (load/save/move/etc)

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::IsTerrainTextureStreamingInProgress Method
C++
virtual bool IsTerrainTextureStreamingInProgress() = 0;
Description

Return true if terrain texture streaming takes place

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::IsTessellationAllowed Method
C++
virtual bool IsTessellationAllowed(const CRenderObject * pObj, const SRenderingPassInfo & passInfo, bool bIgnoreShadowPass = false) const = 0;
Description

Return true if tessellation is allowed for given render object

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::IsUnderWater Method

Returns whether a world pos is under water.

C++
virtual bool IsUnderWater(const Vec3& vPos) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::IsVisAreasConnected Method

Determines if two VisAreas are connected.

C++
virtual bool IsVisAreasConnected(IVisArea * pArea1, IVisArea * pArea2, int nMaxRecursion = 1, bool bSkipDisabledPortals = true) = 0;
Parameters
Parameters 
Description 
IVisArea * pArea1 
A pointer to a VisArea 
IVisArea * pArea2 
A pointer to a VisArea 
int nMaxRecursion = 1 
Maximum number of recursions to be done 
bool bSkipDisabledPortals = true 
Indicate if disabled portals should be skipped 
Returns

A boolean value set to true if the two VisAreas are connected, else false will be returned.

Description

Used to determine if a sound is potentially hearable between two VisAreas.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::IsZoomInProgress Method
C++
virtual float IsZoomInProgress() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::LoadChunkFileContent Method
C++
virtual bool LoadChunkFileContent(CContentCGF* pCGF, const char * filename, bool bNoWarningMode = false, bool bCopyChunkFile = true) = 0;
Description

Loads the contents of a chunkfile into the given CContentCGF. Returns 'false' on error.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::LoadChunkFileContentFromMem Method
C++
virtual bool LoadChunkFileContentFromMem(CContentCGF* pCGF, const void* pData, size_t nDataLen, uint32 nLoadingFlags, bool bNoWarningMode = false, bool bCopyChunkFile = true) = 0;
Description

Loads the contents of a chunkfile into the given CContentCGF. Returns 'false' on error.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::LoadDesignerObject Method

Loads a designer object from a stream of _decoded_ binary node. (Base64Decode)

C++
virtual IStatObj* LoadDesignerObject(int nVersion, const char* szBinaryStream, int size) = 0;
Parameters
Parameters 
Description 
const char* szBinaryStream 
decoded stream + size 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::LoadInternalState Method
C++
virtual void LoadInternalState(struct IDataReadStream& reader, const uint8* pVisibleLayersMasks, const uint16* pLayerIdTranslation) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::LoadLevel Method

Load a level.

C++
virtual bool LoadLevel(const char * szFolderName, const char * szMissionName) = 0;
Parameters
Parameters 
Description 
const char * szFolderName 
Name of the subfolder to load 
const char * szMissionName 
Name of the mission 
Returns

A boolean which indicate the result of the function; true is succeed, or false if failed.

Description

Will load a level from the folder specified with SetLevelPath. If a level is already loaded, the resources will be deleted before.

See Also
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::LoadStatObj Method (TSerialize)
C++
virtual IStatObj * LoadStatObj(TSerialize ser) = 0;
Description

Loads statobj from a stream

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::LoadStatObj Method (char *, char *, IStatObj::SSubObject **, bool, unsigned long)

Loads a static object from a CGF file.

C++
virtual IStatObj* LoadStatObj(const char * szFileName, const char * szGeomName = NULL, IStatObj::SSubObject ** ppSubObject = NULL, bool bUseStreaming = true, unsigned long nLoadingFlags = 0) = 0;
Parameters
Parameters 
Description 
const char * szFileName 
CGF Filename - should not be 0 or "" 
const char * szGeomName = NULL 
Optional name of geometry inside CGF. 
IStatObj::SSubObject ** ppSubObject = NULL 
[Out]Optional Out parameter,Pointer to the 
unsigned long nLoadingFlags = 0 
Zero or a bitwise combination of the flags from ELoadingFlags, defined in IMaterial.h, under the interface IMaterialManager. 
Returns

A pointer to an object derived from IStatObj.

See Also

IStatObj

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::LockCGFResources Method

Disables CGFs unloading.

C++
virtual void LockCGFResources() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::OffsetPosition Method
C++
virtual void OffsetPosition(Vec3 & delta) = 0;
Description

Called when the segmented world moves

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::OnExplosion Method

Notifies of an explosion, and maybe creates an hole in the terrain

C++
virtual void OnExplosion(Vec3 vPos, float fRadius, bool bDeformTerrain = true) = 0;
Parameters
Parameters 
Description 
Vec3 vPos 
Position of the explosion 
float fRadius 
Radius of the explosion 
bool bDeformTerrain = true 
Allow to deform the terrain 
Description

This function should usually make sure that no static objects are near before making the hole.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::OnFrameStart Method

Handles any work needed at start of new frame. Notes: Should be called for every frame.

C++
virtual void OnFrameStart() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::OnRenderMeshDeleted Method
C++
virtual void OnRenderMeshDeleted(IRenderMesh * pRenderMesh) = 0;
Description

Removes references to RenderMesh

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::OverrideCameraPrecachePoint Method
C++
virtual void OverrideCameraPrecachePoint(const Vec3& vPos) = 0;
Description

override the camera precache point with the requested position for the current round

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::PostLoadLevel Method

Pre-caches some resources need for rendering.

C++
virtual void PostLoadLevel() = 0;
Description

Must be called after the game completely finishes loading the level. 3D engine uses it to pre-cache some resources needed for rendering.

See Also
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::PostSerialize Method

Cleanups after save/load.

C++
virtual void PostSerialize(bool bReading) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::PrecacheCharacter Method
C++
virtual void PrecacheCharacter(IRenderNode * pObj, const float fImportance, ICharacterInstance * pCharacter, IMaterial* pSlotMat, const Matrix34& matParent, const float fEntDistance, const float fScale, int nMaxDepth, bool bForceStreamingSystemUpdate, const SRenderingPassInfo & passInfo) = 0;
Description

Activate streaming of character and all sub-components

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::PrecacheLevel Method
C++
virtual void PrecacheLevel(bool bPrecacheAllVisAreas, Vec3 * pPrecachePoints, int nPrecachePointsNum) = 0;
Description

Places camera into every visarea or every manually set pre-cache points and render the scenes.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::PrecacheRenderNode Method
C++
virtual void PrecacheRenderNode(IRenderNode * pObj, float fEntDistanceReal) = 0;
Description

Activate streaming of render node and all sub-components

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::PrepareOcclusion Method
C++
virtual void PrepareOcclusion(const CCamera & rCamera) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::PreWorldStreamUpdate Method

Prepares for the world stream update, should be called before rendering

C++
virtual void PreWorldStreamUpdate(const CCamera& cam) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ProposeContentPrecache Method
C++
virtual void ProposeContentPrecache() = 0;
Description

Proposes 3dengine to load on next frame all shaders and textures synchronously.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::RayObjectsIntersection2D Method
C++
virtual bool RayObjectsIntersection2D(Vec3 vStart, Vec3 vEnd, Vec3 & vHitPoint, EERType eERType) = 0;
Description

Used by editor during AO computations

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::RegisterEntity Method

Registers an entity to be rendered.

C++
virtual void RegisterEntity(IRenderNode * pEntity, int nSID = -1, int nSIDConsideredSafe = -1) = 0;
Parameters
Parameters 
Description 
IRenderNode * pEntity 
The entity to render 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::Release Method

Deletes the 3D Engine instance.

C++
virtual void Release() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ReleaseChunkfileContent Method
C++
virtual void ReleaseChunkfileContent(CContentCGF*) = 0;
Description

Deletes the chunkfile content instance

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ReleaseChunkFileWriter Method
C++
virtual void ReleaseChunkFileWriter(ChunkFile::IChunkFileWriter* p) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::RenderMeshRayIntersection Method
C++
virtual bool RenderMeshRayIntersection(IRenderMesh * pRenderMesh, SRayHitInfo & hitInfo, IMaterial * pCustomMtl = 0) = 0;
Description

Used by editor during object alignment

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::RenderRenderNode_ShadowPass Method
C++
virtual void RenderRenderNode_ShadowPass(IShadowCaster * pRNode, const SRenderingPassInfo & passInfo, JobManager::SJobState * pJobState) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::RenderWorld Method

Draws the world.

C++
virtual void RenderWorld(const int nRenderFlags, const SRenderingPassInfo & passInfo, const char * szDebugName) = 0;
Parameters
Parameters 
Description 
const char * szDebugName 
name that can be visualized for debugging purpose, must not be 0 
See Also

SetCamera

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ResetCoverageBufferSignalVariables Method
C++
virtual void ResetCoverageBufferSignalVariables() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ResetParticlesAndDecals Method

Removes all particles and decals from the world.

C++
virtual void ResetParticlesAndDecals() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ResetPostEffects Method
C++
virtual void ResetPostEffects(bool bOnSpecChange = false) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::RestoreTerrainFromDisk Method

Reload the heightmap.

C++
virtual bool RestoreTerrainFromDisk(int nSID = 0) = 0;
Returns

success

Description

Reloading the heightmap will resets all decals and particles. Notes: In future will restore deleted vegetations

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SampleWind Method

Gets wind direction and forace at the sample points provided.

C++
virtual bool SampleWind(Vec3* pSamples, int nSamples, const AABB& volume, bool bIndoors) const = 0;
Notes

the positions defining the samples will be overwritten with the accumulated wind influences.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SaveInternalState Method
C++
virtual void SaveInternalState(struct IDataWriteStream& writer, const AABB& filterArea, const bool bTerrain, const uint32 objectMask) = 0;
Description

LiveCreate

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SaveStatObj Method
C++
virtual int SaveStatObj(IStatObj * pStatObj, TSerialize ser) = 0;
Description

Saves pStatObj to a stream. Notes: Full mesh for generated ones, path/geom otherwise

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SelectEntity Method

Selects an entity for debugging.

C++
virtual void SelectEntity(IRenderNode * pEntity) = 0;
Parameters
Parameters 
Description 
IRenderNode * pEntity 
The entity to render 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SerializeState Method

Saves/loads state of engine objects.

C++
virtual void SerializeState(TSerialize ser) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetCoverageBufferDepthReady Method
C++
virtual void SetCoverageBufferDepthReady() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetFogColor Method

Sets the fog color.

C++
virtual void SetFogColor(const Vec3& vFogColor) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetGetLayerIdAtCallback Method

Gives 3dengine access to original and most precise heighmap data in the editor

C++
virtual void SetGetLayerIdAtCallback(IGetLayerIdAtCallback * pCallBack) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetGlobalParameter Method (E3DEngineParameter, Vec3 &)
C++
virtual void SetGlobalParameter(E3DEngineParameter param, const Vec3 & v) = 0;
Description

Sets global 3d engine parameter.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetGlobalParameter Method (E3DEngineParameter, float)
C++
void SetGlobalParameter(E3DEngineParameter param, float val);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetLevelPath Method

Sets the path used to load levels.

C++
virtual void SetLevelPath(const char * szFolderName) = 0;
Parameters
Parameters 
Description 
const char * szFolderName 
Should contains the folder to be used 
See Also
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetMaterialFloat Method
C++
virtual bool SetMaterialFloat(char * szMatName, int nSubMatId, int nTexSlot, char * szParamName, float fValue) = 0;
Description

fValue - new value

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetMaxViewDistanceScale Method

Sets the view distance scale.

C++
virtual void SetMaxViewDistanceScale(float fScale) = 0;
Parameters
Parameters 
Description 
float fScale 
may be between 0 and 1, 1.f = Unmodified view distance set by level designer, value of 0.5 will reduce it twice 
Notes 
This value will be reset automatically to 1 on next level loading. 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetOceanRenderFlags Method

Returns whether ocean volume is visible or not.

C++
virtual void SetOceanRenderFlags(uint8 nFlags) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetPhysMaterialEnumerator Method

Sets the physics material enumerator

C++
virtual void SetPhysMaterialEnumerator(IPhysMaterialEnumerator * pPhysMaterialEnumerator) = 0;
Parameters
Parameters 
Description 
IPhysMaterialEnumerator * pPhysMaterialEnumerator 
The physics material enumarator to set 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetPostEffectParam Method

Post processing effects interfaces.

C++
virtual void SetPostEffectParam(const char * pParam, float fValue, bool bForceValue = false) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetPostEffectParamString Method
C++
virtual void SetPostEffectParamString(const char * pParam, const char * pszArg) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetPostEffectParamVec4 Method
C++
virtual void SetPostEffectParamVec4(const char * pParam, const Vec4 & pValue, bool bForceValue = false) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetPrevZoomFactor Method
C++
virtual void SetPrevZoomFactor(float fZoomFactor) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetRainParams Method

Sets current rain parameters.

C++
virtual void SetRainParams(const SRainParams & rainParams) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetRecomputeStaticShadows Method
C++
virtual void SetRecomputeStaticShadows(bool bRecompute) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetRenderNodeMaterialAtPosition Method
C++
virtual void SetRenderNodeMaterialAtPosition(EERType eNodeType, const Vec3 & vPos, IMaterial * pMat) = 0;
Description

allows to modify material on render nodes at run-time (make sure it is properly restored back)

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetScreenshotCallback Method
C++
virtual void SetScreenshotCallback(IScreenshotCallback* pCallback) = 0;
Description

Set Callback for Editor to store additional information in Minimap tool

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetSegmentOperationInProgress Method
C++
virtual void SetSegmentOperationInProgress(bool bActive) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetSegmentsManager Method
C++
virtual void SetSegmentsManager(ISegmentsManager * pSegmentsManager) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetShadowMode Method
C++
virtual void SetShadowMode(EShadowMode shadowMode) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetShadowsGSMCache Method
C++
virtual void SetShadowsGSMCache(bool bCache) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetSkyBrightness Method

Sets the current sky brightening multiplier.

C++
virtual void SetSkyBrightness(float fMul) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetSkyColor Method

Sets the current outdoor ambient color.

C++
virtual void SetSkyColor(Vec3 vColor) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetSkyLightParameters Method

Sets various sky light parameters.

C++
virtual void SetSkyLightParameters(const Vec3& sunDir, const Vec3& sunIntensity, float Km, float Kr, float g, const Vec3& rgbWaveLengths, bool forceImmediateUpdate = false) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetSnowFallParams Method

Sets current snow parameters.

C++
virtual void SetSnowFallParams(int nSnowFlakeCount, float fSnowFlakeSize, float fSnowFallBrightness, float fSnowFallGravityScale, float fSnowFallWindScale, float fSnowFallTurbulence, float fSnowFallTurbulenceFreq) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetSnowSurfaceParams Method

Sets current snow surface parameters.

C++
virtual void SetSnowSurfaceParams(const Vec3 & vCenter, float fRadius, float fSnowAmount, float fFrostAmount, float fSurfaceFreezing) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetStaticShadowBounds Method
C++
virtual void SetStaticShadowBounds(const AABB& shadowBounds) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetStreamableListener Method
C++
virtual void SetStreamableListener(IStreamedObjectListener* pListener) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetSunColor Method

Sets the current sun color.

C++
virtual void SetSunColor(Vec3 vColor) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetTerrainLayerBaseTextureData Method
C++
virtual void SetTerrainLayerBaseTextureData(int nLayerId, byte* pImage, int nDim, const char * nImgFileName, IMaterial * pMat, float fBr, float fTiling, int nDetailSurfTypeId, float fTilingDetail, float fSpecularAmount, float fSortOrder, ColorF layerFilterColor, float fUseRemeshing, bool bShowSelection) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetWind Method

Set global wind vector.

C++
virtual void SetWind(const Vec3 & vWind) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SetZoomMode Method
C++
virtual void SetZoomMode(int nZoomMode) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ShutDown Method

Shuts down the 3D Engine.

C++
virtual void ShutDown() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SkipLayerLoading Method
C++
virtual void SkipLayerLoading(uint16 nLayerId, bool bClearList) = 0;
Description

Collect layer ID's to skip loading objects from these layers, e.g. to skip console specific layers

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SyncOctreeUpdate Method

Sync all changes to the octree to prevent reading data which is about to be changed

C++
virtual void SyncOctreeUpdate(IRenderNode* pEnt = NULL) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::SyncProcessStreamingUpdate Method
C++
virtual void SyncProcessStreamingUpdate() = 0;
Description

Syncs and performs outstanding operations for the Asyncrhon ProcessStreaming Update

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::Tick Method

clear all per frame temp data used in SRenderingPass

C++
virtual void Tick() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::ToggelAsyncOctreeUpdates Method
C++
virtual bool ToggelAsyncOctreeUpdates(bool) = 0;
Description

Enable/Disable octree updates in a seperate thread

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::TraceFogVolumes Method
C++
virtual void TraceFogVolumes(const Vec3& worldPos, ColorF& fogVolumeContrib, const SRenderingPassInfo & passInfo) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::UnloadLevel Method

Clears all rendering resources, all objects, characters and materials, voxels and terrain. Notes: Should always be called before LoadLevel, and also before loading textures from a script.

C++
virtual void UnloadLevel() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::UnlockCGFResources Method

Enables CGFs unloading (this is default state), this function will also release all not used CGF's.

C++
virtual void UnlockCGFResources() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::UnRegisterEntityAsJob Method
C++
virtual void UnRegisterEntityAsJob(IRenderNode* pEnt) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::UnRegisterEntityDirect Method

Notices the 3D Engine to stop rendering a specified entity.

C++
virtual void UnRegisterEntityDirect(IRenderNode * pEntity) = 0;
Parameters
Parameters 
Description 
IRenderNode * pEntity 
The entity to stop render 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::Update Method

Updates the 3D Engine. Notes: Should be called for every frame.

C++
virtual void Update() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::UpdateDeformableStatObj Method

Updates rendering mesh in the stat obj associated with pPhysGeom. Notes: Creates or clones the object if necessary.

C++
virtual IStatObj * UpdateDeformableStatObj(IGeometry * pPhysGeom, bop_meshupdate * pLastUpdate = 0, IFoliage * pSrcFoliage = 0) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::UpdateShaderItems Method

Update all ShaderItems flags, only required after shaders were reloaded at runtime

C++
virtual void UpdateShaderItems() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::UpdateVisArea Method

Updates the VisArea

C++
virtual void UpdateVisArea(IVisArea * pArea, const Vec3 * pPoints, int nCount, const char * szName, const SVisAreaInfo & info, bool bReregisterObjects) = 0;
Parameters
Parameters 
Description 
IVisArea * pArea 
pPoints - 
int nCount 
szName - 
const SVisAreaInfo & info 
bReregisterObjects - 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::Voxel_GetObjects Method
C++
virtual IMemoryBlock * Voxel_GetObjects(Vec3 vPos, float fRadius, int nSurfaceTypeId, EVoxelEditOperation eOperation, EVoxelBrushShape eShape, EVoxelEditTarget eTarget) = 0;
Description

Gets list of voxel objects that will be affected by paint operation, IMemoryBlock will contain array of IVoxelObject pointers.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::Voxel_Paint Method

Paints voxel shape.

C++
virtual void Voxel_Paint(Vec3 vPos, float fRadius, int nSurfaceTypeId, Vec3 vBaseColor, EVoxelEditOperation eOperation, EVoxelBrushShape eShape, EVoxelEditTarget eTarget, PodArray<IRenderNode*> * pBrushes, float fMinVoxelSize) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::Voxel_SetFlags Method

Setups voxel flags.

C++
virtual void Voxel_SetFlags(bool bPhysics, bool bSimplify, bool bShadows, bool bMaterials) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::I3DEngine::WorldStreamUpdate Method

Performs the actual world streaming update. PreWorldStreamUpdate must be called before

C++
virtual void WorldStreamUpdate() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage Structure
C++
struct IFoliage {
  enum EFoliageFlags {
    FLAG_FROZEN = 1
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::EFoliageFlags Enumeration
C++
enum EFoliageFlags {
  FLAG_FROZEN = 1
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::~IFoliage Destructor
C++
virtual ~IFoliage();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::AddRef Method
C++
virtual void AddRef() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::GetBranchCount Method
C++
virtual int GetBranchCount() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::GetBranchPhysics Method
C++
virtual IPhysicalEntity * GetBranchPhysics(int iBranch) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::GetFlags Method
C++
virtual int GetFlags() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::GetIRenderNode Method
C++
virtual IRenderNode* GetIRenderNode() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::GetSkinningData Method
C++
virtual SSkinningData* GetSkinningData(const Matrix34& RenderMat34, const SRenderingPassInfo & passInfo) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::Release Method
C++
virtual void Release() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::Serialize Method
C++
virtual int Serialize(TSerialize ser) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IFoliage::SetFlags Method
C++
virtual void SetFlags(int flags) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager Structure

Manages simple pre-merged mesh instances into pre-baked sectors

C++
struct IMergedMeshesManager {
  struct SInstanceSector {
    DynArray<uint8> data;
    string id;
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::SInstanceSector Structure
C++
struct SInstanceSector {
  DynArray<uint8> data;
  string id;
};
File

I3DEngine.h

Members
Members 
Description 
DynArray<uint8> data; 
memory stream of internally compiled data 
string id; 
unique identifier string identifing this sector 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::~IMergedMeshesManager Destructor
C++
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::CompileSectors Method

Returns the compiled instance sectors as a null-terminated pointer array. Returns false on error.

C++
virtual bool CompileSectors(DynArray<SInstanceSector>& pSectors, std::vector<struct IStatInstGroup*> * pVegGroupTable) = 0;
Description

Compilation

Notes

The caller is responsible for freeing the allocated memory (both the array and the sectors)

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::CurrentSizeInMainMem Method

Returns the current memory footprint in main memory (the accumulated footprint of all merged instances)

C++
virtual size_t CurrentSizeInMainMem() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::CurrentSizeInVram Method

Returns the current memory footprint in vram (accumulated vertex and indexbuffer size in bytes)

C++
virtual size_t CurrentSizeInVram() const = 0;
Description

Statistics

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::GeomSizeInMainMem Method

Returns the memory footprint of the prebaked geometry in bytes

C++
virtual size_t GeomSizeInMainMem() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::GetCompiledData Method
C++
virtual bool GetCompiledData(uint32 index, byte * pData, int nSize, string * pName, std::vector<struct IStatInstGroup*> ** ppStatInstGroupTable, const Vec3 & segmentOffset) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::GetCompiledDataSize Method
C++
virtual int GetCompiledDataSize(uint32 index) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::GetSegmentNodeCount Method
C++
virtual int GetSegmentNodeCount() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::GetUsedMeshes Method

Returns the list of merged mesh geometry currently active. Returns false on error.

C++
virtual bool GetUsedMeshes(DynArray<string>& pMeshNames) = 0;
Description

Compilation

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::InstanceCount Method

The instance count

C++
virtual size_t InstanceCount() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::InstanceSize Method

Returns the size of the instance map in bytes

C++
virtual size_t InstanceSize() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::PrepareSegmentData Method
C++
virtual void PrepareSegmentData(const AABB & aabb) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::SpineSize Method

Returns the size of animated instances if they have spines

C++
virtual size_t SpineSize() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IMergedMeshesManager::VisibleInstances Method

The number of visible instances last frame

C++
virtual size_t VisibleInstances() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IScreenshotCallback Structure
C++
struct IScreenshotCallback {
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IScreenshotCallback::~IScreenshotCallback Destructor
C++
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IScreenshotCallback::SendParameters Method
C++
virtual void SendParameters(void* data, uint32 width, uint32 height, f32 minx, f32 miny, f32 maxx, f32 maxy) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager Structure
C++
struct ISegmentsManager {
  enum ESegmentLoadFlags {
    slfTerrain = BIT(1),
    slfVisArea = BIT(2),
    slfEntity = BIT(3),
    slfNavigation = BIT(4),
    slfAll = slfTerrain|slfVisArea|slfEntity|slfNavigation
  };
};
File

I3DEngine.h

Description

callbacks interface for higher level segments management

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::ESegmentLoadFlags Enumeration
C++
enum ESegmentLoadFlags {
  slfTerrain = BIT(1),
  slfVisArea = BIT(2),
  slfEntity = BIT(3),
  slfNavigation = BIT(4),
  slfAll = slfTerrain|slfVisArea|slfEntity|slfNavigation
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::~ISegmentsManager Destructor
C++
virtual ~ISegmentsManager();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::CreateSegments Method
C++
virtual bool CreateSegments(ITerrain * pTerrain) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::DeleteSegments Method
C++
virtual bool DeleteSegments(ITerrain * pTerrain) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::FindSegment Method
C++
virtual bool FindSegment(ITerrain * pTerrain, const Vec3 & pt, int & nSID) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::FindSegmentCoordByID Method
C++
virtual bool FindSegmentCoordByID(int nSID, int & x, int & y) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::ForceLoadSegments Method
C++
virtual void ForceLoadSegments(unsigned int flags) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::GetSegmentSizeInMeters Method
C++
virtual int GetSegmentSizeInMeters() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::GetTerrainSizeInMeters Method
C++
virtual void GetTerrainSizeInMeters(int & x, int & y) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::GlobalSegVecToLocalSegVec Method
C++
virtual void GlobalSegVecToLocalSegVec(const Vec3 & inPos, const Vec2 & inAbsCoords, Vec3 & outPos) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::LocalToAbsolutePosition Method
C++
virtual Vec3 LocalToAbsolutePosition(Vec3 const& vPos, f32 fDir = 1.f) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::PushEntityToSegment Method
C++
virtual bool PushEntityToSegment(unsigned int id, bool bLocal = true) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::WorldVecToGlobalSegVec Method
C++
virtual void WorldVecToGlobalSegVec(const Vec3 & inPos, Vec3 & outPos, Vec2 & outAbsCoords) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ISegmentsManager::WorldVecToLocalSegVec Method
C++
virtual Vec3 WorldVecToLocalSegVec(const Vec3 & inPos) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IStreamedObjectListener Class
Class Hierarchy
C++
class IStreamedObjectListener;
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IStreamedObjectListener::~IStreamedObjectListener Destructor
C++
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IStreamedObjectListener::OnBegunUsingStreamedObjects Method
C++
virtual void OnBegunUsingStreamedObjects(void** pHandles, size_t numHandles) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IStreamedObjectListener::OnCreatedStreamedObject Method
C++
virtual void OnCreatedStreamedObject(const char* filename, void* pHandle) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IStreamedObjectListener::OnDestroyedStreamedObject Method
C++
virtual void OnDestroyedStreamedObject(void* pHandle) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IStreamedObjectListener::OnEndedUsingStreamedObjects Method
C++
virtual void OnEndedUsingStreamedObjects(void** pHandles, size_t numHandles) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IStreamedObjectListener::OnReceivedStreamedObject Method
C++
virtual void OnReceivedStreamedObject(void* pHandle) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IStreamedObjectListener::OnRequestedStreamedObject Method
C++
virtual void OnRequestedStreamedObject(void* pHandle) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IStreamedObjectListener::OnUnloadedStreamedObject Method
C++
virtual void OnUnloadedStreamedObject(void* pHandle) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain Structure
C++
struct ITerrain {
  struct SExportInfo {
    bool bHeigtmap;
    bool bObjects;
    AABB areaBox;
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SExportInfo Structure
C++
struct SExportInfo {
  bool bHeigtmap;
  bool bObjects;
  AABB areaBox;
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SExportInfo::areaBox Data Member
C++
AABB areaBox;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SExportInfo::bHeigtmap Data Member
C++
bool bHeigtmap;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SExportInfo::bObjects Data Member
C++
bool bObjects;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SExportInfo::SExportInfo Constructor
C++
SExportInfo();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::~ITerrain Destructor
C++
virtual ~ITerrain();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::AddVegetationInstance Method

Creates and place a new vegetation object on the terrain.

C++
virtual IRenderNode* AddVegetationInstance(int nStaticGroupID, const Vec3 & vPos, const float fScale, uint8 ucBright, uint8 angle, uint8 angleX = 0, uint8 angleY = 0, int nSID = DEFAULT_SID) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::CancelStreamCompiledData Method
C++
virtual void CancelStreamCompiledData(int nSID) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::CanPaintSurfaceType Method

Checks if it is possible to paint on the terrain with a given surface type ID. Notes: Should be called by the editor to avoid overflowing the sector surface type palettes.

C++
virtual bool CanPaintSurfaceType(int x, int y, int r, uint16 usGlobalSurfaceType) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::CreateSegment Method
C++
virtual int CreateSegment(Vec3 vSegmentSize, Vec3 vSegmentOrigin = Vec3(0, 0, 0), const char * pcPath = 0) = 0;
Description

Allocate new world segment Returns handle of newly created segment (usually it is just id of segment in the list of currently loaded segments)

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::DeleteSegment Method
C++
virtual bool DeleteSegment(int nSID, bool bDeleteNow) = 0;
Description

Set new origin for existing world segment Returns true if specified segment was found and successfully deleted

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::FindSegment Method (Vec3)
C++
virtual int FindSegment(Vec3 vPt) = 0;
Description

Find (first) world segment containing given point (in local world coordinates) Returns id of the found segment or -1 if not found

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::FindSegment Method (int, int)
C++
virtual int FindSegment(int x, int y) = 0;
Description

Find (first) world segment containing given point (in heightmap coordinates) Returns id of the found segment or -1 if not found

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetCompiledData Method

Saves data from terrain engine into memory block.

C++
virtual bool GetCompiledData(byte * pData, int nDataSize, std::vector<struct IStatObj*> ** ppStatObjTable, std::vector<IMaterial*> ** ppMatTable, std::vector<struct IStatInstGroup*> ** ppStatInstGroupTable, EEndian eEndian, SHotUpdateInfo * pExportInfo = NULL, int nSID = 0, const Vec3 & segmentOffset = Vec3(0, 0, 0)) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetCompiledDataSize Method

Returns terrain data memory block size.

C++
virtual int GetCompiledDataSize(SHotUpdateInfo * pExportInfo = NULL, int nSID = 0) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetDetailTextureMaterials Method

Return number of used detail texture materials Fills materials array if materials!=NULL

C++
virtual int GetDetailTextureMaterials(IMaterial* materials[], int nSID = 0) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetMaxSegmentsCount Method
C++
virtual int GetMaxSegmentsCount() const = 0;
Description

Returns a number bigger than the last valid segment ID to be used in loops like: for (int nSID = 0; nSID < GetMaxSegmentsCount(); ++nSID)

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetNotReadyTextureNodesCount Method

Returns current amount of terrain textures requests for streaming, if more than 0 = there is streaming in progress.

C++
virtual int GetNotReadyTextureNodesCount() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetResourceMemoryUsage Method

Retrieves the resource (mostly texture system memory) memory usage for a given region of the terrain.

C++
virtual void GetResourceMemoryUsage(ICrySizer* pSizer, const AABB& crstAABB, int nSID = 0) = 0;
Parameters
Parameters 
Description 
ICrySizer* pSizer 
Is a pointer to an instance of the CrySizer object. The purpose of this object is making sure each element is accounted only once. 
const AABB& crstAABB 
Is a reference to the bounding box in which region we want to analyze the resources. 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetSegmentBounds Method
C++
virtual bool GetSegmentBounds(int nSID, AABB & bbox) = 0;
Description

fills bbox with the bounding box of the specified segment (nSID) Returns true if succeeded, false if nSID is not valid segment id

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetSegmentOrigin Method (int)
C++
virtual Vec3 GetSegmentOrigin(int nSID) = 0;
Description

Returns the segment origin of the given segment id.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetSegmentOrigin Method (int)
C++
virtual const Vec3 & GetSegmentOrigin(int nSID) const = 0;
Description

Get origin for existing world segment, really. Returns Vec3 with position or NaNs if segment ID is invalid

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetSegmentPath Method
C++
virtual const char* GetSegmentPath(int nSID) = 0;
Description

Returns a pointer to the segment file path

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetTables Method
C++
virtual void GetTables(std::vector<struct IStatObj*> *& pStatObjTable, std::vector<IMaterial*> *& pMatTable, std::vector<struct IStatInstGroup*> *& pStatInstGroupTable, int nSID) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetTablesSize Method
C++
virtual int GetTablesSize(SHotUpdateInfo * pExportInfo, int nSID) = 0;
Description

virtual bool LoadTables(byte * & f, int & nDataSize, std::vector*& pStatObjTable, std::vector*& pMatTable, bool bHotUpdate, bool bSW, EEndian eEndian) = 0;

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::GetTerrainLightmapTexId Method

Returns whole terrain lightmap texture id.

C++
virtual int GetTerrainLightmapTexId(Vec4 & vTexGenInfo, int nSID = 0) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::ReleaseInactiveSegments Method
C++
virtual void ReleaseInactiveSegments() = 0;
Description

Deallocate segment data in the deleted array

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::ReleaseTables Method
C++
virtual void ReleaseTables(std::vector<struct IStatObj*> *& pStatObjTable, std::vector<IMaterial*> *& pMatTable, std::vector<struct IStatInstGroup*> *& pStatInstGroupTable) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SaveTables Method
C++
virtual void SaveTables(byte *& pData, int & nDataSize, std::vector<struct IStatObj*> *& pStatObjTable, std::vector<IMaterial*> *& pMatTable, std::vector<struct IStatInstGroup*> *& pStatInstGroupTable, EEndian eEndian, SHotUpdateInfo * pExportInfo, int nSID) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SetCompiledData Method

Loads data into terrain engine from memory block.

C++
virtual bool SetCompiledData(byte * pData, int nDataSize, std::vector<struct IStatObj*> ** ppStatObjTable, std::vector<IMaterial*> ** ppMatTable, bool bHotUpdate = false, SHotUpdateInfo * pExportInfo = NULL, int nSID = 0, Vec3 vSegmentOrigin = Vec3(0,0,0)) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SetOceanWaterLevel Method

Sets ocean level.

C++
virtual void SetOceanWaterLevel(float fOceanWaterLevel) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SetSegmentOrigin Method
C++
virtual bool SetSegmentOrigin(int nSID, Vec3 vSegmentOrigin, bool callOffsetPosition = true) = 0;
Description

Set new origin for existing world segment Returns true if specified segment exist and origin was successfully updated

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SetSegmentPath Method
C++
virtual bool SetSegmentPath(int nSID, const char * pcPath) = 0;
Description

Changes the segment file path Returns true if specified segment exist and path was successfully updated

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::SetTerrainElevation Method

Updates part of height map. Notes: x1, y1, nSizeX, nSizeY are in terrain units pTerrainBlock points to a square 2D array with dimensions GetTerrainSize() by default update only elevation.

C++
virtual void SetTerrainElevation(int x1, int y1, int nSizeX, int nSizeY, float * pTerrainBlock, uint8 * pSurfaceData, int nSurfOrgX, int nSurfOrgY, int nSurfSizeX, int nSurfSizeY, uint32 * pResolMap, int nResolMapSizeX, int nResolMapSizeY, int nSID = DEFAULT_SID) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::StreamCompiledData Method

Executes one step of streaming the compiled data in pData. Returns false when the streaming is complete, true if there is still work to do. You should call this until it returns true.

C++
virtual bool StreamCompiledData(byte* pData, int nDataSize, int nSID, const Vec3 & vSegmentOrigin) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::WorldToSegment Method (Vec3 &, int)
C++
virtual int WorldToSegment(Vec3 & vPt, int nSID = DEFAULT_SID) = 0;
Description

if nSID < 0 finds segment containing vPt (in local world coordinates) and adjusts vPt to be relative to segment's origin if nSID >= 0 does nothing Returns id of the found segment or -1 if not found

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITerrain::WorldToSegment Method (int &, int &, int, int)
C++
virtual int WorldToSegment(int & x, int & y, int nBitShift, int nSID = DEFAULT_SID) = 0;
Description

if nSID < 0 finds segment containing given point on input, (x << nBitShift, y << nBitShift) represents a point in local world coordinates on output, x and y are adjusted to be relative to found segment if nSID >= 0 does nothing Returns id of the found segment or -1 if not found

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay Structure

Interface to the Time Of Day functionality.

C++
struct ITimeOfDay {
  enum ETimeOfDayParamID {
    PARAM_HDR_DYNAMIC_POWER_FACTOR,
    PARAM_TERRAIN_OCCL_MULTIPLIER,
    PARAM_GI_MULTIPLIER,
    PARAM_SUN_COLOR,
    PARAM_SUN_COLOR_MULTIPLIER,
    PARAM_SUN_SPECULAR_MULTIPLIER,
    PARAM_FOG_COLOR,
    PARAM_FOG_COLOR_MULTIPLIER,
    PARAM_VOLFOG_HEIGHT,
    PARAM_VOLFOG_DENSITY,
    PARAM_FOG_COLOR2,
    PARAM_FOG_COLOR2_MULTIPLIER,
    PARAM_VOLFOG_HEIGHT2,
    PARAM_VOLFOG_DENSITY2,
    PARAM_VOLFOG_HEIGHT_OFFSET,
    PARAM_FOG_RADIAL_COLOR,
    PARAM_FOG_RADIAL_COLOR_MULTIPLIER,
    PARAM_VOLFOG_RADIAL_SIZE,
    PARAM_VOLFOG_RADIAL_LOBE,
    PARAM_VOLFOG_FINAL_DENSITY_CLAMP,
    PARAM_VOLFOG_GLOBAL_DENSITY,
    PARAM_VOLFOG_RAMP_START,
    PARAM_VOLFOG_RAMP_END,
    PARAM_VOLFOG_RAMP_INFLUENCE,
    PARAM_VOLFOG_SHADOW_DARKENING,
    PARAM_VOLFOG_SHADOW_DARKENING_SUN,
    PARAM_VOLFOG_SHADOW_DARKENING_AMBIENT,
    PARAM_VOLFOG_SHADOW_RANGE,
    PARAM_SKYLIGHT_SUN_INTENSITY,
    PARAM_SKYLIGHT_SUN_INTENSITY_MULTIPLIER,
    PARAM_SKYLIGHT_KM,
    PARAM_SKYLIGHT_KR,
    PARAM_SKYLIGHT_G,
    PARAM_SKYLIGHT_WAVELENGTH_R,
    PARAM_SKYLIGHT_WAVELENGTH_G,
    PARAM_SKYLIGHT_WAVELENGTH_B,
    PARAM_NIGHSKY_HORIZON_COLOR,
    PARAM_NIGHSKY_HORIZON_COLOR_MULTIPLIER,
    PARAM_NIGHSKY_ZENITH_COLOR,
    PARAM_NIGHSKY_ZENITH_COLOR_MULTIPLIER,
    PARAM_NIGHSKY_ZENITH_SHIFT,
    PARAM_NIGHSKY_START_INTENSITY,
    PARAM_NIGHSKY_MOON_COLOR,
    PARAM_NIGHSKY_MOON_COLOR_MULTIPLIER,
    PARAM_NIGHSKY_MOON_INNERCORONA_COLOR,
    PARAM_NIGHSKY_MOON_INNERCORONA_COLOR_MULTIPLIER,
    PARAM_NIGHSKY_MOON_INNERCORONA_SCALE,
    PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR,
    PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR_MULTIPLIER,
    PARAM_NIGHSKY_MOON_OUTERCORONA_SCALE,
    PARAM_CLOUDSHADING_SUNLIGHT_MULTIPLIER,
    PARAM_CLOUDSHADING_SKYLIGHT_MULTIPLIER,
    PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR,
    PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_MULTIPLIER,
    PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_INFLUENCE,
    PARAM_SUN_SHAFTS_VISIBILITY,
    PARAM_SUN_RAYS_VISIBILITY,
    PARAM_SUN_RAYS_ATTENUATION,
    PARAM_SUN_RAYS_SUNCOLORINFLUENCE,
    PARAM_SUN_RAYS_CUSTOMCOLOR,
    PARAM_OCEANFOG_COLOR,
    PARAM_OCEANFOG_COLOR_MULTIPLIER,
    PARAM_OCEANFOG_DENSITY,
    PARAM_SKYBOX_MULTIPLIER,
    PARAM_HDR_FILMCURVE_SHOULDER_SCALE,
    PARAM_HDR_FILMCURVE_LINEAR_SCALE,
    PARAM_HDR_FILMCURVE_TOE_SCALE,
    PARAM_HDR_FILMCURVE_WHITEPOINT,
    PARAM_HDR_COLORGRADING_COLOR_SATURATION,
    PARAM_HDR_COLORGRADING_COLOR_BALANCE,
    PARAM_HDR_EYEADAPTATION_SCENEKEY,
    PARAM_HDR_EYEADAPTATION_MIN_EXPOSURE,
    PARAM_HDR_EYEADAPTATION_MAX_EXPOSURE,
    PARAM_HDR_BLOOM_AMOUNT,
    PARAM_COLORGRADING_FILTERS_GRAIN,
    PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR,
    PARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY,
    PARAM_COLORGRADING_DOF_FOCUSRANGE,
    PARAM_COLORGRADING_DOF_BLURAMOUNT,
    PARAM_SHADOWSC0_BIAS,
    PARAM_SHADOWSC0_SLOPE_BIAS,
    PARAM_SHADOWSC1_BIAS,
    PARAM_SHADOWSC1_SLOPE_BIAS,
    PARAM_SHADOWSC2_BIAS,
    PARAM_SHADOWSC2_SLOPE_BIAS,
    PARAM_SHADOWSC3_BIAS,
    PARAM_SHADOWSC3_SLOPE_BIAS,
    PARAM_SHADOWSC4_BIAS,
    PARAM_SHADOWSC4_SLOPE_BIAS,
    PARAM_SHADOWSC5_BIAS,
    PARAM_SHADOWSC5_SLOPE_BIAS,
    PARAM_SHADOWSC6_BIAS,
    PARAM_SHADOWSC6_SLOPE_BIAS,
    PARAM_SHADOWSC7_BIAS,
    PARAM_SHADOWSC7_SLOPE_BIAS,
    PARAM_SHADOW_JITTERING,
    PARAM_TOTAL
  };
  enum EVariableType {
    TYPE_FLOAT,
    TYPE_COLOR
  };
  struct SVariableInfo {
    const char * name;
    const char * displayName;
    const char * group;
    int nParamId;
    EVariableType type;
    float fValue[3];
    ISplineInterpolator* pInterpolator;
    unsigned int bSelected : 1;
  };
  struct SAdvancedInfo {
    float fStartTime;
    float fEndTime;
    float fAnimSpeed;
  };
  struct SEnvironmentInfo {
    bool bSunLinkedToTOD;
    float sunRotationLatitude;
    float sunRotationLongitude;
  };
  const int NETSER_FORCESET = BIT(0);
  const int NETSER_COMPENSATELAG = BIT(1);
  const int NETSER_STATICPROPS = BIT(2);
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::ETimeOfDayParamID Enumeration
C++
enum ETimeOfDayParamID {
  PARAM_HDR_DYNAMIC_POWER_FACTOR,
  PARAM_TERRAIN_OCCL_MULTIPLIER,
  PARAM_GI_MULTIPLIER,
  PARAM_SUN_COLOR,
  PARAM_SUN_COLOR_MULTIPLIER,
  PARAM_SUN_SPECULAR_MULTIPLIER,
  PARAM_FOG_COLOR,
  PARAM_FOG_COLOR_MULTIPLIER,
  PARAM_VOLFOG_HEIGHT,
  PARAM_VOLFOG_DENSITY,
  PARAM_FOG_COLOR2,
  PARAM_FOG_COLOR2_MULTIPLIER,
  PARAM_VOLFOG_HEIGHT2,
  PARAM_VOLFOG_DENSITY2,
  PARAM_VOLFOG_HEIGHT_OFFSET,
  PARAM_FOG_RADIAL_COLOR,
  PARAM_FOG_RADIAL_COLOR_MULTIPLIER,
  PARAM_VOLFOG_RADIAL_SIZE,
  PARAM_VOLFOG_RADIAL_LOBE,
  PARAM_VOLFOG_FINAL_DENSITY_CLAMP,
  PARAM_VOLFOG_GLOBAL_DENSITY,
  PARAM_VOLFOG_RAMP_START,
  PARAM_VOLFOG_RAMP_END,
  PARAM_VOLFOG_RAMP_INFLUENCE,
  PARAM_VOLFOG_SHADOW_DARKENING,
  PARAM_VOLFOG_SHADOW_DARKENING_SUN,
  PARAM_VOLFOG_SHADOW_DARKENING_AMBIENT,
  PARAM_VOLFOG_SHADOW_RANGE,
  PARAM_SKYLIGHT_SUN_INTENSITY,
  PARAM_SKYLIGHT_SUN_INTENSITY_MULTIPLIER,
  PARAM_SKYLIGHT_KM,
  PARAM_SKYLIGHT_KR,
  PARAM_SKYLIGHT_G,
  PARAM_SKYLIGHT_WAVELENGTH_R,
  PARAM_SKYLIGHT_WAVELENGTH_G,
  PARAM_SKYLIGHT_WAVELENGTH_B,
  PARAM_NIGHSKY_HORIZON_COLOR,
  PARAM_NIGHSKY_HORIZON_COLOR_MULTIPLIER,
  PARAM_NIGHSKY_ZENITH_COLOR,
  PARAM_NIGHSKY_ZENITH_COLOR_MULTIPLIER,
  PARAM_NIGHSKY_ZENITH_SHIFT,
  PARAM_NIGHSKY_START_INTENSITY,
  PARAM_NIGHSKY_MOON_COLOR,
  PARAM_NIGHSKY_MOON_COLOR_MULTIPLIER,
  PARAM_NIGHSKY_MOON_INNERCORONA_COLOR,
  PARAM_NIGHSKY_MOON_INNERCORONA_COLOR_MULTIPLIER,
  PARAM_NIGHSKY_MOON_INNERCORONA_SCALE,
  PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR,
  PARAM_NIGHSKY_MOON_OUTERCORONA_COLOR_MULTIPLIER,
  PARAM_NIGHSKY_MOON_OUTERCORONA_SCALE,
  PARAM_CLOUDSHADING_SUNLIGHT_MULTIPLIER,
  PARAM_CLOUDSHADING_SKYLIGHT_MULTIPLIER,
  PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR,
  PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_MULTIPLIER,
  PARAM_CLOUDSHADING_SUNLIGHT_CUSTOM_COLOR_INFLUENCE,
  PARAM_SUN_SHAFTS_VISIBILITY,
  PARAM_SUN_RAYS_VISIBILITY,
  PARAM_SUN_RAYS_ATTENUATION,
  PARAM_SUN_RAYS_SUNCOLORINFLUENCE,
  PARAM_SUN_RAYS_CUSTOMCOLOR,
  PARAM_OCEANFOG_COLOR,
  PARAM_OCEANFOG_COLOR_MULTIPLIER,
  PARAM_OCEANFOG_DENSITY,
  PARAM_SKYBOX_MULTIPLIER,
  PARAM_HDR_FILMCURVE_SHOULDER_SCALE,
  PARAM_HDR_FILMCURVE_LINEAR_SCALE,
  PARAM_HDR_FILMCURVE_TOE_SCALE,
  PARAM_HDR_FILMCURVE_WHITEPOINT,
  PARAM_HDR_COLORGRADING_COLOR_SATURATION,
  PARAM_HDR_COLORGRADING_COLOR_BALANCE,
  PARAM_HDR_EYEADAPTATION_SCENEKEY,
  PARAM_HDR_EYEADAPTATION_MIN_EXPOSURE,
  PARAM_HDR_EYEADAPTATION_MAX_EXPOSURE,
  PARAM_HDR_BLOOM_AMOUNT,
  PARAM_COLORGRADING_FILTERS_GRAIN,
  PARAM_COLORGRADING_FILTERS_PHOTOFILTER_COLOR,
  PARAM_COLORGRADING_FILTERS_PHOTOFILTER_DENSITY,
  PARAM_COLORGRADING_DOF_FOCUSRANGE,
  PARAM_COLORGRADING_DOF_BLURAMOUNT,
  PARAM_SHADOWSC0_BIAS,
  PARAM_SHADOWSC0_SLOPE_BIAS,
  PARAM_SHADOWSC1_BIAS,
  PARAM_SHADOWSC1_SLOPE_BIAS,
  PARAM_SHADOWSC2_BIAS,
  PARAM_SHADOWSC2_SLOPE_BIAS,
  PARAM_SHADOWSC3_BIAS,
  PARAM_SHADOWSC3_SLOPE_BIAS,
  PARAM_SHADOWSC4_BIAS,
  PARAM_SHADOWSC4_SLOPE_BIAS,
  PARAM_SHADOWSC5_BIAS,
  PARAM_SHADOWSC5_SLOPE_BIAS,
  PARAM_SHADOWSC6_BIAS,
  PARAM_SHADOWSC6_SLOPE_BIAS,
  PARAM_SHADOWSC7_BIAS,
  PARAM_SHADOWSC7_SLOPE_BIAS,
  PARAM_SHADOW_JITTERING,
  PARAM_TOTAL
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::EVariableType Enumeration
C++
enum EVariableType {
  TYPE_FLOAT,
  TYPE_COLOR
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SAdvancedInfo Structure
C++
struct SAdvancedInfo {
  float fStartTime;
  float fEndTime;
  float fAnimSpeed;
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SEnvironmentInfo Structure
C++
struct SEnvironmentInfo {
  bool bSunLinkedToTOD;
  float sunRotationLatitude;
  float sunRotationLongitude;
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SEnvironmentInfo::bSunLinkedToTOD Data Member
C++
bool bSunLinkedToTOD;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SEnvironmentInfo::sunRotationLatitude Data Member
C++
float sunRotationLatitude;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SEnvironmentInfo::sunRotationLongitude Data Member
C++
float sunRotationLongitude;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SEnvironmentInfo::SEnvironmentInfo Constructor
C++
SEnvironmentInfo();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SVariableInfo Structure
C++
struct SVariableInfo {
  const char * name;
  const char * displayName;
  const char * group;
  int nParamId;
  EVariableType type;
  float fValue[3];
  ISplineInterpolator* pInterpolator;
  unsigned int bSelected : 1;
};
File

I3DEngine.h

Members
Members 
Description 
const char * name; 
Variable name. 
const char * displayName; 
Variable user readable name. 
const char * group; 
Group name. 
float fValue[3]; 
Value of the variable (3 needed for color type) 
ISplineInterpolator* pInterpolator; 
Splines that control variable value 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::NETSER_COMPENSATELAG Data Member
C++
const int NETSER_COMPENSATELAG = BIT(1);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::NETSER_FORCESET Data Member
C++
const int NETSER_FORCESET = BIT(0);
Description

MP serialization

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::NETSER_STATICPROPS Data Member
C++
const int NETSER_STATICPROPS = BIT(2);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::~ITimeOfDay Destructor
C++
virtual ~ITimeOfDay();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::BeginEditMode Method
C++
virtual void BeginEditMode() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::EndEditMode Method
C++
virtual void EndEditMode() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::GetAdvancedInfo Method
C++
virtual void GetAdvancedInfo(SAdvancedInfo & advInfo) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::GetSunLatitude Method
C++
virtual float GetSunLatitude() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::GetSunLongitude Method
C++
virtual float GetSunLongitude() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::GetTime Method
C++
virtual float GetTime() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::GetVariableCount Method
C++
virtual int GetVariableCount() = 0;
Description

Access to variables that control time of the day appearance.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::GetVariableInfo Method
C++
virtual bool GetVariableInfo(int nIndex, SVariableInfo & varInfo) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::LoadInternalState Method
C++
virtual void LoadInternalState(struct IDataReadStream& reader) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::NetSerialize Method
C++
virtual void NetSerialize(TSerialize ser, float lag, uint32 flags) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::ResetVariables Method
C++
virtual void ResetVariables() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SaveInternalState Method
C++
virtual void SaveInternalState(struct IDataWriteStream& writer) = 0;
Description

LiveCreate

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::Serialize Method (TSerialize)
C++
virtual void Serialize(TSerialize ser) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::Serialize Method (XmlNodeRef &, bool)
C++
virtual void Serialize(XmlNodeRef & node, bool bLoading) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SetAdvancedInfo Method
C++
virtual void SetAdvancedInfo(const SAdvancedInfo & advInfo) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SetEnvironmentSettings Method
C++
virtual void SetEnvironmentSettings(const SEnvironmentInfo& envInfo) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SetPaused Method
C++
virtual void SetPaused(bool paused) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SetSunPos Method
C++
virtual void SetSunPos(float longitude, float latitude) = 0;
Description

Sun position

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SetTime Method

Sets the time of the day specified in hours.

C++
virtual void SetTime(float fHour, bool bForceUpdate = false) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SetTimer Method
C++
virtual void SetTimer(ITimer * pTimer) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SetUpdateCallback Method
C++
virtual void SetUpdateCallback(ITimeOfDayUpdateCallback* pCallback) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::SetVariableValue Method
C++
virtual void SetVariableValue(int nIndex, float fValue[3]) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::Tick Method

Updates the current tod.

C++
virtual void Tick() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDay::Update Method

Updates engine parameters after variable values have been changed.

C++
virtual void Update(bool bInterpolate = true, bool bForceUpdate = false) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDayUpdateCallback Structure
C++
struct ITimeOfDayUpdateCallback {
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDayUpdateCallback::~ITimeOfDayUpdateCallback Destructor
C++
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDayUpdateCallback::BeginUpdate Method
C++
virtual void BeginUpdate() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDayUpdateCallback::EndUpdate Method
C++
virtual void EndUpdate() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::ITimeOfDayUpdateCallback::GetCustomValue Method
C++
virtual bool GetCustomValue(ITimeOfDay::ETimeOfDayParamID paramID, int dim, float* pValues, float& blendWeight) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaCallback Structure
C++
struct IVisAreaCallback {
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaCallback::~IVisAreaCallback Destructor
C++
virtual ~IVisAreaCallback();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaCallback::OnVisAreaDeleted Method
C++
virtual void OnVisAreaDeleted(IVisArea* pVisArea) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager Structure
C++
struct IVisAreaManager {
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::~IVisAreaManager Destructor
C++
virtual ~IVisAreaManager();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::AddListener Method
C++
virtual void AddListener(IVisAreaCallback * pListener) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::CreateSegment Method
C++
virtual bool CreateSegment(int nSID) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::DeleteSegment Method
C++
virtual bool DeleteSegment(int nSID, bool bDeleteNow) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::GetCompiledData Method

Saves data from VisAreaManager engine into memory block.

C++
virtual bool GetCompiledData(uint8 * pData, int nDataSize, std::vector<struct IStatObj*> ** ppStatObjTable, std::vector<IMaterial*> ** ppMatTable, std::vector<struct IStatInstGroup*> ** ppStatInstGroupTable, EEndian eEndian, SHotUpdateInfo * pExportInfo = NULL, const Vec3 & segment = Vec3(0, 0, 0)) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::GetCompiledDataSize Method

Returns VisAreaManager data memory block size.

C++
virtual int GetCompiledDataSize(SHotUpdateInfo * pExportInfo = NULL) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::GetNumberOfVisArea Method

Returns the accumulated number of visareas and portals.

C++
virtual int GetNumberOfVisArea() const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::GetVisAreaById Method

Returns the visarea interface based on the id (0..GetNumberOfVisArea()) it can be a visarea or a portal.

C++
virtual IVisArea* GetVisAreaById(int nID) const = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::OffsetPosition Method
C++
virtual void OffsetPosition(const Vec3& delta) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::PrepareSegmentData Method
C++
virtual void PrepareSegmentData(const AABB & box) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::ReleaseInactiveSegments Method
C++
virtual void ReleaseInactiveSegments() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::RemoveListener Method
C++
virtual void RemoveListener(IVisAreaCallback * pListener) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::SetCompiledData Method

Loads data into VisAreaManager engine from memory block.

C++
virtual bool SetCompiledData(uint8 * pData, int nDataSize, std::vector<struct IStatObj*> ** ppStatObjTable, std::vector<IMaterial*> ** ppMatTable, bool bHotUpdate, SHotUpdateInfo * pExportInfo, const Vec3 & vSegmentOrigin = Vec3(0, 0, 0)) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::StreamCompiledData Method
C++
virtual bool StreamCompiledData(uint8 * pData, int nDataSize, int nSID, std::vector<struct IStatObj*> * pStatObjTable, std::vector<IMaterial*> * pMatTable, std::vector<struct IStatInstGroup*> * pStatInstGroupTable, const Vec3 & vSegmentOrigin, const Vec2 & vIndexOffset) = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::IVisAreaManager::UpdateConnections Method
C++
virtual void UpdateConnections() = 0;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader Structure

Common header for binary files used by 3dengine

C++
struct SCommonFileHeader {
  char signature[4];
  uint8 file_type;
  uint8 flags;
  uint16 version;
  struct STerrainTextureFileHeader_old {
    uint16 nSectorSizeMeters;
    uint16 nLodsNum;
    uint16 nLayerCount;
    uint16 nReserved;
    struct STerrainTextureFileHeader {
      uint16 nLayerCount;
      uint16 dwFlags;
      float fBrMultiplier;
      struct STerrainTextureLayerFileHeader {
        uint16 nSectorSizePixels;
        uint16 nReserved;
        ETEX_Format eTexFormat;
        uint32 nSectorSizeBytes;
        struct SRenderingPassInfo {
          enum EShadowMapType {
            SHADOW_MAP_NONE = 0,
            SHADOW_MAP_GSM0,
            SHADOW_MAP_GSM1,
            SHADOW_MAP_GSM2,
            SHADOW_MAP_GSM3,
            SHADOW_MAP_GSM4,
            SHADOW_MAP_GSM5,
            SHADOW_MAP_GSM6,
            SHADOW_MAP_GSM7,
            SHADOW_MAP_LOCAL,
            SHADOW_MAP_REFLECTIVE,
            SHADOW_MAP_STATIC,
            SHADOW_MAP_STATIC_MGPU_COPY
          };
          enum ESkipRenderingFlags {
            SHADOWS = BIT(0),
            BRUSHES = BIT(1),
            VEGETATION = BIT(2),
            ENTITIES = BIT(3),
            TERRAIN = BIT(4),
            WATEROCEAN = BIT(5),
            PARTICLES = BIT(6),
            DECALS = BIT(7),
            TERRAIN_DETAIL_MATERIALS = BIT(8),
            FAR_SPRITES = BIT(9),
            WATER_WAVES = BIT(12),
            ROADS = BIT(13),
            WATER_VOLUMES = BIT(14),
            CLOUDS = BIT(15),
            CUBEMAP_GEN = BIT(16),
            GEOM_CACHES = BIT(17),
            STATIC_OBJECTS = BRUSHES|VEGETATION,
            DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
            DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
          };
        };
        struct SRendItemSorter {
          enum EDeferredPreprocess {
            eLPVPass = 0,
            eDeferredShadingPass = BIT(30)
          };
public:
          enum {
          };
public:
          enum {
          };
public:
          enum {
          };
public:
          enum {
          };
public:
          enum {
          };
        };
      };
    };
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old Structure

Sub header for terrain texture file Notes: "locally higher texture resolution" following structure can be removed (as well in autotype)

C++
struct STerrainTextureFileHeader_old {
  uint16 nSectorSizeMeters;
  uint16 nLodsNum;
  uint16 nLayerCount;
  uint16 nReserved;
  struct STerrainTextureFileHeader {
    uint16 nLayerCount;
    uint16 dwFlags;
    float fBrMultiplier;
    struct STerrainTextureLayerFileHeader {
      uint16 nSectorSizePixels;
      uint16 nReserved;
      ETEX_Format eTexFormat;
      uint32 nSectorSizeBytes;
      struct SRenderingPassInfo {
        enum EShadowMapType {
          SHADOW_MAP_NONE = 0,
          SHADOW_MAP_GSM0,
          SHADOW_MAP_GSM1,
          SHADOW_MAP_GSM2,
          SHADOW_MAP_GSM3,
          SHADOW_MAP_GSM4,
          SHADOW_MAP_GSM5,
          SHADOW_MAP_GSM6,
          SHADOW_MAP_GSM7,
          SHADOW_MAP_LOCAL,
          SHADOW_MAP_REFLECTIVE,
          SHADOW_MAP_STATIC,
          SHADOW_MAP_STATIC_MGPU_COPY
        };
        enum ESkipRenderingFlags {
          SHADOWS = BIT(0),
          BRUSHES = BIT(1),
          VEGETATION = BIT(2),
          ENTITIES = BIT(3),
          TERRAIN = BIT(4),
          WATEROCEAN = BIT(5),
          PARTICLES = BIT(6),
          DECALS = BIT(7),
          TERRAIN_DETAIL_MATERIALS = BIT(8),
          FAR_SPRITES = BIT(9),
          WATER_WAVES = BIT(12),
          ROADS = BIT(13),
          WATER_VOLUMES = BIT(14),
          CLOUDS = BIT(15),
          CUBEMAP_GEN = BIT(16),
          GEOM_CACHES = BIT(17),
          STATIC_OBJECTS = BRUSHES|VEGETATION,
          DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
          DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
        };
      };
      struct SRendItemSorter {
        enum EDeferredPreprocess {
          eLPVPass = 0,
          eDeferredShadingPass = BIT(30)
        };
public:
        enum {
        };
public:
        enum {
        };
public:
        enum {
        };
public:
        enum {
        };
public:
        enum {
        };
      };
    };
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader Structure

Sub header for terrain texture file

C++
struct STerrainTextureFileHeader {
  uint16 nLayerCount;
  uint16 dwFlags;
  float fBrMultiplier;
  struct STerrainTextureLayerFileHeader {
    uint16 nSectorSizePixels;
    uint16 nReserved;
    ETEX_Format eTexFormat;
    uint32 nSectorSizeBytes;
    struct SRenderingPassInfo {
      enum EShadowMapType {
        SHADOW_MAP_NONE = 0,
        SHADOW_MAP_GSM0,
        SHADOW_MAP_GSM1,
        SHADOW_MAP_GSM2,
        SHADOW_MAP_GSM3,
        SHADOW_MAP_GSM4,
        SHADOW_MAP_GSM5,
        SHADOW_MAP_GSM6,
        SHADOW_MAP_GSM7,
        SHADOW_MAP_LOCAL,
        SHADOW_MAP_REFLECTIVE,
        SHADOW_MAP_STATIC,
        SHADOW_MAP_STATIC_MGPU_COPY
      };
      enum ESkipRenderingFlags {
        SHADOWS = BIT(0),
        BRUSHES = BIT(1),
        VEGETATION = BIT(2),
        ENTITIES = BIT(3),
        TERRAIN = BIT(4),
        WATEROCEAN = BIT(5),
        PARTICLES = BIT(6),
        DECALS = BIT(7),
        TERRAIN_DETAIL_MATERIALS = BIT(8),
        FAR_SPRITES = BIT(9),
        WATER_WAVES = BIT(12),
        ROADS = BIT(13),
        WATER_VOLUMES = BIT(14),
        CLOUDS = BIT(15),
        CUBEMAP_GEN = BIT(16),
        GEOM_CACHES = BIT(17),
        STATIC_OBJECTS = BRUSHES|VEGETATION,
        DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
        DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
      };
    };
    struct SRendItemSorter {
      enum EDeferredPreprocess {
        eLPVPass = 0,
        eDeferredShadingPass = BIT(30)
      };
public:
      enum {
      };
public:
      enum {
      };
public:
      enum {
      };
public:
      enum {
      };
public:
      enum {
      };
    };
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader Structure

Layer header for terrain texture file (for each layer)

C++
struct STerrainTextureLayerFileHeader {
  uint16 nSectorSizePixels;
  uint16 nReserved;
  ETEX_Format eTexFormat;
  uint32 nSectorSizeBytes;
  struct SRenderingPassInfo {
    enum EShadowMapType {
      SHADOW_MAP_NONE = 0,
      SHADOW_MAP_GSM0,
      SHADOW_MAP_GSM1,
      SHADOW_MAP_GSM2,
      SHADOW_MAP_GSM3,
      SHADOW_MAP_GSM4,
      SHADOW_MAP_GSM5,
      SHADOW_MAP_GSM6,
      SHADOW_MAP_GSM7,
      SHADOW_MAP_LOCAL,
      SHADOW_MAP_REFLECTIVE,
      SHADOW_MAP_STATIC,
      SHADOW_MAP_STATIC_MGPU_COPY
    };
    enum ESkipRenderingFlags {
      SHADOWS = BIT(0),
      BRUSHES = BIT(1),
      VEGETATION = BIT(2),
      ENTITIES = BIT(3),
      TERRAIN = BIT(4),
      WATEROCEAN = BIT(5),
      PARTICLES = BIT(6),
      DECALS = BIT(7),
      TERRAIN_DETAIL_MATERIALS = BIT(8),
      FAR_SPRITES = BIT(9),
      WATER_WAVES = BIT(12),
      ROADS = BIT(13),
      WATER_VOLUMES = BIT(14),
      CLOUDS = BIT(15),
      CUBEMAP_GEN = BIT(16),
      GEOM_CACHES = BIT(17),
      STATIC_OBJECTS = BRUSHES|VEGETATION,
      DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
      DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
    };
  };
  struct SRendItemSorter {
    enum EDeferredPreprocess {
      eLPVPass = 0,
      eDeferredShadingPass = BIT(30)
    };
public:
    enum {
    };
public:
    enum {
    };
public:
    enum {
    };
public:
    enum {
    };
public:
    enum {
    };
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo Structure
C++
struct SRenderingPassInfo {
  enum EShadowMapType {
    SHADOW_MAP_NONE = 0,
    SHADOW_MAP_GSM0,
    SHADOW_MAP_GSM1,
    SHADOW_MAP_GSM2,
    SHADOW_MAP_GSM3,
    SHADOW_MAP_GSM4,
    SHADOW_MAP_GSM5,
    SHADOW_MAP_GSM6,
    SHADOW_MAP_GSM7,
    SHADOW_MAP_LOCAL,
    SHADOW_MAP_REFLECTIVE,
    SHADOW_MAP_STATIC,
    SHADOW_MAP_STATIC_MGPU_COPY
  };
  enum ESkipRenderingFlags {
    SHADOWS = BIT(0),
    BRUSHES = BIT(1),
    VEGETATION = BIT(2),
    ENTITIES = BIT(3),
    TERRAIN = BIT(4),
    WATEROCEAN = BIT(5),
    PARTICLES = BIT(6),
    DECALS = BIT(7),
    TERRAIN_DETAIL_MATERIALS = BIT(8),
    FAR_SPRITES = BIT(9),
    WATER_WAVES = BIT(12),
    ROADS = BIT(13),
    WATER_VOLUMES = BIT(14),
    CLOUDS = BIT(15),
    CUBEMAP_GEN = BIT(16),
    GEOM_CACHES = BIT(17),
    STATIC_OBJECTS = BRUSHES|VEGETATION,
    DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
    DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
  };
};
File

I3DEngine.h

Description

state of 3dengine during rendering used to prevent global state

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::EShadowMapType Enumeration
C++
enum EShadowMapType {
  SHADOW_MAP_NONE = 0,
  SHADOW_MAP_GSM0,
  SHADOW_MAP_GSM1,
  SHADOW_MAP_GSM2,
  SHADOW_MAP_GSM3,
  SHADOW_MAP_GSM4,
  SHADOW_MAP_GSM5,
  SHADOW_MAP_GSM6,
  SHADOW_MAP_GSM7,
  SHADOW_MAP_LOCAL,
  SHADOW_MAP_REFLECTIVE,
  SHADOW_MAP_STATIC,
  SHADOW_MAP_STATIC_MGPU_COPY
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::ESkipRenderingFlags Enumeration
C++
enum ESkipRenderingFlags {
  SHADOWS = BIT(0),
  BRUSHES = BIT(1),
  VEGETATION = BIT(2),
  ENTITIES = BIT(3),
  TERRAIN = BIT(4),
  WATEROCEAN = BIT(5),
  PARTICLES = BIT(6),
  DECALS = BIT(7),
  TERRAIN_DETAIL_MATERIALS = BIT(8),
  FAR_SPRITES = BIT(9),
  WATER_WAVES = BIT(12),
  ROADS = BIT(13),
  WATER_VOLUMES = BIT(14),
  CLOUDS = BIT(15),
  CUBEMAP_GEN = BIT(16),
  GEOM_CACHES = BIT(17),
  STATIC_OBJECTS = BRUSHES|VEGETATION,
  DEFAULT_FLAGS = SHADOWS|BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES,
  DEFAULT_RECURSIVE_FLAGS = BRUSHES|VEGETATION|ENTITIES|TERRAIN|WATEROCEAN|PARTICLES|DECALS|TERRAIN_DETAIL_MATERIALS|FAR_SPRITES|WATER_WAVES|ROADS|WATER_VOLUMES|CLOUDS|GEOM_CACHES
};
File

I3DEngine.h

Members
Members 
Description 
STATIC_OBJECTS = BRUSHES|VEGETATION 
below are precombined flags 
Description

enum flags to identify which objects to skip for this pass

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::CreateGeneralPassRenderingInfo Method
C++
static SRenderingPassInfo CreateGeneralPassRenderingInfo(const CCamera & rCamera, uint32 nRenderingFlags = DEFAULT_FLAGS, bool bAuxWindow = false);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::CreateRecursivePassRenderingInfo Method
C++
static SRenderingPassInfo CreateRecursivePassRenderingInfo(const CCamera & rCamera, uint32 nRenderingFlags = DEFAULT_RECURSIVE_FLAGS);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::CreateShadowPassRenderingInfo Method (CCamera &, SRenderingPassInfo::EShadowMapType, uint32)
C++
static SRenderingPassInfo CreateShadowPassRenderingInfo(const CCamera & rCamera, SRenderingPassInfo::EShadowMapType eShadowMapType, uint32 nRenderingFlags = DEFAULT_FLAGS);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::CreateShadowPassRenderingInfo Method (CCamera &, int, int, bool, uint, uint32 *, uint32, uint32, uint32)
C++
static SRenderingPassInfo CreateShadowPassRenderingInfo(const CCamera & rCamera, int nLightFlags, int nShadowMapLod, bool bExtendedLod, uint nShadowGpuID, uint32 * pShadowGenMask, uint32 nSide, uint32 nShadowFrustumID, uint32 nRenderingFlags = DEFAULT_FLAGS);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::CreateTempRenderingInfo Method (CCamera &, SRenderingPassInfo &)
C++
static SRenderingPassInfo CreateTempRenderingInfo(const CCamera & rCamera, const SRenderingPassInfo & rPassInfo);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::CreateTempRenderingInfo Method (uint32, SRenderingPassInfo &)
C++
static SRenderingPassInfo CreateTempRenderingInfo(uint32 nRenderingFlags, const SRenderingPassInfo & rPassInfo);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::GetCamera Method
C++
const CCamera& GetCamera() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::GetFrameID Method
C++
int GetFrameID() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::GetInverseZoomFactor Method
C++
float GetInverseZoomFactor() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::GetMainFrameID Method
C++
uint32 GetMainFrameID() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::GetRecursiveLevel Method
C++
uint32 GetRecursiveLevel() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::GetShadowMapType Method
C++
EShadowMapType GetShadowMapType() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::GetZoomFactor Method
C++
float GetZoomFactor() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::IsAuxWindow Method
C++
bool IsAuxWindow() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::IsCameraUnderWater Method
C++
bool IsCameraUnderWater() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::IsGeneralPass Method
C++
bool IsGeneralPass() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::IsRecursivePass Method
C++
bool IsRecursivePass() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::IsRenderingCubemap Method
C++
bool IsRenderingCubemap() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::IsShadowPass Method
C++
bool IsShadowPass() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::IsStaticShadowPass Method
C++
bool IsStaticShadowPass() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::IsZoomActive Method
C++
bool IsZoomActive() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::IsZoomInProgress Method
C++
bool IsZoomInProgress() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderBrushes Method
C++
bool RenderBrushes() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderClouds Method
C++
bool RenderClouds() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderDecals Method
C++
bool RenderDecals() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderEntities Method
C++
bool RenderEntities() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderFarSprites Method
C++
bool RenderFarSprites() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderGeomCaches Method
C++
bool RenderGeomCaches() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderParticles Method
C++
bool RenderParticles() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderRoads Method
C++
bool RenderRoads() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderShadows Method
C++
bool RenderShadows() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderTerrain Method
C++
bool RenderTerrain() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderTerrainDetailMaterial Method
C++
bool RenderTerrainDetailMaterial() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderVegetation Method
C++
bool RenderVegetation() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderWaterOcean Method
C++
bool RenderWaterOcean() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderWaterVolumes Method
C++
bool RenderWaterVolumes() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::RenderWaterWaves Method
C++
bool RenderWaterWaves() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::ShadowFrustumID Method
C++
uint32 ShadowFrustumID() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::ShadowFrustumSide Method
C++
uint8 ShadowFrustumSide() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::ShadowGenMaskAddress Method
C++
uint32* ShadowGenMaskAddress() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRenderingPassInfo::ThreadID Method
C++
threadID ThreadID() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter Structure
C++
struct SRendItemSorter {
  enum EDeferredPreprocess {
    eLPVPass = 0,
    eDeferredShadingPass = BIT(30)
  };
public:
  enum {
  };
public:
  enum {
  };
public:
  enum {
  };
public:
  enum {
  };
public:
  enum {
  };
};
File

I3DEngine.h

Description

class to wrap a special counter used to presort SRendItems this is used to fix random ordering introduced by parallelization of parts of the 3DEngine

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::EDeferredPreprocess Enumeration
C++
enum EDeferredPreprocess {
  eLPVPass = 0,
  eDeferredShadingPass = BIT(30)
};
File

I3DEngine.h

Description

Deferred PreProcess needs a special ordering, use these to prefix the values to ensure the deferred shading pass is after all LPV objects

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::< Operator
C++
bool operator <(const SRendItemSorter & rOther) const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::CreateDefaultRendItemSorter Method
C++
static SRendItemSorter CreateDefaultRendItemSorter();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::CreateDeferredPreProcessRendItemSorter Method
C++
static SRendItemSorter CreateDeferredPreProcessRendItemSorter(const SRenderingPassInfo & passInfo, EDeferredPreprocess deferredPrerocessType);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::CreateParticleRendItemSorter Method
C++
static SRendItemSorter CreateParticleRendItemSorter(const SRenderingPassInfo & passInfo);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::CreateRendItemSorter Method
C++
static SRendItemSorter CreateRendItemSorter(const SRenderingPassInfo & passInfo);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::CreateShadowPassRendItemSorter Method
C++
static SRendItemSorter CreateShadowPassRendItemSorter(const SRenderingPassInfo & passInfo);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::GetValue Method
C++
uint32 GetValue() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::IncreaseGroupCounter Method
C++
void IncreaseGroupCounter();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::IncreaseObjectCounter Method
C++
void IncreaseObjectCounter();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::IncreaseOctreeCounter Method
C++
void IncreaseOctreeCounter();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::IncreaseParticleCounter Method
C++
void IncreaseParticleCounter();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::IsRecursivePass Method
C++
bool IsRecursivePass() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::ParticleCounter Method
C++
uint32 ParticleCounter() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::ShadowFrustumID Method
C++
uint32 ShadowFrustumID() const;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::SRendItemSorter Constructor ()
C++
SRendItemSorter();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::SRendItemSorter::SRendItemSorter Constructor (uint32)
C++
explicit SRendItemSorter(uint32 _nValue);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::eTexFormat Data Member
C++
ETEX_Format eTexFormat;
Description

typically eTF_DXT1, eTF_A4R4G4B4 or eTF_R5G6B5

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::nReserved Data Member
C++
uint16 nReserved;
Description

ensure padding and for later usage

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::nSectorSizeBytes Data Member
C++
uint32 nSectorSizeBytes;
Description

redundant information for more convenient loading code

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::STerrainTextureLayerFileHeader::nSectorSizePixels Data Member
C++
uint16 nSectorSizePixels;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::dwFlags Data Member
C++
uint16 dwFlags;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::fBrMultiplier Data Member
C++
float fBrMultiplier;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::STerrainTextureFileHeader::nLayerCount Data Member
C++
uint16 nLayerCount;
Description

STerrainTextureLayerFileHeader count following (also defines how may layers are interleaved) 1/2

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::nLayerCount Data Member
C++
uint16 nLayerCount;
Description

STerrainTextureLayerFileHeader count following (also defines how may layers are interleaved) 1/2

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::nLodsNum Data Member
C++
uint16 nLodsNum;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::nReserved Data Member
C++
uint16 nReserved;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::STerrainTextureFileHeader_old::nSectorSizeMeters Data Member
C++
uint16 nSectorSizeMeters;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::file_type Data Member
C++
uint8 file_type;
Description

File type

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::flags Data Member
C++
uint8 flags;
Description

File common flags

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::signature Data Member
C++
char signature[4];
Description

File signature, should be "CRY

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::version Data Member
C++
uint16 version;
Description

File version

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::Check Method
C++
bool Check(uint16 t, uint16 v);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SCommonFileHeader::Set Method
C++
void Set(uint16 t, uint16 v);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SDebugFPSInfo Structure
C++
struct SDebugFPSInfo {
  float fAverageFPS;
  float fMinFPS;
  float fMaxFPS;
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SDebugFPSInfo::fAverageFPS Data Member
C++
float fAverageFPS;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SDebugFPSInfo::fMaxFPS Data Member
C++
float fMaxFPS;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SDebugFPSInfo::fMinFPS Data Member
C++
float fMinFPS;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SDebugFPSInfo::SDebugFPSInfo Constructor
C++
SDebugFPSInfo();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume Structure
C++
struct SLightVolume {
  struct SLightData {
    Vec4 vPos;
    Vec4 vColor;
    Vec4 vParams;
  };
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume::SLightData Structure
C++
struct SLightData {
  Vec4 vPos;
  Vec4 vColor;
  Vec4 vParams;
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume::SLightData::vColor Data Member
C++
Vec4 vColor;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume::SLightData::vParams Data Member
C++
Vec4 vParams;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume::SLightData::vPos Data Member
C++
Vec4 vPos;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume::SLightData::SLightData Constructor ()
C++
SLightData();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume::SLightData::SLightData Constructor (Vec4 &, Vec4 &, Vec4 &)
C++
SLightData(const Vec4 & vInPos, const Vec4 & vInColor, const Vec4 & vInParams);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume::DEFINE_ALIGNED_DATA Method
C++
DEFINE_ALIGNED_DATA(LightDataVector, pData, 16);
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume::SLightVolume Constructor
C++
SLightVolume();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SLightVolume::LightDataVector Nested Type
C++
typedef DynArray<SLightData> LightDataVector;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::sRAEColdData Structure
C++
struct sRAEColdData {
  Vec4 m_RAEPortalInfos[96];
};
File

I3DEngine.h

Members
Members 
Description 
Vec4 m_RAEPortalInfos[96]; 
It stores all data needed to solve the problem between the portals & indirect lighting. byte m_OcclLights[MAX_LIGHTS_NUM]; 
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams Structure

Common scene rain parameters shared across engine and editor

C++
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::areaAABB Data Member
C++
AABB areaAABB;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::bApplyOcclusion Data Member
C++
bool bApplyOcclusion;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::bDisableOcclusion Data Member
C++
bool bDisableOcclusion;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::bIgnoreVisareas Data Member
C++
bool bIgnoreVisareas;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fAmount Data Member
C++
float fAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fCurrentAmount Data Member
C++
float fCurrentAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fDiffuseDarkening Data Member
C++
float fDiffuseDarkening;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fFakeGlossiness Data Member
C++
float fFakeGlossiness;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fFakeReflectionAmount Data Member
C++
float fFakeReflectionAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fMistAmount Data Member
C++
float fMistAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fMistHeight Data Member
C++
float fMistHeight;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fPuddlesAmount Data Member
C++
float fPuddlesAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fPuddlesMaskAmount Data Member
C++
float fPuddlesMaskAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fPuddlesRippleAmount Data Member
C++
float fPuddlesRippleAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fRadius Data Member
C++
float fRadius;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fRainDropsAmount Data Member
C++
float fRainDropsAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fRainDropsLighting Data Member
C++
float fRainDropsLighting;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fRainDropsSpeed Data Member
C++
float fRainDropsSpeed;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::fSplashesAmount Data Member
C++
float fSplashesAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::matOccTrans Data Member
C++
Matrix44 matOccTrans;
Description

Transformation matrix for rendering into a new occ map

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::matOccTransRender Data Member
C++
Matrix44 matOccTransRender;
Description

Transformation matrix for rendering occluded rain using current occ map

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::nUpdateFrameID Data Member
C++
int nUpdateFrameID;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::qRainRotation Data Member
C++
Quat qRainRotation;
Description

Quaternion for the scene's rain entity rotation

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::vColor Data Member
C++
Vec3 vColor;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::vWorldPos Data Member
C++
Vec3 vWorldPos;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SRainParams::SRainParams Constructor
C++
SRainParams();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams Structure
C++
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::dummy0 Data Member
C++
uint32 dummy0;
Description

temporarily add padding bytes to prevent fetching Vec4 constants below from wrong offset

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::dummy1 Data Member
C++
uint32 dummy1;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_hazeColor Data Member
C++
Vec4 m_hazeColor;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_hazeColorMieNoPremul Data Member
C++
Vec4 m_hazeColorMieNoPremul;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_hazeColorRayleighNoPremul Data Member
C++
Vec4 m_hazeColorRayleighNoPremul;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_partialMieInScatteringConst Data Member
C++
Vec4 m_partialMieInScatteringConst;
Description

Sky dome shader constants

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_partialRayleighInScatteringConst Data Member
C++
Vec4 m_partialRayleighInScatteringConst;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_phaseFunctionConsts Data Member
C++
Vec4 m_phaseFunctionConsts;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_pSkyDomeMesh Data Member
C++
_smart_ptr<IRenderMesh> m_pSkyDomeMesh;
Description

Sky dome mesh

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_pSkyDomeTextureDataMie Data Member
C++
const void* m_pSkyDomeTextureDataMie;
Description

Sky dome texture data

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_pSkyDomeTextureDataRayleigh Data Member
C++
const void* m_pSkyDomeTextureDataRayleigh;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_skyColorEast Data Member
C++
Vec3 m_skyColorEast;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_skyColorNorth Data Member
C++
Vec3 m_skyColorNorth;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_skyColorSouth Data Member
C++
Vec3 m_skyColorSouth;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_skyColorTop Data Member
C++
Vec3 m_skyColorTop;
Description

Sky hemisphere colors

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_skyColorWest Data Member
C++
Vec3 m_skyColorWest;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_skyDomeTexturePitch Data Member
C++
size_t m_skyDomeTexturePitch;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_skyDomeTextureTimeStamp Data Member
C++
int m_skyDomeTextureTimeStamp;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::m_sunDirection Data Member
C++
Vec4 m_sunDirection;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::pad Data Member
C++
int pad;
Description

Enable 16 byte alignment for Vec4s

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::skyDomeTextureHeight Data Member
C++
const int skyDomeTextureHeight = 32;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::skyDomeTextureHeightBy2Log Data Member
C++
const int skyDomeTextureHeightBy2Log = 4;
Description

log2(32/2)

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::skyDomeTextureSize Data Member
C++
const int skyDomeTextureSize = 64 * 32;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::skyDomeTextureWidth Data Member
C++
const int skyDomeTextureWidth = 64;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::skyDomeTextureWidthBy4Log Data Member
C++
const int skyDomeTextureWidthBy4Log = 4;
Description

log2(64/4)

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::skyDomeTextureWidthBy8 Data Member
C++
const int skyDomeTextureWidthBy8 = 8;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSkyLightRenderParams::SSkyLightRenderParams Constructor
C++
SSkyLightRenderParams();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams Structure
C++
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fFrostAmount Data Member
C++
float m_fFrostAmount;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fRadius Data Member
C++
float m_fRadius;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fSnowAmount Data Member
C++
float m_fSnowAmount;
Description

Surface params.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fSnowFallBrightness Data Member
C++
float m_fSnowFallBrightness;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fSnowFallGravityScale Data Member
C++
float m_fSnowFallGravityScale;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fSnowFallTurbulence Data Member
C++
float m_fSnowFallTurbulence;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fSnowFallTurbulenceFreq Data Member
C++
float m_fSnowFallTurbulenceFreq;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fSnowFallWindScale Data Member
C++
float m_fSnowFallWindScale;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fSnowFlakeSize Data Member
C++
float m_fSnowFlakeSize;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_fSurfaceFreezing Data Member
C++
float m_fSurfaceFreezing;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_nSnowFlakeCount Data Member
C++
int m_nSnowFlakeCount;
Description

Snowfall params.

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::m_vWorldPos Data Member
C++
Vec3 m_vWorldPos;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SSnowParams::SSnowParams Constructor
C++
SSnowParams();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SVisAreaInfo Structure
C++
struct SVisAreaInfo {
  float fHeight;
  Vec3 vAmbientColor;
  bool bAffectedByOutLights;
  bool bIgnoreSkyColor;
  bool bSkyOnly;
  float fViewDistRatio;
  bool bDoubleSide;
  bool bUseDeepness;
  bool bUseInIndoors;
  bool bOceanIsVisible;
  bool bIgnoreGI;
};
File

I3DEngine.h

STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::areaBox Data Member
C++
AABB areaBox;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::nHeigtmap Data Member
C++
uint32 nHeigtmap;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::nObjTypeMask Data Member
C++
uint32 nObjTypeMask;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::pLayerIdTranslation Data Member
C++
const uint16* pLayerIdTranslation;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::pVisibleLayerMask Data Member
C++
const uint8* pVisibleLayerMask;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::SHotUpdateInfo::SHotUpdateInfo Constructor
C++
SHotUpdateInfo();
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::nChunkVersion Data Member
C++
int16 nChunkVersion;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::nObjectsBlockSize Data Member
C++
int32 nObjectsBlockSize;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::nodeBox Data Member
C++
AABB nodeBox;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::SOcTreeNodeChunk::ucChildsMask Data Member
C++
int16 ucChildsMask;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::nChunkSize Data Member
C++
int nChunkSize;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::nDummy Data Member
C++
int8 nDummy;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::nFlags Data Member
C++
int8 nFlags;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::nFlags2 Data Member
C++
int8 nFlags2;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::nOcclAreasNum Data Member
C++
int nOcclAreasNum;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::nPortalsNum Data Member
C++
int nPortalsNum;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::nVersion Data Member
C++
int8 nVersion;
STerrainInfo::STerrainChunkHeader::SVisAreaManChunkHeader::nVisAreasNum Data Member
C++
int nVisAreasNum;
STerrainInfo::STerrainChunkHeader::nChunkSize Data Member
C++
int32 nChunkSize;
STerrainInfo::STerrainChunkHeader::nDummy Data Member
C++
int8 nDummy;
STerrainInfo::STerrainChunkHeader::nFlags Data Member
C++
int8 nFlags;
STerrainInfo::STerrainChunkHeader::nFlags2 Data Member
C++
int8 nFlags2;
STerrainInfo::STerrainChunkHeader::nVersion Data Member
C++
int8 nVersion;
STerrainInfo::STerrainChunkHeader::TerrainInfo Data Member
C++
STerrainInfo TerrainInfo;
STerrainInfo::fHeightmapZRatio Data Member
C++
float fHeightmapZRatio;
STerrainInfo::fOceanWaterLevel Data Member
C++
float fOceanWaterLevel;
STerrainInfo::nHeightMapSize_InUnits Data Member
C++
int nHeightMapSize_InUnits;
STerrainInfo::nSectorSize_InMeters Data Member
C++
int nSectorSize_InMeters;
STerrainInfo::nSectorsTableSize_InSectors Data Member
C++
int nSectorsTableSize_InSectors;
STerrainInfo::nUnitSize_InMeters Data Member
C++
int nUnitSize_InMeters;

In This Topic

  • No labels