Структура IndoorLocation

#include <Indoor.h>

Граф связей класса IndoorLocation:

Открытые члены
	IndoorLocation ()
int	GetSector (int sX, int sY, int sZ)
void	Release ()
bool	Alloc ()
bool	Load (const String &filename, int num_days_played, int respawn_interval_days, char *pDest)
void	Draw ()
void	ToggleLight (signed int uLightID, unsigned int bToggle)
void	ExecDraw (bool bD3D)
void	ExecDraw_d3d (unsigned int uFaceID, struct IndoorCameraD3D_Vec4 *pVertices, unsigned int uNumVertices, struct RenderVertexSoft *pPortalBounding)
void	PrepareActorRenderList_BLV ()
void	PrepareDecorationsRenderList_BLV (unsigned int uDecorationID, unsigned int uSectorID)
void	PrepareItemsRenderList_BLV ()

Открытые статические члены
static unsigned int	GetLocationIndex (const char *Str1)

Открытые атрибуты
String	filename
char	field_20 [48]
unsigned int	bLoaded
char	field_54 [404]
struct BLVHeader	blv
unsigned int	uNumVertices
struct Vec3_short_ *	pVertices
unsigned int	uNumFaces
struct BLVFace *	pFaces
unsigned int	uNumFaceExtras
struct BLVFaceExtra *	pFaceExtras
int	uNumSectors
struct BLVSector *	pSectors
int	uNumLights
struct BLVLightMM7 *	pLights
int	uNumDoors
struct BLVDoor *	pDoors
unsigned int	uNumNodes
struct BSPNode *	pNodes
BLVMapOutlines *	pMapOutlines
uint16_t *	pLFaces
uint16_t *	ptr_0002B0_sector_rdata
uint16_t *	ptr_0002B4_doors_ddata
uint16_t *	ptr_0002B8_sector_lrdata
unsigned int	uNumSpawnPoints
struct SpawnPointMM7 *	pSpawnPoints
struct DDM_DLV_Header	dlv
LocationTime_stru1	stru1
char	_visible_outlines [875]
char	padding
Log *	log = nullptr
DecalBuilder *	decal_builder = nullptr
SpellFxRenderer *	spell_fx_renderer = nullptr
LightmapBuilder *	lightmap_builder = nullptr
ParticleEngine *	particle_engine = nullptr

Подробное описание

См. определение в файле Indoor.h строка 576

Конструктор(ы)

IndoorLocation()

IndoorLocation::IndoorLocation ( )

inline

См. определение в файле Indoor.h строка 578

                            {
        this->log = EngineIoc::ResolveLogger();
        this->decal_builder = EngineIoc::ResolveDecalBuilder();
        this->spell_fx_renderer = EngineIoc::ResolveSpellFxRenderer();
        this->lightmap_builder = EngineIoc::ResolveLightmapBuilder();
        this->particle_engine = EngineIoc::ResolveParticleEngine();
 
        bLoaded = 0;
        ptr_0002B8_sector_lrdata = 0;
        ptr_0002B4_doors_ddata = 0;
        ptr_0002B0_sector_rdata = 0;
        pLFaces = 0;
        pVertices = 0;
        pFaces = 0;
        pFaceExtras = 0;
        pSectors = 0;
        pLights = 0;
        pDoors = 0;
        pNodes = 0;
        pMapOutlines = 0;
        uNumSpawnPoints = 0;
        pSpawnPoints = 0;
        uNumSectors = 0;
    }

Перекрестные ссылки bLoaded, decal_builder, lightmap_builder, log, particle_engine, pDoors, pFaceExtras, pFaces, pLFaces, pLights, pMapOutlines, pNodes, pSectors, pSpawnPoints, ptr_0002B0_sector_rdata, ptr_0002B4_doors_ddata, ptr_0002B8_sector_lrdata, pVertices, Engine_::IocContainer::ResolveDecalBuilder(), Engine_::IocContainer::ResolveLightmapBuilder(), Engine_::IocContainer::ResolveLogger(), Engine_::IocContainer::ResolveParticleEngine(), Engine_::IocContainer::ResolveSpellFxRenderer(), spell_fx_renderer, uNumSectors и uNumSpawnPoints.

Граф вызовов:

Методы

GetSector()

int IndoorLocation::GetSector	(	int	sX,
		int	sY,
		int	sZ
	)

См. определение в файле Indoor.cpp строка 1279

                                                    {
    // sx = partyx..
 
    int v25;        // edx@21
    int v26;        // ebx@23
 
    int pSectorID;  // ebx@40
    int v39;        // eax@41
    int FoundFaceStore[50];    // [sp+Ch] [bp-108h]@1
    bool Vert2AboveParty;       // [sp+ECh] [bp-28h]@19
 
    int v53;        // [sp+F8h] [bp-1Ch]@10
    int VertsPassChecks;        // [sp+FCh] [bp-18h]@16
 
 
    FoundFaceStore[0] = 0;
 
    int NumFoundFaceStore = 0;
 
    if (uNumSectors < 2) return 0;
 
    for (uint i = 1; i < uNumSectors; ++i) {
        BLVSector *pSector = &pSectors[i];
 
        if (pSector->pBounding.x1 > sX || pSector->pBounding.x2 < sX ||
            pSector->pBounding.y1 > sY || pSector->pBounding.y2 < sY ||
            pSector->pBounding.z1 - 64 > sZ || pSector->pBounding.z2 + 64 < sZ)
            continue;  // outside sector
 
        // logger->Warning(L"Sector[%u]", i);
         int FloorsAndPortals = pSector->uNumFloors + pSector->uNumPortals;
        if (!FloorsAndPortals) continue;
 
        for (uint j = 0; j < FloorsAndPortals; ++j) {
            uint uFaceID;
            if (j < pSector->uNumFloors)
                uFaceID = pSector->pFloors[j];
            else
                uFaceID = pSector->pPortals[j - pSector->uNumFloors];
 
            BLVFace *pFace = &pFaces[uFaceID];
            if (pFace->uPolygonType != POLYGON_Floor &&
                pFace->uPolygonType != POLYGON_InBetweenFloorAndWall)
                continue;
 
            VertsPassChecks = 0;
            Vert2AboveParty = pVertices[pFace->pVertexIDs[0]].y >= sY;
 
            for (uint k = 1; k <= pFace->uNumVertices; k++) {
                bool Vert1AboveParty = Vert2AboveParty;
 
                if (VertsPassChecks >= 2) break;
 
                Vec3<int16_t> *v2 = &pVertices[pFace->pVertexIDs[k]];
                Vert2AboveParty = v2->y >= sY;
 
                if (Vert1AboveParty == Vert2AboveParty) continue;
 
                Vec3<int16_t> *v1 = &pVertices[pFace->pVertexIDs[k - 1]];
                v25 = v2->x >= sX ? 0 : 2;
                v26 = v25 | (v1->x < sX);
 
                if (v26 == 3) continue;  // v1 and v2 less than x
 
                if (!v26) {
                    ++VertsPassChecks;  // both greater than x
                } else {
                    if (v1->x >= v2->x) {
                        /*int _a58;
                        int _a59;
 
                        v32 = v1->x - v2->x;
                        LODWORD(v33) = v32 << 16;
                        HIDWORD(v33) = v32 >> 16;*/
                        // fixpoint_div(v1->x - v2->x, v1->y - v2->y);
                        // _a58 = v33 / (v1->y - v2->y);
                        // _a59 = fixpoint_mul(_a58, sY - v2->y);
                        long long x_div_y =
                            fixpoint_div(v1->x - v2->x, v1->y - v2->y);
                        long long res = fixpoint_mul(
                            x_div_y,
                            sY - v2->y);  // a / b * c  - looks like projection
                        if (res + v2->x > sX) ++VertsPassChecks;
                    } else {
                        long long x_div_y =
                            fixpoint_div(v2->x - v1->x, v2->y - v1->y);
                        long long res = fixpoint_mul(x_div_y, sY - v1->y);
 
                        if (res + v1->x > sX) ++VertsPassChecks;
 
                        /*int _a58;
                        int _a59;
                        auto v32 = v2->x - v1->x;
                        LODWORD(v33) = v32 << 16;
                        HIDWORD(v33) = v32 >> 16;
                        _a58 = v33 / (v2->y - v1->y);
                        _a59 = fixpoint_mul(_a58, sY - v1->y);
 
                        if (_a59 + pVertices[k].x > sX)
                          ++VertsPassChecks;*/
                    }
                }
            }
 
            if (pFace->uNumVertices && VertsPassChecks == 1) FoundFaceStore[NumFoundFaceStore++] = uFaceID;
        }
    }
 
    // v4 = FoundFaceStore[0];
    if (NumFoundFaceStore == 1) return this->pFaces[/*v4*/FoundFaceStore[0]].uSectorID;
 
    if (!NumFoundFaceStore) return 0;
 
    // when multiple possibilities are found - cycle through and use the closer one to party
    pSectorID = 0;
    v53 = 0xFFFFFFu;
    if (NumFoundFaceStore > 0) {
        v39 = sY;
        for (int v37 = 0; v37 < NumFoundFaceStore; ++v37) {
            if (this->pFaces[FoundFaceStore[v37]].uPolygonType == POLYGON_Floor)
                v39 =
                    sZ - this->pVertices[*this->pFaces[FoundFaceStore[v37]].pVertexIDs].z;
            if (this->pFaces[FoundFaceStore[v37]].uPolygonType ==
                POLYGON_InBetweenFloorAndWall) {
                v39 =
                    sZ -
                    ((fixpoint_mul(this->pFaces[FoundFaceStore[v37]].zCalc1, (sX << 16)) +
                      fixpoint_mul(this->pFaces[FoundFaceStore[v37]].zCalc2, (sY << 16)) +
                      this->pFaces[FoundFaceStore[v37]].zCalc3 + 0x8000) >>
                     16);
            }
            if (v39 >= 0) {
                if (v39 < v53) {
                    pSectorID = this->pFaces[FoundFaceStore[v37]].uSectorID;
                    v53 = v39;
                }
            }
        }
    }
    return pSectorID;
}

Перекрестные ссылки fixpoint_div(), fixpoint_mul(), BLVSector::pBounding, pFaces, BLVSector::pFloors, POLYGON_Floor, POLYGON_InBetweenFloorAndWall, BLVSector::pPortals, pSectors, BLVFace::pVertexIDs, pVertices, BLVSector::uNumFloors, BLVSector::uNumPortals, uNumSectors, BLVFace::uNumVertices, BLVFace::uPolygonType, BLVFace::uSectorID, BBox_short_::x1, BBox_short_::x2, BBox_short_::y1, BBox_short_::y2, BBox_short_::z1, BBox_short_::z2 и BLVFace::zCalc3.

