Структура IndoorCameraD3D

#include <IndoorCameraD3D.h>

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

Открытые члены
	IndoorCameraD3D ()
virtual	~IndoorCameraD3D ()
void	ViewTransform (int x, int y, int z, int *transformed_x, int *transformed_y, int *transformed_z)
void	ViewTransform (struct RenderVertexSoft *a1a, unsigned int uNumVertices)
bool	ViewClip (int x, int y, int z, int *transformed_x, int *transformed_y, int *transformed_z, bool dont_show=false)
void	Project (int x, int y, int z, int *screenspace_x, int *screenspace_y)
void	Project (struct RenderVertexSoft *pVertices, unsigned int uNumVertices, bool fit_into_viewport=false)
double	GetPolygonMaxZ (struct RenderVertexSoft *pVertex, unsigned int uStripType)
double	GetPolygonMinZ (struct RenderVertexSoft *pVertices, unsigned int uStripType)
void	LightmapNeerClip (struct RenderVertexSoft *pInVertices, int uNumInVertices, struct RenderVertexSoft *pOutVertices, unsigned int *pOutNumVertices)
void	LightmapFarClip (struct RenderVertexSoft *pInVertices, int uNumInVertices, struct RenderVertexSoft *pOutVertices, unsigned int *pOutNumVertices)
void	_437143 (unsigned int uNumInVertices, struct RenderVertexSoft *pOutVertices, struct RenderVertexSoft *pInVertices, signed int *pOutNumVertices)
bool	_4371C3 (struct RenderVertexSoft *pVertices, unsigned int *pOutNumVertices, int _unused)
bool	CalcPortalShape (struct RenderVertexSoft *a1, unsigned int *pOutNumVertices, struct RenderVertexSoft *pVertices, IndoorCameraD3D_Vec4 *a4, signed int uNumVertices, char a6, int _unused)
char	_437376 (struct stru154 *thisa, struct RenderVertexSoft *a2, unsigned int *pOutNumVertices)
void	_4374E8_ProllyBuildFrustrum ()
void	_437607 (IndoorCameraD3D_Vec3 *a1, IndoorCameraD3D_Vec4 *a2)
void	Vec3Transform (const IndoorCameraD3D_Vec3 *pVector, IndoorCameraD3D_Vec3 *pOut)
void	CreateWorldMatrixAndSomeStuff ()
void	MatrixMultiply (struct Matrix3x3_float_ *a1, struct Matrix3x3_float_ *a2, struct Matrix3x3_float_ *a3)
void	PrepareAndDrawDebugOutline (struct BLVFace *pFace, unsigned int uDiffuse)
void	debug_outline_sw (struct RenderVertexSoft *a2, unsigned int uNumVertices, unsigned int uDiffuse, float a5)
void	debug_outline_d3d (const struct RenderVertexD3D3 *pLineVertices, unsigned int uNumLines, int uDiffuse, float z_stuff)
void	do_draw_debug_line_sw (struct RenderVertexSoft *pLineBegin, signed int sStartDiffuse, struct RenderVertexSoft *pLineEnd, signed int sEndDiffuse, unsigned int uOutNumVertices, float z_stuff)
bool	is_face_faced_to_camera (struct BLVFace *pFace, struct RenderVertexSoft *a2)
bool	GetFacetOrientation (char polyType, struct Vec3_float_ *a2, struct Vec3_float_ *a3, struct Vec3_float_ *a4)
bool	IsCulled (struct BLVFace *pFace)
void	ViewTransfrom_OffsetUV (struct RenderVertexSoft *pVertices, unsigned int uNumVertices, struct RenderVertexSoft *pOutVertices, struct LightsData *a5)
bool	ApplyViewTransform_TrueIfStillVisible_BLV (int x, int y, int z, fixed *pOutX, fixed *pOutZ, fixed *pOutY, bool clip_plane_test)
float	GetPickDepth ()
void	DebugDrawPortal (struct BLVFace *pFace)
void	CalculateRotations (int camera_rot_x, int camera_rot_y)
float	GetNearClip () const
float	GetFarClip () const

Открытые атрибуты
IndoorCameraD3D_Vec3	field_4 [3]
IndoorCameraD3D_Vec4	std__vector_000034_prolly_frustrum [6]
float	fov
float	screenCenterX
float	screenCenterY
float	fov_x
float	fov_y
float	inv_fov
float	_unused_blv_party_x
float	_unused_blv_party_y
float	_unused_blv_party_z
char	field_E8 [32]
float	field_108
float	_unused_blv_party_x_2
float	_unused_blv_party_y_2
float	_unused_blv_party_z_2
char	field_118 [32]
float	field_138
char	field_13C [44]
float	field_168
char	field_16C [44]
float	field_198
char	field_19C [44]
float	field_1C8
char	field_1CC [44]
float	field_1F8
char	field_1FC [44]
float	field_228
char	field_22C [44]
float	field_258
char	field_25C [44]
float	field_288
char	field_28C [44]
float	field_2B8
float	field_2BC
float	field_2C0
float	field_2C4
char	field_2C8 [32]
float	field_2E8
float	field_2EC
float	field_2F0
float	field_2F4
char	field_2F8 [32]
float	field_318
float	field_31C
float	field_320
float	field_324
char	field_328 [32]
float	field_348
float	field_34C
float	field_350
float	field_354
char	field_358 [32]
float	field_378
IndoorCameraD3D_stru3	list_0037C [16384]
unsigned int	list_0037C_size
IndoorCameraD3D_stru2	list_E0380 [256]
int	list_E0380_size
int	sRotationY
int	sRotationX
float	fRotationYSine
float	fRotationYCosine
float	fRotationXSine
float	fRotationXCosine
Vec3< int >	vPartyPos
int	debug_flags
int	int_sine_y
int	int_cosine_y
int	int_sine_x
int	int_cosine_x

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

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

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

IndoorCameraD3D()

IndoorCameraD3D::IndoorCameraD3D

(

)

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

                                 {
    this->field_108 = 0.0;
    this->field_138 = 0.0;
    this->field_168 = 0.0;
    this->field_198 = 0.0;
    this->field_1C8 = 0.0;
    this->field_1F8 = 0.0;
    this->field_228 = 0.0;
    this->field_258 = 0.0;
    this->field_288 = 0.0;
    this->field_2B8 = 0.0;
    this->field_2E8 = 0.0;
    this->field_2BC = 0.0;
    this->field_2C0 = 0.0;
    this->field_2C4 = 0.0;
    this->field_318 = 0.0;
    this->field_2EC = 0.0;
    this->field_2F0 = 0.0;
    this->field_2F4 = 0.0;
    this->field_348 = 0.0;
    this->field_31C = 0.0;
    this->field_320 = 0.0;
    this->field_324 = 0.0;
    this->field_378 = 0.0;
    this->field_34C = 0.0;
    this->field_350 = 0.0;
    this->field_354 = 0.0;
    for (uint i = 0; i < 16384; ++i) {
        list_0037C[i].field_0 = 0;
        list_0037C[i].flt_30 = 0.0f;
    }
    list_0037C_size = 0;
    for (uint i = 0; i < 256; ++i) list_E0380[i].mm7__vector_000004_size = 0;
    list_E0380_size = 0;
}

Перекрестные ссылки IndoorCameraD3D_stru3::field_0, field_108, field_138, field_168, field_198, field_1C8, field_1F8, field_228, field_258, field_288, field_2B8, field_2BC, field_2C0, field_2C4, field_2E8, field_2EC, field_2F0, field_2F4, field_318, field_31C, field_320, field_324, field_348, field_34C, field_350, field_354, field_378, IndoorCameraD3D_stru3::flt_30, list_0037C, list_0037C_size, list_E0380 и list_E0380_size.

~IndoorCameraD3D()

virtual IndoorCameraD3D::~IndoorCameraD3D ( )

inlinevirtual

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

{}

Методы

ViewTransform() [1/2]

void IndoorCameraD3D::ViewTransform	(	int	x,
		int	y,
		int	z,
		int *	transformed_x,
		int *	transformed_y,
		int *	transformed_z
	)

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

                                                                            {
    RenderVertexSoft v;
    v.vWorldPosition.x = x;
    v.vWorldPosition.y = y;
    v.vWorldPosition.z = z;
 
    this->ViewTransform(&v, 1);
    if (transformed_x) {
        *transformed_x = floorf(v.vWorldViewPosition.x + 0.5f);
    }
 
    if (transformed_y) {
        *transformed_y = floorf(v.vWorldViewPosition.y + 0.5f);
    }
 
    if (transformed_z) {
        *transformed_z = floorf(v.vWorldViewPosition.z + 0.5f);
    }
}

Используется в LightmapBuilder::_45BE86_build_light_polygon(), DecalBuilder::_49B790_build_decal_geometry(), DebugDrawPortal(), Vis::DetermineFacetIntersection(), do_draw_debug_line_sw(), Render::DrawBuildingsD3D(), SpellFxRenderer::DrawProjectiles(), Vis::PickIndoorFaces_Mouse(), Vis::PickOutdoorFaces_Mouse(), Render::RenderTerrainD3D(), SpellFX_Billboard::SpellFXViewTransform(), ViewClip() и ViewTransfrom_OffsetUV().

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

ViewTransform() [2/2]

