vwemirror/RP412
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

The map draws on every step of the rate wheel

Browse Source 
The renderer walks a sixteen-step rate wheel: one step per full pass over
the gauge list, shifted right each pass and reset at the bottom. A gauge
redraws only on the step its configured rate names, so the map - on one
step - waited a whole turn of the wheel however cheap its redraw was.

With the frame budget fixed the wheel turns about fifty times a second
and one-in-sixteen would be tolerable. It is still the wrong shape for
the map: the thing a pilot reads to navigate should not be the display
that updates least often, and RP412MAPRATE says how many of the sixteen
steps it draws on. Sixteen by default, one for the old data-driven
behaviour. Each extra step costs one gauge's redraw against a pass that
runs ninety of them, which measured as nothing.

The write has to be QUALIFIED, and that is worth recording because it
cost hours. GPS's constructor takes its rate as a parameter also called
'rate', which shadows the inherited Gauge::rate for the whole body - so a
bare assignment sets the parameter and leaves the member holding whatever
the gauge data asked for. oldRate is not shadowed, so it took the value,
and the pair then disagreed: rate=2000, old=ffff. That looked exactly
like something writing the member from outside, and there is no such
writer - Gauge touches rate in three places, none of which can produce
that pair. A hardware write-watch on the member settled it by reporting
an address on the STACK.

