World of Might and Magic  0.2.0
Open reimplementation of Might and Magic 6 7 8 game engine
Открытые члены | Открытые атрибуты | Полный список членов класса
Структура stru10

#include <stru10.h>

Открытые члены

 stru10 ()
 
virtual ~stru10 ()
 
char _49C5DA (struct BLVFace *pFace, struct RenderVertexSoft *pVertices, unsigned int *pNumVertices, struct IndoorCameraD3D_Vec4 *a5, struct RenderVertexSoft *pOutBounding)
 
bool CalcPortalShape (struct BLVFace *pFace, struct IndoorCameraD3D_Vec4 *pPortalDataFrustum, struct RenderVertexSoft *pOutBounding)
 
char _49C720 (struct RenderVertexSoft *pFaceBounding, struct IndoorCameraD3D_Vec4 *pPortalDataFrustum)
 
bool FindFaceNormal (struct RenderVertexSoft *pFaceBounding1, struct RenderVertexSoft *pFaceBounding2, struct Vec3_float_ *pRayStart, struct IndoorCameraD3D_Vec4 *pPortalDataFrustum)
 
bool FindFacePlane (struct RenderVertexSoft *face, struct Vec3_float_ *out_normal, float *out_distance)
 
bool CalcFaceBounding (struct BLVFace *pFace, struct RenderVertexSoft *pFaceLimits, unsigned int uNumVertices, struct RenderVertexSoft *pOutBounding)
 
void CalcPolygonLimits (struct BLVFace *pFace, struct RenderVertexSoft pOutVertices[4])
 
void _49CE9E (struct BLVFace *pFace, struct RenderVertexSoft *pVertices, unsigned int uNumVertices, RenderVertexSoft *pOutLimits)
 

Открытые атрибуты

void(*** vdestructor_ptr )(stru10 *, bool)
 
int bDoNotDrawPortalFrustum
 

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

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

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

◆ stru10()

stru10::stru10 ( )

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

724 { this->bDoNotDrawPortalFrustum = false; }

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

◆ ~stru10()

stru10::~stru10 ( )
virtual

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

727 {}

Методы

◆ _49C5DA()

char stru10::_49C5DA ( struct BLVFace *  pFace,
struct RenderVertexSoft *  pVertices,
unsigned int *  pNumVertices,
struct IndoorCameraD3D_Vec4 *  a5,
struct RenderVertexSoft *  pOutBounding 
)

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

732  {
733  RenderVertexSoft pLimits[4]; // [sp+Ch] [bp-C0h]@1
734 
735  _49CE9E(pFace, pVertices, *pNumVertices, pLimits);
736 
737  // if ( _4D864C_force_sw_render_rules && engine->config->DrawBlvDebugs())
738  // pIndoorCameraD3D->debug_outline_sw(a4a, 4u, 0xFF1E1Eu, 0.000099999997);
739  if (CalcFaceBounding(pFace, pLimits, 4, pOutBounding))
740  return _49C720(pOutBounding, a5);
741  return false;
742 }

Перекрестные ссылки _49C720(), _49CE9E(), CalcFaceBounding() и pVertices.

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

◆ CalcPortalShape()

bool stru10::CalcPortalShape ( struct BLVFace *  pFace,
struct IndoorCameraD3D_Vec4 *  pPortalDataFrustum,
struct RenderVertexSoft *  pOutBounding 
)

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

748  {
749  RenderVertexSoft pLimits[4]; // [sp+Ch] [bp-C0h]@1
750 
751  CalcPolygonLimits(pFace, pLimits); //определение границ портала
752  // if ( _4D864C_force_sw_render_rules && engine->config->DrawBlvDebugs())
753  // pIndoorCameraD3D->debug_outline_sw(pLimits, 4, 0xFF1E1E,
754  // 0.000099999997);
755  if (CalcFaceBounding(pFace, pLimits, 4, pOutBounding))
756  return _49C720(pOutBounding, pPortalDataFrustum) != 0;
757  return false;
758 }

Перекрестные ссылки _49C720(), CalcFaceBounding() и CalcPolygonLimits().

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

◆ _49C720()

char stru10::_49C720 ( struct RenderVertexSoft *  pFaceBounding,
struct IndoorCameraD3D_Vec4 *  pPortalDataFrustum 
)

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

764  {
765  Vec3_float_ pRayStart; // [sp+4h] [bp-34h]@1
766  pRayStart.x = (double)pIndoorCameraD3D->vPartyPos.x;
767  pRayStart.y = (double)pIndoorCameraD3D->vPartyPos.y;
768  pRayStart.z = (double)pIndoorCameraD3D->vPartyPos.z;
769 
770  if (FindFaceNormal(&pFaceBounding[0], &pFaceBounding[1], &pRayStart,
771  &pPortalDataFrustum[0]) &&
772  FindFaceNormal(&pFaceBounding[1], &pFaceBounding[2], &pRayStart,
773  &pPortalDataFrustum[1]) &&
774  FindFaceNormal(&pFaceBounding[2], &pFaceBounding[3], &pRayStart,
775  &pPortalDataFrustum[2]) &&
776  FindFaceNormal(&pFaceBounding[3], &pFaceBounding[0], &pRayStart,
777  &pPortalDataFrustum[3]))
778  return true;
779  return false;
780 }

Перекрестные ссылки FindFaceNormal(), pIndoorCameraD3D, IndoorCameraD3D::vPartyPos, Vec2< T >::x, Vec3_float_::x, Vec2< T >::y, Vec3_float_::y, Vec3< T >::z и Vec3_float_::z.

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

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

◆ FindFaceNormal()

bool stru10::FindFaceNormal ( struct RenderVertexSoft *  pFaceBounding1,
struct RenderVertexSoft *  pFaceBounding2,
struct Vec3_float_ *  pRayStart,
struct IndoorCameraD3D_Vec4 *  pPortalDataFrustum 
)

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