void IndoorCameraD3D::ViewTransform	(	struct RenderVertexSoft *	a1a,
		unsigned int	uNumVertices
	)

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

                                                                                    {
    for (uint i = 0; i < uNumVertices; ++i) {
        RenderVertexSoft *a1 = &a1a[i];
 
        double vCamToVertexX = a1->vWorldPosition.x - (double)pIndoorCameraD3D->vPartyPos.x;
        double vCamToVertexY = a1->vWorldPosition.y - (double)pIndoorCameraD3D->vPartyPos.y;
        double vCamToVertexZ = a1->vWorldPosition.z - (double)pIndoorCameraD3D->vPartyPos.z;
 
        if (pIndoorCameraD3D->sRotationX) {
            double v5 = vCamToVertexY * fRotationYSine + fRotationYCosine * vCamToVertexX;
 
            a1->vWorldViewPosition.x = v5 * fRotationXCosine /*+*/ - fRotationXSine * vCamToVertexZ;
            a1->vWorldViewPosition.y = fRotationYCosine * vCamToVertexY - fRotationYSine * vCamToVertexX;
            a1->vWorldViewPosition.z = fRotationXCosine * vCamToVertexZ /*-*/ + v5 * fRotationXSine;
        } else {
            a1->vWorldViewPosition.x = fRotationYSine * vCamToVertexY + fRotationYCosine * vCamToVertexX;
            a1->vWorldViewPosition.y = fRotationYCosine * vCamToVertexY - fRotationYSine * vCamToVertexX;
            a1->vWorldViewPosition.z = vCamToVertexZ;
        }
    }
 
        // this tranforms to odd axis
        // x would usually be z (depth)
        // y would usually be x
        // z would usually be y
 
        // above is corrected back to normal during projection - sort later
    // invert xrotation in calc rotations rather than transform
}

Перекрестные ссылки fRotationXCosine, fRotationXSine, fRotationYCosine, fRotationYSine, pIndoorCameraD3D, sRotationX, vPartyPos, RenderVertexSoft::vWorldPosition, RenderVertexSoft::vWorldViewPosition, Vec2< T >::x, Vec3_float_::x, Vec2< T >::y, Vec3_float_::y, Vec3< T >::z и Vec3_float_::z.

ViewClip()

bool IndoorCameraD3D::ViewClip	(	int	x,
		int	y,
		int	z,
		int *	transformed_x,
		int *	transformed_y,
		int *	transformed_z,
		bool	dont_show = false
	)

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

                                               {
    this->ViewTransform(x, y, z, transformed_x, transformed_y, transformed_z);
 
    if (dont_show) {
        return false;
    }
    return *transformed_x >= this->GetNearClip() &&
           *transformed_x <= this->GetFarClip();
}

Перекрестные ссылки GetFarClip(), GetNearClip() и ViewTransform().

Используется в RenderBase::DrawSpriteObjects_ODM(), IndoorLocation::PrepareActorRenderList_BLV(), OutdoorLocation::PrepareActorsDrawList(), IndoorLocation::PrepareDecorationsRenderList_BLV(), RenderOpenGL::PrepareDecorationsRenderList_ODM(), Render::PrepareDecorationsRenderList_ODM(), IndoorLocation::PrepareItemsRenderList_BLV() и ParticleEngine::ViewProject_TrueIfStillVisible_BLV().

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

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

Project() [1/2]

void IndoorCameraD3D::Project	(	int	x,
		int	y,
		int	z,
		int *	screenspace_x,
		int *	screenspace_y
	)

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

                                                  {
    RenderVertexSoft v;
    v.vWorldViewPosition.x = x;
    v.vWorldViewPosition.y = y;
    v.vWorldViewPosition.z = z;
 
    this->Project(&v, 1, false);
 
    if (screenspace_x) {
        *screenspace_x = floorf(v.vWorldViewProjX + 0.5f);
    }
 
    if (screenspace_y) {
        *screenspace_y = floorf(v.vWorldViewProjY + 0.5f);
    }
}

Используется в LightmapBuilder::_45BE86_build_light_polygon(), DecalBuilder::_49B790_build_decal_geometry(), DebugDrawPortal(), Vis::DetermineFacetIntersection(), do_draw_debug_line_sw(), Render::DrawBuildingsD3D(), SpellFxRenderer::DrawProjectiles(), RenderBase::DrawSpriteObjects_ODM(), IndoorLocation::ExecDraw_d3d(), IndoorLocation::PrepareActorRenderList_BLV(), OutdoorLocation::PrepareActorsDrawList(), IndoorLocation::PrepareDecorationsRenderList_BLV(), RenderOpenGL::PrepareDecorationsRenderList_ODM(), Render::PrepareDecorationsRenderList_ODM(), IndoorLocation::PrepareItemsRenderList_BLV(), Render::RenderTerrainD3D(), SpellFX_Billboard::SpellFXProject() и ParticleEngine::ViewProject_TrueIfStillVisible_BLV().

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

Project() [2/2]

void IndoorCameraD3D::Project	(	struct RenderVertexSoft *	pVertices,
		unsigned int	uNumVertices,
		bool	fit_into_viewport = false
	)

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

                                                      {
    // double v7;   // st7@7
    double v8;   // st7@9
    double v9;   // st6@10
    double v10;  // st5@12
    double v11;  // st7@16
    double v12;  // st6@17
    double v13;  // st5@19
    double v1;
    double v2;
 
    for (uint i = 0; i < uNumVertices; ++i) {
        /*if (_4D864C_force_sw_render_rules && engine->config->ForceLegacyProjection() ||
            uCurrentlyLoadedLevelType == LEVEL_Indoor) {
 
            v1 = 1.0 / pVertices[i].vWorldViewPosition.x;
 
            pVertices[i].vWorldViewProjX =
                pVertices[i].vWorldViewPosition.y * fov * v1 + screenCenterX;
 
            pVertices[i].vWorldViewProjY =
                (signed int)pViewport->uViewportBR_Y -
                (pVertices[i].vWorldViewPosition.z * fov * v1 + screenCenterY);
 
        } else {*/
            auto v = pVertices + i;
 
 
            v1 = 1.0 / (v->vWorldViewPosition.x + 0.0000001);
            v->_rhw = v1;
 
            // if indoors use fov - if outdoors use as below - fix later
            if (uCurrentlyLoadedLevelType == LEVEL_Indoor) {
                v2 = v1 * fov;
            } else {
                v2 = v1 * (double)pODMRenderParams->int_fov_rad;
            }
 
            v->vWorldViewProjX = (double)pViewport->uScreenCenterX -
                                 v2 * v->vWorldViewPosition.y;
            v->vWorldViewProjY = (double)pViewport->uScreenCenterY -
                                 v2 * v->vWorldViewPosition.z;
        //}
 
        if (fit_into_viewport) {
            //        __debugbreak();
            v8 = (double)(signed int)pViewport->uViewportBR_X;
            if (v8 >= pVertices[i].vWorldViewProjX)
                v9 = pVertices[i].vWorldViewProjX;
            else
                v9 = v8;
            v10 = (double)(signed int)pViewport->uViewportTL_X;
            if (v10 <= v9) {
                if (v8 >= pVertices[i].vWorldViewProjX)
                    v8 = pVertices[i].vWorldViewProjX;
            } else {
                v8 = v10;
            }
            pVertices[i].vWorldViewProjX = v8;
            v11 = (double)(signed int)pViewport->uViewportBR_Y;
            if (v11 >= pVertices[i].vWorldViewProjY)
                v12 = pVertices[i].vWorldViewProjY;
            else
                v12 = v11;
            v13 = (double)(signed int)pViewport->uViewportTL_Y;
            if (v13 <= v12) {
                if (v11 >= pVertices[i].vWorldViewProjY)
                    v11 = pVertices[i].vWorldViewProjY;
            } else {
                v11 = v13;
            }
            pVertices[i].vWorldViewProjY = v11;
        }
    }
}

Перекрестные ссылки fov, ODMRenderParams::int_fov_rad, LEVEL_Indoor, pODMRenderParams, pVertices, pViewport, uCurrentlyLoadedLevelType, Viewport::uScreenCenterX, Viewport::uScreenCenterY, Viewport::uViewportBR_X, Viewport::uViewportBR_Y, Viewport::uViewportTL_X и Viewport::uViewportTL_Y.

GetPolygonMaxZ()

double IndoorCameraD3D::GetPolygonMaxZ	(	struct RenderVertexSoft *	pVertex,
		unsigned int	uStripType
	)

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

                                                                {
    double result;  // st7@1
 
    result = 1.1754944e-38;
    for (uint i = 0; i < uStripType; i++) {
        if (pVertex[i].vWorldPosition.z > result)
            result = pVertex[i].vWorldPosition.z;
    }
    return result;
}

Перекрестные ссылки RenderVertexSoft::vWorldPosition и Vec3_float_::z.

Используется в DecalBuilder::ApplyBloodSplatToTerrain() и LightmapBuilder::StackLight_TerrainFace().

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

GetPolygonMinZ()

double IndoorCameraD3D::GetPolygonMinZ	(	struct RenderVertexSoft *	pVertices,
		unsigned int	uStripType
	)

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

                                                                {
    double result = FLT_MAX;
    for (uint i = 0; i < uStripType; i++) {
        if (pVertices[i].vWorldPosition.z < result) {
            result = pVertices[i].vWorldPosition.z;
        }
    }
    return result;
}

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

Используется в DecalBuilder::ApplyBloodSplatToTerrain() и LightmapBuilder::StackLight_TerrainFace().

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

LightmapNeerClip()