Используется в CastSpellInfoHelpers::_427E01_cast_spell(), Player::_42FA66_do_explosive_impact(), _45063B_spawn_some_monster(), Actor::AI_RangedAttack(), Actor::AI_SpellAttack(), Actor::Arena_summon_actor(), BLV_ProcessPartyActions(), collide_against_floor(), collide_against_floor_approximate(), SpriteObject::Create_Splash_Object(), Engine::DrawGUI(), Engine::DropHeldItem(), EventCastSpell(), Application::Game::EventLoop(), Actor::Explode(), Actor::MakeActorAIList_BLV(), Chest::Open(), BLVRenderParams::Reset(), SpawnEncounter(), MapInfo::SpawnRandomTreasure(), sub_4070EF_prolly_detect_player(), sub_407A1C(), Party::sub_421B2C_PlaceInInventory_or_DropPickedItem(), SpriteObject::sub_42F7EB_DropItemAt(), sub_44FA4C_spawn_light_elemental(), sub_450521_ProllyDropItemAt(), Actor::SummonMinion(), UpdateActors_BLV() и SpriteObject::UpdateObject_fn0_BLV().

Граф вызовов:

Граф вызова функции:

Release()

void IndoorLocation::Release

(

)

См. определение в файле Indoor.cpp строка 761

                             {
    free(this->ptr_0002B4_doors_ddata);
    this->ptr_0002B4_doors_ddata = NULL;
 
    free(this->ptr_0002B0_sector_rdata);
    this->ptr_0002B0_sector_rdata = NULL;
 
    free(this->ptr_0002B8_sector_lrdata);
    this->ptr_0002B8_sector_lrdata = NULL;
 
    free(this->pLFaces);
    this->pLFaces = NULL;
 
    free(this->pSpawnPoints);
    this->pSpawnPoints = NULL;
 
    this->uNumSectors = 0;
    this->uNumFaces = 0;
    this->uNumVertices = 0;
    this->uNumNodes = 0;
    this->uNumDoors = 0;
    this->uNumLights = 0;
 
    free(this->pVertices);
    this->pVertices = NULL;
 
    free(this->pFaces);
    this->pFaces = NULL;
 
    free(this->pFaceExtras);
    this->pFaceExtras = NULL;
 
    free(this->pSectors);
    this->pSectors = NULL;
 
    free(this->pLights);
    this->pLights = NULL;
 
    free(this->pDoors);
    this->pDoors = NULL;
 
    free(this->pNodes);
    this->pNodes = NULL;
 
    free(this->pMapOutlines);
    this->pMapOutlines = NULL;
 
    this->bLoaded = 0;
}

Перекрестные ссылки bLoaded, pDoors, pFaceExtras, pFaces, pLFaces, pLights, pMapOutlines, pNodes, pSectors, pSpawnPoints, ptr_0002B0_sector_rdata, ptr_0002B4_doors_ddata, ptr_0002B8_sector_lrdata, pVertices, uNumDoors, uNumFaces, uNumLights, uNumNodes, uNumSectors и uNumVertices.

Используется в Load() и Engine::ResetCursor_Palettes_LODs_Level_Audio_SFT_Windows().

Граф вызова функции:

Alloc()

bool IndoorLocation::Alloc

(

)

См. определение в файле Indoor.cpp строка 812

                           {
    pVertices = (Vec3_short_ *)malloc(15000 * sizeof(Vec3_short_));  // 0x15F90u
    pFaces = (BLVFace *)malloc(10000 * sizeof(BLVFace));             // 0xEA600u
    pFaceExtras =
        (BLVFaceExtra *)malloc(5000 * sizeof(BLVFaceExtra));     // 0x2BF20u
    pSectors = (BLVSector *)malloc(512 * sizeof(BLVSector));     // 0xE800u
    pLights = (BLVLightMM7 *)malloc(400 * sizeof(BLVLightMM7));  // 0x1900u
    pDoors = (BLVDoor *)malloc(200 * sizeof(BLVDoor));           // 0x3E80u
    pNodes = (BSPNode *)malloc(5000 * sizeof(BSPNode));          // 0x9C40u
    pMapOutlines = (BLVMapOutlines *)malloc(sizeof(BLVMapOutlines));  // 0x14824u
    if (pVertices && pFaces && pFaceExtras && pSectors && pLights && pDoors &&
        pNodes && pMapOutlines) {
        memset(pVertices, 0, 15000 * sizeof(Vec3_short_));
        memset(pFaces, 0, 10000 * sizeof(BLVFace));
        memset(pFaceExtras, 0, 5000 * sizeof(BLVFaceExtra));
        memset(pSectors, 0, 512 * sizeof(BLVSector));
        memset(pLights, 0, 400 * sizeof(BLVLightMM7));
        memset(pDoors, 0, 200 * sizeof(BLVDoor));
        memset(pNodes, 0, 5000 * sizeof(BSPNode));
        memset(pMapOutlines, 0, sizeof(BLVMapOutlines));
        return true;
    } else {
        return false;
    }
}

Перекрестные ссылки pDoors, pFaceExtras, pFaces, pLights, pMapOutlines, pNodes, pSectors и pVertices.

Используется в Load().

Граф вызова функции:

Load()

bool IndoorLocation::Load	(	const String &	filename,
		int	num_days_played,
		int	respawn_interval_days,
		char *	pDest
	)

