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

 #include "spark.h"
-#include "brender/brender.h"
+#include "brender.h"
 #include "car.h"
+#include "crush.h"
 #include "depth.h"
+#include "displays.h"
 #include "errors.h"
+#include "formats.h"
 #include "globvars.h"
 #include "globvrkm.h"
 #include "graphics.h"
 #include "harness/hooks.h"
 #include "harness/trace.h"
 #include "piping.h"
 #include "replay.h"
 #include "trig.h"
 #include "utility.h"
 #include "world.h"
+#include <math.h>
 #include <stdlib.h>
 int gNext_spark;
 int gSpark_flags;
 int gNext_shrapnel;
+}
 // IDA: void __cdecl DustRotate()
 void DustRotate(void) {
     LOG_TRACE("()");
-    NOT_IMPLEMENTED();
+    gDust_rotate += 1;
+    if (gDust_rotate >= gNum_dust_tables) {
+        gDust_rotate = 0;
+    }
+    NewTextHeadupSlot(4, 0, 1000, -4, "Dust colour rotated");
+}
 // IDA: void __usercall RenderSmoke(br_pixelmap *pRender_screen@<EAX>, br_pixelmap *pDepth_buffer@<EDX>, br_actor *pCamera@<EBX>, br_matrix34 *pCamera_to_world@<ECX>, tU32 pTime)
 void RenderSmoke(br_pixelmap* pRender_screen, br_pixelmap* pDepth_buffer, br_actor* pCamera, br_matrix34* pCamera_to_world, tU32 pTime) {
     int i;
         gSmoke_column[i].upright = 0;
+    }
     actor = c->car_model_actors[c->principal_car_actor].actor;
     bonny = c->car_model_actors[c->car_actor_count - 1].actor;