void IndoorCameraD3D::LightmapNeerClip	(	struct RenderVertexSoft *	pInVertices,
		int	uNumInVertices,
		struct RenderVertexSoft *	pOutVertices,
		unsigned int *	pOutNumVertices
	)

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

                                                                      {
    float nearclip = pIndoorCameraD3D->GetNearClip();
 
    double t;                    // st6@11
    bool current_vertices_flag;  // esi@2
    bool next_vertices_flag;     // [sp+Ch] [bp+8h]@7
 
    // check for near clip plane(проверка по ближней границе)
    //
    // v3.__________________. v0
    //   |                  |
    //   |                  |
    //   |                  |
    //  ----------------------- 8.0(near_clip - 8.0)
    //   |                  |
    //   .__________________.
    //  v2                     v1
 
    int out_num_vertices = 0;
 
    if (uNumInVertices) {
        memcpy(&pInVertices[uNumInVertices], &pInVertices[0],
               sizeof(pInVertices[0]));
        next_vertices_flag = false;
        current_vertices_flag = false;
        if (pInVertices[0].vWorldViewPosition.x <= nearclip)
            current_vertices_flag = true;
        for (uint i = 0; i < uNumInVertices; ++i) {
            next_vertices_flag =
                pInVertices[i + 1].vWorldViewPosition.x <= nearclip;  //
            if (current_vertices_flag ^ next_vertices_flag) {  // XOR
                if (next_vertices_flag) {  // следующая вершина за ближней границей
                    // t = near_clip - v0.x / v1.x - v0.x    (формула получения
                    // точки пересечения отрезка с плоскостью)
                    t = (nearclip - pInVertices[i].vWorldViewPosition.x) /
                        (pInVertices[i + 1].vWorldViewPosition.x -
                         pInVertices[i].vWorldViewPosition.x);
                    pOutVertices[out_num_vertices].vWorldViewPosition.x = nearclip;
                    pOutVertices[out_num_vertices].vWorldViewPosition.y =
                        pInVertices[i].vWorldViewPosition.y +
                        (pInVertices[i + 1].vWorldViewPosition.y -
                         pInVertices[i].vWorldViewPosition.y) *
                            t;
                    pOutVertices[out_num_vertices].vWorldViewPosition.z =
                        pInVertices[i].vWorldViewPosition.z +
                        (pInVertices[i + 1].vWorldViewPosition.z -
                         pInVertices[i].vWorldViewPosition.z) *
                            t;
                    pOutVertices[out_num_vertices].u =
                        pInVertices[i].u +
                        (pInVertices[i + 1].u - pInVertices[i].u) * t;
                    pOutVertices[out_num_vertices].v =
                        pInVertices[i].v +
                        (pInVertices[i + 1].v - pInVertices[i].v) * t;
                    pOutVertices[out_num_vertices]._rhw = 1.0 / 8.0;
                    // pOutVertices[*pOutNumVertices]._rhw = 0.125;
                } else {  // текущая вершина за ближней границей
                    t = (nearclip - pInVertices[i].vWorldViewPosition.x) /
                        (pInVertices[i].vWorldViewPosition.x -
                         pInVertices[i + 1].vWorldViewPosition.x);
                    pOutVertices[out_num_vertices].vWorldViewPosition.x = nearclip;
                    pOutVertices[out_num_vertices].vWorldViewPosition.y =
                        pInVertices[i].vWorldViewPosition.y +
                        (pInVertices[i].vWorldViewPosition.y -
                         pInVertices[i + 1].vWorldViewPosition.y) *
                            t;
                    pOutVertices[out_num_vertices].vWorldViewPosition.z =
                        pInVertices[i].vWorldViewPosition.z +
                        (pInVertices[i].vWorldViewPosition.z -
                         pInVertices[i + 1].vWorldViewPosition.z) *
                            t;
                    pOutVertices[out_num_vertices].u =
                        pInVertices[i].u +
                        (pInVertices[i].u - pInVertices[i + 1].u) * t;
                    pOutVertices[out_num_vertices].v =
                        pInVertices[i].v +
                        (pInVertices[i].v - pInVertices[i + 1].v) * t;
                    pOutVertices[out_num_vertices]._rhw = 1.0 / nearclip;
                }
                ++out_num_vertices;
            }
            if (!next_vertices_flag) {
                memcpy(&pOutVertices[out_num_vertices], &pInVertices[i + 1],
                       sizeof(pInVertices[i + 1]));
                // pOutVertices[out_num_vertices]._rhw = 1.0 /
                // (pInVertices[i].vWorldViewPosition.x + 0.0000001);
                out_num_vertices++;
            }
            current_vertices_flag = next_vertices_flag;
        }
        if (out_num_vertices >= 3)
            *pOutNumVertices = out_num_vertices;
        else
            *pOutNumVertices = 0;
    }
}

Перекрестные ссылки RenderVertexSoft::_rhw, GetNearClip(), pIndoorCameraD3D, RenderVertexSoft::u, RenderVertexSoft::v, RenderVertexSoft::vWorldViewPosition, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

Используется в LightmapBuilder::_45BE86_build_light_polygon() и DecalBuilder::_49B790_build_decal_geometry().

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

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

LightmapFarClip()

void IndoorCameraD3D::LightmapFarClip	(	struct RenderVertexSoft *	pInVertices,
		int	uNumInVertices,
		struct RenderVertexSoft *	pOutVertices,
		unsigned int *	pOutNumVertices
	)

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

                                                                     {
    bool current_vertices_flag;
    bool next_vertices_flag;
    double t;
    signed int depth_num_vertices;
 
    memcpy(&pInVertices[uNumInVertices], &pInVertices[0],
           sizeof(pInVertices[uNumInVertices]));
    depth_num_vertices = 0;
    current_vertices_flag = false;
    if (pInVertices[0].vWorldViewPosition.x >= pIndoorCameraD3D->GetFarClip())
        current_vertices_flag =
            true;  //настоящая вершина больше границы видимости
    if ((signed int)uNumInVertices <= 0) return;
    // check for far clip plane(проверка по дальней границе)
    //
    // v3.__________________. v0
    //   |                  |
    //   |                  |
    //   |                  |
    //  ----------------------- 8192.0(far_clip - 0x2000)
    //   |                  |
    //   .__________________.
    //  v2                     v1
 
    for (uint i = 0; i < uNumInVertices; ++i) {
        next_vertices_flag = pInVertices[i + 1].vWorldViewPosition.x >=
                             pIndoorCameraD3D->GetFarClip();
        if (current_vertices_flag ^
            next_vertices_flag) {  // одна из граней за границей видимости
            if (next_vertices_flag) {  // следующая вершина больше границы
                                       // видимости(настоящая вершина меньше
                                       // границы видимости) - v3
                // t = far_clip - v2.x / v3.x - v2.x (формула получения точки
                // пересечения отрезка с плоскостью)
                t = (pIndoorCameraD3D->GetFarClip() -
                     pInVertices[i].vWorldViewPosition.x) /
                    (pInVertices[i].vWorldViewPosition.x -
                     pInVertices[i + 1].vWorldViewPosition.x);
                pOutVertices[depth_num_vertices].vWorldViewPosition.x =
                    pIndoorCameraD3D->GetFarClip();
                // New_y = v2.y + (v3.y - v2.y)*t
                pOutVertices[depth_num_vertices].vWorldViewPosition.y =
                    pInVertices[i].vWorldViewPosition.y +
                    (pInVertices[i].vWorldViewPosition.y -
                     pInVertices[i + 1].vWorldViewPosition.y) *
                        t;
                // New_z = v2.z + (v3.z - v2.z)*t
                pOutVertices[depth_num_vertices].vWorldViewPosition.z =
                    pInVertices[i].vWorldViewPosition.z +
                    (pInVertices[i].vWorldViewPosition.z -
                     pInVertices[i + 1].vWorldViewPosition.z) *
                        t;
                pOutVertices[depth_num_vertices].u =
                    pInVertices[i].u +
                    (pInVertices[i].u - pInVertices[i + 1].u) * t;
                pOutVertices[depth_num_vertices].v =
                    pInVertices[i].v +
                    (pInVertices[i].v - pInVertices[i + 1].v) * t;
                pOutVertices[depth_num_vertices]._rhw =
                    1.0 / pIndoorCameraD3D->GetFarClip();
            } else {  // настоящая вершина больше границы видимости(следующая
                      // вершина меньше границы видимости) - v0
                // t = far_clip - v1.x / v0.x - v1.x
                t = (pIndoorCameraD3D->GetFarClip() -
                     pInVertices[i].vWorldViewPosition.x) /
                    (pInVertices[i + 1].vWorldViewPosition.x -
                     pInVertices[i].vWorldViewPosition.x);
                pOutVertices[depth_num_vertices].vWorldViewPosition.x =
                    pIndoorCameraD3D->GetFarClip();
                // New_y = (v0.y - v1.y)*t + v1.y
                pOutVertices[depth_num_vertices].vWorldViewPosition.y =
                    pInVertices[i].vWorldViewPosition.y +
                    (pInVertices[i + 1].vWorldViewPosition.y -
                     pInVertices[i].vWorldViewPosition.y) *
                        t;
                // New_z = (v0.z - v1.z)*t + v1.z
                pOutVertices[depth_num_vertices].vWorldViewPosition.z =
                    pInVertices[i].vWorldViewPosition.z +
                    (pInVertices[i + 1].vWorldViewPosition.z -
                     pInVertices[i].vWorldViewPosition.z) *
                        t;
                pOutVertices[depth_num_vertices].u =
                    pInVertices[i].u +
                    (pInVertices[i + 1].u - pInVertices[i].u) * t;
                pOutVertices[depth_num_vertices].v =
                    pInVertices[i].v +
                    (pInVertices[i + 1].v - pInVertices[i].v) * t;
                pOutVertices[depth_num_vertices]._rhw =
                    1.0 / pIndoorCameraD3D->GetFarClip();
            }
            ++depth_num_vertices;
        }
        if (!next_vertices_flag) {  // оба в границе видимости
            memcpy(&pOutVertices[depth_num_vertices], &pInVertices[i + 1],
                   sizeof(pOutVertices[depth_num_vertices]));
            depth_num_vertices++;
        }
        current_vertices_flag = next_vertices_flag;
    }
    if (depth_num_vertices >= 3)
        *pOutNumVertices = depth_num_vertices;
    else
        *pOutNumVertices = 0;
}

Перекрестные ссылки RenderVertexSoft::_rhw, GetFarClip(), pIndoorCameraD3D, RenderVertexSoft::u, RenderVertexSoft::v, RenderVertexSoft::vWorldViewPosition, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

Используется в LightmapBuilder::_45BE86_build_light_polygon() и DecalBuilder::_49B790_build_decal_geometry().

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

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

_437143()

void IndoorCameraD3D::_437143	(	unsigned int	uNumInVertices,
		struct RenderVertexSoft *	pOutVertices,
		struct RenderVertexSoft *	pInVertices,
		signed int *	pOutNumVertices
	)

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

                                                           {
    double v9;  // st7@3
 
    uint i = 0;
 
    for (; i < uNumInVertices; ++i) {
        pInVertices[i]._rhw =
            1.0 / (pInVertices[i].vWorldViewPosition.x + 0.0000001);
        memcpy(&pOutVertices[i], &pInVertices[i], sizeof(pOutVertices[i]));
        v9 = (double)pODMRenderParams->int_fov_rad * pInVertices[i]._rhw;
        pOutVertices[i].vWorldViewProjX =
            (double)pViewport->uScreenCenterX -
            v9 * pInVertices[i].vWorldViewPosition.y;
        pOutVertices[i].vWorldViewProjY =
            (double)pViewport->uScreenCenterY -
            v9 * pInVertices[i].vWorldViewPosition.z;
    }
    *pOutNumVertices = i;
    return;
}