См. определение в файле Indoor.cpp строка 858

                                                                  {
    decal_builder->Reset(0);
 
    _6807E0_num_decorations_with_sounds_6807B8 = 0;
 
    if (bLoaded) {
        log->Warning(L"BLV is already loaded");
        return true;
    }
 
    auto blv_filename = String(filename);
    blv_filename.replace(blv_filename.length() - 4, 4, ".blv");
 
    this->filename = String(filename);
    if (!pGames_LOD->DoesContainerExist(blv_filename)) {
        Error("Unable to find %s in Games.LOD", blv_filename.c_str());
    }
 
    Release();
    if (!Alloc())
        return false;
 
    size_t blv_size = 0;
    void *rawData = pGames_LOD->LoadCompressed(blv_filename, &blv_size);
    char *pData = (char*)rawData;
 
    bLoaded = true;
 
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&blv, pData, sizeof(BLVHeader));
    pData += sizeof(BLVHeader);
    memcpy(&uNumVertices, pData, 4);
    pData += 4;
    memcpy(pVertices, pData, uNumVertices * sizeof(Vec3_short_));
 
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumFaces, pData += uNumVertices * sizeof(Vec3_short_), 4);
    pData += 4;
 
    pGameLoadingUI_ProgressBar->Progress();
 
    // memcpy(pFaces, pData, uNumFaces * sizeof(BLVFace));
    auto face_data = (BLVFace_MM7 *)pData;
    pFaces = new BLVFace[uNumFaces];
    for (unsigned int i = 0; i < uNumFaces; ++i) {
        pFaces[i].Deserialize(face_data);
        face_data++;
    }
 
    pLFaces = (unsigned __int16 *)malloc(blv.uFaces_fdata_Size);
    memcpy(pLFaces, pData += uNumFaces * sizeof(BLVFace_MM7),
           blv.uFaces_fdata_Size);
 
    for (uint i = 0, j = 0; i < uNumFaces; ++i) {
        BLVFace *pFace = &pFaces[i];
 
        pFace->pVertexIDs = &pLFaces[j];
 
        j += pFace->uNumVertices + 1;
        pFace->pXInterceptDisplacements = (short *)(&pLFaces[j]);
 
        j += pFace->uNumVertices + 1;
        pFace->pYInterceptDisplacements = (short *)(&pLFaces[j]);
 
        j += pFace->uNumVertices + 1;
        pFace->pZInterceptDisplacements = (short *)(&pLFaces[j]);
 
        j += pFace->uNumVertices + 1;
        pFace->pVertexUIDs = (__int16 *)(&pLFaces[j]);
 
        j += pFace->uNumVertices + 1;
        pFace->pVertexVIDs = (__int16 *)(&pLFaces[j]);
 
        j += pFace->uNumVertices + 1;
    }
 
    pGameLoadingUI_ProgressBar->Progress();
 
    pData += blv.uFaces_fdata_Size;
 
    for (uint i = 0; i < uNumFaces; ++i) {
        BLVFace *pFace = &pFaces[i];
 
        char pTexName[16];
        strncpy(pTexName, pData, 10);
        pData += 10;
 
        pFace->SetTexture(String(pTexName));
    }
 
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumFaceExtras, pData, 4);
    memcpy(pFaceExtras, pData += 4, uNumFaceExtras * sizeof(BLVFaceExtra));
    pData += uNumFaceExtras * sizeof(BLVFaceExtra);
 
    pGameLoadingUI_ProgressBar->Progress();
 
    // v108 = (char *)v107 + 36 * uNumFaceExtras;
    // v245 = 0;
    // *(int *)((char *)&uSourceLen + 1) = 0;
    for (uint i = 0; i < uNumFaceExtras; ++i) {
        char pTexName[32];
        strncpy(pTexName, pData, 10);
        pData += 10;
 
        if (!strcmp(pTexName, ""))
            pFaceExtras[i].uAdditionalBitmapID = -1;
        else
            pFaceExtras[i].uAdditionalBitmapID =
                pBitmaps_LOD->LoadTexture(pTexName);
    }
 
    for (uint i = 0; i < uNumFaces; ++i) {
        BLVFace *pFace = &pFaces[i];
        BLVFaceExtra *pFaceExtra = &pFaceExtras[pFace->uFaceExtraID];
 
        if (pFaceExtra->uEventID) {
            if (pFaceExtra->HasEventint())
                pFace->uAttributes |= FACE_HAS_EVENT;
            else
                pFace->uAttributes &= ~FACE_HAS_EVENT;
        }
    }
 
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumSectors, pData, 4);
    memcpy(pSectors, pData + 4, uNumSectors * sizeof(BLVSector));
    pData += 4 + uNumSectors * sizeof(BLVSector);
 
    pGameLoadingUI_ProgressBar->Progress();
 
    ptr_0002B0_sector_rdata =
        (unsigned short *)malloc(blv.uSector_rdata_Size);  //, "L.RData");
    memcpy(ptr_0002B0_sector_rdata, pData, blv.uSector_rdata_Size);
    pData += blv.uSector_rdata_Size;
 
    for (uint i = 0, j = 0; i < uNumSectors; ++i) {
        BLVSector *pSector = &pSectors[i];
 
        pSector->pFloors = &ptr_0002B0_sector_rdata[j];
        j += pSector->uNumFloors;
 
        pSector->pWalls = &ptr_0002B0_sector_rdata[j];
        j += pSector->uNumWalls;
 
        pSector->pCeilings = &ptr_0002B0_sector_rdata[j];
        j += pSector->uNumCeilings;
 
        pSector->pFluids = &ptr_0002B0_sector_rdata[j];
        j += pSector->uNumFluids;
 
        pSector->pPortals = &ptr_0002B0_sector_rdata[j];
        j += pSector->uNumPortals;
 
        pSector->pFaceIDs = &ptr_0002B0_sector_rdata[j];
        j += pSector->uNumFaces;
 
        pSector->pCogs = &ptr_0002B0_sector_rdata[j];
        j += pSector->uNumCogs;
 
        pSector->pDecorationIDs = &ptr_0002B0_sector_rdata[j];
        j += pSector->uNumDecorations;
 
        pSector->pMarkers = &ptr_0002B0_sector_rdata[j];
        j += pSector->uNumMarkers;
    }
 
    ptr_0002B8_sector_lrdata =
        (unsigned __int16 *)malloc(blv.uSector_lrdata_Size);  //, "L.RLData");
    memcpy(ptr_0002B8_sector_lrdata, pData, blv.uSector_lrdata_Size);
    pData += blv.uSector_lrdata_Size;
 
    pGameLoadingUI_ProgressBar->Progress();
 
    for (uint i = 0, j = 0; i < uNumSectors; ++i) {
        pSectors[i].pLights = ptr_0002B8_sector_lrdata + j;
        j += pSectors[i].uNumLights;
    }
 
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumDoors, pData, 4);
    pData += 4;
 
    pGameLoadingUI_ProgressBar->Progress();
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumLevelDecorations, pData, 4);
    memcpy(pLevelDecorations.data(), pData + 4,
           uNumLevelDecorations * sizeof(LevelDecoration));
    pData += 4 + uNumLevelDecorations * sizeof(LevelDecoration);
 
    for (uint i = 0; i < uNumLevelDecorations; ++i) {
        pLevelDecorations[i].uDecorationDescID =
            pDecorationList->GetDecorIdByName(pData);
 
        pData += 32;
    }
 
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumLights, pData, 4);
    memcpy(pLights, pData + 4, uNumLights * sizeof(BLVLightMM7));
    pData += 4 + uNumLights * sizeof(BLVLightMM7);
 
    pGameLoadingUI_ProgressBar->Progress();
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumNodes, pData, 4);
    memcpy(pNodes, pData + 4, uNumNodes * sizeof(BSPNode));
    pData += 4 + uNumNodes * sizeof(BSPNode);
 
    pGameLoadingUI_ProgressBar->Progress();
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumSpawnPoints, pData, 4);
    pSpawnPoints = (SpawnPointMM7 *)malloc(uNumSpawnPoints * sizeof(SpawnPointMM7));
    memcpy(pSpawnPoints, pData + 4, uNumSpawnPoints * sizeof(SpawnPointMM7));
    pData += 4 + uNumSpawnPoints * sizeof(SpawnPointMM7);
 
    pGameLoadingUI_ProgressBar->Progress();
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&pMapOutlines->uNumOutlines, pData, 4);
    memcpy(pMapOutlines->pOutlines, pData + 4, pMapOutlines->uNumOutlines * sizeof(BLVMapOutline));
    free(rawData);
 
    String dlv_filename = String(filename);
    dlv_filename.replace(dlv_filename.length() - 4, 4, ".dlv");
 
    bool bResetSpawn = false;
    size_t dlv_size = 0;
    rawData = pNew_LOD->LoadCompressed(dlv_filename, &dlv_size);
    if (rawData != nullptr) {
        pData = (char*)rawData;
        memcpy(&dlv, pData, sizeof(DDM_DLV_Header));
        pData += sizeof(DDM_DLV_Header);
    } else {
        bResetSpawn = true;
    }
 
    if (dlv.uNumFacesInBModels > 0) {
        if (dlv.uNumDecorations > 0) {
            if (dlv.uNumFacesInBModels != uNumFaces ||
                dlv.uNumDecorations != uNumLevelDecorations)
                bResetSpawn = true;
        }
    }
 
    if (dword_6BE364_game_settings_1 & GAME_SETTINGS_2000) {
        respawn_interval_days = 0x1BAF800;
    }
 
    bool bRespawnLocation = false;
    if (num_days_played - dlv.uLastRepawnDay >= respawn_interval_days &&
        (pCurrentMapName != "d29.dlv")) {
        bRespawnLocation = true;
    }
 
    char SavedOutlines[875];
    if (bResetSpawn || (bRespawnLocation || !dlv.uLastRepawnDay)) {
        if (bResetSpawn) {
            memset(SavedOutlines, 0, 875);
        } else if (bRespawnLocation || !dlv.uLastRepawnDay) {
            memcpy(SavedOutlines, pData, 875);
        }
 
        dlv.uLastRepawnDay = num_days_played;
        if (!bResetSpawn) ++dlv.uNumRespawns;
        *(int *)pDest = 1;
 
        pData = (char*)pGames_LOD->LoadCompressed(dlv_filename);
        pData += sizeof(DDM_DLV_Header);
    } else {
        *(int*)pDest = 0;
    }
 
    memcpy(_visible_outlines, pData, 875);
    pData += 875;
 
    if (*(int *)pDest) memcpy(_visible_outlines, SavedOutlines, 875);
 
    for (uint i = 0; i < pMapOutlines->uNumOutlines; ++i) {
        BLVMapOutline *pVertex = &pMapOutlines->pOutlines[i];
        if ((unsigned __int8)(1 << (7 - i % 8)) & _visible_outlines[i / 8])
            pVertex->uFlags |= 1;
    }
 
    for (uint i = 0; i < uNumFaces; ++i) {
        BLVFace *pFace = &pFaces[i];
        BLVFaceExtra *pFaceExtra = &pFaceExtras[pFace->uFaceExtraID];
 
        memcpy(&pFace->uAttributes, pData, 4);
        pData += 4;
 
        if (pFaceExtra->uEventID) {
            if (pFaceExtra->HasEventint())
                pFace->uAttributes |= FACE_HAS_EVENT;
            else
                pFace->uAttributes &= ~FACE_HAS_EVENT;
        }
    }
 
    pGameLoadingUI_ProgressBar->Progress();
 
    for (uint i = 0; i < uNumLevelDecorations; ++i) {
        memcpy(&pLevelDecorations[i].uFlags, pData, 2);
        pData += 2;
    }
 
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumActors, pData, 4);
    memcpy(&pActors, pData + 4, uNumActors * sizeof(Actor));
    pData += 4 + uNumActors * sizeof(Actor);
 
    pGameLoadingUI_ProgressBar->Progress();
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&uNumSpriteObjects, pData, 4);
    memcpy(pSpriteObjects.data(), pData + 4,
           uNumSpriteObjects * sizeof(SpriteObject));
    pData += 4 + uNumSpriteObjects * sizeof(SpriteObject);
 
    pGameLoadingUI_ProgressBar->Progress();
 
    for (uint i = 0; i < uNumSpriteObjects; ++i) {
        if (pSpriteObjects[i].containing_item.uItemID && !(pSpriteObjects[i].uAttributes & 0x0100)) {
            pSpriteObjects[i].uType = (SPRITE_OBJECT_TYPE)pItemsTable->pItems[pSpriteObjects[i].containing_item.uItemID].uSpriteID;
            pSpriteObjects[i].uObjectDescID = pObjectList->ObjectIDByItemID(pSpriteObjects[i].uType);
        }
    }
 
    pGameLoadingUI_ProgressBar->Progress();
 
    pData = ChestsDeserialize(pData);
 
    pGameLoadingUI_ProgressBar->Progress();
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(pDoors, pData, 0x3E80);
    pData += 0x3E80;
 
    // v201 = (const char *)blv.uDoors_ddata_Size;
    // v200 = (size_t)ptr_0002B4_doors_ddata;
    // v170 = malloc(ptr_0002B4_doors_ddata, blv.uDoors_ddata_Size, "L.DData");
    // v171 = blv.uDoors_ddata_Size;
    ptr_0002B4_doors_ddata = (uint16_t*)malloc(blv.uDoors_ddata_Size);  //, "L.DData");
    if (ptr_0002B4_doors_ddata == nullptr) {
        log->Warning(L"Malloc error");
        Error("Malloc");  // is this recoverable
    }
 
    memcpy(ptr_0002B4_doors_ddata, pData, blv.uDoors_ddata_Size);
    pData += blv.uDoors_ddata_Size;
 
    // Src = (BLVFace *)((char *)Src + v171);
    // v172 = 0;
    // v245 = 0;
    // if (uNumDoors > 0)
    for (uint i = 0, j = 0; i < uNumDoors; ++i) {
        BLVDoor *pDoor = &pDoors[i];
 
        pDoor->pVertexIDs = &ptr_0002B4_doors_ddata[j];
        j += pDoor->uNumVertices;
 
        pDoor->pFaceIDs = &ptr_0002B4_doors_ddata[j];
        j += pDoor->uNumFaces;
 
        pDoor->pSectorIDs = &ptr_0002B4_doors_ddata[j];
        j += pDoor->field_48;
 
        pDoor->pDeltaUs = (short *)(&ptr_0002B4_doors_ddata[j]);
        j += pDoor->uNumFaces;
 
        pDoor->pDeltaVs = (short *)(&ptr_0002B4_doors_ddata[j]);
        j += pDoor->uNumFaces;
 
        pDoor->pXOffsets = &ptr_0002B4_doors_ddata[j];
        j += pDoor->uNumOffsets;
 
        pDoor->pYOffsets = &ptr_0002B4_doors_ddata[j];
        j += pDoor->uNumOffsets;
 
        pDoor->pZOffsets = &ptr_0002B4_doors_ddata[j];
        j += pDoor->uNumOffsets;
    }
    // v190 = 0;
    // v245 = 0;
    for (uint i = 0; i < uNumDoors; ++i) {
        BLVDoor *pDoor = &pDoors[i];
 
        for (uint j = 0; j < pDoor->uNumFaces; ++j) {
            BLVFace *pFace = &pFaces[pDoor->pFaceIDs[j]];
            BLVFaceExtra *pFaceExtra = &pFaceExtras[pFace->uFaceExtraID];
 
            pDoor->pDeltaUs[j] = pFaceExtra->sTextureDeltaU;
            pDoor->pDeltaVs[j] = pFaceExtra->sTextureDeltaV;
        }
    }
 
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&stru_5E4C90_MapPersistVars, pData, 0xC8);
    pData += 0xC8;
 
    pGameLoadingUI_ProgressBar->Progress();
 
    memcpy(&stru1, pData, 0x38u);
    pData += 0x38;
 
    free(rawData);
 
    return 0;
}