786  {
787  Vec3_float_ ray_dir; // [sp+4h] [bp-48h]@1
788  Vec3_float_ pRay2; // [sp+10h] [bp-3Ch]@1
789 
790  ray_dir.x = pFaceBounding1->vWorldPosition.x -
791  pRayStart->x; // get ray for cmera to bounding1
792  ray_dir.y = pFaceBounding1->vWorldPosition.y - pRayStart->y;
793  ray_dir.z = pFaceBounding1->vWorldPosition.z - pRayStart->z;
794  Vec3_float_::Cross(
795  &ray_dir, &pRay2,
796  pFaceBounding2->vWorldPosition.x - pFaceBounding1->vWorldPosition.x,
797  pFaceBounding2->vWorldPosition.y - pFaceBounding1->vWorldPosition.y,
798  pFaceBounding2->vWorldPosition.z - pFaceBounding1->vWorldPosition.z);
799 
800  float sqr_mag = pRay2.x * pRay2.x + pRay2.y * pRay2.y + pRay2.z * pRay2.z;
801  if (fabsf(sqr_mag) > 1e-6f) {
802  float inv_mag = 1.0f / sqrtf(sqr_mag);
803  pRay2.x *= inv_mag;
804  pRay2.y *= inv_mag;
805  pRay2.z *= inv_mag;
806  pRay2.Normalize();
807 
808  pPortalDataFrustum->x = pRay2.x;
809  pPortalDataFrustum->y = pRay2.y;
810  pPortalDataFrustum->z = pRay2.z;
811  pPortalDataFrustum->dot = pRayStart->z * pRay2.z +
812  pRayStart->y * pRay2.y +
813  pRayStart->x * pRay2.x;
814  return true;
815  }
816  return false;
817 }

Перекрестные ссылки Vec3_float_::Cross(), IndoorCameraD3D_Vec4::dot, Vec3_float_::Normalize(), RenderVertexSoft::vWorldPosition, IndoorCameraD3D_Vec3::x, Vec3_float_::x, IndoorCameraD3D_Vec3::y, Vec3_float_::y, IndoorCameraD3D_Vec3::z и Vec3_float_::z.

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

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

◆ FindFacePlane()

bool stru10::FindFacePlane ( struct RenderVertexSoft *  face,
struct Vec3_float_ *  out_normal,
float *  out_distance 
)

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

820  {
821  Vec3_float_ v1; // [sp+8h] [bp-3Ch]@1
822  Vec3_float_ v2; // [sp+14h] [bp-30h]@1
823 
824  v1.x = arg0[1].vWorldPosition.x - arg0[0].vWorldPosition.x;
825  v1.y = arg0[1].vWorldPosition.y - arg0[0].vWorldPosition.y;
826  v1.z = arg0[1].vWorldPosition.z - arg0[0].vWorldPosition.z;
827 
828  Vec3_float_::Cross(&v1, &v2,
829  arg0[2].vWorldPosition.x - arg0[1].vWorldPosition.x,
830  arg0[2].vWorldPosition.y - arg0[1].vWorldPosition.y,
831  arg0[2].vWorldPosition.z - arg0[1].vWorldPosition.z);
832 
833  float sqr_mag = v2.x * v2.x + v2.y * v2.y + v2.z * v2.z;
834  if (fabsf(sqr_mag) > 1e-6f) {
835  // v2.Normalize();
836  float inv_mag = 1.0f / sqrtf(sqr_mag);
837  v2.x *= inv_mag;
838  v2.y *= inv_mag;
839  v2.z *= inv_mag;
840 
841  a2->x = v2.x;
842  a2->y = v2.y;
843  a2->z = v2.z;
844  *a3 = -(arg0[0].vWorldPosition.z * v2.z +
845  arg0[0].vWorldPosition.y * v2.y +
846  arg0[0].vWorldPosition.x * v2.x);
847  return true;
848  }
849  return false;
850 }

Перекрестные ссылки Vec3_float_::Cross(), RenderVertexSoft::vWorldPosition, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

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

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

◆ CalcFaceBounding()

bool stru10::CalcFaceBounding ( struct BLVFace *  pFace,
struct RenderVertexSoft *  pFaceLimits,
unsigned int  uNumVertices,
struct RenderVertexSoft *  pOutBounding 
)

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