Also here, the terrain-arrival work on the map background. It draws one
placement into the cached picture when the static bounds are unchanged,
and rebuilds the whole thing only when they move - the bounds set the
scale, and the scale is what everything already on the picture was drawn
at. It is honest to say this fires rarely: the logs show terrain arriving
in one burst at mission load, not streaming in as you drive, so the
incremental path is mostly insurance. What it does close is real, though
- departures now order a rebuild. Nothing listened for those before, and
they had been swept up by the rebuild the next ARRIVAL ordered, which on
a track whose terrain all arrives at load is a rebuild that never comes.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Cyd
2026-08-09 13:13:03 -05:00
co-authored by Claude Opus 5
parent b7b2c3b148
commit 1dd40be0a3
3 changed files with 276 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
RP_L4/RPL4GAUG.cpp
+241 -45
View File
@@ -1,4 +1,5 @@
#include "rpl4.h"
#pragma hdrstop
#define PRELOAD_ART
@@ -1951,7 +1952,75 @@ GPS::GPS(
//-----------------------------------------------------------
background = new Video8BitBuffered(width, height);
Register_Object(background);
//
//-----------------------------------------------------------------
// RP412MAPRATE - how many of the sixteen rate steps the map redraws
// on.
//
// The gauge renderer walks a 16-bit rate wheel: one bit per full
// pass over every active gauge, shifted right each pass and reset at
// the bottom (GAUGREND.cpp). A gauge redraws only on the step its
// configured rate names, so a map on one bit redraws once per
// SIXTEEN passes - and its update period is sixteen passes however
// cheap the redraw is.
//
// That was fine when a pass was quick. Racing, the background loop
// only gets what is left of the frame after the 3D, passes fall to
// about five a second, and sixteen of them is over three seconds
// between map updates - measured, on a 60 fps display with the 3D
// perfectly smooth. Nothing is slow here; the map is just waiting
// its turn on a wheel built for a machine that came round faster.
//
// Drawing on more of the steps costs one gauge's redraw per step,
// against a pass that runs ninety of them. It does not make the
// wheel turn faster - it stops the map needing a whole turn.
//-----------------------------------------------------------------
//
{
static int updates = -1;
if (updates < 0)
{
const char *setting = getenv("RP412MAPRATE");
updates = (setting != NULL) ? atoi(setting) : 16;
// 1..16, and only the powers of two divide the wheel evenly
if (updates > 16) updates = 16;
if (updates < 1) updates = 1;
}
if (updates > 1)
{
GaugeRate mask = 0;
for (int step = 0; step < 16; step += (16 / updates))
{
mask |= (GaugeRate)(0x8000 >> step);
}
//
// QUALIFIED, both of them. This constructor's first
// parameter is also called 'rate', so a bare assignment
// here writes the PARAMETER and leaves the member holding
// whatever the gauge data asked for - which is what it did,
// silently, and cost a long hunt for a writer that did not
// exist. oldRate is not shadowed, which is why it took the
// value and the pair disagreed.
//
// Gauge::Disable(False) restores rate from oldRate when the
// mode system enables a gauge, so both have to carry it or
// the first activation puts the old rate back.
//
Gauge::rate = mask;
Gauge::oldRate = mask;
}
}
needsStaticUpdate = True;
//
// Nothing drawn yet, so there is no picture to add a placement to and
// no scale it would be added at. The first pass builds both.
//
backgroundBuilt = False;
builtMinX = builtMinY = builtMinZ = (Scalar) 0;
builtMaxX = builtMaxY = builtMaxZ = (Scalar) 0;
Check_Fpu();
}
@@ -1989,6 +2058,95 @@ void
void
GPS::NotifyOfNewInterestingEntity(Entity *entity)
{
Check(this);
Check(entity);
if (!entity->IsDerivedFrom(*Terrain::GetClassDerivations()))
{
Check_Fpu();
return;
}
//
// A rebuild is already owed, or there is no picture to add to yet.
//
if (needsStaticUpdate || !backgroundBuilt)
{
needsStaticUpdate = True;
Check_Fpu();
return;
}
//
// Terrain arrives as you DRIVE - the interest system hands each piece
// over as it comes into range, not all of it at load - and this used
// to order a rebuild of the entire map for every one of them. A
// rebuild redraws every placement on the track, so the cost of one
// arriving piece was the whole track, and the map went seconds
// between updates on the tracks that draw the most: Tour De Mars at
// 351 placements and Ares' Armpits at 320, against 80-140 for a
// typical one. It is also not interruptible - the gauge loop checks
// its time slice BETWEEN gauges - so a rebuild stalled every other
// display with it.
//
// But the bounds are what set the scale, and the scale is what the
// whole cached picture was drawn at. An arrival that leaves the
// bounds alone leaves every placement already on the map exactly
// where it belongs, and the only thing missing from the picture is
// the new one. Draw that, and nothing else.
//
// Only a piece that moves an EDGE of the track changes the scale, and
// then the picture really is wrong everywhere and has to be redrawn.
// That is rare, and it gets rarer as the track fills in.
//
// RPL4GaugeRenderer::NotifyOfNewInterestingEntity adds the entity to
// staticEntities before chaining here, so these bounds already
// account for the arrival being judged.
//
Scalar
minX, minY, minZ,
maxX, maxY, maxZ;
Check(renderer);
renderer->GetStaticBounds(
&minX, &minY, &minZ,
&maxX, &maxY, &maxZ
);
if (minX != builtMinX || minY != builtMinY || minZ != builtMinZ ||
maxX != builtMaxX || maxY != builtMaxY || maxZ != builtMaxZ)
{
needsStaticUpdate = True;
}
else if (DrawStaticEntity(entity))
{
//
// Only when something was actually drawn. Terrain without a
// GaugeImage never reaches the map - on these tracks that is
// most of it, 256 of Tour De Mars' 607 - and blitting the
// background again for one of those is pure cost.
//
needsScreenUpdate = True;
}
Check_Fpu();
}
//
//#############################################################################
// NotifyOfBecomingUninterestingEntity
//#############################################################################
//
// The map showed only currently-interesting terrain before any of this,
// and it still does. A placement cannot be un-drawn from a composited
// picture, so a departure is the one case left that costs a full rebuild.
//
// Nothing used to listen for this at all: departures were swept up by the
// rebuild that the very next ARRIVAL ordered, which is no longer ordered.
// Without this the map would keep showing terrain that had gone until
// something moved the bounds.
//
void
GPS::NotifyOfBecomingUninterestingEntity(Entity *entity)
{
Check(this);
Check(entity);
@@ -2104,61 +2262,34 @@ void
ChainIteratorOf<Entity*>
i(staticEntityList.GetInstanceList());
Check(renderer);
L4Warehouse
*warehouse = (L4Warehouse *) renderer->warehousePointer;
Check(warehouse);
Entity
*entity;
L4GaugeImage
*gauge_image;
AffineMatrix
worldToView,
localToView;
Vector3D
scaling_vector;
//------------------------------------
// Scale the display
//------------------------------------
Verify(!Small_Enough(pixelsPerMeter));
scaling_vector.x = pixelsPerMeter;
scaling_vector.y = pixelsPerMeter;
scaling_vector.z = pixelsPerMeter;
worldToView.BuildIdentity();
worldToView *= centeringOffset; // translation
worldToView *= scaling_vector;
int
drawn = 0;
while ((entity=i.ReadAndNext()) != NULL)
{
Check(entity);
//-------------------------------------
// Draw image
//-------------------------------------
gauge_image = warehouse->
gaugeImageBin.GetIfAlreadyExists(entity->GetResourceID());
if (gauge_image != NULL)
{
Check(gauge_image);
localToView.Multiply(entity->localToWorld, worldToView);
gauge_image->Draw(
LODIndex, // value set by creator
metersPerPixel,
&backgroundView,
0, // default color
(AffineMatrix &) localToView
);
warehouse->gaugeImageBin.Release(entity->GetResourceID());
}
DrawStaticEntity(entity);
}
//
// The picture now matches these bounds, and they are what the scale
// everything on it was drawn at came from. Remember them: an arrival
// that leaves them alone can be added to this picture rather than
// replacing it.
//
builtMinX = minX;
builtMinY = minY;
builtMinZ = minZ;
builtMaxX = maxX;
builtMaxY = maxY;
builtMaxZ = maxZ;
backgroundBuilt = True;
//-----------------------------------------------------------
// Redraw new background, restart moving entity display
//-----------------------------------------------------------
@@ -2166,6 +2297,71 @@ void
Check_Fpu();
}
//
//#############################################################################
// DrawStaticEntity
//#############################################################################
//
// One placement onto the cached background, at the scale that background
// was built at. Shared by the full rebuild above and by the single-arrival
// path in NotifyOfNewInterestingEntity, so the two cannot drift into
// drawing the same track two different ways.
//
Logical
GPS::DrawStaticEntity(Entity *entity)
{
Check(this);
Check(entity);
Check(background);
Check(renderer);
L4Warehouse
*warehouse = (L4Warehouse *) renderer->warehousePointer;
Check(warehouse);
L4GaugeImage
*gauge_image =
warehouse->gaugeImageBin.GetIfAlreadyExists(entity->GetResourceID());
if (gauge_image == NULL)
{
return False; // nothing of it appears on the map
}
Check(gauge_image);
L4BytePort
backgroundPort(background, "background", 0);
GraphicsView
backgroundView(&backgroundPort);
backgroundView.SetOrigin(width>>1, height>>1);
Vector3D
scaling_vector;
scaling_vector.x = pixelsPerMeter;
scaling_vector.y = pixelsPerMeter;
scaling_vector.z = pixelsPerMeter;
AffineMatrix
worldToView,
localToView;
worldToView.BuildIdentity();
worldToView *= centeringOffset; // translation
worldToView *= scaling_vector;
localToView.Multiply(entity->localToWorld, worldToView);
gauge_image->Draw(
LODIndex, // value set by creator
metersPerPixel,
&backgroundView,
0, // default color
(AffineMatrix &) localToView
);
warehouse->gaugeImageBin.Release(entity->GetResourceID());
return True;
}
void
GPS::Execute()