Перекрестные ссылки _6807E0_num_decorations_with_sounds_6807B8, _visible_outlines, Alloc(), bLoaded, blv, ChestsDeserialize(), decal_builder, BLVFace::Deserialize(), dlv, LOD::File::DoesContainerExist(), dword_6BE364_game_settings_1, BLVDoor::field_48, filename, DecorationList::GetDecorIdByName(), BLVFaceExtra::HasEventint(), LOD::File::LoadCompressed(), LODFile_IconsBitmaps::LoadTexture(), log, ObjectList::ObjectIDByItemID(), pActors, pBitmaps_LOD, BLVSector::pCeilings, BLVSector::pCogs, pCurrentMapName, BLVSector::pDecorationIDs, pDecorationList, BLVDoor::pDeltaUs, BLVDoor::pDeltaVs, pDoors, pFaceExtras, BLVDoor::pFaceIDs, BLVSector::pFaceIDs, pFaces, BLVSector::pFloors, BLVSector::pFluids, pGameLoadingUI_ProgressBar, pGames_LOD, ItemsTable::pItems, pItemsTable, pLevelDecorations, pLFaces, BLVSector::pLights, pLights, pMapOutlines, BLVSector::pMarkers, pNew_LOD, pNodes, pObjectList, BLVMapOutlines::pOutlines, BLVSector::pPortals, GUIProgressBar::Progress(), BLVDoor::pSectorIDs, pSectors, pSpawnPoints, pSpriteObjects, ptr_0002B0_sector_rdata, ptr_0002B4_doors_ddata, ptr_0002B8_sector_lrdata, BLVDoor::pVertexIDs, BLVFace::pVertexIDs, BLVFace::pVertexUIDs, BLVFace::pVertexVIDs, pVertices, BLVSector::pWalls, BLVFace::pXInterceptDisplacements, BLVDoor::pXOffsets, BLVFace::pYInterceptDisplacements, BLVDoor::pYOffsets, BLVFace::pZInterceptDisplacements, BLVDoor::pZOffsets, Release(), DecalBuilder::Reset(), BLVFace::SetTexture(), BLVFaceExtra::sTextureDeltaU, BLVFaceExtra::sTextureDeltaV, stru1, stru_5E4C90_MapPersistVars, BLVFaceExtra::uAdditionalBitmapID, BLVFace::uAttributes, BLVHeader::uDoors_ddata_Size, BLVFaceExtra::uEventID, BLVFace::uFaceExtraID, BLVHeader::uFaces_fdata_Size, BLVMapOutline::uFlags, DDM_DLV_Header::uLastRepawnDay, uNumActors, BLVSector::uNumCeilings, BLVSector::uNumCogs, DDM_DLV_Header::uNumDecorations, BLVSector::uNumDecorations, uNumDoors, uNumFaceExtras, BLVDoor::uNumFaces, BLVSector::uNumFaces, uNumFaces, DDM_DLV_Header::uNumFacesInBModels, BLVSector::uNumFloors, BLVSector::uNumFluids, uNumLevelDecorations, BLVSector::uNumLights, uNumLights, BLVSector::uNumMarkers, uNumNodes, BLVDoor::uNumOffsets, BLVMapOutlines::uNumOutlines, BLVSector::uNumPortals, DDM_DLV_Header::uNumRespawns, uNumSectors, uNumSpawnPoints, uNumSpriteObjects, BLVDoor::uNumVertices, BLVFace::uNumVertices, uNumVertices, BLVSector::uNumWalls, BLVHeader::uSector_lrdata_Size, BLVHeader::uSector_rdata_Size и Log::Warning().

Используется в PrepareToLoadBLV().

Граф вызовов:

Граф вызова функции:

Draw()

void IndoorLocation::Draw

(

)

См. определение в файле Indoor.cpp строка 322

                          {
    // int v0; // eax@1
    // IndoorLocation_drawstru _this; // [sp+0h] [bp-4Ch]@5
    //  int v2; // [sp+44h] [bp-8h]@5
    //  int v3; // [sp+48h] [bp-4h]@5
 
    /*_this.uFlags = 0;
    if (viewparams->draw_sw_outlines)
      _this.uFlags |= BLV_RENDER_DRAW_SW_OUTLINES;
    if (viewparams->draw_d3d_outlines)
      _this.uFlags |= BLV_RENDER_DRAW_D3D_OUTLINES;
 
    _this.uFlags |= BLV_RENDER_DRAW_SW_OUTLINES;
    _this.uFlags |= BLV_RENDER_DRAW_D3D_OUTLINES;
 
    _this.field_0_timer = pEventTimer->uTotalGameTimeElapsed;
    //_this.fov_deg = 65;
    //_this.vPosition.x = pParty->vPosition.x -
    fixpoint_mul(stru_5C6E00->Cos(pParty->sRotationY),
    pParty->y_rotation_granularity);
    //_this.vPosition.y = pParty->vPosition.y -
    fixpoint_mul(stru_5C6E00->Sin(pParty->sRotationY),
    pParty->y_rotation_granularity);
    //_this.vPosition.z = pParty->vPosition.z + pParty->sEyelevel;
    //_this.sRotationX = pParty->sRotationX;
    //_this.sRotationY = pParty->sRotationY;
    _this.uViewportX = pViewport->uScreen_TL_X;
    _this.uViewportY = pViewport->uScreen_TL_Y;
    _this.uViewportZ = pViewport->uScreen_BR_X;
    _this.uViewportW = pViewport->uScreen_BR_Y;
    _this.field_3C = pViewport->field_30;
 
    _this.uTargetWidth = 640;
    _this.uTargetHeight = 480;
    _this.pTargetZ = render->pActiveZBuffer;*/
 
    // sub_440BED(&_this); -- inlined
    //{
    PrepareDrawLists_BLV();
    if (pBLVRenderParams->uPartySectorID)
        ExecDraw(true /*render->pRenderD3D != 0*/);
    render->DrawBillboardList_BLV();
    //}
 
    pParty->uFlags &= ~2;
    engine->DrawParticles();
    trail_particle_generator.UpdateParticles();
}

Перекрестные ссылки engine, ExecDraw(), pBLVRenderParams, pParty, PrepareDrawLists_BLV(), render, trail_particle_generator, Party::uFlags, BLVRenderParams::uPartySectorID и TrailParticleGenerator::UpdateParticles().

Используется в ArenaFight(), Engine::Draw() и Render::MakeScreenshot().

Граф вызовов:

Граф вызова функции:

ToggleLight()

void IndoorLocation::ToggleLight	(	signed int	uLightID,
		unsigned int	bToggle
	)

См. определение в файле Indoor.cpp строка 846

                                                                          {
    if (uCurrentlyLoadedLevelType == LEVEL_Indoor &&
        (sLightID <= pIndoor->uNumLights - 1) && (sLightID >= 0)) {
        if (bToggle)
            pIndoor->pLights[sLightID].uAtributes &= 0xFFFFFFF7;
        else
            pIndoor->pLights[sLightID].uAtributes |= 8;
        pParty->uFlags |= 2;
    }
}

Перекрестные ссылки LEVEL_Indoor, pIndoor, pLights, pParty, BLVLightMM7::uAtributes, uCurrentlyLoadedLevelType, Party::uFlags и uNumLights.

Используется в EventProcessor().

Граф вызова функции:

GetLocationIndex()

unsigned int IndoorLocation::GetLocationIndex ( const char *  Str1 )

static

См. определение в файле Indoor.cpp строка 839

                                                              {
    for (uint i = 0; i < 11; ++i)
        if (!_stricmp(Str1, _4E6BDC_loc_names[i])) return i + 1;
    return 0;
}

Перекрестные ссылки _4E6BDC_loc_names.

Используется в GUIWindow_Transition::GUIWindow_Transition() и GUIWindow_Transition::Update().

Граф вызова функции:

ExecDraw()

void IndoorLocation::ExecDraw

(

bool

bD3D

)

См. определение в файле Indoor.cpp строка 235

                                       {
    if (bD3D) {
        // pIndoor->GetSector(pParty->vPosition.x, pParty->vPosition.y, pParty->vPosition.z);
 
        for (uint i = 0; i < pBspRenderer->num_faces; ++i) {
            if (pBspRenderer->nodes[pBspRenderer->faces[i].uNodeID]
                    .viewing_portal_id == -1)
                IndoorLocation::ExecDraw_d3d(pBspRenderer->faces[i].uFaceID,
                                             nullptr, 4, nullptr);
            else
                IndoorLocation::ExecDraw_d3d(
                    pBspRenderer->faces[i].uFaceID,
                    pBspRenderer->nodes[pBspRenderer->faces[i].uNodeID]
                        .std__vector_0007AC,
                    4,
                    pBspRenderer->nodes[pBspRenderer->faces[i].uNodeID]
                        .pPortalBounding);
        }
    } else {
        for (uint j = 0; j < pBspRenderer->num_faces; ++j) {
            __debugbreak();  // no SW
            // pBLVRenderParams->field_7C =
            // &pBspRenderer->nodes[pBspRenderer->faces[j].uNodeID].PortalScreenData;
            // IndoorLocation::ExecDraw_sw(pBspRenderer->faces[j].uFaceID);
        }
    }
}

Перекрестные ссылки __debugbreak(), ExecDraw_d3d(), BspRenderer::faces, BspRenderer::nodes, BspRenderer::num_faces, pBspRenderer, BspRenderer_stru0::pPortalBounding, BspRenderer_stru0::std__vector_0007AC, BspFace::uFaceID, BspFace::uNodeID и BspRenderer_stru0::viewing_portal_id.

Используется в Draw().

Граф вызовов:

Граф вызова функции:

ExecDraw_d3d()

void IndoorLocation::ExecDraw_d3d	(	unsigned int	uFaceID,
		struct IndoorCameraD3D_Vec4 *	pVertices,
		unsigned int	uNumVertices,
		struct RenderVertexSoft *	pPortalBounding
	)