Перекрестные ссылки RenderVertexSoft::_rhw, ODMRenderParams::int_fov_rad, pODMRenderParams, pViewport, Viewport::uScreenCenterX, Viewport::uScreenCenterY, RenderVertexSoft::vWorldViewPosition, RenderVertexSoft::vWorldViewProjX, RenderVertexSoft::vWorldViewProjY, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

Используется в LightmapBuilder::_45BE86_build_light_polygon() и DecalBuilder::_49B790_build_decal_geometry().

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

_4371C3()

bool IndoorCameraD3D::_4371C3	(	struct RenderVertexSoft *	pVertices,
		unsigned int *	pOutNumVertices,
		int	_unused
	)

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

                                                                          {
    __debugbreak();
 
    //  char *v4; // eax@2
    //  signed int v5; // ecx@2
    RenderVertexSoft *v6;           // esi@5
    unsigned int *v7;               // edi@5
    char *v8;                       // ecx@6
    int v9;                         // eax@6
    IndoorCameraD3D *thisa;         // [sp+0h] [bp-Ch]@1
    signed int v12;                 // [sp+4h] [bp-8h]@5
    unsigned int pVerticesa;        // [sp+14h] [bp+8h]@6
    unsigned int pOutNumVerticesa;  // [sp+18h] [bp+Ch]@6
 
    thisa = this;
 
    static RenderVertexSoft static_4371C3_array_50E5E0[64];
    static bool __init_flag1 = false;
    if (!__init_flag1) {
        __init_flag1 = true;
 
        for (uint i = 0; i < 64; ++i)
            static_4371C3_array_50E5E0[i].flt_2C = 0.0f;
    }
 
    v12 = 0;
    v6 = pVertices;
    v7 = pOutNumVertices;
    if ((int)*pOutNumVertices > 0) {
        pOutNumVerticesa =
            (char *)static_4371C3_array_50E5E0 - (char *)pVertices;
        pVerticesa = (char *)&static_4371C3_array_50E5E0[0].vWorldViewProjY -
                     (char *)pVertices;
        v8 = (char *)&static_4371C3_array_50E5E0[0].vWorldPosition.y;
        v9 = (int)&v6->vWorldPosition.z;
        do {
            ++v12;
            *((int *)v8 - 1) = *(int *)(v9 - 8);
            *(int *)v8 = *(int *)(v9 - 4);
            v8 += 48;
            *(float *)(pOutNumVerticesa + v9) = *(float *)v9;
            *(float *)(pVerticesa + v9) = *(float *)(v9 + 28);
            *(float *)((char *)&static_4371C3_array_50E5E0[0]._rhw -
                       (char *)v6 + v9) = *(float *)(v9 + 32);
            v9 += 48;
        } while (v12 < (signed int)*v7);
    }
    return CalcPortalShape(static_4371C3_array_50E5E0, v7, v6,
                           thisa->std__vector_000034_prolly_frustrum, 4, 0,
                           _unused);
}

Перекрестные ссылки __debugbreak(), RenderVertexSoft::_rhw, CalcPortalShape(), pVertices, std__vector_000034_prolly_frustrum, RenderVertexSoft::vWorldPosition и Vec3_float_::z.

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

CalcPortalShape()

bool IndoorCameraD3D::CalcPortalShape	(	struct RenderVertexSoft *	a1,
		unsigned int *	pOutNumVertices,
		struct RenderVertexSoft *	pVertices,
		IndoorCameraD3D_Vec4 *	a4,
		signed int	uNumVertices,
		char	a6,
		int	_unused
	)

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

                                                   {
    // NumFrustumPlanes usually 4 - top, bottom, left, right - near and far done elsewhere
    // DebugLines 0 or 1 - 1 when debug lines
 
    //  char *v8; // eax@2
    //  signed int v9; // ecx@2
    // bool result; // eax@5
    // int MinVertsAllowed;  // ecx@5
    // signed int v12; // ecx@6
    // char *v13; // esi@6
    RenderVertexSoft *v14;  // eax@8
    RenderVertexSoft *v15;  // edx@8
    Vec3_float_ FrustumPlaneVec;         // [sp+18h] [bp-3Ch]@12
    // float v17; // [sp+44h] [bp-10h]@1
    // int v18; // [sp+48h] [bp-Ch]@5
    // stru9 *thisa; // [sp+4Ch] [bp-8h]@1
    int VertsAdjusted = 0;  // [sp+53h] [bp-1h]@5
    // bool a6a; // [sp+70h] [bp+1Ch]@5
 
    // v17 = 0.0;
    // thisa = engine->pStru9Instance;
 
    static RenderVertexSoft sr_vertices_50D9D8[64];
 
    // result = 0;
    // VertsAdjusted = 0;
    int MinVertsAllowed = 2 * (DebugLines == 0) + 1;  // 3 normally 1 for debuglines
    // a6a = 0;
    // v18 = MinVertsAllowed;
    if (NumFrustumPlanes <= 0) return false;
 
    // v12 = *pOutNumVertices;
    // v13 = (char *)&a4->y;
 
    // while ( 1 )
    for (uint i = 0; i < NumFrustumPlanes; ++i) {  // cycle through left,right, top, bottom planes
        if (i % 2) {
            v14 = pInVertices;
            v15 = sr_vertices_50D9D8;
        } else {
            v15 = pInVertices;
            v14 = sr_vertices_50D9D8;
        }
        if (i == NumFrustumPlanes - 1) v14 = pVertices;
        FrustumPlaneVec.x = CameraFrustrum[i].x;
        FrustumPlaneVec.y = CameraFrustrum[i].y;
        FrustumPlaneVec.z = CameraFrustrum[i].z;
 
        engine->pStru9Instance->AdjustVerticesToFrustumPlane(
            v15, *pOutNumVertices, v14, pOutNumVertices, &FrustumPlaneVec, CameraFrustrum[i].dot,
            (char *)&VertsAdjusted, _unused);
 
        // v12 = *pOutNumVertices;
        if (*pOutNumVertices < MinVertsAllowed) {
            *pOutNumVertices = 0;
            return true;
        }
        // result = a6a;
        // v13 += 24;
        // if (++i >= FrustumPlanes)
        //
    }
    return VertsAdjusted;
}

Перекрестные ссылки engine, pVertices, IndoorCameraD3D_Vec3::x, Vec3_float_::x, IndoorCameraD3D_Vec3::y, Vec3_float_::y, IndoorCameraD3D_Vec3::z и Vec3_float_::z.

Используется в _4371C3(), BspRenderer::AddFaceToRenderList_d3d(), do_draw_debug_line_sw() и IndoorLocation::ExecDraw_d3d().

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

_437376()

char IndoorCameraD3D::_437376	(	struct stru154 *	thisa,
		struct RenderVertexSoft *	a2,
		unsigned int *	pOutNumVertices
	)

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

                                                             {
    double v6;             // st7@3
    int previous;          // esi@6
    int current;           // ebx@8
    int next;              // eax@8
    int v13;               // eax@15
    signed int v14;        // ebx@17
    RenderVertexSoft v18;  // [sp+Ch] [bp-34h]@2
                           //  signed int thisb; // [sp+48h] [bp+8h]@6
    bool result;           // [sp+4Fh] [bp+Fh]@5
 
    memcpy(&v18, a2, sizeof(v18));
    result = false;
    memcpy(&a2[*pOutNumVertices], a2, sizeof(a2[*pOutNumVertices]));
    memcpy(&a2[*pOutNumVertices + 1], &a2[1], sizeof(a2[*pOutNumVertices + 1]));
 
    if ((signed int)*pOutNumVertices <= 3 ||
        (((v18.vWorldPosition.z - (double)pIndoorCameraD3D->vPartyPos.z) *
                  thisa->face_plane.vNormal.z +
              (v18.vWorldPosition.y - (double)pIndoorCameraD3D->vPartyPos.y) *
                  thisa->face_plane.vNormal.y +
              (v18.vWorldPosition.x - (double)pIndoorCameraD3D->vPartyPos.x) *
                  thisa->face_plane.vNormal.x <
          0.0)
             ? (v6 = 1.0)
             : (v6 = -1.0),
         (signed int)*pOutNumVertices <= 0))
        return 0;
 
    for (int i = 1; i - 1 < (signed int)*pOutNumVertices; i++) {
        current = i;
        next = i + 1;
 
        previous = i - 1;
        if (previous >= (signed int)*pOutNumVertices)
            previous -= *pOutNumVertices;
 
        if (current >= (signed int)*pOutNumVertices)
            current -= *pOutNumVertices;
 
        if (next >= (signed int)*pOutNumVertices) next -= *pOutNumVertices;
 
        if (-0.009999999776482582 <
            ((a2[current].vWorldViewProjX - a2[previous].vWorldViewProjX) *
                 (a2[next].vWorldViewProjY - a2[previous].vWorldViewProjY) -
             (a2[current].vWorldViewProjY - a2[previous].vWorldViewProjY) *
                 (a2[next].vWorldViewProjX - a2[previous].vWorldViewProjX)) *
                v6) {
            v13 = next;
            if (next >= (signed int)*pOutNumVertices)
                v13 = next - *pOutNumVertices;
 
            if (v13 < (signed int)*pOutNumVertices) {
                for (v14 = v13; v14 < (signed int)*pOutNumVertices; ++v14)
                    memcpy(&a2[v14], &a2[v14 + 1], sizeof(a2[v14]));
            }
            result = true;
            --*pOutNumVertices;
        }
    }
    if (result)
        return true;
    else
        return false;
}

