Pedestrian Proxy Ray not visible in OpenGL mode

[madebr]

In cheat mode, ALT+5 gives you the ray, and ALT+SHIFT+7 respawns all pedestrians

[madebr]

Using the patch below, the rays are visible but look wrong.

patch

diff --git a/src/DETHRACE/common/pedestrn.c b/src/DETHRACE/common/pedestrn.c
index 2695d928..417fcc1e 100644
--- a/src/DETHRACE/common/pedestrn.c
+++ b/src/DETHRACE/common/pedestrn.c
@@ -5,6 +5,7 @@
 #include "displays.h"
 #include "errors.h"
 #include "globvars.h"
+#include "globvrbm.h"
 #include "globvrkm.h"
 #include "globvrpb.h"
 #include "graphics.h"
@@ -3875,6 +3876,20 @@ void RenderProximityRays(br_pixelmap* pRender_screen, br_pixelmap* pDepth_buffer
     br_scalar distance;
     br_scalar t;
 
+#ifdef DETHRACE_3DFX_PATCH
+    if (gNo_2d_effects) {
+        BrActorRemove(gLine_actor);
+        BrActorAdd(gCamera, gLine_actor);
+        gLine_model->vertices[0].red = 0x80;
+        gLine_model->vertices[0].grn = 0x80;
+        gLine_model->vertices[0].blu = 0xff;
+        gLine_model->vertices[1].red = 0xff;
+        gLine_model->vertices[1].grn = 0xff;
+        gLine_model->vertices[1].blu = 0xff;
+        BrModelUpdate(gLine_model, BR_MODU_ALL);
+    }
+#endif
+
     the_time = GetTotalTime();
     StartPipingSession(ePipe_chunk_prox_ray);
     for (i = 0; i < COUNT_OF(gProximity_rays); i++) {
@@ -3923,6 +3938,12 @@ void RenderProximityRays(br_pixelmap* pRender_screen, br_pixelmap* pDepth_buffer
         }
     }
     EndPipingSession();
+#ifdef DETHRACE_3DFX_PATCH
+    if (gNo_2d_effects) {
+        BrActorRemove(gLine_actor);
+        BrActorAdd(gDont_render_actor, gLine_actor);
+    }
+#endif
 }
 
 // IDA: void __usercall AdjustProxRay(int pRay_index@<EAX>, tU16 pCar_ID@<EDX>, tU16 pPed_index@<EBX>, tU32 pTime@<ECX>)

[Squall-Leonhart]

your patch renders a single line actor but only as a 1-pixel-wide line.

The original code achieves this by calling DrawLine3D many times with random offsets in a loop.
To replicate this in 3D mode, you need to render multiple line actors (or a ribbon/quad strip) per ray segment, each slightly offset, to simulate the thickness.

diff --git a/src/DETHRACE/common/pedestrn.c b/src/DETHRACE/common/pedestrn.c
index 2695d928..417fcc1e 100644
--- a/src/DETHRACE/common/pedestrn.c
+++ b/src/DETHRACE/common/pedestrn.c
@@ -5,6 +5,7 @@
 #include "displays.h"
 #include "errors.h"
 #include "globvars.h"
+#include "globvrbm.h"
 #include "globvrkm.h"
 #include "globvrpb.h"
 #include "graphics.h"