См. определение в файле Indoor.cpp строка 409

                                                                     {
    int ColourMask;  // ebx@25
    // IDirect3DTexture2 *v27; // eax@42
    unsigned int uNumVerticesa;  // [sp+24h] [bp-4h]@17
    int LightLevel;                     // [sp+34h] [bp+Ch]@25
 
    if (uFaceID >= pIndoor->uNumFaces)
        return;
 
    static RenderVertexSoft static_vertices_buff_in[64];  // buff in
    static RenderVertexSoft static_vertices_calc_out[64];  // buff out - calc portal shape
 
    static stru154 FacePlaneHolder;  // idb
 
 
    BLVFace *pFace = &pIndoor->pFaces[uFaceID];
    if (pFace->uNumVertices < 3) return;
 
    if (pFace->Invisible()) {
        return;
    }
 
    ++pBLVRenderParams->uNumFacesRenderedThisFrame;
    pFace->uAttributes |= FACE_RENDERED;
 
    if (!pFace->GetTexture()) {
        return;
    }
 
    if (!pIndoorCameraD3D->IsCulled(pFace)) {
        uNumVerticesa = pFace->uNumVertices;
 
        // copy to buff in
        for (uint i = 0; i < pFace->uNumVertices; ++i) {
            static_vertices_buff_in[i].vWorldPosition.x =
                pIndoor->pVertices[pFace->pVertexIDs[i]].x;
            static_vertices_buff_in[i].vWorldPosition.y =
                pIndoor->pVertices[pFace->pVertexIDs[i]].y;
            static_vertices_buff_in[i].vWorldPosition.z =
                pIndoor->pVertices[pFace->pVertexIDs[i]].z;
            static_vertices_buff_in[i].u = (signed short)pFace->pVertexUIDs[i];
            static_vertices_buff_in[i].v = (signed short)pFace->pVertexVIDs[i];
        }
 
        // 498377 always true - appears to be anothe function to clip vertices to portal planes??
        if (!pVertices || (engine->pStru9Instance->_498377(
                               pPortalBounding, 4, pVertices,
                               static_vertices_buff_in, &uNumVerticesa),
                           uNumVerticesa)) {
            if (pIndoorCameraD3D->CalcPortalShape(  // clips vertices to the frustum planes
                    static_vertices_buff_in, &uNumVerticesa,
                    static_vertices_calc_out,
                    pIndoorCameraD3D->std__vector_000034_prolly_frustrum, 4,
                    false, 0) != 1 || uNumVerticesa) {
                LightLevel = HEXRAYS_SHIWORD(Lights.uCurrentAmbientLightLevel);
                ColourMask =
                    (248 -
                     (HEXRAYS_SHIWORD(Lights.uCurrentAmbientLightLevel) << 3)) |
                    (((248 - (HEXRAYS_SHIWORD(Lights.uCurrentAmbientLightLevel)
                              << 3)) |
                      ((248 - (HEXRAYS_SHIWORD(Lights.uCurrentAmbientLightLevel)
                               << 3))
                       << 8))
                     << 8);
 
                FaceFlowTextureOffset(uFaceID);
 
 
                // if (uFaceID == 2215 && pFace->uAttributes & FACE_OUTLINED) __debugbreak();
                // ToDo: restore this
                // if (pFace->uAttributes & FACE_OUTLINED) {
                    lightmap_builder->ApplyLights_IndoorFace(uFaceID);
                //}
 
                // if (Lights.uNumLightsApplied > 0) __debugbreak();
 
                decal_builder->ApplyBloodsplatDecals_IndoorFace(uFaceID);
 
                pIndoorCameraD3D->ViewTransfrom_OffsetUV(static_vertices_calc_out, uNumVerticesa, array_507D30, &Lights);
 
                pIndoorCameraD3D->Project(array_507D30, uNumVerticesa, 0);
 
                lightmap_builder->StationaryLightsCount = 0;
                if (Lights.uNumLightsApplied > 0 || decal_builder->uNumDecals > 0) {
                    FacePlaneHolder.face_plane.vNormal.x =
                        pFace->pFacePlane.vNormal.x;
                    FacePlaneHolder.polygonType = pFace->uPolygonType;
                    FacePlaneHolder.face_plane.vNormal.y =
                        pFace->pFacePlane.vNormal.y;
                    FacePlaneHolder.face_plane.vNormal.z =
                        pFace->pFacePlane.vNormal.z;
                    FacePlaneHolder.face_plane.dist = pFace->pFacePlane.dist;
                }
 
                if (Lights.uNumLightsApplied > 0 && !pFace->Indoor_sky())  // for torchlight(для света факелов)
                    // if (pFace->uAttributes & FACE_OUTLINED) {
                        lightmap_builder->ApplyLights(&Lights, &FacePlaneHolder, uNumVerticesa, array_507D30, pVertices, 0);
                    //}
 
                // bool LightmapBuilder::ApplyLights(LightsData *pLights, stru154 *a3, unsigned int uNumVertices,
               // RenderVertexSoft *VertexRenderList, IndoorCameraD3D_Vec4 *a6, char uClipFlag) {
 
                if (decal_builder->uNumDecals > 0)  // blood draw
                    decal_builder->ApplyDecals(LightLevel, 1, &FacePlaneHolder,
                                               uNumVerticesa, array_507D30,
                                               pVertices, 0, pFace->uSectorID);
 
                Texture *face_texture = pFace->GetTexture();
                if (pFace->Fluid()) {
                    // if (pFace->uBitmapID == render->hd_water_tile_id)
                    //    v27 =
                    //    pBitmaps_LOD->pHardwareTextures[render->pHDWaterBitmapIDs[render->hd_water_current_frame]];
                    // else
                    {
                        face_texture = (Texture *)pFace->resource;
                        // auto v24 = GetTickCount() / 4;
                        // auto v25 = v24 - stru_5C6E00->uIntegerHalfPi;
                        uint eightSeconds = OS_GetTime() % 8000;
                        float angle = (eightSeconds / 8000.0f) * 2 * 3.1415f;
 
                        // animte lava back and forth
                        for (uint i = 0; i < uNumVerticesa; ++i)
                            // array_507D30[i].v +=
                            // (double)(pBitmaps_LOD->pTextures[pFace->uBitmapID].uHeightMinus1
                            // & (unsigned int)(stru_5C6E00->SinCos(v25) >> 8));
                            array_507D30[i].v +=
                                (face_texture->GetHeight() - 1) * cosf(angle);
                    }
                } else if (pFace->IsTextureFrameTable()) {
                    face_texture = pTextureFrameTable->GetFrameTexture(
                        (int)pFace->resource, pBLVRenderParams->field_0_timer_);
                } else {
                    ColourMask = 0xFF808080;
                    // v27 = pBitmaps_LOD->pHardwareTextures[pFace->uBitmapID];
                }
 
                if (pFace->Indoor_sky()) {
                    render->DrawIndoorSky(uNumVerticesa, uFaceID);
                } else {
                   // if (pFace->uAttributes & FACE_OUTLINED) {
                        render->DrawIndoorPolygon(uNumVerticesa, pFace, PID(OBJECT_BModel, uFaceID), ColourMask, 0);
                    //}
                }
                return;
            }
        }
    }
}

Перекрестные ссылки DecalBuilder::ApplyBloodsplatDecals_IndoorFace(), DecalBuilder::ApplyDecals(), LightmapBuilder::ApplyLights(), LightmapBuilder::ApplyLights_IndoorFace(), array_507D30, IndoorCameraD3D::CalcPortalShape(), decal_builder, Plane_float_::dist, engine, stru154::face_plane, FaceFlowTextureOffset(), BLVRenderParams::field_0_timer_, BLVFace::Fluid(), TextureFrameTable::GetFrameTexture(), Image::GetHeight(), BLVFace::GetTexture(), BLVFace::Indoor_sky(), BLVFace::Invisible(), IndoorCameraD3D::IsCulled(), BLVFace::IsTextureFrameTable(), lightmap_builder, Lights, OBJECT_BModel, OS_GetTime(), pBLVRenderParams, BLVFace::pFacePlane, pFaces, pIndoor, pIndoorCameraD3D, stru154::polygonType, IndoorCameraD3D::Project(), pTextureFrameTable, BLVFace::pVertexIDs, BLVFace::pVertexUIDs, BLVFace::pVertexVIDs, pVertices, render, BLVFace::resource, LightmapBuilder::StationaryLightsCount, IndoorCameraD3D::std__vector_000034_prolly_frustrum, RenderVertexSoft::u, BLVFace::uAttributes, LightsData::uCurrentAmbientLightLevel, DecalBuilder::uNumDecals, uNumFaces, BLVRenderParams::uNumFacesRenderedThisFrame, LightsData::uNumLightsApplied, BLVFace::uNumVertices, BLVFace::uPolygonType, BLVFace::uSectorID, RenderVertexSoft::v, IndoorCameraD3D::ViewTransfrom_OffsetUV(), Plane_float_::vNormal, RenderVertexSoft::vWorldPosition, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

Используется в ExecDraw().

Граф вызовов:

Граф вызова функции:

PrepareActorRenderList_BLV()

void IndoorLocation::PrepareActorRenderList_BLV

(

)

