Files
BT411/engine/MUNGA_L4/L4VB16.h
T
CydandClaude Opus 4.8 f338595685 Glass cockpit: per-display windows (BT_GLASS_PANELS)
Break the desktop glass cockpit's secondary displays out of the single
combined pad panel + D3D gauge strip into ONE window per pod display, each
carrying that display's surface with its RIO button bank, arranged
pod-faithfully around the main view.  New TU engine/MUNGA_L4/L4GLASSWIN.*
(BT_GLASS-only), selected by the -platform glass preset via the new runtime
gate BT_GLASS_PANELS (=0 falls back to the legacy single panel + dock).

- Surfaces are CPU-expanded from the shared gauge buffer
  (SVGA16::ExpandPlaneToBGRA, no D3D) and StretchDIBits'd in -- the D3D
  dev-composite path (dock / window / overlay) stands down while active.
- Buttons sit UNDER the imagery: big hidden click targets that reach into
  the display, with only a small protruding edge showing as a lamp light.
  Red MFD banks tile the top/bottom; radar rails run the sides + a bottom
  row; a Flight Controls window hosts the no-display banks.
- Windows: Heat / Engineering / Comm / Left Weapons / Right Weapons / radar
  + Flight Controls; edge-to-edge (no in-client margin/title; OS caption
  labels each).
- Fix blank surfaces: application/ghWnd are duplicate-defined and bind
  non-deterministically under /FORCE, so the fresh L4GLASSWIN TU read NULL.
  Reach the renderer/window via BTResolveGaugeRenderer/BTResolveMainWindow
  defined in btl4main.cpp off the real btl4App/hWnd pointers.  New gotcha:
  reconstruction-gotchas.md S6 duplicate-GLOBAL corollary.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-20 14:43:40 -05:00

553 lines
11 KiB
C++