@@ -3875,6 +3876,48 @@ void RenderProximityRays(br_pixelmap* pRender_screen, br_pixelmap* pDepth_buffer
     br_scalar distance;
     br_scalar t;
 
+#ifdef DETHRACE_3DFX_PATCH
+#define PROX_RAY_MAX_SEGS   200
+#define PROX_RAY_MAX_VERTS  (PROX_RAY_MAX_SEGS * 4)
+#define PROX_RAY_MAX_FACES  (PROX_RAY_MAX_SEGS * 2)
+    static br_actor*    ray_bolt_actors[COUNT_OF(gProximity_rays)];
+    static br_model*    ray_bolt_models[COUNT_OF(gProximity_rays)];
+    static br_material* ray_bolt_mat;
+    static int ray_bolts_initialized = 0;
+    if (gNo_2d_effects && !ray_bolts_initialized) {
+        int _i, _f;
+        ray_bolt_mat = BrMaterialAllocate(NULL);
+        ray_bolt_mat->flags |= BR_MATF_PRELIT | BR_MATF_TWO_SIDED | BR_MATF_BLEND;
+        ray_bolt_mat->ka = BR_SCALAR(1.0);
+        BrMaterialAdd(ray_bolt_mat);
+        for (_i = 0; _i < COUNT_OF(gProximity_rays); _i++) {
+            ray_bolt_models[_i] = BrModelAllocate(NULL, PROX_RAY_MAX_VERTS, PROX_RAY_MAX_FACES);
+            ray_bolt_models[_i]->flags |= BR_MODF_UPDATEABLE | BR_MODF_DONT_WELD;
+            for (_f = 0; _f < PROX_RAY_MAX_FACES; _f += 2) {
+                int _v = (_f / 2) * 4;
+                ray_bolt_models[_i]->faces[_f].vertices[0]     = _v;
+                ray_bolt_models[_i]->faces[_f].vertices[1]     = _v + 1;
+                ray_bolt_models[_i]->faces[_f].vertices[2]     = _v + 2;
+                ray_bolt_models[_i]->faces[_f].smoothing       = 1;
+                ray_bolt_models[_i]->faces[_f + 1].vertices[0] = _v;
+                ray_bolt_models[_i]->faces[_f + 1].vertices[1] = _v + 2;
+                ray_bolt_models[_i]->faces[_f + 1].vertices[2] = _v + 3;
+                ray_bolt_models[_i]->faces[_f + 1].smoothing   = 1;
+            }
+            BrModelAdd(ray_bolt_models[_i]);
+            ray_bolt_actors[_i] = BrActorAllocate(BR_ACTOR_MODEL, NULL);
+            ray_bolt_actors[_i]->model    = ray_bolt_models[_i];
+            ray_bolt_actors[_i]->material = ray_bolt_mat;
+            ray_bolt_actors[_i]->render_style = BR_RSTYLE_NONE;
+            BrActorAdd(gDont_render_actor, ray_bolt_actors[_i]);
+        }
+        ray_bolts_initialized = 1;
+    }
+#endif
+
     the_time = GetTotalTime();
     StartPipingSession(ePipe_chunk_prox_ray);
     for (i = 0; i < COUNT_OF(gProximity_rays); i++) {
@@ -3907,6 +3950,60 @@ void RenderProximityRays(br_pixelmap* pRender_screen, br_pixelmap* pDepth_buffer
             srand(seed);
 
+#ifdef DETHRACE_3DFX_PATCH
+            if (gNo_2d_effects) {
+                br_model* _bolt = ray_bolt_models[i];
+                int _seg = 0;
+                br_vector3 _p0, _p1, _d, _perp, _ray;
+                br_scalar _dx, _dy, _len, _hw;
+                BrActorRemove(ray_bolt_actors[i]);
+                BrActorAdd(gCamera, ray_bolt_actors[i]);
+                _p0 = car_pos_cam;
+                t = 0.f;
+                do {
+                    BrVector3Scale(&_ray, &r1, t);
+                    BrVector3Add(&_p1, &_ray, &car_pos_cam);
+                    _p1.v[X] += SRandomPosNeg(0.1f);
+                    _p1.v[Y] += SRandomPosNeg(0.1f);
+                    _p1.v[Z] += SRandomPosNeg(0.1f);
+                    _dx = _p1.v[X] - _p0.v[X];
+                    _dy = _p1.v[Y] - _p0.v[Y];
+                    _len = BrSqrt(_dx * _dx + _dy * _dy);
+                    _hw = 0.03f;
+                    if (_len > 1e-6f) {
+                        _perp.v[X] = -_dy / _len * _hw;
+                        _perp.v[Y] =  _dx / _len * _hw;
+                    } else {
+                        _perp.v[X] = _hw;
+                        _perp.v[Y] = 0.f;
+                    }
+                    _perp.v[Z] = 0.f;
+                    int _v = _seg * 4;
+                    br_uint_8 _r = (br_uint_8)(0x60 + (br_uint_8)(0x9f * t / distance));
+                    br_uint_8 _g = (br_uint_8)(0x60 + (br_uint_8)(0x9f * t / distance));
+                    br_uint_8 _b = 0xff;
+                    _bolt->vertices[_v  ].p.v[X] = _p0.v[X] + _perp.v[X]; _bolt->vertices[_v  ].p.v[Y] = _p0.v[Y] + _perp.v[Y]; _bolt->vertices[_v  ].p.v[Z] = _p0.v[Z];
+                    _bolt->vertices[_v+1].p.v[X] = _p0.v[X] - _perp.v[X]; _bolt->vertices[_v+1].p.v[Y] = _p0.v[Y] - _perp.v[Y]; _bolt->vertices[_v+1].p.v[Z] = _p0.v[Z];
+                    _bolt->vertices[_v+2].p.v[X] = _p1.v[X] - _perp.v[X]; _bolt->vertices[_v+2].p.v[Y] = _p1.v[Y] - _perp.v[Y]; _bolt->vertices[_v+2].p.v[Z] = _p1.v[Z];
+                    _bolt->vertices[_v+3].p.v[X] = _p1.v[X] + _perp.v[X]; _bolt->vertices[_v+3].p.v[Y] = _p1.v[Y] + _perp.v[Y]; _bolt->vertices[_v+3].p.v[Z] = _p1.v[Z];
+                    _bolt->vertices[_v  ].red = _r; _bolt->vertices[_v  ].grn = _g; _bolt->vertices[_v  ].blu = _b;
+                    _bolt->vertices[_v+1].red = _r; _bolt->vertices[_v+1].grn = _g; _bolt->vertices[_v+1].blu = _b;
+                    _bolt->vertices[_v+2].red = _r; _bolt->vertices[_v+2].grn = _g; _bolt->vertices[_v+2].blu = _b;
+                    _bolt->vertices[_v+3].red = _r; _bolt->vertices[_v+3].grn = _g; _bolt->vertices[_v+3].blu = _b;
+                    _p0 = _p1;
+                    _seg++;
+                    t += 0.05f;
+                } while (t < distance && _seg < PROX_RAY_MAX_SEGS - 1);
+                _bolt->nvertices = _seg * 4;
+                _bolt->nfaces    = _seg * 2;
+                BrModelUpdate(_bolt, BR_MODU_ALL);
+                ray_bolt_actors[i]->render_style = BR_RSTYLE_FACES;
+            } else
+#endif
+            {
             t = 0.f;
             do {
                 BrVector3Scale(&ray, &r1, t);
@@ -3919,8 +4016,17 @@ void RenderProximityRays(br_pixelmap* pRender_screen, br_pixelmap* pDepth_buffer
                 t += 0.05f;
             } while (t < distance);
             DrawLine3D(&ped_pos_cam, &from_pos, pRender_screen, pDepth_buffer, gProx_ray_shade_table);
+            }
         } else {
             gProximity_rays[i].start_time = 0;
+#ifdef DETHRACE_3DFX_PATCH
+            if (gNo_2d_effects) {
+                ray_bolt_actors[i]->render_style = BR_RSTYLE_NONE;
+                BrActorRemove(ray_bolt_actors[i]);
+                BrActorAdd(gDont_render_actor, ray_bolt_actors[i]);
+            }
+#endif
         }
     }
     EndPipingSession();

[madebr]

The fps counter of softcube16, added in dethrace-labs/BRender-v1.3.2#31, is also not visible in opengl mode.

[Squall-Leonhart]

Digging into the whys of this further, there are several mistakes in the patch

Issues with the original patch:

1. gLine_model->vertices[2] colour never initialised. The gLine_actor triangle has face {0, 2, 1}, so v2's colour participates in Gouraud interpolation. The patch sets v0 and v1 then calls BrModelUpdate(BR_MODU_ALL), which transcribes whatever happens to be in vertices[2] at that moment into v11m->vertex_colours. RenderSparks runs immediately before RenderProximityRays in the frame and SetLineModelCols only touches v0/v1, so v2 carries the last spark's v1 colour — yellow for colour == 0 sparks. That yellow then tints the v1 end of every prox-ray triangle.

2. Wrong target colour. Patch uses (0x80, 0x80, 0xff) → (0xff, 0xff, 0xff) (pale blue → white). The software path uses gProx_ray_shade_table, generated as GenerateShadeTable(8, gRender_palette, 215, 255, 233, 0.5, 0.75, 0.9). The ref_col is (215, 255, 233) — pale near-white with a very faint green/cyan tint. Original DOSBox + 3dfx screenshots confirm this; the bolts are not blue.

3. The v0/v1 gradient is the wrong shape. Setting v0 different from v1 once at the top of the function means every segment carries the same gradient end-to-end, with a colour discontinuity at every segment boundary (v1 of segment N adjacent to v0 of segment N+1). The software's per-segment fade comes from the shade table walking row 0→7 within each segment independently, not a fade across the whole bolt. It's the wrong shape regardless of the colours chosen.

4. No alpha blending. DrawDot does *scr_ptr = shade_ptr[*scr_ptr], which is out = lerp(scene, ref_col, ratio2) — a screen blend. That's what GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA with src.rgb = ref_col does. Without BLEND_B + OPACITY_X on gLine_material (via extra_prim + BrMaterialUpdate(..., BR_MATU_EXTRA_PRIM)), bolts render opaque and lose the soft/hazy quality of the reference.

5. Sub-pixel triangle dropout. DrawLine3DThroughBRender puts v2 at pEnd + (0.001, 0.001, 0.001) in camera space — a fixed (1,1,1) diagonal offset that's well under one pixel at typical depths and collapses to zero area whenever a segment direction is near-parallel to (1,1,1). With random jitter some segments end up perpendicular and visible, others parallel and invisible. That's the dotted/sparkly look — segments aren't tinted wrong, they're missing. Routing prox rays through DrawLine3D inherits this. Fix is to drive gLine_model directly for the prox-ray path and put v2 perpendicular to the segment in the camera XY plane, scaled by depth.

its supposed to look more like this

which

diff --git a/src/DETHRACE/common/pedestrn.c b/src/DETHRACE/common/pedestrn.c
index 2695d928..417fcc1e 100644
--- a/src/DETHRACE/common/pedestrn.c
+++ b/src/DETHRACE/common/pedestrn.c
@@ -5,6 +5,7 @@
 #include "displays.h"
 #include "errors.h"
 #include "globvars.h"
+#include "globvrbm.h"
 #include "globvrkm.h"
 #include "globvrpb.h"
 #include "graphics.h"
@@ -3905,6 +3906,42 @@ void RecordPedsAndPowerups(void) {
     fclose(f);
 }
 
+#ifdef DETHRACE_3DFX_PATCH
+static br_token_value gProxRayBlendTokens[3] = {
+    { BRT_BLEND_B,   { .u32 = 1u } },
+    { BRT_OPACITY_X, { .x = 0x800000 } },
+    { 0 }
+};
+
+static void DrawProxRaySegmentBR(br_vector3* pStart, br_vector3* pEnd) {
+    br_vector3 dir, perp;
+    br_scalar  len, thickness;
+
+    gLine_model->vertices[0].p = *pStart;
+    gLine_model->vertices[1].p = *pEnd;
+
+    BrVector3Sub(&dir, pEnd, pStart);
+    perp.v[0] = dir.v[1];
+    perp.v[1] = -dir.v[0];
+    perp.v[2] = 0.f;
+    len = BrVector3Length(&perp);
+    if (len < 1e-6f) {
+        BrVector3Set(&perp, 1.f, 0.f, 0.f);
+        len = 1.f;
+    }
+    thickness = -pEnd->v[2] * 0.003f;
+    if (thickness < 0.01f) {
+        thickness = 0.01f;
+    }
+    BrVector3Scale(&perp, &perp, thickness / len);
+
+    gLine_model->vertices[2].p.v[0] = pEnd->v[0] + perp.v[0];
+    gLine_model->vertices[2].p.v[1] = pEnd->v[1] + perp.v[1];
+    gLine_model->vertices[2].p.v[2] = pEnd->v[2];
+
+    BrModelUpdate(gLine_model, BR_MODU_VERTEX_POSITIONS);
+    BrZbSceneRenderAdd(gLine_actor);
+}
+#endif
+
 // IDA: void __usercall RenderProximityRays(br_pixelmap *pRender_screen@<EAX>, br_pixelmap *pDepth_buffer@<EDX>, br_actor *pCamera@<EBX>, br_matrix34 *pCamera_to_world@<ECX>, tU32 pTime)
 // FUNCTION: CARM95 0x00460696
 void RenderProximityRays(br_pixelmap* pRender_screen, br_pixelmap* pDepth_buffer, br_actor* pCamera, br_matrix34* pCamera_to_world, tU32 pTime) {
@@ -3925,6 +3962,25 @@ void RenderProximityRays(br_pixelmap* pRender_screen, br_pixelmap* pDepth_buffer
     br_scalar distance;
     br_scalar t;
 
+#ifdef DETHRACE_3DFX_PATCH
+    if (gNo_2d_effects) {
+        BrActorRemove(gLine_actor);
+        BrActorAdd(gCamera, gLine_actor);
+        gLine_material->extra_prim = gProxRayBlendTokens;
+        BrMaterialUpdate(gLine_material, BR_MATU_EXTRA_PRIM);
+        gLine_model->vertices[0].red = 215;
+        gLine_model->vertices[0].grn = 255;
+        gLine_model->vertices[0].blu = 233;
+        gLine_model->vertices[1].red = 215;
+        gLine_model->vertices[1].grn = 255;
+        gLine_model->vertices[1].blu = 233;
+        gLine_model->vertices[2].red = 215;
+        gLine_model->vertices[2].grn = 255;
+        gLine_model->vertices[2].blu = 233;
+        BrModelUpdate(gLine_model, BR_MODU_ALL);
+    }
+#endif
+
     the_time = GetTotalTime();
     StartPipingSession(ePipe_chunk_prox_ray);
     for (i = 0; i < COUNT_OF(gProximity_rays); i++) {
@@ -3958,16 +4014,36 @@ void RenderProximityRays(br_pixelmap* pRender_screen, br_pixelmap* pDepth_buffer
                 to_pos.v[X] += SRandomPosNeg(0.1f);
                 to_pos.v[Y] += SRandomPosNeg(0.1f);
                 to_pos.v[Z] += SRandomPosNeg(0.1f);
-                DrawLine3D(&to_pos, &from_pos, pRender_screen, pDepth_buffer, gProx_ray_shade_table);
+#ifdef DETHRACE_3DFX_PATCH
+                if (gNo_2d_effects) {
+                    DrawProxRaySegmentBR(&to_pos, &from_pos);
+                } else
+#endif
+                {
+                    DrawLine3D(&to_pos, &from_pos, pRender_screen, pDepth_buffer, gProx_ray_shade_table);
+                }
                 from_pos = to_pos;
                 t += 0.05f;
             } while (t < distance);
-            DrawLine3D(&ped_pos_cam, &from_pos, pRender_screen, pDepth_buffer, gProx_ray_shade_table);
+#ifdef DETHRACE_3DFX_PATCH
+            if (gNo_2d_effects) {
+                DrawProxRaySegmentBR(&ped_pos_cam, &from_pos);
+            } else
+#endif
+            {
+                DrawLine3D(&ped_pos_cam, &from_pos, pRender_screen, pDepth_buffer, gProx_ray_shade_table);
+            }
         } else {
             gProximity_rays[i].start_time = 0;
         }
     }
     EndPipingSession();
+#ifdef DETHRACE_3DFX_PATCH
+    if (gNo_2d_effects) {
+        gLine_material->extra_prim = NULL;
+        BrMaterialUpdate(gLine_material, BR_MATU_EXTRA_PRIM);
+        BrActorRemove(gLine_actor);
+        BrActorAdd(gDont_render_actor, gLine_actor);
+    }
+#endif
 }
 
 // IDA: void __usercall AdjustProxRay(int pRay_index@<EAX>, tU16 pCar_ID@<EDX>, tU16 pPed_index@<EBX>, tU32 pTime@<ECX>)

try this

[MastaG]

Awesome!