237  {
238  // IndoorCameraD3D *v6; // edi@1
239  // PolygonType v7; // al@1
240  // unsigned int v8; // edx@7
241  // char v10; // zf@10
242  // float v13; // ST14_4@20
243  // stru10 *v15; // ecx@21
244  // RenderVertexSoft *v16; // ST0C_4@21
245  // bool result; // eax@21
246  // float v18; // ST14_4@24
247  // stru10 *v19; // edi@29
248  // float v20; // ST14_4@30
249  // float v21; // ST14_4@30
250  // float v22; // ST14_4@30
251  // float v23; // ST14_4@30
252  // float v24; // ST14_4@31
253  // RenderVertexSoft v25; // [sp+10h] [bp-90h]@24
254  // RenderVertexSoft v26; // [sp+40h] [bp-60h]@20
255  // IndoorCameraD3D *thisa; // [sp+70h] [bp-30h]@1
256  // stru10 *v31; // [sp+84h] [bp-1Ch]@1
257  // float v32; // [sp+88h] [bp-18h]@8
258  Vec3_float_ a1; // [sp+8Ch] [bp-14h]@1
259  // float v35; // [sp+9Ch] [bp-4h]@8
260 
261  // auto a3 = pFace;
262  // auto arg4 = pFaceBounding;
263 
264  // _ESI = a3;
265  // v31 = this;
266  // v6 = pIndoorCameraD3D;
267  // v7 = a3->uPolygonType;
268 
269  a1.x = 0.0f;
270  a1.y = 0.0f;
271  a1.z = 0.0f;
272 
273  float var_28;
274  float var_24;
275  switch (pFace->uPolygonType) {
276  case POLYGON_VerticalWall:
277  a1.x = -pFace->pFacePlane.vNormal.y; // направление полигона
278  a1.y = pFace->pFacePlane.vNormal.x;
279  a1.z = 0.0f;
280  a1.Normalize();
281 
282  var_28 = 0;
283  var_24 = 1;
284  break;
285 
286  case POLYGON_Floor:
287  case POLYGON_Ceiling:
288  a1.x = 1;
289  a1.y = 0;
290  a1.z = 0.0f;
291 
292  var_28 = 1;
293  var_24 = 0;
294  break;
295 
296  default:
297  Error("Invalid polygon type (%u)", pFace->uPolygonType);
298  }
299 
300  float face_center_x;
301  float face_center_y;
302  float face_center_z;
303  float a3;
304  float var_8;
305 
306  if (pFace->uAttributes & FACE_XY_PLANE) {
307  face_center_x = (pFaceLimits[0].vWorldPosition.x +
308  pFaceLimits[2].vWorldPosition.x) /
309  2;
310  face_center_y = (pFaceLimits[3].vWorldPosition.y +
311  pFaceLimits[1].vWorldPosition.y) /
312  2;
313  face_center_z = (pFaceLimits[0].vWorldPosition.z +
314  pFaceLimits[2].vWorldPosition.z) /
315  2;
316 
317  a3 = face_center_x - pFaceLimits[0].vWorldPosition.x;
318  var_8 = face_center_y - pFaceLimits[1].vWorldPosition.y;
319  }
320  if (pFace->uAttributes & FACE_XZ_PLANE) {
321  face_center_x = (pFaceLimits[0].vWorldPosition.x +
322  pFaceLimits[2].vWorldPosition.x) /
323  2; // центр полигона
324  face_center_y = (pFaceLimits[0].vWorldPosition.y +
325  pFaceLimits[2].vWorldPosition.y) /
326  2;
327  face_center_z = (pFaceLimits[1].vWorldPosition.z +
328  pFaceLimits[3].vWorldPosition.z) /
329  2;
330 
331  a3 = face_center_x -
332  pFaceLimits[0].vWorldPosition.x; //от центра до верхнего края
333  var_8 = face_center_z -
334  pFaceLimits[1].vWorldPosition.z; // высота от центра
335 
336  if (pFace->uPolygonType == POLYGON_VerticalWall) a3 /= a1.x;
337  }
338  if (pFace->uAttributes & FACE_YZ_PLANE) {
339  face_center_x = (pFaceLimits[0].vWorldPosition.x +
340  pFaceLimits[2].vWorldPosition.x) /
341  2;
342  face_center_y = (pFaceLimits[0].vWorldPosition.y +
343  pFaceLimits[2].vWorldPosition.y) /
344  2;
345  face_center_z = (pFaceLimits[1].vWorldPosition.z +
346  pFaceLimits[3].vWorldPosition.z) /
347  2;
348 
349  a3 = face_center_y - pFaceLimits[0].vWorldPosition.y;
350  var_8 = face_center_z - pFaceLimits[1].vWorldPosition.z;
351  // [0.5]
352  if (pFace->uPolygonType == POLYGON_VerticalWall) {
353  if (a1.x != 1.0f) a3 /= a1.y;
354  }
355  }
356 
357  // _EBX = arg0;
358  // v15 = v31;
359  // v16 = arg0;
360  // float var_20 = var_8 * var_24;
361  // var_8 = a3 * a1.z;
362  // float arg_0 = var_8 + var_4;
363 
364  /*
365 
366 
367 
368  .text:0049CBB3 fld [ebp+var_8] 0 var8
369  .text:0049CBB6 1 fmul ds:flt_4D84E8 0 var8 *
370  flt_4D84E8
371 
372  .text:0049CBBC 1 fld [ebp+var_8] 0 var8
373  1 var8 *
374  flt_4D84E8
375 
376  .text:0049CBBF 2 fmul [ebp+var_28] 0 var8 *
377  var28 1 var8 * flt_4D84E8
378 
379  .text:0049CBC2 2 fld [ebp+var_8] 0 var8
380  1 var8 * var28
381  2 var8 *
382  flt_4D84E8
383 
384  .text:0049CBC5 3 fmul [ebp+var_24] 0 var8 * var24
385  768 1 var8 * var28 0 2 var8 * flt_4D84E8 0
386 
387  .text:0049CBD5 3 fst [ebp+var_20] 0 var8 * var24
388  768 1 var8 * var28 0 2 var8 * flt_4D84E8 0
389  [var20] var8 * var24 768
390 
391  .text:0049CBD8 3 fld [ebp+a3] 0 a3
392  -1984 1 var8 * var24 768 2 var8 * var28 0 3
393  var8 * flt_4D84E8 0
394 
395  .text:0049CBDB 4 fmul [ebp+a1.x] 0 a3 * a1.x
396  1984 1 var8 * var24 768 2 var8 * var28 0 3
397  var8 * flt_4D84E8 0
398 
399  .text:0049CBDE 4 fld [ebp+a3] 0 a3
400  1 a3 * a1.x
401  1984 2 var8 * var24 768 3 var8 * var28 0 4
402  var8 * flt_4D84E8 0
403 
404  .text:0049CBE1 5 fmul [ebp+a1.y] 0 a3 * a1.y
405  0 1 a3 * a1.x 1984 2 var8 * var24 768 3 var8 *
406  var28 0 4 var8 * flt_4D84E8 0 .text:0049CBE4 5 fld
407  [ebp+a3]
408  .text:0049CBE7 6 fmul [ebp+a1.z] 0 a3 * a1.z
409  0 1 a3 * a1.y 0 2 a3 * a1.x 1984 3 var8 *
410  var24 768 4 var8 * var28 0 5 var8 *
411  flt_4D84E8 0
412 
413  .text:0049CBEC 6 fstp [ebp+var_8]
414  var8 <- a3 * a1.z 0
415 
416  .text:0049CBEF 5 fld [ebp+arg4] 0 arg4
417  -1700 1 a3 * a1.y 0 2 a3 * a1.x 1984 3
418  var8 * var24 768 4 var8 * var28 0 5 var8 *
419  flt_4D84E8 0
420 
421  .text:0049CBF2 6 fsub st, st(2) 0 arg4 - a3 * a1.x
422  -3684 1 a3 * a1.y 0 2 a3 * a1.x 1984 3
423  var8 * var24 768 4 var8 * var28 0 5 var8 *
424  flt_4D84E8 0
425 
426  .text:0049CBF4 6 fld st 0 arg4 - a3 * a1.x
427  -3684 1 arg4 - a3 * a1.x -3684 2 a3 * a1.y 0 3
428  a3 * a1.x 1984 4 var8 * var24 768 5 var8 * var28
429  0 6 var8 * flt_4D84E8 0
430 
431  .text:0049CBF6 7 fadd st, st(6) 0 arg4 - a3 * a1.x + var8 *
432  flt_4D84E8 -3684 1 arg4 - a3 * a1.x -3684 2 a3 *
433  a1.y 0 3 a3 * a1.x
434  1984 4 var8 * var24 768 5 var8 * var28
435  0 6 var8 * flt_4D84E8 0 .text:0049CBF8 7 fstp dword
436  ptr [ebx] [0].x <- arg4 - a3 * a1.x + var8 * flt_4D84E8 -3684
437 
438  .text:0049CBFA 6 fld [ebp+var_18] 0 var18
439  1480 1 arg4 - a3 * a1.x -3684 2 a3 * a1.y
440  0 3 a3 * a1.x 1984 4 var8 * var24
441  768 5 var8 * var28 0 6 var8 *
442  flt_4D84E8 0
443 
444  .text:0049CBFD 7 fsub st, st(2) 0 var18 - a3 * a1.y
445  1480 1 arg4 - a3 * a1.x -3684 2 a3 * a1.y
446  0 3 a3 * a1.x 1984 4 var8 * var24
447  768 5 var8 * var28 0 6 var8 *
448  flt_4D84E8 0
449 
450  .text:0049CBFF 7 fld st 0 var18 - a3 * a1.y
451  1480 1 var18 - a3 * a1.y 1480 2 arg4 - a3 * a1.x
452  -3684 3 a3 * a1.y 0 4 a3 * a1.x
453  1984 5 var8 * var24 768 6 var8 * var28
454  0 7 var8 * flt_4D84E8 0
455 
456  .text:0049CC01 8 fadd st, st(6) 0 var18 - a3 * a1.y + var8
457  * var28 1480 1 var18 - a3 * a1.y 1480 2 arg4 -
458  a3 * a1.x -3684 3 a3 * a1.y 0 4 a3 * a1.x
459  1984 5 var8 * var24 768 6 var8 * var28
460  0 7 var8 * flt_4D84E8 0
461 
462  .text:0049CC03 8 fstp dword ptr [ebx+4]
463  [0].y <- var18 - a3 * a1.y + var8 * var28
464  1480
465 
466  .text:0049CC06 7 fld [ebp+var_4]
467  .text:0049CC09 8 fsub [ebp+var_8] 0 var4 - a3 * a1.z
468  768 1 var18 - a3 * a1.y 1480 2 arg4 - a3 * a1.x
469  -3684 3 a3 * a1.y 0 4 a3 * a1.x
470  1984 5 var8 * var24 768 6 var8 * var28
471  0 7 var8 * flt_4D84E8 0 .text:0049CC0C 8 fst [ebp+a3]
472  a3 <- var4 - a3 * a1.z 768
473 
474  .text:0049CC0F 8 fadd st, st(5)
475  .text:0049CC11 8 fstp dword ptr [ebx+8]
476  [0].z <- var4 - a3 * a1.z + var8 * var24 1536
477 
478  0 var18 - a3 *
479  a1.y 1480 1 arg4 - a3 * a1.x
480  -3684 2 a3 * a1.y 0 3 a3 * a1.x
481  1984 4 var8 * var24 768 5 var8 * var28
482  0 6 var8 * flt_4D84E8 0
483 
484 
485 
486 
487  [var20] var8 * var24
488  768 [var8] a3 * a1.z [a3] var4 - a3 * a1.z 768
489 
490 
491  .text:0049CC14 7 fld st(1)
492  .text:0049CC16 8 fsub st, st(7) 0 arg4 - a3 * a1.x - var8 *
493  flt_4D84E8 -3684 1 var18 - a3 * a1.y 1480 2 arg4 -
494  a3 * a1.x -3684 3 a3 * a1.y 0 4 a3 * a1.x
495  1984 5 var8 * var24 768 6 var8 * var28
496  0 7 var8 * flt_4D84E8 0 .text:0049CC18 8 fstp dword
497  ptr [ebx+30h] [1].x <- arg4 - a3 * a1.x - var8 * flt_4D84E8 -3684
498 
499  0 var18 - a3 *
500  a1.y 1480 1 arg4 - a3 * a1.x
501  -3684 2 a3 * a1.y 0 3 a3 * a1.x
502  1984 4 var8 * var24 768 5 var8 * var28
503  0 6 var8 * flt_4D84E8 0 .text:0049CC1B 7 fsub st,
504  st(5) .text:0049CC1D 7 fstp dword ptr [ebx+34h] [1].y <- var18 - a3 *
505  a1.y - var8 * var28 1480 .text:0049CC20 6 fstp st 0 a3 *
506  a1.y 0 1 a3 * a1.x
507  1984 2 var8 * var24 768 3 var8 * var28
508  0 4 var8 * flt_4D84E8 0
509 
510 
511  [var20] var8 * var24
512  768 [var8] a3 * a1.z [a3] var4 - a3 * a1.z 768
513 
514  .text:0049CC22 5 fld [ebp+a3] 0 var4 - a3 * a1.z
515  768 1 a3 * a1.y 0 2 a3 * a1.x
516  1984 3 var8 * var24 768 4 var8 * var28
517  0 5 var8 * flt_4D84E8 0 .text:0049CC25 6 fsub st,
518  st(3) .text:0049CC27 6 fstp dword ptr [ebx+38h] [1].z <- var4 - a3 * a1.z
519  - var8 * var24 768 - 768 = 0
520 
521  0 a3 * a1.y
522  0 1 a3 * a1.x 1984 2 var8 * var24
523  768 3 var8 * var28 0 4 var8 *
524  flt_4D84E8 0
525 
526 
527  .text:0049CC2A fld st(1)
528  .text:0049CC2C 6 fadd [ebp+arg4] 0 arg4 + a3 * a1.x
529  284 1 a3 * a1.y 0 2 a3 * a1.x
530  1984 3 var8 * var24 768 4 var8 * var28
531  0 5 var8 * flt_4D84E8 0 .text:0049CC2F 6 fst [ebp+a3]
532 
533  [var20] var8 * var24
534  768 [var8] a3 * a1.z [a3] arg4 + a3 * a1.x 284 .text:0049CC32 6
535  fsub st, st(5) .text:0049CC34 6 fstp dword ptr [ebx+60h] [2].x <- arg4
536  + a3 * a1.x - var8 * flt_4D84E8 284
537 
538  0 a3 * a1.y
539  0 1 a3 * a1.x 1984 2 var8 * var24
540  768 3 var8 * var28 0 4 var8 *
541  flt_4D84E8 0
542 
543  .text:0049CC37 5 fadd [ebp+var_18] 0 var18 + a3 * a1.y
544  1480 1 a3 * a1.x 1984 2 var8 * var24
545  768 3 var8 * var28 0 4 var8 *
546  flt_4D84E8 0
547 
548  .text:0049CC3A 5 fstp st(2) 0 a3 * a1.x
549  1984 1 var18 + a3 * a1.y 1480 2 var8 * var28
550  0 3 var8 * flt_4D84E8 0
551 
552  .text:0049CC3C 4 fstp st 0 var18 + a3 * a1.y
553  1480 1 var8 * var28 0 2 var8 *
554  flt_4D84E8 0
555 
556  .text:0049CC3E 3 fld st 0 var18 + a3 * a1.y
557  1480 1 var18 + a3 * a1.y 1480 2 var8 * var28
558  0 3 var8 * flt_4D84E8 0 .text:0049CC40 4 fsub st,
559  st(2) .text:0049CC42 4 fstp dword ptr [ebx+64h] [2].y <- var18 + a3 *
560  a1.y - var8 * var28 1480
561 
562  0 var18 + a3 *
563  a1.y 1480 1 var8 * var28 0
564  2 var8 *
565  flt_4D84E8 0
566 
567  [var20] var8 * var24
568  768 [var8] a3 * a1.z [a3] arg4 + a3 * a1.x 284 .text:0049CC45 3 fld
569  [ebp+var_8] .text:0049CC48 4 fadd [ebp+var_4] 0
570  var4 + a3 * a1.z 768 1 var18 + a3 * a1.y
571  1480 2 var8 * var28 0 3 var8 *
572  flt_4D84E8 0
573 
574  .text:0049CC4B 4 fst [ebp+arg0]
575  [var20] var8 * var24
576  768 [arg0] var4 + a3 * a1.z 768 [var8] a3 * a1.z 0
577  [a3] arg4 + a3 * a1.x
578  284
579 
580  .text:0049CC4E 4 fsub [ebp+var_20]
581  .text:0049CC51 4 fstp dword ptr [ebx+68h]
582  [2].z <- var4 + a3 * a1.z - var8 * var24 0
583 
584 
585 
586  [var20] var8 * var24
587  768 [arg0] var4 + a3 * a1.z 768 [var8] a3 * a1.z 0
588  [a3] arg4 + a3 * a1.x
589  284
590 
591 
592  0 var18 + a3 *
593  a1.y 1480 1 var8 * var28 0
594  2 var8 *
595  flt_4D84E8 0
596 
597  .text:0049CC54 3 fld [ebp+a3]
598  .text:0049CC57 4 fadd st, st(3)
599  .text:0049CC59 4 fstp dword ptr [ebx+90h]
600  [3].x <- arg4 + a3 * a1.x + var8 * flt_4D84E8
601  284
602 
603  .text:0049CC5F 3 fadd st, st(1)
604  .text:0049CC61 3 fstp dword ptr [ebx+94h]
605  [3].y <- var18 + a3 * a1.y + var8 * var28
606  1480
607 
608  .text:0049CC67 2 fstp st
609  .text:0049CC69 1 fstp st
610  0 empty
611  .text:0049CC6B 0 fld [ebp+arg0]
612  .text:0049CC6E 1 fadd [ebp+var_20]
613  .text:0049CC71 1 fstp dword ptr [ebx+98h]
614  [3].z <- var4 + a3 * a1.z + var8 * var24 1536
615 
616  0 empty
617  */
618 
619  pOutBounding[0].vWorldPosition.x =
620  face_center_x - a3 * a1.x + var_8 * flt_4D84E8;
621  pOutBounding[0].vWorldPosition.y =
622  face_center_y - a3 * a1.y + var_8 * var_28;
623  pOutBounding[0].vWorldPosition.z =
624  face_center_z - a3 * a1.z + var_8 * var_24;
625 
626  pOutBounding[1].vWorldPosition.x =
627  face_center_x - a3 * a1.x - var_8 * flt_4D84E8;
628  pOutBounding[1].vWorldPosition.y =
629  face_center_y - a3 * a1.y - var_8 * var_28;
630  pOutBounding[1].vWorldPosition.z =
631  face_center_z - a3 * a1.z - var_8 * var_24;
632 
633  pOutBounding[2].vWorldPosition.x =
634  face_center_x + a3 * a1.x - var_8 * flt_4D84E8;
635  pOutBounding[2].vWorldPosition.y =
636  face_center_y + a3 * a1.y - var_8 * var_28;
637  pOutBounding[2].vWorldPosition.z =
638  face_center_z + a3 * a1.z - var_8 * var_24;
639 
640  pOutBounding[3].vWorldPosition.x =
641  face_center_x + a3 * a1.x + var_8 * flt_4D84E8;
642  pOutBounding[3].vWorldPosition.y =
643  face_center_y + a3 * a1.y + var_8 * var_28;
644  pOutBounding[3].vWorldPosition.z =
645  face_center_z + a3 * a1.z + var_8 * var_24;
646 
647  a1.x = 0.0f;
648  a1.y = 0.0f;
649  a1.z = 0.0f;
650  a3 = face_center_x + a3 * a1.x;
651 
652  if (!FindFacePlane(pOutBounding, &a1, &a3)) return false;
653 
654  RenderVertexSoft v25; // [sp+10h] [bp-90h]@20
655  memcpy(&v25, pOutBounding, sizeof(RenderVertexSoft));
656 
657  float _dp = (v25.vWorldPosition.x - pIndoorCameraD3D->vPartyPos.x) * a1.x +
658  (v25.vWorldPosition.y - pIndoorCameraD3D->vPartyPos.y) * a1.y +
659  (v25.vWorldPosition.z - pIndoorCameraD3D->vPartyPos.z) * a1.z;
660  if (fabs(_dp) < 1e-6f) {
661  memcpy(&v25, &pOutBounding[1], sizeof(RenderVertexSoft));
662  memcpy(&pOutBounding[1], &pOutBounding[3], sizeof(RenderVertexSoft));
663  memcpy(&pOutBounding[3], &v25, sizeof(RenderVertexSoft));
664  }
665 
666  // if ( _4D864C_force_sw_render_rules && engine->config->DrawBlvDebugs())
667  //{
668  RenderVertexSoft v26; // [sp+40h] [bp-60h]@20
669  if (engine->config->debug_portal_outlines) {
670  if (!bDoNotDrawPortalFrustum) {
671  v26.vWorldPosition.x = pParty->vPosition.x;
672  v26.vWorldPosition.y = pParty->vPosition.y;
673  v26.vWorldPosition.z =
674  pParty->vPosition.z + pParty->sEyelevel; // frustum
675 
676  pIndoorCameraD3D->do_draw_debug_line_sw(&v26, 0xFF0000u, &pOutBounding[0], 0xFF0000u, 0, 0);
677  pIndoorCameraD3D->do_draw_debug_line_sw(&v26, 0xFF00u, &pOutBounding[1], 0xFF00u, 0, 0);
678  pIndoorCameraD3D->do_draw_debug_line_sw(&v26, 0xFFu, &pOutBounding[2], 0xFFu, 0, 0);
679  pIndoorCameraD3D->do_draw_debug_line_sw(&v26, 0xFFFFFFu, &pOutBounding[3], 0xFFFFFFu, 0, 0);
680  bDoNotDrawPortalFrustum = true;
681  }
682  pIndoorCameraD3D->debug_outline_sw(pOutBounding, uNumVertices, 0x1EFF1Eu, 0.00019999999); // bounding
683  }
684  //}
685 
686  // pIndoorCameraD3D->debug_outline_sw(pFaceLimits, 4, 0xFFF14040,
687  // 0.000099999997); // limits
688 
689  /*if ( _4D864C_force_sw_render_rules && engine->config->DrawBlvDebugs())
690  {
691  RenderVertexSoft v26; // [sp+40h] [bp-60h]@20
692  v26.vWorldPosition.x = face_center_x; // corner to center
693  v26.vWorldPosition.y = face_center_y;
694  v26.vWorldPosition.z = face_center_z;
695 
696  pIndoorCameraD3D->do_draw_debug_line_sw(pFaceLimits, 0xFF00u, &v26,
697  0xFF0000u, 0, 0);
698  }*/
699 
700  /*if ( _4D864C_force_sw_render_rules )
701 {
702  if (engine->config->DrawBlvDebugs())*/
703  {
704  RenderVertexSoft v25; // [sp+10h] [bp-90h]@20
705  RenderVertexSoft v26; // [sp+40h] [bp-60h]@20
706 
707  v25.vWorldPosition.x = face_center_x; // portal normal
708  v25.vWorldPosition.y = face_center_y;
709  v25.vWorldPosition.z = face_center_z;
710 
711  v26.vWorldPosition.x = face_center_x + a1.x * 400.0f;
712  v26.vWorldPosition.y = face_center_y + a1.y * 400.0f;
713  v26.vWorldPosition.z = face_center_z + a1.z * 400.0f;
714 
715  if (engine->config->debug_portal_outlines)
716  pIndoorCameraD3D->do_draw_debug_line_sw(&v25, -1, &v26, 0xFFFF00u, 0, 0);
717  }
718  //}
719 
720  return true;
721 }

