WebSVN – Games.Carmageddon – Diff – /src/DETHRACE/common/finteray.c

 #include "finteray.h"
-#include "brender/brender.h"
+#include "brender.h"
 #include "brucetrk.h"
 #include "car.h"
+#include "formats.h"
 #include "globvars.h"
 #include "harness/trace.h"
 #include "raycast.h"
 #include "world.h"
 #include <math.h>
+}
 // 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)
 //  Suffix added to avoid duplicate symbol
 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) {
-    DR_FACE* fp;
+    // DR_FACE* fp;
     int f;
     int axis_m;
     int axis_0;
     int axis_1;
     br_scalar t;
-    //br_scalar n; // Pierre-Marie Baty -- unused variable
+    br_scalar n;
     br_scalar d;
     br_vector3 p;
     float u0;
     float u1;
     float u2;
     int v;
     int e;
     int r;
     br_material* this_material;
     br_scalar numerator;
-    //float f_numerator; // Pierre-Marie Baty -- unused variable
+    float f_numerator;
     int group;
     LOG_TRACE("(%p, %p, %p, %p, %f, %f, %p, %p)", model, material, ray_pos, ray_dir, t_near, t_far, callback, arg);
+    struct v11group* grp_ptr;
+    br_vector4* eqn;
     t_near -= 0.00001f;
     t_far += 0.00001f;
     for (group = 0; group < V11MODEL(model)->ngroups; group++) {
+        grp_ptr = &V11MODEL(model)->groups[group];
         for (f = 0; f < V11MODEL(model)->groups[group].nfaces; f++) {
-            fp = &V11MODEL(model)->groups[group].faces[f];
+            eqn = &V11MODEL(model)->groups[group].eqn[f];
-            if (V11MODEL(model)->groups[group].face_colours_material) {
+            if (V11MODEL(model)->groups[group].user) {
-                this_material = V11MODEL(model)->groups[group].face_colours_material;
+                this_material = V11MODEL(model)->groups[group].user;
             } else {
                 this_material = material;
+            }
-            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];
+            d = BrVector3Dot(eqn, ray_dir);
             if (fabs(d) >= 0.00000023841858 && (!this_material || !this_material->identifier || *this_material->identifier != '!' || !gPling_materials)
                 && (!this_material || (this_material->flags & 0x1800) != 0 || d <= 0.0)) {
-                numerator = fp->eqn.v[1] * ray_pos->v[1]
+                numerator = eqn->v[1] * ray_pos->v[1]
-                    + fp->eqn.v[2] * ray_pos->v[2]
+                    + eqn->v[2] * ray_pos->v[2]
-                    + fp->eqn.v[0] * ray_pos->v[0]
+                    + eqn->v[0] * ray_pos->v[0]
-                    - fp->eqn.v[3];
+                    - eqn->v[3];
                 if (!BadDiv__finteray(numerator, d)) {
                     t = -(numerator / d);
                     if (t >= t_near && t <= t_far) {
                         BrVector3Scale(&p, ray_dir, t);
                         BrVector3Accumulate(&p, ray_pos);
-                        axis_m = fabsf(fp->eqn.v[0]) < fabsf(fp->eqn.v[1]);
+                        axis_m = fabsf(eqn->v[0]) < fabsf(eqn->v[1]);
-                        if (fabsf(fp->eqn.v[2]) > fabsf(fp->eqn.v[axis_m])) {
+                        if (fabsf(eqn->v[2]) > fabsf(eqn->v[axis_m])) {
                             axis_m = 2;
+                        }
                         if (axis_m) {
                             axis_0 = 0;
                             if (axis_m == 1) {
                         } else {
                             axis_0 = 1;
                             axis_1 = 2;
+                        }
-                        v0 = V11MODEL(model)->groups[group].vertices[fp->vertices[0]].p.v[axis_0];
+                        v0 = grp_ptr->position[grp_ptr->vertex_numbers[f].v[0]].v[axis_0];
-                        u0 = V11MODEL(model)->groups[group].vertices[fp->vertices[0]].p.v[axis_1];
+                        u0 = grp_ptr->position[grp_ptr->vertex_numbers[f].v[0]].v[axis_1];
-                        v1 = V11MODEL(model)->groups[group].vertices[fp->vertices[1]].p.v[axis_0] - v0;
+                        v1 = grp_ptr->position[grp_ptr->vertex_numbers[f].v[1]].v[axis_0] - v0;
-                        u1 = V11MODEL(model)->groups[group].vertices[fp->vertices[1]].p.v[axis_1] - u0;
+                        u1 = grp_ptr->position[grp_ptr->vertex_numbers[f].v[1]].v[axis_1] - u0;
-                        v2 = V11MODEL(model)->groups[group].vertices[fp->vertices[2]].p.v[axis_0] - v0;
+                        v2 = grp_ptr->position[grp_ptr->vertex_numbers[f].v[2]].v[axis_0] - v0;
-                        u2 = V11MODEL(model)->groups[group].vertices[fp->vertices[2]].p.v[axis_1] - u0;
+                        u2 = grp_ptr->position[grp_ptr->vertex_numbers[f].v[2]].v[axis_1] - u0;
                         v0i1 = p.v[axis_0] - v0;
                         v0i2 = p.v[axis_1] - u0;
                         if (fabs(v1) > 0.0000002384185791015625) {
                             f_n = u2 * v1 - u1 * v2;
+                        }
                         if (alpha >= 0.0 && beta + alpha <= 1.0) {
                             s_alpha = alpha;
                             s_beta = beta;
-                            map.v[0] = V11MODEL(model)->groups[group].vertices[fp->vertices[1]].map.v[0] * s_alpha;
-                            map.v[1] = V11MODEL(model)->groups[group].vertices[fp->vertices[1]].map.v[1] * s_alpha;
+                            BrVector2Scale(&map, &grp_ptr->map[grp_ptr->vertex_numbers[f].v[1]], s_alpha);
                             DRVector2AccumulateScale__finteray(
                                 &map,
-                                &V11MODEL(model)->groups[group].vertices[fp->vertices[2]].map,
+                                &grp_ptr->map[grp_ptr->vertex_numbers[f].v[2]],
                                 s_beta);
                             DRVector2AccumulateScale__finteray(
                                 &map,
-                                &V11MODEL(model)->groups[group].vertices[fp->vertices[0]].map,
+                                &grp_ptr->map[grp_ptr->vertex_numbers[f].v[0]],
 .0 - (s_alpha + s_beta));
                             v = 0;
                             e = 1;
                             if (s_alpha <= s_beta) {
                                 if (0.5 - s_beta / 2.0 > s_alpha) {
 // IDA: void __usercall FindFace(br_vector3 *pPosition@<EAX>, br_vector3 *pDir@<EDX>, br_vector3 *nor@<EBX>, br_scalar *t@<ECX>, br_material **material)
 void FindFace(br_vector3* pPosition, br_vector3* pDir, br_vector3* nor, br_scalar* t, br_material** material) {
     int group;
     LOG_TRACE("(%p, %p, %p, %p, %p)", pPosition, pDir, nor, t, material);
+    br_vector4* eqn;
     gNearest_T = 100.0f;
     DRSceneRayPick2D(gTrack_actor, pPosition, pDir, FindHighestCallBack__finteray);
     *t = gNearest_T;
     if (*t < 100.0f) {
         group = gNearest_face_group;
-        nor->v[0] = V11MODEL(gNearest_model)->groups[group].faces[gNearest_face].eqn.v[0];
+        eqn = &V11MODEL(gNearest_model)->groups[group].eqn[gNearest_face];
+        nor->v[0] = eqn->v[0];
-        nor->v[1] = V11MODEL(gNearest_model)->groups[group].faces[gNearest_face].eqn.v[1];
+        nor->v[1] = eqn->v[1];
-        nor->v[2] = V11MODEL(gNearest_model)->groups[group].faces[gNearest_face].eqn.v[2];
+        nor->v[2] = eqn->v[2];
-        *material = V11MODEL(gNearest_model)->groups[group].face_colours_material;
+        *material = V11MODEL(gNearest_model)->groups[group].user;
+    }
+}
 // IDA: void __cdecl EnablePlingMaterials()
 void EnablePlingMaterials(void) {
     this_material = pFace->material;
     *rt = 100.0;
     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];
-    if ((this_material == NULL || (this_material->flags & (BR_MATF_TWO_SIDED | BR_MATF_ALWAYS_VISIBLE )) != 0 || d <= 0.0)
+    if ((this_material == NULL || (this_material->flags & (BR_MATF_TWO_SIDED | BR_MATF_ALWAYS_VISIBLE)) != 0 || d <= 0.0)
         && (!this_material || !this_material->identifier || *this_material->identifier != '!' || !gPling_materials)
         && fabs(d) >= 0.00000023841858) {
         BrVector3Sub(&p, ray_pos, &pFace->v[0]);
         numerator = BrVector3Dot(&pFace->normal, &p);
         if (!BadDiv__finteray(numerator, d)) {
     return j;
+}
 // IDA: int __usercall FindFacesInBox2@<EAX>(tBounds *bnds@<EAX>, tFace_ref *face_list@<EDX>, int max_face@<EBX>)
 int FindFacesInBox2(tBounds* bnds, tFace_ref* face_list, int max_face) {
-    //br_vector3 a; // Pierre-Marie Baty -- unused variable
+    br_vector3 a;
-    //br_vector3 b; // Pierre-Marie Baty -- unused variable
+    br_vector3 b;
-    //br_vector3 c[3]; // Pierre-Marie Baty -- unused variable
+    br_vector3 c[3];
-    //int i; // Pierre-Marie Baty -- unused variable
+    int i;
-    //int j; // Pierre-Marie Baty -- unused variable
+    int j;
     LOG_TRACE("(%p, %p, %d)", bnds, face_list, max_face);
+    a.v[0] = (bnds->original_bounds.min.v[0] + bnds->original_bounds.max.v[0]) * .5f;
+    a.v[1] = (bnds->original_bounds.min.v[1] + bnds->original_bounds.max.v[1]) * .5f;
+    a.v[2] = (bnds->original_bounds.min.v[2] + bnds->original_bounds.max.v[2]) * .5f;
+    BrMatrix34ApplyP(&bnds->box_centre, &a, bnds->mat);
+    BrVector3Sub(&b, &bnds->original_bounds.max, &bnds->original_bounds.min);
+    bnds->radius = BrVector3Length(&b) / 2.f;
+    BrMatrix34ApplyP(&bnds->real_bounds.min, &bnds->original_bounds.min, bnds->mat);
+    BrVector3Copy(&bnds->real_bounds.max, &bnds->real_bounds.min);
-    NOT_IMPLEMENTED();
+    for (i = 0; i < 3; i++) {
+        BrVector3Scale(&c[i], (br_vector3*)bnds->mat->m[i], b.v[i]);
+    }
+    for (i = 0; i < 3; i++) {
+      bnds->real_bounds.min.v[i] += MIN(0.f, c[0].v[i]) + MIN(0.f, c[1].v[i]) + MIN(0.f, c[2].v[i]);
+      bnds->real_bounds.max.v[i] += MAX(0.f, c[0].v[i]) + MAX(0.f, c[1].v[i]) + MAX(0.f, c[2].v[i]);
+  }
+  return max_face - ActorBoxPick(bnds, gTrack_actor, model_unk1, material_unk1, face_list, max_face, NULL);
+}
 // 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)
 int ActorBoxPick(tBounds* bnds, br_actor* ap, br_model* model, br_material* material, tFace_ref* face_list, int max_face, br_matrix34* pMat) {
     br_model* this_model;
 int ModelPickBox(br_actor* actor, tBounds* bnds, br_model* model, br_material* model_material, tFace_ref* face_list, int max_face, br_matrix34* pMat) {
     int f;
     int i;
     int n;
     int group;
-    DR_FACE* fp;
+    // DR_FACE* fp;
     int v1;
     int v2;
     int v3;
     br_vector3 polygon[12];
     br_vector3 a;
     br_vector3 tv;
     br_scalar t;
-    v11model* prepared;
+    struct v11model* prepared;
     LOG_TRACE("(%p, %p, %p, %p, %p, %d, %p)", actor, bnds, model, model_material, face_list, max_face, pMat);
+    struct v11group* grp_ptr;
     prepared = model->prepared;
     if (max_face <= 0) {
         return 0;
+    }
     for (group = 0; prepared->ngroups > group; group++) {
+        grp_ptr = &prepared->groups[group];
         for (f = 0; f < prepared->groups[group].nfaces; f++) {
-            fp = &prepared->groups[group].faces[f];
+            // fp = &prepared->groups[group].faces[f];
-            v1 = fp->vertices[0];
+            v1 = grp_ptr->vertex_numbers[f].v[0]; // fp->vertices[0];
-            BrVector3Sub(&a, &prepared->groups[group].vertices[v1].p, &bnds->box_centre);
+            // BrVector3Sub(&a, &prepared->groups[group].vertices[v1].p, &bnds->box_centre);
+            BrVector3Sub(&a, &grp_ptr->position[v1], &bnds->box_centre);
-            t = BrVector3Dot((br_vector3*)&fp->eqn, &a);
+            // t = BrVector3Dot((br_vector3*)&fp->eqn, &a);
+            t = BrVector3Dot((br_vector3*)&grp_ptr->eqn[f], &a);
             if (fabsf(t) > bnds->radius) {
                 continue;
+            }
-            v2 = fp->vertices[1];
+            // v2 = fp->vertices[1];
-            v3 = fp->vertices[2];
+            // v3 = fp->vertices[2];
+            v2 = grp_ptr->vertex_numbers[f].v[1];
+            v3 = grp_ptr->vertex_numbers[f].v[2];
             t = bnds->real_bounds.min.v[0];
-            if (t > prepared->groups[group].vertices[v1].p.v[0]
+            if (t > grp_ptr->position[v1].v[0]
-                && t > prepared->groups[group].vertices[v2].p.v[0]
+                && t > grp_ptr->position[v2].v[0]
-                && t > prepared->groups[group].vertices[v3].p.v[0]) {
+                && t > grp_ptr->position[v3].v[0]) {
                 continue;
+            }
             t = bnds->real_bounds.max.v[0];
-            if (t < prepared->groups[group].vertices[v1].p.v[0]
+            if (t < grp_ptr->position[v1].v[0]
-                && t < prepared->groups[group].vertices[v2].p.v[0]
+                && t < grp_ptr->position[v2].v[0]
-                && t < prepared->groups[group].vertices[v3].p.v[0]) {
+                && t < grp_ptr->position[v3].v[0]) {
                 continue;
+            }
             t = bnds->real_bounds.min.v[1];
-            if (t > prepared->groups[group].vertices[v1].p.v[1]
+            if (t > grp_ptr->position[v1].v[1]
-                && t > prepared->groups[group].vertices[v2].p.v[1]
+                && t > grp_ptr->position[v2].v[1]
-                && t > prepared->groups[group].vertices[v3].p.v[1]) {
+                && t > grp_ptr->position[v3].v[1]) {
                 continue;
+            }
             t = bnds->real_bounds.max.v[1];
-            if (t < prepared->groups[group].vertices[v1].p.v[1]
+            if (t < grp_ptr->position[v1].v[1]
-                && t < prepared->groups[group].vertices[v2].p.v[1]
+                && t < grp_ptr->position[v2].v[1]
-                && t < prepared->groups[group].vertices[v3].p.v[1]) {
+                && t < grp_ptr->position[v3].v[1]) {
                 continue;
+            }
             t = bnds->real_bounds.min.v[2];
-            if (t > prepared->groups[group].vertices[v1].p.v[2]
+            if (t > grp_ptr->position[v1].v[2]
-                && t > prepared->groups[group].vertices[v2].p.v[2]
+                && t > grp_ptr->position[v2].v[2]
-                && t > prepared->groups[group].vertices[v3].p.v[2]) {
+                && t > grp_ptr->position[v3].v[2]) {
                 continue;
+            }
             t = bnds->real_bounds.max.v[2];
-            if (t < prepared->groups[group].vertices[v1].p.v[2]
+            if (t < grp_ptr->position[v1].v[2]
-                && t < prepared->groups[group].vertices[v2].p.v[2]
+                && t < grp_ptr->position[v2].v[2]
-                && t < prepared->groups[group].vertices[v3].p.v[2]) {
+                && t < grp_ptr->position[v3].v[2]) {
                 continue;
+            }
-            BrVector3Sub(&polygon[1], &prepared->groups[group].vertices[v1].p, (br_vector3*)bnds->mat->m[3]);
+            BrVector3Sub(&polygon[1], &grp_ptr->position[v1], (br_vector3*)bnds->mat->m[3]);
-            BrVector3Sub(&polygon[2], &prepared->groups[group].vertices[v2].p, (br_vector3*)bnds->mat->m[3]);
+            BrVector3Sub(&polygon[2], &grp_ptr->position[v2], (br_vector3*)bnds->mat->m[3]);
-            BrVector3Sub(&polygon[3], &prepared->groups[group].vertices[v3].p, (br_vector3*)bnds->mat->m[3]);
+            BrVector3Sub(&polygon[3], &grp_ptr->position[v3], (br_vector3*)bnds->mat->m[3]);
             BrMatrix34TApplyV(&polygon[0], &polygon[1], bnds->mat);
             BrMatrix34TApplyV(&polygon[1], &polygon[2], bnds->mat);
             BrMatrix34TApplyV(&polygon[2], &polygon[3], bnds->mat);
             n = 3;
             for (i = 0; i < 3; i++) {
                     break;
+                }
+            }
             if (n >= 3) {
                 if (pMat != NULL) {
-                    BrMatrix34ApplyP(&face_list->v[0], &prepared->groups[group].vertices[v1].p, pMat);
+                    BrMatrix34ApplyP(&face_list->v[0], &grp_ptr->position[v1], pMat);
-                    BrMatrix34ApplyP(&face_list->v[1], &prepared->groups[group].vertices[v2].p, pMat);
+                    BrMatrix34ApplyP(&face_list->v[1], &grp_ptr->position[v2], pMat);
-                    BrMatrix34ApplyP(&face_list->v[2], &prepared->groups[group].vertices[v3].p, pMat);
+                    BrMatrix34ApplyP(&face_list->v[2], &grp_ptr->position[v3], pMat);
-                    BrVector3Copy(&tv, (br_vector3*)&fp->eqn);
+                    BrVector3Copy(&tv, (br_vector3*)&grp_ptr->eqn[f]);
                     BrMatrix34ApplyV(&face_list->normal, &tv, pMat);
                 } else {
-                    BrVector3Copy(&face_list->v[0], &prepared->groups[group].vertices[v1].p);
+                    BrVector3Copy(&face_list->v[0], &grp_ptr->position[v1]);
-                    BrVector3Copy(&face_list->v[1], &prepared->groups[group].vertices[v2].p);
+                    BrVector3Copy(&face_list->v[1], &grp_ptr->position[v2]);
-                    BrVector3Copy(&face_list->v[2], &prepared->groups[group].vertices[v3].p);
+                    BrVector3Copy(&face_list->v[2], &grp_ptr->position[v3]);
-                    BrVector3Copy(&face_list->normal, (br_vector3*)&fp->eqn);
+                    BrVector3Copy(&face_list->normal, (br_vector3*)&grp_ptr->eqn[f]);
+                }
-                if (prepared->groups[group].face_colours_material != NULL) {
+                if (prepared->groups[group].user != NULL) {
-                    face_list->material = prepared->groups[group].face_colours_material;
+                    face_list->material = prepared->groups[group].user;
                 } else {
                     face_list->material = model_material;
+                }
                 face_list->flags = 0;
                 if (face_list->material != NULL && (face_list->material->flags & (BR_MATF_TWO_SIDED | BR_MATF_ALWAYS_VISIBLE)) == 0) {
                     face_list->flags |= (v1 < v2) | (v2 < v3) << 1 | (v3 < v1) << 2;
+                }
                 if (pMat != NULL) {
                     face_list->d = BrVector3LengthSquared(&face_list->v[0]);
                 } else {
-                    face_list->d = fp->eqn.v[3];
+                    face_list->d = grp_ptr->eqn[f].v[3];
+                }
-                face_list->map[0] = &prepared->groups[group].vertices[v1].map;
+                face_list->map[0] = &grp_ptr->map[v1];
-                face_list->map[1] = &prepared->groups[group].vertices[v2].map;
+                face_list->map[1] = &grp_ptr->map[v2];
-                face_list->map[2] = &prepared->groups[group].vertices[v3].map;
+                face_list->map[2] = &grp_ptr->map[v3];
-                if (face_list->material!= NULL
+                if (face_list->material != NULL
                     && face_list->material->identifier != NULL
                     && face_list->material->identifier[0] == '!') {
                     gPling_face = face_list;
+                }
                 face_list++;
     return 0;
+}
 // IDA: int __usercall CompVert@<EAX>(int v1@<EAX>, int v2@<EDX>)
 int CompVert(int v1, int v2) {
-    //br_vertex* vl; // Pierre-Marie Baty -- unused variable
+    br_vertex* vl;
-    //br_vector3 tv; // Pierre-Marie Baty -- unused variable
+    br_vector3 tv;
-    //br_vector2 tv2; // Pierre-Marie Baty -- unused variable
+    br_vector2 tv2;
     LOG_TRACE("(%d, %d)", v1, v2);
+    if (v1 == v2) {
-    NOT_IMPLEMENTED();
+        return 1;
+    }
+    vl = gSelected_model->vertices;
+    BrVector3Sub(&tv, &vl[v1].p, &vl[v2].p);
+    if (BrVector3LengthSquared(&tv) > 1e-5f) {
+        return 0;
+    }
+    BrVector2Sub(&tv2, &vl[v1].map, &vl[v2].map);
+    if (BrVector2LengthSquared(&tv2) > 1e-5f) {
+        return 0;
+    }
+    return 1;
+}
 // IDA: void __usercall SetFacesGroup(int pFace@<EAX>)
 void SetFacesGroup(int pFace) {
     //int f; // Pierre-Marie Baty -- unused variable
     NOT_IMPLEMENTED();
+}
 // IDA: void __usercall GetTilingLimits(br_vector2 *min@<EAX>, br_vector2 *max@<EDX>)
 void GetTilingLimits(br_vector2* min, br_vector2* max) {
-    //int f; // Pierre-Marie Baty -- unused variable
+    int f;
-    //int i; // Pierre-Marie Baty -- unused variable
+    int i;
-    //int j; // Pierre-Marie Baty -- unused variable
+    int j;
-    //br_vertex* verts; // Pierre-Marie Baty -- unused variable
+    br_vertex* verts;
-    //br_face* faces; // Pierre-Marie Baty -- unused variable
+    br_face* faces;
     LOG_TRACE("(%p, %p)", min, max);
+    verts = gSelected_model->vertices;
+    faces = gSelected_model->faces;
+    BrVector2Set(min, 32000.f, 32000.f);
+    BrVector2Set(max, -32000.f, -32000.f);
+    for (f = 0; f < gSelected_model->nfaces; f++) {
+        if (faces[f].material == gSub_material) {
+            for (i = 0; i < 3; i++) {
+                for (j = 0; j < 3; j++) {
+                    if (verts[faces[f].vertices[i]].map.v[j] < min->v[j]) {
+                        min->v[j] = verts[faces[f].vertices[i]].map.v[j];
-    NOT_IMPLEMENTED();
+                    }
+                    if (verts[faces[f].vertices[i]].map.v[j] > max->v[j]) {
+                        max->v[j] = verts[faces[f].vertices[i]].map.v[j];
+                    }
+                }
+            }
+        }
+    }
+}
 // IDA: void __usercall Scale(int pD@<EAX>, int factor@<EDX>)
 void Scale(int pD, int factor) {
-    //br_vector2 min; // Pierre-Marie Baty -- unused variable
+    br_vector2 min;
-    //br_vector2 max; // Pierre-Marie Baty -- unused variable
+    br_vector2 max;
-    //int f; // Pierre-Marie Baty -- unused variable
+    int f;
-    //int v; // Pierre-Marie Baty -- unused variable
+    int v;
-    //br_scalar d; // Pierre-Marie Baty -- unused variable
+    br_scalar d;
-    //br_vertex* verts; // Pierre-Marie Baty -- unused variable
+    br_vertex* verts;
-    //br_face* faces; // Pierre-Marie Baty -- unused variable
+    br_face* faces;
     LOG_TRACE("(%d, %d)", pD, factor);
+    if (gSelected_model == NULL) {
+        return;
+    }
+    if (gSelected_model->nfaces != gNfaces) {
+        return;
+    }
+    verts = gSelected_model->vertices;
+    faces = gSelected_model->faces;
+    GetTilingLimits(&min, &max);
+    d = max.v[pD] - min.v[pD];
+    if (d <= 0.f || factor + d <= 0.f) {
+        return;
+    }
+    for (v = 0; v < gSelected_model->nvertices; v++) {
+        for (f = 0; f < gSelected_model->nfaces; f++) {
+            if (faces[f].material == gSub_material
+                    && (faces[f].vertices[0] == v || faces[f].vertices[1] == v || faces[f].vertices[2] == v)) {
+                verts[v].map.v[pD] = (factor + d) / d * verts[v].map.v[pD];
-    NOT_IMPLEMENTED();
+                break;
+            }
+        }
+    }
+    BrModelUpdate(gSelected_model, BR_MODU_ALL);
+}
 // IDA: void __cdecl ScaleUpX()
 void ScaleUpX(void) {
     LOG_TRACE("()");
-    NOT_IMPLEMENTED();
+    Scale(0, 1);
+}
 // IDA: void __cdecl ScaleDnX()
 void ScaleDnX(void) {
     LOG_TRACE("()");
-    NOT_IMPLEMENTED();
+    Scale(0, -1);
+}
 // IDA: void __cdecl ScaleUpY()
 void ScaleUpY(void) {
     LOG_TRACE("()");
-    NOT_IMPLEMENTED();
+    Scale(1, 1);
+}
 // IDA: void __cdecl ScaleDnY()
 void ScaleDnY(void) {
     LOG_TRACE("()");
-    NOT_IMPLEMENTED();
+    Scale(1, -1);
+}
 // IDA: void __cdecl SelectFaceForward()
 void SelectFaceForward(void) {
-    //br_vector3 dir; // Pierre-Marie Baty -- unused variable
+    br_vector3 dir;
     LOG_TRACE("()");
+    BrVector3Scale(&dir, (br_vector3*)&gProgram_state.current_car.car_master_actor->t.t.mat.m[2], -2.f);
-    NOT_IMPLEMENTED();
+    SelectFace(&dir);
+}
 // IDA: void __cdecl SelectFaceDown()
 void SelectFaceDown(void) {
-    //br_vector3 dir; // Pierre-Marie Baty -- unused variable
+    br_vector3 dir;
     LOG_TRACE("()");
+    BrVector3Scale(&dir, (br_vector3*)&gProgram_state.current_car.car_master_actor->t.t.look_up.up, -2.f);
-    NOT_IMPLEMENTED();
+    SelectFace(&dir);
+}

Subversion Repositories Games.Carmageddon

Games.Carmageddon/src/DETHRACE/common/finteray.c – Rev 1 → 18