Subversion Repositories Games.Carmageddon

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include "finteray.h"
  2. #include "brender/brender.h"
  3. #include "brucetrk.h"
  4. #include "car.h"
  5. #include "globvars.h"
  6. #include "harness/trace.h"
  7. #include "raycast.h"
  8. #include "world.h"
  9. #include <math.h>
  10. #include <stdlib.h>
  11.  
  12. int gPling_materials = 1;
  13. br_material* gSub_material;
  14. br_material* gReal_material;
  15. int gNfaces;
  16. br_matrix34 gPick_model_to_view__finteray; // suffix added to avoid duplicate symbol
  17. int gTemp_group;
  18. br_model* gNearest_model;
  19. br_model* gSelected_model;
  20. int gNearest_face_group;
  21. int gNearest_face;
  22. br_scalar gNearest_T;
  23. tFace_ref* gPling_face;
  24.  
  25. // IDA: int __cdecl BadDiv(br_scalar a, br_scalar b)
  26. // Suffix added to avoid duplicate symbol
  27. int BadDiv__finteray(br_scalar a, br_scalar b) {
  28.     // LOG_TRACE("(%f, %f)", a, b);
  29.  
  30.     return fabsf(b) < 1.0f && fabsf(a) > fabsf(b) * BR_SCALAR_MAX;
  31. }
  32.  
  33. // IDA: void __usercall DRVector2AccumulateScale(br_vector2 *a@<EAX>, br_vector2 *b@<EDX>, br_scalar s)
  34. // Suffix added to avoid duplicate symbol
  35. void DRVector2AccumulateScale__finteray(br_vector2* a, br_vector2* b, br_scalar s) {
  36.     LOG_TRACE("(%p, %p, %f)", a, b, s);
  37.  
  38.     a->v[0] = b->v[0] * s + a->v[0];
  39.     a->v[1] = b->v[1] * s + a->v[1];
  40. }
  41.  
  42. // IDA: int __usercall PickBoundsTestRay@<EAX>(br_bounds *b@<EAX>, br_vector3 *rp@<EDX>, br_vector3 *rd@<EBX>, br_scalar t_near, br_scalar t_far, br_scalar *new_t_near, br_scalar *new_t_far)
  43. //  Suffix added to avoid duplicate symbol
  44. int PickBoundsTestRay__finteray(br_bounds* b, br_vector3* rp, br_vector3* rd, br_scalar t_near, br_scalar t_far, br_scalar* new_t_near, br_scalar* new_t_far) {
  45.     int i;
  46.     float s;
  47.     float t;
  48.     LOG_TRACE("(%p, %p, %p, %f, %f, %p, %p)", b, rp, rd, t_near, t_far, new_t_near, new_t_far);
  49.  
  50.     for (i = 0; i < 3; i++) {
  51.         if (rd->v[i] >= -0.00000023841858) {
  52.             if (rd->v[i] <= 0.00000023841858) {
  53.                 if (b->max.v[i] < rp->v[i] || rp->v[i] < b->min.v[i]) {
  54.                     return 0;
  55.                 }
  56.             } else {
  57.                 s = (-1.0f / rd->v[i]) * (rp->v[i] - b->max.v[i]);
  58.                 if (s >= BR_SCALAR_MIN) {
  59.                     if (s < t_far) {
  60.                         t_far = (-1.0f / rd->v[i]) * (rp->v[i] - b->max.v[i]);
  61.                     }
  62.                 } else {
  63.                     t_far = BR_SCALAR_MIN;
  64.                 }
  65.                 t = (-1.0f / rd->v[i]) * (rp->v[i] - b->min.v[i]);
  66.                 if (t <= BR_SCALAR_MAX) {
  67.                     if (t > t_near) {
  68.                         t_near = (-1.0f / rd->v[i]) * (rp->v[i] - b->min.v[i]);
  69.                     }
  70.                 } else {
  71.                     t_near = BR_SCALAR_MAX;
  72.                 }
  73.             }
  74.         } else {
  75.             s = (-1.0f / rd->v[i]) * (rp->v[i] - b->max.v[i]);
  76.             if (s <= BR_SCALAR_MAX) {
  77.                 if (s > t_near) {
  78.                     t_near = (-1.0f / rd->v[i]) * (rp->v[i] - b->max.v[i]);
  79.                 }
  80.             } else {
  81.                 t_near = BR_SCALAR_MAX;
  82.             }
  83.             t = (-1.0f / rd->v[i]) * (rp->v[i] - b->min.v[i]);
  84.             if (t >= BR_SCALAR_MIN) {
  85.                 if (t < t_far) {
  86.                     t_far = (-1.0f / rd->v[i]) * (rp->v[i] - b->min.v[i]);
  87.                 }
  88.             } else {
  89.                 t_far = BR_SCALAR_MIN;
  90.             }
  91.         }
  92.     }
  93.     if (t_far < t_near) {
  94.         return 0;
  95.     }
  96.     *new_t_near = t_near;
  97.     *new_t_far = t_far;
  98.     return 1;
  99. }
  100.  
  101. // IDA: int __usercall ActorRayPick2D@<EAX>(br_actor *ap@<EAX>, br_vector3 *pPosition@<EDX>, br_vector3 *pDir@<EBX>, br_model *model@<ECX>, br_material *material, dr_pick2d_cbfn *callback)
  102. int ActorRayPick2D(br_actor* ap, br_vector3* pPosition, br_vector3* pDir, br_model* model, br_material* material, dr_pick2d_cbfn* callback) {
  103.     br_actor* a;
  104.     br_model* this_model;
  105.     br_material* this_material;
  106.     br_scalar t_near;
  107.     br_scalar t_far;
  108.     int r;
  109.     br_matrix34 mat;
  110.     br_matrix34 invmat;
  111.     br_vector3 pos;
  112.     br_vector3 dir;
  113.     void* arg;
  114.     LOG_TRACE("(%p, %p, %p, %p, %p, %p)", ap, pPosition, pDir, model, material, callback);
  115.  
  116.     t_near = 0.0;
  117.     t_far = 1.0;
  118.     r = 0;
  119.     arg = NULL;
  120.     if (ap->model != NULL) {
  121.         this_model = ap->model;
  122.     } else {
  123.         this_model = model;
  124.     }
  125.     if (ap->material != NULL) {
  126.         this_material = ap->material;
  127.     } else {
  128.         this_material = material;
  129.     }
  130.     if (ap->render_style == BR_RSTYLE_NONE) {
  131.         return 0;
  132.     }
  133.     if (ap->identifier != NULL && ap->identifier[0] == '&') {
  134.         BrTransformToMatrix34(&mat, &ap->t);
  135.         BrMatrix34Inverse(&invmat, &mat);
  136.         BrMatrix34ApplyP(&pos, pPosition, &invmat);
  137.         BrMatrix34ApplyV(&dir, pDir, &invmat);
  138.         pPosition = &pos;
  139.         pDir = &dir;
  140.     }
  141.     if (ap->type == BR_ACTOR_MODEL) {
  142.         if (PickBoundsTestRay__finteray(&this_model->bounds, pPosition, pDir, t_near, t_far, &t_near, &t_far)) {
  143.             t_near = 0.0;
  144.             t_far = MIN(1.f, gNearest_T);
  145.             r = callback(ap, this_model, this_material, pPosition, pDir, t_near, t_far, arg);
  146.             if (r) {
  147.                 return r;
  148.             }
  149.         }
  150.         if (r) {
  151.             return r;
  152.         }
  153.     } else if (ap->type >= BR_ACTOR_BOUNDS && ap->type <= BR_ACTOR_BOUNDS_CORRECT) {
  154.         if (PickBoundsTestRay__finteray((br_bounds*)ap->type_data, pPosition, pDir, t_near, t_far, &t_near, &t_far)) {
  155.             for (a = ap->children; a != NULL; a = a->next) {
  156.                 r = ActorRayPick2D(a, pPosition, pDir, this_model, this_material, callback);
  157.                 if (r) {
  158.                     break;
  159.                 }
  160.             }
  161.         }
  162.         return r;
  163.     }
  164.     for (a = ap->children; a != NULL; a = a->next) {
  165.         r = ActorRayPick2D(a, pPosition, pDir, this_model, this_material, callback);
  166.         if (r) {
  167.             break;
  168.         }
  169.     }
  170.     return r;
  171. }
  172.  
  173. // IDA: int __usercall DRSceneRayPick2D@<EAX>(br_actor *world@<EAX>, br_vector3 *pPosition@<EDX>, br_vector3 *pDir@<EBX>, dr_pick2d_cbfn *callback@<ECX>)
  174. int DRSceneRayPick2D(br_actor* world, br_vector3* pPosition, br_vector3* pDir, dr_pick2d_cbfn* callback) {
  175.     LOG_TRACE("(%p, %p, %p, %p)", world, pPosition, pDir, callback);
  176.  
  177.     BrMatrix34Inverse(&gPick_model_to_view__finteray, &world->t.t.mat);
  178.     LOG_WARN_ONCE("Missing material and model pointers to ActorRayPick2D");
  179.     return ActorRayPick2D(world, pPosition, pDir, NULL, NULL, callback);
  180. }
  181.  
  182. // IDA: int __usercall DRModelPick2D@<EAX>(br_model *model@<EAX>, br_material *material@<EDX>, br_vector3 *ray_pos@<EBX>, br_vector3 *ray_dir@<ECX>, br_scalar t_near, br_scalar t_far, dr_modelpick2d_cbfn *callback, void *arg)
  183. //  Suffix added to avoid duplicate symbol
  184. int DRModelPick2D__finteray(br_model* model, br_material* material, br_vector3* ray_pos, br_vector3* ray_dir, br_scalar t_near, br_scalar t_far, dr_modelpick2d_cbfn* callback, void* arg) {
  185.     DR_FACE* fp;
  186.     int f;
  187.     int axis_m;
  188.     int axis_0;
  189.     int axis_1;
  190.     br_scalar t;
  191.     //br_scalar n; // Pierre-Marie Baty -- unused variable
  192.     br_scalar d;
  193.     br_vector3 p;
  194.     float u0;
  195.     float u1;
  196.     float u2;
  197.     float v0;
  198.     float v1;
  199.     float v2;
  200.     br_scalar v0i1;
  201.     br_scalar v0i2;
  202.     float alpha;
  203.     float beta;
  204.     float f_d;
  205.     float f_n;
  206.     br_scalar s_alpha;
  207.     br_scalar s_beta;
  208.     br_vector2 map;
  209.     int v;
  210.     int e;
  211.     int r;
  212.     br_material* this_material;
  213.     br_scalar numerator;
  214.     //float f_numerator; // Pierre-Marie Baty -- unused variable
  215.     int group;
  216.     LOG_TRACE("(%p, %p, %p, %p, %f, %f, %p, %p)", model, material, ray_pos, ray_dir, t_near, t_far, callback, arg);
  217.  
  218.     t_near -= 0.00001f;
  219.     t_far += 0.00001f;
  220.     for (group = 0; group < V11MODEL(model)->ngroups; group++) {
  221.         for (f = 0; f < V11MODEL(model)->groups[group].nfaces; f++) {
  222.             fp = &V11MODEL(model)->groups[group].faces[f];
  223.             if (V11MODEL(model)->groups[group].face_colours_material) {
  224.                 this_material = V11MODEL(model)->groups[group].face_colours_material;
  225.             } else {
  226.                 this_material = material;
  227.             }
  228.             d = fp->eqn.v[1] * ray_dir->v[1] + fp->eqn.v[2] * ray_dir->v[2] + fp->eqn.v[0] * ray_dir->v[0];
  229.             if (fabs(d) >= 0.00000023841858 && (!this_material || !this_material->identifier || *this_material->identifier != '!' || !gPling_materials)
  230.                 && (!this_material || (this_material->flags & 0x1800) != 0 || d <= 0.0)) {
  231.                 numerator = fp->eqn.v[1] * ray_pos->v[1]
  232.                     + fp->eqn.v[2] * ray_pos->v[2]
  233.                     + fp->eqn.v[0] * ray_pos->v[0]
  234.                     - fp->eqn.v[3];
  235.                 if (!BadDiv__finteray(numerator, d)) {
  236.                     t = -(numerator / d);
  237.                     if (t >= t_near && t <= t_far) {
  238.                         BrVector3Scale(&p, ray_dir, t);
  239.                         BrVector3Accumulate(&p, ray_pos);
  240.                         axis_m = fabsf(fp->eqn.v[0]) < fabsf(fp->eqn.v[1]);
  241.                         if (fabsf(fp->eqn.v[2]) > fabsf(fp->eqn.v[axis_m])) {
  242.                             axis_m = 2;
  243.                         }
  244.                         if (axis_m) {
  245.                             axis_0 = 0;
  246.                             if (axis_m == 1) {
  247.                                 axis_1 = 2;
  248.                             } else {
  249.                                 axis_1 = 1;
  250.                             }
  251.                         } else {
  252.                             axis_0 = 1;
  253.                             axis_1 = 2;
  254.                         }
  255.  
  256.                         v0 = V11MODEL(model)->groups[group].vertices[fp->vertices[0]].p.v[axis_0];
  257.                         u0 = V11MODEL(model)->groups[group].vertices[fp->vertices[0]].p.v[axis_1];
  258.                         v1 = V11MODEL(model)->groups[group].vertices[fp->vertices[1]].p.v[axis_0] - v0;
  259.                         u1 = V11MODEL(model)->groups[group].vertices[fp->vertices[1]].p.v[axis_1] - u0;
  260.                         v2 = V11MODEL(model)->groups[group].vertices[fp->vertices[2]].p.v[axis_0] - v0;
  261.                         u2 = V11MODEL(model)->groups[group].vertices[fp->vertices[2]].p.v[axis_1] - u0;
  262.  
  263.                         v0i1 = p.v[axis_0] - v0;
  264.                         v0i2 = p.v[axis_1] - u0;
  265.                         if (fabs(v1) > 0.0000002384185791015625) {
  266.                             f_n = u2 * v1 - u1 * v2;
  267.                             f_d = v0i2 * v1 - u1 * v0i1;
  268.                             if (fabs(f_n) < fabs(f_d)) {
  269.                                 continue;
  270.                             }
  271.                             if (f_n == 0) {
  272.                                 continue;
  273.                             }
  274.                             beta = f_d / f_n;
  275.                             if (beta < 0.0 || beta > 1.0 || v1 == 0.0) {
  276.                                 continue;
  277.                             }
  278.                             alpha = (v0i1 - beta * v2) / v1;
  279.                         } else {
  280.                             if (fabsf(v2) < fabsf(v0i1)) {
  281.                                 continue;
  282.                             }
  283.                             if (v2 == 0) {
  284.                                 continue;
  285.                             }
  286.  
  287.                             beta = v0i1 / v2;
  288.                             if (beta < 0.0 || beta > 1.0 || u1 == 0.0) {
  289.                                 continue;
  290.                             }
  291.                             alpha = (v0i2 - beta * u2) / u1;
  292.                         }
  293.  
  294.                         if (alpha >= 0.0 && beta + alpha <= 1.0) {
  295.                             s_alpha = alpha;
  296.                             s_beta = beta;
  297.                             map.v[0] = V11MODEL(model)->groups[group].vertices[fp->vertices[1]].map.v[0] * s_alpha;
  298.                             map.v[1] = V11MODEL(model)->groups[group].vertices[fp->vertices[1]].map.v[1] * s_alpha;
  299.                             DRVector2AccumulateScale__finteray(
  300.                                 &map,
  301.                                 &V11MODEL(model)->groups[group].vertices[fp->vertices[2]].map,
  302.                                 s_beta);
  303.                             DRVector2AccumulateScale__finteray(
  304.                                 &map,
  305.                                 &V11MODEL(model)->groups[group].vertices[fp->vertices[0]].map,
  306.                                 1.0 - (s_alpha + s_beta));
  307.                             v = 0;
  308.                             e = 1;
  309.                             if (s_alpha <= s_beta) {
  310.                                 if (0.5 - s_beta / 2.0 > s_alpha) {
  311.                                     e = 0;
  312.                                 }
  313.                                 if (1.0 - s_beta * 2.0 < s_alpha) {
  314.                                     v = 1;
  315.                                 }
  316.                             } else {
  317.                                 if (1.0 - s_beta * 2.0 > s_alpha) {
  318.                                     e = 2;
  319.                                 }
  320.                                 if (0.5 - s_beta / 2.0 < s_alpha) {
  321.                                     v = 2;
  322.                                 }
  323.                             }
  324.                             gTemp_group = group;
  325.                             r = callback(model, this_material, ray_pos, ray_dir, t, f, e, v, &p, &map, arg);
  326.                             if (r) {
  327.                                 return r;
  328.                             }
  329.                         }
  330.                     }
  331.                 }
  332.             }
  333.         }
  334.     }
  335.     return 0;
  336. }
  337.  
  338. // IDA: int __cdecl FindHighestPolyCallBack(br_model *pModel, br_material *pMaterial, br_vector3 *pRay_pos, br_vector3 *pRay_dir, br_scalar pT, int pF, int pE, int pV, br_vector3 *pPoint, br_vector2 *pMap, void *pArg)
  339. // Suffix added to avoid duplicate symbol
  340. int FindHighestPolyCallBack__finteray(br_model* pModel, br_material* pMaterial, br_vector3* pRay_pos, br_vector3* pRay_dir, br_scalar pT, int pF, int pE, int pV, br_vector3* pPoint, br_vector2* pMap, void* pArg) {
  341.     LOG_TRACE("(%p, %p, %p, %p, %f, %d, %d, %d, %p, %p, %p)", pModel, pMaterial, pRay_pos, pRay_dir, pT, pF, pE, pV, pPoint, pMap, pArg);
  342.  
  343.     if (pT < (double)gNearest_T) {
  344.         gNearest_T = pT;
  345.         gNearest_model = pModel;
  346.         gNearest_face = pF;
  347.         gNearest_face_group = gTemp_group;
  348.     }
  349.     return 0;
  350. }
  351.  
  352. // IDA: int __cdecl FindHighestCallBack(br_actor *pActor, br_model *pModel, br_material *pMaterial, br_vector3 *pRay_pos, br_vector3 *pRay_dir, br_scalar pT_near, br_scalar pT_far, void *pArg)
  353. // Suffix added to avoid duplicate symbol
  354. int FindHighestCallBack__finteray(br_actor* pActor, br_model* pModel, br_material* pMaterial, br_vector3* pRay_pos, br_vector3* pRay_dir, br_scalar pT_near, br_scalar pT_far, void* pArg) {
  355.     LOG_TRACE("(%p, %p, %p, %p, %p, %f, %f, %p)", pActor, pModel, pMaterial, pRay_pos, pRay_dir, pT_near, pT_far, pArg);
  356.  
  357.     if (gProgram_state.current_car.current_car_actor < 0
  358.         || gProgram_state.current_car.car_model_actors[gProgram_state.current_car.current_car_actor].actor != pActor) {
  359.         DRModelPick2D__finteray(pModel, pMaterial, pRay_pos, pRay_dir, pT_near, pT_far, FindHighestPolyCallBack__finteray, pArg);
  360.     }
  361.     return 0;
  362. }
  363.  
  364. // IDA: void __usercall FindFace(br_vector3 *pPosition@<EAX>, br_vector3 *pDir@<EDX>, br_vector3 *nor@<EBX>, br_scalar *t@<ECX>, br_material **material)
  365. void FindFace(br_vector3* pPosition, br_vector3* pDir, br_vector3* nor, br_scalar* t, br_material** material) {
  366.     int group;
  367.     LOG_TRACE("(%p, %p, %p, %p, %p)", pPosition, pDir, nor, t, material);
  368.  
  369.     gNearest_T = 100.0f;
  370.     DRSceneRayPick2D(gTrack_actor, pPosition, pDir, FindHighestCallBack__finteray);
  371.     *t = gNearest_T;
  372.     if (*t < 100.0f) {
  373.         group = gNearest_face_group;
  374.         nor->v[0] = V11MODEL(gNearest_model)->groups[group].faces[gNearest_face].eqn.v[0];
  375.         nor->v[1] = V11MODEL(gNearest_model)->groups[group].faces[gNearest_face].eqn.v[1];
  376.         nor->v[2] = V11MODEL(gNearest_model)->groups[group].faces[gNearest_face].eqn.v[2];
  377.         *material = V11MODEL(gNearest_model)->groups[group].face_colours_material;
  378.     }
  379. }
  380.  
  381. // IDA: void __cdecl EnablePlingMaterials()
  382. void EnablePlingMaterials(void) {
  383.     LOG_TRACE("()");
  384.  
  385.     gPling_materials = 1;
  386. }
  387.  
  388. // IDA: void __cdecl DisablePlingMaterials()
  389. void DisablePlingMaterials(void) {
  390.     LOG_TRACE("()");
  391.  
  392.     gPling_materials = 0;
  393. }
  394.  
  395. // IDA: void __usercall CheckSingleFace(tFace_ref *pFace@<EAX>, br_vector3 *ray_pos@<EDX>, br_vector3 *ray_dir@<EBX>, br_vector3 *normal@<ECX>, br_scalar *rt)
  396. void CheckSingleFace(tFace_ref* pFace, br_vector3* ray_pos, br_vector3* ray_dir, br_vector3* normal, br_scalar* rt) {
  397.     br_scalar t;
  398.     br_scalar numerator;
  399.     br_scalar d;
  400.     br_vector3 p;
  401.     br_vector3 tv;
  402.     int axis_m;
  403.     int axis_0;
  404.     int axis_1;
  405.     double u0;
  406.     double u1;
  407.     double u2;
  408.     double v0;
  409.     double v1;
  410.     double v2;
  411.     br_scalar v0i1;
  412.     br_scalar v0i2;
  413.     double alpha;
  414.     double beta;
  415.     double f_d;
  416.     //double f_n; // Pierre-Marie Baty -- unused variable
  417.     //double f_numerator; // Pierre-Marie Baty -- unused variable
  418.     br_material* this_material;
  419.     LOG_TRACE("(%p, %p, %p, %p, %p)", pFace, ray_pos, ray_dir, normal, rt);
  420.  
  421.     this_material = pFace->material;
  422.     *rt = 100.0;
  423.  
  424.     d = pFace->normal.v[1] * ray_dir->v[1] + ray_dir->v[2] * pFace->normal.v[2] + ray_dir->v[0] * pFace->normal.v[0];
  425.     if ((this_material == NULL || (this_material->flags & (BR_MATF_TWO_SIDED | BR_MATF_ALWAYS_VISIBLE )) != 0 || d <= 0.0)
  426.         && (!this_material || !this_material->identifier || *this_material->identifier != '!' || !gPling_materials)
  427.         && fabs(d) >= 0.00000023841858) {
  428.         BrVector3Sub(&p, ray_pos, &pFace->v[0]);
  429.         numerator = BrVector3Dot(&pFace->normal, &p);
  430.         if (!BadDiv__finteray(numerator, d)) {
  431.             if (d > 0.0) {
  432.                 if (-numerator < -0.001 || -numerator > d + 0.003) {
  433.                     return;
  434.                 }
  435.             } else if (numerator < -0.001 || 0.003 - d < numerator) {
  436.                 return;
  437.             }
  438.             t = -(numerator / d);
  439.             if (t > 1.0) {
  440.                 t = 1.0;
  441.             }
  442.             BrVector3Scale(&tv, ray_dir, t);
  443.             BrVector3Accumulate(&tv, ray_pos);
  444.             axis_m = fabs(pFace->normal.v[0]) < fabs(pFace->normal.v[1]);
  445.             if (fabs(pFace->normal.v[2]) > fabs(pFace->normal.v[axis_m])) {
  446.                 axis_m = 2;
  447.             }
  448.             if (axis_m) {
  449.                 axis_0 = 0;
  450.                 if (axis_m == 1) {
  451.                     axis_1 = 2;
  452.                 } else {
  453.                     axis_1 = 1;
  454.                 }
  455.             } else {
  456.                 axis_0 = 1;
  457.                 axis_1 = 2;
  458.             }
  459.             v0i1 = pFace->v[0].v[axis_0];
  460.             v0i2 = pFace->v[0].v[axis_1];
  461.             u0 = pFace->v[1].v[axis_0] - v0i1;
  462.             u1 = pFace->v[1].v[axis_1] - v0i2;
  463.             v0 = pFace->v[2].v[axis_0] - v0i1;
  464.             v1 = pFace->v[2].v[axis_1] - v0i2;
  465.             u2 = tv.v[axis_0] - v0i1;
  466.             v2 = tv.v[axis_1] - v0i2;
  467.             if (fabs(u0) > 0.0000002384185791015625) {
  468.                 f_d = v1 * u0 - u1 * v0;
  469.                 if (f_d == 0) {
  470.                     return;
  471.                 }
  472.                 alpha = (v2 * u0 - u1 * u2) / f_d;
  473.                 beta = (u2 - alpha * v0) / u0;
  474.             } else {
  475.                 alpha = u2 / v0;
  476.                 beta = (v2 - alpha * v1) / u1;
  477.             }
  478.             if (beta >= -0.0001 && alpha >= -0.0001 && alpha + beta <= 1.0001) {
  479.                 *rt = t;
  480.                 *normal = pFace->normal;
  481.                 if (d > 0.0) {
  482.                     BrVector3Negate(normal, normal);
  483.                 }
  484.             }
  485.         }
  486.     }
  487. }
  488.  
  489. // IDA: void __usercall MultiRayCheckSingleFace(int pNum_rays@<EAX>, tFace_ref *pFace@<EDX>, br_vector3 *ray_pos@<EBX>, br_vector3 *ray_dir@<ECX>, br_vector3 *normal, br_scalar *rt)
  490. void MultiRayCheckSingleFace(int pNum_rays, tFace_ref* pFace, br_vector3* ray_pos, br_vector3* ray_dir, br_vector3* normal, br_scalar* rt) {
  491.     int i;
  492.     br_scalar t[4];
  493.     br_scalar numerator;
  494.     br_scalar d;
  495.     br_vector3 p[4];
  496.     br_vector3 tv;
  497.     int axis_m;
  498.     int axis_0;
  499.     int axis_1;
  500.     double u0[4];
  501.     double u1;
  502.     double u2;
  503.     double v0[4];
  504.     double v1;
  505.     double v2;
  506.     br_scalar v0i1;
  507.     br_scalar v0i2;
  508.     double alpha;
  509.     double beta;
  510.     double f_d;
  511.     double f_n;
  512.     double f_numerator;
  513.     br_material* this_material;
  514.     LOG_TRACE("(%d, %p, %p, %p, %p, %p)", pNum_rays, pFace, ray_pos, ray_dir, normal, rt);
  515.  
  516.     this_material = pFace->material;
  517.     d = ray_dir->v[2] * pFace->normal.v[2] + ray_dir->v[1] * pFace->normal.v[1] + ray_dir->v[0] * pFace->normal.v[0];
  518.     for (i = 0; i < pNum_rays; ++i) {
  519.         rt[i] = 100.0;
  520.     }
  521.     if ((!this_material || (this_material->flags & 0x1800) != 0 || d <= 0.0)
  522.         && (!this_material || !this_material->identifier || *this_material->identifier != '!' || !gPling_materials)
  523.         && fabs(d) >= 0.00000023841858) {
  524.         for (i = 0;; ++i) {
  525.             if (i >= pNum_rays) {
  526.                 axis_m = fabs(pFace->normal.v[0]) < fabs(pFace->normal.v[1]);
  527.                 if (fabs(pFace->normal.v[2]) > fabs(pFace->normal.v[axis_m])) {
  528.                     axis_m = 2;
  529.                 }
  530.                 if (axis_m) {
  531.                     axis_0 = 0;
  532.                     if (axis_m == 1) {
  533.                         axis_1 = 2;
  534.                     } else {
  535.                         axis_1 = 1;
  536.                     }
  537.                 } else {
  538.                     axis_0 = 1;
  539.                     axis_1 = 2;
  540.                 }
  541.                 v0i1 = pFace->v[0].v[axis_0];
  542.                 v0i2 = pFace->v[0].v[axis_1];
  543.                 u1 = pFace->v[1].v[axis_0] - v0i1;
  544.                 v1 = pFace->v[1].v[axis_1] - v0i2;
  545.                 u2 = pFace->v[2].v[axis_0] - v0i1;
  546.                 v2 = pFace->v[2].v[axis_1] - v0i2;
  547.                 i = 0;
  548.                 while (1) {
  549.                     if (i >= pNum_rays) {
  550.                         return;
  551.                     }
  552.                     if (t[i] != 100.0) {
  553.                         u0[i] = p[i].v[axis_0] - v0i1;
  554.                         v0[i] = p[i].v[axis_1] - v0i2;
  555.                         if (fabs(u1) <= 0.0000002384185791015625) {
  556.                             alpha = u0[i] / u2;
  557.                             beta = v0[i] - alpha * v2;
  558.                             f_d = beta / v1;
  559.                             goto LABEL_43;
  560.                         }
  561.                         f_numerator = v0[i] * u1 - u0[i] * v1;
  562.                         f_n = v2 * u1 - v1 * u2;
  563.                         if (f_n != 0) {
  564.                             alpha = f_numerator / f_n;
  565.                             beta = u0[i] - alpha * u2;
  566.                             f_d = beta / u1;
  567.                         LABEL_43:
  568.                             if (f_d >= -0.0001 && alpha >= -0.0001 && alpha + f_d <= 1.0001) {
  569.                                 rt[i] = t[i];
  570.                                 *normal = pFace->normal;
  571.                                 if (d > 0.0) {
  572.                                     normal->v[0] = -pFace->normal.v[0];
  573.                                     normal->v[1] = -pFace->normal.v[1];
  574.                                     normal->v[2] = -pFace->normal.v[2];
  575.                                 }
  576.                             }
  577.                         }
  578.                     }
  579.                     ++i;
  580.                     continue;
  581.                 }
  582.             }
  583.             tv.v[0] = ray_pos[i].v[0] - pFace->v[0].v[0];
  584.             tv.v[1] = ray_pos[i].v[1] - pFace->v[0].v[1];
  585.             tv.v[2] = ray_pos[i].v[2] - pFace->v[0].v[2];
  586.             numerator = pFace->normal.v[2] * tv.v[2] + pFace->normal.v[1] * tv.v[1] + pFace->normal.v[0] * tv.v[0];
  587.             if (BadDiv__finteray(numerator, d)) {
  588.                 return;
  589.             }
  590.             if (d > 0.0) {
  591.                 if (-numerator < -0.001 || -numerator > d + 0.003) {
  592.                     t[i] = 100.0;
  593.                     continue;
  594.                 }
  595.             } else if (numerator < -0.001 || 0.003 - d < numerator) {
  596.                 t[i] = 100.0;
  597.                 continue;
  598.             }
  599.             t[i] = -(numerator / d);
  600.             if (t[i] > 1.0) {
  601.                 t[i] = 1.0;
  602.             }
  603.             p[i].v[0] = t[i] * ray_dir->v[0];
  604.             p[i].v[1] = t[i] * ray_dir->v[1];
  605.             p[i].v[2] = t[i] * ray_dir->v[2];
  606.             p[i].v[0] = ray_pos[i].v[0] + p[i].v[0];
  607.             p[i].v[1] = ray_pos[i].v[1] + p[i].v[1];
  608.             p[i].v[2] = ray_pos[i].v[2] + p[i].v[2];
  609.         }
  610.     }
  611. }
  612.  
  613. // IDA: void __usercall GetNewBoundingBox(br_bounds *b2@<EAX>, br_bounds *b1@<EDX>, br_matrix34 *m@<EBX>)
  614. void GetNewBoundingBox(br_bounds* b2, br_bounds* b1, br_matrix34* m) {
  615.     br_vector3 a;
  616.     br_vector3 c[3];
  617.     int j;
  618.     LOG_TRACE("(%p, %p, %p)", b2, b1, m);
  619.  
  620.     BrMatrix34ApplyP(&b2->min, &b1->min, m);
  621.     BrVector3Copy(&b2->max, &b2->min);
  622.     BrVector3Sub(&a, &b1->max, &b1->min);
  623.     for (j = 0; j < 3; j++) {
  624.         BrVector3Scale(&c[j], (br_vector3*)m->m[j], a.v[j]);
  625.     }
  626.     for (j = 0; j < 3; ++j) {
  627.         b2->min.v[j] = (float)(c[2].v[j] < 0.f) * c[2].v[j]
  628.             + (float)(c[1].v[j] < 0.f) * c[1].v[j]
  629.             + (float)(c[0].v[j] < 0.f) * c[0].v[j]
  630.             + b2->min.v[j];
  631.         b2->max.v[j] = (float)(c[0].v[j] > 0.f) * c[0].v[j]
  632.             + (float)(c[2].v[j] > 0.f) * c[2].v[j]
  633.             + (float)(c[1].v[j] > 0.f) * c[1].v[j]
  634.             + b2->max.v[j];
  635.     }
  636. }
  637.  
  638. // IDA: int __usercall FindFacesInBox@<EAX>(tBounds *bnds@<EAX>, tFace_ref *face_list@<EDX>, int max_face@<EBX>)
  639. int FindFacesInBox(tBounds* bnds, tFace_ref* face_list, int max_face) {
  640.     br_vector3 a;
  641.     br_vector3 b;
  642.     br_vector3 c[3];
  643.     int i;
  644.     int j;
  645.     int x;
  646.     int z;
  647.     tU8 cx_min;
  648.     tU8 cx_max;
  649.     tU8 cz_min;
  650.     tU8 cz_max;
  651.     tTrack_spec* track_spec;
  652.     LOG_TRACE("(%p, %p, %d)", bnds, face_list, max_face);
  653.  
  654.     j = 0;
  655.     track_spec = &gProgram_state.track_spec;
  656.     BrVector3Add(&a, &bnds->original_bounds.min, &bnds->original_bounds.max);
  657.     BrVector3Scale(&a, &a, 0.5f);
  658.     BrMatrix34ApplyP(&bnds->box_centre, &a, bnds->mat);
  659.     BrVector3Sub(&b, &bnds->original_bounds.max, &bnds->original_bounds.min);
  660.     bnds->radius = BrVector3Length(&b) / 2.f;
  661.     BrMatrix34ApplyP(&bnds->real_bounds.min, &bnds->original_bounds.min, bnds->mat);
  662.     BrVector3Copy(&bnds->real_bounds.max, &bnds->real_bounds.min);
  663.     for (i = 0; i < 3; ++i) {
  664.         c[i].v[0] = bnds->mat->m[i][0] * b.v[i];
  665.         c[i].v[1] = bnds->mat->m[i][1] * b.v[i];
  666.         c[i].v[2] = bnds->mat->m[i][2] * b.v[i];
  667.     }
  668.     for (i = 0; i < 3; ++i) {
  669.         bnds->real_bounds.min.v[i] += MIN(c[0].v[i], 0.f)
  670.             + MIN(c[1].v[i], 0.f)
  671.             + MIN(c[2].v[i], 0.f);
  672.         bnds->real_bounds.max.v[i] += MAX(c[0].v[i], 0.f)
  673.             + MAX(c[1].v[i], 0.f)
  674.             + MAX(c[2].v[i], 0.f);
  675.     }
  676.     XZToColumnXZ(&cx_min, &cz_min, bnds->real_bounds.min.v[0], bnds->real_bounds.min.v[2], track_spec);
  677.     XZToColumnXZ(&cx_max, &cz_max, bnds->real_bounds.max.v[0], bnds->real_bounds.max.v[2], track_spec);
  678.     if (cx_min != 0) {
  679.         cx_min--;
  680.     }
  681.     if (cz_min != 0) {
  682.         cz_min--;
  683.     }
  684.     if (cx_max + 1 < track_spec->ncolumns_x) {
  685.         cx_max++;
  686.     }
  687.     if (cz_max + 1 < track_spec->ncolumns_z) {
  688.         cz_max++;
  689.     }
  690.     for (x = cx_min; x <= cx_max; x++) {
  691.         for (z = cz_min; z <= cz_max; z++) {
  692.             if (track_spec->columns[z][x] != NULL) {
  693.                 if (track_spec->blends[z][x] != NULL) {
  694.                     track_spec->blends[z][x]->render_style = BR_RSTYLE_FACES;
  695.                 }
  696.                 j = max_face - ActorBoxPick(bnds, track_spec->columns[z][x], model_unk1, material_unk1, &face_list[j], max_face - j, NULL);
  697.                 if (track_spec->blends[z][x] != NULL) {
  698.                     track_spec->blends[z][x]->render_style = BR_RSTYLE_NONE;
  699.                 }
  700.             }
  701.             if (track_spec->lollipops[z][x] != NULL) {
  702.                 j = max_face - ActorBoxPick(bnds, track_spec->lollipops[z][x], model_unk1, material_unk1, &face_list[j], max_face - j, NULL);
  703.             }
  704.         }
  705.     }
  706.     return j;
  707. }
  708.  
  709. // IDA: int __usercall FindFacesInBox2@<EAX>(tBounds *bnds@<EAX>, tFace_ref *face_list@<EDX>, int max_face@<EBX>)
  710. int FindFacesInBox2(tBounds* bnds, tFace_ref* face_list, int max_face) {
  711.     //br_vector3 a; // Pierre-Marie Baty -- unused variable
  712.     //br_vector3 b; // Pierre-Marie Baty -- unused variable
  713.     //br_vector3 c[3]; // Pierre-Marie Baty -- unused variable
  714.     //int i; // Pierre-Marie Baty -- unused variable
  715.     //int j; // Pierre-Marie Baty -- unused variable
  716.     LOG_TRACE("(%p, %p, %d)", bnds, face_list, max_face);
  717.     NOT_IMPLEMENTED();
  718. }
  719.  
  720. // IDA: int __usercall ActorBoxPick@<EAX>(tBounds *bnds@<EAX>, br_actor *ap@<EDX>, br_model *model@<EBX>, br_material *material@<ECX>, tFace_ref *face_list, int max_face, br_matrix34 *pMat)
  721. int ActorBoxPick(tBounds* bnds, br_actor* ap, br_model* model, br_material* material, tFace_ref* face_list, int max_face, br_matrix34* pMat) {
  722.     br_model* this_model;
  723.     br_material* this_material;
  724.     int i;
  725.     int n;
  726.     int test_children;
  727.     br_actor* a;
  728.     br_actor* next_a;
  729.     br_matrix34 mat;
  730.     br_matrix34 mat2;
  731.     br_matrix34 invmat;
  732.     br_matrix34 box_to_actor;
  733.     tBounds new_bounds;
  734.     br_bounds br_bnds;
  735.     LOG_TRACE("(%p, %p, %p, %p, %p, %d, %p)", bnds, ap, model, material, face_list, max_face, pMat);
  736.  
  737.     i = 0;
  738.     test_children = 1;
  739.     if (ap->model != NULL) {
  740.         this_model = ap->model;
  741.     } else {
  742.         this_model = model;
  743.     }
  744.     if (ap->material != NULL) {
  745.         this_material = ap->material;
  746.     } else {
  747.         this_material = material;
  748.     }
  749.     if (ap->render_style == BR_RSTYLE_NONE) {
  750.         return max_face;
  751.     }
  752.     if (ap->identifier != NULL && ap->identifier[0] == '&') {
  753.         if (ap->children == NULL) {
  754.             if (ap->type != BR_ACTOR_MODEL) {
  755.                 return max_face;
  756.             }
  757.             if (!BoundsTransformTest(&this_model->bounds, &bnds->real_bounds, &ap->t.t.mat)) {
  758.                 return max_face;
  759.             }
  760.         }
  761.         if (pMat != NULL) {
  762.             BrMatrix34Mul(&mat, &ap->t.t.mat, pMat);
  763.             pMat = &mat;
  764.         } else {
  765.             pMat = &ap->t.t.mat;
  766.         }
  767.         BrMatrix34LPInverse(&invmat, &ap->t.t.mat);
  768.         BrMatrix34Mul(&mat2, bnds->mat, &invmat);
  769.         new_bounds.mat = &mat2;
  770.         BrVector3Copy(&new_bounds.original_bounds.min, &bnds->original_bounds.min);
  771.         BrVector3Copy(&new_bounds.original_bounds.max, &bnds->original_bounds.max);
  772.         BrMatrix34ApplyP(&new_bounds.box_centre, &bnds->box_centre, &invmat);
  773.         new_bounds.radius = bnds->radius;
  774.         GetNewBoundingBox(&new_bounds.real_bounds, &new_bounds.original_bounds, new_bounds.mat);
  775.         if (ap->identifier[1] >= '0' && ap->identifier[1] <= '9') {
  776.             if (!BoundsOverlapTest__finteray(&new_bounds.real_bounds, &this_model->bounds)) {
  777.                 return max_face;
  778.             }
  779.             BrMatrix34LPInverse(&invmat, bnds->mat);
  780.             BrMatrix34Mul(&box_to_actor, &ap->t.t.mat, &invmat);
  781.             GetNewBoundingBox(&br_bnds, &ap->model->bounds, &box_to_actor);
  782.             if (!BoundsOverlapTest__finteray(&br_bnds, &bnds->original_bounds)) {
  783.                 return max_face;
  784.             }
  785.             if (PullActorFromWorld(ap)) {
  786.                 return max_face;
  787.             }
  788.         }
  789.         bnds = &new_bounds;
  790.     }
  791.     if (ap->type == BR_ACTOR_MODEL) {
  792.         if (BoundsOverlapTest__finteray(&bnds->real_bounds, &this_model->bounds)) {
  793.             n = ModelPickBox(ap, bnds, this_model, this_material, &face_list[i], max_face, pMat);
  794.             if (pMat && max_face != n) {
  795.                 StopGroovidelic(ap);
  796.             }
  797.             i += max_face - n;
  798.             max_face = n;
  799.         }
  800.     } else if (ap->type == BR_ACTOR_BOUNDS || ap->type == BR_ACTOR_BOUNDS_CORRECT) {
  801.         test_children = BoundsOverlapTest__finteray(&bnds->real_bounds, (br_bounds*)ap->type_data);
  802.     }
  803.     if (test_children) {
  804.         for (a = ap->children; a != NULL; a = next_a) {
  805.             next_a = a->next;
  806.             n = ActorBoxPick(bnds, a, this_model, this_material, &face_list[i], max_face, pMat);
  807.             i += max_face - n;
  808.             max_face = n;
  809.         }
  810.     }
  811.     return max_face;
  812. }
  813.  
  814. // IDA: int __usercall ModelPickBox@<EAX>(br_actor *actor@<EAX>, tBounds *bnds@<EDX>, br_model *model@<EBX>, br_material *model_material@<ECX>, tFace_ref *face_list, int max_face, br_matrix34 *pMat)
  815. int ModelPickBox(br_actor* actor, tBounds* bnds, br_model* model, br_material* model_material, tFace_ref* face_list, int max_face, br_matrix34* pMat) {
  816.     int f;
  817.     int i;
  818.     int n;
  819.     int group;
  820.     DR_FACE* fp;
  821.     int v1;
  822.     int v2;
  823.     int v3;
  824.     br_vector3 polygon[12];
  825.     br_vector3 a;
  826.     br_vector3 tv;
  827.     br_scalar t;
  828.     v11model* prepared;
  829.     LOG_TRACE("(%p, %p, %p, %p, %p, %d, %p)", actor, bnds, model, model_material, face_list, max_face, pMat);
  830.  
  831.     prepared = model->prepared;
  832.     if (max_face <= 0) {
  833.         return 0;
  834.     }
  835.     for (group = 0; prepared->ngroups > group; group++) {
  836.         for (f = 0; f < prepared->groups[group].nfaces; f++) {
  837.             fp = &prepared->groups[group].faces[f];
  838.             v1 = fp->vertices[0];
  839.             BrVector3Sub(&a, &prepared->groups[group].vertices[v1].p, &bnds->box_centre);
  840.             t = BrVector3Dot((br_vector3*)&fp->eqn, &a);
  841.             if (fabsf(t) > bnds->radius) {
  842.                 continue;
  843.             }
  844.             v2 = fp->vertices[1];
  845.             v3 = fp->vertices[2];
  846.  
  847.             t = bnds->real_bounds.min.v[0];
  848.             if (t > prepared->groups[group].vertices[v1].p.v[0]
  849.                 && t > prepared->groups[group].vertices[v2].p.v[0]
  850.                 && t > prepared->groups[group].vertices[v3].p.v[0]) {
  851.                 continue;
  852.             }
  853.             t = bnds->real_bounds.max.v[0];
  854.             if (t < prepared->groups[group].vertices[v1].p.v[0]
  855.                 && t < prepared->groups[group].vertices[v2].p.v[0]
  856.                 && t < prepared->groups[group].vertices[v3].p.v[0]) {
  857.                 continue;
  858.             }
  859.             t = bnds->real_bounds.min.v[1];
  860.             if (t > prepared->groups[group].vertices[v1].p.v[1]
  861.                 && t > prepared->groups[group].vertices[v2].p.v[1]
  862.                 && t > prepared->groups[group].vertices[v3].p.v[1]) {
  863.                 continue;
  864.             }
  865.             t = bnds->real_bounds.max.v[1];
  866.             if (t < prepared->groups[group].vertices[v1].p.v[1]
  867.                 && t < prepared->groups[group].vertices[v2].p.v[1]
  868.                 && t < prepared->groups[group].vertices[v3].p.v[1]) {
  869.                 continue;
  870.             }
  871.             t = bnds->real_bounds.min.v[2];
  872.             if (t > prepared->groups[group].vertices[v1].p.v[2]
  873.                 && t > prepared->groups[group].vertices[v2].p.v[2]
  874.                 && t > prepared->groups[group].vertices[v3].p.v[2]) {
  875.                 continue;
  876.             }
  877.             t = bnds->real_bounds.max.v[2];
  878.             if (t < prepared->groups[group].vertices[v1].p.v[2]
  879.                 && t < prepared->groups[group].vertices[v2].p.v[2]
  880.                 && t < prepared->groups[group].vertices[v3].p.v[2]) {
  881.                 continue;
  882.             }
  883.             BrVector3Sub(&polygon[1], &prepared->groups[group].vertices[v1].p, (br_vector3*)bnds->mat->m[3]);
  884.             BrVector3Sub(&polygon[2], &prepared->groups[group].vertices[v2].p, (br_vector3*)bnds->mat->m[3]);
  885.             BrVector3Sub(&polygon[3], &prepared->groups[group].vertices[v3].p, (br_vector3*)bnds->mat->m[3]);
  886.             BrMatrix34TApplyV(&polygon[0], &polygon[1], bnds->mat);
  887.             BrMatrix34TApplyV(&polygon[1], &polygon[2], bnds->mat);
  888.             BrMatrix34TApplyV(&polygon[2], &polygon[3], bnds->mat);
  889.             n = 3;
  890.             for (i = 0; i < 3; i++) {
  891.                 ClipToPlaneGE(&polygon[0], &n, i, bnds->original_bounds.min.v[i]);
  892.                 if (n < 3) {
  893.                     break;
  894.                 }
  895.                 ClipToPlaneLE(&polygon[0], &n, i, bnds->original_bounds.max.v[i]);
  896.                 if (n < 3) {
  897.                     break;
  898.                 }
  899.             }
  900.             if (n >= 3) {
  901.                 if (pMat != NULL) {
  902.                     BrMatrix34ApplyP(&face_list->v[0], &prepared->groups[group].vertices[v1].p, pMat);
  903.                     BrMatrix34ApplyP(&face_list->v[1], &prepared->groups[group].vertices[v2].p, pMat);
  904.                     BrMatrix34ApplyP(&face_list->v[2], &prepared->groups[group].vertices[v3].p, pMat);
  905.                     BrVector3Copy(&tv, (br_vector3*)&fp->eqn);
  906.                     BrMatrix34ApplyV(&face_list->normal, &tv, pMat);
  907.                 } else {
  908.                     BrVector3Copy(&face_list->v[0], &prepared->groups[group].vertices[v1].p);
  909.                     BrVector3Copy(&face_list->v[1], &prepared->groups[group].vertices[v2].p);
  910.                     BrVector3Copy(&face_list->v[2], &prepared->groups[group].vertices[v3].p);
  911.                     BrVector3Copy(&face_list->normal, (br_vector3*)&fp->eqn);
  912.                 }
  913.                 if (prepared->groups[group].face_colours_material != NULL) {
  914.                     face_list->material = prepared->groups[group].face_colours_material;
  915.                 } else {
  916.                     face_list->material = model_material;
  917.                 }
  918.                 face_list->flags = 0;
  919.                 if (face_list->material != NULL && (face_list->material->flags & (BR_MATF_TWO_SIDED | BR_MATF_ALWAYS_VISIBLE)) == 0) {
  920.                     face_list->flags |= (v1 < v2) | (v2 < v3) << 1 | (v3 < v1) << 2;
  921.                 }
  922.                 if (pMat != NULL) {
  923.                     face_list->d = BrVector3LengthSquared(&face_list->v[0]);
  924.                 } else {
  925.                     face_list->d = fp->eqn.v[3];
  926.                 }
  927.                 face_list->map[0] = &prepared->groups[group].vertices[v1].map;
  928.                 face_list->map[1] = &prepared->groups[group].vertices[v2].map;
  929.                 face_list->map[2] = &prepared->groups[group].vertices[v3].map;
  930.                 if (face_list->material!= NULL
  931.                     && face_list->material->identifier != NULL
  932.                     && face_list->material->identifier[0] == '!') {
  933.                     gPling_face = face_list;
  934.                 }
  935.                 face_list++;
  936.                 max_face--;
  937.                 if (max_face == 0) {
  938.                     break;
  939.                 }
  940.             }
  941.         }
  942.         if (max_face == 0) {
  943.             break;
  944.         }
  945.     }
  946.     return max_face;
  947. }
  948.  
  949. // IDA: void __usercall ClipToPlaneGE(br_vector3 *p@<EAX>, int *nv@<EDX>, int i@<EBX>, br_scalar limit)
  950. void ClipToPlaneGE(br_vector3* p, int* nv, int i, br_scalar limit) {
  951.     int last_vertex;
  952.     int j;
  953.     int vertex;
  954.     int k;
  955.     br_vector3 p2[12];
  956.     LOG_TRACE("(%p, %p, %d, %f)", p, nv, i, limit);
  957.  
  958.     last_vertex = *nv - 1;
  959.     j = 0;
  960.     for (vertex = 0; *nv > vertex; ++vertex) {
  961.         if ((p[last_vertex].v[i] > limit) != (p[vertex].v[i] > limit)) {
  962.             for (k = 0; k < 3; ++k) {
  963.                 if (i != k) {
  964.                     p2[j].v[k] = (p[vertex].v[k] - p[last_vertex].v[k])
  965.                             * (limit - p[last_vertex].v[i])
  966.                             / (p[vertex].v[i] - p[last_vertex].v[i])
  967.                         + p[last_vertex].v[k];
  968.                 }
  969.             }
  970.             p2[j++].v[i] = limit;
  971.         }
  972.         if (p[vertex].v[i] >= limit) {
  973.             BrVector3Copy(&p2[j], &p[vertex]);
  974.             j++;
  975.         }
  976.         last_vertex = vertex;
  977.     }
  978.     *nv = j;
  979.     for (k = 0; k < j; k++) {
  980.         BrVector3Copy(&p[k], &p2[k]);
  981.     }
  982. }
  983.  
  984. // IDA: void __usercall ClipToPlaneLE(br_vector3 *p@<EAX>, int *nv@<EDX>, int i@<EBX>, br_scalar limit)
  985. void ClipToPlaneLE(br_vector3* p, int* nv, int i, br_scalar limit) {
  986.     int last_vertex;
  987.     int j;
  988.     int vertex;
  989.     int k;
  990.     br_vector3 p2[12];
  991.     LOG_TRACE("(%p, %p, %d, %f)", p, nv, i, limit);
  992.  
  993.     last_vertex = *nv - 1;
  994.     j = 0;
  995.     for (vertex = 0; *nv > vertex; ++vertex) {
  996.         if ((p[vertex].v[i] > limit) != (p[last_vertex].v[i] > limit)) {
  997.             for (k = 0; k < 3; ++k) {
  998.                 if (k != i) {
  999.                     p2[j].v[k] = (p[vertex].v[k] - p[last_vertex].v[k])
  1000.                             * (limit - p[last_vertex].v[i])
  1001.                             / (p[vertex].v[i] - p[last_vertex].v[i])
  1002.                         + p[last_vertex].v[k];
  1003.                 }
  1004.             }
  1005.             p2[j++].v[i] = limit;
  1006.         }
  1007.         if (p[vertex].v[i] <= (double)limit) {
  1008.             BrVector3Copy(&p2[j], &p[vertex]);
  1009.             j++;
  1010.         }
  1011.         last_vertex = vertex;
  1012.     }
  1013.     *nv = j;
  1014.     for (k = 0; k < j; k++) {
  1015.         BrVector3Copy(&p[k], &p2[k]);
  1016.     }
  1017. }
  1018.  
  1019. // IDA: int __usercall BoundsOverlapTest@<EAX>(br_bounds *b1@<EAX>, br_bounds *b2@<EDX>)
  1020. // Suffix added to avoid duplicate symbol
  1021. int BoundsOverlapTest__finteray(br_bounds* b1, br_bounds* b2) {
  1022.     LOG_TRACE("(%p, %p)", b1, b2);
  1023.  
  1024.     return b1->min.v[0] <= b2->max.v[0]
  1025.         && b2->min.v[0] <= b1->max.v[0]
  1026.         && b1->min.v[1] <= b2->max.v[1]
  1027.         && b2->min.v[1] <= b1->max.v[1]
  1028.         && b1->min.v[2] <= b2->max.v[2]
  1029.         && b2->min.v[2] <= b1->max.v[2];
  1030. }
  1031.  
  1032. // IDA: int __usercall BoundsTransformTest@<EAX>(br_bounds *b1@<EAX>, br_bounds *b2@<EDX>, br_matrix34 *M@<EBX>)
  1033. int BoundsTransformTest(br_bounds* b1, br_bounds* b2, br_matrix34* M) {
  1034.     br_scalar val;
  1035.     br_vector3 o;
  1036.     LOG_TRACE("(%p, %p, %p)", b1, b2, M);
  1037.  
  1038.     BrVector3Sub(&o, &b1->max, &b1->min);
  1039.     val = M->m[0][0] * b1->min.v[0] + M->m[1][0] * b1->min.v[1] + M->m[2][0] * b1->min.v[2] + M->m[3][0];
  1040.  
  1041.     if ((M->m[0][0] <= 0.0f ? 0.0f : M->m[0][0] * o.v[0])
  1042.             + (M->m[1][0] <= 0.0f ? 0.0f : M->m[1][0] * o.v[1])
  1043.             + (M->m[2][0] <= 0.0f ? 0.0f : M->m[2][0] * o.v[2])
  1044.             + val
  1045.         < b2->min.v[0]) {
  1046.         return 0;
  1047.     }
  1048.     if ((M->m[0][0] < 0.0f ? M->m[0][0] * o.v[0] : 0.0f)
  1049.             + (M->m[1][0] < 0.0f ? M->m[1][0] * o.v[1] : 0.0f)
  1050.             + (M->m[2][0] < 0.0f ? M->m[2][0] * o.v[2] : 0.0f)
  1051.             + val
  1052.         > b2->max.v[0]) {
  1053.         return 0;
  1054.     }
  1055.  
  1056.     val = M->m[0][2] * b1->min.v[0] + M->m[1][2] * b1->min.v[1] + M->m[2][2] * b1->min.v[2] + M->m[3][2];
  1057.     if ((M->m[0][2] <= 0.0f ? 0.0f : M->m[0][2] * o.v[0])
  1058.             + (M->m[1][2] <= 0.0f ? 0.0f : M->m[1][2] * o.v[1])
  1059.             + (M->m[2][2] <= 0.0f ? 0.0f : M->m[2][2] * o.v[2])
  1060.             + val
  1061.         < b2->min.v[2]) {
  1062.         return 0;
  1063.     }
  1064.     if ((M->m[0][2] < 0.0f ? M->m[0][2] * o.v[0] : 0.0f)
  1065.             + (M->m[1][2] < 0.0f ? M->m[1][2] * o.v[1] : 0.0f)
  1066.             + (M->m[2][2] < 0.0f ? M->m[2][2] * o.v[2] : 0.0f)
  1067.             + val
  1068.         > b2->max.v[2]) {
  1069.         return 0;
  1070.     }
  1071.  
  1072.     val = M->m[0][1] * b1->min.v[0] + M->m[1][1] * b1->min.v[1] + M->m[2][1] * b1->min.v[2] + M->m[3][1];
  1073.     if ((M->m[0][1] <= 0.0f ? 0.0f : M->m[0][1] * o.v[0])
  1074.             + (M->m[1][1] <= 0.0f ? 0.0f : M->m[1][1] * o.v[1])
  1075.             + (M->m[2][1] <= 0.0f ? 0.0f : M->m[2][1] * o.v[2])
  1076.             + val
  1077.         < b2->min.v[1]) {
  1078.         return 0;
  1079.     }
  1080.     if ((M->m[0][1] < 0.0 ? M->m[0][1] * o.v[0] : 0.0)
  1081.             + (M->m[1][1] < 0.0 ? M->m[1][1] * o.v[1] : 0.0)
  1082.             + (M->m[2][1] < 0.0 ? M->m[2][1] * o.v[2] : 0.0)
  1083.             + val
  1084.         > b2->max.v[1]) {
  1085.         return 0;
  1086.     }
  1087.  
  1088.     return 1;
  1089. }
  1090.  
  1091. // IDA: int __usercall LineBoxColl@<EAX>(br_vector3 *o@<EAX>, br_vector3 *p@<EDX>, br_bounds *pB@<EBX>, br_vector3 *pHit_point@<ECX>)
  1092. int LineBoxColl(br_vector3* o, br_vector3* p, br_bounds* pB, br_vector3* pHit_point) {
  1093.     br_vector3 dir;
  1094.     int inside;
  1095.     int quad[3];
  1096.     int i;
  1097.     int which_plane;
  1098.     br_scalar max_t[3];
  1099.     br_scalar cp[3];
  1100.     LOG_TRACE("(%p, %p, %p, %p)", o, p, pB, pHit_point);
  1101.  
  1102.     inside = 1;
  1103.     BrVector3Sub(&dir, p, o);
  1104.     for (i = 0; i < 3; ++i) {
  1105.         if (pB->min.v[i] <= o->v[i]) {
  1106.             if (pB->max.v[i] >= o->v[i]) {
  1107.                 quad[i] = 2;
  1108.             } else {
  1109.                 quad[i] = 0;
  1110.                 max_t[i] = pB->max.v[i];
  1111.                 inside = 0;
  1112.             }
  1113.         } else {
  1114.             quad[i] = 1;
  1115.             max_t[i] = pB->min.v[i];
  1116.             inside = 0;
  1117.         }
  1118.     }
  1119.     if (inside) {
  1120.         BrVector3Copy(pHit_point, o);
  1121.         return 8;
  1122.     } else {
  1123.         for (i = 0; i < 3; ++i) {
  1124.             if (quad[i] == 2 || dir.v[i] == 0.0) {
  1125.                 cp[i] = -1.0;
  1126.             } else {
  1127.                 cp[i] = (max_t[i] - o->v[i]) / dir.v[i];
  1128.             }
  1129.         }
  1130.         which_plane = 0;
  1131.         for (i = 1; i < 3; ++i) {
  1132.             if (cp[which_plane] < cp[i]) {
  1133.                 which_plane = i;
  1134.             }
  1135.         }
  1136.         if (cp[which_plane] >= 0.0 && cp[which_plane] <= 1.0) {
  1137.             for (i = 0; i < 3; ++i) {
  1138.                 if (which_plane == i) {
  1139.                     pHit_point->v[i] = max_t[i];
  1140.                 } else {
  1141.                     pHit_point->v[i] = dir.v[i] * cp[which_plane] + o->v[i];
  1142.                     if (pHit_point->v[i] < pB->min.v[i] || pB->max.v[i] < pHit_point->v[i]) {
  1143.                         return 0;
  1144.                     }
  1145.                 }
  1146.             }
  1147.             return which_plane + 4 * quad[which_plane] + 1;
  1148.         } else {
  1149.             return 0;
  1150.         }
  1151.     }
  1152. }
  1153.  
  1154. // IDA: int __usercall SphereBoxIntersection@<EAX>(br_bounds *pB@<EAX>, br_vector3 *pC@<EDX>, br_scalar pR_squared, br_vector3 *pHit_point)
  1155. int SphereBoxIntersection(br_bounds* pB, br_vector3* pC, br_scalar pR_squared, br_vector3* pHit_point) {
  1156.     int i;
  1157.     br_scalar d;
  1158.     LOG_TRACE("(%p, %p, %f, %p)", pB, pC, pR_squared, pHit_point);
  1159.  
  1160.     d = 0.f;
  1161.     for (i = 0; i < 3; i++) {
  1162.         if (pC->v[i] <= pB->min.v[i]) {
  1163.             pHit_point->v[i] = pB->min.v[i];
  1164.         } else if (pC->v[i] > pB->max.v[i]) {
  1165.             pHit_point->v[i] = pB->max.v[i];
  1166.         } else {
  1167.             pHit_point->v[i] = pC->v[i];
  1168.         }
  1169.         d += (pC->v[i] - pHit_point->v[i]) * (pC->v[i] - pHit_point->v[i]);
  1170.     }
  1171.     return d <= pR_squared;
  1172. }
  1173.  
  1174. // IDA: int __usercall LineBoxCollWithSphere@<EAX>(br_vector3 *o@<EAX>, br_vector3 *p@<EDX>, br_bounds *pB@<EBX>, br_vector3 *pHit_point@<ECX>)
  1175. int LineBoxCollWithSphere(br_vector3* o, br_vector3* p, br_bounds* pB, br_vector3* pHit_point) {
  1176.     int i;
  1177.     int plane;
  1178.     LOG_TRACE("(%p, %p, %p, %p)", o, p, pB, pHit_point);
  1179.  
  1180.     plane = LineBoxColl(o, p, pB, pHit_point);
  1181.  
  1182.     if (plane != 0) {
  1183.         return plane;
  1184.     }
  1185.     if (!SphereBoxIntersection(pB, p, 2.5e-5f, pHit_point)) {
  1186.         return 0;
  1187.     }
  1188.     for (i = 0; i < 3; i++) {
  1189.         if (pB->max.v[i] == pHit_point->v[i] && p->v[i] <= o->v[i]) {
  1190.             return i + 1;
  1191.         }
  1192.         if (pHit_point->v[i] == pB->min.v[i] && p->v[i] >= o->v[i]) {
  1193.             return i + 5;
  1194.         }
  1195.     }
  1196.     return 0;
  1197. }
  1198.  
  1199. // IDA: int __usercall CompVert@<EAX>(int v1@<EAX>, int v2@<EDX>)
  1200. int CompVert(int v1, int v2) {
  1201.     //br_vertex* vl; // Pierre-Marie Baty -- unused variable
  1202.     //br_vector3 tv; // Pierre-Marie Baty -- unused variable
  1203.     //br_vector2 tv2; // Pierre-Marie Baty -- unused variable
  1204.     LOG_TRACE("(%d, %d)", v1, v2);
  1205.     NOT_IMPLEMENTED();
  1206. }
  1207.  
  1208. // IDA: void __usercall SetFacesGroup(int pFace@<EAX>)
  1209. void SetFacesGroup(int pFace) {
  1210.     //int f; // Pierre-Marie Baty -- unused variable
  1211.     //int v; // Pierre-Marie Baty -- unused variable
  1212.     //int i; // Pierre-Marie Baty -- unused variable
  1213.     LOG_TRACE("(%d)", pFace);
  1214.     NOT_IMPLEMENTED();
  1215. }
  1216.  
  1217. // IDA: void __usercall SelectFace(br_vector3 *pDir@<EAX>)
  1218. void SelectFace(br_vector3* pDir) {
  1219.     //tCar_spec* c; // Pierre-Marie Baty -- unused variable
  1220.     //br_vector3 dir; // Pierre-Marie Baty -- unused variable
  1221.     //br_vector3 normal; // Pierre-Marie Baty -- unused variable
  1222.     //br_scalar t; // Pierre-Marie Baty -- unused variable
  1223.     //br_model* old_model; // Pierre-Marie Baty -- unused variable
  1224.     //int i; // Pierre-Marie Baty -- unused variable
  1225.     LOG_TRACE("(%p)", pDir);
  1226.     NOT_IMPLEMENTED();
  1227. }
  1228.  
  1229. // IDA: void __usercall GetTilingLimits(br_vector2 *min@<EAX>, br_vector2 *max@<EDX>)
  1230. void GetTilingLimits(br_vector2* min, br_vector2* max) {
  1231.     //int f; // Pierre-Marie Baty -- unused variable
  1232.     //int i; // Pierre-Marie Baty -- unused variable
  1233.     //int j; // Pierre-Marie Baty -- unused variable
  1234.     //br_vertex* verts; // Pierre-Marie Baty -- unused variable
  1235.     //br_face* faces; // Pierre-Marie Baty -- unused variable
  1236.     LOG_TRACE("(%p, %p)", min, max);
  1237.     NOT_IMPLEMENTED();
  1238. }
  1239.  
  1240. // IDA: void __usercall Scale(int pD@<EAX>, int factor@<EDX>)
  1241. void Scale(int pD, int factor) {
  1242.     //br_vector2 min; // Pierre-Marie Baty -- unused variable
  1243.     //br_vector2 max; // Pierre-Marie Baty -- unused variable
  1244.     //int f; // Pierre-Marie Baty -- unused variable
  1245.     //int v; // Pierre-Marie Baty -- unused variable
  1246.     //br_scalar d; // Pierre-Marie Baty -- unused variable
  1247.     //br_vertex* verts; // Pierre-Marie Baty -- unused variable
  1248.     //br_face* faces; // Pierre-Marie Baty -- unused variable
  1249.     LOG_TRACE("(%d, %d)", pD, factor);
  1250.     NOT_IMPLEMENTED();
  1251. }
  1252.  
  1253. // IDA: void __cdecl ScaleUpX()
  1254. void ScaleUpX(void) {
  1255.     LOG_TRACE("()");
  1256.     NOT_IMPLEMENTED();
  1257. }
  1258.  
  1259. // IDA: void __cdecl ScaleDnX()
  1260. void ScaleDnX(void) {
  1261.     LOG_TRACE("()");
  1262.     NOT_IMPLEMENTED();
  1263. }
  1264.  
  1265. // IDA: void __cdecl ScaleUpY()
  1266. void ScaleUpY(void) {
  1267.     LOG_TRACE("()");
  1268.     NOT_IMPLEMENTED();
  1269. }
  1270.  
  1271. // IDA: void __cdecl ScaleDnY()
  1272. void ScaleDnY(void) {
  1273.     LOG_TRACE("()");
  1274.     NOT_IMPLEMENTED();
  1275. }
  1276.  
  1277. // IDA: void __cdecl SelectFaceForward()
  1278. void SelectFaceForward(void) {
  1279.     //br_vector3 dir; // Pierre-Marie Baty -- unused variable
  1280.     LOG_TRACE("()");
  1281.     NOT_IMPLEMENTED();
  1282. }
  1283.  
  1284. // IDA: void __cdecl SelectFaceDown()
  1285. void SelectFaceDown(void) {
  1286.     //br_vector3 dir; // Pierre-Marie Baty -- unused variable
  1287.     LOG_TRACE("()");
  1288.     NOT_IMPLEMENTED();
  1289. }
  1290.