Перекрестные ссылки stru154::face_plane, pIndoorCameraD3D, Plane_float_::vNormal, vPartyPos, RenderVertexSoft::vWorldPosition, Vec2< T >::x, Vec3_float_::x, Vec2< T >::y, Vec3_float_::y, Vec3< T >::z и Vec3_float_::z.

Используется в DecalBuilder::ApplyDecals() и LightmapBuilder::ApplyLights().

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

_4374E8_ProllyBuildFrustrum()

void IndoorCameraD3D::_4374E8_ProllyBuildFrustrum

(

)

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

                                                  {
    // IndoorCameraD3D *v1; // esi@1
    // double v2; // st7@1
    double v3;  // st7@1
    // double v4; // st7@1
    double v5;  // st7@1
    // double v6; // st7@1
    IndoorCameraD3D_Vec3 v7;  // [sp+Ch] [bp-24h]@1
    // float v8; // [sp+10h] [bp-20h]@1
    // float v9; // [sp+14h] [bp-1Ch]@1
    // float v10; // [sp+18h] [bp-18h]@1
    // float v11; // [sp+1Ch] [bp-14h]@1
    // float v12; // [sp+20h] [bp-10h]@1
    // int v13; // [sp+2Ch] [bp-4h]@1
 
    // v1 = this;
    // IndoorCameraD3D_Vec3::IndoorCameraD3D_Vec3(&v7);
    // v2 = 2.0 / inv_fov;
    // v13 = 0;
    v3 = atan(2.0 / inv_fov * fov / fov_x);
    // v12 = v3;
    // v11 = sin(v3);
    // v4 = cos(v3);
    v7.x = -sin(v3);
    v7.y = 0.0;
    v7.z = cos(v3);
    _437607(&v7, std__vector_000034_prolly_frustrum + 0);
 
    v7.x = sin(v3);
    _437607(&v7, std__vector_000034_prolly_frustrum + 1);
 
    v5 = atan(2.0 / inv_fov * fov / (fov_y + 0.5));
    // v12 = v5;
    // v11 = sin(v5);
    // v6 = cos(v5);
    v7.y = sin(v5);
    v7.x = 0.0;
    v7.z = cos(v5);
    _437607(&v7, &std__vector_000034_prolly_frustrum[2]);
 
    v7.y = -sin(v5);
    _437607(&v7, &std__vector_000034_prolly_frustrum[3]);
 
    // v13 = -1;
    // IndoorCameraD3D_Vec3::dtor(&v7);
}

Перекрестные ссылки _437607(), fov, fov_x, fov_y, inv_fov, std__vector_000034_prolly_frustrum, IndoorCameraD3D_Vec3::x, IndoorCameraD3D_Vec3::y и IndoorCameraD3D_Vec3::z.

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

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

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

_437607()

void IndoorCameraD3D::_437607	(	IndoorCameraD3D_Vec3 *	a1,
		IndoorCameraD3D_Vec4 *	a2
	)

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

                                                        {
    double v4;                // st7@1
    IndoorCameraD3D_Vec3 v8;  // [sp+8h] [bp-1Ch]@1
 
    v8.x = (double)pIndoorCameraD3D->vPartyPos.x;
    v8.y = (double)pIndoorCameraD3D->vPartyPos.y;
    v8.z = (double)pIndoorCameraD3D->vPartyPos.z;
    Vec3Transform(a1, a2);
 
    v4 = v8.x * a2->x + v8.y * a2->y + v8.z * a2->z;
    a2->dot = v4 + 0.000099999997;
}

Перекрестные ссылки IndoorCameraD3D_Vec4::dot, pIndoorCameraD3D, Vec3Transform(), vPartyPos, Vec2< T >::x, IndoorCameraD3D_Vec3::x, Vec2< T >::y, IndoorCameraD3D_Vec3::y, IndoorCameraD3D_Vec3::z и Vec3< T >::z.

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

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

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

Vec3Transform()

void IndoorCameraD3D::Vec3Transform	(	const IndoorCameraD3D_Vec3 *	pVector,
		IndoorCameraD3D_Vec3 *	pOut
	)

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

                                                                {
    pOut->y = field_4[1].x * pVector->x + field_4[0].x * pVector->y +
              field_4[2].x * pVector->z;
    pOut->z = field_4[1].y * pVector->x + field_4[0].y * pVector->y +
              field_4[2].y * pVector->z;
    pOut->x = field_4[1].z * pVector->x + field_4[0].z * pVector->y +
              field_4[2].z * pVector->z;
}

Перекрестные ссылки field_4, IndoorCameraD3D_Vec3::x, IndoorCameraD3D_Vec3::y и IndoorCameraD3D_Vec3::z.

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

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

CreateWorldMatrixAndSomeStuff()

void IndoorCameraD3D::CreateWorldMatrixAndSomeStuff

(

)

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

                                                    {
    Matrix3x3_float_ m1;  // [sp+10h] [bp-B8h]@1
    Matrix3x3_float_ m2;  // [sp+34h] [bp-94h]@1
    Matrix3x3_float_ m3;  // [sp+58h] [bp-70h]@1
    Matrix3x3_float_ m4;  // [sp+7Ch] [bp-4Ch]@1
    Matrix3x3_float_ m5;  // [sp+A0h] [bp-28h]@1
 
    // RotationZ(0) - roll
    m5._11 = cosf(0);
    m5._12 = sinf(0);
    m5._13 = 0;
    m5._21 = -sinf(0);
    m5._22 = cosf(0);
    m5._23 = 0;
    m5._31 = 0;
    m5._32 = 0;
    m5._33 = 1;
 
    float cos_x1 = fRotationXCosine, sin_x1 = fRotationXSine;
    // RotationX(x) - pitch
    m4._11 = 1;
    m4._12 = 0;
    m4._13 = 0;
    m4._21 = 0;
    m4._22 = cos_x1;
    m4._23 = sin_x1;
    m4._31 = 0;
    m4._32 = -sin_x1;
    m4._33 = cos_x1;
 
    float cos_y1 = fRotationYCosine, sin_y1 = fRotationYSine;
    // RotationY(some_angle) - yaw
    m3._11 = cos_y1;
    m3._12 = 0;
    m3._13 = -sin_y1;
    m3._21 = 0;
    m3._22 = 1;
    m3._23 = 0;
    m3._31 = sin_y1;
    m3._32 = 0;
    m3._33 = cos_y1;
 
    MatrixMultiply(&m5, &m3, &m1);
    MatrixMultiply(&m4, &m1, &m2);
 
    for (uint i = 0; i < 3; ++i) {
        field_4[0].v[i] = m2.v[1][i];
        field_4[1].v[i] = m2.v[0][i];
        field_4[2].v[i] = m2.v[2][i];
    }
 
    // indoor outdoor fov different
    fov = 0.8814736;
    inv_fov = 1.0 / fov;
 
    fov_x = (double)pViewport->uScreenWidth * fov;
    fov_y = (double)pViewport->uScreenHeight * fov;
 
    fov = fov_y;
    if (fov_x > fov) fov = fov_x;
 
    screenCenterX = (double)pViewport->uScreenCenterX;
    screenCenterY = (double)pViewport->uScreenCenterY - pViewport->uScreen_TL_Y;  //- pViewport->uScreen_TL_Y);
}

Перекрестные ссылки Matrix3x3_float_::_11, Matrix3x3_float_::_12, Matrix3x3_float_::_13, Matrix3x3_float_::_21, Matrix3x3_float_::_22, Matrix3x3_float_::_23, Matrix3x3_float_::_31, Matrix3x3_float_::_32, Matrix3x3_float_::_33, field_4, fov, fov_x, fov_y, fRotationXCosine, fRotationXSine, fRotationYCosine, fRotationYSine, inv_fov, MatrixMultiply(), pViewport, screenCenterX, screenCenterY, Viewport::uScreen_TL_Y, Viewport::uScreenCenterX, Viewport::uScreenCenterY, Viewport::uScreenHeight, Viewport::uScreenWidth, IndoorCameraD3D_Vec3::v и Matrix3x3_float_::v.

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

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

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

MatrixMultiply()

void IndoorCameraD3D::MatrixMultiply	(	struct Matrix3x3_float_ *	a1,
		struct Matrix3x3_float_ *	a2,
		struct Matrix3x3_float_ *	a3
	)

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

                                                              {
    float sum;
 
    for (uint row = 0; row < 3; row++) {
        for (uint col = 0; col < 3; col++) {
            sum = 0;
            for (int index = 0; index < 3; index++)
                sum += ma->v[row][index] * mb->v[index][col];
            m_out->v[row][col] = sum;
        }
    }
}

Перекрестные ссылки Matrix3x3_float_::v.

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

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

PrepareAndDrawDebugOutline()

void IndoorCameraD3D::PrepareAndDrawDebugOutline	(	struct BLVFace *	pFace,
		unsigned int	uDiffuse
	)

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

                                                                        {
    static RenderVertexSoft static_sub_437906_array_50CDD0[64];
    static bool __init_flag1 = false;
    if (!__init_flag1) {
        __init_flag1 = true;
 
        for (uint i = 0; i < 64; ++i)
            static_sub_437906_array_50CDD0[i].flt_2C = 0.0f;
    }
    if (pFace->uNumVertices) {
        for (uint i = 0; i < pFace->uNumVertices; i++) {
            static_sub_437906_array_50CDD0[i].vWorldPosition.x =
                (double)pIndoor->pVertices[pFace->pVertexIDs[i]].x;
            static_sub_437906_array_50CDD0[i].vWorldPosition.y =
                (double)pIndoor->pVertices[pFace->pVertexIDs[i]].y;
            static_sub_437906_array_50CDD0[i].vWorldPosition.z =
                (double)pIndoor->pVertices[pFace->pVertexIDs[i]].z;
            static_sub_437906_array_50CDD0[i].u = (double)pFace->pVertexUIDs[i];
            static_sub_437906_array_50CDD0[i].v = (double)pFace->pVertexVIDs[i];
        }
    }
    if (engine->config->debug_portal_outlines)
        debug_outline_sw(static_sub_437906_array_50CDD0, pFace->uNumVertices,
                         uDiffuse, 0.0);
}