-    BrVector3Add(pRet_car_pos, &V11MODEL(actor->model)->groups->vertices[gSmoke_column[i].vertex_index].p, &actor->t.t.translate.t);
+    BrVector3Add(pRet_car_pos, &V11MODEL(actor->model)->groups[0].position[gSmoke_column[i].vertex_index], &actor->t.t.translate.t);
     if (gProgram_state.cockpit_on && c->driver == eDriver_local_human) {
         if (c->driver_z_offset + 0.2f <= pRet_car_pos->v[2]) {
             pRet_car_pos->v[1] -= -0.07f;
         } else {
-            BrMatrix34ApplyP(pRet_car_pos, &V11MODEL(actor->model)->groups->vertices[gSmoke_column[i].vertex_index].p, &bonny->t.t.mat);
+            BrMatrix34ApplyP(pRet_car_pos, &V11MODEL(actor->model)->groups[0].position[gSmoke_column[i].vertex_index], &bonny->t.t.mat);
+        }
+    }
     if (!gSmoke_column[i].upright) {
         pRet_car_pos->v[1] = c->bounds[1].min.v[1] / WORLD_SCALE;
+    }
     model = actor->model;
     bonny = pCar->car_model_actors[pCar->car_actor_count - 1].actor;
     n = 0;
     real_vertex_number = 0;
     if ((model->flags & BR_MODF_KEEP_ORIGINAL) != 0 || (model->flags & BR_MODF_UPDATEABLE) != 0) {
-        point = V11MODEL(model)->groups[group].vertices[fire_point].p;
+        point = V11MODEL(model)->groups[group].position[fire_point];
         StartPipingSession(ePipe_chunk_smudge);
         for (group = 0; group < V11MODEL(model)->ngroups; group++) {
             for (j = 0; j < V11MODEL(model)->groups[group].nvertices; j++) {
-                BrVector3Sub(&tv, &V11MODEL(model)->groups[group].vertices[j].p, &point);
+                BrVector3Sub(&tv, &V11MODEL(model)->groups[group].position[j], &point);
                 ts = (.0144f - BrVector3LengthSquared(&tv) / SRandomBetween(.5f, 1.f)) / .0144f * 127.f;
                 if (ts > 0.f) {
                     ts += BR_ALPHA(V11MODEL(model)->groups[group].vertex_colours[j]);
                     if (ts > 255.f) {
                         ts = 255.f;
                 break;
+            }
+        }
         if (n > 0) {
             AddSmudgeToPipingSession(pCar->car_ID, pCar->principal_car_actor, n, data);
+            // FIXME?
             // Added by dethrace to update gpu-buffered vertices
-            model->flags |= BR_MODF_DETHRACE_FORCE_BUFFER_UPDATE;
+            // model->flags |= BR_MODF_DETHRACE_FORCE_BUFFER_UPDATE;
+        }
         n = 0;
         real_vertex_number = 0;
         if (actor != bonny) {
             BrVector3Accumulate(&tv, &bonny->t.t.translate.t);
             BrMatrix34TApplyV(&bonny_pos, &tv, &bonny->t.t.mat);
             for (group = 0; group < V11MODEL(b_model)->ngroups; group++) {
                 j = 0;
                 for (j = 0; j < V11MODEL(b_model)->groups[group].nvertices; j++) {
-                    BrVector3Sub(&tv, &V11MODEL(b_model)->groups[group].vertices[j].p, &bonny_pos);
+                    BrVector3Sub(&tv, &V11MODEL(b_model)->groups[group].position[j], &bonny_pos);
                     ts = (.0144f - BrVector3LengthSquared(&tv) / SRandomBetween(.5f, 1.f)) / .0144f * 127.f;
                     if (ts > 0.f) {
                         ts += BR_ALPHA(V11MODEL(b_model)->groups[group].vertex_colours[j]);
                         if (ts > 255.f) {
                             ts = 255.f;
                     break;
+                }
+            }
             if (n > 0) {
                 AddSmudgeToPipingSession(pCar->car_ID, pCar->car_actor_count - 1, n, data);
+                // FIXME?
                 // Added by dethrace to update gpu-buffered vertices
-                b_model->flags |= BR_MODF_DETHRACE_FORCE_BUFFER_UPDATE;
+                // b_model->flags |= BR_MODF_DETHRACE_FORCE_BUFFER_UPDATE;
+            }
+        }
         EndPipingSession();
+    }
+}
 // IDA: void __cdecl ResetSmokeColumns()
 void ResetSmokeColumns(void) {
-    //int i; // Pierre-Marie Baty -- unused variable
+    int i;
     LOG_TRACE("()");
+    for (i = 0; i < MAX_SMOKE_COLUMNS; i++) {
+        if (gColumn_flags & (1 << i)) {
+            BrActorRemove(gSmoke_column[i].flame_actor);
+        }
+    }
-    NOT_IMPLEMENTED();
+    gColumn_flags = 0;
+}
 // IDA: void __usercall SetSmokeOn(int pSmoke_on@<EAX>)
 void SetSmokeOn(int pSmoke_on) {
     LOG_TRACE("(%d)", pSmoke_on);
+}
 // IDA: void __usercall ReallySetSmokeOn(int pSmoke_on@<EAX>)
 void ReallySetSmokeOn(int pSmoke_on) {
     LOG_TRACE("(%d)", pSmoke_on);
+    ResetSmoke();
-    NOT_IMPLEMENTED();
+    ResetSmokeColumns();
+}
 // IDA: void __usercall SetSmoke(int pSmoke_on@<EAX>)
 void SetSmoke(int pSmoke_on) {
     LOG_TRACE("(%d)", pSmoke_on);
+    }
+}
 // IDA: void __cdecl DoTrueColModelThing(br_actor *actor, br_model *pModel, br_material *material, void *render_data, br_uint_8 style, int on_screen)
 void DoTrueColModelThing(br_actor* actor, br_model* pModel, br_material* material, void* render_data, br_uint_8 style, int on_screen) {
-    //int group; // Pierre-Marie Baty -- unused variable
+    int group;
-    //int j; // Pierre-Marie Baty -- unused variable
+    int j;
-    //int val; // Pierre-Marie Baty -- unused variable
+    int val;
     LOG_TRACE("(%p, %p, %p, %p, %d, %d)", actor, pModel, material, render_data, style, on_screen);
     NOT_IMPLEMENTED();
+}
 // IDA: void __cdecl DoModelThing(br_actor *actor, br_model *pModel, br_material *material, void *render_data, br_uint_8 style, int on_screen)
 void DoModelThing(br_actor* actor, br_model* pModel, br_material* material, void* render_data, br_uint_8 style, int on_screen) {
-    //int j; // Pierre-Marie Baty -- unused variable
+    int j;
-    //int i; // Pierre-Marie Baty -- unused variable
+    int i;
-    //int group; // Pierre-Marie Baty -- unused variable
+    int group;
-    //tU32 t; // Pierre-Marie Baty -- unused variable
+    tU32 t;
-    //int val; // Pierre-Marie Baty -- unused variable
+    int val;
     LOG_TRACE("(%p, %p, %p, %p, %d, %d)", actor, pModel, material, render_data, style, on_screen);
-    NOT_IMPLEMENTED();
+    GetRaceTime();
+    for (group = 0; group < V11MODEL(pModel)->ngroups; group++) {
+        for (j = 0; j < V11MODEL(pModel)->groups[group].nvertices; j++) {
+            if (!(((V11MODEL(pModel)->groups[group].vertex_colours[j]) >> 24) & 1)) {
+                if (((V11MODEL(pModel)->groups[group].vertex_colours[j]) >> 24) < 0xc9) {
+                    val = ((V11MODEL(pModel)->groups[group].vertex_colours[j]) >> 24) + 2 * IRandomBetween(5, 10);
+                    V11MODEL(pModel)->groups[group].vertex_colours[j] = BR_COLOUR_RGBA(0, 0, 0, val);
+                    if (pModel->flags & BR_MODF_UPDATEABLE) {
+                        pModel->vertices[V11MODEL(pModel)->groups[group].vertex_user[j]].index = val;
+                    }
+                } else {
+                    V11MODEL(pModel)->groups[group].vertex_colours[j] = BR_COLOUR_RGBA(0, 0, 0, 0xc9);
+                    if (pModel->flags & BR_MODF_UPDATEABLE) {
+                        pModel->vertices[V11MODEL(pModel)->groups[group].vertex_user[j]].index = 0xc9;
+                    }
+                }
+            } else if ((V11MODEL(pModel)->groups[group].vertex_colours[j] >> 24) < 20) {
+                V11MODEL(pModel)->groups[group].vertex_colours[j] = 0;
+                if (pModel->flags & BR_MODF_UPDATEABLE) {
+                    pModel->vertices[V11MODEL(pModel)->groups[group].vertex_user[j]].index = 0;
+                }
+            } else {
+                val = ((V11MODEL(pModel)->groups[group].vertex_colours[j] >> 24) - 2 * IRandomBetween(5, 10)) << 24;
+                V11MODEL(pModel)->groups[group].vertex_colours[j] = BR_COLOUR_RGBA(0, 0, 0, val);
+                if (pModel->flags & BR_MODF_UPDATEABLE) {
+                    pModel->vertices[V11MODEL(pModel)->groups[group].vertex_user[j]].index = val;
+                }
+            }
+        }
+    }
+    if ((pModel->flags & BR_MODF_UPDATEABLE) && pModel->user != NULL) {
+        BrModelUpdate(pModel, BR_MODU_VERTEX_POSITIONS);
+    }
+    pModel->user = NULL;
+    BrZbModelRender(actor, pModel, material, style, BrOnScreenCheck(&pModel->bounds), 0);
+}
 // IDA: void __usercall SetModelShade(br_actor *pActor@<EAX>, br_pixelmap *pShade@<EDX>)
 void SetModelShade(br_actor* pActor, br_pixelmap* pShade) {
     int i;
     br_actor* bonny;
     br_pixelmap* shade[6];
     static int shade_num = 0;
     //int i; // Pierre-Marie Baty -- unused variable
     LOG_TRACE("(%p)", pCar);
-    STUB();
-    return;
     shade[0] = gIt_shade_table;
     shade[1] = gFog_shade_table;
     shade[2] = gShade_list[0];
     shade[3] = gShade_list[1];
     shade[4] = gShade_list[2];
     shade[5] = NULL;
     actor = pCar->car_model_actors[pCar->principal_car_actor].actor;
     bonny = pCar->car_model_actors[pCar->car_actor_count - 1].actor;
-    if (((actor->model->flags & BR_MODF_CUSTOM) == 0) || actor->model->custom != DoTrueColModelThing) {
+    if (!(actor->model->flags & BR_MODF_CUSTOM) || actor->model->custom != DoModelThing) {
         SetModelShade(actor, shade[shade_num]);
-        actor->model->user = DoTrueColModelThing;
+        actor->model->user = DoModelThing;
-        actor->model->custom = DoTrueColModelThing;
+        actor->model->custom = DoModelThing;
         actor->model->flags |= BR_MODF_CUSTOM;
         if (bonny != actor) {
-            bonny->model->user = DoTrueColModelThing;
+            bonny->model->user = DoModelThing;
-            bonny->model->custom = DoTrueColModelThing;
+            bonny->model->custom = DoModelThing;
             bonny->model->flags |= BR_MODF_CUSTOM;
             SetModelShade(bonny, shade[shade_num]);
+        }
+    }
+}
 // IDA: void __usercall StopCarBeingIt(tCar_spec *pCar@<EAX>)
 void StopCarBeingIt(tCar_spec* pCar) {
-    //int i; // Pierre-Marie Baty -- unused variable
+    int i;
-    //int group; // Pierre-Marie Baty -- unused variable
+    int group;
-    //br_actor* actor; // Pierre-Marie Baty -- unused variable
+    br_actor* actor;
-    //br_actor* bonny; // Pierre-Marie Baty -- unused variable
+    br_actor* bonny;
     LOG_TRACE("(%p)", pCar);
+    actor = pCar->car_model_actors[pCar->principal_car_actor].actor;
+    bonny = pCar->car_model_actors[pCar->car_actor_count - 1].actor;
+    if (actor->model->custom == DoModelThing) {
+        actor->model->flags &= ~BR_MODF_CUSTOM;
+        SetModelShade(actor, gShade_list[0]);
+        for (group = 0; group < V11MODEL(actor->model)->ngroups; group++) {
+            for (i = 0; i < V11MODEL(actor->model)->groups[group].nvertices; i++) {
+                V11MODEL(actor->model)->groups[group].vertex_colours[i] = 0;
+                if (actor->model->flags & BR_MODF_UPDATEABLE) {
+                    actor->model->vertices[V11MODEL(actor->model)->groups[group].vertex_user[i]].index = 0;
+                }
+            }
-    STUB();
+        }
+        SetModelForUpdate(actor->model, pCar, 0);
+        if (bonny != actor) {
+            bonny->model->flags &= ~BR_MODF_CUSTOM;
+            SetModelShade(bonny, gShade_list[0]);
+            for (group = 0; group < V11MODEL(bonny->model)->ngroups; group++) {
+                for (i = 0; i < V11MODEL(bonny->model)->groups[group].nvertices; i++) {
+                    V11MODEL(bonny->model)->groups[group].vertex_colours[i] = 0;
+                    if (bonny->model->flags & BR_MODF_UPDATEABLE) {
+                        bonny->model->vertices[V11MODEL(bonny->model)->groups[group].vertex_user[i]].index = 0;
+                    }
+                }
+            }
+            SetModelForUpdate(bonny->model, pCar, 0);
+        }
+    }
+}

Subversion Repositories Games.Carmageddon

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