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 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 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 {
                    };
                  };
                };
              };
            };
          };
        };
      };
    };
  };
};

I3DEngine.h

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 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 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 {
                  };
                };
              };
            };
          };
        };
      };
    };
  };
};

I3DEngine.h

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 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 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 {
                };
              };
            };
          };
        };
      };
    };
  };
};

I3DEngine.h

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 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 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 {
              };
            };
          };
        };
      };
    };
  };
};

I3DEngine.h

struct IGetLayerIdAtCallback {
};

I3DEngine.h

virtual ~IGetLayerIdAtCallback();

virtual ColorB GetColorAtPosition(const float x, const float y, bool bBilinear) = 0;

virtual float GetElevationAtPosition(const float x, const float y) = 0;

virtual bool GetHoleAtPosition(const int x, const int y) const = 0;

virtual uint32 GetLayerIdAtPosition(const int x, const int y) const = 0;

virtual float GetRGBMultiplier() = 0;

virtual uint32 GetSurfaceTypeIdAtPosition(const int x, const int y) const = 0;

Interface to terrain engine

struct IVoxTerrain {
};

I3DEngine.h

virtual ~IVoxTerrain();

virtual void DrawEditingHelper(const Sphere & sp, EVoxelEditOperation eOperation, IMaterial * pHelperMat) = 0;

virtual IMemoryBlock * GetCompiledData(bool bSaveMesh, EEndian eEndian, bool bSaveForEditing, AABB * pAreaBox, int nSID = 0) = 0;

virtual void GetLayerData(void ** pData, int & nDataSize) = 0;

virtual PodArray<IRenderNode*> * GetNodesForUpdate() = 0;

virtual void OnMouse(bool bUp) = 0;

virtual void PaintLayerId(const float fpx, const float fpy, const float radius, const float hardness, const uint32 dwLayerId) = 0;

virtual bool SetCompiledData(byte * pData, int nDataSize, bool bUpdateMesh, EEndian eEndian, AABB * pAreaBox, int nSID = 0) = 0;

virtual void SetLayerData(void * pData, int nDataSize) = 0;

virtual void SetTextureArea(Vec3 * pPoints, int nPointsCount, int nShapePartId) = 0;

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 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 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 {
            };
          };
        };
      };
    };
  };
};

I3DEngine.h

Types of binary files used by 3dengine

enum EFileTypes {
  eTerrainTextureFile = 100
};

I3DEngine.h

Interface to the 3d Engine.

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
  };
};

I3DEngine.h

enum EChunkFileFormat {
  eChunkFileFormat_0x745,
  eChunkFileFormat_0x746
};

I3DEngine.h

Chunk file writer.

enum eStreamingSubsystem {
  eStreamingSubsystem_Textures,
  eStreamingSubsystem_Objects,
  eStreamingSubsystem_Audio
};

I3DEngine.h

struct SObjectsStreamingStatus {
  int nReady;
  int nInProgress;
  int nTotal;
  int nActive;
  int nAllocatedBytes;
  int nMemRequired;
  int nMeshPoolSize;
};

I3DEngine.h

struct SStremaingBandwidthData {
  float fBandwidthActual;
  float fBandwidthRequested;
};

I3DEngine.h

float fBandwidthActual;

float fBandwidthRequested;

SStremaingBandwidthData();

virtual void ActivateObjectsLayer(uint16 nLayerId, bool bActivate, bool bPhys, bool bObjects, bool bStaticLights, const char * pLayerName, IGeneralMemoryHeap* pHeap = NULL, bool bCheckLayerActivation = true) = 0;

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

Enables or disables portal at a specified position.

virtual void ActivatePortal(const Vec3 & vPos, bool bActivate, const char * szEntityName) = 0;

virtual int AddPrecachePoint(const Vec3& vPos, const Vec3& vDir, float fTimeOut = 3.f, float fImportanceFactor = 1.0f) = 0;

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

Applies physics in a specified area

virtual void ApplyForceToEnvironment(Vec3 vPos, float fRadius, float fAmountOfForce) = 0;

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

virtual bool CheckIntersectClouds(const Vec3 & p1, const Vec3 & p2) = 0;

Returns true if input line segment intersect clouds sprites.

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