Перекрестные ссылки debug_outline_sw(), engine, pIndoor, BLVFace::pVertexIDs, BLVFace::pVertexUIDs, BLVFace::pVertexVIDs, IndoorLocation::pVertices, RenderVertexSoft::u, BLVFace::uNumVertices, RenderVertexSoft::v, RenderVertexSoft::vWorldPosition, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

Используется в BspRenderer::AddFaceToRenderList_d3d().

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

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

debug_outline_sw()

void IndoorCameraD3D::debug_outline_sw	(	struct RenderVertexSoft *	a2,
		unsigned int	uNumVertices,
		unsigned int	uDiffuse,
		float	a5
	)

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

                                                                        {
    if (!uNumVertices) return;
    if ((signed int)(uNumVertices - 1) > 0) {
        for (uint i = 0; i < uNumVertices - 1; i++)
            do_draw_debug_line_sw(&a2[i], uDiffuse, &a2[i + 1], uDiffuse, 0,
                                  a5);
    }
    do_draw_debug_line_sw(&a2[uNumVertices - 1], uDiffuse, a2, uDiffuse, 0, a5);
}

Перекрестные ссылки do_draw_debug_line_sw().

Используется в stru10::CalcFaceBounding(), LightmapBuilder::DrawDebugOutlines(), DecalBuilder::DrawDecalDebugOutlines() и PrepareAndDrawDebugOutline().

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

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

debug_outline_d3d()

void IndoorCameraD3D::debug_outline_d3d	(	const struct RenderVertexD3D3 *	pLineVertices,
		unsigned int	uNumLines,
		int	uDiffuse,
		float	z_stuff
	)

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

                                                       {
    for (int i = 0; i < uNumLines - 1; ++i)
        render->do_draw_debug_line_d3d(&pLineVertices[i], uDiffuse,
                                       &pLineVertices[i + 1], uDiffuse,
                                       z_stuff);
    render->do_draw_debug_line_d3d(&pLineVertices[uNumLines - 1], uDiffuse,
                                   pLineVertices, uDiffuse, z_stuff);
}

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

Используется в Render::DrawTerrainPolygon().

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

do_draw_debug_line_sw()

void IndoorCameraD3D::do_draw_debug_line_sw	(	struct RenderVertexSoft *	pLineBegin,
		signed int	sStartDiffuse,
		struct RenderVertexSoft *	pLineEnd,
		signed int	sEndDiffuse,
		unsigned int	uOutNumVertices,
		float	z_stuff
	)

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

                                                           {
    RenderVertexSoft a1[20];         // [sp+8h] [bp-7C4h]@6
    RenderVertexSoft pVertices[20];  // [sp+3C8h] [bp-404h]@2
    RenderVertexD3D3 v24[2];         // [sp+788h] [bp-44h]@11
 
    // if ( render->pRenderD3D )
    //{
    for (uint i = 0; i < 20; i++) pVertices[i].flt_2C = 0.0;
    if ((char)uOutNumVertices) {
        pVertices[0].vWorldViewProjX = pLineBegin->vWorldViewProjX;
        pVertices[0].vWorldViewProjY = pLineBegin->vWorldViewProjY;
 
        pVertices[1].vWorldViewProjX = pLineEnd->vWorldViewProjX;
        pVertices[1].vWorldViewProjY = pLineEnd->vWorldViewProjY;
        v24[0].specular = 0;
        v24[0].pos.x = pVertices[0].vWorldViewProjX;
        v24[0].pos.y = pVertices[0].vWorldViewProjY;
        v24[0].pos.z = 0.001 - z_stuff;
        v24[0].diffuse = sStartDiffuse;
        v24[0].rhw = 0.001;
        v24[0].texcoord.x = 0.0;
        v24[0].texcoord.y = 0.0;
 
        v24[1].pos.x = pVertices[1].vWorldViewProjX;
        v24[1].pos.y = pVertices[1].vWorldViewProjY;
        v24[1].diffuse = sEndDiffuse;
        v24[1].pos.z = 0.001 - z_stuff;
        v24[1].specular = 0;
        v24[1].rhw = 0.001;
        v24[1].texcoord.x = 0.0;
        v24[1].texcoord.y = 0.0;
        // v19 = render->pRenderD3D->pDevice;
        render->DrawLines(v24, 2);
        return;
    }
    for (uint i = 0; i < 20; i++) a1[i].flt_2C = 0.0;
    uOutNumVertices = 2;
    a1[0].vWorldPosition.x = pLineBegin->vWorldPosition.x;
    a1[0].vWorldPosition.y = pLineBegin->vWorldPosition.y;
    a1[0].vWorldPosition.z = pLineBegin->vWorldPosition.z;
    a1[1].vWorldPosition.x = pLineEnd->vWorldPosition.x;
    a1[1].vWorldPosition.y = pLineEnd->vWorldPosition.y;
    a1[1].vWorldPosition.z = pLineEnd->vWorldPosition.z;
    if (CalcPortalShape(a1, &uOutNumVertices, pVertices,
                        this->std__vector_000034_prolly_frustrum, 4, 1,
                        0) != 1 ||
        (signed int)uOutNumVertices >= 2) {
        ViewTransform(pVertices, 2);
        Project(pVertices, 2, 0);
        v24[0].specular = 0;
        v24[0].pos.x = pVertices[0].vWorldViewProjX;
        v24[0].pos.y = pVertices[0].vWorldViewProjY;
        v24[0].pos.z = 0.001 - z_stuff;
        v24[0].diffuse = sStartDiffuse;
        v24[0].rhw = 0.001;
        v24[0].texcoord.x = 0.0;
        v24[0].texcoord.y = 0.0;
 
        v24[1].pos.x = pVertices[1].vWorldViewProjX;
        v24[1].pos.y = pVertices[1].vWorldViewProjY;
        v24[1].diffuse = sEndDiffuse;
        v24[1].pos.z = 0.001 - z_stuff;
        v24[1].specular = 0;
        v24[1].rhw = 0.001;
        v24[1].texcoord.x = 0.0;
        v24[1].texcoord.y = 0.0;
        // v19 = render->pRenderD3D->pDevice;
        render->DrawLines(v24, 2);
        return;
    }
    //}
}

Перекрестные ссылки CalcPortalShape(), RenderVertexD3D3::diffuse, RenderVertexD3D3::pos, Project(), pVertices, render, RenderVertexD3D3::rhw, RenderVertexD3D3::specular, std__vector_000034_prolly_frustrum, RenderVertexD3D3::texcoord, ViewTransform(), RenderVertexSoft::vWorldPosition, RenderVertexSoft::vWorldViewProjX, RenderVertexSoft::vWorldViewProjY, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

Используется в stru10::CalcFaceBounding() и debug_outline_sw().

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

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

is_face_faced_to_camera()

bool IndoorCameraD3D::is_face_faced_to_camera	(	struct BLVFace *	pFace,
		struct RenderVertexSoft *	a2
	)

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

                                                                    {
    if (pFace->Portal()) return false;
 
    // really strange cull; dot(to_cam, normal) < 0 means we see the BACK face,
    // not font %_%
    if ((a2->vWorldPosition.z - (double)pIndoorCameraD3D->vPartyPos.z) *
                (double)pFace->pFacePlane_old.vNormal.z +
            (a2->vWorldPosition.y - (double)pIndoorCameraD3D->vPartyPos.y) *
                (double)pFace->pFacePlane_old.vNormal.y +
            (a2->vWorldPosition.x - (double)pIndoorCameraD3D->vPartyPos.x) *
                (double)pFace->pFacePlane_old.vNormal.x <
        0.0)
        return false;
 
    return true;
}

Перекрестные ссылки BLVFace::pFacePlane_old, pIndoorCameraD3D, BLVFace::Portal(), Plane_int_::vNormal, vPartyPos, RenderVertexSoft::vWorldPosition, Vec2< T >::x, Vec3_float_::x, Vec2< T >::y, Vec3_float_::y, Vec3< T >::z и Vec3_float_::z.

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

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

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

GetFacetOrientation()

bool IndoorCameraD3D::GetFacetOrientation	(	char	polyType,
		struct Vec3_float_ *	a2,
		struct Vec3_float_ *	a3,
		struct Vec3_float_ *	a4
	)

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

                                                                            {
    switch ((PolygonType)polyType) {
        case POLYGON_VerticalWall: {
            a4->x = -a2->y;
            a4->y = a2->x;
            a4->z = 0.0;
 
            a3->x = 0.0;
            a3->y = 0.0;
            a3->z = 1.0f;
        }
            return true;
 
        case POLYGON_Floor:
        case POLYGON_Ceiling: {
            a4->x = 1.0;
            a4->y = 0.0;
            a4->z = 0.0;
 
            a3->x = 0.0;
            a3->y = 1.0;
            a3->z = 0.0;
        }
            return true;
 
        case POLYGON_InBetweenFloorAndWall:
        case POLYGON_InBetweenCeilingAndWall: {
            if (fabs(a2->z) < 0.70811361) {
                a4->x = -a2->y;
                a4->y = a2->x;
                a4->z = 0.0;
                a4->Normalize();
 
                a3->x = 0.0;
                a3->y = 0.0;
                a3->z = 1.0;
            } else {
                a4->x = 1.0;
                a4->y = 0.0;
                a4->z = 0.0;
 
                a3->x = 0.0;
                a3->y = 1.0;
                a3->z = 0.0;
            }
        }
            return true;
 
        default:
            return false;
    }
}

Перекрестные ссылки Vec3_float_::Normalize(), POLYGON_Ceiling, POLYGON_Floor, POLYGON_InBetweenCeilingAndWall, POLYGON_InBetweenFloorAndWall, POLYGON_VerticalWall, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

Используется в DecalBuilder::ApplyDecals() и LightmapBuilder::ApplyLights().

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

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

IsCulled()

bool IndoorCameraD3D::IsCulled