Перекрестные ссылки bDoNotDrawPortalFrustum, IndoorCameraD3D::debug_outline_sw(), IndoorCameraD3D::do_draw_debug_line_sw(), engine, FindFacePlane(), flt_4D84E8, Vec3_float_::Normalize(), BLVFace::pFacePlane, pIndoorCameraD3D, POLYGON_Ceiling, POLYGON_Floor, POLYGON_VerticalWall, pParty, Party::sEyelevel, BLVFace::uAttributes, BLVFace::uPolygonType, Plane_float_::vNormal, IndoorCameraD3D::vPartyPos, Party::vPosition, RenderVertexSoft::vWorldPosition, Vec2< T >::x, Vec3_float_::x, Vec2< T >::y, Vec3_float_::y, Vec3< T >::z и Vec3_float_::z.

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

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

◆ CalcPolygonLimits()

void stru10::CalcPolygonLimits ( struct BLVFace *  pFace,
struct RenderVertexSoft  pOutVertices[4] 
)

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

130  {
131  struct {
132  float x;
133  float y;
134  int c;
135  } v46[40]; // [sp+0C];
136 
137  if (pFace->uAttributes & FACE_XY_PLANE) {
138  for (uint i = 0; i < pFace->uNumVertices; ++i) {
139  v46[i].x = pIndoor->pVertices[pFace->pVertexIDs[i]].x +
140  pFace->pXInterceptDisplacements[i];
141  v46[i].y = pIndoor->pVertices[pFace->pVertexIDs[i]].y +
142  pFace->pYInterceptDisplacements[i];
143  v46[i].c = i;
144  }
145  }
146  if (pFace->uAttributes & FACE_XZ_PLANE) {
147  for (uint i = 0; i < pFace->uNumVertices; ++i) {
148  v46[i].x = pIndoor->pVertices[pFace->pVertexIDs[i]].x +
149  pFace->pXInterceptDisplacements[i];
150  v46[i].y = pIndoor->pVertices[pFace->pVertexIDs[i]].z +
151  pFace->pZInterceptDisplacements[i];
152  v46[i].c = i;
153  }
154  }
155  if (pFace->uAttributes & FACE_YZ_PLANE) {
156  for (uint i = 0; i < pFace->uNumVertices; ++i) {
157  v46[i].x = pIndoor->pVertices[pFace->pVertexIDs[i]].y +
158  pFace->pYInterceptDisplacements[i];
159  v46[i].y = pIndoor->pVertices[pFace->pVertexIDs[i]].z +
160  pFace->pZInterceptDisplacements[i];
161  v46[i].c = i;
162  }
163  }
164 
165  float x_min = v46[0].x;
166  uint x_min_idx = 0;
167 
168  float x_max = v46[0].x;
169  uint x_max_idx = 0;
170 
171  float y_min = v46[0].y;
172  uint y_min_idx = 0;
173 
174  float y_max = v46[0].y;
175  uint y_max_idx = 0;
176 
177  for (uint i = 0; i < pFace->uNumVertices; ++i) {
178  if (v46[i].x < x_min) {
179  x_min = v46[i].x;
180  x_min_idx = v46[i].c;
181  }
182  if (v46[i].x > x_max) {
183  x_max = v46[i].x;
184  x_max_idx = v46[i].c;
185  }
186 
187  if (v46[i].y < y_min) {
188  y_min = v46[i].y;
189  y_min_idx = v46[i].c;
190  }
191  if (v46[i].y > y_max) {
192  y_max = v46[i].y;
193  y_max_idx = v46[i].c;
194  }
195  }
196 
197  RenderVertexSoft v1; // [sp+30Ch] [bp-54h]@24
198  v1.vWorldPosition.x =
199  (float)pIndoor->pVertices[pFace->pVertexIDs[x_min_idx]].x;
200  v1.vWorldPosition.y =
201  (float)pIndoor->pVertices[pFace->pVertexIDs[x_min_idx]].y;
202  v1.vWorldPosition.z =
203  (float)pIndoor->pVertices[pFace->pVertexIDs[x_min_idx]].z;
204  memcpy(&pOutVertices[0], &v1, sizeof(RenderVertexSoft));
205 
206  RenderVertexSoft v2; // [sp+30Ch] [bp-54h]@24
207  v2.vWorldPosition.x =
208  (float)pIndoor->pVertices[pFace->pVertexIDs[y_min_idx]].x;
209  v2.vWorldPosition.y =
210  (float)pIndoor->pVertices[pFace->pVertexIDs[y_min_idx]].y;
211  v2.vWorldPosition.z =
212  (float)pIndoor->pVertices[pFace->pVertexIDs[y_min_idx]].z;
213  memcpy(&pOutVertices[1], &v2, sizeof(RenderVertexSoft));
214 
215  RenderVertexSoft v3; // [sp+30Ch] [bp-54h]@24
216  v3.vWorldPosition.x =
217  (float)pIndoor->pVertices[pFace->pVertexIDs[x_max_idx]].x;
218  v3.vWorldPosition.y =
219  (float)pIndoor->pVertices[pFace->pVertexIDs[x_max_idx]].y;
220  v3.vWorldPosition.z =
221  (float)pIndoor->pVertices[pFace->pVertexIDs[x_max_idx]].z;
222  memcpy(&pOutVertices[2], &v3, sizeof(RenderVertexSoft));
223 
224  RenderVertexSoft v4; // [sp+30Ch] [bp-54h]@24
225  v4.vWorldPosition.x =
226  (double)pIndoor->pVertices[pFace->pVertexIDs[y_max_idx]].x;
227  v4.vWorldPosition.y =
228  (double)pIndoor->pVertices[pFace->pVertexIDs[y_max_idx]].y;
229  v4.vWorldPosition.z =
230  (double)pIndoor->pVertices[pFace->pVertexIDs[y_max_idx]].z;
231  memcpy(&pOutVertices[3], &v4, sizeof(RenderVertexSoft));
232 }