См. определение в файле Indoor.cpp строка 2739

                                                {  // combines this with outdoorlocation ??
    unsigned int v4;  // eax@5
    int v6;           // esi@5
    int v8;           // eax@10
    SpriteFrame *v9;  // eax@16
    int v12;          // ecx@28
    __int16 v41;      // [sp+3Ch] [bp-18h]@18
    // int z; // [sp+48h] [bp-Ch]@32
    // signed int y; // [sp+4Ch] [bp-8h]@32
    // int x; // [sp+50h] [bp-4h]@32
 
    for (uint i = 0; i < uNumActors; ++i) {
        if (pActors[i].uAIState == Removed || pActors[i].uAIState == Disabled)
            continue;
 
        v4 = stru_5C6E00->Atan2(
            pActors[i].vPosition.x - pIndoorCameraD3D->vPartyPos.x,
            pActors[i].vPosition.y - pIndoorCameraD3D->vPartyPos.y);
        v6 = ((signed int)(pActors[i].uYawAngle +
                           ((signed int)stru_5C6E00->uIntegerPi >> 3) - v4 +
                           stru_5C6E00->uIntegerPi) >>
              8) &
             7;
        v8 = pActors[i].uCurrentActionTime;
        if (pParty->bTurnBasedModeOn) {
            if (pActors[i].uCurrentActionAnimation == 1)
                v8 = i * 32 + pMiscTimer->uTotalGameTimeElapsed;
        } else {
            if (pActors[i].uCurrentActionAnimation == 1)
                v8 = i * 32 + pBLVRenderParams->field_0_timer_;
        }
        if (pActors[i].pActorBuffs[ACTOR_BUFF_STONED].Active() ||
            pActors[i].pActorBuffs[ACTOR_BUFF_PARALYZED].Active())
            v8 = 0;
 
        if (pActors[i].uAIState == Resurrected)
            v9 = pSpriteFrameTable->GetFrameBy_x(
                pActors[i].pSpriteIDs[pActors[i].uCurrentActionAnimation], v8);
        else
            v9 = pSpriteFrameTable->GetFrame(
                pActors[i].pSpriteIDs[pActors[i].uCurrentActionAnimation], v8);
 
        if (v9->icon_name == "null") continue;
 
        v41 = 0;
        if (v9->uFlags & 2) v41 = 2;
        if (v9->uFlags & 0x40000) v41 |= 0x40;
        if (v9->uFlags & 0x20000) v41 |= 0x80;
        if ((256 << v6) & v9->uFlags) v41 |= 4;
        if (v9->uGlowRadius) {
            pMobileLightsStack->AddLight(
                pActors[i].vPosition.x, pActors[i].vPosition.y,
                pActors[i].vPosition.z, pActors[i].uSectorID, v9->uGlowRadius,
                0xFFu, 0xFFu, 0xFFu, _4E94D3_light_type);
        }
 
        for (v12 = 0; v12 < pBspRenderer->uNumVisibleNotEmptySectors; ++v12) {
            if (pBspRenderer
                    ->pVisibleSectorIDs_toDrawDecorsActorsEtcFrom[v12] ==
                pActors[i].uSectorID) {
                int view_x = 0;
                int view_y = 0;
                int view_z = 0;
                bool visible = pIndoorCameraD3D->ViewClip(
                    pActors[i].vPosition.x, pActors[i].vPosition.y,
                    pActors[i].vPosition.z, &view_x, &view_y, &view_z);
                if (visible) {
                    if (abs(view_x) >= abs(view_y)) {
                        int projected_x = 0;
                        int projected_y = 0;
                        pIndoorCameraD3D->Project(view_x, view_y, view_z,
                                                  &projected_x, &projected_y);
 
                        if (uNumBillboardsToDraw >= 500) break;
                        ++uNumBillboardsToDraw;
                        ++uNumSpritesDrawnThisFrame;
 
                        pActors[i].uAttributes |= ACTOR_VISIBLE;
                        pBillboardRenderList[uNumBillboardsToDraw - 1]
                            .hwsprite = v9->hw_sprites[v6];
 
                        // error catching
                        if (v9->hw_sprites[v6]->texture->GetHeight() == 0 || v9->hw_sprites[v6]->texture->GetWidth() == 0)
                            __debugbreak();
 
                        pBillboardRenderList[uNumBillboardsToDraw - 1]
                            .uPalette = v9->uPaletteIndex;
                        pBillboardRenderList[uNumBillboardsToDraw - 1] .uIndoorSectorID = pActors[i].uSectorID;
 
                        pBillboardRenderList[uNumBillboardsToDraw - 1].fov_x = pIndoorCameraD3D->fov_x;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].fov_y = pIndoorCameraD3D->fov_y;
 
                        auto _v18_over_x =
                            fixed::FromInt(
                                floorf(pIndoorCameraD3D->fov_x + 0.5f)) /
                            fixed::FromInt(view_x);
                        pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_x = v9->scale.GetFloat() * _v18_over_x.GetFloat();
                        pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_y = v9->scale.GetFloat() * _v18_over_x.GetFloat();
 
                        if (pActors[i].pActorBuffs[ACTOR_BUFF_MASS_DISTORTION].Active()) {
                            pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_y = spell_fx_renderer->_4A806F_get_mass_distortion_value(&pActors[i]) *
                                pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_y;
                        } else if (pActors[i].pActorBuffs[ACTOR_BUFF_SHRINK].Active() &&
                                   pActors[i].pActorBuffs[ACTOR_BUFF_SHRINK].uPower > 0) {
                            pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_y =
                                    1.0f / pActors[i].pActorBuffs[ACTOR_BUFF_SHRINK].uPower *
                                    pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_y;
                        }
 
                        pBillboardRenderList[uNumBillboardsToDraw - 1].world_x = pActors[i].vPosition.x;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].world_y = pActors[i].vPosition.y;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].world_z = pActors[i].vPosition.z;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].screen_space_x = projected_x;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].screen_space_y = projected_y;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].screen_space_z = view_x;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].object_pid = PID(OBJECT_Actor, i);
                        pBillboardRenderList[uNumBillboardsToDraw - 1].field_1E = v41 & 0xFF;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].pSpriteFrame = v9;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].sTintColor = pMonsterList
                                ->pMonsters[pActors[i].pMonsterInfo.uID - 1].sTintColor;
 
                        if (pActors[i].pActorBuffs[ACTOR_BUFF_STONED].Active()) {
                            pBillboardRenderList[uNumBillboardsToDraw - 1]
                                .field_1E |= 0x100;
                        }
                    }
                }
            }
        }
    }
}

Перекрестные ссылки SpellFxRenderer::_4A806F_get_mass_distortion_value(), _4E94D3_light_type, __debugbreak(), ACTOR_BUFF_MASS_DISTORTION, ACTOR_BUFF_PARALYZED, ACTOR_BUFF_SHRINK, ACTOR_BUFF_STONED, LightsStack_MobileLight_::AddLight(), stru193_math::Atan2(), Party::bTurnBasedModeOn, Disabled, BLVRenderParams::field_0_timer_, RenderBillboard::field_1E, RenderBillboard::fov_x, IndoorCameraD3D::fov_x, RenderBillboard::fov_y, IndoorCameraD3D::fov_y, fixed::FromInt(), fixed::GetFloat(), SpriteFrameTable::GetFrame(), SpriteFrameTable::GetFrameBy_x(), Image::GetHeight(), Image::GetWidth(), SpriteFrame::hw_sprites, RenderBillboard::hwsprite, SpriteFrame::icon_name, OBJECT_Actor, RenderBillboard::object_pid, pActors, pBillboardRenderList, pBLVRenderParams, pBspRenderer, pIndoorCameraD3D, pMiscTimer, pMobileLightsStack, pMonsterList, MonsterList::pMonsters, pParty, IndoorCameraD3D::Project(), RenderBillboard::pSpriteFrame, pSpriteFrameTable, Removed, Resurrected, SpriteFrame::scale, RenderBillboard::screen_space_x, RenderBillboard::screen_space_y, RenderBillboard::screen_space_z, RenderBillboard::screenspace_projection_factor_x, RenderBillboard::screenspace_projection_factor_y, spell_fx_renderer, RenderBillboard::sTintColor, MonsterDesc::sTintColor, stru_5C6E00, Sprite::texture, SpriteFrame::uFlags, SpriteFrame::uGlowRadius, RenderBillboard::uIndoorSectorID, stru193_math::uIntegerPi, uNumActors, uNumBillboardsToDraw, uNumSpritesDrawnThisFrame, BspRenderer::uNumVisibleNotEmptySectors, RenderBillboard::uPalette, SpriteFrame::uPaletteIndex, Timer::uTotalGameTimeElapsed, IndoorCameraD3D::ViewClip(), IndoorCameraD3D::vPartyPos, RenderBillboard::world_x, RenderBillboard::world_y, RenderBillboard::world_z, Vec2< T >::x и Vec2< T >::y.

Используется в PrepareDrawLists_BLV().

Граф вызовов:

Граф вызова функции:

PrepareDecorationsRenderList_BLV()

void IndoorLocation::PrepareDecorationsRenderList_BLV	(	unsigned int	uDecorationID,
		unsigned int	uSectorID
	)

См. определение в файле Indoor.cpp строка 3042

                                                                                                        {
    unsigned int v8;       // edi@5
    int v9;                // edi@5
    int v10;               // eax@7
    SpriteFrame *v11;      // eax@7
    Particle_sw particle;  // [sp+Ch] [bp-A0h]@3
    int v30;               // [sp+8Ch] [bp-20h]@7
 
    if (pLevelDecorations[uDecorationID].uFlags & LEVEL_DECORATION_INVISIBLE)
        return;
 
    DecorationDesc *decoration = pDecorationList->GetDecoration(pLevelDecorations[uDecorationID].uDecorationDescID);
 
    if (decoration->uFlags & DECORATION_DESC_EMITS_FIRE) {
        memset(&particle, 0, sizeof(particle));  // fire,  like at the Pit's tavern
        particle.type =
            ParticleType_Bitmap | ParticleType_Rotating | ParticleType_8;
        particle.uDiffuse = 0xFF3C1E;
        particle.x = (double)pLevelDecorations[uDecorationID].vPosition.x;
        particle.y = (double)pLevelDecorations[uDecorationID].vPosition.y;
        particle.z = (double)pLevelDecorations[uDecorationID].vPosition.z;
        particle.r = 0.0;
        particle.g = 0.0;
        particle.b = 0.0;
        particle.particle_size = 1.0;
        particle.timeToLive = (rand() & 0x80) + 128;
        particle.texture = spell_fx_renderer->effpar01;
        particle_engine->AddParticle(&particle);
        return;
    }
 
    if (decoration->uFlags & DECORATION_DESC_DONT_DRAW) {
        return;
    }
 
    v8 = pLevelDecorations[uDecorationID].field_10_y_rot +
         ((signed int)stru_5C6E00->uIntegerPi >> 3) -
         stru_5C6E00->Atan2(pLevelDecorations[uDecorationID].vPosition.x -
                                pIndoorCameraD3D->vPartyPos.x,
                            pLevelDecorations[uDecorationID].vPosition.y -
                                pIndoorCameraD3D->vPartyPos.y);
    v9 = ((signed int)(stru_5C6E00->uIntegerPi + v8) >> 8) & 7;
    int v37 = pBLVRenderParams->field_0_timer_;
    if (pParty->bTurnBasedModeOn) v37 = pMiscTimer->uTotalGameTimeElapsed;
    v10 = abs(pLevelDecorations[uDecorationID].vPosition.x +
              pLevelDecorations[uDecorationID].vPosition.y);
    v11 = pSpriteFrameTable->GetFrame(decoration->uSpriteID, v37 + v10);
 
    // error catching
    if (v11->icon_name == "null") __debugbreak();
 
    v30 = 0;
    if (v11->uFlags & 2) v30 = 2;
    if (v11->uFlags & 0x40000) v30 |= 0x40;
    if (v11->uFlags & 0x20000) v30 |= 0x80;
    if ((256 << v9) & v11->uFlags) v30 |= 4;
 
    int view_x = 0;
    int view_y = 0;
    int view_z = 0;
    bool visible =
        pIndoorCameraD3D->ViewClip(pLevelDecorations[uDecorationID].vPosition.x,
                                   pLevelDecorations[uDecorationID].vPosition.y,
                                   pLevelDecorations[uDecorationID].vPosition.z,
                                   &view_x, &view_y, &view_z);
 
    if (visible) {
        if (abs(view_x) >= abs(view_y)) {
            int projected_x = 0;
            int projected_y = 0;
            pIndoorCameraD3D->Project(view_x, view_y, view_z, &projected_x,
                                      &projected_y);
 
            assert(uNumBillboardsToDraw < 500);
            ++uNumBillboardsToDraw;
            ++uNumDecorationsDrawnThisFrame;
 
            pBillboardRenderList[uNumBillboardsToDraw - 1].hwsprite =
                v11->hw_sprites[v9];
 
            if (v11->hw_sprites[v9]->texture->GetHeight() == 0 || v11->hw_sprites[v9]->texture->GetWidth() == 0)
                __debugbreak();
 
            pBillboardRenderList[uNumBillboardsToDraw - 1].uPalette =
                v11->uPaletteIndex;
            pBillboardRenderList[uNumBillboardsToDraw - 1].uIndoorSectorID =
                uSectorID;
 
            pBillboardRenderList[uNumBillboardsToDraw - 1].fov_x =
                pIndoorCameraD3D->fov_x;
            pBillboardRenderList[uNumBillboardsToDraw - 1].fov_y =
                pIndoorCameraD3D->fov_y;
            pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_x = v11->scale.GetFloat() * (int)floorf(pIndoorCameraD3D->fov_x + 0.5f) / view_x;
            pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_y = v11->scale.GetFloat() * (int)floorf(pIndoorCameraD3D->fov_y + 0.5f) / view_x;
            pBillboardRenderList[uNumBillboardsToDraw - 1].field_1E = v30;
            pBillboardRenderList[uNumBillboardsToDraw - 1].world_x =
                pLevelDecorations[uDecorationID].vPosition.x;
            pBillboardRenderList[uNumBillboardsToDraw - 1].world_y =
                pLevelDecorations[uDecorationID].vPosition.y;
            pBillboardRenderList[uNumBillboardsToDraw - 1].world_z =
                pLevelDecorations[uDecorationID].vPosition.z;
            pBillboardRenderList[uNumBillboardsToDraw - 1].screen_space_x =
                projected_x;
            pBillboardRenderList[uNumBillboardsToDraw - 1].screen_space_y =
                projected_y;
            pBillboardRenderList[uNumBillboardsToDraw - 1].screen_space_z =
                view_x;
            pBillboardRenderList[uNumBillboardsToDraw - 1].object_pid =
                PID(OBJECT_Decoration, uDecorationID);
 
            pBillboardRenderList[uNumBillboardsToDraw - 1].sTintColor = 0;
            pBillboardRenderList[uNumBillboardsToDraw - 1].pSpriteFrame = v11;
        }
    }
}