(

struct BLVFace *

pFace

)

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

                                             {
    RenderVertexSoft v;  // [sp+8h] [bp-30h]@1
 
    //----- (0043648F) --------------------------------------------------------
    auto Vec3_short__to_RenderVertexSoft = [](RenderVertexSoft *_this,
                                              Vec3_short_ *a2) -> void {
        _this->flt_2C = 0.0;
 
        _this->vWorldPosition.x = a2->x;
        _this->vWorldPosition.y = a2->y;
        _this->vWorldPosition.z = a2->z;
    };
 
    Vec3_short__to_RenderVertexSoft(&v,
                                    &pIndoor->pVertices[*pFace->pVertexIDs]);
    return is_face_faced_to_camera(pFace, &v);
}

Перекрестные ссылки RenderVertexSoft::flt_2C, is_face_faced_to_camera(), pIndoor, BLVFace::pVertexIDs, IndoorLocation::pVertices, RenderVertexSoft::vWorldPosition, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

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

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

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

ViewTransfrom_OffsetUV()

void IndoorCameraD3D::ViewTransfrom_OffsetUV	(	struct RenderVertexSoft *	pVertices,
		unsigned int	uNumVertices,
		struct RenderVertexSoft *	pOutVertices,
		struct LightsData *	a5
	)

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

                                                             {
    for (uint i = 0; i < uNumVertices; ++i) {
        pOutVertices[i].vWorldPosition.x = pVertices[i].vWorldPosition.x;
        pOutVertices[i].vWorldPosition.y = pVertices[i].vWorldPosition.y;
        pOutVertices[i].vWorldPosition.z = pVertices[i].vWorldPosition.z;
 
        pOutVertices[i].u = pVertices[i].u + a5->pDeltaUV[0];
        pOutVertices[i].v = pVertices[i].v + a5->pDeltaUV[1];
    }
    ViewTransform(pOutVertices, uNumVertices);
}

Перекрестные ссылки LightsData::pDeltaUV, pVertices, RenderVertexSoft::u, RenderVertexSoft::v, ViewTransform(), RenderVertexSoft::vWorldPosition, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

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

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

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

ApplyViewTransform_TrueIfStillVisible_BLV()

bool IndoorCameraD3D::ApplyViewTransform_TrueIfStillVisible_BLV	(	int	x,
		int	y,
		int	z,
		fixed *	pOutX,
		fixed *	pOutZ,
		fixed *	pOutY,
		bool	clip_plane_test
	)

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

                       {
    int to_x = x - pIndoorCameraD3D->vPartyPos.x;
    int to_y = y - pIndoorCameraD3D->vPartyPos.y;
    int to_z = (z - pIndoorCameraD3D->vPartyPos.z) << 16;
 
    if (pIndoorCameraD3D->sRotationX) {
         int v14 = (unsigned __int64)(to_x * (signed __int64)pIndoorCameraD3D->int_cosine_y) +
            (unsigned __int64)(to_y * (signed __int64)pIndoorCameraD3D->int_sine_y);
 
 
        *pOutX = fixed::Raw(fixpoint_mul(v14, pIndoorCameraD3D->int_cosine_x) /*+*/-
                            fixpoint_mul(to_z, pIndoorCameraD3D->int_sine_x));
 
        *pOutY = fixed::Raw((unsigned __int64)(to_y * (signed __int64)pIndoorCameraD3D->int_cosine_y) -
                            (unsigned __int64)(to_x * (signed __int64)pIndoorCameraD3D->int_sine_y));
 
        *pOutZ = fixed::Raw(fixpoint_mul(to_z, pIndoorCameraD3D->int_cosine_x) /*-*/+
                            fixpoint_mul(v14, pIndoorCameraD3D->int_sine_x));
 
    } else {
        *pOutX = fixed::Raw((unsigned __int64)(to_x * (signed __int64)pIndoorCameraD3D->int_cosine_y) +
                            (unsigned __int64)(to_y * (signed __int64)pIndoorCameraD3D->int_sine_y));
 
        *pOutY = fixed::Raw((unsigned __int64)(to_y * (signed __int64)pIndoorCameraD3D->int_cosine_y) -
                            (unsigned __int64)(to_x * (signed __int64)pIndoorCameraD3D->int_sine_y));
 
        *pOutZ = fixed::Raw(to_z);
    }
 
    if (!do_clip_test) return false;
 
    // return *pOutX >= fixpoint_from_int(4, 0) &&
    //    *pOutX <= fixpoint_from_int(8000, 0);
    return *pOutX >= fixed::FromFloat(this->GetNearClip()) &&
           *pOutX <= fixed::FromFloat(this->GetFarClip());
}

Перекрестные ссылки fixpoint_mul(), fixed::FromFloat(), GetFarClip(), GetNearClip(), int_cosine_x, int_cosine_y, int_sine_x, int_sine_y, pIndoorCameraD3D, fixed::Raw(), sRotationX, vPartyPos, Vec2< T >::x, Vec2< T >::y и Vec3< T >::z.

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

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

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

GetPickDepth()

float IndoorCameraD3D::GetPickDepth

(

)

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

                                    {
    if (uCurrentlyLoadedLevelType == LEVEL_Outdoor)
        return pODMRenderParams->uPickDepth;
    else
        return 16192.0;
}

Перекрестные ссылки LEVEL_Outdoor, pODMRenderParams, uCurrentlyLoadedLevelType и ODMRenderParams::uPickDepth.

Используется в CastSpellInfoHelpers::_427E01_cast_spell(), Engine::_44EEA7() и Application::GameWindowHandler::OnMouseRightClick().

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

DebugDrawPortal()

void IndoorCameraD3D::DebugDrawPortal

(

struct BLVFace *

pFace

)

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

                                                    {
    Assert(pFace->uNumVertices <= 32);
 
    RenderVertexSoft sw[32];
    for (uint i = 0; i < pFace->uNumVertices; ++i) {
        sw[i].vWorldPosition.x = pIndoor->pVertices[pFace->pVertexIDs[i]].x;
        sw[i].vWorldPosition.y = pIndoor->pVertices[pFace->pVertexIDs[i]].y;
        sw[i].vWorldPosition.z = pIndoor->pVertices[pFace->pVertexIDs[i]].z;
    }
    ViewTransform(sw, pFace->uNumVertices);
    Project(sw, pFace->uNumVertices, 0);
 
    RenderVertexD3D3 v[32];
    for (uint i = 0; i < pFace->uNumVertices; ++i) {
        v[i].pos.x = sw[i].vWorldViewProjX;
        v[i].pos.y = sw[i].vWorldViewProjY;
        v[i].pos.z = 1.0 - 1.0 / (sw[i].vWorldViewPosition.x * 0.061758894);
        v[i].rhw = 1.0 / sw[i].vWorldViewPosition.x;
        v[i].diffuse = 0x80F020F0;
        v[i].specular = 0;
        // v[i].texcoord.x = pFace->pVertexUIDs[i] /
        // (double)pTex->uTextureWidth; v[i].texcoord.y = pFace->pVertexUIDs[i] /
        // (double)pTex->uTextureHeight;
        v[i].texcoord.x = 0;
        v[i].texcoord.y = 0;
    }
 
    render->DrawFansTransparent(v, pFace->uNumVertices);
}

Перекрестные ссылки pIndoor, RenderVertexD3D3::pos, Project(), BLVFace::pVertexIDs, IndoorLocation::pVertices, render, BLVFace::uNumVertices, ViewTransform(), RenderVertexSoft::vWorldPosition, RenderVertexSoft::vWorldViewPosition, RenderVertexSoft::vWorldViewProjX, RenderVertexSoft::vWorldViewProjY, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

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

CalculateRotations()

void IndoorCameraD3D::CalculateRotations	(	int	camera_rot_x,
		int	camera_rot_y
	)

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

                                                                           {
    sRotationX = camera_rot_x + 20;  // pitch
    sRotationY = camera_rot_y;  // yaw
 
    fRotationYSine = sin((pi_double + pi_double) * (double)sRotationY / 2048.0);
    fRotationYCosine = cos((pi_double + pi_double) * (double)sRotationY / 2048.0);
 
    fRotationXSine = sin((pi_double + pi_double) * (double)sRotationX / 2048.0);
    fRotationXCosine = cos((pi_double + pi_double) * (double)sRotationX / 2048.0);
 
    int_sine_y = stru_5C6E00->Sin(sRotationY);
    int_cosine_y = stru_5C6E00->Cos(sRotationY);
    int_sine_x = stru_5C6E00->Sin(sRotationX);
    int_cosine_x = stru_5C6E00->Cos(sRotationX);
}

Перекрестные ссылки stru193_math::Cos(), fRotationXCosine, fRotationXSine, fRotationYCosine, fRotationYSine, int_cosine_x, int_cosine_y, int_sine_x, int_sine_y, stru193_math::Sin(), sRotationX, sRotationY и stru_5C6E00.

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

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

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

GetNearClip()

float IndoorCameraD3D::GetNearClip

(

)

const

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

                                         {
    if (uCurrentlyLoadedLevelType == LEVEL_Outdoor) {
        if (pODMRenderParams) {
            return pODMRenderParams->near_clip;
        }
 
        return 4.0f;
    } else {
        // return (double)pBLVRenderParams->fov_rad_fixpoint / 65536.0f;
        return 4.0f;
    }
}

Перекрестные ссылки LEVEL_Outdoor, ODMRenderParams::near_clip, pODMRenderParams и uCurrentlyLoadedLevelType.

Используется в _set_3d_projection_matrix(), ApplyViewTransform_TrueIfStillVisible_BLV(), RenderOpenGL::DoRenderBillboards_D3D(), Render::DrawBuildingsD3D(), LightmapNeerClip(), ODM_NearClip(), Render::RenderTerrainD3D(), SpellFX_Billboard::SpellFXViewClip() и ViewClip().

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

GetFarClip()

float IndoorCameraD3D::GetFarClip

(

)

const

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

                                        {
    if (uCurrentlyLoadedLevelType == LEVEL_Outdoor) {
        if (pODMRenderParams) {
            return pODMRenderParams->far_clip;
        }
 
        return (float)0x2000;
    } else {
        return 16192.0f;
    }
}