virtual void CheckMemoryHeap() = 0;

Physicalizes area if not physicalized yet.

virtual void CheckPhysicalized(const Vec3 & vBoxMin, const Vec3 & vBoxMax) = 0;

virtual void ClearAllPrecachePoints() = 0;

virtual void ClearPrecachePoint(int id) = 0;

virtual bool ClipToVisAreas(IVisArea* pInside, Sphere& sphere, Vec3 const& vNormal, void* pNodeCache = 0) = 0;

Whether it was clipped

Clips geometry against the boundaries of VisAreas.

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

virtual void CloseTerrainTextureFile(int nSID = DEFAULT_SID) = 0;

Finishes objects geometery generation/loading.

virtual void CompleteObjectsGeometry() = 0;

virtual IChunkFile * CreateChunkFile(bool bReadOnly = false) = 0;

Creates ChunkFile.

virtual CContentCGF* CreateChunkfileContent(const char * filename) = 0;

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

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

virtual ChunkFile::IChunkFileWriter* CreateChunkFileWriter(EChunkFileFormat eFormat, ICryPak* pPak, const char* filename) const = 0;

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

virtual void CreateDecal(const CryEngineDecalInfo & Decal) = 0;

Creates the instance of the indexed mesh.

virtual IIndexedMesh* CreateIndexedMesh() = 0;

Creates a new light source.

virtual struct ILightSource * CreateLightSource() = 0;

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

Creates instance of IRenderNode object with specified type.

virtual IRenderNode* CreateRenderNode(EERType type) = 0;

Creates static object containing empty IndexedMesh.

virtual IStatObj * CreateStatObj() = 0;

virtual IStatObj * CreateStatObjOptionalIndexedMesh(bool createIndexedMesh) = 0;

virtual ITerrain * CreateTerrain(const STerrainInfo & TerrainInfo) = 0;

Creates terrain engine

Creates a new VisArea.

virtual IVisArea * CreateVisArea(uint64 visGUID) = 0;

A pointer to a newly created VisArea object

virtual void DebugDraw_UpdateDebugNode() = 0;

Used to highlight an object under the reticule

Removes decals in a specified range.

virtual void DeleteDecalsInRange(AABB * pAreaBox, IRenderNode * pEntity) = 0;

Removes all decals attached to specified entity.

virtual void DeleteEntityDecals(IRenderNode * pEntity) = 0;

Deletes a light.

virtual void DeleteLightSource(ILightSource * pLightSource) = 0;

Delete RenderNode object.

virtual void DeleteRenderNode(IRenderNode * pRenderNode) = 0;

virtual void DeleteTerrain() = 0;

Deletes terrain

Deletes a VisArea.

virtual void DeleteVisArea(IVisArea * pVisArea) = 0;

Displays statistic on the 3d Engine.

virtual void DisplayInfo(float & fTextPosX, float & fTextPosY, float & fTextStepY, const bool bEnhanced) = 0;

virtual void DrawDeferredCoverageBufferDebug() = 0;

Draws text right aligned at the y pixel precision.

virtual void DrawTextRightAligned(const float x, const float y, const char * format, ...);

virtual void DrawTextRightAligned(const float x, const float y, const float scale, const ColorF & color, const char * format, ...);

Enables or disables ocean rendering.

virtual void EnableOceanRendering(bool bOcean) = 0;

virtual void EndOcclusion() = 0;

virtual void FillDebugFPSInfo(SDebugFPSInfo&) = 0;

Finds a static object created from the given filename

virtual IStatObj * FindStatObjectByFilename(const char * filename) = 0;

A pointer to an object derived from IStatObj.

IStatObj

Frees entity render info.

virtual void FreeRenderNodeState(IRenderNode * pEntity) = 0;

virtual void FreeRNTmpData(CRNTmpData ** ppInfo) = 0;

Frees lod transition state

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.

virtual float GetAccurateOceanHeight(const Vec3 & pCurrPos) const = 0;

A float value which indicate the water level.

virtual float GetBottomLevel(const Vec3 & referencePos, float maxRelevantDepth = 10.0f) = 0;

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.

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).

virtual float GetBottomLevel(const Vec3 & referencePos, float maxRelevantDepth, int objtypes) = 0;

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.