Перекрестные ссылки __debugbreak(), ParticleEngine::AddParticle(), stru193_math::Atan2(), Particle_sw::b, Party::bTurnBasedModeOn, DECORATION_DESC_DONT_DRAW, DECORATION_DESC_EMITS_FIRE, SpellFxRenderer::effpar01, BLVRenderParams::field_0_timer_, RenderBillboard::field_1E, RenderBillboard::fov_x, IndoorCameraD3D::fov_x, RenderBillboard::fov_y, IndoorCameraD3D::fov_y, Particle_sw::g, DecorationList::GetDecoration(), fixed::GetFloat(), SpriteFrameTable::GetFrame(), Image::GetHeight(), Image::GetWidth(), SpriteFrame::hw_sprites, RenderBillboard::hwsprite, SpriteFrame::icon_name, LEVEL_DECORATION_INVISIBLE, OBJECT_Decoration, RenderBillboard::object_pid, particle_engine, Particle_sw::particle_size, ParticleType_8, ParticleType_Bitmap, ParticleType_Rotating, pBillboardRenderList, pBLVRenderParams, pDecorationList, pIndoorCameraD3D, pLevelDecorations, pMiscTimer, pParty, IndoorCameraD3D::Project(), RenderBillboard::pSpriteFrame, pSpriteFrameTable, Particle_sw::r, SpriteFrame::scale, RenderBillboard::screen_space_x, RenderBillboard::screen_space_y, RenderBillboard::screen_space_z, RenderBillboard::screenspace_projection_factor_x, RenderBillboard::screenspace_projection_factor_y, spell_fx_renderer, RenderBillboard::sTintColor, stru_5C6E00, Particle_sw::texture, Sprite::texture, Particle_sw::timeToLive, Particle_sw::type, Particle_sw::uDiffuse, DecorationDesc_mm6::uFlags, SpriteFrame::uFlags, RenderBillboard::uIndoorSectorID, stru193_math::uIntegerPi, uNumBillboardsToDraw, uNumDecorationsDrawnThisFrame, RenderBillboard::uPalette, SpriteFrame::uPaletteIndex, DecorationDesc_mm6::uSpriteID, Timer::uTotalGameTimeElapsed, IndoorCameraD3D::ViewClip(), IndoorCameraD3D::vPartyPos, RenderBillboard::world_x, RenderBillboard::world_y, RenderBillboard::world_z, Vec2< T >::x, Particle_sw::x, Vec2< T >::y, Particle_sw::y и Particle_sw::z.

Используется в PrepareDrawLists_BLV().

Граф вызовов:

Граф вызова функции:

PrepareItemsRenderList_BLV()

void IndoorLocation::PrepareItemsRenderList_BLV

(

)

См. определение в файле Indoor.cpp строка 2871

                                                {
    unsigned int v6;     // eax@12
 
    for (uint i = 0; i < uNumSpriteObjects; ++i) {
        if (pSpriteObjects[i].uObjectDescID) {
            if (pSpriteObjects[i].HasSprite()) {
                if ((pSpriteObjects[i].uType < 1000 ||
                     pSpriteObjects[i].uType >= 10000) &&
                        (pSpriteObjects[i].uType < 500 ||
                         pSpriteObjects[i].uType >= 600) &&
                        (pSpriteObjects[i].uType < 811 ||
                         pSpriteObjects[i].uType >= 815) ||
                    spell_fx_renderer->RenderAsSprite(&pSpriteObjects[i])) {
                    SpriteFrame *v4 = pSpriteObjects[i].GetSpriteFrame();
                    int a6 = v4->uGlowRadius * pSpriteObjects[i].field_22_glow_radius_multiplier;
                    v6 = stru_5C6E00->Atan2(pSpriteObjects[i].vPosition.x - pIndoorCameraD3D->vPartyPos.x,
                                            pSpriteObjects[i].vPosition.y - pIndoorCameraD3D->vPartyPos.y);
                    int v7 = pSpriteObjects[i].uFacing;
                    int v9 = ((int)(stru_5C6E00->uIntegerPi + ((int)stru_5C6E00->uIntegerPi >> 3) + v7 - v6) >> 8) & 7;
 
                    pBillboardRenderList[uNumBillboardsToDraw].hwsprite = v4->hw_sprites[v9];
                    // error catching
                    if (v4->hw_sprites[v9]->texture->GetHeight() == 0 || v4->hw_sprites[v9]->texture->GetWidth() == 0)
                        __debugbreak();
 
                    // centre sprite on coords
                    int modz = pSpriteObjects[i].vPosition.z;
                    if (v4->uFlags & 0x20)
                       modz -= (int)(fixpoint_mul(v4->scale._internal, v4->hw_sprites[v9]->uBufferHeight) / 2);
 
                    int16_t v34 = 0;
                    if (v4->uFlags & 2) v34 = 2;
                    if (v4->uFlags & 0x40000) v34 |= 0x40;
                    if (v4->uFlags & 0x20000) v34 |= 0x80;
                    // v11 = (int *)(256 << v9);
                    if ((256 << v9) & v4->uFlags) v34 |= 4;
                    if (a6) {
                        pMobileLightsStack->AddLight(
                            pSpriteObjects[i].vPosition.x,
                            pSpriteObjects[i].vPosition.y,
                            pSpriteObjects[i].vPosition.z,
                            pSpriteObjects[i].uSectorID, a6,
                            pSpriteObjects[i].GetParticleTrailColorR(),
                            pSpriteObjects[i].GetParticleTrailColorG(),
                            pSpriteObjects[i].GetParticleTrailColorB(),
                            _4E94D3_light_type);
                    }
 
                    int view_x = 0;
                    int view_y = 0;
                    int view_z = 0;
 
                    bool visible = pIndoorCameraD3D->ViewClip(pSpriteObjects[i].vPosition.x,
                                                              pSpriteObjects[i].vPosition.y,
                                                              modz,
                                                              &view_x, &view_y, &view_z);
 
                    view_x -= 0.005;
 
 
                    if (visible) {
                        int projected_x = 0;
                        int projected_y = 0;
                        pIndoorCameraD3D->Project(view_x, view_y, view_z, &projected_x, &projected_y);
 
                        assert(uNumBillboardsToDraw < 499);
                        ++uNumBillboardsToDraw;
                        ++uNumSpritesDrawnThisFrame;
 
                        pSpriteObjects[i].uAttributes |= 1;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].uPalette = v4->uPaletteIndex;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].uIndoorSectorID = pSpriteObjects[i].uSectorID;
                        // if ( render->pRenderD3D )
                        {
                            pBillboardRenderList[uNumBillboardsToDraw - 1].fov_x = pIndoorCameraD3D->fov_x;
                            pBillboardRenderList[uNumBillboardsToDraw - 1].fov_y = pIndoorCameraD3D->fov_y;
                            pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_x =
                                v4->scale.GetFloat() * (int)floorf(pIndoorCameraD3D->fov_x + 0.5f) / view_x;
                            pBillboardRenderList[uNumBillboardsToDraw - 1].screenspace_projection_factor_y =
                                v4->scale.GetFloat() * (int)floorf(pIndoorCameraD3D->fov_x + 0.5f) / view_x;
                        }
 
                        pBillboardRenderList[uNumBillboardsToDraw - 1].field_1E = v34;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].world_x = pSpriteObjects[i].vPosition.x;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].world_y = pSpriteObjects[i].vPosition.y;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].world_z = pSpriteObjects[i].vPosition.z;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].screen_space_x = projected_x;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].screen_space_y = projected_y;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].sTintColor = 0;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].pSpriteFrame = v4;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].screen_space_z = view_x;
                        pBillboardRenderList[uNumBillboardsToDraw - 1].object_pid = PID(OBJECT_Item, i);
                    }
                }
            }
        }
    }
}

Перекрестные ссылки _4E94D3_light_type, __debugbreak(), fixed::_internal, LightsStack_MobileLight_::AddLight(), stru193_math::Atan2(), RenderBillboard::field_1E, fixpoint_mul(), RenderBillboard::fov_x, IndoorCameraD3D::fov_x, RenderBillboard::fov_y, IndoorCameraD3D::fov_y, fixed::GetFloat(), Image::GetHeight(), Image::GetWidth(), SpriteFrame::hw_sprites, RenderBillboard::hwsprite, OBJECT_Item, RenderBillboard::object_pid, pBillboardRenderList, pIndoorCameraD3D, pMobileLightsStack, IndoorCameraD3D::Project(), RenderBillboard::pSpriteFrame, pSpriteObjects, SpellFxRenderer::RenderAsSprite(), SpriteFrame::scale, RenderBillboard::screen_space_x, RenderBillboard::screen_space_y, RenderBillboard::screen_space_z, RenderBillboard::screenspace_projection_factor_x, RenderBillboard::screenspace_projection_factor_y, spell_fx_renderer, RenderBillboard::sTintColor, stru_5C6E00, Sprite::texture, Sprite::uBufferHeight, SpriteFrame::uFlags, SpriteFrame::uGlowRadius, RenderBillboard::uIndoorSectorID, stru193_math::uIntegerPi, uNumBillboardsToDraw, uNumSpriteObjects, uNumSpritesDrawnThisFrame, RenderBillboard::uPalette, SpriteFrame::uPaletteIndex, IndoorCameraD3D::ViewClip(), IndoorCameraD3D::vPartyPos, RenderBillboard::world_x, RenderBillboard::world_y, RenderBillboard::world_z, Vec2< T >::x и Vec2< T >::y.