Перекрестные ссылки pIndoor, BLVFace::pVertexIDs, IndoorLocation::pVertices, BLVFace::pXInterceptDisplacements, BLVFace::pYInterceptDisplacements, BLVFace::pZInterceptDisplacements, BLVFace::uAttributes, BLVFace::uNumVertices, RenderVertexSoft::vWorldPosition, Vec3_float_::x, Vec3_float_::y и Vec3_float_::z.

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

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

◆ _49CE9E()

void stru10::_49CE9E ( struct BLVFace *  pFace,
struct RenderVertexSoft *  pVertices,
unsigned int  uNumVertices,
RenderVertexSoft *  pOutLimits 
)

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

69  {
70  Assert(sizeof(RenderVertexSoft) == 0x30);
71 
72  RenderVertexSoft pLimits[64];
73  stru10::CalcPolygonLimits(pFace, pLimits);
74 
75  if (pFace->uAttributes & FACE_XY_PLANE) {
76  memcpy(&pOutLimits[0],
77  &pVertices[_49CE9E_sub0_x(pVertices, uNumVertices,
78  pLimits[0].vWorldPosition.x)],
79  0x30);
80  memcpy(&pOutLimits[2],
81  &pVertices[_49CE9E_sub0_x(pVertices, uNumVertices,
82  pLimits[2].vWorldPosition.x)],
83  0x30);
84  memcpy(&pOutLimits[1],
85  &pVertices[_49CE9E_sub0_y(pVertices, uNumVertices,
86  pLimits[1].vWorldPosition.y)],
87  0x30);
88  memcpy(&pOutLimits[3],
89  &pVertices[_49CE9E_sub0_y(pVertices, uNumVertices,
90  pLimits[3].vWorldPosition.y)],
91  0x30);
92  } else if (pFace->uAttributes & FACE_XZ_PLANE) {
93  memcpy(&pOutLimits[0],
94  &pVertices[_49CE9E_sub0_x(pVertices, uNumVertices,
95  pLimits[0].vWorldPosition.x)],
96  0x30);
97  memcpy(&pOutLimits[2],
98  &pVertices[_49CE9E_sub0_x(pVertices, uNumVertices,
99  pLimits[2].vWorldPosition.x)],
100  0x30);
101  memcpy(&pOutLimits[1],
102  &pVertices[_49CE9E_sub0_z(pVertices, uNumVertices,
103  pLimits[1].vWorldPosition.z)],
104  0x30);
105  memcpy(&pOutLimits[3],
106  &pVertices[_49CE9E_sub0_z(pVertices, uNumVertices,
107  pLimits[3].vWorldPosition.z)],
108  0x30);
109  } else if (pFace->uAttributes & FACE_YZ_PLANE) {
110  memcpy(&pOutLimits[0],
111  &pVertices[_49CE9E_sub0_y(pVertices, uNumVertices,
112  pLimits[0].vWorldPosition.y)],
113  0x30);
114  memcpy(&pOutLimits[2],
115  &pVertices[_49CE9E_sub0_y(pVertices, uNumVertices,
116  pLimits[2].vWorldPosition.y)],
117  0x30);
118  memcpy(&pOutLimits[1],
119  &pVertices[_49CE9E_sub0_z(pVertices, uNumVertices,
120  pLimits[1].vWorldPosition.z)],
121  0x30);
122  memcpy(&pOutLimits[3],
123  &pVertices[_49CE9E_sub0_z(pVertices, uNumVertices,
124  pLimits[3].vWorldPosition.z)],
125  0x30);
126  }
127 }