Перекрестные ссылки ODMRenderParams::far_clip, LEVEL_Outdoor, pODMRenderParams и uCurrentlyLoadedLevelType.

Используется в Render::_4A4CC9_AddSomeBillboard(), _set_3d_projection_matrix(), ApplyViewTransform_TrueIfStillVisible_BLV(), RenderOpenGL::DoRenderBillboards_D3D(), Render::DrawBuildingsD3D(), Render::DrawDecal(), RenderOpenGL::DrawOutdoorSkyD3D(), Render::DrawOutdoorSkyD3D(), RenderOpenGL::DrawPolygon(), Render::DrawPolygon(), Render::DrawProjectile(), Render::DrawTerrainPolygon(), LightmapFarClip(), RenderBase::MakeParticleBillboardAndPush(), ODM_FarClip(), RenderOpenGL::RenderTerrainD3D(), Render::RenderTerrainD3D(), SpellFX_Billboard::SpellFXViewClip(), RenderBase::TransformBillboard() и ViewClip().

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

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

field_4

IndoorCameraD3D_Vec3 IndoorCameraD3D::field_4[3]

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

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

std__vector_000034_prolly_frustrum

IndoorCameraD3D_Vec4 IndoorCameraD3D::std__vector_000034_prolly_frustrum[6]

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

Используется в _4371C3(), _4374E8_ProllyBuildFrustrum(), do_draw_debug_line_sw() и IndoorLocation::ExecDraw_d3d().

fov

float IndoorCameraD3D::fov

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

Используется в _4374E8_ProllyBuildFrustrum(), CreateWorldMatrixAndSomeStuff(), Project(), UnprojectX() и UnprojectY().

screenCenterX

float IndoorCameraD3D::screenCenterX

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

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

screenCenterY

float IndoorCameraD3D::screenCenterY

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

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

fov_x

float IndoorCameraD3D::fov_x

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

Используется в _4374E8_ProllyBuildFrustrum(), CreateWorldMatrixAndSomeStuff(), SpellFxRenderer::DrawProjectiles(), IndoorLocation::PrepareActorRenderList_BLV(), IndoorLocation::PrepareDecorationsRenderList_BLV(), IndoorLocation::PrepareItemsRenderList_BLV() и ParticleEngine::ViewProject_TrueIfStillVisible_BLV().

fov_y

float IndoorCameraD3D::fov_y

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

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

inv_fov

float IndoorCameraD3D::inv_fov

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

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

_unused_blv_party_x

float IndoorCameraD3D::_unused_blv_party_x

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

_unused_blv_party_y

float IndoorCameraD3D::_unused_blv_party_y

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

_unused_blv_party_z

float IndoorCameraD3D::_unused_blv_party_z

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

field_E8

char IndoorCameraD3D::field_E8[32]

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

field_108

float IndoorCameraD3D::field_108

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

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

_unused_blv_party_x_2

float IndoorCameraD3D::_unused_blv_party_x_2

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

_unused_blv_party_y_2

float IndoorCameraD3D::_unused_blv_party_y_2

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

_unused_blv_party_z_2

float IndoorCameraD3D::_unused_blv_party_z_2

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

field_118

char IndoorCameraD3D::field_118[32]

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

field_138

float IndoorCameraD3D::field_138

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

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

field_13C

char IndoorCameraD3D::field_13C[44]

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

field_168

float IndoorCameraD3D::field_168

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

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

field_16C

char IndoorCameraD3D::field_16C[44]

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

field_198

float IndoorCameraD3D::field_198

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

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

field_19C

char IndoorCameraD3D::field_19C[44]

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

field_1C8

float IndoorCameraD3D::field_1C8

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

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

field_1CC

char IndoorCameraD3D::field_1CC[44]

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

field_1F8

float IndoorCameraD3D::field_1F8

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

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

field_1FC

char IndoorCameraD3D::field_1FC[44]

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

field_228

float IndoorCameraD3D::field_228

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

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

field_22C

char IndoorCameraD3D::field_22C[44]

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

field_258

float IndoorCameraD3D::field_258

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

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

field_25C

char IndoorCameraD3D::field_25C[44]

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

field_288

float IndoorCameraD3D::field_288

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

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

field_28C

char IndoorCameraD3D::field_28C[44]

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

field_2B8

float IndoorCameraD3D::field_2B8

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

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

field_2BC

float IndoorCameraD3D::field_2BC

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

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

field_2C0

float IndoorCameraD3D::field_2C0

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

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

field_2C4

float IndoorCameraD3D::field_2C4

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

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

field_2C8

char IndoorCameraD3D::field_2C8[32]

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

field_2E8

float IndoorCameraD3D::field_2E8

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

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

field_2EC

float IndoorCameraD3D::field_2EC

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

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

field_2F0

float IndoorCameraD3D::field_2F0

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

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

field_2F4

float IndoorCameraD3D::field_2F4

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

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

field_2F8

char IndoorCameraD3D::field_2F8[32]

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

field_318

float IndoorCameraD3D::field_318

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

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

field_31C

float IndoorCameraD3D::field_31C

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

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

field_320

float IndoorCameraD3D::field_320

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

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

field_324

float IndoorCameraD3D::field_324

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

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

field_328

char IndoorCameraD3D::field_328[32]

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

field_348

float IndoorCameraD3D::field_348

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

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

field_34C

float IndoorCameraD3D::field_34C

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

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

field_350

float IndoorCameraD3D::field_350

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

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

field_354

float IndoorCameraD3D::field_354

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

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

field_358

char IndoorCameraD3D::field_358[32]

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

field_378

float IndoorCameraD3D::field_378

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

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

list_0037C

IndoorCameraD3D_stru3 IndoorCameraD3D::list_0037C[16384]

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

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

list_0037C_size

unsigned int IndoorCameraD3D::list_0037C_size

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

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

list_E0380

IndoorCameraD3D_stru2 IndoorCameraD3D::list_E0380[256]

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

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

list_E0380_size

int IndoorCameraD3D::list_E0380_size

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

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

sRotationY

int IndoorCameraD3D::sRotationY

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

Используется в Engine::_461103_load_level_sub(), CalculateRotations(), Vis::CastPickRay(), Engine::Draw(), IsBModelVisible(), ODM_LoadAndInitialize(), GUIWindow_House::Release(), RenderOpenGL::RenderTerrainD3D(), Render::RenderTerrainD3D() и TravelByTransport().

sRotationX

int IndoorCameraD3D::sRotationX

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

Используется в Engine::_461103_load_level_sub(), ApplyViewTransform_TrueIfStillVisible_BLV(), SkyBillboardStruct::CalcSkyFrustumVec(), CalculateRotations(), Vis::CastPickRay(), Engine::Draw(), Render::DrawIndoorSky(), RenderOpenGL::DrawOutdoorSkyD3D(), Render::DrawOutdoorSkyD3D(), IsBModelVisible(), ODM_LoadAndInitialize() и ViewTransform().

fRotationYSine

float IndoorCameraD3D::fRotationYSine

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

Используется в CalculateRotations(), CreateWorldMatrixAndSomeStuff() и ViewTransform().

fRotationYCosine

float IndoorCameraD3D::fRotationYCosine

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

Используется в CalculateRotations(), CreateWorldMatrixAndSomeStuff() и ViewTransform().

fRotationXSine

float IndoorCameraD3D::fRotationXSine

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

Используется в CalculateRotations(), CreateWorldMatrixAndSomeStuff() и ViewTransform().

fRotationXCosine

float IndoorCameraD3D::fRotationXCosine

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

Используется в CalculateRotations(), CreateWorldMatrixAndSomeStuff() и ViewTransform().

vPartyPos

Vec3<int> IndoorCameraD3D::vPartyPos

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

Используется в _437376(), _437607(), Engine::_461103_load_level_sub(), stru10::_49C720(), BspRenderer::AddFaceToRenderList_d3d(), Actor::AI_Bored(), ApplyViewTransform_TrueIfStillVisible_BLV(), stru10::CalcFaceBounding(), SkyBillboardStruct::CalcSkyFrustumVec(), Vis::CastPickRay(), Engine::Draw(), Render::DrawIndoorSky(), RenderOpenGL::DrawOutdoorSkyD3D(), Render::DrawOutdoorSkyD3D(), RenderBase::DrawSpriteObjects_ODM(), GetPortalScreenCoord(), is_face_faced_to_camera(), ODMFace::IsBackfaceNotCulled(), IsBModelVisible(), IndoorLocation::PrepareActorRenderList_BLV(), OutdoorLocation::PrepareActorsDrawList(), IndoorLocation::PrepareDecorationsRenderList_BLV(), RenderOpenGL::PrepareDecorationsRenderList_ODM(), Render::PrepareDecorationsRenderList_ODM(), PrepareDrawLists_BLV(), IndoorLocation::PrepareItemsRenderList_BLV(), RenderOpenGL::RenderTerrainD3D(), BLVRenderParams::Reset(), sub_4406BC() и ViewTransform().

debug_flags

int IndoorCameraD3D::debug_flags

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

Используется в BspRenderer::AddFaceToRenderList_d3d(), OutdoorLocation::ExecDraw() и BLVRenderParams::Reset().

int_sine_y

int IndoorCameraD3D::int_sine_y

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

Используется в ApplyViewTransform_TrueIfStillVisible_BLV(), SkyBillboardStruct::CalcSkyFrustumVec() и CalculateRotations().

int_cosine_y

int IndoorCameraD3D::int_cosine_y

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

Используется в ApplyViewTransform_TrueIfStillVisible_BLV(), SkyBillboardStruct::CalcSkyFrustumVec() и CalculateRotations().

int_sine_x

int IndoorCameraD3D::int_sine_x

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

Используется в ApplyViewTransform_TrueIfStillVisible_BLV(), SkyBillboardStruct::CalcSkyFrustumVec() и CalculateRotations().

int_cosine_x

int IndoorCameraD3D::int_cosine_x

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

Используется в ApplyViewTransform_TrueIfStillVisible_BLV(), SkyBillboardStruct::CalcSkyFrustumVec() и CalculateRotations().

---

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

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