#pragma once
#include "..\munga\graph2d.h"
#include "..\munga\time.h"
#include <D3DX9.h>
#include <D3DX9math.h>
class L4graphicsPort;
class GaugeRenderer;
// GLASS: resolve the gauge renderer / main window. DEFINED in game/btl4main.cpp
// off the REAL app + window pointers it holds as locals -- NOT off the
// `application`/`ghWnd` globals, which are duplicate-defined and bind
// non-deterministically per link under /FORCE (the "duplicate-symbol race" --
// CMakeLists.txt:186), so a newly-added engine TU (L4GLASSWIN) can read NULL.
GaugeRenderer *BTResolveGaugeRenderer();
void *BTResolveMainWindow(); // HWND (kept void* -- no windows.h dependency)
//########################################################################
//######################### Video16BitBuffered ###########################
//########################################################################
//
// X/Y values passed to these routines are assumed to be in
// the VIDEO DISPLAY COORDINATE SYSTEM, with (0,0) at the top left.
//
class Video16BitBuffered :
public GraphicsDisplay
{
public:
Video16BitBuffered(int x, int y);
~Video16BitBuffered();
Logical
TestInstance() const;
void
ShowInstance(char *indent);
void
DrawPoint(
int color,
int bitmask,
Enumeration operation,
int x, int y
);
void
DrawLine(
int color,
int bitmask,
Enumeration operation,
int x1, int y1,
int x2, int y2,
Logical include_last_pixel
);
void
DrawFilledRectangle(
int color,
int bitmask,
Enumeration operation,
int x1, int y1,
int x2, int y2
);
void
DrawText(
int color,
int bitmask,
Enumeration operation,
Logical opaque,
int rotation,
Enumeration fontNumber,
Logical vertical,
GraphicsDisplay::Justification justification,
Rectangle2D *clippingRectanglePtr,
char *stringPointer
);
void
DrawBitMap(
int color,
int bitmask,
Enumeration operation,
int rotation,
int x, int y,
BitMap *bitmap,
int sx1, int sy1, int sx2, int sy2 // these are SOURCE coordinates
);
void
DrawBitMapOpaque(
int color,
int background,
int bitmask,
Enumeration operation,
int rotation,
int x, int y,
BitMap *bitmap,
int sx1, int sy1, int sx2, int sy2 // these are SOURCE coordinates
);
void
DrawPixelMap8(
int *translation_table,
int bitmask,
Enumeration operation,
Logical opaque,
int rotation,
int x, int y,
PixelMap8 *pixelmap,
int sx1, int sy1, int sx2, int sy2 // these are SOURCE coordinates
);
void
DrawPixelMap8SingleColor(
int color,
int bitmask,
Enumeration operation,
int rotation,
int x, int y,
PixelMap8 *pixelmap,
int sx1, int sy1, int sx2, int sy2 // these are SOURCE coordinates
);
protected:
void
MarkChangedLines(int screenTop, int screenBottom);
void
buildDestPointer(
int x, int y,
Word **pixelPointer,
LWord **changed_bit_pointer,
LWord *changed_bit
);
Logical
valid;
int
width,
changedBitWidth,
height,
maximumX,
maximumY;
PixelMap16
pixelBuffer;
Byte
*changedLine;
LWord
*changedBit;
};
//########################################################################
//################################ SVGA16 ################################
//########################################################################
struct SVGA16Palette
{
Word
hardwarePort;
Logical
modified;
Palette8
paletteData;
Scalar
flashAccumulator,
flashRate;
enum PaletteID
{
maskStates=4
};
unsigned char
mask[maskStates];
int
previousMaskState;
};
class SVGA16 :
public Video16BitBuffered
{
friend class L4GraphicsPort; // for palette access
public:
enum PaletteID {
NativePalette=0,
SecondaryPalette,
AuxiliaryPalette1,
AuxiliaryPalette2,
PaletteCount
};
SVGA16(
int mode,
int width,
int height,
int page_size,
int mem_granularity,
int bytes_per_line,
int page_function_pointer,
int special_interface,
bool windowed,
int *secondaryIndex,
int *aux1Index,
int *aux2Index
);
~SVGA16();
Logical
TestInstance() const;
void
ShowInstance(char *indent);
Logical
Update(Logical forceall);
void
Refresh();
void
UpdatePalette();
void
FadeToPalettes(Scalar fade_time);
void
FadeToWhite(Scalar fade_time);
void
FlashPalette(
int palette_number,
Scalar rate,
unsigned char *stateList
);
void
UnflashPalette(int palette_number);
void
FunkyVideo(Logical on_off);
protected:
void BuildWindows(unsigned int width, unsigned int height, bool windowed, int *secondaryIndex, int *aux1Gauge, int *aux2Gauge);
void
ResetUpdatePosition();
int
pageSize,
pageDelta,
widthInBytes,
pageFcnPtr,
specialInterface;
int
currentPageNumber,
nextPageNumber,
lineNumber;
long
destOffset;
Byte
*changedLinePointer;
Word
*sourcePointer;
LWord
*changedBitPointer;
enum PaletteFadeState
{
staticPalette,
fadeToWhite,
whitePalette,
fadeToColor
};
PaletteFadeState
paletteFadeState;
Scalar
fadeAlpha,
fadeUnitsPerSecond;
Time
previousFadeTime;
// This array is closely linked to the PaletteID enumeration, above
SVGA16Palette
palette[PaletteCount];
private:
int NUMGAUGEWINDOWS;
HWND *gaugeWindows;
LPDIRECT3DDEVICE9 *mDevice;
D3DPRESENT_PARAMETERS *mPresentParams;
LPDIRECT3DVERTEXBUFFER9 *mVertBuffers;
LPDIRECT3DTEXTURE9 *mSurfaces;
DWORD *mLockFlags;
RECT *mSurfaceRects;
int mDisplayToUpdate;
LPDIRECT3DTEXTURE9 mDevSurfaceTex[10]; // DEV-COMPOSITE: one texture per gauge surface
// (sec/radar + the 5 MFD bit-planes + the Eng1-3
// preset-page planes, Gitea #9), on the MAIN device.
public:
// DEV-COMPOSITE: extract ONE gauge surface from the shared pixelBuffer into
// mDevSurfaceTex[slot] on the given (main) device + draw it as a quad at (dstX,dstY,
// dstW,dstH). monoTint < 0 -> palette-expand (sec/radar, case-0 LUT); monoTint >= 0
// -> mono bit-plane expand ((word & mask) ? tint : 0) for an MFD plane. See
// BTDrawGaugeSurfaces (L4VB16.cpp).
// rotateCCW: 0 = as-is; 1/3 = display the texture turned 90 degrees (the
// pod's portrait-mounted secondary CRT; the dev panel unrotates it).
void DrawDevSurface(LPDIRECT3DDEVICE9 device, int slot, int mask, int paletteID,
int monoTint, float dstX, float dstY, float dstW, float dstH,
int rotateCCW = 0);
// GLASS (per-display windows, L4GLASSWIN): CPU-expand ONE gauge surface (a
// bit-plane of the shared pixelBuffer) into a 32-bit BGRA image for GDI
// StretchDIBits -- no D3D. Same pixel rule as DrawDevSurface: monoTint < 0 ->
// palette-expand via palette[paletteID]; else fill (word & mask) ? monoTint : 0
// (monoTint is a 0x00RRGGBB value here, NOT R5G6B5). rotateQuadrant: 0 = native
// (outW=bufW, outH=bufH); 1 = 90 CCW / 3 = 90 CW -> transposed (outW=bufH,
// outH=bufW), for the portrait secondary CRT. `dst` must hold >= bufW*bufH
// dwords; the image is written TOP-DOWN. *outW/*outH receive the produced size.
void ExpandPlaneToBGRA(int mask, int paletteID, int monoTint, int rotateQuadrant,
unsigned long *dst, int *outW, int *outH);
};
//########################################################################
//########################## L4GraphicsPort ##############################
//########################################################################
//
// X/Y values passed to these routines are assumed to be in
// the GRAPHICS COORDINATE SYSTEM, with (0,0) at the bottom left.
//
class L4GraphicsPort :
public GraphicsPort
{
public:
enum ChannelEnableID {
RedChannel,
GreenChannel,
BlueChannel,
AllChannels,
DirectColor,
BlankColor,
RedChannelTransparentZero=0x80,
GreenChannelTransparentZero,
BlueChannelTransparentZero,
AllChannelsTransparentZero
};
L4GraphicsPort(
Video16BitBuffered *graphics_display,
const char *name,
int rotation,
int bit_mask,
SVGA16::PaletteID palette_ID,
L4GraphicsPort::ChannelEnableID channel_enable
);
~L4GraphicsPort();
Logical
TestInstance() const;
void
ShowInstance(char *indent);
void
SetSecondaryPalette(
Palette8 *source_palette
);
void
SetAuxiliaryPalette();
void
SetColor(
PaletteTriplet *source_color,
int color_index
);
void
DrawPoint(
int color,
Enumeration operation,
int x, int y
);
void
DrawLine(
int color,
Enumeration operation,
int x1, int y1,
int x2, int y2,
Logical include_last_pixel
);
void
DrawFilledRectangle(
int color,
Enumeration operation,
int x1, int y1,
int x2, int y2
);
void
DrawText(
int color,
Enumeration operation,
Logical opaque,
int rotation,
Enumeration fontNumber,
Logical vertical,
GraphicsDisplay::Justification justification,
Rectangle2D *clippingRectanglePtr,
char *stringPointer
);
void
DrawBitMap(
int color,
Enumeration operation,
int rotation,
int x, int y,
BitMap *bitmap,
int sx1, int sy1, int sx2, int sy2 // these are SOURCE coordinates
);
void
DrawBitMapOpaque(
int color,
int background,
Enumeration operation,
int rotation,
int x, int y,
BitMap *bitmap,
int sx1, int sy1, int sx2, int sy2 // these are SOURCE coordinates
);
void
DrawPixelMap8(
Enumeration operation,
Logical opaque,
int rotation,
int x, int y,
PixelMap8 *pixelmap,
int sx1, int sy1, int sx2, int sy2 // these are SOURCE coordinates
);
void
DrawPixelMap8SingleColor(
int color,
Enumeration operation,
int rotation,
int x, int y,
PixelMap8 *pixelmap,
int sx1, int sy1, int sx2, int sy2 // these are SOURCE coordinates
);
void
SetPaletteID(SVGA16::PaletteID palette_ID)
{
Check(this);
paletteID = palette_ID;
}
void
SetEnableID(L4GraphicsPort::ChannelEnableID channel_enable)
{
Check(this);
channelEnable = channel_enable;
}
int
GetBitMask()
{
Check(this);
return bitMask;
}
// DEV-COMPOSITE (Gitea #9): the dock honors the live reconfigure state --
// a plane whose channel is currently BlankColor contributes nothing on the
// pod's shared-word palette LUT, so the dev panel skips drawing it.
L4GraphicsPort::ChannelEnableID
GetEnableID()
{
Check(this);
return channelEnable;
}
SVGA16::PaletteID
paletteID;
protected:
void
convertPortPair(
int *xp,
int *yp,
int x,
int y
);
void
BuildDirectTranslation(
Palette8 *source_palette
);
void
BuildSecondaryPalette(
Palette8 *source_palette
);
void
BuildAuxiliaryPalette();
void
BuildSecondaryTranslation();
void
BuildAuxiliaryTranslation();
void
BlankPalette();
void
BuildSecondaryColor(
PaletteTriplet *source_triplet,
int color_number
);
//------------------------------------------------------------
// Protected data
//------------------------------------------------------------
int
translationTable[256];
unsigned char
myColor[256];
int
baseRotation,
bitMask,
numberOfBits,
maximumX,
maximumY;
L4GraphicsPort::ChannelEnableID
channelEnable;
};