Перекрестные ссылки _49CE9E_sub0_x(), _49CE9E_sub0_y(), _49CE9E_sub0_z(), CalcPolygonLimits(), pVertices и BLVFace::uAttributes.

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

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

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

◆ vdestructor_ptr

void(*** stru10::vdestructor_ptr) (stru10 *, bool)

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

◆ bDoNotDrawPortalFrustum

int stru10::bDoNotDrawPortalFrustum

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

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

Объявления и описания членов структур находятся в файлах:
BLVFace::uPolygonType
PolygonType uPolygonType
Definition: Indoor.h:487
stru10::CalcPolygonLimits
void CalcPolygonLimits(struct BLVFace *pFace, struct RenderVertexSoft pOutVertices[4])
Definition: stru10.cpp:130
Vec3_float_
Definition: VectorTypes.h:74
Party::vPosition
Vec3_int_ vPosition
Definition: Party.h:250
BLVFace::uNumVertices
uint8_t uNumVertices
Definition: Indoor.h:488
IndoorCameraD3D::do_draw_debug_line_sw
void do_draw_debug_line_sw(struct RenderVertexSoft *pLineBegin, signed int sStartDiffuse, struct RenderVertexSoft *pLineEnd, signed int sEndDiffuse, unsigned int uOutNumVertices, float z_stuff)
Definition: IndoorCameraD3D.cpp:311
IndoorCameraD3D_Vec3::x
float x
Definition: IndoorCameraD3D.h:21
_49CE9E_sub0_x
int _49CE9E_sub0_x(RenderVertexSoft *pVertices, unsigned int uNumVertices, float test_val)
Definition: stru10.cpp:7
Vec2::x
T x
Definition: VectorTypes.h:12
BLVFace::pVertexIDs
uint16_t * pVertexIDs
Definition: Indoor.h:476
Vec3_float_::x
float x
Definition: VectorTypes.h:89
stru10::FindFaceNormal
bool FindFaceNormal(struct RenderVertexSoft *pFaceBounding1, struct RenderVertexSoft *pFaceBounding2, struct Vec3_float_ *pRayStart, struct IndoorCameraD3D_Vec4 *pPortalDataFrustum)
Definition: stru10.cpp:783
Party::sEyelevel
int sEyelevel
Definition: Party.h:239
BLVFace::pXInterceptDisplacements
int16_t * pXInterceptDisplacements
Definition: Indoor.h:477
engine
std::shared_ptr< Engine > engine
Definition: Engine.cpp:130
Vec3_float_::Cross
static Vec3_float_ * Cross(Vec3_float_ *v1, Vec3_float_ *pOut, float x, float y, float z)
Definition: VectorTypes.h:77
stru10::CalcFaceBounding
bool CalcFaceBounding(struct BLVFace *pFace, struct RenderVertexSoft *pFaceLimits, unsigned int uNumVertices, struct RenderVertexSoft *pOutBounding)
Definition: stru10.cpp:235
POLYGON_Floor
@ POLYGON_Floor
Definition: Indoor.h:220
Vec3_float_::y
float y
Definition: VectorTypes.h:90
Vec3_float_::z
float z
Definition: VectorTypes.h:91
pIndoor
IndoorLocation * pIndoor
Definition: Indoor.cpp:49
Vec3_float_::Normalize
void Normalize()
Definition: VectorTypes.cpp:22
Plane_float_::vNormal
struct Vec3_float_ vNormal
Definition: VectorTypes.h:136
pVertices
struct RenderVertexD3D3 pVertices[50]
Definition: Render.cpp:50
y
EGLSurface EGLint EGLint y
Definition: SDL_egl.h:1596
IndoorCameraD3D::vPartyPos
Vec3< int > vPartyPos
Definition: IndoorCameraD3D.h:253
Vec2::y
T y
Definition: VectorTypes.h:13
stru10::_49C720
char _49C720(struct RenderVertexSoft *pFaceBounding, struct IndoorCameraD3D_Vec4 *pPortalDataFrustum)
Definition: stru10.cpp:763
pParty
Party * pParty
Definition: Party.cpp:30
BLVFace::pZInterceptDisplacements
int16_t * pZInterceptDisplacements
Definition: Indoor.h:479
x
EGLSurface EGLint x
Definition: SDL_egl.h:1596
IndoorCameraD3D_Vec3::y
float y
Definition: IndoorCameraD3D.h:22
IndoorCameraD3D::debug_outline_sw
void debug_outline_sw(struct RenderVertexSoft *a2, unsigned int uNumVertices, unsigned int uDiffuse, float a5)
Definition: IndoorCameraD3D.cpp:402
v1
GLfloat GLfloat v1
Definition: SDL_opengl_glext.h:694
BLVFace::pFacePlane
struct Plane_float_ pFacePlane
Definition: Indoor.h:470
IndoorCameraD3D_Vec4::dot
float dot
Definition: IndoorCameraD3D.h:39
f
GLfloat f
Definition: SDL_opengl_glext.h:1873
_49CE9E_sub0_z
int _49CE9E_sub0_z(RenderVertexSoft *pVertices, unsigned int uNumVertices, float test_val)
Definition: stru10.cpp:47
stru10::_49CE9E
void _49CE9E(struct BLVFace *pFace, struct RenderVertexSoft *pVertices, unsigned int uNumVertices, RenderVertexSoft *pOutLimits)
Definition: stru10.cpp:68
_49CE9E_sub0_y
int _49CE9E_sub0_y(RenderVertexSoft *pVertices, unsigned int uNumVertices, float test_val)
Definition: stru10.cpp:27
stru10::FindFacePlane
bool FindFacePlane(struct RenderVertexSoft *face, struct Vec3_float_ *out_normal, float *out_distance)
Definition: stru10.cpp:820
BLVFace::pYInterceptDisplacements
int16_t * pYInterceptDisplacements
Definition: Indoor.h:478
IndoorCameraD3D_Vec3::z
float z
Definition: IndoorCameraD3D.h:23
c
const GLubyte * c
Definition: SDL_opengl_glext.h:11096
v2
GLfloat GLfloat GLfloat v2
Definition: SDL_opengl_glext.h:695
uint
unsigned int uint
Definition: MM7.h:4
v3
GLfloat GLfloat GLfloat GLfloat v3
Definition: SDL_opengl_glext.h:696
stru10::bDoNotDrawPortalFrustum
int bDoNotDrawPortalFrustum
Definition: stru10.h:32
RenderVertexSoft::vWorldPosition
Vec3_float_ vWorldPosition
Definition: IRender.h:116
IndoorLocation::pVertices
struct Vec3_short_ * pVertices
Definition: Indoor.h:628
flt_4D84E8
float flt_4D84E8
Definition: mm7_data.cpp:212
RenderVertexSoft
Definition: IRender.h:113
pIndoorCameraD3D
IndoorCameraD3D * pIndoorCameraD3D
Definition: IndoorCameraD3D.cpp:21
POLYGON_Ceiling
@ POLYGON_Ceiling
Definition: Indoor.h:222
BLVFace::uAttributes
unsigned int uAttributes
Definition: Indoor.h:475
Vec3::z
T z
Definition: VectorTypes.h:27
POLYGON_VerticalWall
@ POLYGON_VerticalWall
Definition: Indoor.h:218