Используется в PrepareDrawLists_BLV().

Граф вызовов:

Граф вызова функции:

Данные класса

filename

String IndoorLocation::filename

См. определение в файле Indoor.h строка 622

Используется в Load().

field_20

char IndoorLocation::field_20[48]

См. определение в файле Indoor.h строка 623

bLoaded

unsigned int IndoorLocation::bLoaded

См. определение в файле Indoor.h строка 624

Используется в IndoorLocation(), Load() и Release().

field_54

char IndoorLocation::field_54[404]

См. определение в файле Indoor.h строка 625

blv

struct BLVHeader IndoorLocation::blv

См. определение в файле Indoor.h строка 626

Используется в Load() и SaveGame().

uNumVertices

unsigned int IndoorLocation::uNumVertices

См. определение в файле Indoor.h строка 627

Используется в Load() и Release().

pVertices

struct Vec3_short_* IndoorLocation::pVertices

См. определение в файле Indoor.h строка 628

Используется в ViewingParams::_443365(), BspRenderer::AddFaceToRenderList_d3d(), Alloc(), Vis::BLV_CreateIntersectFacesVertexCoordList(), BLV_GetFloorLevel(), BLV_ProcessPartyActions(), BLV_UpdateDoors(), stru10::CalcPolygonLimits(), IndoorCameraD3D::DebugDrawPortal(), Vis::DetermineFacetIntersection(), DrawBook_Map_sub(), RenderOpenGL::DrawIndoorPolygon(), ExecDraw_d3d(), GameUI_DrawMinimap(), GetPortalScreenCoord(), GetSector(), IndoorLocation(), IndoorCameraD3D::IsCulled(), Load(), IndoorCameraD3D::PrepareAndDrawDebugOutline(), Release(), sub_4070EF_prolly_detect_player(), sub_4075DB(), sub_475665(), UpdateActors_BLV() и SpriteObject::UpdateObject_fn0_BLV().

uNumFaces

unsigned int IndoorLocation::uNumFaces

См. определение в файле Indoor.h строка 629

Используется в ExecDraw_d3d(), Load(), Vis::PickIndoorFaces_Keyboard(), Vis::PickIndoorFaces_Mouse(), Release() и SaveGame().

pFaces

struct BLVFace* IndoorLocation::pFaces

См. определение в файле Indoor.h строка 630

Используется в CastSpellInfoHelpers::_427E01_cast_spell(), _46E44E_collide_against_faces_and_portals(), _46F04E_collide_against_portals(), BspRenderer::AddFaceToRenderList_d3d(), Alloc(), DecalBuilder::ApplyBloodsplatDecals_IndoorFace(), LightmapBuilder::ApplyLights_IndoorFace(), BLV_GetFloorLevel(), BLV_ProcessPartyActions(), BLV_UpdateDoors(), DoInteractionWithTopmostZObject(), DrawBook_Map_sub(), Render::DrawIndoorSky(), Application::Game::EventLoop(), ExecDraw_d3d(), FaceFlowTextureOffset(), GameUI_DrawMinimap(), GameUI_WritePointedObjectStatusString(), Actor::GetDirectionInfo(), GetPortalScreenCoord(), GetSector(), IndoorLocation(), Load(), Engine::OnGameViewportClick(), Chest::Open(), Vis::PickIndoorFaces_Keyboard(), Vis::PickIndoorFaces_Mouse(), Release(), SaveGame(), sub_4070EF_prolly_detect_player(), sub_407A1C(), sub_4406BC(), sub_44861E_set_texture_indoor(), sub_44892E_set_faces_bit(), UpdateActors_BLV() и SpriteObject::UpdateObject_fn0_BLV().

uNumFaceExtras

unsigned int IndoorLocation::uNumFaceExtras

См. определение в файле Indoor.h строка 631

Используется в Load(), sub_44861E_set_texture_indoor() и sub_44892E_set_faces_bit().

pFaceExtras

struct BLVFaceExtra* IndoorLocation::pFaceExtras

См. определение в файле Indoor.h строка 632

Используется в CastSpellInfoHelpers::_427E01_cast_spell(), Alloc(), BLV_ProcessPartyActions(), BLV_UpdateDoors(), DoInteractionWithTopmostZObject(), Application::Game::EventLoop(), FaceFlowTextureOffset(), GameUI_DrawMinimap(), GameUI_WritePointedObjectStatusString(), IndoorLocation(), Vis::is_part_of_selection(), Load(), Engine::OnGameViewportClick(), Release(), sub_44861E_set_texture_indoor() и sub_44892E_set_faces_bit().

uNumSectors

int IndoorLocation::uNumSectors

См. определение в файле Indoor.h строка 633

Используется в Engine::DrawGUI(), GetSector(), IndoorLocation(), Load() и Release().

pSectors

struct BLVSector* IndoorLocation::pSectors

См. определение в файле Indoor.h строка 634

Используется в _43F55F_get_billboard_light_level(), _43F5C8_get_point_light_level_with_respect_to_lights(), _46E0B2_collide_against_decorations(), _46E44E_collide_against_faces_and_portals(), _46F04E_collide_against_portals(), AddBspNodeToRenderList(), Alloc(), LightmapBuilder::ApplyLights_IndoorFace(), BLV_GetFloorLevel(), GetSector(), IndoorLocation(), Load(), PrepareDrawLists_BLV(), Release(), sub_4070EF_prolly_detect_player(), sub_407A1C() и sub_4406BC().

uNumLights

int IndoorLocation::uNumLights

См. определение в файле Indoor.h строка 635

Используется в Load(), Release() и ToggleLight().

pLights

struct BLVLightMM7* IndoorLocation::pLights

См. определение в файле Indoor.h строка 636

Используется в _43F5C8_get_point_light_level_with_respect_to_lights(), Alloc(), LightmapBuilder::ApplyLights_IndoorFace(), IndoorLocation(), Load(), Release() и ToggleLight().

uNumDoors

int IndoorLocation::uNumDoors

См. определение в файле Indoor.h строка 637

Используется в BLV_UpdateDoors(), Load(), PrepareToLoadBLV() и Release().

pDoors

struct BLVDoor* IndoorLocation::pDoors

См. определение в файле Indoor.h строка 638

Используется в Alloc(), BLV_UpdateDoors(), Door_switch_animation(), IndoorLocation(), Load(), AudioPlayer::PlaySound(), PrepareToLoadBLV(), Release() и SaveGame().

uNumNodes

unsigned int IndoorLocation::uNumNodes

См. определение в файле Indoor.h строка 639

Используется в Load() и Release().

pNodes

struct BSPNode* IndoorLocation::pNodes

См. определение в файле Indoor.h строка 640

Используется в Alloc(), IndoorLocation(), Load(), Release() и sub_4406BC().

pMapOutlines

BLVMapOutlines* IndoorLocation::pMapOutlines

См. определение в файле Indoor.h строка 641

Используется в ViewingParams::_443365(), Alloc(), DrawBook_Map_sub(), GameUI_DrawMinimap(), IndoorLocation(), Load() и Release().

pLFaces

uint16_t* IndoorLocation::pLFaces

См. определение в файле Indoor.h строка 642

Используется в IndoorLocation(), Load() и Release().

ptr_0002B0_sector_rdata

uint16_t* IndoorLocation::ptr_0002B0_sector_rdata

См. определение в файле Indoor.h строка 643

Используется в IndoorLocation(), Load() и Release().

ptr_0002B4_doors_ddata

uint16_t* IndoorLocation::ptr_0002B4_doors_ddata

См. определение в файле Indoor.h строка 644

Используется в IndoorLocation(), Load(), Release() и SaveGame().

ptr_0002B8_sector_lrdata

uint16_t* IndoorLocation::ptr_0002B8_sector_lrdata

См. определение в файле Indoor.h строка 645

Используется в IndoorLocation(), Load() и Release().

uNumSpawnPoints

unsigned int IndoorLocation::uNumSpawnPoints

См. определение в файле Indoor.h строка 646

Используется в IndoorLocation(), Load() и PrepareToLoadBLV().

pSpawnPoints

struct SpawnPointMM7* IndoorLocation::pSpawnPoints

См. определение в файле Indoor.h строка 647

Используется в IndoorLocation(), Load(), PrepareToLoadBLV() и Release().

dlv

struct DDM_DLV_Header IndoorLocation::dlv

См. определение в файле Indoor.h строка 648

Используется в CastSpellInfoHelpers::_427E01_cast_spell(), Player::AddVariable(), Actor::ApplyFineForKillingPeasant(), Player::CompareVariable(), GetAlertStatus(), Party::GetPartyReputation(), Load(), SaveGame(), Player::SetVariable(), SpawnEncounter(), Actor::StealFrom(), sub_4B1447_party_fine(), Player::SubtractVariable() и TempleDialog().

stru1

LocationTime_stru1 IndoorLocation::stru1

См. определение в файле Indoor.h строка 649

Используется в Load(), OnMapLoad() и SaveGame().

_visible_outlines

char IndoorLocation::_visible_outlines[875]

См. определение в файле Indoor.h строка 650

Используется в DrawBook_Map_sub(), GameUI_DrawMinimap(), Load() и SaveGame().

padding

char IndoorLocation::padding

См. определение в файле Indoor.h строка 651

log

Log* IndoorLocation::log = nullptr

См. определение в файле Indoor.h строка 653

Используется в IndoorLocation() и Load().

decal_builder

DecalBuilder* IndoorLocation::decal_builder = nullptr

См. определение в файле Indoor.h строка 654

Используется в ExecDraw_d3d(), IndoorLocation() и Load().

spell_fx_renderer

SpellFxRenderer* IndoorLocation::spell_fx_renderer = nullptr

См. определение в файле Indoor.h строка 655

Используется в IndoorLocation(), PrepareActorRenderList_BLV(), PrepareDecorationsRenderList_BLV() и PrepareItemsRenderList_BLV().

lightmap_builder

LightmapBuilder* IndoorLocation::lightmap_builder = nullptr

См. определение в файле Indoor.h строка 656

Используется в ExecDraw_d3d() и IndoorLocation().

particle_engine

ParticleEngine* IndoorLocation::particle_engine = nullptr

См. определение в файле Indoor.h строка 657

Используется в IndoorLocation() и PrepareDecorationsRenderList_BLV().

---

Объявления и описания членов структур находятся в файлах:

• C:/git/world-of-might-and-magic/Engine/Graphics/Indoor.h
• C:/git/world-of-might-and-magic/Engine/Graphics/Indoor.cpp