Compare commits
13
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
  CydandClaude Fable 5
|
19a1abbff2 | ||
|
CydandClaude Fable 5
|
a1b7dae3da | ||
|
CydandClaude Fable 5
|
767473d1cf | ||
|
CydandClaude Fable 5
|
007d15e668 | ||
|
CydandClaude Opus 4.8
|
391c53f294 | ||
|
CydandClaude Fable 5
|
bec3bb1e4a | ||
|
CydandClaude Fable 5
|
6923c9f252 | ||
|
CydandClaude Fable 5
|
23204ba9c6 | ||
|
CydandClaude Fable 5
|
97e78b0eea | ||
|
CydandClaude Fable 5
|
ce5ed1117a | ||
|
CydandClaude Fable 5
|
41f6ef364d | ||
|
CydandClaude Fable 5
|
f77cd55b11 | ||
|
CydandClaude Fable 5
|
31c3a910f0 |
@@ -0,0 +1,68 @@
|
||||
---
|
||||
name: verify
|
||||
description: Build, launch, and drive the vRIO WinForms app to verify changes at the GUI surface — screenshots via PrintWindow, input via PostMessage, no focus stealing.
|
||||
---
|
||||
|
||||
# Verifying vRIO changes
|
||||
|
||||
Build + tests (tests are CI's job; run the app for verification):
|
||||
|
||||
```powershell
|
||||
dotnet build vrio.sln -v q -nologo # Debug
|
||||
# exe: src\VRio.App\bin\Debug\net48\VRio.App.exe
|
||||
# exe: src\VPlasma.App\bin\Debug\net48\VPlasma.App.exe (companion display)
|
||||
```
|
||||
|
||||
Everything below applies to vPLASMA too. It auto-opens **COM12** on
|
||||
launch (hardwired; status in the title bar), so its serial path tests
|
||||
end-to-end with no UI driving: the script just plays the game writing
|
||||
**COM2** (second com0com pair; vRIO/RIOJoy use COM1⇄COM11). Double-click
|
||||
the glass = self-test pages, right-click = reset.
|
||||
Killing a writer mid-stream can leave stale bytes queued in the com0com
|
||||
buffer — the next session's byte counter will run high; re-run clean
|
||||
before trusting counts.
|
||||
|
||||
## Driving the GUI without touching the user's desktop
|
||||
|
||||
This is the user's live desktop — **never** use SetForegroundWindow +
|
||||
SendKeys/mouse_event: focus-stealing prevention leaves the app behind
|
||||
VS Code and your clicks land in the user's windows. Instead:
|
||||
|
||||
- **Screenshots**: `PrintWindow(hwnd, dc, 2)` (PW_RENDERFULLCONTENT) —
|
||||
captures the window even when occluded. CopyFromScreen captures
|
||||
whatever is on top; don't use it.
|
||||
- **Canvas input** (stick drags, cell clicks): PostMessage
|
||||
`WM_LBUTTONDOWN/WM_MOUSEMOVE/WM_LBUTTONUP` straight to the canvas
|
||||
child HWND. Find it by descending `RealChildWindowFromPoint` from the
|
||||
form. Canvas geometry is compile-time constant (PanelCanvas.cs):
|
||||
CellW=66, BoxXY = x 416..496, y 6..74 (X/Y stick box).
|
||||
The **first** posted drag after launch can half-land (only the
|
||||
button-down registers); do a throwaway drag first, then the measured
|
||||
one, screenshot **while held** (spring-back recenters on up).
|
||||
- **Checkboxes/buttons**: WinForms controls expose no UIA TogglePattern
|
||||
(they surface as bare Panes) and don't answer BM_GETCHECK — but
|
||||
`SendMessage(hwnd, BM_CLICK, 0, 0)` works. Get the HWND from the UIA
|
||||
element's NativeWindowHandle (find by Name).
|
||||
- **Combo boxes** (COM port pickers): string-carrying messages
|
||||
(`CB_FINDSTRINGEXACT`, `CB_GETLBTEXT`) do **not** marshal across
|
||||
processes — the SendMessage hangs. Compute the item index locally
|
||||
(both apps fill from `SerialPort.GetPortNames()` sorted
|
||||
OrdinalIgnoreCase) and send index-only `CB_SETCURSEL`; the apps read
|
||||
`SelectedItem` lazily so no CBN_SELCHANGE notification is needed.
|
||||
Find the combo child HWND via EnumChildWindows + GetClassName
|
||||
containing `COMBOBOX` (UIA ClassName "ComboBox" doesn't match).
|
||||
- Pattern that works: Add-Type user32 P/Invokes, Start-Process the exe,
|
||||
drive via messages, PrintWindow screenshot to the scratchpad, kill
|
||||
the process in `finally`.
|
||||
|
||||
## Environment gotchas
|
||||
|
||||
- Bindings load from `%APPDATA%\vRIO\bindings.txt` (the user's file),
|
||||
not the built-in defaults — arrow keys are bound to Hat *buttons*,
|
||||
not the joystick axis. Drive axes via the X/Y box.
|
||||
- A real XInput gamepad is connected on this machine ("Controller #1
|
||||
connected"); the router only writes an axis when its composed value
|
||||
changes, so a centered pad won't fight a canvas drag.
|
||||
- The wire readout (top center, green) shows `GetWireAxis` values —
|
||||
joystick Y is natively negated on the wire (stick up = −80) unless
|
||||
"Invert Y" is checked.
|
||||
@@ -3,7 +3,9 @@
|
||||
A software replica of the cockpit **RIO** (Remote Input/Output) board: it opens
|
||||
a COM port and speaks the **device side** of the RIO serial protocol, so any
|
||||
host that expects the real hardware — most importantly
|
||||
[RIOJoy](../riojoy/) — can talk to it without a cockpit attached.
|
||||
[RIOJoy](../riojoy/) — can talk to it without a cockpit attached. (The
|
||||
cockpit's other serial device gets the same treatment: see
|
||||
[vPLASMA](#vplasma--the-companion-plasma-display) below.)
|
||||
|
||||
The window is an interactive version of the cockpit control panel that
|
||||
RIOJoy's profile editor draws (the same functional layout from the original
|
||||
@@ -23,6 +25,17 @@ controls:
|
||||
- Cells shade to the **lamp state the host commands** (`LampRequest`:
|
||||
off / dim / bright, with slow/med/fast flash), so RIOJoy's press-feedback
|
||||
lights the on-screen panel just like the real buttons.
|
||||
- **Lamps can mirror onto an RGB keyboard** (*Mirror lamps on RGB keyboard*,
|
||||
via Windows 11 Dynamic Lighting): keys bound to lamp-capable buttons glow
|
||||
with the panel's palette and blink in step with the on-screen flash modes;
|
||||
per-key keyboards get the full button field, zone-lit keyboards show the
|
||||
strongest current lamp board-wide, and a picker narrows the mirror to one
|
||||
keyboard when several are attached. For the LEDs to stay lit while the
|
||||
*game* has focus, vRIO needs package identity: run `pkg\Register-vRIO.ps1`
|
||||
once (Developer Mode required; pass the exe folder for a deployed copy),
|
||||
launch vRIO from its **Start menu entry** (a direct exe launch runs without
|
||||
identity), then drag vRIO to the top of *Settings → Personalization →
|
||||
Dynamic Lighting → Background light control*.
|
||||
- **Keyboard and Xbox (XInput) controller input** drive the same controls
|
||||
through a bindings file (`%APPDATA%\vRIO\bindings.txt`, created with
|
||||
commented defaults on first run — *Edit bindings…* opens it, *Reload
|
||||
@@ -37,6 +50,17 @@ controls:
|
||||
F1–F6 / F7–F12 = the Secondary / Screen columns, numpad = internal
|
||||
keypad (hex keys on the operators), arrows + Space = hat + main, with
|
||||
ABXY / dpad / shoulders on the pad's named buttons.
|
||||
- **Capture one keyboard in the background** (*Capture keyboard* picker in the
|
||||
Input panel): by default keyboard input follows the focused window, so vRIO
|
||||
goes deaf the moment the sim takes focus. Selecting a specific keyboard
|
||||
instead taps it through the Windows **Raw Input** API (`RIDEV_INPUTSINK`), so
|
||||
its keys drive the panel *while the game has focus* — the input-side twin of
|
||||
the lamp mirror writing that keyboard's LEDs under the same condition. Raw
|
||||
Input observes without intercepting: the keystroke still reaches the focused
|
||||
app, so this is meant for a keyboard *dedicated* to the panel, not the one you
|
||||
also type on. Leaving the picker on *All keyboards* keeps the plain
|
||||
focus-only behavior. (No package identity needed — unlike the lamp side, this
|
||||
is a plain Win32 tap.)
|
||||
|
||||
## Wire behavior
|
||||
|
||||
@@ -60,33 +84,73 @@ device behavior grounded in the **real v4.2 firmware dump**
|
||||
- `ResetRequest` re-zeroes the targeted axis (or all).
|
||||
- A NAK re-sends the last event up to **4 times**, then gives up with a
|
||||
RESTART byte — the real board's retry budget.
|
||||
- Optional **v4.2 reply-wedge emulation**: after retry exhaustion (or the
|
||||
"Wedge analog now" button), analog requests are silently dropped — still
|
||||
ACK'd, RX path alive — until a host `ResetRequest`, reproducing the
|
||||
latch-leak fault the firmware analysis documents. Use it to exercise
|
||||
RIOJoy's 5-second no-analog recovery watchdog.
|
||||
- Optional **v4.2 reply-wedge emulation** (in `VRio.Core`; the UI toggles
|
||||
were removed): after retry exhaustion, analog requests are silently
|
||||
dropped — still ACK'd, RX path alive — until a host `ResetRequest`,
|
||||
reproducing the latch-leak fault the firmware analysis documents.
|
||||
|
||||
## Using it with RIOJoy on one PC
|
||||
|
||||
The two apps need a crossed serial link. Install a
|
||||
[com0com](https://com0com.sourceforge.net/) virtual null-modem pair
|
||||
(e.g. `COM5 ⇄ COM6`), then:
|
||||
(e.g. `COM1 ⇄ COM11`), then:
|
||||
|
||||
1. Run `VRio.App`, pick `COM5`, **Open**.
|
||||
2. Point RIOJoy at `COM6`.
|
||||
1. Run `VRio.App`, pick `COM11`, **Open**.
|
||||
2. RIOJoy will always poit to `COM1`.
|
||||
|
||||
RIOJoy's DTR open-pulse shows up in the wire log (DSR handshake), its ~55 ms
|
||||
analog polling drives the "analog polls served" counter, and every click on
|
||||
the vRIO panel arrives at RIOJoy as real cockpit input. Two physical PCs with
|
||||
a null-modem cable work the same way.
|
||||
|
||||
## vPLASMA — the companion plasma display
|
||||
|
||||
The cockpit's second serial device is the **plasma display**: a 128×32
|
||||
dot-matrix panel on COM2 (9600 8N1, no flow control) that the game draws
|
||||
mission text and status graphics on. `VPlasma.App` is its software replica:
|
||||
a bare-glass window that opens **COM12** (the device end of the plasma's
|
||||
null-modem pair) on startup — retrying while the port is missing or busy,
|
||||
port status in the title bar — decodes the display's command stream, and
|
||||
renders the dot matrix in plasma orange, text mode included.
|
||||
|
||||
The command set was recovered from two Tesla 4.10 artifacts:
|
||||
`CODE\RP\MUNGA_L4\L4PLASMA.CPP` (the game's driver — it renders everything
|
||||
into a local 1bpp buffer and streams changed rows as `ESC P` graphics
|
||||
writes, hiding the cursor with `ESC G 0` at boot) and the factory test tool
|
||||
`VWETEST\VGLTEST\PLASMA.EXE` (the text mode: BS/HT/LF/VT/CR cursor motion,
|
||||
`ESC @` clear, `ESC L` home, `ESC G` cursor visibility, `ESC K` font
|
||||
select, `ESC H` attributes — intensity/underline/reverse/flash). The full
|
||||
recovered grammar lives in `src/VPlasma.Core/Protocol/PlasmaProtocol.cs`.
|
||||
|
||||
- **Graphics** — `ESC P screen y xbyte width rows` + packed 1bpp row data,
|
||||
MSB = leftmost pixel. This is everything the game sends, so it is the
|
||||
wire path a pod's plasma actually sees.
|
||||
- **Text** — printable ASCII renders through a 5×7 font at a cursor:
|
||||
fonts 0–3 give a 21×4 cell grid, fonts 4–7 the same glyphs doubled to
|
||||
10×2. Half-intensity draws dimmer, reverse/underline render in the
|
||||
cell, flashing text (and the flashing cursor) blink on the glass. The
|
||||
panel's own ROM glyphs are lost with the hardware, so the classic
|
||||
public-domain 5×7 set stands in.
|
||||
- **Double-click** the glass to cycle three self-test pages (banner,
|
||||
charset, graphics pattern) through the same parser the wire feeds —
|
||||
useful without a host. **Right-click** resets the display to its
|
||||
power-on state.
|
||||
- Pair it with the game like vRIO ↔ RIOJoy: a second com0com null-modem
|
||||
pair `COM2 ⇄ COM12` — the game's plasma output writes COM2, vPLASMA
|
||||
listens on COM12. The plasma never talks back, so there is no transmit
|
||||
path to pace.
|
||||
|
||||
## Repository layout
|
||||
|
||||
| Path | Contents |
|
||||
|------|----------|
|
||||
| `src/VRio.Core` | Protocol framing/builder/parser, the `VRioDevice` state machine, serial pump, panel layout data (class library) |
|
||||
| `src/VRio.App` | WinForms panel UI |
|
||||
| `src/VPlasma.Core` | Plasma command-stream parser, the `VPlasmaDevice` display state machine, 5×7 font, serial listener (class library) |
|
||||
| `src/VPlasma.App` | WinForms dot-matrix display UI |
|
||||
| `pkg` | Sparse-package manifest + registration script: grants VRio.App.exe the package identity Dynamic Lighting's background-control list requires |
|
||||
| `tests/VRio.Core.Tests` | xUnit tests for the protocol + device engine |
|
||||
| `tests/VPlasma.Core.Tests` | xUnit tests for the plasma parser + display engine |
|
||||
|
||||
## Building
|
||||
|
||||
|
||||
@@ -13,6 +13,12 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{C4993638
|
||||
EndProject
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VRio.Core.Tests", "tests\VRio.Core.Tests\VRio.Core.Tests.csproj", "{986638BB-F289-4480-8575-F1699D201590}"
|
||||
EndProject
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VPlasma.Core", "src\VPlasma.Core\VPlasma.Core.csproj", "{39E7C28F-8B07-495C-A887-21F2F6AF9A86}"
|
||||
EndProject
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VPlasma.App", "src\VPlasma.App\VPlasma.App.csproj", "{72D03B3A-7D4E-496C-8DA9-596DFC91704E}"
|
||||
EndProject
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VPlasma.Core.Tests", "tests\VPlasma.Core.Tests\VPlasma.Core.Tests.csproj", "{F31F1D86-546A-4B0C-A283-C04FAAC49F46}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
||||
Debug|Any CPU = Debug|Any CPU
|
||||
@@ -34,10 +40,25 @@ Global
|
||||
{986638BB-F289-4480-8575-F1699D201590}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{986638BB-F289-4480-8575-F1699D201590}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{986638BB-F289-4480-8575-F1699D201590}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{39E7C28F-8B07-495C-A887-21F2F6AF9A86}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{39E7C28F-8B07-495C-A887-21F2F6AF9A86}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{39E7C28F-8B07-495C-A887-21F2F6AF9A86}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{39E7C28F-8B07-495C-A887-21F2F6AF9A86}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{72D03B3A-7D4E-496C-8DA9-596DFC91704E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{72D03B3A-7D4E-496C-8DA9-596DFC91704E}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{72D03B3A-7D4E-496C-8DA9-596DFC91704E}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{72D03B3A-7D4E-496C-8DA9-596DFC91704E}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
{F31F1D86-546A-4B0C-A283-C04FAAC49F46}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
|
||||
{F31F1D86-546A-4B0C-A283-C04FAAC49F46}.Debug|Any CPU.Build.0 = Debug|Any CPU
|
||||
{F31F1D86-546A-4B0C-A283-C04FAAC49F46}.Release|Any CPU.ActiveCfg = Release|Any CPU
|
||||
{F31F1D86-546A-4B0C-A283-C04FAAC49F46}.Release|Any CPU.Build.0 = Release|Any CPU
|
||||
EndGlobalSection
|
||||
GlobalSection(NestedProjects) = preSolution
|
||||
{80312F43-09BF-4F09-A0FA-A60FDF86274D} = {D0ECC9D9-7379-4759-89F7-56CD3214BD57}
|
||||
{2D1A482C-D907-47EB-9830-B78132154E57} = {D0ECC9D9-7379-4759-89F7-56CD3214BD57}
|
||||
{986638BB-F289-4480-8575-F1699D201590} = {C4993638-7EB6-47A9-897C-976DB9939601}
|
||||
{39E7C28F-8B07-495C-A887-21F2F6AF9A86} = {D0ECC9D9-7379-4759-89F7-56CD3214BD57}
|
||||
{72D03B3A-7D4E-496C-8DA9-596DFC91704E} = {D0ECC9D9-7379-4759-89F7-56CD3214BD57}
|
||||
{F31F1D86-546A-4B0C-A283-C04FAAC49F46} = {C4993638-7EB6-47A9-897C-976DB9939601}
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
Sparse package ("package with external location"): grants the plain win32
|
||||
VRio.App.exe a package identity without changing how it is built or run.
|
||||
vRIO needs identity so Windows Dynamic Lighting can list it under
|
||||
Settings → Personalization → Dynamic Lighting → Background light control —
|
||||
without it the keyboard lamp mirror only works while vRIO has focus.
|
||||
|
||||
Register (Developer Mode, unsigned) with the exe's folder as the external
|
||||
location: see Register-vRIO.ps1 next to this file.
|
||||
-->
|
||||
<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
|
||||
xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
|
||||
xmlns:uap3="http://schemas.microsoft.com/appx/manifest/uap/windows10/3"
|
||||
xmlns:uap10="http://schemas.microsoft.com/appx/manifest/uap/windows10/10"
|
||||
xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
|
||||
IgnorableNamespaces="uap uap3 uap10 rescap">
|
||||
|
||||
<!-- Bump Version on any Assets/resources.pri change: the shell's MrtCache
|
||||
is keyed by package full name and serves stale (even failed) icon
|
||||
lookups for a re-registered same-version package. -->
|
||||
<Identity Name="VWE.vRIO"
|
||||
ProcessorArchitecture="neutral"
|
||||
Publisher="CN=VWE"
|
||||
Version="1.0.0.1" />
|
||||
|
||||
<Properties>
|
||||
<DisplayName>vRIO</DisplayName>
|
||||
<PublisherDisplayName>VWE</PublisherDisplayName>
|
||||
<Logo>Assets\logo150.png</Logo>
|
||||
<uap10:AllowExternalContent>true</uap10:AllowExternalContent>
|
||||
</Properties>
|
||||
|
||||
<Dependencies>
|
||||
<TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26200.0" />
|
||||
</Dependencies>
|
||||
|
||||
<Resources>
|
||||
<Resource Language="en-us" />
|
||||
</Resources>
|
||||
|
||||
<Capabilities>
|
||||
<rescap:Capability Name="runFullTrust" />
|
||||
<rescap:Capability Name="unvirtualizedResources" />
|
||||
</Capabilities>
|
||||
|
||||
<Applications>
|
||||
<Application Id="vRIO"
|
||||
Executable="VRio.App.exe"
|
||||
uap10:TrustLevel="mediumIL"
|
||||
uap10:RuntimeBehavior="win32App">
|
||||
<uap:VisualElements DisplayName="vRIO"
|
||||
Description="Virtual RIO cockpit device emulator"
|
||||
Square150x150Logo="Assets\logo150.png"
|
||||
Square44x44Logo="Assets\logo44.png"
|
||||
BackgroundColor="transparent" />
|
||||
<Extensions>
|
||||
<!-- Advertise as a lighting-controller app so Dynamic Lighting offers
|
||||
vRIO in Settings' "Background light control" picker. -->
|
||||
<uap3:Extension Category="windows.appExtension">
|
||||
<uap3:AppExtension Name="com.microsoft.windows.lighting"
|
||||
Id="vrio"
|
||||
DisplayName="vRIO"
|
||||
Description="vRIO cockpit lamp mirror"
|
||||
PublicFolder="Public" />
|
||||
</uap3:Extension>
|
||||
</Extensions>
|
||||
</Application>
|
||||
</Applications>
|
||||
</Package>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 8.8 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.5 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 696 B |
Binary file not shown.
|
After Width: | Height: | Size: 696 B |
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 744 B |
Binary file not shown.
|
After Width: | Height: | Size: 744 B |
Binary file not shown.
|
After Width: | Height: | Size: 2.8 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.8 KiB |
@@ -0,0 +1,62 @@
|
||||
<#
|
||||
.SYNOPSIS
|
||||
Regenerates pkg\Assets\*.png from src\VRio.App\vwe.ico and rebuilds
|
||||
resources.pri — run after changing the icon artwork.
|
||||
|
||||
The shell resolves the manifest's Square44x44Logo through the package
|
||||
resource index; without resources.pri every icon lookup fails and the
|
||||
Start menu / taskbar show a generic icon. After regenerating, bump the
|
||||
Version in AppxManifest.xml (the shell's MrtCache is keyed by package
|
||||
full name and serves stale lookups otherwise) and re-register with
|
||||
Register-vRIO.ps1.
|
||||
|
||||
.PARAMETER MakePri
|
||||
Path to makepri.exe. Auto-detected from the Windows SDK if installed;
|
||||
otherwise extract it from the Microsoft.Windows.SDK.BuildTools NuGet
|
||||
package (it is a zip: bin\<ver>\x64\makepri.exe).
|
||||
#>
|
||||
param([string]$MakePri)
|
||||
|
||||
$ErrorActionPreference = 'Stop'
|
||||
Add-Type -AssemblyName System.Drawing
|
||||
|
||||
if (-not $MakePri) {
|
||||
$MakePri = Get-ChildItem 'C:\Program Files (x86)\Windows Kits\10\bin' -Recurse -Filter makepri.exe -ErrorAction SilentlyContinue |
|
||||
Where-Object FullName -like '*\x64\*' | Select-Object -First 1 -ExpandProperty FullName
|
||||
if (-not $MakePri) {
|
||||
throw 'makepri.exe not found — install the Windows SDK or pass -MakePri (see help).'
|
||||
}
|
||||
}
|
||||
|
||||
$assets = Join-Path $PSScriptRoot 'Assets'
|
||||
$ico = New-Object System.Drawing.Icon((Join-Path $PSScriptRoot '..\src\VRio.App\vwe.ico'), 32, 32)
|
||||
$src = $ico.ToBitmap()
|
||||
|
||||
function Save-Png([int]$canvas, [int]$content, [string]$name) {
|
||||
$bmp = New-Object System.Drawing.Bitmap($canvas, $canvas)
|
||||
$g = [System.Drawing.Graphics]::FromImage($bmp)
|
||||
$g.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic
|
||||
$g.PixelOffsetMode = [System.Drawing.Drawing2D.PixelOffsetMode]::HighQuality
|
||||
$off = [int](($canvas - $content) / 2)
|
||||
$g.DrawImage($src, $off, $off, $content, $content)
|
||||
$g.Dispose()
|
||||
$bmp.Save((Join-Path $assets $name), [System.Drawing.Imaging.ImageFormat]::Png)
|
||||
$bmp.Dispose()
|
||||
Write-Host " $name"
|
||||
}
|
||||
|
||||
Save-Png 44 44 'logo44.png'
|
||||
Save-Png 150 96 'logo150.png' # medium tile: 3x upscale centered, crisper than full-bleed
|
||||
foreach ($ts in 16, 24, 32, 48) {
|
||||
# targetsize / altform-unplated variants are found by naming convention;
|
||||
# unplated is what the Win11 taskbar prefers.
|
||||
Save-Png $ts $ts "logo44.targetsize-$ts.png"
|
||||
Save-Png $ts $ts "logo44.targetsize-${ts}_altform-unplated.png"
|
||||
}
|
||||
$src.Dispose(); $ico.Dispose()
|
||||
|
||||
$cf = Join-Path $env:TEMP 'vrio-priconfig.xml'
|
||||
& $MakePri createconfig /cf $cf /dq en-US /o | Out-Null
|
||||
& $MakePri new /pr $PSScriptRoot /cf $cf /mn (Join-Path $PSScriptRoot 'AppxManifest.xml') /of (Join-Path $PSScriptRoot 'resources.pri') /o | Out-Null
|
||||
Remove-Item $cf
|
||||
Write-Host 'resources.pri rebuilt. Now bump Version in AppxManifest.xml and re-register.'
|
||||
@@ -0,0 +1 @@
|
||||
Public folder for the com.microsoft.windows.lighting app extension (required by the manifest schema).
|
||||
@@ -0,0 +1,60 @@
|
||||
<#
|
||||
.SYNOPSIS
|
||||
Grants VRio.App.exe package identity by registering the sparse package
|
||||
(pkg\AppxManifest.xml) with the exe's folder as the external location.
|
||||
|
||||
Identity is what lets Windows Dynamic Lighting offer vRIO under
|
||||
Settings > Personalization > Dynamic Lighting > "Background light control",
|
||||
so the keyboard lamp mirror keeps working while the game has focus.
|
||||
|
||||
Unsigned registration requires Developer Mode
|
||||
(Settings > System > For developers).
|
||||
|
||||
.PARAMETER ExePath
|
||||
Folder containing VRio.App.exe. Defaults to the repo's Release output;
|
||||
for a deployed zip, pass the extracted VRio folder.
|
||||
|
||||
.PARAMETER Unregister
|
||||
Remove the registration instead.
|
||||
#>
|
||||
param(
|
||||
[string]$ExePath = (Join-Path $PSScriptRoot '..\src\VRio.App\bin\Release\net48'),
|
||||
[switch]$Unregister
|
||||
)
|
||||
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$packageName = 'VWE.vRIO'
|
||||
|
||||
$existing = Get-AppxPackage -Name $packageName -ErrorAction SilentlyContinue
|
||||
if ($existing) {
|
||||
Write-Host "Removing existing registration $($existing.PackageFullName)..."
|
||||
Remove-AppxPackage -Package $existing.PackageFullName
|
||||
}
|
||||
if ($Unregister) {
|
||||
Write-Host 'Unregistered.'
|
||||
return
|
||||
}
|
||||
|
||||
$exe = Join-Path $ExePath 'VRio.App.exe'
|
||||
if (-not (Test-Path $exe)) { throw "VRio.App.exe not found in '$ExePath'" }
|
||||
$manifest = Join-Path $PSScriptRoot 'AppxManifest.xml'
|
||||
|
||||
# With AllowExternalContent the shell resolves the manifest's logo assets
|
||||
# against the EXTERNAL location, not the manifest's folder — the Start/taskbar
|
||||
# icon only shows if Assets\ and resources.pri sit next to the exe.
|
||||
$assetDir = New-Item -ItemType Directory -Force (Join-Path $ExePath 'Assets')
|
||||
Copy-Item (Join-Path $PSScriptRoot 'Assets\*') $assetDir -Force
|
||||
Copy-Item (Join-Path $PSScriptRoot 'resources.pri') $ExePath -Force
|
||||
|
||||
Add-AppxPackage -Register $manifest -ExternalLocation (Resolve-Path $ExePath).Path
|
||||
$family = (Get-AppxPackage -Name $packageName).PackageFamilyName
|
||||
Write-Host "Registered $packageName with external location '$ExePath'."
|
||||
Write-Host ''
|
||||
Write-Host 'IMPORTANT: identity is granted through shell activation only. Launch vRIO'
|
||||
Write-Host 'from the Start menu entry ("vRIO") or via:'
|
||||
Write-Host " explorer shell:AppsFolder\$family!vRIO"
|
||||
Write-Host 'Double-clicking VRio.App.exe runs it WITHOUT identity (lamp mirror then'
|
||||
Write-Host 'works only while vRIO has focus).'
|
||||
Write-Host ''
|
||||
Write-Host 'Then enable the lamp mirror and pick vRIO under Settings > Personalization >'
|
||||
Write-Host 'Dynamic Lighting > Background light control.'
|
||||
Binary file not shown.
@@ -0,0 +1,104 @@
|
||||
using VPlasma.Core.Device;
|
||||
|
||||
namespace VPlasma.App;
|
||||
|
||||
/// <summary>
|
||||
/// vPLASMA main window: just the plasma glass, sized to the display. The
|
||||
/// device end is hardwired to <see cref="PortName"/> (the plasma side of the
|
||||
/// second com0com pair) and opened automatically — a retry timer keeps
|
||||
/// trying while the port is missing or busy, and reopens it if it dies. The
|
||||
/// title bar carries the port status; double-clicking the glass cycles the
|
||||
/// self-test pages (banner, charset, graphics) through the wire parser, and
|
||||
/// a right-click resets the display to its power-on state.
|
||||
/// </summary>
|
||||
internal sealed class MainForm : Form
|
||||
{
|
||||
/// <summary>The plasma's fixed port: the device end of the COM2 pair.</summary>
|
||||
private const string PortName = "COM12";
|
||||
|
||||
private readonly VPlasmaDevice _device = new();
|
||||
private readonly VPlasmaSerialService _service;
|
||||
private readonly PlasmaCanvas _canvas = new();
|
||||
|
||||
private readonly System.Windows.Forms.Timer _reconnectTimer = new() { Interval = 3000 };
|
||||
private int _selfTestPage;
|
||||
|
||||
public MainForm()
|
||||
{
|
||||
Icon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
|
||||
FormBorderStyle = FormBorderStyle.FixedSingle; // the glass is a fixed-size device
|
||||
MaximizeBox = false;
|
||||
ClientSize = _canvas.Size;
|
||||
StartPosition = FormStartPosition.CenterScreen;
|
||||
|
||||
_service = new VPlasmaSerialService(_device);
|
||||
|
||||
_canvas.Location = new Point(0, 0);
|
||||
Controls.Add(_canvas);
|
||||
|
||||
// Device / service events arrive on the serial reader thread; marshal to the UI.
|
||||
_device.Updated += () => RunOnUi(() => _canvas.UpdateFrom(_device));
|
||||
_service.ConnectionChanged += _ => RunOnUi(UpdateTitle);
|
||||
|
||||
_canvas.DoubleClick += (_, _) => RunSelfTest();
|
||||
_canvas.MouseClick += (_, e) =>
|
||||
{
|
||||
if (e.Button == MouseButtons.Right)
|
||||
_device.Reset();
|
||||
};
|
||||
|
||||
// Open at startup, retry while closed (port missing/busy, host restarts).
|
||||
_reconnectTimer.Tick += (_, _) => EnsureOpen();
|
||||
_reconnectTimer.Start();
|
||||
|
||||
FormClosed += (_, _) =>
|
||||
{
|
||||
_reconnectTimer.Dispose();
|
||||
_service.Dispose();
|
||||
};
|
||||
|
||||
_canvas.UpdateFrom(_device);
|
||||
EnsureOpen();
|
||||
}
|
||||
|
||||
private void EnsureOpen()
|
||||
{
|
||||
if (_service.IsOpen)
|
||||
return;
|
||||
|
||||
try
|
||||
{
|
||||
_service.Open(PortName);
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidOperationException or ArgumentException)
|
||||
{
|
||||
UpdateTitle(); // stays closed; the timer tries again
|
||||
}
|
||||
}
|
||||
|
||||
private void UpdateTitle()
|
||||
{
|
||||
// ProductVersion carries the git stamp (see StampGitVersion in the csproj).
|
||||
string status = _service.IsOpen
|
||||
? $"{PortName} @ 9600 8N1"
|
||||
: $"{PortName} unavailable — retrying";
|
||||
Text = $"vPLASMA v{Application.ProductVersion} — {status}";
|
||||
}
|
||||
|
||||
private void RunSelfTest()
|
||||
{
|
||||
byte[] bytes = PlasmaSelfTest.BuildPage(_selfTestPage);
|
||||
_device.OnReceived(bytes, bytes.Length);
|
||||
_selfTestPage = (_selfTestPage + 1) % PlasmaSelfTest.PageCount;
|
||||
}
|
||||
|
||||
private void RunOnUi(Action action)
|
||||
{
|
||||
if (IsDisposed || Disposing)
|
||||
return;
|
||||
if (InvokeRequired)
|
||||
BeginInvoke(action);
|
||||
else
|
||||
action();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
using VPlasma.Core.Device;
|
||||
|
||||
namespace VPlasma.App;
|
||||
|
||||
/// <summary>
|
||||
/// The glass: renders the device's 128×32 frame as a dot-matrix panel —
|
||||
/// neon-orange plasma dots on dark glass, with a faint unlit grid so the
|
||||
/// matrix reads as hardware. Half-intensity dots draw dimmer; flashing dots
|
||||
/// and the flashing cursor blink on a shared phase timer that only runs
|
||||
/// invalidations while something on screen actually blinks.
|
||||
/// </summary>
|
||||
internal sealed class PlasmaCanvas : Control
|
||||
{
|
||||
private const int DotPitch = 5; // 4 px dot + 1 px gap → a 640×160 dot field
|
||||
private const int DotSize = 4;
|
||||
private const int Bezel = 4;
|
||||
|
||||
private static readonly Color BezelColor = Color.FromArgb(20, 18, 16);
|
||||
private static readonly Color GlassColor = Color.FromArgb(26, 14, 6);
|
||||
private static readonly Color UnlitDot = Color.FromArgb(46, 24, 10);
|
||||
private static readonly Color LitDot = Color.FromArgb(255, 106, 26);
|
||||
private static readonly Color HalfDot = Color.FromArgb(150, 62, 15);
|
||||
|
||||
private readonly byte[] _frame = new byte[VPlasmaDevice.Width * VPlasmaDevice.Height];
|
||||
private readonly System.Windows.Forms.Timer _blinkTimer = new() { Interval = 266 };
|
||||
private bool _blinkPhase = true;
|
||||
private bool _anythingBlinks;
|
||||
|
||||
private VPlasmaDevice.Point _cursor;
|
||||
private PlasmaCursorMode _cursorMode;
|
||||
private int _cellWidth = 6, _cellHeight = 8;
|
||||
|
||||
public PlasmaCanvas()
|
||||
{
|
||||
SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint |
|
||||
ControlStyles.OptimizedDoubleBuffer | ControlStyles.FixedWidth |
|
||||
ControlStyles.FixedHeight, true);
|
||||
Size = new Size(
|
||||
VPlasmaDevice.Width * DotPitch + 2 * Bezel,
|
||||
VPlasmaDevice.Height * DotPitch + 2 * Bezel);
|
||||
BackColor = BezelColor;
|
||||
|
||||
_blinkTimer.Tick += (_, _) =>
|
||||
{
|
||||
_blinkPhase = !_blinkPhase;
|
||||
if (_anythingBlinks)
|
||||
Invalidate();
|
||||
};
|
||||
_blinkTimer.Start();
|
||||
}
|
||||
|
||||
/// <summary>Snapshot the device state and repaint. Call on the UI thread.</summary>
|
||||
public void UpdateFrom(VPlasmaDevice device)
|
||||
{
|
||||
device.CopyFrame(_frame);
|
||||
_cursor = device.CursorCell;
|
||||
_cursorMode = device.CursorMode;
|
||||
_cellWidth = device.CellWidth;
|
||||
_cellHeight = device.CellHeight;
|
||||
|
||||
_anythingBlinks = _cursorMode == PlasmaCursorMode.Flashing;
|
||||
if (!_anythingBlinks)
|
||||
foreach (byte dot in _frame)
|
||||
if ((dot & VPlasmaDevice.PixelFlash) != 0)
|
||||
{
|
||||
_anythingBlinks = true;
|
||||
break;
|
||||
}
|
||||
|
||||
Invalidate();
|
||||
}
|
||||
|
||||
protected override void OnPaint(PaintEventArgs e)
|
||||
{
|
||||
Graphics g = e.Graphics;
|
||||
g.Clear(BezelColor);
|
||||
|
||||
using (var glass = new SolidBrush(GlassColor))
|
||||
g.FillRectangle(glass, Bezel - 4, Bezel - 4,
|
||||
VPlasmaDevice.Width * DotPitch + 7, VPlasmaDevice.Height * DotPitch + 7);
|
||||
|
||||
using var unlit = new SolidBrush(UnlitDot);
|
||||
using var lit = new SolidBrush(LitDot);
|
||||
using var half = new SolidBrush(HalfDot);
|
||||
|
||||
for (int y = 0; y < VPlasmaDevice.Height; ++y)
|
||||
{
|
||||
int rowOffset = y * VPlasmaDevice.Width;
|
||||
int py = Bezel + y * DotPitch;
|
||||
for (int x = 0; x < VPlasmaDevice.Width; ++x)
|
||||
{
|
||||
byte dot = _frame[rowOffset + x];
|
||||
Brush brush = unlit;
|
||||
if ((dot & VPlasmaDevice.PixelLit) != 0
|
||||
&& ((dot & VPlasmaDevice.PixelFlash) == 0 || _blinkPhase))
|
||||
{
|
||||
brush = (dot & VPlasmaDevice.PixelHalf) != 0 ? half : lit;
|
||||
}
|
||||
g.FillRectangle(brush, Bezel + x * DotPitch, py, DotSize, DotSize);
|
||||
}
|
||||
}
|
||||
|
||||
// Underline cursor on the bottom dot-row of its cell.
|
||||
if (_cursorMode == PlasmaCursorMode.Steady
|
||||
|| (_cursorMode == PlasmaCursorMode.Flashing && _blinkPhase))
|
||||
{
|
||||
int cx = _cursor.Col * _cellWidth;
|
||||
int cy = _cursor.Row * _cellHeight + _cellHeight - 1;
|
||||
if (cy < VPlasmaDevice.Height)
|
||||
for (int i = 0; i < _cellWidth && cx + i < VPlasmaDevice.Width; ++i)
|
||||
g.FillRectangle(lit, Bezel + (cx + i) * DotPitch, Bezel + cy * DotPitch, DotSize, DotSize);
|
||||
}
|
||||
}
|
||||
|
||||
protected override void Dispose(bool disposing)
|
||||
{
|
||||
if (disposing)
|
||||
_blinkTimer.Dispose();
|
||||
base.Dispose(disposing);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
namespace VPlasma.App;
|
||||
|
||||
internal static class Program
|
||||
{
|
||||
[STAThread]
|
||||
private static void Main()
|
||||
{
|
||||
Application.EnableVisualStyles();
|
||||
Application.SetCompatibleTextRenderingDefault(false);
|
||||
Application.Run(new MainForm());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<OutputType>WinExe</OutputType>
|
||||
<TargetFramework>net48</TargetFramework>
|
||||
<Nullable>enable</Nullable>
|
||||
<UseWindowsForms>true</UseWindowsForms>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<LangVersion>latest</LangVersion>
|
||||
<ApplicationManifest>app.manifest</ApplicationManifest>
|
||||
<ApplicationIcon>vwe.ico</ApplicationIcon>
|
||||
<AssemblyTitle>vPLASMA — Virtual plasma display</AssemblyTitle>
|
||||
<!-- StampGitVersion already puts the sha in InformationalVersion; stop the
|
||||
SDK appending "+fullsha" on top of it. -->
|
||||
<IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\VPlasma.Core\VPlasma.Core.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
<!-- Stamp commit date + short sha into InformationalVersion; the window
|
||||
title shows it (Application.ProductVersion) so a running build can be
|
||||
matched to its vYYYY.MM.DD release tag at a glance. Falls back to the
|
||||
default 1.0.0 when git isn't available. -->
|
||||
<Target Name="StampGitVersion" BeforeTargets="GetAssemblyVersion" Condition="'$(DesignTimeBuild)' != 'true'">
|
||||
<!-- %%cs survives cmd's percent expansion as %cs: committer date, YYYY-MM-DD. -->
|
||||
<Exec Command="git -C "$(MSBuildProjectDirectory)" log -1 --format=%%cs"
|
||||
ConsoleToMSBuild="true" StandardOutputImportance="low" IgnoreExitCode="true" ContinueOnError="true">
|
||||
<Output TaskParameter="ConsoleOutput" PropertyName="GitCommitDate" />
|
||||
<Output TaskParameter="ExitCode" PropertyName="GitDateExitCode" />
|
||||
</Exec>
|
||||
<!-- The exclude flag keeps describe off the release tags: always the short
|
||||
sha, with a "dirty" suffix when the working tree has local edits. -->
|
||||
<Exec Command="git -C "$(MSBuildProjectDirectory)" describe --always --dirty --exclude=*"
|
||||
ConsoleToMSBuild="true" StandardOutputImportance="low" IgnoreExitCode="true" ContinueOnError="true">
|
||||
<Output TaskParameter="ConsoleOutput" PropertyName="GitShortSha" />
|
||||
</Exec>
|
||||
<PropertyGroup Condition="'$(GitDateExitCode)' == '0' And '$(GitShortSha)' != ''">
|
||||
<InformationalVersion>$(GitCommitDate.Trim().Replace('-', '.')) ($(GitShortSha))</InformationalVersion>
|
||||
</PropertyGroup>
|
||||
</Target>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="PolySharp" Version="1.14.1">
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
</PackageReference>
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,20 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
|
||||
<assemblyIdentity version="1.0.0.0" name="VPlasma.App" type="win32" />
|
||||
|
||||
<!-- Run as the invoking user: vPLASMA only opens a COM port and draws a window. -->
|
||||
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
|
||||
<security>
|
||||
<requestedPrivileges>
|
||||
<requestedExecutionLevel level="asInvoker" uiAccess="false" />
|
||||
</requestedPrivileges>
|
||||
</security>
|
||||
</trustInfo>
|
||||
|
||||
<!-- Declare Windows 10/11 compatibility for correct DPI / API behavior. -->
|
||||
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
|
||||
<application>
|
||||
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" /> <!-- Windows 10/11 -->
|
||||
</application>
|
||||
</compatibility>
|
||||
</assembly>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 2.9 KiB |
@@ -0,0 +1,130 @@
|
||||
namespace VPlasma.Core.Device;
|
||||
|
||||
/// <summary>
|
||||
/// The display's character generator: a classic 5×7 dot-matrix font for
|
||||
/// ASCII 0x20..0x7E, stored column-major (5 column bytes per glyph, bit 0 =
|
||||
/// top row) — the layout every KS0108-era controller used. The real panel's
|
||||
/// ROM glyphs are lost with the hardware; this is the standard public-domain
|
||||
/// 5×7 set, which is what such panels shipped with. Codes outside the range
|
||||
/// render as a solid block so stream corruption is visible on the glass.
|
||||
/// </summary>
|
||||
public static class PlasmaFont
|
||||
{
|
||||
public const int GlyphWidth = 5;
|
||||
public const int GlyphHeight = 7;
|
||||
public const byte First = 0x20;
|
||||
public const byte Last = 0x7E;
|
||||
|
||||
/// <summary>
|
||||
/// Column bits for <paramref name="code"/>'s glyph. Bit r of
|
||||
/// <c>result[c]</c> is the dot at column c, row r (row 0 at the top).
|
||||
/// </summary>
|
||||
public static void GetColumns(byte code, Span<byte> columns)
|
||||
{
|
||||
if (code < First || code > Last)
|
||||
{
|
||||
columns.Slice(0, GlyphWidth).Fill(0x7F); // solid block
|
||||
return;
|
||||
}
|
||||
Glyphs.AsSpan((code - First) * GlyphWidth, GlyphWidth).CopyTo(columns);
|
||||
}
|
||||
|
||||
private static readonly byte[] Glyphs =
|
||||
{
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, // 0x20 ' '
|
||||
0x00, 0x00, 0x5F, 0x00, 0x00, // 0x21 '!'
|
||||
0x00, 0x07, 0x00, 0x07, 0x00, // 0x22 '"'
|
||||
0x14, 0x7F, 0x14, 0x7F, 0x14, // 0x23 '#'
|
||||
0x24, 0x2A, 0x7F, 0x2A, 0x12, // 0x24 '$'
|
||||
0x23, 0x13, 0x08, 0x64, 0x62, // 0x25 '%'
|
||||
0x36, 0x49, 0x55, 0x22, 0x50, // 0x26 '&'
|
||||
0x00, 0x05, 0x03, 0x00, 0x00, // 0x27 '''
|
||||
0x00, 0x1C, 0x22, 0x41, 0x00, // 0x28 '('
|
||||
0x00, 0x41, 0x22, 0x1C, 0x00, // 0x29 ')'
|
||||
0x08, 0x2A, 0x1C, 0x2A, 0x08, // 0x2A '*'
|
||||
0x08, 0x08, 0x3E, 0x08, 0x08, // 0x2B '+'
|
||||
0x00, 0x50, 0x30, 0x00, 0x00, // 0x2C ','
|
||||
0x08, 0x08, 0x08, 0x08, 0x08, // 0x2D '-'
|
||||
0x00, 0x60, 0x60, 0x00, 0x00, // 0x2E '.'
|
||||
0x20, 0x10, 0x08, 0x04, 0x02, // 0x2F '/'
|
||||
0x3E, 0x51, 0x49, 0x45, 0x3E, // 0x30 '0'
|
||||
0x00, 0x42, 0x7F, 0x40, 0x00, // 0x31 '1'
|
||||
0x42, 0x61, 0x51, 0x49, 0x46, // 0x32 '2'
|
||||
0x21, 0x41, 0x45, 0x4B, 0x31, // 0x33 '3'
|
||||
0x18, 0x14, 0x12, 0x7F, 0x10, // 0x34 '4'
|
||||
0x27, 0x45, 0x45, 0x45, 0x39, // 0x35 '5'
|
||||
0x3C, 0x4A, 0x49, 0x49, 0x30, // 0x36 '6'
|
||||
0x01, 0x71, 0x09, 0x05, 0x03, // 0x37 '7'
|
||||
0x36, 0x49, 0x49, 0x49, 0x36, // 0x38 '8'
|
||||
0x06, 0x49, 0x49, 0x29, 0x1E, // 0x39 '9'
|
||||
0x00, 0x36, 0x36, 0x00, 0x00, // 0x3A ':'
|
||||
0x00, 0x56, 0x36, 0x00, 0x00, // 0x3B ';'
|
||||
0x00, 0x08, 0x14, 0x22, 0x41, // 0x3C '<'
|
||||
0x14, 0x14, 0x14, 0x14, 0x14, // 0x3D '='
|
||||
0x41, 0x22, 0x14, 0x08, 0x00, // 0x3E '>'
|
||||
0x02, 0x01, 0x51, 0x09, 0x06, // 0x3F '?'
|
||||
0x32, 0x49, 0x79, 0x41, 0x3E, // 0x40 '@'
|
||||
0x7E, 0x11, 0x11, 0x11, 0x7E, // 0x41 'A'
|
||||
0x7F, 0x49, 0x49, 0x49, 0x36, // 0x42 'B'
|
||||
0x3E, 0x41, 0x41, 0x41, 0x22, // 0x43 'C'
|
||||
0x7F, 0x41, 0x41, 0x22, 0x1C, // 0x44 'D'
|
||||
0x7F, 0x49, 0x49, 0x49, 0x41, // 0x45 'E'
|
||||
0x7F, 0x09, 0x09, 0x09, 0x01, // 0x46 'F'
|
||||
0x3E, 0x41, 0x49, 0x49, 0x7A, // 0x47 'G'
|
||||
0x7F, 0x08, 0x08, 0x08, 0x7F, // 0x48 'H'
|
||||
0x00, 0x41, 0x7F, 0x41, 0x00, // 0x49 'I'
|
||||
0x20, 0x40, 0x41, 0x3F, 0x01, // 0x4A 'J'
|
||||
0x7F, 0x08, 0x14, 0x22, 0x41, // 0x4B 'K'
|
||||
0x7F, 0x40, 0x40, 0x40, 0x40, // 0x4C 'L'
|
||||
0x7F, 0x02, 0x0C, 0x02, 0x7F, // 0x4D 'M'
|
||||
0x7F, 0x04, 0x08, 0x10, 0x7F, // 0x4E 'N'
|
||||
0x3E, 0x41, 0x41, 0x41, 0x3E, // 0x4F 'O'
|
||||
0x7F, 0x09, 0x09, 0x09, 0x06, // 0x50 'P'
|
||||
0x3E, 0x41, 0x51, 0x21, 0x5E, // 0x51 'Q'
|
||||
0x7F, 0x09, 0x19, 0x29, 0x46, // 0x52 'R'
|
||||
0x46, 0x49, 0x49, 0x49, 0x31, // 0x53 'S'
|
||||
0x01, 0x01, 0x7F, 0x01, 0x01, // 0x54 'T'
|
||||
0x3F, 0x40, 0x40, 0x40, 0x3F, // 0x55 'U'
|
||||
0x1F, 0x20, 0x40, 0x20, 0x1F, // 0x56 'V'
|
||||
0x3F, 0x40, 0x38, 0x40, 0x3F, // 0x57 'W'
|
||||
0x63, 0x14, 0x08, 0x14, 0x63, // 0x58 'X'
|
||||
0x07, 0x08, 0x70, 0x08, 0x07, // 0x59 'Y'
|
||||
0x61, 0x51, 0x49, 0x45, 0x43, // 0x5A 'Z'
|
||||
0x00, 0x7F, 0x41, 0x41, 0x00, // 0x5B '['
|
||||
0x02, 0x04, 0x08, 0x10, 0x20, // 0x5C '\'
|
||||
0x00, 0x41, 0x41, 0x7F, 0x00, // 0x5D ']'
|
||||
0x04, 0x02, 0x01, 0x02, 0x04, // 0x5E '^'
|
||||
0x40, 0x40, 0x40, 0x40, 0x40, // 0x5F '_'
|
||||
0x00, 0x01, 0x02, 0x04, 0x00, // 0x60 '`'
|
||||
0x20, 0x54, 0x54, 0x54, 0x78, // 0x61 'a'
|
||||
0x7F, 0x48, 0x44, 0x44, 0x38, // 0x62 'b'
|
||||
0x38, 0x44, 0x44, 0x44, 0x20, // 0x63 'c'
|
||||
0x38, 0x44, 0x44, 0x48, 0x7F, // 0x64 'd'
|
||||
0x38, 0x54, 0x54, 0x54, 0x18, // 0x65 'e'
|
||||
0x08, 0x7E, 0x09, 0x01, 0x02, // 0x66 'f'
|
||||
0x0C, 0x52, 0x52, 0x52, 0x3E, // 0x67 'g'
|
||||
0x7F, 0x08, 0x04, 0x04, 0x78, // 0x68 'h'
|
||||
0x00, 0x44, 0x7D, 0x40, 0x00, // 0x69 'i'
|
||||
0x20, 0x40, 0x44, 0x3D, 0x00, // 0x6A 'j'
|
||||
0x7F, 0x10, 0x28, 0x44, 0x00, // 0x6B 'k'
|
||||
0x00, 0x41, 0x7F, 0x40, 0x00, // 0x6C 'l'
|
||||
0x7C, 0x04, 0x18, 0x04, 0x78, // 0x6D 'm'
|
||||
0x7C, 0x08, 0x04, 0x04, 0x78, // 0x6E 'n'
|
||||
0x38, 0x44, 0x44, 0x44, 0x38, // 0x6F 'o'
|
||||
0x7C, 0x14, 0x14, 0x14, 0x08, // 0x70 'p'
|
||||
0x08, 0x14, 0x14, 0x14, 0x7C, // 0x71 'q'
|
||||
0x7C, 0x08, 0x04, 0x04, 0x08, // 0x72 'r'
|
||||
0x48, 0x54, 0x54, 0x54, 0x20, // 0x73 's'
|
||||
0x04, 0x3F, 0x44, 0x40, 0x20, // 0x74 't'
|
||||
0x3C, 0x40, 0x40, 0x20, 0x7C, // 0x75 'u'
|
||||
0x1C, 0x20, 0x40, 0x20, 0x1C, // 0x76 'v'
|
||||
0x3C, 0x40, 0x30, 0x40, 0x3C, // 0x77 'w'
|
||||
0x44, 0x28, 0x10, 0x28, 0x44, // 0x78 'x'
|
||||
0x0C, 0x50, 0x50, 0x50, 0x3C, // 0x79 'y'
|
||||
0x44, 0x64, 0x54, 0x4C, 0x44, // 0x7A 'z'
|
||||
0x00, 0x08, 0x36, 0x41, 0x00, // 0x7B '{'
|
||||
0x00, 0x00, 0x7F, 0x00, 0x00, // 0x7C '|'
|
||||
0x00, 0x41, 0x36, 0x08, 0x00, // 0x7D '}'
|
||||
0x08, 0x04, 0x08, 0x10, 0x08, // 0x7E '~'
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
using VPlasma.Core.Protocol;
|
||||
|
||||
namespace VPlasma.Core.Device;
|
||||
|
||||
/// <summary>
|
||||
/// Canned wire streams for the UI's <i>Self test</i> button: each page is a
|
||||
/// byte sequence exactly as a host would send it over COM2, fed through the
|
||||
/// same parser as live traffic — so the button doubles as an end-to-end
|
||||
/// exercise of the command set without a host attached.
|
||||
/// </summary>
|
||||
public static class PlasmaSelfTest
|
||||
{
|
||||
public const int PageCount = 3;
|
||||
|
||||
/// <summary>The wire bytes for self-test page <paramref name="page"/> (0-based).</summary>
|
||||
public static byte[] BuildPage(int page) => page switch
|
||||
{
|
||||
0 => BuildBanner(),
|
||||
1 => BuildCharset(),
|
||||
2 => BuildGraphics(),
|
||||
_ => throw new ArgumentOutOfRangeException(nameof(page)),
|
||||
};
|
||||
|
||||
private static void Esc(List<byte> b, byte cmd, params byte[] operands)
|
||||
{
|
||||
b.Add(PlasmaProtocol.Esc);
|
||||
b.Add(cmd);
|
||||
b.AddRange(operands);
|
||||
}
|
||||
|
||||
private static void Text(List<byte> b, string s)
|
||||
{
|
||||
foreach (char c in s)
|
||||
b.Add((byte)c);
|
||||
}
|
||||
|
||||
/// <summary>Big-font banner over small-font attribute samples.</summary>
|
||||
private static byte[] BuildBanner()
|
||||
{
|
||||
var b = new List<byte>();
|
||||
Esc(b, PlasmaProtocol.CmdClearScreen);
|
||||
Esc(b, PlasmaProtocol.CmdCursorMode, 0x00);
|
||||
|
||||
Esc(b, PlasmaProtocol.CmdFontSelect, 0x04); // 12×16 cells: 10 × 2
|
||||
Text(b, " vPLASMA");
|
||||
|
||||
Esc(b, PlasmaProtocol.CmdFontSelect, 0x00); // 6×8 cells: 21 × 4
|
||||
Esc(b, PlasmaProtocol.CmdHomeCursor);
|
||||
b.Add(PlasmaProtocol.LineFeed);
|
||||
b.Add(PlasmaProtocol.LineFeed);
|
||||
Text(b, "128x32 PLASMA DISPLAY"); // exactly one 21-cell row
|
||||
|
||||
Esc(b, PlasmaProtocol.CmdAttributes, 1); Text(b, "HALF ");
|
||||
Esc(b, PlasmaProtocol.CmdAttributes, 2); Text(b, "UNDER ");
|
||||
Esc(b, PlasmaProtocol.CmdAttributes, 3); Text(b, "REV");
|
||||
Esc(b, PlasmaProtocol.CmdAttributes, 4); Text(b, " FLASH");
|
||||
Esc(b, PlasmaProtocol.CmdAttributes, PlasmaProtocol.OperandDefault);
|
||||
return b.ToArray();
|
||||
}
|
||||
|
||||
/// <summary>The printable set 0x20..0x6F — a full 21×4 grid, minus a cell.</summary>
|
||||
private static byte[] BuildCharset()
|
||||
{
|
||||
var b = new List<byte>();
|
||||
Esc(b, PlasmaProtocol.CmdClearScreen);
|
||||
Esc(b, PlasmaProtocol.CmdCursorMode, 0x00);
|
||||
for (byte c = 0x20; c <= 0x6F; ++c)
|
||||
b.Add(c);
|
||||
return b.ToArray();
|
||||
}
|
||||
|
||||
/// <summary>The rest of the charset plus an ESC P pattern block.</summary>
|
||||
private static byte[] BuildGraphics()
|
||||
{
|
||||
var b = new List<byte>();
|
||||
Esc(b, PlasmaProtocol.CmdClearScreen);
|
||||
Esc(b, PlasmaProtocol.CmdCursorMode, 0x00);
|
||||
for (byte c = 0x70; c <= 0x7E; ++c)
|
||||
b.Add(c);
|
||||
|
||||
// A framed checkerboard sent the way the game sends everything:
|
||||
// full-width ESC P rows (screen 0, xbyte 0, 16 bytes, 1 row each).
|
||||
for (int y = 10; y < VPlasmaDevice.Height; ++y)
|
||||
{
|
||||
Esc(b, PlasmaProtocol.CmdGraphicsWrite,
|
||||
0, (byte)y, 0, VPlasmaDevice.WidthBytes, 1);
|
||||
bool edge = y is 10 or VPlasmaDevice.Height - 1;
|
||||
for (int x = 0; x < VPlasmaDevice.WidthBytes; ++x)
|
||||
{
|
||||
byte fill = edge ? (byte)0xFF : (y & 2) == 0 ? (byte)0xAA : (byte)0x55;
|
||||
if (!edge)
|
||||
{
|
||||
if (x == 0) fill |= 0x80; // left frame edge
|
||||
if (x == VPlasmaDevice.WidthBytes - 1) fill |= 0x01; // right frame edge
|
||||
}
|
||||
b.Add(fill);
|
||||
}
|
||||
}
|
||||
return b.ToArray();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,447 @@
|
||||
using VPlasma.Core.Protocol;
|
||||
|
||||
namespace VPlasma.Core.Device;
|
||||
|
||||
/// <summary>How the text cursor is shown (set with <c>ESC G</c>).</summary>
|
||||
public enum PlasmaCursorMode
|
||||
{
|
||||
Hidden,
|
||||
Steady,
|
||||
Flashing,
|
||||
}
|
||||
|
||||
/// <summary>Text rendering attributes (set with <c>ESC H</c>).</summary>
|
||||
[Flags]
|
||||
public enum PlasmaAttributes : byte
|
||||
{
|
||||
None = 0,
|
||||
HalfIntensity = 1,
|
||||
Underline = 2,
|
||||
Reverse = 4,
|
||||
Flash = 8,
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The plasma display proper: a 128×32 1bpp frame plus the text-mode state
|
||||
/// (cursor, font, attributes), driven by the byte stream a host writes to
|
||||
/// COM2. Feed raw wire bytes to <see cref="OnReceived"/>; the parser is a
|
||||
/// state machine, so commands may arrive split across any chunk boundaries.
|
||||
///
|
||||
/// <para>Pixels carry flags rather than a plain bit: graphics writes set
|
||||
/// full-intensity dots, while text can stamp half-intensity or flashing dots
|
||||
/// (<c>ESC H</c>); the UI renders <see cref="PixelHalf"/> dimmer and blinks
|
||||
/// <see cref="PixelFlash"/>. The command set itself is documented on
|
||||
/// <see cref="PlasmaProtocol"/>.</para>
|
||||
///
|
||||
/// <para>Grid geometry: fonts 0–3 are the 5×7 set in a 6×8 cell (21 columns
|
||||
/// × 4 rows), fonts 4–7 the same glyphs doubled into a 12×16 cell
|
||||
/// (10 × 2). Which of the eight slots the real panel mapped to which face is
|
||||
/// lost with the hardware; two sizes cover what the surviving software
|
||||
/// exercises.</para>
|
||||
///
|
||||
/// <para>Thread-safe: the serial reader feeds bytes while the UI snapshots
|
||||
/// frames. Events are raised outside the lock, on the caller's thread.</para>
|
||||
/// </summary>
|
||||
public sealed class VPlasmaDevice
|
||||
{
|
||||
public const int Width = 128;
|
||||
public const int Height = 32;
|
||||
public const int WidthBytes = Width / 8;
|
||||
|
||||
// Per-pixel flag bits in the frame buffer.
|
||||
public const byte PixelLit = 0x01;
|
||||
public const byte PixelHalf = 0x02;
|
||||
public const byte PixelFlash = 0x04;
|
||||
|
||||
private readonly object _sync = new();
|
||||
private readonly byte[] _pixels = new byte[Width * Height];
|
||||
|
||||
// ---- text-mode state -------------------------------------------------
|
||||
private int _font; // 0..7
|
||||
private PlasmaAttributes _attributes;
|
||||
private int _col, _row; // cursor, in cells of the current grid
|
||||
private PlasmaCursorMode _cursorMode = PlasmaCursorMode.Steady; // power-on default; the game hides it
|
||||
|
||||
// ---- parser state ----------------------------------------------------
|
||||
private enum State
|
||||
{
|
||||
Text, // printable chars + control bytes
|
||||
Escape, // got ESC, awaiting the command letter
|
||||
Operand, // awaiting the 1-byte operand of _pendingCommand
|
||||
GraphicsHeader, // collecting ESC P's 5 header bytes
|
||||
GraphicsData, // consuming ESC P's w*h data bytes
|
||||
}
|
||||
|
||||
private State _state;
|
||||
private byte _pendingCommand;
|
||||
private readonly byte[] _header = new byte[5]; // screen, y, x, w, h
|
||||
private int _headerFill;
|
||||
private int _dataIndex, _dataLength;
|
||||
|
||||
private bool _dirty; // frame/cursor changed during this chunk
|
||||
private List<string>? _pendingLog; // lines queued under the lock
|
||||
private bool _graphicsLogArmed = true; // log the first ESC P of a stream, then go quiet
|
||||
private readonly HashSet<byte> _loggedUnknown = new();
|
||||
|
||||
private long _bytesReceived, _graphicsRows, _textCharsDrawn;
|
||||
|
||||
/// <summary>Frame or cursor changed. Raised on the feeding thread.</summary>
|
||||
public event Action? Updated;
|
||||
|
||||
/// <summary>Decoded-command log lines. Raised on the feeding thread.</summary>
|
||||
public event Action<string>? Logged;
|
||||
|
||||
public long BytesReceived { get { lock (_sync) return _bytesReceived; } }
|
||||
public long GraphicsRows { get { lock (_sync) return _graphicsRows; } }
|
||||
public long TextCharsDrawn { get { lock (_sync) return _textCharsDrawn; } }
|
||||
|
||||
public PlasmaCursorMode CursorMode { get { lock (_sync) return _cursorMode; } }
|
||||
public int Font { get { lock (_sync) return _font; } }
|
||||
public PlasmaAttributes Attributes { get { lock (_sync) return _attributes; } }
|
||||
|
||||
// Current font grid, for the UI's cursor overlay and status line.
|
||||
private int FontScale => _font >= 4 ? 2 : 1;
|
||||
public int CellWidth { get { lock (_sync) return 6 * FontScale; } }
|
||||
public int CellHeight { get { lock (_sync) return 8 * FontScale; } }
|
||||
private int Columns => Width / (6 * FontScale);
|
||||
private int Rows => Height / (8 * FontScale);
|
||||
public Point CursorCell { get { lock (_sync) return new Point(_col, _row); } }
|
||||
|
||||
/// <summary>A cursor cell position (avoids dragging in System.Drawing).</summary>
|
||||
public readonly record struct Point(int Col, int Row);
|
||||
|
||||
/// <summary>Copy the frame into <paramref name="destination"/> (Width*Height flag bytes).</summary>
|
||||
public void CopyFrame(byte[] destination)
|
||||
{
|
||||
if (destination.Length < _pixels.Length)
|
||||
throw new ArgumentException("Buffer too small.", nameof(destination));
|
||||
lock (_sync)
|
||||
Buffer.BlockCopy(_pixels, 0, destination, 0, _pixels.Length);
|
||||
}
|
||||
|
||||
/// <summary>Power-on state: dark glass, home cursor, defaults.</summary>
|
||||
public void Reset()
|
||||
{
|
||||
lock (_sync)
|
||||
{
|
||||
Array.Clear(_pixels, 0, _pixels.Length);
|
||||
_col = _row = 0;
|
||||
_font = 0;
|
||||
_attributes = PlasmaAttributes.None;
|
||||
_cursorMode = PlasmaCursorMode.Steady;
|
||||
_state = State.Text;
|
||||
_dirty = true;
|
||||
}
|
||||
FlushEvents();
|
||||
}
|
||||
|
||||
/// <summary>Feed <paramref name="count"/> received wire bytes.</summary>
|
||||
public void OnReceived(byte[] buffer, int count)
|
||||
{
|
||||
lock (_sync)
|
||||
{
|
||||
_bytesReceived += count;
|
||||
for (int i = 0; i < count; ++i)
|
||||
Step(buffer[i]);
|
||||
}
|
||||
FlushEvents();
|
||||
}
|
||||
|
||||
// ---- parser ------------------------------------------------------------
|
||||
|
||||
private void Step(byte b)
|
||||
{
|
||||
switch (_state)
|
||||
{
|
||||
case State.Text:
|
||||
StepText(b);
|
||||
break;
|
||||
|
||||
case State.Escape:
|
||||
StepEscape(b);
|
||||
break;
|
||||
|
||||
case State.Operand:
|
||||
_state = State.Text;
|
||||
ApplyOperand(_pendingCommand, b);
|
||||
break;
|
||||
|
||||
case State.GraphicsHeader:
|
||||
_header[_headerFill++] = b;
|
||||
if (_headerFill == _header.Length)
|
||||
BeginGraphicsData();
|
||||
break;
|
||||
|
||||
case State.GraphicsData:
|
||||
StepGraphicsData(b);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void StepText(byte b)
|
||||
{
|
||||
switch (b)
|
||||
{
|
||||
case PlasmaProtocol.Esc:
|
||||
_state = State.Escape;
|
||||
return;
|
||||
|
||||
case PlasmaProtocol.BackSpace:
|
||||
if (_col > 0) _col--;
|
||||
_dirty = true;
|
||||
return;
|
||||
|
||||
case PlasmaProtocol.HorizontalTab:
|
||||
AdvanceCursor();
|
||||
_dirty = true;
|
||||
return;
|
||||
|
||||
case PlasmaProtocol.LineFeed:
|
||||
_row = (_row + 1) % Rows;
|
||||
_dirty = true;
|
||||
return;
|
||||
|
||||
case PlasmaProtocol.VerticalTab:
|
||||
_row = (_row + Rows - 1) % Rows;
|
||||
_dirty = true;
|
||||
return;
|
||||
|
||||
case PlasmaProtocol.CarriageReturn:
|
||||
_col = 0;
|
||||
_dirty = true;
|
||||
return;
|
||||
}
|
||||
|
||||
if (b < 0x20)
|
||||
{
|
||||
// A control byte the surviving software never sends: swallow it,
|
||||
// but say so once per value — it's the tell of a desynced stream.
|
||||
if (_loggedUnknown.Add(b))
|
||||
Log($"Unhandled control byte 0x{b:X2} ignored");
|
||||
return;
|
||||
}
|
||||
|
||||
DrawChar(b);
|
||||
_graphicsLogArmed = true;
|
||||
}
|
||||
|
||||
private void StepEscape(byte b)
|
||||
{
|
||||
_state = State.Text;
|
||||
switch (b)
|
||||
{
|
||||
case PlasmaProtocol.CmdClearScreen:
|
||||
Array.Clear(_pixels, 0, _pixels.Length);
|
||||
_col = _row = 0;
|
||||
_font = 0;
|
||||
_attributes = PlasmaAttributes.None;
|
||||
_dirty = true;
|
||||
Log("Clear screen (ESC @)");
|
||||
_graphicsLogArmed = true;
|
||||
break;
|
||||
|
||||
case PlasmaProtocol.CmdHomeCursor:
|
||||
_col = _row = 0;
|
||||
_dirty = true;
|
||||
Log("Home cursor (ESC L)");
|
||||
_graphicsLogArmed = true;
|
||||
break;
|
||||
|
||||
case PlasmaProtocol.CmdCursorMode:
|
||||
case PlasmaProtocol.CmdFontSelect:
|
||||
case PlasmaProtocol.CmdAttributes:
|
||||
_pendingCommand = b;
|
||||
_state = State.Operand;
|
||||
break;
|
||||
|
||||
case PlasmaProtocol.CmdGraphicsWrite:
|
||||
_headerFill = 0;
|
||||
_state = State.GraphicsHeader;
|
||||
break;
|
||||
|
||||
default:
|
||||
if (_loggedUnknown.Add(b))
|
||||
Log($"Unknown command ESC 0x{b:X2} ('{(char)b}') ignored");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void ApplyOperand(byte command, byte operand)
|
||||
{
|
||||
switch (command)
|
||||
{
|
||||
case PlasmaProtocol.CmdCursorMode:
|
||||
// The game hides the cursor with 00, the test tool with FF;
|
||||
// 01 shows it steady, 03 flashing (bit 1 = blink).
|
||||
_cursorMode =
|
||||
operand is 0x00 or 0xFF ? PlasmaCursorMode.Hidden :
|
||||
(operand & 0x02) != 0 ? PlasmaCursorMode.Flashing :
|
||||
PlasmaCursorMode.Steady;
|
||||
_dirty = true;
|
||||
Log($"Cursor {_cursorMode} (ESC G {operand:X2})");
|
||||
break;
|
||||
|
||||
case PlasmaProtocol.CmdFontSelect:
|
||||
_font = operand == PlasmaProtocol.OperandDefault ? 0 : operand & 0x07;
|
||||
// The cursor keeps its cell coordinates but the grid changed size.
|
||||
_col = Math.Min(_col, Columns - 1);
|
||||
_row = Math.Min(_row, Rows - 1);
|
||||
_dirty = true;
|
||||
Log($"Font {_font}: {Columns}×{Rows} cells (ESC K {operand:X2})");
|
||||
break;
|
||||
|
||||
case PlasmaProtocol.CmdAttributes:
|
||||
_attributes = DecodeAttributes(operand);
|
||||
Log($"Attributes {(_attributes == PlasmaAttributes.None ? "default" : _attributes.ToString())} (ESC H {operand:X2})");
|
||||
break;
|
||||
}
|
||||
_graphicsLogArmed = true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// <c>ESC H</c>'s operand indexes the style list PLASMA.EXE enumerates
|
||||
/// (its <c>/s</c> option): the 17 intensity/underline/reverse/flash
|
||||
/// combos below, in the tool's own order. FF (and anything out of range)
|
||||
/// restores the defaults.
|
||||
/// </summary>
|
||||
private static PlasmaAttributes DecodeAttributes(byte operand) => operand switch
|
||||
{
|
||||
0 => PlasmaAttributes.None,
|
||||
1 => PlasmaAttributes.HalfIntensity,
|
||||
2 => PlasmaAttributes.Underline,
|
||||
3 => PlasmaAttributes.Reverse,
|
||||
4 => PlasmaAttributes.Flash,
|
||||
5 => PlasmaAttributes.Underline,
|
||||
6 => PlasmaAttributes.Reverse,
|
||||
7 => PlasmaAttributes.Flash,
|
||||
8 => PlasmaAttributes.HalfIntensity | PlasmaAttributes.Underline,
|
||||
9 => PlasmaAttributes.HalfIntensity | PlasmaAttributes.Reverse,
|
||||
10 => PlasmaAttributes.HalfIntensity | PlasmaAttributes.Flash,
|
||||
11 => PlasmaAttributes.Underline | PlasmaAttributes.Reverse,
|
||||
12 => PlasmaAttributes.Underline | PlasmaAttributes.Flash,
|
||||
13 => PlasmaAttributes.Underline | PlasmaAttributes.Reverse | PlasmaAttributes.Flash,
|
||||
14 => PlasmaAttributes.HalfIntensity | PlasmaAttributes.Underline | PlasmaAttributes.Reverse,
|
||||
15 => PlasmaAttributes.HalfIntensity | PlasmaAttributes.Underline | PlasmaAttributes.Flash,
|
||||
16 => PlasmaAttributes.HalfIntensity | PlasmaAttributes.Underline | PlasmaAttributes.Reverse | PlasmaAttributes.Flash,
|
||||
_ => PlasmaAttributes.None,
|
||||
};
|
||||
|
||||
// ---- graphics writes (ESC P) -------------------------------------------
|
||||
|
||||
private void BeginGraphicsData()
|
||||
{
|
||||
int w = _header[3], h = _header[4];
|
||||
_dataLength = w * h;
|
||||
_dataIndex = 0;
|
||||
|
||||
if (_graphicsLogArmed)
|
||||
{
|
||||
// The game streams row upon row; log the first of a run only.
|
||||
_graphicsLogArmed = false;
|
||||
Log($"Graphics stream: screen={_header[0]} y={_header[1]} xbyte={_header[2]} " +
|
||||
$"{w} byte(s)/row × {h} row(s) (further rows counted silently)");
|
||||
}
|
||||
|
||||
_state = _dataLength > 0 ? State.GraphicsData : State.Text;
|
||||
}
|
||||
|
||||
private void StepGraphicsData(byte b)
|
||||
{
|
||||
int w = _header[3];
|
||||
int rowOfBlock = _dataIndex / w;
|
||||
int byteOfRow = _dataIndex % w;
|
||||
|
||||
int y = _header[1] + rowOfBlock;
|
||||
int xByte = _header[2] + byteOfRow;
|
||||
if (y < Height && xByte < WidthBytes)
|
||||
{
|
||||
// MSB is the leftmost pixel (L4PLASMA.CPP packs 0x80 first).
|
||||
// Graphics dots are plain full intensity: overwriting text clears
|
||||
// its half/flash flags, like repainting the glass.
|
||||
int offset = y * Width + xByte * 8;
|
||||
for (int bit = 0; bit < 8; ++bit)
|
||||
_pixels[offset + bit] = (b & (0x80 >> bit)) != 0 ? PixelLit : (byte)0;
|
||||
_dirty = true;
|
||||
if (byteOfRow == w - 1)
|
||||
_graphicsRows++;
|
||||
}
|
||||
|
||||
if (++_dataIndex >= _dataLength)
|
||||
_state = State.Text;
|
||||
}
|
||||
|
||||
// ---- text rendering ------------------------------------------------------
|
||||
|
||||
private void DrawChar(byte code)
|
||||
{
|
||||
int scale = FontScale;
|
||||
int cellW = 6 * scale, cellH = 8 * scale;
|
||||
int ox = _col * cellW, oy = _row * cellH;
|
||||
|
||||
Span<byte> columns = stackalloc byte[PlasmaFont.GlyphWidth];
|
||||
PlasmaFont.GetColumns(code, columns);
|
||||
|
||||
bool reverse = (_attributes & PlasmaAttributes.Reverse) != 0;
|
||||
bool underline = (_attributes & PlasmaAttributes.Underline) != 0;
|
||||
byte litFlags = PixelLit;
|
||||
if ((_attributes & PlasmaAttributes.HalfIntensity) != 0) litFlags |= PixelHalf;
|
||||
if ((_attributes & PlasmaAttributes.Flash) != 0) litFlags |= PixelFlash;
|
||||
|
||||
for (int cy = 0; cy < cellH; ++cy)
|
||||
{
|
||||
int glyphRow = cy / scale; // 0..7; row 7 is the gap/underline row
|
||||
int rowOffset = (oy + cy) * Width + ox;
|
||||
for (int cx = 0; cx < cellW; ++cx)
|
||||
{
|
||||
int glyphCol = cx / scale; // 0..5; column 5 is the gap column
|
||||
bool on = glyphCol < PlasmaFont.GlyphWidth
|
||||
&& glyphRow < PlasmaFont.GlyphHeight
|
||||
&& (columns[glyphCol] >> glyphRow & 1) != 0;
|
||||
if (underline && glyphRow == 7)
|
||||
on = true;
|
||||
if (reverse)
|
||||
on = !on;
|
||||
_pixels[rowOffset + cx] = on ? litFlags : (byte)0;
|
||||
}
|
||||
}
|
||||
|
||||
_textCharsDrawn++;
|
||||
_dirty = true;
|
||||
AdvanceCursor();
|
||||
}
|
||||
|
||||
private void AdvanceCursor()
|
||||
{
|
||||
if (++_col >= Columns)
|
||||
{
|
||||
_col = 0;
|
||||
// No scroll on these panels: writing past the last row wraps to the top.
|
||||
if (++_row >= Rows)
|
||||
_row = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// ---- event plumbing --------------------------------------------------------
|
||||
|
||||
private void Log(string line) => (_pendingLog ??= new List<string>()).Add(line);
|
||||
|
||||
/// <summary>Raise queued events outside the lock, on the caller's thread.</summary>
|
||||
private void FlushEvents()
|
||||
{
|
||||
List<string>? log;
|
||||
bool dirty;
|
||||
lock (_sync)
|
||||
{
|
||||
log = _pendingLog;
|
||||
_pendingLog = null;
|
||||
dirty = _dirty;
|
||||
_dirty = false;
|
||||
}
|
||||
|
||||
if (log is not null && Logged is { } logged)
|
||||
foreach (string line in log)
|
||||
logged(line);
|
||||
if (dirty)
|
||||
Updated?.Invoke();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
using System.IO.Ports;
|
||||
using VPlasma.Core.Protocol;
|
||||
|
||||
namespace VPlasma.Core.Device;
|
||||
|
||||
/// <summary>
|
||||
/// Pumps a real COM port into a <see cref="VPlasmaDevice"/> at the plasma's
|
||||
/// 9600 8N1 settings. On a single PC, pair it with the game through a
|
||||
/// virtual null-modem (e.g. com0com): the game's COM2 passthrough opens one
|
||||
/// end, vPLASMA the other.
|
||||
///
|
||||
/// <para>Unlike the RIO, the plasma is a pure listener — the game opens the
|
||||
/// port with flow control disabled and never reads a byte back — so there is
|
||||
/// no transmit path and no wire pacing to emulate. Our DTR/RTS are asserted
|
||||
/// so a host that does check its modem lines sees "display present".</para>
|
||||
/// </summary>
|
||||
public sealed class VPlasmaSerialService : IDisposable
|
||||
{
|
||||
private readonly VPlasmaDevice _device;
|
||||
|
||||
private SerialPort? _port;
|
||||
private Thread? _reader;
|
||||
private volatile bool _running;
|
||||
|
||||
public VPlasmaSerialService(VPlasmaDevice device)
|
||||
{
|
||||
_device = device ?? throw new ArgumentNullException(nameof(device));
|
||||
}
|
||||
|
||||
/// <summary>True while a COM port is open.</summary>
|
||||
public bool IsOpen => _port?.IsOpen == true;
|
||||
|
||||
/// <summary>The open port's name, or null.</summary>
|
||||
public string? PortName => _port?.PortName;
|
||||
|
||||
/// <summary>Raised after the port opens (true) or closes (false).</summary>
|
||||
public event Action<bool>? ConnectionChanged;
|
||||
|
||||
/// <summary>Port-level log lines (open/close/errors).</summary>
|
||||
public event Action<string>? Logged;
|
||||
|
||||
/// <summary>Open <paramref name="portName"/> and start listening.</summary>
|
||||
public void Open(string portName)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(portName))
|
||||
throw new ArgumentException("Port name is required.", nameof(portName));
|
||||
|
||||
Close();
|
||||
|
||||
var port = new SerialPort(portName, PlasmaProtocol.BaudRate, Parity.None, 8, StopBits.One)
|
||||
{
|
||||
Handshake = Handshake.None,
|
||||
// Finite read timeout so the reader thread can notice shutdown.
|
||||
ReadTimeout = 200,
|
||||
// Assert our modem lines: through a null modem the host sees
|
||||
// DSR/CTS high, i.e. "display present".
|
||||
DtrEnable = true,
|
||||
RtsEnable = true,
|
||||
};
|
||||
port.Open();
|
||||
|
||||
_port = port;
|
||||
_running = true;
|
||||
|
||||
_reader = new Thread(ReadLoop) { IsBackground = true, Name = "vPLASMA serial reader" };
|
||||
_reader.Start();
|
||||
|
||||
Logged?.Invoke($"Opened {portName} @ {PlasmaProtocol.BaudRate} 8N1 — listening for the host");
|
||||
ConnectionChanged?.Invoke(true);
|
||||
}
|
||||
|
||||
/// <summary>Close the port (idempotent).</summary>
|
||||
public void Close()
|
||||
{
|
||||
SerialPort? port = _port;
|
||||
if (port is null)
|
||||
return;
|
||||
|
||||
_running = false;
|
||||
_port = null;
|
||||
try { port.Close(); }
|
||||
catch (IOException) { }
|
||||
port.Dispose();
|
||||
|
||||
_reader?.Join(1000);
|
||||
_reader = null;
|
||||
|
||||
Logged?.Invoke("Port closed");
|
||||
ConnectionChanged?.Invoke(false);
|
||||
}
|
||||
|
||||
private void ReadLoop()
|
||||
{
|
||||
var buffer = new byte[256];
|
||||
while (_running)
|
||||
{
|
||||
SerialPort? port = _port;
|
||||
if (port is null)
|
||||
return;
|
||||
|
||||
int n;
|
||||
try
|
||||
{
|
||||
n = port.Read(buffer, 0, buffer.Length);
|
||||
}
|
||||
catch (TimeoutException)
|
||||
{
|
||||
continue; // just a poll tick; check _running again
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or InvalidOperationException or OperationCanceledException)
|
||||
{
|
||||
if (_running)
|
||||
Logged?.Invoke($"Port error: {ex.Message}");
|
||||
return;
|
||||
}
|
||||
|
||||
if (n > 0)
|
||||
_device.OnReceived(buffer, n);
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose() => Close();
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
namespace VPlasma.Core.Protocol;
|
||||
|
||||
/// <summary>
|
||||
/// The cockpit plasma display's serial command set, as recovered from the
|
||||
/// Tesla 4.10 sources and tools:
|
||||
///
|
||||
/// <para>The display is a 128×32 dot-matrix plasma panel on COM2 at
|
||||
/// <b>9600 8N1</b>, no flow control. The game side
|
||||
/// (<c>CODE\RP\MUNGA_L4\L4PLASMA.CPP</c>) renders everything into a local
|
||||
/// 1bpp buffer and streams changed rows with the <c>ESC P</c> graphics
|
||||
/// command, sending <c>ESC G 0</c> once at startup to hide the cursor. The
|
||||
/// factory test tool (<c>VWETEST\VGLTEST\PLASMA.EXE</c>) additionally
|
||||
/// exercises a text mode: printable ASCII renders at a cursor, with escape
|
||||
/// commands for clear/home, cursor visibility, font select, and text
|
||||
/// attributes (intensity/underline/reverse/flash), plus BS/HT/LF/VT/CR
|
||||
/// cursor motion.</para>
|
||||
///
|
||||
/// <para>Every multi-byte command begins with ESC (0x1B) followed by one
|
||||
/// command letter:</para>
|
||||
///
|
||||
/// <code>
|
||||
/// ESC @ clear screen, reset text state
|
||||
/// ESC L home the cursor (0,0)
|
||||
/// ESC G n cursor mode: 00/FF hidden, 01 steady, 03 flashing
|
||||
/// ESC K n select font n (FF = default font 0)
|
||||
/// ESC H n text attributes: index 0..16 into the
|
||||
/// intensity/underline/reverse/flash combos the
|
||||
/// test tool enumerates; FF = defaults
|
||||
/// ESC P s y x w h data… graphics write: screen s (single-screen, ignored),
|
||||
/// top row y (0..31), left byte column x (0..15),
|
||||
/// w bytes per row, h rows, then w*h data bytes,
|
||||
/// MSB = leftmost pixel. The game always sends
|
||||
/// whole rows: x=0, w=16, h=1.
|
||||
/// </code>
|
||||
///
|
||||
/// <para>Where the two sources disagree on <c>ESC G</c> (the game hides the
|
||||
/// cursor with 00, the test tool with FF) both operands are treated as
|
||||
/// hidden.</para>
|
||||
/// </summary>
|
||||
public static class PlasmaProtocol
|
||||
{
|
||||
/// <summary>Wire bit rate — the game opens PCS_9600, PCS_N81.</summary>
|
||||
public const int BaudRate = 9600;
|
||||
|
||||
public const byte Esc = 0x1B;
|
||||
|
||||
// Single-byte cursor-motion controls (PLASMA.EXE's /b /c /l /t /v options).
|
||||
public const byte BackSpace = 0x08;
|
||||
public const byte HorizontalTab = 0x09;
|
||||
public const byte LineFeed = 0x0A;
|
||||
public const byte VerticalTab = 0x0B;
|
||||
public const byte CarriageReturn = 0x0D;
|
||||
|
||||
// ESC command letters.
|
||||
public const byte CmdClearScreen = (byte)'@';
|
||||
public const byte CmdCursorMode = (byte)'G';
|
||||
public const byte CmdAttributes = (byte)'H';
|
||||
public const byte CmdFontSelect = (byte)'K';
|
||||
public const byte CmdHomeCursor = (byte)'L';
|
||||
public const byte CmdGraphicsWrite = (byte)'P';
|
||||
|
||||
/// <summary>Operand meaning "restore the default" for ESC K / ESC H.</summary>
|
||||
public const byte OperandDefault = 0xFF;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<!-- net48 so it runs in-box on the cabinet PCs, same as VRio.Core. Uses
|
||||
System.IO.Ports from the framework BCL; Span/records/init come from
|
||||
System.Memory + PolySharp. -->
|
||||
<TargetFramework>net48</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<LangVersion>latest</LangVersion>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="System.Memory" Version="4.5.5" />
|
||||
<PackageReference Include="Microsoft.Bcl.HashCode" Version="1.1.1" />
|
||||
<PackageReference Include="PolySharp" Version="1.14.1">
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
</PackageReference>
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,431 @@
|
||||
using System.Diagnostics;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Windows.Forms;
|
||||
using VRio.Core.Device;
|
||||
using VRio.Core.Input;
|
||||
using VRio.Core.Panel;
|
||||
using VRio.Core.Protocol;
|
||||
using Windows.Devices.Enumeration;
|
||||
using Windows.Devices.Lights;
|
||||
using Windows.System;
|
||||
using Windows.UI;
|
||||
using Color = Windows.UI.Color;
|
||||
|
||||
namespace VRio.App;
|
||||
|
||||
/// <summary>
|
||||
/// Mirrors the host-commanded lamp states onto per-key RGB keyboards through
|
||||
/// Windows Dynamic Lighting (<see cref="LampArray"/>). Keys bound to
|
||||
/// lamp-capable button addresses in the active profile glow with the panel's
|
||||
/// palette — the red family for most groups, yellow for Secondary/Screen —
|
||||
/// and the flash bits blink at the panel's rates; every other key is blacked
|
||||
/// out so the keyboard reads as the button field. Zone-lit keyboards (no
|
||||
/// per-key addressing, common on laptops) fall back to a whole-board mirror
|
||||
/// of the strongest current lamp state.
|
||||
///
|
||||
/// <para>Opt-in: enabling claims keyboard-kind lamp arrays (hot-plug aware),
|
||||
/// disabling releases them so Windows hands the LEDs back to the ambient
|
||||
/// scene — no explicit restore needed. With several keyboards attached,
|
||||
/// <see cref="SetTarget"/> narrows the mirror to one of them
|
||||
/// (<see cref="KeyboardsChanged"/> feeds the picker). Dynamic Lighting gives
|
||||
/// LED control to the <em>foreground</em> app by default; for the keys to
|
||||
/// stay lit while the game has focus, vRIO needs package identity and a pick
|
||||
/// under Settings → Personalization → Dynamic Lighting → "Background light
|
||||
/// control".</para>
|
||||
/// </summary>
|
||||
public sealed class KeyboardLampMirror : IDisposable
|
||||
{
|
||||
// Refresh cadence and flash phases match PanelCanvas, so the keyboard and
|
||||
// the on-screen panel blink in step.
|
||||
private const int RefreshMs = 100;
|
||||
|
||||
private static readonly Stopwatch Clock = Stopwatch.StartNew();
|
||||
|
||||
// Address → panel colouring, from the cockpit layout (yellow = the
|
||||
// Secondary/Screen columns, same test as PanelCanvas).
|
||||
private static readonly Dictionary<int, bool> LampAddressIsYellow = BuildAddressInfo();
|
||||
|
||||
private readonly VRioDevice _device;
|
||||
private readonly object _gate = new();
|
||||
private readonly Dictionary<string, (LampArray Array, bool PerKey)> _claimed = new();
|
||||
private readonly Dictionary<string, string> _known = new(); // every keyboard array seen, id → name
|
||||
|
||||
// One entry per lamp-capable bound key: which lamp drives it, how to paint it.
|
||||
private (int Address, VirtualKey Key, bool Yellow)[] _map = Array.Empty<(int, VirtualKey, bool)>();
|
||||
|
||||
private DeviceWatcher? _watcher;
|
||||
private System.Threading.Timer? _timer;
|
||||
private Color[]? _lastPushed; // parallel to _map; null forces a full repaint
|
||||
private Color _lastAggregate; // last whole-board color for zone keyboards
|
||||
private string? _target; // device id to mirror to; null = all keyboards
|
||||
private bool _enabled;
|
||||
private bool _unsupported; // WinRT/Dynamic Lighting missing — don't retry
|
||||
private bool _anyArraySeen; // a lamp-array device event arrived this session
|
||||
|
||||
public KeyboardLampMirror(VRioDevice device) =>
|
||||
_device = device ?? throw new ArgumentNullException(nameof(device));
|
||||
|
||||
/// <summary>Status/log lines (attach, detach, availability hints).</summary>
|
||||
public event Action<string>? Logged;
|
||||
|
||||
/// <summary>The set of detected keyboards changed (id, name) — for a picker.</summary>
|
||||
public event Action<IReadOnlyList<(string Id, string Name)>>? KeyboardsChanged;
|
||||
|
||||
/// <summary>Mirror on/off. Off releases the LEDs back to Windows.</summary>
|
||||
public bool Enabled
|
||||
{
|
||||
get { lock (_gate) return _enabled; }
|
||||
set
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
if (_enabled == value || _unsupported)
|
||||
return;
|
||||
_enabled = value;
|
||||
}
|
||||
if (value) Start();
|
||||
else Stop();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Mirror to one keyboard by device id, or to all (null).</summary>
|
||||
public void SetTarget(string? deviceId)
|
||||
{
|
||||
LampArray[] release;
|
||||
List<(string Id, string Name)> reclaim = new();
|
||||
lock (_gate)
|
||||
{
|
||||
if (_target == deviceId)
|
||||
return;
|
||||
_target = deviceId;
|
||||
release = _claimed.Where(kv => !Matches(kv.Key))
|
||||
.Select(kv => kv.Value.Array).ToArray();
|
||||
foreach (string id in _claimed.Keys.Where(id => !Matches(id)).ToArray())
|
||||
_claimed.Remove(id);
|
||||
foreach (KeyValuePair<string, string> kv in _known)
|
||||
if (Matches(kv.Key) && !_claimed.ContainsKey(kv.Key))
|
||||
reclaim.Add((kv.Key, kv.Value));
|
||||
_lastPushed = null;
|
||||
}
|
||||
foreach (LampArray array in release)
|
||||
Release(array);
|
||||
foreach ((string id, string name) in reclaim)
|
||||
ReclaimAsync(id, name);
|
||||
}
|
||||
|
||||
/// <summary>Rebuild the key map from a loaded profile (lamp-capable buttons only).</summary>
|
||||
public void SetProfile(BindingProfile profile)
|
||||
{
|
||||
var map = new List<(int, VirtualKey, bool)>();
|
||||
var seen = new HashSet<VirtualKey>();
|
||||
foreach (KeyButtonBinding b in profile.KeyButtons)
|
||||
{
|
||||
if (!LampAddressIsYellow.TryGetValue(b.Address, out bool yellow))
|
||||
continue; // keypads and unknown addresses have no lamp
|
||||
if (!Enum.TryParse(b.Key, ignoreCase: true, out Keys key))
|
||||
continue;
|
||||
// WinForms Keys and WinRT VirtualKey share the Win32 VK number space.
|
||||
var vk = (VirtualKey)(int)(key & Keys.KeyCode);
|
||||
if (seen.Add(vk)) // first binding wins, like the router's key lookup
|
||||
map.Add((b.Address, vk, yellow));
|
||||
}
|
||||
lock (_gate)
|
||||
{
|
||||
_map = map.ToArray();
|
||||
_lastPushed = null; // repaint under the new map
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
Enabled = false;
|
||||
Logged = null;
|
||||
KeyboardsChanged = null;
|
||||
}
|
||||
|
||||
// ---- Device lifecycle ---------------------------------------------------
|
||||
|
||||
private void Start()
|
||||
{
|
||||
try
|
||||
{
|
||||
var watcher = DeviceInformation.CreateWatcher(LampArray.GetDeviceSelector());
|
||||
watcher.Added += OnArrayAdded;
|
||||
watcher.Removed += OnArrayRemoved;
|
||||
watcher.Updated += (_, _) => { }; // required for the watcher to progress
|
||||
watcher.EnumerationCompleted += (_, _) =>
|
||||
{
|
||||
// Attaches log themselves (and may still be in flight); only the
|
||||
// empty case needs a line here.
|
||||
bool any;
|
||||
lock (_gate) any = _anyArraySeen;
|
||||
if (!any)
|
||||
Logged?.Invoke("Keyboard lighting: no Dynamic Lighting keyboard found (check Settings → Personalization → Dynamic Lighting)");
|
||||
};
|
||||
lock (_gate) _watcher = watcher;
|
||||
watcher.Start();
|
||||
// A leaked exception in a Timer callback kills the process — never
|
||||
// let a lighting hiccup take vRIO down mid-flight.
|
||||
_timer = new System.Threading.Timer(_ =>
|
||||
{
|
||||
try { Tick(); }
|
||||
catch (Exception ex) { Logged?.Invoke($"Keyboard lighting: paint failed: {ex.Message}"); }
|
||||
}, null, RefreshMs, RefreshMs);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
_unsupported = true;
|
||||
_enabled = false;
|
||||
}
|
||||
Logged?.Invoke($"Keyboard lighting unavailable (Dynamic Lighting needs Windows 11): {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
private void Stop()
|
||||
{
|
||||
DeviceWatcher? watcher;
|
||||
LampArray[] arrays;
|
||||
lock (_gate)
|
||||
{
|
||||
watcher = _watcher;
|
||||
_watcher = null;
|
||||
arrays = _claimed.Values.Select(a => a.Array).ToArray();
|
||||
_claimed.Clear();
|
||||
_known.Clear();
|
||||
_lastPushed = null;
|
||||
}
|
||||
_timer?.Dispose();
|
||||
_timer = null;
|
||||
try { watcher?.Stop(); }
|
||||
catch (Exception ex) when (ex is InvalidOperationException or COMException) { }
|
||||
// Releasing the arrays hands the LEDs back to the system ambient scene.
|
||||
foreach (LampArray array in arrays)
|
||||
Release(array);
|
||||
RaiseKeyboardsChanged();
|
||||
}
|
||||
|
||||
private async void OnArrayAdded(DeviceWatcher sender, DeviceInformation info)
|
||||
{
|
||||
lock (_gate) _anyArraySeen = true;
|
||||
try
|
||||
{
|
||||
LampArray array = await LampArray.FromIdAsync(info.Id);
|
||||
if (array is null || array.LampArrayKind != LampArrayKind.Keyboard)
|
||||
return; // don't paint mice/strips/cases
|
||||
|
||||
lock (_gate) _known[info.Id] = info.Name;
|
||||
if (!TryClaim(info.Id, info.Name, array))
|
||||
Release(array);
|
||||
RaiseKeyboardsChanged();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Logged?.Invoke($"Keyboard lighting: could not open {info.Name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
private void OnArrayRemoved(DeviceWatcher sender, DeviceInformationUpdate update)
|
||||
{
|
||||
string? name;
|
||||
LampArray? gone = null;
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_known.TryGetValue(update.Id, out name))
|
||||
return;
|
||||
_known.Remove(update.Id);
|
||||
if (_claimed.TryGetValue(update.Id, out (LampArray Array, bool PerKey) entry))
|
||||
{
|
||||
gone = entry.Array;
|
||||
_claimed.Remove(update.Id);
|
||||
}
|
||||
}
|
||||
if (gone is not null)
|
||||
Release(gone);
|
||||
Logged?.Invoke($"Keyboard lighting: {name} disconnected");
|
||||
RaiseKeyboardsChanged();
|
||||
}
|
||||
|
||||
private async void ReclaimAsync(string id, string name)
|
||||
{
|
||||
try
|
||||
{
|
||||
LampArray array = await LampArray.FromIdAsync(id);
|
||||
if (array is null)
|
||||
return;
|
||||
if (!TryClaim(id, name, array))
|
||||
Release(array);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Logged?.Invoke($"Keyboard lighting: could not reopen {name}: {ex.Message}");
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Store the array if it is wanted right now; false = caller releases.</summary>
|
||||
private bool TryClaim(string id, string name, LampArray array)
|
||||
{
|
||||
bool perKey = array.SupportsVirtualKeys;
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_enabled || !Matches(id) || _claimed.ContainsKey(id))
|
||||
return false;
|
||||
_claimed[id] = (array, perKey);
|
||||
_lastPushed = null; // full repaint including the base coat
|
||||
}
|
||||
Logged?.Invoke(perKey
|
||||
? $"Keyboard lighting: + {name} ({array.LampCount} LEDs, per-key)"
|
||||
: $"Keyboard lighting: + {name} ({array.LampCount} zones — no per-key map, mirroring the strongest lamp board-wide)");
|
||||
HookAvailability(array, name);
|
||||
return true;
|
||||
}
|
||||
|
||||
private bool Matches(string id) => _target is null || _target == id;
|
||||
|
||||
private static void Release(LampArray array)
|
||||
{
|
||||
// No IDisposable projection on .NET Framework — drop the COM wrapper.
|
||||
try { Marshal.ReleaseComObject(array); } catch (ArgumentException) { }
|
||||
}
|
||||
|
||||
private void RaiseKeyboardsChanged()
|
||||
{
|
||||
(string, string)[] known;
|
||||
lock (_gate) known = _known.Select(kv => (kv.Key, kv.Value)).ToArray();
|
||||
KeyboardsChanged?.Invoke(known);
|
||||
}
|
||||
|
||||
private void HookAvailability(LampArray array, string name)
|
||||
{
|
||||
// IsAvailable/AvailabilityChanged need Windows 11 22H2+; older builds
|
||||
// just never get the background-control hint.
|
||||
try
|
||||
{
|
||||
bool lastAvailable = array.IsAvailable;
|
||||
if (!lastAvailable)
|
||||
Logged?.Invoke($"Keyboard lighting: Windows is withholding {name} — enable vRIO under " +
|
||||
"Settings → Personalization → Dynamic Lighting → Background light control");
|
||||
array.AvailabilityChanged += (a, _) =>
|
||||
{
|
||||
bool available = a.IsAvailable;
|
||||
if (available == lastAvailable)
|
||||
return; // the event also fires without a state change
|
||||
lastAvailable = available;
|
||||
Logged?.Invoke(available
|
||||
? $"Keyboard lighting: {name} available"
|
||||
: $"Keyboard lighting: {name} withheld (foreground app owns it — see Dynamic Lighting settings)");
|
||||
lock (_gate) _lastPushed = null; // repaint when control returns
|
||||
};
|
||||
}
|
||||
catch (Exception ex) when (ex is COMException or InvalidCastException or MissingMethodException) { }
|
||||
}
|
||||
|
||||
// ---- Rendering ----------------------------------------------------------
|
||||
|
||||
private void Tick()
|
||||
{
|
||||
(int Address, VirtualKey Key, bool Yellow)[] map;
|
||||
(LampArray Array, bool PerKey)[] arrays;
|
||||
Color[]? last;
|
||||
Color lastAggregate;
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_enabled || _claimed.Count == 0)
|
||||
return;
|
||||
map = _map;
|
||||
arrays = _claimed.Values.ToArray();
|
||||
last = _lastPushed;
|
||||
lastAggregate = _lastAggregate;
|
||||
}
|
||||
|
||||
long tick = Clock.ElapsedMilliseconds;
|
||||
var colors = new Color[map.Length];
|
||||
var keys = new VirtualKey[map.Length];
|
||||
var bestShade = LampBrightness.Off;
|
||||
bool bestYellow = false;
|
||||
bool changed = last is null || last.Length != map.Length;
|
||||
for (int i = 0; i < map.Length; i++)
|
||||
{
|
||||
byte state = _device.GetLamp(map[i].Address);
|
||||
LampBrightness shade = RioLampState.Brightness(state);
|
||||
if (shade != LampBrightness.Off && !FlashPhaseOn(RioLampState.Flash(state), tick))
|
||||
shade = LampBrightness.Off;
|
||||
if (shade > bestShade)
|
||||
(bestShade, bestYellow) = (shade, map[i].Yellow);
|
||||
|
||||
colors[i] = Shade(shade, map[i].Yellow);
|
||||
keys[i] = map[i].Key;
|
||||
if (last is not null)
|
||||
changed |= !colors[i].Equals(last[i]);
|
||||
}
|
||||
Color aggregate = Shade(bestShade, bestYellow);
|
||||
changed |= !aggregate.Equals(lastAggregate);
|
||||
if (!changed)
|
||||
return;
|
||||
|
||||
foreach ((LampArray array, bool perKey) in arrays)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (perKey)
|
||||
{
|
||||
if (last is null) // new claim/map: black out the whole board first
|
||||
array.SetColor(ColorHelper.FromArgb(255, 0, 0, 0));
|
||||
if (map.Length > 0)
|
||||
array.SetColorsForKeys(colors, keys);
|
||||
}
|
||||
else if (map.Length > 0)
|
||||
{
|
||||
// Zone keyboard: the whole board is one big lamp showing
|
||||
// the strongest current state (idle dim, alerts bright/flash).
|
||||
array.SetColor(aggregate);
|
||||
}
|
||||
}
|
||||
catch (COMException) { } // device wobble; the watcher handles removal
|
||||
}
|
||||
lock (_gate)
|
||||
{
|
||||
_lastPushed = colors;
|
||||
_lastAggregate = aggregate;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The panel's lamp palette (PanelCanvas fills), as LED colors.</summary>
|
||||
private static Color Shade(LampBrightness shade, bool yellow) =>
|
||||
yellow
|
||||
? shade switch
|
||||
{
|
||||
LampBrightness.Bright => ColorHelper.FromArgb(255, 245, 210, 60),
|
||||
LampBrightness.Dim => ColorHelper.FromArgb(255, 140, 118, 38),
|
||||
_ => ColorHelper.FromArgb(255, 70, 60, 24),
|
||||
}
|
||||
: shade switch
|
||||
{
|
||||
LampBrightness.Bright => ColorHelper.FromArgb(255, 230, 70, 70),
|
||||
LampBrightness.Dim => ColorHelper.FromArgb(255, 120, 50, 50),
|
||||
_ => ColorHelper.FromArgb(255, 64, 40, 40),
|
||||
};
|
||||
|
||||
// Same half-periods as PanelCanvas, so panel and keyboard blink together.
|
||||
private static bool FlashPhaseOn(LampFlash flash, long tick)
|
||||
{
|
||||
long halfPeriod = flash switch
|
||||
{
|
||||
LampFlash.FlashSlow => 500,
|
||||
LampFlash.FlashMed => 250,
|
||||
LampFlash.FlashFast => 125,
|
||||
_ => 0,
|
||||
};
|
||||
return halfPeriod == 0 || tick / halfPeriod % 2 == 0;
|
||||
}
|
||||
|
||||
private static Dictionary<int, bool> BuildAddressInfo()
|
||||
{
|
||||
var info = new Dictionary<int, bool>();
|
||||
foreach (PanelButton b in CockpitLayout.Buttons())
|
||||
if (b.LampCapable)
|
||||
info[b.Address] = b.Group.Title is "Secondary" or "Screen";
|
||||
return info;
|
||||
}
|
||||
}
|
||||
+180
-35
@@ -19,6 +19,9 @@ internal sealed class MainForm : Form
|
||||
private readonly PanelCanvas _canvas = new();
|
||||
private readonly InputRouter _router;
|
||||
private readonly XInputGamepad _gamepad = new();
|
||||
private readonly KeyboardLampMirror _lampMirror;
|
||||
private readonly RawKeyboardSource _rawKeyboard = new();
|
||||
private string? _activeInputId; // interface path of the keyboard being captured; null = WinForms focus path
|
||||
private readonly string _bindingsPath = Path.Combine(
|
||||
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "vRIO", "bindings.txt");
|
||||
|
||||
@@ -38,16 +41,13 @@ internal sealed class MainForm : Form
|
||||
ForeColor = Color.Gray,
|
||||
};
|
||||
|
||||
private readonly NumericUpDown _verMajor = new() { Location = new Point(80, 24), Width = 44, Minimum = 0, Maximum = 127, Value = 4 };
|
||||
private readonly NumericUpDown _verMinor = new() { Location = new Point(140, 24), Width = 44, Minimum = 0, Maximum = 127, Value = 2 };
|
||||
private readonly CheckBox _spring = new() { Text = "Stick springs back to center", Location = new Point(10, 56), AutoSize = true, Checked = true };
|
||||
private readonly Button _centerAxes = new() { Text = "Center all axes", Location = new Point(10, 82), Width = 140, Height = 26 };
|
||||
private readonly Button _lampsOff = new() { Text = "All lamps off", Location = new Point(156, 82), Width = 140, Height = 26 };
|
||||
private readonly Button _testEnter = new() { Text = "Enter test mode", Location = new Point(10, 114), Width = 140, Height = 26 };
|
||||
private readonly Button _testExit = new() { Text = "Exit test mode", Location = new Point(156, 114), Width = 140, Height = 26 };
|
||||
private readonly CheckBox _spring = new() { Text = "Stick springs back to center", Location = new Point(10, 24), AutoSize = true, Checked = true };
|
||||
private readonly Button _centerAxes = new() { Text = "Center all axes", Location = new Point(10, 52), Width = 140, Height = 26 };
|
||||
private readonly Button _lampsOff = new() { Text = "All lamps off", Location = new Point(156, 52), Width = 140, Height = 26 };
|
||||
|
||||
private readonly CheckBox _kbInput = new() { Text = "Keyboard", Location = new Point(10, 22), AutoSize = true, Checked = true };
|
||||
private readonly CheckBox _padInput = new() { Text = "Xbox gamepad", Location = new Point(120, 22), AutoSize = true, Checked = true };
|
||||
private readonly CheckBox _padInput = new() { Text = "Gamepad", Location = new Point(100, 22), AutoSize = true, Checked = true };
|
||||
private readonly CheckBox _invertY = new() { Text = "Invert Y", Location = new Point(190, 22), AutoSize = true };
|
||||
private readonly Label _padStatus = new()
|
||||
{
|
||||
Text = "No controller detected.",
|
||||
@@ -57,31 +57,61 @@ internal sealed class MainForm : Form
|
||||
};
|
||||
private readonly Button _reloadBindings = new() { Text = "Reload bindings", Location = new Point(10, 68), Width = 140, Height = 26 };
|
||||
private readonly Button _editBindings = new() { Text = "Edit bindings…", Location = new Point(156, 68), Width = 140, Height = 26 };
|
||||
private readonly CheckBox _kbLights = new()
|
||||
{
|
||||
Text = "Mirror lamps on RGB keyboard (Dynamic Lighting)",
|
||||
Location = new Point(10, 100),
|
||||
AutoSize = true,
|
||||
};
|
||||
private readonly ComboBox _kbLightsTarget = new()
|
||||
{
|
||||
Location = new Point(10, 122),
|
||||
Width = 286,
|
||||
DropDownStyle = ComboBoxStyle.DropDownList,
|
||||
Enabled = false, // populated while the mirror is on
|
||||
};
|
||||
private readonly Label _kbInputLabel = new()
|
||||
{
|
||||
Text = "Capture keyboard (no window focus needed):",
|
||||
Location = new Point(10, 144),
|
||||
AutoSize = true,
|
||||
};
|
||||
private readonly ComboBox _kbInputTarget = new()
|
||||
{
|
||||
Location = new Point(10, 162),
|
||||
Width = 286,
|
||||
DropDownStyle = ComboBoxStyle.DropDownList,
|
||||
};
|
||||
|
||||
/// <summary>A keyboard choice in the lamp-mirror picker (null id = all).</summary>
|
||||
private sealed record KbChoice(string? Id, string Name)
|
||||
{
|
||||
public override string ToString() => Name;
|
||||
}
|
||||
|
||||
private readonly Label _counters = new()
|
||||
{
|
||||
Location = new Point(12, 336),
|
||||
Location = new Point(12, 372),
|
||||
AutoSize = true,
|
||||
Font = new Font("Consolas", 8f),
|
||||
};
|
||||
|
||||
private readonly Label _help = new()
|
||||
{
|
||||
Location = new Point(12, 392),
|
||||
Location = new Point(12, 428),
|
||||
MaximumSize = new Size(306, 0),
|
||||
AutoSize = true,
|
||||
ForeColor = Color.Gray,
|
||||
Text = "Left-click a cell: momentary press. Right-click: latch it down. " +
|
||||
"Drag the X/Y box and the Z / L / R gauges to move the axes. " +
|
||||
"Keyboard and Xbox-pad input follow the bindings file (Edit bindings…).",
|
||||
"Drag the X/Y box and the Z / L / R gauges to move the axes.",
|
||||
};
|
||||
|
||||
private readonly TextBox _logBox = new()
|
||||
{
|
||||
Location = new Point(12, 476),
|
||||
Location = new Point(12, 498),
|
||||
Multiline = true,
|
||||
ReadOnly = true,
|
||||
ScrollBars = ScrollBars.Vertical,
|
||||
ScrollBars = ScrollBars.Both, // long wire lines don't wrap — scroll to read
|
||||
BackColor = Color.FromArgb(24, 24, 24),
|
||||
ForeColor = Color.Gainsboro,
|
||||
Font = new Font("Consolas", 8f),
|
||||
@@ -102,7 +132,10 @@ internal sealed class MainForm : Form
|
||||
|
||||
public MainForm()
|
||||
{
|
||||
Text = "vRIO — Virtual RIO cockpit device";
|
||||
// ProductVersion carries the git stamp (see StampGitVersion in the csproj).
|
||||
Text = $"vRIO v{Application.ProductVersion} — Virtual RIO cockpit device";
|
||||
// Title-bar/taskbar icon from the exe's embedded ApplicationIcon (vwe.ico).
|
||||
Icon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
|
||||
// Fit the window to its content: the cockpit canvas plus the 330px
|
||||
// control strip, with just enough height for the strip's log area.
|
||||
ClientSize = new Size(_canvas.Width + 332, Math.Max(_canvas.Height, 640));
|
||||
@@ -112,6 +145,7 @@ internal sealed class MainForm : Form
|
||||
|
||||
_service = new VRioSerialService(_device);
|
||||
_router = new InputRouter(_device);
|
||||
_lampMirror = new KeyboardLampMirror(_device);
|
||||
|
||||
// Panel canvas, scrolled if the window is smaller than the grid.
|
||||
var scroller = new Panel { Dock = DockStyle.Fill, AutoScroll = true, BackColor = Color.FromArgb(28, 28, 28) };
|
||||
@@ -123,6 +157,7 @@ internal sealed class MainForm : Form
|
||||
// Canvas ↔ device wiring.
|
||||
_canvas.LampProvider = _device.GetLamp;
|
||||
_canvas.AxisProvider = _device.GetAxis;
|
||||
_canvas.WireAxisProvider = _device.GetWireAxis;
|
||||
_canvas.AddressPressed += _device.PressAddress;
|
||||
_canvas.AddressReleased += _device.ReleaseAddress;
|
||||
_canvas.AxisMoved += (axis, value) => _device.SetAxis(axis, value);
|
||||
@@ -137,14 +172,13 @@ internal sealed class MainForm : Form
|
||||
_device.ResetReceived += _ => RunOnUi(_router.ResetAxisState);
|
||||
_device.Logged += line => RunOnUi(() => PrependLog(line));
|
||||
_service.Logged += line => RunOnUi(() => PrependLog(line));
|
||||
_lampMirror.Logged += line => RunOnUi(() => PrependLog(line));
|
||||
_service.ConnectionChanged += open => RunOnUi(() => OnConnectionChanged(open));
|
||||
_service.HostHandshake += high => RunOnUi(() =>
|
||||
PrependLog(high ? "Host raised DTR (board-reset handshake)" : "Host dropped DTR"));
|
||||
|
||||
_rescan.Click += (_, _) => RefreshPorts();
|
||||
_openClose.Click += (_, _) => ToggleOpen();
|
||||
_verMajor.ValueChanged += (_, _) => _device.VersionMajor = (byte)_verMajor.Value;
|
||||
_verMinor.ValueChanged += (_, _) => _device.VersionMinor = (byte)_verMinor.Value;
|
||||
_spring.CheckedChanged += (_, _) => _canvas.StickSpringsBack = _spring.Checked;
|
||||
_centerAxes.Click += (_, _) =>
|
||||
{
|
||||
@@ -157,8 +191,6 @@ internal sealed class MainForm : Form
|
||||
_device.ClearLamps();
|
||||
_canvas.Invalidate();
|
||||
};
|
||||
_testEnter.Click += (_, _) => _device.SendTestMode(1);
|
||||
_testExit.Click += (_, _) => _device.SendTestMode(0);
|
||||
_clearLog.Click += (_, _) => _logBox.Clear();
|
||||
|
||||
_kbInput.CheckedChanged += (_, _) =>
|
||||
@@ -166,6 +198,34 @@ internal sealed class MainForm : Form
|
||||
if (!_kbInput.Checked)
|
||||
_router.ReleaseAllKeys();
|
||||
};
|
||||
_invertY.CheckedChanged += (_, _) =>
|
||||
{
|
||||
_device.InvertJoystickY = _invertY.Checked;
|
||||
_canvas.Invalidate(); // the wire readout flips even though the axes didn't move
|
||||
};
|
||||
_device.InvertJoystickY = _invertY.Checked; // the field initializer raises no event
|
||||
_kbLights.CheckedChanged += (_, _) =>
|
||||
{
|
||||
_lampMirror.Enabled = _kbLights.Checked;
|
||||
_kbLightsTarget.Enabled = _kbLights.Checked;
|
||||
};
|
||||
_kbLightsTarget.SelectedIndexChanged += (_, _) =>
|
||||
_lampMirror.SetTarget((_kbLightsTarget.SelectedItem as KbChoice)?.Id);
|
||||
_lampMirror.KeyboardsChanged += list => RunOnUi(() => RebuildKeyboardPicker(list));
|
||||
_kbLightsTarget.Items.Add(new KbChoice(null, "All keyboards"));
|
||||
_kbLightsTarget.SelectedIndex = 0;
|
||||
|
||||
// Raw-input capture: a chosen keyboard drives the panel even while the
|
||||
// sim has focus. Down-edges only fire when keyboard input is enabled;
|
||||
// up-edges always land so a release is never stranded by a mid-hold flip.
|
||||
_rawKeyboard.KeyDown += name => RunOnUi(() => { if (_kbInput.Checked) _router.KeyDown(name); });
|
||||
_rawKeyboard.KeyUp += name => RunOnUi(() => _router.KeyUp(name));
|
||||
_rawKeyboard.Logged += line => RunOnUi(() => PrependLog(line));
|
||||
_rawKeyboard.KeyboardsChanged += list => RunOnUi(() => RebuildInputKeyboardPicker(list));
|
||||
_kbInputTarget.SelectedIndexChanged += (_, _) => ApplyInputSource();
|
||||
_kbInputTarget.DropDown += (_, _) => _rawKeyboard.RefreshKeyboards();
|
||||
_kbInputTarget.Items.Add(new KbChoice(null, "All keyboards (focus only)"));
|
||||
_kbInputTarget.SelectedIndex = 0;
|
||||
_reloadBindings.Click += (_, _) => LoadBindings();
|
||||
_editBindings.Click += (_, _) => OpenBindingsFile();
|
||||
|
||||
@@ -179,6 +239,8 @@ internal sealed class MainForm : Form
|
||||
{
|
||||
_uiTimer.Dispose();
|
||||
_inputTimer.Dispose();
|
||||
_lampMirror.Dispose();
|
||||
_rawKeyboard.Dispose();
|
||||
_service.Dispose();
|
||||
};
|
||||
|
||||
@@ -209,21 +271,17 @@ internal sealed class MainForm : Form
|
||||
panel.Controls.Add(_openClose);
|
||||
panel.Controls.Add(_linkStatus);
|
||||
|
||||
var device = new GroupBox { Text = "Device", Location = new Point(12, 68), Size = new Size(306, 150) };
|
||||
device.Controls.Add(new Label { Text = "Firmware:", Location = new Point(10, 27), AutoSize = true });
|
||||
device.Controls.Add(_verMajor);
|
||||
device.Controls.Add(new Label { Text = ".", Location = new Point(127, 27), AutoSize = true });
|
||||
device.Controls.Add(_verMinor);
|
||||
device.Controls.AddRange(new Control[] { _spring, _centerAxes, _lampsOff, _testEnter, _testExit });
|
||||
var device = new GroupBox { Text = "Device", Location = new Point(12, 68), Size = new Size(306, 88) };
|
||||
device.Controls.AddRange(new Control[] { _spring, _centerAxes, _lampsOff });
|
||||
panel.Controls.Add(device);
|
||||
|
||||
var input = new GroupBox { Text = "Input", Location = new Point(12, 224), Size = new Size(306, 104) };
|
||||
input.Controls.AddRange(new Control[] { _kbInput, _padInput, _padStatus, _reloadBindings, _editBindings });
|
||||
var input = new GroupBox { Text = "Input", Location = new Point(12, 162), Size = new Size(306, 202) };
|
||||
input.Controls.AddRange(new Control[] { _kbInput, _padInput, _invertY, _padStatus, _reloadBindings, _editBindings, _kbLights, _kbLightsTarget, _kbInputLabel, _kbInputTarget });
|
||||
panel.Controls.Add(input);
|
||||
|
||||
panel.Controls.Add(_counters);
|
||||
panel.Controls.Add(_help);
|
||||
panel.Controls.Add(new Label { Text = "Wire log:", Location = new Point(12, 458), AutoSize = true });
|
||||
panel.Controls.Add(new Label { Text = "Wire log:", Location = new Point(12, 480), AutoSize = true });
|
||||
|
||||
_logBox.Size = new Size(306, ClientSize.Height - _logBox.Top - 44);
|
||||
panel.Controls.Add(_logBox);
|
||||
@@ -288,11 +346,35 @@ internal sealed class MainForm : Form
|
||||
|
||||
/// <summary>
|
||||
/// Keys route to the panel unless the user is in a control that needs
|
||||
/// them (port list, firmware spinners, log box scrolling).
|
||||
/// them (port list, log box scrolling).
|
||||
/// </summary>
|
||||
private bool KeyboardRoutingActive =>
|
||||
_kbInput.Checked &&
|
||||
!_portBox.ContainsFocus && !_verMajor.ContainsFocus && !_verMinor.ContainsFocus && !_logBox.ContainsFocus;
|
||||
!_portBox.ContainsFocus && !_logBox.ContainsFocus;
|
||||
|
||||
protected override void OnHandleCreated(EventArgs e)
|
||||
{
|
||||
base.OnHandleCreated(e);
|
||||
_rawKeyboard.Attach(Handle);
|
||||
_rawKeyboard.RefreshKeyboards(); // seed the capture picker
|
||||
}
|
||||
|
||||
protected override void WndProc(ref Message m)
|
||||
{
|
||||
// Raw Input arrives outside the normal key-message path; feed it to the
|
||||
// capture source, then let DefWindowProc run its WM_INPUT cleanup.
|
||||
const int WM_INPUT = 0x00FF, WM_INPUT_DEVICE_CHANGE = 0x00FE;
|
||||
switch (m.Msg)
|
||||
{
|
||||
case WM_INPUT:
|
||||
_rawKeyboard.ProcessInput(m.LParam);
|
||||
break;
|
||||
case WM_INPUT_DEVICE_CHANGE:
|
||||
_rawKeyboard.HandleDeviceChange();
|
||||
break;
|
||||
}
|
||||
base.WndProc(ref m);
|
||||
}
|
||||
|
||||
protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
|
||||
{
|
||||
@@ -306,7 +388,10 @@ internal sealed class MainForm : Form
|
||||
string name = (keyData & Keys.KeyCode).ToString();
|
||||
if (_router.HasKeyBinding(name))
|
||||
{
|
||||
_router.KeyDown(name);
|
||||
// While a specific keyboard is captured, that source owns
|
||||
// routing; still swallow the key so it can't click a button.
|
||||
if (!_rawKeyboard.IsCapturing)
|
||||
_router.KeyDown(name);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -315,18 +400,57 @@ internal sealed class MainForm : Form
|
||||
|
||||
protected override void OnKeyUp(KeyEventArgs e)
|
||||
{
|
||||
// Unconditional: the router ignores keys it never saw go down, and a
|
||||
// release must land even if the checkbox flipped mid-hold.
|
||||
_router.KeyUp(e.KeyCode.ToString());
|
||||
// Unconditional in focus mode: the router ignores keys it never saw go
|
||||
// down, and a release must land even if the checkbox flipped mid-hold.
|
||||
// In capture mode the raw source owns edges, so don't double-release.
|
||||
if (!_rawKeyboard.IsCapturing)
|
||||
_router.KeyUp(e.KeyCode.ToString());
|
||||
base.OnKeyUp(e);
|
||||
}
|
||||
|
||||
protected override void OnDeactivate(EventArgs e)
|
||||
{
|
||||
_router.ReleaseAllKeys(); // key-up events are lost once unfocused
|
||||
// Focus mode loses key-up events once unfocused, so release held keys.
|
||||
// Capture mode keeps receiving them in the background — leave holds be.
|
||||
if (!_rawKeyboard.IsCapturing)
|
||||
_router.ReleaseAllKeys();
|
||||
base.OnDeactivate(e);
|
||||
}
|
||||
|
||||
/// <summary>Apply the capture-picker selection: swap the keyboard input source.</summary>
|
||||
private void ApplyInputSource()
|
||||
{
|
||||
string? id = (_kbInputTarget.SelectedItem as KbChoice)?.Id;
|
||||
if (id == _activeInputId)
|
||||
return;
|
||||
_activeInputId = id;
|
||||
_router.ReleaseAllKeys(); // don't strand holds across a source swap
|
||||
_rawKeyboard.SetTarget(id);
|
||||
PrependLog(id is null
|
||||
? "Keyboard input: all keyboards, only while vRIO has focus"
|
||||
: $"Keyboard input: capturing \"{(_kbInputTarget.SelectedItem as KbChoice)?.Name}\" in the background");
|
||||
}
|
||||
|
||||
/// <summary>Refresh the capture picker, keeping the pick if the device survived.</summary>
|
||||
private void RebuildInputKeyboardPicker(IReadOnlyList<(string Id, string Name)> keyboards)
|
||||
{
|
||||
string? selected = (_kbInputTarget.SelectedItem as KbChoice)?.Id;
|
||||
_kbInputTarget.BeginUpdate();
|
||||
_kbInputTarget.Items.Clear();
|
||||
_kbInputTarget.Items.Add(new KbChoice(null, "All keyboards (focus only)"));
|
||||
int select = 0;
|
||||
foreach ((string id, string name) in keyboards)
|
||||
{
|
||||
int idx = _kbInputTarget.Items.Add(new KbChoice(id, name));
|
||||
if (id == selected)
|
||||
select = idx;
|
||||
}
|
||||
// A vanished capture device falls back to "All keyboards"; the
|
||||
// selection-changed handler (ApplyInputSource) unregisters accordingly.
|
||||
_kbInputTarget.SelectedIndex = select;
|
||||
_kbInputTarget.EndUpdate();
|
||||
}
|
||||
|
||||
private void InputTick()
|
||||
{
|
||||
double now = _clock.Elapsed.TotalSeconds;
|
||||
@@ -370,6 +494,7 @@ internal sealed class MainForm : Form
|
||||
|
||||
var profile = BindingProfileFormat.Parse(text, out var errors);
|
||||
_router.Profile = profile;
|
||||
_lampMirror.SetProfile(profile);
|
||||
foreach (string error in errors)
|
||||
PrependLog($"Bindings: {error}");
|
||||
PrependLog($"Bindings loaded: {profile.Count} ({_bindingsPath})");
|
||||
@@ -395,6 +520,26 @@ internal sealed class MainForm : Form
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Refresh the lamp-mirror keyboard picker, keeping the pick if it survived.</summary>
|
||||
private void RebuildKeyboardPicker(IReadOnlyList<(string Id, string Name)> keyboards)
|
||||
{
|
||||
string? selected = (_kbLightsTarget.SelectedItem as KbChoice)?.Id;
|
||||
_kbLightsTarget.BeginUpdate();
|
||||
_kbLightsTarget.Items.Clear();
|
||||
_kbLightsTarget.Items.Add(new KbChoice(null, "All keyboards"));
|
||||
int select = 0;
|
||||
foreach ((string id, string name) in keyboards)
|
||||
{
|
||||
int idx = _kbLightsTarget.Items.Add(new KbChoice(id, name));
|
||||
if (id == selected)
|
||||
select = idx;
|
||||
}
|
||||
// Falls back to "All keyboards" if the picked device vanished (the
|
||||
// selection-changed handler re-targets the mirror accordingly).
|
||||
_kbLightsTarget.SelectedIndex = select;
|
||||
_kbLightsTarget.EndUpdate();
|
||||
}
|
||||
|
||||
// ---- Status / log ------------------------------------------------------
|
||||
|
||||
private void UpdateStatus()
|
||||
|
||||
@@ -73,6 +73,12 @@ internal sealed class PanelCanvas : Control
|
||||
/// <summary>Current raw value of an axis (from the device).</summary>
|
||||
public Func<RioAxis, short>? AxisProvider { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// Axis value as transmitted to the host (joystick Y sign flip applied).
|
||||
/// The text readout shows this; the dot and gauges track physical state.
|
||||
/// </summary>
|
||||
public Func<RioAxis, short>? WireAxisProvider { get; set; }
|
||||
|
||||
/// <summary>The user pressed a panel control.</summary>
|
||||
public event Action<int>? AddressPressed;
|
||||
|
||||
@@ -299,9 +305,10 @@ internal sealed class PanelCanvas : Control
|
||||
new Size(statusRect.Width, 0), TextFormatFlags.WordBreak).Height + 2;
|
||||
}
|
||||
|
||||
short WireAxis(RioAxis a) => WireAxisProvider?.Invoke(a) ?? Axis(a);
|
||||
string readout =
|
||||
$"Z {Axis(RioAxis.Throttle),4} L {Axis(RioAxis.LeftPedal),3} R {Axis(RioAxis.RightPedal),3} " +
|
||||
$"X {Axis(RioAxis.JoystickX),3} Y {Axis(RioAxis.JoystickY),3}";
|
||||
$"Z {WireAxis(RioAxis.Throttle),4} L {WireAxis(RioAxis.LeftPedal),3} R {WireAxis(RioAxis.RightPedal),3} " +
|
||||
$"X {WireAxis(RioAxis.JoystickX),3} Y {WireAxis(RioAxis.JoystickY),3}";
|
||||
TextRenderer.DrawText(g, readout, statusFont,
|
||||
new Rectangle(statusRect.X, readoutTop, statusRect.Width, statusRect.Bottom - readoutTop), green,
|
||||
TextFormatFlags.Left | TextFormatFlags.Top | TextFormatFlags.SingleLine);
|
||||
|
||||
@@ -0,0 +1,376 @@
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text.RegularExpressions;
|
||||
using System.Windows.Forms;
|
||||
using Microsoft.Win32;
|
||||
|
||||
namespace VRio.App;
|
||||
|
||||
/// <summary>
|
||||
/// A background keyboard input source built on the Win32 <b>Raw Input</b> API.
|
||||
/// Where the WinForms focus path (<c>ProcessCmdKey</c>/<c>OnKeyUp</c>) only sees
|
||||
/// keys while vRIO is the foreground window and can't tell one keyboard from
|
||||
/// another, Raw Input carries a per-device handle with every keystroke and —
|
||||
/// with the <c>RIDEV_INPUTSINK</c> flag — keeps delivering <c>WM_INPUT</c> even
|
||||
/// when vRIO is in the background. That lets the user nominate one physical
|
||||
/// keyboard as a dedicated cockpit panel: its keys drive the RIO controls while
|
||||
/// the sim (or RIOJoy) holds focus, and other keyboards are ignored.
|
||||
///
|
||||
/// <para>This is the input-side twin of <see cref="KeyboardLampMirror"/>: that
|
||||
/// class <em>writes</em> a chosen keyboard's LEDs while the game has focus, this
|
||||
/// one <em>reads</em> a chosen keyboard's keys under the same condition. Raw
|
||||
/// Input observes without intercepting — the keystroke still reaches whatever
|
||||
/// app has focus — so the selected keyboard should be one dedicated to the
|
||||
/// panel, not the one you also type on.</para>
|
||||
///
|
||||
/// <para>Registration is scoped to when a device is actually selected
|
||||
/// (<see cref="SetTarget"/>): picking "all keyboards" unregisters and hands
|
||||
/// input back to the focus path, so vRIO isn't pumping <c>WM_INPUT</c> for every
|
||||
/// keystroke system-wide when the feature is idle. Not thread-safe;
|
||||
/// <see cref="ProcessInput"/> and the events fire on the UI thread that owns the
|
||||
/// window handle, which is exactly where <see cref="Input.InputRouter"/> wants
|
||||
/// to be called.</para>
|
||||
/// </summary>
|
||||
public sealed class RawKeyboardSource : IDisposable
|
||||
{
|
||||
// --- Win32 Raw Input interop ---------------------------------------------
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct RAWINPUTDEVICE
|
||||
{
|
||||
public ushort usUsagePage;
|
||||
public ushort usUsage;
|
||||
public uint dwFlags;
|
||||
public IntPtr hwndTarget;
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct RAWINPUTDEVICELIST
|
||||
{
|
||||
public IntPtr hDevice;
|
||||
public uint dwType;
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct RAWINPUTHEADER
|
||||
{
|
||||
public uint dwType;
|
||||
public uint dwSize;
|
||||
public IntPtr hDevice;
|
||||
public IntPtr wParam;
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct RAWKEYBOARD
|
||||
{
|
||||
public ushort MakeCode;
|
||||
public ushort Flags;
|
||||
public ushort Reserved;
|
||||
public ushort VKey;
|
||||
public uint Message;
|
||||
public uint ExtraInformation;
|
||||
}
|
||||
|
||||
[DllImport("user32.dll", SetLastError = true)]
|
||||
private static extern bool RegisterRawInputDevices(
|
||||
[In] RAWINPUTDEVICE[] pRawInputDevices, uint uiNumDevices, uint cbSize);
|
||||
|
||||
[DllImport("user32.dll", SetLastError = true)]
|
||||
private static extern uint GetRawInputData(
|
||||
IntPtr hRawInput, uint uiCommand, IntPtr pData, ref uint pcbSize, uint cbSizeHeader);
|
||||
|
||||
[DllImport("user32.dll", SetLastError = true)]
|
||||
private static extern uint GetRawInputDeviceList(
|
||||
[In, Out] RAWINPUTDEVICELIST[]? pRawInputDeviceList, ref uint puiNumDevices, uint cbSize);
|
||||
|
||||
[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
|
||||
private static extern uint GetRawInputDeviceInfoW(
|
||||
IntPtr hDevice, uint uiCommand, IntPtr pData, ref uint pcbSize);
|
||||
|
||||
private const uint Err = 0xFFFFFFFF; // sentinel: all three APIs return (UINT)-1 on failure
|
||||
private const uint RIDEV_REMOVE = 0x00000001;
|
||||
private const uint RIDEV_INPUTSINK = 0x00000100;
|
||||
private const uint RIDEV_DEVNOTIFY = 0x00002000; // WM_INPUT_DEVICE_CHANGE on hot-plug
|
||||
private const uint RID_INPUT = 0x10000003;
|
||||
private const uint RIDI_DEVICENAME = 0x20000007;
|
||||
private const uint RIM_TYPEKEYBOARD = 1;
|
||||
private const ushort RI_KEY_BREAK = 0x01; // set = key up (make/break)
|
||||
private const ushort HidUsagePageGeneric = 0x01;
|
||||
private const ushort HidUsageKeyboard = 0x06;
|
||||
|
||||
private static readonly int HeaderSize = Marshal.SizeOf<RAWINPUTHEADER>();
|
||||
|
||||
// --- State ---------------------------------------------------------------
|
||||
|
||||
// hDevice → interface path, so the hot per-keystroke path skips the
|
||||
// two-call GetRawInputDeviceInfo dance once a device is known.
|
||||
private readonly Dictionary<IntPtr, string> _pathByHandle = new();
|
||||
|
||||
private IntPtr _hwnd;
|
||||
private string? _target; // interface path of the keyboard to capture; null = disabled
|
||||
private bool _registered;
|
||||
private bool _disposed;
|
||||
|
||||
/// <summary>A key on the captured keyboard went down (.NET <see cref="Keys"/> name).</summary>
|
||||
public event Action<string>? KeyDown;
|
||||
|
||||
/// <summary>A key on the captured keyboard came up (.NET <see cref="Keys"/> name).</summary>
|
||||
public event Action<string>? KeyUp;
|
||||
|
||||
/// <summary>The set of attached keyboards changed (interface path, display name) — for a picker.</summary>
|
||||
public event Action<IReadOnlyList<(string Id, string Name)>>? KeyboardsChanged;
|
||||
|
||||
/// <summary>Status/diagnostic lines.</summary>
|
||||
public event Action<string>? Logged;
|
||||
|
||||
/// <summary>True while a specific keyboard is being captured (focus path should stand down).</summary>
|
||||
public bool IsCapturing => _target is not null;
|
||||
|
||||
/// <summary>Bind to the window whose message loop delivers <c>WM_INPUT</c>.</summary>
|
||||
public void Attach(IntPtr hwnd) => _hwnd = hwnd;
|
||||
|
||||
/// <summary>
|
||||
/// Capture one keyboard by interface path, or none (<paramref name="deviceId"/>
|
||||
/// null) to release input back to the focus path. Registering/unregistering
|
||||
/// Raw Input is scoped here so vRIO only taps the global key stream while the
|
||||
/// feature is actually in use.
|
||||
/// </summary>
|
||||
public void SetTarget(string? deviceId)
|
||||
{
|
||||
if (_target == deviceId)
|
||||
return;
|
||||
_target = deviceId;
|
||||
if (deviceId is null)
|
||||
Unregister();
|
||||
else
|
||||
Register();
|
||||
}
|
||||
|
||||
/// <summary>Re-enumerate keyboards and raise <see cref="KeyboardsChanged"/>.</summary>
|
||||
public void RefreshKeyboards()
|
||||
{
|
||||
_pathByHandle.Clear(); // handles are only stable per connection
|
||||
KeyboardsChanged?.Invoke(EnumerateKeyboards());
|
||||
}
|
||||
|
||||
/// <summary>Handle a <c>WM_INPUT_DEVICE_CHANGE</c>: a keyboard arrived or left.</summary>
|
||||
public void HandleDeviceChange() => RefreshKeyboards();
|
||||
|
||||
/// <summary>
|
||||
/// Handle a <c>WM_INPUT</c> message (pass its <c>LParam</c>). Silently ignores
|
||||
/// input from any keyboard other than the captured one.
|
||||
/// </summary>
|
||||
public void ProcessInput(IntPtr hRawInput)
|
||||
{
|
||||
string? target = _target;
|
||||
if (target is null)
|
||||
return;
|
||||
|
||||
uint size = 0;
|
||||
if (GetRawInputData(hRawInput, RID_INPUT, IntPtr.Zero, ref size, (uint)HeaderSize) == Err || size == 0)
|
||||
return;
|
||||
|
||||
IntPtr buffer = Marshal.AllocHGlobal((int)size);
|
||||
try
|
||||
{
|
||||
if (GetRawInputData(hRawInput, RID_INPUT, buffer, ref size, (uint)HeaderSize) != size)
|
||||
return;
|
||||
|
||||
var header = Marshal.PtrToStructure<RAWINPUTHEADER>(buffer);
|
||||
if (header.dwType != RIM_TYPEKEYBOARD)
|
||||
return;
|
||||
string? path = PathFor(header.hDevice);
|
||||
if (!string.Equals(path, target, StringComparison.OrdinalIgnoreCase))
|
||||
return;
|
||||
|
||||
var kb = Marshal.PtrToStructure<RAWKEYBOARD>(IntPtr.Add(buffer, HeaderSize));
|
||||
ushort vkey = kb.VKey;
|
||||
// 0 = no VK, 0xFF = fake key emitted as part of an escaped sequence.
|
||||
if (vkey is 0 or 0xFF)
|
||||
return;
|
||||
|
||||
string key = ((Keys)vkey).ToString();
|
||||
if ((kb.Flags & RI_KEY_BREAK) != 0)
|
||||
KeyUp?.Invoke(key);
|
||||
else
|
||||
KeyDown?.Invoke(key); // repeats while held are dropped by the router
|
||||
}
|
||||
finally
|
||||
{
|
||||
Marshal.FreeHGlobal(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (_disposed)
|
||||
return;
|
||||
_disposed = true;
|
||||
_target = null;
|
||||
Unregister();
|
||||
KeyDown = null;
|
||||
KeyUp = null;
|
||||
KeyboardsChanged = null;
|
||||
Logged = null;
|
||||
}
|
||||
|
||||
// --- Registration --------------------------------------------------------
|
||||
|
||||
private void Register()
|
||||
{
|
||||
if (_registered || _hwnd == IntPtr.Zero)
|
||||
return;
|
||||
var rid = new[]
|
||||
{
|
||||
new RAWINPUTDEVICE
|
||||
{
|
||||
usUsagePage = HidUsagePageGeneric,
|
||||
usUsage = HidUsageKeyboard,
|
||||
dwFlags = RIDEV_INPUTSINK | RIDEV_DEVNOTIFY, // background delivery + hot-plug notices
|
||||
hwndTarget = _hwnd,
|
||||
},
|
||||
};
|
||||
if (RegisterRawInputDevices(rid, 1, (uint)Marshal.SizeOf<RAWINPUTDEVICE>()))
|
||||
_registered = true;
|
||||
else
|
||||
Logged?.Invoke($"Raw keyboard capture unavailable (error {Marshal.GetLastWin32Error()})");
|
||||
}
|
||||
|
||||
private void Unregister()
|
||||
{
|
||||
if (!_registered)
|
||||
return;
|
||||
// RIDEV_REMOVE must pass a null target window, or the call fails.
|
||||
var rid = new[]
|
||||
{
|
||||
new RAWINPUTDEVICE
|
||||
{
|
||||
usUsagePage = HidUsagePageGeneric,
|
||||
usUsage = HidUsageKeyboard,
|
||||
dwFlags = RIDEV_REMOVE,
|
||||
hwndTarget = IntPtr.Zero,
|
||||
},
|
||||
};
|
||||
RegisterRawInputDevices(rid, 1, (uint)Marshal.SizeOf<RAWINPUTDEVICE>());
|
||||
_registered = false;
|
||||
}
|
||||
|
||||
// --- Enumeration / naming ------------------------------------------------
|
||||
|
||||
private List<(string Id, string Name)> EnumerateKeyboards()
|
||||
{
|
||||
var result = new List<(string, string)>();
|
||||
uint listSize = (uint)Marshal.SizeOf<RAWINPUTDEVICELIST>();
|
||||
uint count = 0;
|
||||
if (GetRawInputDeviceList(null, ref count, listSize) == Err || count == 0)
|
||||
return result;
|
||||
|
||||
var devices = new RAWINPUTDEVICELIST[count];
|
||||
uint got = GetRawInputDeviceList(devices, ref count, listSize);
|
||||
if (got == Err)
|
||||
return result;
|
||||
|
||||
var labelCounts = new Dictionary<string, int>();
|
||||
for (int i = 0; i < got; i++)
|
||||
{
|
||||
if (devices[i].dwType != RIM_TYPEKEYBOARD)
|
||||
continue;
|
||||
string? path = PathFor(devices[i].hDevice);
|
||||
if (string.IsNullOrEmpty(path))
|
||||
continue;
|
||||
|
||||
string label = FriendlyName(path!);
|
||||
// Physical keyboards can surface as more than one collection; a bare
|
||||
// count suffix keeps otherwise-identical labels distinguishable.
|
||||
if (labelCounts.TryGetValue(label, out int n))
|
||||
{
|
||||
labelCounts[label] = n + 1;
|
||||
label = $"{label} ({n + 1})";
|
||||
}
|
||||
else
|
||||
{
|
||||
labelCounts[label] = 1;
|
||||
}
|
||||
result.Add((path!, label));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private string? PathFor(IntPtr hDevice)
|
||||
{
|
||||
if (_pathByHandle.TryGetValue(hDevice, out string? cached))
|
||||
return cached;
|
||||
string? path = DeviceName(hDevice);
|
||||
if (path is not null)
|
||||
_pathByHandle[hDevice] = path;
|
||||
return path;
|
||||
}
|
||||
|
||||
private static string? DeviceName(IntPtr hDevice)
|
||||
{
|
||||
uint chars = 0;
|
||||
if (GetRawInputDeviceInfoW(hDevice, RIDI_DEVICENAME, IntPtr.Zero, ref chars) == Err || chars == 0)
|
||||
return null;
|
||||
|
||||
IntPtr buffer = Marshal.AllocHGlobal((int)chars * sizeof(char));
|
||||
try
|
||||
{
|
||||
if (GetRawInputDeviceInfoW(hDevice, RIDI_DEVICENAME, buffer, ref chars) == Err)
|
||||
return null;
|
||||
return Marshal.PtrToStringUni(buffer);
|
||||
}
|
||||
finally
|
||||
{
|
||||
Marshal.FreeHGlobal(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Turn a raw device interface path into something a human recognizes: the
|
||||
/// device's registry description if we can resolve it, else its VID:PID.
|
||||
/// </summary>
|
||||
private static string FriendlyName(string interfacePath)
|
||||
{
|
||||
string? desc = RegistryName(interfacePath);
|
||||
if (!string.IsNullOrWhiteSpace(desc))
|
||||
return desc!;
|
||||
|
||||
Match m = Regex.Match(interfacePath, @"VID_([0-9A-Fa-f]{4}).*?PID_([0-9A-Fa-f]{4})");
|
||||
return m.Success
|
||||
? $"Keyboard {m.Groups[1].Value.ToUpperInvariant()}:{m.Groups[2].Value.ToUpperInvariant()}"
|
||||
: "Keyboard";
|
||||
}
|
||||
|
||||
private static string? RegistryName(string interfacePath)
|
||||
{
|
||||
try
|
||||
{
|
||||
// \\?\HID#VID_x&PID_y#instance#{class-guid} → Enum key HID\VID_x&PID_y\instance
|
||||
string s = interfacePath;
|
||||
if (s.StartsWith(@"\\?\", StringComparison.Ordinal) || s.StartsWith(@"\\.\", StringComparison.Ordinal))
|
||||
s = s.Substring(4);
|
||||
int guid = s.LastIndexOf("#{", StringComparison.Ordinal);
|
||||
if (guid >= 0)
|
||||
s = s.Substring(0, guid);
|
||||
string instance = s.Replace('#', '\\');
|
||||
|
||||
using RegistryKey? key = Registry.LocalMachine.OpenSubKey(
|
||||
@"SYSTEM\CurrentControlSet\Enum\" + instance);
|
||||
if (key is null)
|
||||
return null;
|
||||
|
||||
string? name = key.GetValue("FriendlyName") as string;
|
||||
if (string.IsNullOrWhiteSpace(name))
|
||||
name = key.GetValue("DeviceDesc") as string;
|
||||
if (string.IsNullOrWhiteSpace(name))
|
||||
return null;
|
||||
|
||||
// DeviceDesc is "@driver.inf,%token%;Actual Name" — keep the tail.
|
||||
int semi = name!.LastIndexOf(';');
|
||||
return semi >= 0 ? name.Substring(semi + 1) : name;
|
||||
}
|
||||
catch (Exception ex) when (ex is System.Security.SecurityException or UnauthorizedAccessException or IOException)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -8,18 +8,47 @@
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<LangVersion>latest</LangVersion>
|
||||
<ApplicationManifest>app.manifest</ApplicationManifest>
|
||||
<ApplicationIcon>vwe.ico</ApplicationIcon>
|
||||
<AssemblyTitle>vRIO — Virtual RIO device</AssemblyTitle>
|
||||
<!-- StampGitVersion already puts the sha in InformationalVersion; stop the
|
||||
SDK appending "+fullsha" on top of it. -->
|
||||
<IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\VRio.Core\VRio.Core.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
<!-- Stamp commit date + short sha into InformationalVersion; the window
|
||||
title shows it (Application.ProductVersion) so a running build can be
|
||||
matched to its vYYYY.MM.DD release tag at a glance. Falls back to the
|
||||
default 1.0.0 when git isn't available. -->
|
||||
<Target Name="StampGitVersion" BeforeTargets="GetAssemblyVersion" Condition="'$(DesignTimeBuild)' != 'true'">
|
||||
<!-- %%cs survives cmd's percent expansion as %cs: committer date, YYYY-MM-DD. -->
|
||||
<Exec Command="git -C "$(MSBuildProjectDirectory)" log -1 --format=%%cs"
|
||||
ConsoleToMSBuild="true" StandardOutputImportance="low" IgnoreExitCode="true" ContinueOnError="true">
|
||||
<Output TaskParameter="ConsoleOutput" PropertyName="GitCommitDate" />
|
||||
<Output TaskParameter="ExitCode" PropertyName="GitDateExitCode" />
|
||||
</Exec>
|
||||
<!-- The exclude flag keeps describe off the release tags: always the short
|
||||
sha, with a "dirty" suffix when the working tree has local edits. -->
|
||||
<Exec Command="git -C "$(MSBuildProjectDirectory)" describe --always --dirty --exclude=*"
|
||||
ConsoleToMSBuild="true" StandardOutputImportance="low" IgnoreExitCode="true" ContinueOnError="true">
|
||||
<Output TaskParameter="ConsoleOutput" PropertyName="GitShortSha" />
|
||||
</Exec>
|
||||
<PropertyGroup Condition="'$(GitDateExitCode)' == '0' And '$(GitShortSha)' != ''">
|
||||
<InformationalVersion>$(GitCommitDate.Trim().Replace('-', '.')) ($(GitShortSha))</InformationalVersion>
|
||||
</PropertyGroup>
|
||||
</Target>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="PolySharp" Version="1.14.1">
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
</PackageReference>
|
||||
<!-- WinRT projections for Windows.Devices.Lights (Dynamic Lighting /
|
||||
LampArray) on .NET Framework — the keyboard lamp mirror. -->
|
||||
<PackageReference Include="Microsoft.Windows.SDK.Contracts" Version="10.0.22621.3233" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 2.9 KiB |
@@ -57,6 +57,15 @@ public sealed class VRioDevice
|
||||
/// <summary>Firmware version reported by VersionReply (real boards run 4.2).</summary>
|
||||
public byte VersionMinor { get; set; } = 2;
|
||||
|
||||
/// <summary>
|
||||
/// The wire natively carries stick-up as negative (full up = −80 in
|
||||
/// AnalogReply); set this to send the physical direction (up = positive)
|
||||
/// instead. Only the host sees the difference — local state
|
||||
/// (<see cref="GetAxis"/>, the panel's dot) keeps the physical stick
|
||||
/// direction either way.
|
||||
/// </summary>
|
||||
public bool InvertJoystickY { get; set; }
|
||||
|
||||
/// <summary>
|
||||
/// When true, retry exhaustion leaves the analog reply path wedged (the
|
||||
/// v4.2 latch-leak bug) until a host ResetRequest clears it.
|
||||
@@ -101,6 +110,21 @@ public sealed class VRioDevice
|
||||
lock (_gate) return _axes[(int)axis];
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Axis value as the next AnalogReply will carry it — same as
|
||||
/// <see cref="GetAxis"/> except joystick Y follows the wire convention
|
||||
/// (see <see cref="InvertJoystickY"/>).
|
||||
/// </summary>
|
||||
public short GetWireAxis(RioAxis axis)
|
||||
{
|
||||
short value = GetAxis(axis);
|
||||
return axis == RioAxis.JoystickY ? WireY(value) : value;
|
||||
}
|
||||
|
||||
private short WireY(short y) => InvertJoystickY
|
||||
? y
|
||||
: (short)Math.Min(AnalogCodec.Max, -y); // clamp: -Min (8192) is one past the 14-bit Max
|
||||
|
||||
/// <summary>
|
||||
/// Move an axis. Values are clamped to the 14-bit signed range the wire
|
||||
/// can carry; the new value is returned by the next AnalogReply.
|
||||
@@ -274,7 +298,7 @@ public sealed class VRioDevice
|
||||
y = _axes[(int)RioAxis.JoystickY];
|
||||
x = _axes[(int)RioAxis.JoystickX];
|
||||
}
|
||||
Send(PacketBuilder.AnalogReply(t, l, r, y, x));
|
||||
Send(PacketBuilder.AnalogReply(t, l, r, WireY(y), x));
|
||||
break;
|
||||
|
||||
case RioCommand.ResetRequest:
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<TargetFramework>net48</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<LangVersion>latest</LangVersion>
|
||||
<IsPackable>false</IsPackable>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
|
||||
<PackageReference Include="xunit" Version="2.9.2" />
|
||||
<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
|
||||
<PackageReference Include="PolySharp" Version="1.14.1">
|
||||
<PrivateAssets>all</PrivateAssets>
|
||||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
|
||||
</PackageReference>
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="..\..\src\VPlasma.Core\VPlasma.Core.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
@@ -0,0 +1,307 @@
|
||||
using VPlasma.Core.Device;
|
||||
using Xunit;
|
||||
|
||||
namespace VPlasma.Core.Tests;
|
||||
|
||||
public class VPlasmaDeviceTests
|
||||
{
|
||||
private const byte Esc = 0x1B;
|
||||
|
||||
private static void Feed(VPlasmaDevice device, params byte[] bytes)
|
||||
=> device.OnReceived(bytes, bytes.Length);
|
||||
|
||||
private static void Feed(VPlasmaDevice device, IEnumerable<byte> bytes)
|
||||
{
|
||||
byte[] arr = bytes.ToArray();
|
||||
device.OnReceived(arr, arr.Length);
|
||||
}
|
||||
|
||||
private static byte Pixel(VPlasmaDevice device, int x, int y)
|
||||
{
|
||||
var frame = new byte[VPlasmaDevice.Width * VPlasmaDevice.Height];
|
||||
device.CopyFrame(frame);
|
||||
return frame[y * VPlasmaDevice.Width + x];
|
||||
}
|
||||
|
||||
/// <summary>A full-width ESC P row the way L4PLASMA.CPP sends one.</summary>
|
||||
private static byte[] GraphicsRow(int y, params byte[] data)
|
||||
{
|
||||
var row = new List<byte> { Esc, (byte)'P', 0, (byte)y, 0, (byte)data.Length, 1 };
|
||||
row.AddRange(data);
|
||||
return row.ToArray();
|
||||
}
|
||||
|
||||
// ---- graphics writes -------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public void GraphicsRow_SetsPixelsMsbFirst()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, GraphicsRow(5, 0x80, 0x01)); // xbyte 0..1
|
||||
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 5)); // MSB of byte 0
|
||||
Assert.Equal(0, Pixel(device, 1, 5));
|
||||
Assert.Equal(0, Pixel(device, 14, 5));
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 15, 5)); // LSB of byte 1
|
||||
Assert.Equal(0, Pixel(device, 0, 4));
|
||||
Assert.Equal(0, Pixel(device, 0, 6));
|
||||
Assert.Equal(1, device.GraphicsRows);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GraphicsRow_SurvivesAnyChunkBoundary()
|
||||
{
|
||||
byte[] wire = GraphicsRow(3, Enumerable.Repeat((byte)0xFF, 16).ToArray());
|
||||
|
||||
// Split the same command at every possible boundary.
|
||||
for (int split = 1; split < wire.Length; ++split)
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
device.OnReceived(wire, split);
|
||||
byte[] rest = wire.Skip(split).ToArray();
|
||||
device.OnReceived(rest, rest.Length);
|
||||
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 3));
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 127, 3));
|
||||
Assert.Equal(1, device.GraphicsRows);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GraphicsBlock_MultipleRowsAdvanceY()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
// screen 0, y=10, xbyte=0, 1 byte/row, 3 rows.
|
||||
Feed(device, Esc, (byte)'P', 0, 10, 0, 1, 3, 0x80, 0x80, 0x80);
|
||||
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 10));
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 11));
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 12));
|
||||
Assert.Equal(0, Pixel(device, 0, 13));
|
||||
Assert.Equal(3, device.GraphicsRows);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GraphicsWrite_HonorsByteColumnOffset()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, Esc, (byte)'P', 0, 0, 2, 1, 1, 0xFF); // xbyte=2 → x 16..23
|
||||
|
||||
Assert.Equal(0, Pixel(device, 15, 0));
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 16, 0));
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 23, 0));
|
||||
Assert.Equal(0, Pixel(device, 24, 0));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GraphicsWrite_OutOfRangeRowIsConsumedNotDrawn()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, GraphicsRow(40, Enumerable.Repeat((byte)0xFF, 16).ToArray()));
|
||||
Feed(device, (byte)'!'); // parser must be back in text mode
|
||||
|
||||
var frame = new byte[VPlasmaDevice.Width * VPlasmaDevice.Height];
|
||||
device.CopyFrame(frame);
|
||||
Assert.Equal(1, device.TextCharsDrawn);
|
||||
Assert.Equal(0, device.GraphicsRows);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GraphicsWrite_OverwritesTextAttributes()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, Esc, (byte)'H', 4); // flashing text
|
||||
Feed(device, (byte)'H'); // glyph col 0 is a full bar at x=0
|
||||
Assert.Equal(VPlasmaDevice.PixelLit | VPlasmaDevice.PixelFlash, Pixel(device, 0, 0));
|
||||
|
||||
Feed(device, GraphicsRow(0, 0x80)); // repaint that row from the wire
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 0));
|
||||
}
|
||||
|
||||
// ---- text mode ---------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public void Text_DrawsGlyphAndAdvancesCursor()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, (byte)'H'); // 5×7 'H': column 0 = 0x7F (all seven rows)
|
||||
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 0));
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 6));
|
||||
Assert.Equal(0, Pixel(device, 0, 7)); // gap row
|
||||
Assert.Equal(0, Pixel(device, 5, 0)); // gap column
|
||||
Assert.Equal(new VPlasmaDevice.Point(1, 0), device.CursorCell);
|
||||
Assert.Equal(1, device.TextCharsDrawn);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ControlChars_MoveTheCursor()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
|
||||
Feed(device, 0x09, 0x09, 0x09); // HT ×3
|
||||
Assert.Equal(new VPlasmaDevice.Point(3, 0), device.CursorCell);
|
||||
|
||||
Feed(device, 0x08); // BS
|
||||
Assert.Equal(new VPlasmaDevice.Point(2, 0), device.CursorCell);
|
||||
|
||||
Feed(device, 0x0A); // LF
|
||||
Assert.Equal(new VPlasmaDevice.Point(2, 1), device.CursorCell);
|
||||
|
||||
Feed(device, 0x0D); // CR
|
||||
Assert.Equal(new VPlasmaDevice.Point(0, 1), device.CursorCell);
|
||||
|
||||
Feed(device, 0x0B); // VT
|
||||
Assert.Equal(new VPlasmaDevice.Point(0, 0), device.CursorCell);
|
||||
|
||||
Feed(device, 0x0B); // VT off the top wraps to the bottom row
|
||||
Assert.Equal(new VPlasmaDevice.Point(0, 3), device.CursorCell);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Text_WrapsAtRowAndScreenEnd()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, Enumerable.Repeat((byte)'X', 22)); // one full 21-cell row + 1
|
||||
|
||||
Assert.Equal(new VPlasmaDevice.Point(1, 1), device.CursorCell);
|
||||
|
||||
Feed(device, Enumerable.Repeat((byte)'X', 21 * 3 - 1)); // exactly to the end
|
||||
Assert.Equal(new VPlasmaDevice.Point(0, 0), device.CursorCell); // wrapped to top
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EscAt_ClearsScreenAndResetsTextState()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, Esc, (byte)'K', 4, Esc, (byte)'H', 1, (byte)'H');
|
||||
Feed(device, Esc, (byte)'@');
|
||||
|
||||
Assert.Equal(0, Pixel(device, 0, 0));
|
||||
Assert.Equal(new VPlasmaDevice.Point(0, 0), device.CursorCell);
|
||||
Assert.Equal(0, device.Font);
|
||||
Assert.Equal(PlasmaAttributes.None, device.Attributes);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EscL_HomesCursorWithoutClearing()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, (byte)'H', Esc, (byte)'L');
|
||||
|
||||
Assert.Equal(new VPlasmaDevice.Point(0, 0), device.CursorCell);
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 0)); // glyph survives
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(0x00, PlasmaCursorMode.Hidden)] // the game's cursor-off
|
||||
[InlineData(0xFF, PlasmaCursorMode.Hidden)] // the test tool's hide
|
||||
[InlineData(0x01, PlasmaCursorMode.Steady)]
|
||||
[InlineData(0x03, PlasmaCursorMode.Flashing)]
|
||||
public void EscG_SetsCursorMode(byte operand, PlasmaCursorMode expected)
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, Esc, (byte)'G', operand);
|
||||
Assert.Equal(expected, device.CursorMode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EscK_SelectsFontGrids()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
|
||||
Feed(device, Esc, (byte)'K', 4); // large: 12×16 cells
|
||||
Assert.Equal(4, device.Font);
|
||||
Assert.Equal(12, device.CellWidth);
|
||||
Assert.Equal(16, device.CellHeight);
|
||||
|
||||
Feed(device, (byte)'A'); // large glyph: 'A' col 1 (0x11) row 0 → 2×2 dots at (2..3, 0..1)
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 2, 0));
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 3, 1));
|
||||
|
||||
Feed(device, Esc, (byte)'K', 0xFF); // FF → default font 0
|
||||
Assert.Equal(0, device.Font);
|
||||
Assert.Equal(6, device.CellWidth);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EscH_AppliesAttributes()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
|
||||
Feed(device, Esc, (byte)'H', 1, (byte)'H'); // half intensity
|
||||
Assert.Equal(VPlasmaDevice.PixelLit | VPlasmaDevice.PixelHalf, Pixel(device, 0, 0));
|
||||
|
||||
Feed(device, Esc, (byte)'H', 2, (byte)'H'); // underline: gap row lit
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 6, 7));
|
||||
|
||||
Feed(device, Esc, (byte)'H', 3, (byte)' '); // reverse: a space renders solid
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 12, 0));
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 17, 7));
|
||||
|
||||
Feed(device, Esc, (byte)'H', 0xFF, (byte)'H'); // defaults restored
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 18, 0));
|
||||
Assert.Equal(0, Pixel(device, 18, 7));
|
||||
Assert.Equal(PlasmaAttributes.None, device.Attributes);
|
||||
}
|
||||
|
||||
// ---- robustness ----------------------------------------------------------
|
||||
|
||||
[Fact]
|
||||
public void UnknownEscape_IsConsumedAndTextResumes()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, Esc, (byte)'Z', (byte)'H');
|
||||
|
||||
Assert.Equal(1, device.TextCharsDrawn);
|
||||
Assert.Equal(VPlasmaDevice.PixelLit, Pixel(device, 0, 0));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GameStartupSequence_HidesCursor()
|
||||
{
|
||||
// L4PLASMA.CPP's constructor sends exactly ESC 'G' 0x00.
|
||||
var device = new VPlasmaDevice();
|
||||
Assert.Equal(PlasmaCursorMode.Steady, device.CursorMode); // power-on default
|
||||
|
||||
Feed(device, 27, (byte)'G', 0x00);
|
||||
Assert.Equal(PlasmaCursorMode.Hidden, device.CursorMode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SelfTestPages_ParseWithoutUnknownCommands()
|
||||
{
|
||||
for (int page = 0; page < PlasmaSelfTest.PageCount; ++page)
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
var complaints = new List<string>();
|
||||
device.Logged += line =>
|
||||
{
|
||||
if (line.StartsWith("Unknown", StringComparison.Ordinal)
|
||||
|| line.StartsWith("Unhandled", StringComparison.Ordinal))
|
||||
complaints.Add(line);
|
||||
};
|
||||
|
||||
byte[] bytes = PlasmaSelfTest.BuildPage(page);
|
||||
device.OnReceived(bytes, bytes.Length);
|
||||
|
||||
Assert.Empty(complaints);
|
||||
Assert.True(device.BytesReceived > 0);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Reset_RestoresPowerOnState()
|
||||
{
|
||||
var device = new VPlasmaDevice();
|
||||
Feed(device, Esc, (byte)'K', 5, Esc, (byte)'H', 4, Esc, (byte)'G', 0, (byte)'H');
|
||||
|
||||
device.Reset();
|
||||
|
||||
Assert.Equal(0, Pixel(device, 0, 0));
|
||||
Assert.Equal(0, device.Font);
|
||||
Assert.Equal(PlasmaAttributes.None, device.Attributes);
|
||||
Assert.Equal(PlasmaCursorMode.Steady, device.CursorMode);
|
||||
Assert.Equal(new VPlasmaDevice.Point(0, 0), device.CursorCell);
|
||||
}
|
||||
}
|
||||
@@ -48,6 +48,7 @@ public class VRioDeviceTests
|
||||
var device = new VRioDevice();
|
||||
var wire = new Wire(device);
|
||||
device.SetAxis(RioAxis.Throttle, 1000);
|
||||
device.SetAxis(RioAxis.JoystickY, 3000);
|
||||
device.SetAxis(RioAxis.JoystickX, -5000);
|
||||
|
||||
Send(device, PacketBuilder.Build(RioCommand.AnalogRequest));
|
||||
@@ -60,11 +61,47 @@ public class VRioDeviceTests
|
||||
Assert.Equal(1000, AnalogCodec.Combine(p[0], p[1])); // throttle
|
||||
Assert.Equal(0, AnalogCodec.Combine(p[2], p[3])); // left pedal
|
||||
Assert.Equal(0, AnalogCodec.Combine(p[4], p[5])); // right pedal
|
||||
Assert.Equal(0, AnalogCodec.Combine(p[6], p[7])); // joystick Y
|
||||
Assert.Equal(-3000, AnalogCodec.Combine(p[6], p[7])); // joystick Y (up is negative on the wire)
|
||||
Assert.Equal(-5000, AnalogCodec.Combine(p[8], p[9])); // joystick X
|
||||
Assert.Equal(1, device.AnalogRequests);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Joystick_Y_is_negated_on_the_wire_but_not_locally()
|
||||
{
|
||||
var device = new VRioDevice();
|
||||
var wire = new Wire(device);
|
||||
device.SetAxis(RioAxis.JoystickY, 3000);
|
||||
|
||||
Send(device, PacketBuilder.Build(RioCommand.AnalogRequest));
|
||||
|
||||
byte[] p = Assert.Single(wire.Packets).Payload;
|
||||
Assert.Equal(-3000, AnalogCodec.Combine(p[6], p[7]));
|
||||
Assert.Equal(3000, device.GetAxis(RioAxis.JoystickY)); // the panel's dot is unflipped
|
||||
Assert.Equal(-3000, device.GetWireAxis(RioAxis.JoystickY)); // the panel's readout matches the wire
|
||||
|
||||
// Full negative deflection: -Min is one past Max, so it clamps rather than throws.
|
||||
device.SetAxis(RioAxis.JoystickY, AnalogCodec.Min);
|
||||
wire.Clear();
|
||||
Send(device, PacketBuilder.Build(RioCommand.AnalogRequest));
|
||||
p = Assert.Single(wire.Packets).Payload;
|
||||
Assert.Equal(AnalogCodec.Max, AnalogCodec.Combine(p[6], p[7]));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void InvertJoystickY_sends_the_physical_direction_instead()
|
||||
{
|
||||
var device = new VRioDevice { InvertJoystickY = true };
|
||||
var wire = new Wire(device);
|
||||
device.SetAxis(RioAxis.JoystickY, 3000);
|
||||
|
||||
Send(device, PacketBuilder.Build(RioCommand.AnalogRequest));
|
||||
|
||||
byte[] p = Assert.Single(wire.Packets).Payload;
|
||||
Assert.Equal(3000, AnalogCodec.Combine(p[6], p[7]));
|
||||
Assert.Equal(3000, device.GetWireAxis(RioAxis.JoystickY));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void VersionRequest_reports_configured_firmware()
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user