virtual float GetBottomLevel(const Vec3 & referencePos, int objflags) = 0;

Gets caustics parameters.

virtual Vec4 GetCausticsParams() const = 0;

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

virtual IDeferredPhysicsEventManager* GetDeferredPhysicsEventManager() = 0;

virtual PodArray<CDLight*>* GetDynamicLightSources() = 0;

Gets the fog color.

virtual Vec3 GetFogColor() = 0;

Retrieves the current GI multiplier Notes:

virtual float GetGIAmount() const = 0;

scalar value

float GetGlobalParameter(E3DEngineParameter param);

virtual void GetGlobalParameter(E3DEngineParameter param, Vec3 & v) = 0;

Retrieves global 3d engine parameter.

Gets the global wind vector.

virtual Vec3 GetGlobalWind(bool bIndoors) const = 0;

Gets HDR setup parameters.

virtual void GetHDRSetupParams(Vec4 pParams[4]) const = 0;

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

virtual int GetHeightMapUnitSize() = 0;

A int value representing the terrain unit size in meters.

virtual IMergedMeshesManager * GetIMergedMeshesManager() = 0;

Returns interface to the mergedmeshes subsystem

virtual ITerrain * GetITerrain() = 0;

Returns interface to terrain engine

virtual IVisAreaManager * GetIVisAreaManager() = 0;

Returns interface to visarea manager.

virtual IVoxTerrain * GetIVoxTerrain() = 0;

Deprecated

virtual void GetLayerMemoryUsage(uint16 nLayerId, ICrySizer* pSizer, int* pNumBrushes, int* pNumDecals) const = 0;

Get object layer memory usage

Adds the level's path to a specified filename.

virtual const char * GetLevelFilePath(const char * szFileName) = 0;

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

virtual float GetLightAmountInRange(const Vec3 & pPos, float fRange, bool bAccurate = 0) = 0;

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.

virtual const PodArray * GetLightEntities() = 0;

virtual float GetLightsHDRDynamicPowerFactor() const = 0;

In logarithmic scale -4.0 .. 4.0

Gives access to list holding all lighting volumes

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

An array holding all the SLightVolume pointers.

Gets the amount of loaded objects.

virtual int GetLoadedObjectCount();

An integer representing the amount of loaded objects.

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

virtual void GetLoadedStatObjArray(IStatObj** pObjectsArray, int & nCount) = 0;

virtual IMaterialManager* GetMaterialManager() = 0;

Retrieve pointer to the material manager interface.

Gives access to materials library.

virtual class CMatMan * GetMatMan() = 0;

Gets the view distance.

virtual float GetMaxViewDistance(bool bScaled = true) = 0;

A float value representing the maximum view distance.

virtual uint32 GetObjectsByType(EERType objType, IRenderNode ** pObjects = 0) = 0;

Count returned

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

virtual uint32 GetObjectsByTypeInBox(EERType objType, const AABB & bbox, IRenderNode ** pObjects = 0) = 0;

virtual void GetObjectsByTypeInBox(EERType objType, const AABB & bbox, PodArray<IRenderNode*> * pLstObjects) = 0;

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

virtual uint32 GetObjectsInBox(const AABB & bbox, IRenderNode ** pObjects = 0) = 0;

Gets stats on streamed objects

virtual void GetObjectsStreamingStatus(SObjectsStreamingStatus & outStatus) = 0;

Gets ocean animation caustics parameters.

virtual Vec4 GetOceanAnimationCausticsParams() const = 0;

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

Gets ocean animation parameters.

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

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

virtual uint8 GetOceanRenderFlags() const = 0;

virtual uint32 GetOceanVisiblePixelsCount() const = 0;

virtual IOpticsManager * GetOpticsManager() = 0;

virtual IParticleManager * GetParticleManager() = 0;

Gets the physics material enumerator

virtual IPhysMaterialEnumerator * GetPhysMaterialEnumerator() = 0;

A pointer to an IPhysMaterialEnumerator derived object.

virtual int32 GetPostEffectID(const char* pPostEffectName) = 0;

virtual void GetPostEffectParam(const char * pParam, float & fValue) const = 0;