Add Verilator simulation (ImGui + headless)

verilator/ runs the core on the host with the shared FM-7 / Apple-IIgs sim
framework: windowed (ImGui/SDL2) or --headless, typing on a frame schedule,
screenshots, text-screen dump, 6809 disassembly trace, floppy/SDC/cart/cassette,
and RS-232 Pak serial debugging (TXD decoder, RXD driver, pty bridge, ACIA
trace) with a minimal DriveWire server and a script to run the real FujiNet
daemon against the sim. See verilator/README.md.

- The VHDL the build uses (ROMs, RAMs, font) is converted to Verilog in
  verilator/rtl/; the VHDL CPU is not instantiated (CoCo3_CYC_ACC_6809).
- sdram2.sv is simulated with its own controller logic and an SDR chip model.
- run_tests.sh: boot, keyboard, disk, WIDTH 80 and HSCREEN tests, judged on
  the text screen and byte-for-byte against test-ref/ screenshots.

rtl/wd1793.sv: spt_addr and buff_wr are declared at module scope instead of
inside generate blocks. They are assigned outside those blocks; Quartus
accepted it, Verilator rejected spt_addr and silently split buff_wr into a
separate net. No change on the FPGA (FM-7 made the same fix).

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
This commit is contained in:
Alan SterembergandClaude Opus 5.5 committed 2026-10-02 07:15:44 -04:00
1 parent aae1ceabf1
commit 874f4f3083
79 files changed
+81058 -2

No files matched your search

+11 -2
View File
@@ -99,6 +99,11 @@ reg [1:0] wd_size_code;
wire [7:0] buff_dout;
reg [1:0] sd_block = 0;
reg format;
// buff_wr is assigned from always blocks outside the `generate if(RWMODE)`
// block it used to be declared in (after the wd1793_dpram that reads it). Those
// assignments then resolve to a separate implicit net in Verilator, so the
// sector-buffer write strobe never reached the RAM. Declared here instead.
reg buff_wr;
generate
if(RWMODE) begin
wd1793_dpram sbuf
@@ -115,7 +120,6 @@ generate
.wren_b(wre & buff_wr & (addr == A_DATA) & ~scan_active),
.q_b(buff_dout)
);
reg buff_wr;
end else begin
assign buff_dout = 0;
assign sd_buff_din = 0;
@@ -788,13 +792,18 @@ wire[10:0] edsk_next = ((edsk_addr + 1'd1) >= edsk_size) ? 11'd0 : edsk_addr + 1
reg [7:0] spt_size = 0;
// spt_addr is assigned from the always block above, outside the
// `generate if(EDSK)` scope it used to be declared in. Quartus tolerates that,
// but Verilator rejects it ("Can't find definition of variable: 'spt_addr'"),
// so it lives at module scope, next to spt_size. No behavioural change.
reg [7:0] spt_addr;
generate
if(EDSK) begin
wire [7:0] scan_data = RWMODE ? buff_dout : input_data;
reg [53:0] edsk[1992];
reg [7:0] spt[166];
reg [7:0] spt_addr;
always @(posedge clk_sys) begin
{edsk_track,edsk_side,edsk_trackf,edsk_sidef,edsk_sector,edsk_sizecode,edsk_offset} <= edsk[edsk_addr];
edsk_spt <= spt[spt_addr];
+12
View File
@@ -0,0 +1,12 @@
*.vcd
dw_boot*
fujinet_boot*/
fujinet_boot/
imgui.ini
obj_dir/
roms/*.rom
screenshot_*.png
test-out*/
test-out/
tests/hello.dsk
trace*.txt
+157
View File
@@ -0,0 +1,157 @@
#============================================================================
# CoCo3 Verilator simulation
#
# Same layout as the FM-7 and Apple-IIgs sims: sim.v stands in for CoCo3.sv,
# sim/ is the shared ImGui/SDL framework, and one binary runs either windowed
# or with --headless.
#
# make build ./obj_dir/Vemu
# make run build and launch the windowed sim
# make headless build and boot to BASIC headless, screenshot at the end
# make test build and run the headless smoke test (run_tests.sh)
# make lint elaborate the design only
# make mem regenerate rtl/*.mem from the VHDL/MIF sources
# make clean
#
# No ghdl step. The build uses the Verilog cycle-accurate 6809 (mc6809glb.v,
# selected by CoCo3_CYC_ACC_6809 in rtl/config.sv), and the VHDL entities it
# does instantiate -- ROMs, RAMs, the font -- are converted by hand in rtl/:
#
# rtl/rom/coco_rom_32K.vhd, coco_rom_8K.vhd, coco_rom_cart.vhd,
# coco_rom_16.vhd, coco3_char_rom.vhd -> rtl/coco_rom.v
# rtl/sram/coco_ram.vhd, coco_vid_ram_buf.vhd -> rtl/coco_sram.v
#
# Quartus-only pieces are replaced as well: rtl/VDAC.v (altsyncram) by
# rtl/VDAC.v here, rtl/sdram/sdram2.sv by rtl/sdram2.sv here (same controller,
# chip model instead of pins), and the PLL by clocks driven from sim_main.
#============================================================================
V = verilator
RTL = ../rtl
TOP = --top-module emu
# Verilator 5 demands --no-timing for the cosmetic `#` delays; 4.x rejects the
# flag. Same probe as the FM-7 Makefile.
VERILATOR_MAJOR := $(shell verilator --version 2>/dev/null | sed -n 's/^Verilator \([0-9][0-9]*\).*/\1/p')
NO_TIMING := $(if $(filter 4,$(VERILATOR_MAJOR)),,--no-timing)
# -Wno-PROCASSWIRE: coco3fpga.sv and fdc.sv declare a number of registers as
# `wire` and assign them in always blocks (Build_Info, VMA, PIX_CLK_D, the $FF40
# latch, ...). Quartus accepts that and so does Verilator once the check is
# waived; the RTL is left as it is.
V_DEFINE = +define+SIMULATION=1 -Wno-PROCASSWIRE \
--timescale-override 1ps/1ps -Wno-TIMESCALEMOD -Wno-fatal \
$(NO_TIMING) --converge-limit 6000 \
-I$(RTL)
# VCD tracing: `make clean && make TRACE=1`, then run with --vcd <file> and a
# --trace-from/--trace-until window (a 114 MHz design dumps ~1 GB a frame).
ifeq ($(TRACE),1)
V_DEFINE += --trace
CXX_DEFINE += -DVM_TRACE_VCD=1
else
CXX_DEFINE += -DVM_TRACE_VCD=0
endif
UNAME_S := $(shell uname -s)
ifeq ($(UNAME_S), Darwin)
LIBS += -framework OpenGL -framework Cocoa -framework IOKit -framework CoreVideo `sdl2-config --libs`
LIBS += -L/usr/local/lib -L/opt/local/lib -L/opt/homebrew/lib
CXXFLAGS += `sdl2-config --cflags`
CXXFLAGS += `sdl2-config --cflags | sed 's|include/SDL2|include/|'`
CXXFLAGS += -I/usr/local/include -I/opt/local/include -I/opt/homebrew/include
endif
ifeq ($(UNAME_S), Linux)
LIBS += -lGL -ldl `sdl2-config --libs`
CXXFLAGS += `sdl2-config --cflags`
endif
ifeq ($(findstring MINGW,$(UNAME_S)),MINGW)
LIBS += -lgdi32 -lopengl32 -limm32 `pkg-config --static --libs sdl2`
CXXFLAGS += `pkg-config --cflags sdl2`
endif
CC_OPT = -O2
V_OPT = -O3 --x-assign fast --x-initial fast --noassert
CXXFLAGS += $(CC_OPT) $(CXX_DEFINE) -I../sim/imgui -I../sim -I.. -g
LDFLAGS = $(LIBS)
EXE = ./obj_dir/Vemu
V_SRC = \
sim.vlt \
sim.v \
rtl/sdram2.sv \
rtl/coco_rom.v \
rtl/coco_sram.v \
rtl/VDAC.v \
../sys/hps_io.sv \
$(RTL)/coco3fpga.sv \
$(RTL)/EE_Cold_Bt.v \
$(RTL)/cassette.v \
$(RTL)/square_gen.v \
$(RTL)/AMW.v \
$(RTL)/rtc.sv \
$(RTL)/fdc.sv \
$(RTL)/wd1793.sv \
$(RTL)/sdc.sv \
$(RTL)/sdc_top.sv \
$(RTL)/Auto_Run.sv \
$(RTL)/ps2_mouse.v \
$(RTL)/coco_mem_fetch.sv \
$(RTL)/Cassette_Write.sv \
$(RTL)/cocokey.v \
$(RTL)/PS2_Key/ps2_keyboard.v \
$(RTL)/UART_6551/uart_6551.v \
$(RTL)/UART_6551/6551tx.v \
$(RTL)/UART_6551/6551rx.v \
$(RTL)/mc6809glb/mc6809glb.v \
$(RTL)/Mister_Video.v \
$(RTL)/Mister_Video_GIMEX.v
C_SRC = \
sim_main.cpp dis6809.cpp serial.cpp \
sim/sim_bus.cpp sim/sim_clock.cpp sim/sim_console.cpp sim/sim_video.cpp \
sim/sim_blkdevice.cpp sim/sim_input.cpp sim/sim_audio.cpp \
sim/imgui/imgui_impl_sdl.cpp sim/imgui/imgui_impl_opengl2.cpp \
sim/imgui/imgui_draw.cpp sim/imgui/imgui_widgets.cpp sim/imgui/imgui_tables.cpp \
sim/imgui/imgui.cpp sim/imgui/ImGuiFileDialog.cpp \
sim/imgui/implot.cpp sim/imgui/implot_items.cpp
VOUT = obj_dir/Vemu.cpp
all: $(EXE)
$(VOUT): $(V_SRC) Makefile
$V -cc $(V_OPT) -LDFLAGS "$(LDFLAGS)" -exe --Mdir ./obj_dir \
$(V_DEFINE) $(TOP) -CFLAGS "$(CXXFLAGS)" $(V_SRC) $(C_SRC)
$(EXE): $(VOUT) $(C_SRC) sim/*.h dis6809.h serial.h
(cd obj_dir; $(MAKE) -f Vemu.mk OBJCACHE= OPT_FAST="-O2" OPT_SLOW="-O0" OPT_GLOBAL="-O2")
lint:
$V --lint-only $(V_DEFINE) -Wno-WIDTH $(TOP) $(V_SRC)
mem:
python3 gen_mem.py
run: all
$(EXE)
headless: all
$(EXE) --headless --stop-at-frame 150 --screenshot 150
test: all
./run_tests.sh
clean:
rm -rf obj_dir
.PHONY: all lint mem run headless test clean
# Disassembler self-check. Standalone -- no Verilator, no core.
distest: dis6809_test.cpp dis6809.cpp dis6809.h
mkdir -p obj_dir && c++ -O1 -o obj_dir/distest dis6809_test.cpp dis6809.cpp -I. && ./obj_dir/distest
.PHONY: distest
+271
View File
@@ -0,0 +1,271 @@
# CoCo3 Verilator simulation
Runs the core on the host, windowed (ImGui + SDL2) or headless, so you can boot
it, type at it, mount disks, screenshot it and trace the 6809, without a
DE10-Nano or a Quartus build.
It uses the same framework as the FM-7 and Apple-IIgs sims: `sim.v` stands in
for `CoCo3.sv`, `sim/` is the shared ImGui/SDL harness (`sim_bus`, `sim_video`,
`sim_input`, `sim_blkdevice`, ...), and one binary does both modes.
## Build and run
```sh
cd verilator
make # -> ./obj_dir/Vemu
make run # windowed
make headless # boot headless to frame 150, screenshot
make test # headless smoke tests (run_tests.sh)
make lint # elaborate only
```
Needs Verilator 5 (built and tested with 5.044), SDL2, and Python 3 for the
generators (`brew install verilator sdl2`). **Run the binary from this
directory**: the ROM defaults and the `$readmemh` images under `rtl/` are
relative paths.
### ROMs
The core loads its ROMs over ioctl at start-up, the way Main_MiSTer does, so
the sim needs the same two files the MiSTer SD card has in `games/CoCo3/`:
| file | contents | ioctl index |
|---|---|---|
| `roms/boot0.rom` | CoCo 3 ROM (32K, `coco3.rom`) | 0 |
| `roms/boot1.rom` | Disk BASIC 1.1 (8K, `disk11.rom`) | 64 |
They are not in git (`roms/*.rom` is ignored). Copy them from your MiSTer, or
from ToolShed's `cocoroms/` build. `--rom` / `--disk-rom` point elsewhere.
## Headless
```sh
# Boot and print the text screen
./obj_dir/Vemu --headless --stop-at-frame 150 --ascii-end
# Type at BASIC; {RETURN} or \n for Enter, {BREAK}, {CLEAR}, {UP}...
./obj_dir/Vemu --headless --stop-at-frame 260 --type '140:PRINT 2+2\n' --ascii-end
# Floppy in drive 0 (selects MPI slot 4), load and run a program
./obj_dir/Vemu --headless --disk tests/hello.dsk --stop-at-frame 420 \
--type '140:RUN"HELLO\n' --screenshot 420
# Disassembly trace of frames 10-11
./obj_dir/Vemu --headless --stop-at-frame 11 --trace-cpu trace.txt --trace-from 10
```
`--help` lists everything: cartridge (`--cart`), cassette (`--cas`), CoCoSDC
(`--sdc`), memory size, turbo speed, artifact mode, `--frame-log` (per-frame
framebuffer hash + instruction count), `--trace-bus`, `--vcd`.
BASIC's banner appears around frame 130. Most of that is the core itself:
`coco3fpga.sv` holds `RESET_N` for 143 ms and `CPU_RESET` for 286 ms after
power-on, and the first frame only appears once the video timing leaves reset.
Type from frame 140 on.
`--ascii` prints the 32×16 VDG screen at `$0400` as the CPU last wrote it (from
a shadow of the CPU bus). That is what the tests judge. It does not follow
`WIDTH 40/80` or graphics modes; use a screenshot for those.
Typed keys are held 2 frames with a 2-frame gap, plus 30 frames after each
RETURN (`--key-hold`, `--key-gap`, `--return-gap`). The CoCo has no type-ahead:
while BASIC runs a line it does not scan the keyboard, so keys pressed then are
lost, on the real machine as well as here.
### Tests
`./run_tests.sh [name...]` runs these in parallel (about 8 minutes in all):
| test | does | judged on |
|---|---|---|
| `boot` | power on, wait for the banner | text screen: `DISK EXTENDED COLOR BASIC 2.1`, `OK` |
| `keyboard` | `PRINT 2+2` | text screen: ` 4` |
| `disk` | `RUN"HELLO` from `tests/hello.dsk` | text screen: `HELLO FROM DISK`, ` 42` |
| `width80` | `WIDTH 80`, then print | screenshot (GIME 80-column text) |
| `hscreen` | `HSCREEN 2`, `HCIRCLE`, `HLINE ... B` | screenshot (GIME 320x192 graphics) |
Every test's final screenshot is compared byte for byte with `test-ref/`. The
sim is deterministic, so a changed image means the RTL or harness changed what
is drawn. After an intended change, `BLESS=1 ./run_tests.sh` records new
references. Output goes to `test-out/`.
### Speed
About **1.2 simulated frames per second** (boot to BASIC ~125 s on an
Apple-silicon Mac), or ~1.6 fps with `--fast-clocks` (~77 s).
Where the time goes, and the two speed-ups made:
- The CoCo clocks are 114.5 MHz (SDRAM controller, the `data_ready` latch,
the video line fetcher), 57.3 MHz `clk_sys` (everything else: 48 negedge
and 10 posedge blocks), 14.3 MHz pixel clock, and CLK_50M for the RTC/UART.
CLK_28 is unused.
- `status` (the OSD word) used to be a top-level input. It feeds the video
pixel mux, so Verilator re-evaluated that mux on every eval, about 20% of the
run time. `sim.v` now registers it, as `hps_io` does on the FPGA.
- `--fast-clocks` steps per half-period of `clk_sys` and runs the 114 MHz
domain at 57 MHz, halving the evals. At normal CPU speeds an SDRAM access
still finishes well inside a CPU cycle. All five tests give byte-identical
screenshots and identical instruction counts either way
(`SIMARGS=--fast-clocks ./run_tests.sh`). High turbo speeds (6 `clk_sys`
per CPU cycle at 9.54 MHz) and video fetch bandwidth are where it could
differ; use the default when timing is the question.
## Serial (RS-232 Pak / FujiNet)
The core's only UART is the RS-232 Pak, a `glb6551` at `$FF68-$FF6B`; on
MiSTer its pins are the `UART_*` signals the FujiNet daemon reaches as
`/dev/ttyS1`. The sim works on those pins, not on the registers:
- **TXD is decoded** at whatever rate the 6551 is programmed for, and every
byte is printed: `SERIAL TX <frame> <hex> |ascii|`.
- **RXD is driven** from a pty (`--serial-pty`, name printed at start) or from
`--serial-send FRAME:HEX...`, at the far end's rate: `--serial-baud N`, or by
default the 6551's transmit rate.
- `--trace-acia` logs every CPU access to `$FF68-$FF6B`, and whether it
actually reached the chip. The exit summary counts bytes, accesses and
undecoded accesses, and warns on a receive-clock mismatch.
- The windowed build has a Serial window with the same information.
- `tests/dwserver.py PTY DISK...` is a minimal DriveWire 3 server (stdlib only)
to stand in for FujiNet: `READEX`, `WRITE`, `TIME`, `DWINIT`, ...
`tests/dw_boot.sh CART DISK STOP [sim args]` wires the two together:
```sh
tests/dw_boot.sh ../../FujiNet_MiSTer/roms/HDBDW3S3.CCC tests/hello.dsk 350 \
--type '140:RUN"HELLO\n'
```
That boots HDB-DOS over DriveWire (reads LSN 0 and the directory), then
`RUN"HELLO` loads and runs the program from the served image, about 5 minutes.
The sim runs ~50x slower than real time, so the far end sees roughly 400 baud
of real throughput whatever rate is programmed. A real FujiNet may time out
where `dwserver.py` does not.
### FujiNet on this core: what was wrong, and the fix
Tested with FujiNet_MiSTer's carts and the real FujiNet daemon (FujiNet-PC
built for `COCO`, run with FujiNet_MiSTer's `fnconfig.ini` pointed at the sim's
pty; `tests/fujinet_boot.sh`).
1. **The 6551 was unreachable with a cart in slot 3.** `coco3fpga.sv` decoded
`$FF68-$FF6B` only when the Multi-Pak I/O select was slot 1
(`MPI_SCS == 0`), and the OSD offers only slots 2-4. HDB-DOS programmed the
chip and polled status forever. It read `$AA` from an empty bus, stopped at
`HDB-DOS 1.5 SY6551 COCO 3`, and transmitted nothing. On a real CoCo the
SCS line covers only `$FF40-$FF5F`, and the RS-232 Pak decodes `$FF68` from
the address bus, so it works in any slot. **Fix:** `RS232_EN` no longer
looks at `MPI_SCS`.
2. **The 19,200 cart received at 115,200.** `HDBDW3L3_19200.CCC` writes
control `$0F`. Bit 4 = 0 selects the "external" receive clock, which
`uart_6551.v` tied to the 1.8475 MHz enable, i.e. 115,200 baud. The cart
transmitted at 19,200 and received garbage: FujiNet logged `Checksum error:
expected 65280, got 57344`. **Fix:** the receiver is clocked from the baud
generator (`RX_CLK = TX_CLK`). That is unchanged for control `$1x` and for
baud select 0.
With both fixes, the L3 cart at 19,200 (the MiSTer configuration) boots from the
real FujiNet daemon with no checksum errors, and gets to FujiNet's CONFIG
splash. The S3 cart (115,200) reaches the CONFIG host-slots screen.
On the FPGA the rest of the path already works. `sys_top.v` wires the core's
`UART_*` pins straight to the HPS UART (`/dev/ttyS1`), whatever the OSD UART
mode. The 6551 only transmits while CTS is low, and CTS is the HPS UART's RTS.
FujiNet-PC turns off `CRTSCTS` and leaves RTS as Linux sets it on open
(asserted), so that holds while `start_fujinet.sh` has the port open.
**Sim-only caveat:** FujiNet times out reads after 500 ms of wall-clock time,
and the sim runs ~50x slower than real time. The CoCo cannot return a sector's
checksum in time, and FujiNet logs `got 65535`. These tests used a FujiNet
build with `.readTimeout(120000)` in `lib/bus/drivewire/drivewire.cpp`. On
hardware the stock value is fine.
## Windowed
`make run`. Windows: the video, a CPU/GIME inspector (registers, `$FF90`, a
live disassembly from the bus shadow), Control (run/pause/step, reset, cold
boot, screenshot, the OSD options, cart/cassette/floppy/SDC file dialogs) and a
console. Keys go to the CoCo from the host keyboard through the same PS/2 path
as on hardware.
## What is simulated, and what is replaced
`sim.v` wires the core the way `CoCo3.sv` does, including the OSD `status` word
decode, the joystick centring and the cassette RAM. The replacements:
| on MiSTer | here | why |
|---|---|---|
| PLL (114.545/57.27/28.64/14.32 MHz) | clocks from `sim_main.cpp` | all phase 0, exact /2 /4 /8, so they are derived from one counter and all rise in the same eval |
| `rtl/sdram/sdram2.sv` | `rtl/sdram2.sv` | same controller logic, plus a CAS-3, burst-2 SDR chip model in place of the `SDRAM_*` pins |
| `hps_io` keyboard | `sys/hps_io.sv`'s own `ps2_device` | `ps2_key` events are fed into the real PS/2 serializer at `PS2DIV(2400)`, so `cocokey.v` sees the same serial stream |
| `rtl/VDAC.v` (altsyncram) | `rtl/VDAC.v` | registered dual-port RAM, preloaded from `VDAC.mif` |
| VHDL ROM/RAM entities | `rtl/coco_rom.v`, `rtl/coco_sram.v` | Verilog conversions, see below |
### VHDL to Verilog
The build uses the Verilog cycle-accurate 6809 (`rtl/mc6809glb/mc6809glb.v`),
because `rtl/config.sv` defines `CoCo3_CYC_ACC_6809`. The VHDL CPU
(`rtl/CPU09/cpu09*.vhd`) is not instantiated, so nothing needs ghdl. The VHDL
the core does use was converted by hand, one module per entity with the same
names and ports:
| VHDL | Verilog |
|---|---|
| `rtl/rom/coco_rom_32K.vhd`, `coco_rom_8K.vhd`, `coco_rom_cart.vhd` | `rtl/coco_rom.v` (`COCO_ROM_32K`, `COCO_ROM_8K`, `COCO_ROM_CART`) |
| `rtl/rom/coco_rom_16.vhd` | `rtl/coco_rom.v` (`COCO_ROM_16`) |
| `rtl/rom/coco3_char_rom.vhd` | `rtl/coco_rom.v` (`coco3_Char_ROM`) + `rtl/coco3_char_rom.mem` |
| `rtl/sram/coco_ram.vhd`, `coco_vid_ram_buf.vhd` | `rtl/coco_sram.v` (`COCO_SRAM`, `COCO_VID_RAM_BUF`) |
`make mem` (`gen_mem.py`) regenerates `rtl/coco3_char_rom.mem` from the font
table in the VHDL and `rtl/vdac.mem` from `rtl/VDAC.mif`.
## Traps found while bringing it up
**Verilator re-runs block-local initialisers.** A variable declared with an
initialiser inside an `always` block, like `reg [4:0] state = STATE_STARTUP;` in
`sdram2.sv`, is re-initialised every time the block runs under Verilator 5.044.
It is not a one-time static. The SDRAM controller was pinned in
`STATE_STARTUP`, and the CPU stalled on its first RAM access. The sim copy
hoists those registers to module scope. Look for this in any other core
(`make lint` flags them as `IMPLICITSTATIC`).
**Quartus powers async-set registers up at 1.** A register with an asynchronous
set is built with NOT-gate push-back, so it starts at 1 on the FPGA and at 0
here. `mc6809x`'s `NMILatched` (active low) is one of them. At 0 the CPU took a
phantom NMI on its first instruction. `sim.v` sets it to 1 in an `initial`
block, which models the FPGA's power-up state.
**`// verilator ...` in a comment is a pragma.** A comment line that *starts*
with the word "verilator" is parsed as a directive and fails the build with
`BADVLTPRAGMA`.
**`rtl/wd1793.sv`:** `spt_addr` and `buff_wr` were declared inside `generate`
blocks but assigned outside them. Quartus accepts that. Verilator rejects
`spt_addr`, and silently makes `buff_wr` a separate implicit net, so the
sector-buffer write strobe would never reach the RAM. Both are now declared at
module scope. FM-7 made the same fix to its copy of the file. There is no
behavioural change on the FPGA.
The core also declares some registers as `wire` and assigns them in `always`
blocks (`Build_Info`, `VMA`, `PIX_CLK_D`, the `$FF40` latch in `fdc.sv`).
Quartus accepts it. The Makefile passes `-Wno-PROCASSWIRE` rather than editing
the RTL.
## Files
```
Makefile build, lint, test
sim.v emu top: CoCo3.sv without sys/, plus debug taps
sim_main.cpp clocks, options, headless loop, ImGui windows
serial.{cpp,h} 6551 line model: TXD decoder, RXD driver, pty bridge
sim.vlt Verilator config (forceable net for --acia-any-slot)
dis6809.{cpp,h} 6809 disassembler (shared with FM-7)
run_tests.sh smoke tests, judged on text screen + screenshot
gen_mem.py VHDL/MIF -> rtl/*.mem
rtl/ Verilog conversions and sim replacements
sim/ shared ImGui/SDL framework
tests/ make_test_disk.py -> hello.dsk (Disk BASIC image),
dwserver.py (minimal DriveWire 3 server)
test-ref/ blessed screenshots for run_tests.sh
```
+233
View File
@@ -0,0 +1,233 @@
//============================================================================
// Motorola 6809 disassembler
//
// Table-driven, covering pages 1 ($xx), 2 ($10 xx) and 3 ($11 xx), all six
// addressing modes and the full indexed postbyte set. No 6309 extensions --
// rtl/mc6809i.v is a 6809, and silently decoding 6309 opcodes would hide the
// fact that the CPU has run off into data.
//============================================================================
#include "dis6809.h"
#include <cstdio>
#include <cstring>
namespace {
enum Mode {
INH, // inherent
IMM8,
IMM16,
DIR,
EXT,
IDX,
REL8,
REL16,
RLIST_S, // PSHS/PULS postbyte
RLIST_U, // PSHU/PULU postbyte
REGPAIR, // TFR/EXG postbyte
ILL
};
struct Op { const char* name; Mode mode; };
// ---- page 1 ---------------------------------------------------------------
const Op page1[256] = {
/*00*/ {"NEG",DIR},{"?",ILL},{"?",ILL},{"COM",DIR},{"LSR",DIR},{"?",ILL},{"ROR",DIR},{"ASR",DIR},
/*08*/ {"LSL",DIR},{"ROL",DIR},{"DEC",DIR},{"?",ILL},{"INC",DIR},{"TST",DIR},{"JMP",DIR},{"CLR",DIR},
/*10*/ {"?",ILL},{"?",ILL},{"NOP",INH},{"SYNC",INH},{"?",ILL},{"?",ILL},{"LBRA",REL16},{"LBSR",REL16},
/*18*/ {"?",ILL},{"DAA",INH},{"ORCC",IMM8},{"?",ILL},{"ANDCC",IMM8},{"SEX",INH},{"EXG",REGPAIR},{"TFR",REGPAIR},
/*20*/ {"BRA",REL8},{"BRN",REL8},{"BHI",REL8},{"BLS",REL8},{"BCC",REL8},{"BCS",REL8},{"BNE",REL8},{"BEQ",REL8},
/*28*/ {"BVC",REL8},{"BVS",REL8},{"BPL",REL8},{"BMI",REL8},{"BGE",REL8},{"BLT",REL8},{"BGT",REL8},{"BLE",REL8},
/*30*/ {"LEAX",IDX},{"LEAY",IDX},{"LEAS",IDX},{"LEAU",IDX},{"PSHS",RLIST_S},{"PULS",RLIST_S},{"PSHU",RLIST_U},{"PULU",RLIST_U},
/*38*/ {"?",ILL},{"RTS",INH},{"ABX",INH},{"RTI",INH},{"CWAI",IMM8},{"MUL",INH},{"RESET",INH},{"SWI",INH},
/*40*/ {"NEGA",INH},{"?",ILL},{"?",ILL},{"COMA",INH},{"LSRA",INH},{"?",ILL},{"RORA",INH},{"ASRA",INH},
/*48*/ {"LSLA",INH},{"ROLA",INH},{"DECA",INH},{"?",ILL},{"INCA",INH},{"TSTA",INH},{"?",ILL},{"CLRA",INH},
/*50*/ {"NEGB",INH},{"?",ILL},{"?",ILL},{"COMB",INH},{"LSRB",INH},{"?",ILL},{"RORB",INH},{"ASRB",INH},
/*58*/ {"LSLB",INH},{"ROLB",INH},{"DECB",INH},{"?",ILL},{"INCB",INH},{"TSTB",INH},{"?",ILL},{"CLRB",INH},
/*60*/ {"NEG",IDX},{"?",ILL},{"?",ILL},{"COM",IDX},{"LSR",IDX},{"?",ILL},{"ROR",IDX},{"ASR",IDX},
/*68*/ {"LSL",IDX},{"ROL",IDX},{"DEC",IDX},{"?",ILL},{"INC",IDX},{"TST",IDX},{"JMP",IDX},{"CLR",IDX},
/*70*/ {"NEG",EXT},{"?",ILL},{"?",ILL},{"COM",EXT},{"LSR",EXT},{"?",ILL},{"ROR",EXT},{"ASR",EXT},
/*78*/ {"LSL",EXT},{"ROL",EXT},{"DEC",EXT},{"?",ILL},{"INC",EXT},{"TST",EXT},{"JMP",EXT},{"CLR",EXT},
/*80*/ {"SUBA",IMM8},{"CMPA",IMM8},{"SBCA",IMM8},{"SUBD",IMM16},{"ANDA",IMM8},{"BITA",IMM8},{"LDA",IMM8},{"?",ILL},
/*88*/ {"EORA",IMM8},{"ADCA",IMM8},{"ORA",IMM8},{"ADDA",IMM8},{"CMPX",IMM16},{"BSR",REL8},{"LDX",IMM16},{"?",ILL},
/*90*/ {"SUBA",DIR},{"CMPA",DIR},{"SBCA",DIR},{"SUBD",DIR},{"ANDA",DIR},{"BITA",DIR},{"LDA",DIR},{"STA",DIR},
/*98*/ {"EORA",DIR},{"ADCA",DIR},{"ORA",DIR},{"ADDA",DIR},{"CMPX",DIR},{"JSR",DIR},{"LDX",DIR},{"STX",DIR},
/*A0*/ {"SUBA",IDX},{"CMPA",IDX},{"SBCA",IDX},{"SUBD",IDX},{"ANDA",IDX},{"BITA",IDX},{"LDA",IDX},{"STA",IDX},
/*A8*/ {"EORA",IDX},{"ADCA",IDX},{"ORA",IDX},{"ADDA",IDX},{"CMPX",IDX},{"JSR",IDX},{"LDX",IDX},{"STX",IDX},
/*B0*/ {"SUBA",EXT},{"CMPA",EXT},{"SBCA",EXT},{"SUBD",EXT},{"ANDA",EXT},{"BITA",EXT},{"LDA",EXT},{"STA",EXT},
/*B8*/ {"EORA",EXT},{"ADCA",EXT},{"ORA",EXT},{"ADDA",EXT},{"CMPX",EXT},{"JSR",EXT},{"LDX",EXT},{"STX",EXT},
/*C0*/ {"SUBB",IMM8},{"CMPB",IMM8},{"SBCB",IMM8},{"ADDD",IMM16},{"ANDB",IMM8},{"BITB",IMM8},{"LDB",IMM8},{"?",ILL},
/*C8*/ {"EORB",IMM8},{"ADCB",IMM8},{"ORB",IMM8},{"ADDB",IMM8},{"LDD",IMM16},{"?",ILL},{"LDU",IMM16},{"?",ILL},
/*D0*/ {"SUBB",DIR},{"CMPB",DIR},{"SBCB",DIR},{"ADDD",DIR},{"ANDB",DIR},{"BITB",DIR},{"LDB",DIR},{"STB",DIR},
/*D8*/ {"EORB",DIR},{"ADCB",DIR},{"ORB",DIR},{"ADDB",DIR},{"LDD",DIR},{"STD",DIR},{"LDU",DIR},{"STU",DIR},
/*E0*/ {"SUBB",IDX},{"CMPB",IDX},{"SBCB",IDX},{"ADDD",IDX},{"ANDB",IDX},{"BITB",IDX},{"LDB",IDX},{"STB",IDX},
/*E8*/ {"EORB",IDX},{"ADCB",IDX},{"ORB",IDX},{"ADDB",IDX},{"LDD",IDX},{"STD",IDX},{"LDU",IDX},{"STU",IDX},
/*F0*/ {"SUBB",EXT},{"CMPB",EXT},{"SBCB",EXT},{"ADDD",EXT},{"ANDB",EXT},{"BITB",EXT},{"LDB",EXT},{"STB",EXT},
/*F8*/ {"EORB",EXT},{"ADCB",EXT},{"ORB",EXT},{"ADDB",EXT},{"LDD",EXT},{"STD",EXT},{"LDU",EXT},{"STU",EXT},
};
// ---- page 2 ($10 prefix) --------------------------------------------------
Op page2_lookup(uint8_t op) {
switch (op) {
case 0x21: return {"LBRN",REL16}; case 0x22: return {"LBHI",REL16};
case 0x23: return {"LBLS",REL16}; case 0x24: return {"LBCC",REL16};
case 0x25: return {"LBCS",REL16}; case 0x26: return {"LBNE",REL16};
case 0x27: return {"LBEQ",REL16}; case 0x28: return {"LBVC",REL16};
case 0x29: return {"LBVS",REL16}; case 0x2a: return {"LBPL",REL16};
case 0x2b: return {"LBMI",REL16}; case 0x2c: return {"LBGE",REL16};
case 0x2d: return {"LBLT",REL16}; case 0x2e: return {"LBGT",REL16};
case 0x2f: return {"LBLE",REL16};
case 0x3f: return {"SWI2",INH};
case 0x83: return {"CMPD",IMM16}; case 0x8c: return {"CMPY",IMM16};
case 0x8e: return {"LDY",IMM16};
case 0x93: return {"CMPD",DIR}; case 0x9c: return {"CMPY",DIR};
case 0x9e: return {"LDY",DIR}; case 0x9f: return {"STY",DIR};
case 0xa3: return {"CMPD",IDX}; case 0xac: return {"CMPY",IDX};
case 0xae: return {"LDY",IDX}; case 0xaf: return {"STY",IDX};
case 0xb3: return {"CMPD",EXT}; case 0xbc: return {"CMPY",EXT};
case 0xbe: return {"LDY",EXT}; case 0xbf: return {"STY",EXT};
case 0xce: return {"LDS",IMM16};
case 0xde: return {"LDS",DIR}; case 0xdf: return {"STS",DIR};
case 0xee: return {"LDS",IDX}; case 0xef: return {"STS",IDX};
case 0xfe: return {"LDS",EXT}; case 0xff: return {"STS",EXT};
default: return {"?",ILL};
}
}
// ---- page 3 ($11 prefix) --------------------------------------------------
Op page3_lookup(uint8_t op) {
switch (op) {
case 0x3f: return {"SWI3",INH};
case 0x83: return {"CMPU",IMM16}; case 0x8c: return {"CMPS",IMM16};
case 0x93: return {"CMPU",DIR}; case 0x9c: return {"CMPS",DIR};
case 0xa3: return {"CMPU",IDX}; case 0xac: return {"CMPS",IDX};
case 0xb3: return {"CMPU",EXT}; case 0xbc: return {"CMPS",EXT};
default: return {"?",ILL};
}
}
const char* const IDX_REG[4] = { "X", "Y", "U", "S" };
// TFR/EXG register field. 6809 leaves 6,7 and 12..15 undefined.
const char* const TFR_REG[16] = {
"D","X","Y","U","S","PC","?6","?7","A","B","CC","DP","?c","?d","?e","?f"
};
void reg_list(uint8_t pb, bool is_u, char* out, size_t n) {
static const char* names_s[8] = {"CC","A","B","DP","X","Y","U","PC"};
static const char* names_u[8] = {"CC","A","B","DP","X","Y","S","PC"};
const char* const* names = is_u ? names_u : names_s;
out[0] = 0;
size_t len = 0;
for (int i = 0; i < 8; i++) {
if (!(pb & (1 << i))) continue;
int w = snprintf(out + len, n - len, "%s%s", len ? "," : "", names[i]);
if (w < 0 || (size_t)w >= n - len) break;
len += w;
}
if (!len) snprintf(out, n, "#$%02x", pb);
}
} // namespace
void cc6809_string(uint8_t cc, char out[9]) {
static const char* bits = "EFHINZVC"; // bit 7 .. bit 0
for (int i = 0; i < 8; i++) {
char c = bits[i];
out[i] = (cc & (0x80 >> i)) ? c : (char)(c + 32);
}
out[8] = 0;
}
int dis6809(uint16_t pc, int (*rd)(uint16_t), char* out, size_t outlen) {
// Local fetch helpers. `bad` sticks once any byte of the instruction is
// unknown, so the caller sees "??" rather than a plausible-looking lie.
int len = 0;
bool bad = false;
auto fetch = [&](void) -> int {
int v = rd((uint16_t)(pc + len));
len++;
if (v < 0) { bad = true; return 0; }
return v;
};
int op = fetch();
Op o;
if (bad) { snprintf(out, outlen, "??"); return 1; }
if (op == 0x10) { int o2 = fetch(); o = bad ? Op{"?",ILL} : page2_lookup((uint8_t)o2); }
else if (op == 0x11) { int o2 = fetch(); o = bad ? Op{"?",ILL} : page3_lookup((uint8_t)o2); }
else o = page1[op];
if (o.mode == ILL) {
snprintf(out, outlen, "FCB $%02x", op);
return 1;
}
char arg[64] = "";
switch (o.mode) {
case INH:
break;
case IMM8: { int v = fetch(); snprintf(arg, sizeof(arg), "#$%02x", v); break; }
case IMM16: { int h = fetch(), l = fetch(); snprintf(arg, sizeof(arg), "#$%02x%02x", h, l); break; }
case DIR: { int v = fetch(); snprintf(arg, sizeof(arg), "<$%02x", v); break; }
case EXT: { int h = fetch(), l = fetch(); snprintf(arg, sizeof(arg), "$%02x%02x", h, l); break; }
case REL8: { int v = fetch();
uint16_t dst = (uint16_t)(pc + len + (int8_t)v);
snprintf(arg, sizeof(arg), "$%04x", dst); break; }
case REL16: { int h = fetch(), l = fetch();
uint16_t dst = (uint16_t)(pc + len + (int16_t)((h << 8) | l));
snprintf(arg, sizeof(arg), "$%04x", dst); break; }
case RLIST_S: { int pb = fetch(); reg_list((uint8_t)pb, false, arg, sizeof(arg)); break; }
case RLIST_U: { int pb = fetch(); reg_list((uint8_t)pb, true, arg, sizeof(arg)); break; }
case REGPAIR: { int pb = fetch();
snprintf(arg, sizeof(arg), "%s,%s", TFR_REG[(pb >> 4) & 15], TFR_REG[pb & 15]);
break; }
case IDX: {
int pb = fetch();
const char* r = IDX_REG[(pb >> 5) & 3];
if (!(pb & 0x80)) {
// 5-bit signed offset, no indirect form
int off = pb & 0x1f;
if (off & 0x10) off -= 0x20;
snprintf(arg, sizeof(arg), "%d,%s", off, r);
break;
}
bool ind = (pb & 0x10) != 0;
char body[48];
switch (pb & 0x0f) {
case 0x0: snprintf(body, sizeof(body), ",%s+", r); break;
case 0x1: snprintf(body, sizeof(body), ",%s++", r); break;
case 0x2: snprintf(body, sizeof(body), ",-%s", r); break;
case 0x3: snprintf(body, sizeof(body), ",--%s", r); break;
case 0x4: snprintf(body, sizeof(body), ",%s", r); break;
case 0x5: snprintf(body, sizeof(body), "B,%s", r); break;
case 0x6: snprintf(body, sizeof(body), "A,%s", r); break;
case 0x8: { int v = fetch(); snprintf(body, sizeof(body), "$%02x,%s", v, r); break; }
case 0x9: { int h = fetch(), l = fetch();
snprintf(body, sizeof(body), "$%02x%02x,%s", h, l, r); break; }
case 0xb: snprintf(body, sizeof(body), "D,%s", r); break;
case 0xc: { int v = fetch();
// PCR offsets are relative to the byte after the instruction,
// which is only known once the whole thing is decoded -- so
// print the raw offset and let the target be inferred.
snprintf(body, sizeof(body), "$%02x,PCR", v); break; }
case 0xd: { int h = fetch(), l = fetch();
snprintf(body, sizeof(body), "$%02x%02x,PCR", h, l); break; }
case 0xf: { int h = fetch(), l = fetch();
snprintf(body, sizeof(body), "$%02x%02x", h, l); break; }
default: snprintf(body, sizeof(body), "?pb$%02x,%s", pb, r); break;
}
if (ind) snprintf(arg, sizeof(arg), "[%s]", body);
else snprintf(arg, sizeof(arg), "%s", body);
break;
}
default: break;
}
if (bad) snprintf(out, outlen, "%-5s ??", o.name);
else if (arg[0]) snprintf(out, outlen, "%-5s %s", o.name, arg);
else snprintf(out, outlen, "%s", o.name);
return len ? len : 1;
}
+18
View File
@@ -0,0 +1,18 @@
#pragma once
#include <cstdint>
#include <cstddef>
// Motorola 6809 disassembler.
//
// `read_byte` returns 0..255, or -1 for an address whose contents are not
// known. The sim feeds it a shadow of every byte the CPU has actually put on
// the bus, so unknown means "the CPU never fetched or wrote this" -- which is
// itself informative, and prints as "??".
//
// Returns the instruction length in bytes (1..5), and writes the mnemonic and
// operand to `out`. On an unknown opcode it emits "FCB $xx" and returns 1, so a
// caller walking a byte stream always makes progress.
int dis6809(uint16_t pc, int (*read_byte)(uint16_t), char* out, size_t outlen);
// Human-readable CC, e.g. "EFHINZVC" with cleared flags lower-cased.
void cc6809_string(uint8_t cc, char out[9]);
+63
View File
@@ -0,0 +1,63 @@
//============================================================================
// dis6809 self-check. `make distest`
//
// Covers every addressing mode, both prefix pages, the register-list and
// register-pair postbytes, and an undefined opcode. Cheap insurance: a
// disassembler that is subtly wrong is worse than none, because it produces
// confident output you will act on.
//============================================================================
#include "dis6809.h"
#include <cstdio>
#include <cstring>
static unsigned char M[0x10000];
static int rd(uint16_t a){ return M[a]; }
struct T { const char* bytes; const char* want; };
static int put(uint16_t a, const char* hex){ int n=0; while(*hex){ unsigned v; sscanf(hex,"%2x",&v); M[a+n++]=v; hex+=2; if(*hex==' ')hex++; } return n; }
int main(){
T t[] = {
{"20 09", "BRA $100b"},
{"16 01 23", "LBRA $1126"},
{"86 fd", "LDA #$fd"},
{"10 ce fc 7f", "LDS #$fc7f"},
{"1f 8b", "TFR A,DP"},
{"1e 12", "EXG X,Y"},
{"34 76", "PSHS A,B,X,Y,U"},
{"35 ff", "PULS CC,A,B,DP,X,Y,U,PC"},
{"36 40", "PSHU S"},
{"d6 04", "LDB <$04"},
{"be fb fe", "LDX $fbfe"},
{"6e 84", "JMP ,X"},
{"a6 80", "LDA ,X+"},
{"a6 81", "LDA ,X++"},
{"a6 82", "LDA ,-X"},
{"a6 83", "LDA ,--X"},
{"a6 91", "LDA [,X++]"},
{"a6 a5", "LDA B,Y"},
{"a6 c6", "LDA A,U"},
{"a6 88 7f", "LDA $7f,X"},
{"a6 89 12 34", "LDA $1234,X"},
{"a6 9f 20 00", "LDA [$2000]"},
{"a6 8c 10", "LDA $10,PCR"},
{"a6 1f", "LDA -1,X"},
{"a6 05", "LDA 5,X"},
{"e7 41", "STB 1,U"},
{"10 8e 12 34", "LDY #$1234"},
{"11 83 00 01", "CMPU #$0001"},
{"11 3f", "SWI3"},
{"39", "RTS"},
{"3d", "MUL"},
{"87", "FCB $87"},
};
int fail=0;
for (auto& e : t) {
memset(M,0,sizeof(M));
int n = put(0x1000, e.bytes);
char out[80];
int len = dis6809(0x1000, rd, out, sizeof(out));
bool ok = !strcmp(out, e.want) && (len==n || (!strcmp(e.want,"FCB $87")));
if(!ok){ printf("FAIL %-16s got \"%s\" (len %d, expected %d) want \"%s\"\n", e.bytes,out,len,n,e.want); fail++; }
}
printf(fail? "%d FAILURES\n" : "all %d cases pass\n", fail?fail:(int)(sizeof(t)/sizeof(t[0])));
return fail!=0;
}
+44
View File
@@ -0,0 +1,44 @@
#!/usr/bin/env python3
"""Regenerate the $readmemh images the Verilog conversions load.
rtl/rom/coco3_char_rom.vhd -> verilator/rtl/coco3_char_rom.mem (4096 x 8)
rtl/VDAC.mif -> verilator/rtl/vdac.mem ( 256 x 16)
Run from the verilator/ directory after either source changes.
"""
import re, sys
def char_rom():
src = open('../rtl/rom/coco3_char_rom.vhd').read()
body = src[src.index('signal RAM'):src.index(');', src.index('signal RAM'))]
vals = re.findall(r'x"([0-9A-Fa-f]{2})"', body)
if len(vals) != 4096:
sys.exit(f'coco3_char_rom.vhd: expected 4096 bytes, found {len(vals)}')
with open('rtl/coco3_char_rom.mem', 'w') as f:
for i in range(0, 4096, 16):
f.write(' '.join(v.upper() for v in vals[i:i+16]) + '\n')
def vdac():
mem = [0] * 256
txt = open('../rtl/VDAC.mif').read()
txt = txt[txt.index('CONTENT BEGIN') + len('CONTENT BEGIN'):txt.index('END;')]
for line in txt.splitlines():
line = line.split('--')[0].strip().rstrip(';')
if ':' not in line:
continue
addr, data = (s.strip() for s in line.split(':', 1))
words = data.split()
if addr.startswith('['): # [lo..hi] : value
lo, hi = (int(x, 16) for x in addr[1:-1].split('..'))
for a in range(lo, hi + 1):
mem[a] = int(words[0], 16)
else:
base = int(addr, 16)
for i, w in enumerate(words):
mem[base + i] = int(w, 16)
with open('rtl/vdac.mem', 'w') as f:
for i in range(0, 256, 8):
f.write(' '.join(f'{v:04X}' for v in mem[i:i+8]) + '\n')
char_rom()
vdac()
+27
View File
@@ -0,0 +1,27 @@
//============================================================================
// Simulation stand-in for rtl/VDAC.v (an altsyncram megafunction).
//
// Same ports and the configuration the megafunction declares: DUAL_PORT,
// 256 x 16, write on wrclock, address AND output registered on rdclock
// (address_reg_b = outdata_reg_b = CLOCK1), so q lags rdaddress by two
// rdclock edges. Preloaded from rtl/VDAC.mif via verilator/rtl/vdac.mem.
//============================================================================
module VDAC
(
input [15:0] data,
input [7:0] rdaddress,
input rdclock,
input [7:0] wraddress,
input wrclock,
input wren,
output reg [15:0] q
);
reg [15:0] mem [0:255];
reg [7:0] rd_a;
initial $readmemh("rtl/vdac.mem", mem);
always @(posedge wrclock) if (wren) mem[wraddress] <= data;
always @(posedge rdclock) begin
rd_a <= rdaddress;
q <= mem[rd_a];
end
endmodule
+256
View File
@@ -0,0 +1,256 @@
1C 22 20 20 20 22 1C 08 00 00 00 00 00 00 00 00
22 00 22 22 22 26 1A 00 00 00 00 00 00 00 00 00
04 08 1C 22 3E 20 1C 00 00 00 00 00 00 00 00 00
08 14 1C 02 1E 22 1E 00 00 00 00 00 00 00 00 00
14 00 1C 02 1E 22 1E 00 00 00 00 00 00 00 00 00
10 08 1C 02 1E 22 1E 00 00 00 00 00 00 00 00 00
08 00 1C 02 1E 22 1E 00 00 00 00 00 00 00 00 00
00 00 1C 22 20 22 1C 08 00 00 00 00 00 00 00 00
08 14 1C 22 3E 20 1C 00 00 00 00 00 00 00 00 00
14 00 1C 22 3E 20 1C 00 00 00 00 00 00 00 00 00
10 08 1C 22 3E 20 1C 00 00 00 00 00 00 00 00 00
14 00 18 08 08 08 1C 00 00 00 00 00 00 00 00 00
08 14 00 18 08 08 1C 00 00 00 00 00 00 00 00 00
00 0C 12 1C 12 12 1C 20 00 00 00 00 00 00 00 00
22 08 14 22 3E 22 22 00 00 00 00 00 00 00 00 00
08 08 14 22 3E 22 22 00 00 00 00 00 00 00 00 00
04 08 1C 22 22 22 1C 00 00 00 00 00 00 00 00 00
00 00 34 0A 1E 28 1E 00 00 00 00 00 00 00 00 00
1E 28 28 3C 28 28 2C 00 00 00 00 00 00 00 00 00
08 14 1C 22 22 22 1C 00 00 00 00 00 00 00 00 00
14 00 1C 22 22 22 1C 00 00 00 00 00 00 00 00 00
00 00 1C 26 2E 32 1C 00 00 00 00 00 00 00 00 00
08 14 00 22 22 26 1A 00 00 00 00 00 00 00 00 00
10 08 22 22 22 26 1A 00 00 00 00 00 00 00 00 00
1C 26 2A 2A 2A 32 1C 00 00 00 00 00 00 00 00 00
22 1C 22 22 22 22 1C 00 00 00 00 00 00 00 00 00
14 22 22 22 22 22 1C 00 00 00 00 00 00 00 00 00
1C 20 1C 22 1C 02 1C 00 00 00 00 00 00 00 00 00
04 0A 08 1C 08 0A 3C 00 00 00 00 00 00 00 00 00
08 08 3E 08 08 00 3E 00 00 00 00 00 00 00 00 00
04 0A 04 00 00 00 00 00 00 00 00 00 00 00 00 00
04 0A 08 1C 08 08 28 10 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
08 08 08 08 08 00 08 00 00 00 00 00 00 00 00 00
14 14 14 00 00 00 00 00 00 00 00 00 00 00 00 00
14 14 3E 14 3E 14 14 00 00 00 00 00 00 00 00 00
08 1E 28 1C 0A 3C 08 00 00 00 00 00 00 00 00 00
32 32 04 08 10 26 26 00 00 00 00 00 00 00 00 00
10 28 28 10 2A 24 1A 00 00 00 00 00 00 00 00 00
08 08 10 00 00 00 00 00 00 00 00 00 00 00 00 00
08 10 20 20 20 10 08 00 00 00 00 00 00 00 00 00
08 04 02 02 02 04 08 00 00 00 00 00 00 00 00 00
00 08 2A 1C 1C 2A 08 00 00 00 00 00 00 00 00 00
00 08 08 3E 08 08 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 08 08 10 00 00 00 00 00 00 00 00
00 00 00 3E 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 08 00 00 00 00 00 00 00 00 00
00 02 04 08 10 20 00 00 00 00 00 00 00 00 00 00
1C 22 26 2A 32 22 1C 00 00 00 00 00 00 00 00 00
08 18 08 08 08 08 1C 00 00 00 00 00 00 00 00 00
1C 22 02 1C 20 20 3E 00 00 00 00 00 00 00 00 00
1C 22 02 04 02 22 1C 00 00 00 00 00 00 00 00 00
04 0C 14 24 3E 04 04 00 00 00 00 00 00 00 00 00
3E 20 3C 02 02 02 3C 00 00 00 00 00 00 00 00 00
1C 20 20 3C 22 22 1C 00 00 00 00 00 00 00 00 00
3E 02 04 08 10 20 20 00 00 00 00 00 00 00 00 00
1C 22 22 1C 22 22 1C 00 00 00 00 00 00 00 00 00
1C 22 22 1E 02 02 1C 00 00 00 00 00 00 00 00 00
00 00 08 00 00 08 00 00 00 00 00 00 00 00 00 00
00 00 08 00 00 08 08 10 00 00 00 00 00 00 00 00
04 08 10 20 10 08 04 00 00 00 00 00 00 00 00 00
00 00 3E 00 3E 00 00 00 00 00 00 00 00 00 00 00
10 08 04 02 04 08 10 00 00 00 00 00 00 00 00 00
1C 22 02 04 08 00 08 00 00 00 00 00 00 00 00 00
1C 22 02 1A 2A 2A 1C 00 00 00 00 00 00 00 00 00
08 14 22 22 3E 22 22 00 00 00 00 00 00 00 00 00
3C 12 12 1C 12 12 3C 00 00 00 00 00 00 00 00 00
1C 22 20 20 20 22 1C 00 00 00 00 00 00 00 00 00
3C 12 12 12 12 12 3C 00 00 00 00 00 00 00 00 00
3E 20 20 3C 20 20 3E 00 00 00 00 00 00 00 00 00
3E 20 20 3C 20 20 20 00 00 00 00 00 00 00 00 00
1E 20 20 26 22 22 1C 00 00 00 00 00 00 00 00 00
22 22 22 3E 22 22 22 00 00 00 00 00 00 00 00 00
1C 08 08 08 08 08 1C 00 00 00 00 00 00 00 00 00
02 02 02 02 22 22 1C 00 00 00 00 00 00 00 00 00
22 24 28 30 28 24 22 00 00 00 00 00 00 00 00 00
20 20 20 20 20 20 3E 00 00 00 00 00 00 00 00 00
22 36 2A 2A 22 22 22 00 00 00 00 00 00 00 00 00
22 32 2A 26 22 22 22 00 00 00 00 00 00 00 00 00
1C 22 22 22 22 22 1C 00 00 00 00 00 00 00 00 00
3C 22 22 3C 20 20 20 00 00 00 00 00 00 00 00 00
1C 22 22 22 2A 24 1A 00 00 00 00 00 00 00 00 00
3C 22 22 3C 28 24 22 00 00 00 00 00 00 00 00 00
1C 22 10 08 04 22 1C 00 00 00 00 00 00 00 00 00
3E 08 08 08 08 08 08 00 00 00 00 00 00 00 00 00
22 22 22 22 22 22 1C 00 00 00 00 00 00 00 00 00
22 22 22 14 14 08 08 00 00 00 00 00 00 00 00 00
22 22 22 2A 2A 36 22 00 00 00 00 00 00 00 00 00
22 22 14 08 14 22 22 00 00 00 00 00 00 00 00 00
22 22 14 08 08 08 08 00 00 00 00 00 00 00 00 00
3E 02 04 08 10 20 3E 00 00 00 00 00 00 00 00 00
38 20 20 20 20 20 38 00 00 00 00 00 00 00 00 00
20 20 10 08 04 02 02 00 00 00 00 00 00 00 00 00
0E 02 02 02 02 02 0E 00 00 00 00 00 00 00 00 00
08 1C 2A 08 08 08 08 00 00 00 00 00 00 00 00 00
00 08 10 3E 10 08 00 00 00 00 00 00 00 00 00 00
08 14 22 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 1C 02 1E 22 1E 00 00 00 00 00 00 00 00 00
20 20 2C 32 22 32 2C 00 00 00 00 00 00 00 00 00
00 00 1C 22 20 22 1C 00 00 00 00 00 00 00 00 00
02 02 1A 26 22 26 1A 00 00 00 00 00 00 00 00 00
00 00 1C 22 3E 20 1C 00 00 00 00 00 00 00 00 00
04 0A 08 1C 08 08 08 00 00 00 00 00 00 00 00 00
00 00 1A 26 26 1A 02 1C 00 00 00 00 00 00 00 00
20 20 2C 32 22 22 22 00 00 00 00 00 00 00 00 00
00 08 00 18 08 08 1C 00 00 00 00 00 00 00 00 00
00 02 00 02 02 02 22 1C 00 00 00 00 00 00 00 00
20 20 24 28 30 28 24 00 00 00 00 00 00 00 00 00
18 08 08 08 08 08 1C 00 00 00 00 00 00 00 00 00
00 00 14 2A 2A 2A 2A 00 00 00 00 00 00 00 00 00
00 00 2C 32 22 22 22 00 00 00 00 00 00 00 00 00
00 00 1C 22 22 22 1C 00 00 00 00 00 00 00 00 00
00 00 2C 32 32 2C 20 20 00 00 00 00 00 00 00 00
00 00 1A 26 26 1A 02 02 00 00 00 00 00 00 00 00
00 00 2C 32 20 20 20 00 00 00 00 00 00 00 00 00
00 00 1E 20 1C 02 3C 00 00 00 00 00 00 00 00 00
10 10 38 10 10 12 0C 00 00 00 00 00 00 00 00 00
00 00 22 22 22 26 1A 00 00 00 00 00 00 00 00 00
00 00 22 22 22 14 08 00 00 00 00 00 00 00 00 00
00 00 22 2A 2A 14 14 00 00 00 00 00 00 00 00 00
00 00 22 14 08 14 22 00 00 00 00 00 00 00 00 00
00 00 22 22 22 1E 02 1C 00 00 00 00 00 00 00 00
00 00 3E 04 08 10 3E 00 00 00 00 00 00 00 00 00
08 10 10 20 10 10 08 00 00 00 00 00 00 00 00 00
08 08 08 00 08 08 08 00 00 00 00 00 00 00 00 00
08 04 04 02 04 04 08 00 00 00 00 00 00 00 00 00
10 2A 04 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 3E 00 00 00 00 00 00 00 00 00
00 00 1C 22 20 20 20 22 1C 08 00 00 00 00 00 00
00 00 22 00 22 22 22 26 1A 00 00 00 00 00 00 00
00 00 04 08 1C 22 3E 20 1C 00 00 00 00 00 00 00
00 00 08 14 1C 02 1E 22 1E 00 00 00 00 00 00 00
00 00 14 00 1C 02 1E 22 1E 00 00 00 00 00 00 00
00 00 10 08 1C 02 1E 22 1E 00 00 00 00 00 00 00
00 00 08 00 1C 02 1E 22 1E 00 00 00 00 00 00 00
00 00 00 00 1C 22 20 22 1C 08 00 00 00 00 00 00
00 00 08 14 1C 22 3E 20 1C 00 00 00 00 00 00 00
00 00 14 00 1C 22 3E 20 1C 00 00 00 00 00 00 00
00 00 10 08 1C 22 3E 20 1C 00 00 00 00 00 00 00
00 00 14 00 18 08 08 08 1C 00 00 00 00 00 00 00
00 00 08 14 00 18 08 08 1C 00 00 00 00 00 00 00
00 00 00 0C 12 1C 12 12 1C 20 00 00 00 00 00 00
00 00 22 08 14 22 3E 22 22 00 00 00 00 00 00 00
00 00 08 08 14 22 3E 22 22 00 00 00 00 00 00 00
00 00 04 08 1C 22 22 22 1C 00 00 00 00 00 00 00
00 00 00 00 34 0A 1E 28 1E 00 00 00 00 00 00 00
00 00 1E 28 28 3C 28 28 2C 00 00 00 00 00 00 00
00 00 08 14 1C 22 22 22 1C 00 00 00 00 00 00 00
00 00 14 00 1C 22 22 22 1C 00 00 00 00 00 00 00
00 00 00 00 1C 26 2E 32 1C 00 00 00 00 00 00 00
00 00 08 14 00 22 22 26 1A 00 00 00 00 00 00 00
00 00 10 08 22 22 22 26 1A 00 00 00 00 00 00 00
00 00 1C 26 2A 2A 2A 32 1C 00 00 00 00 00 00 00
00 00 22 1C 22 22 22 22 1C 00 00 00 00 00 00 00
00 00 14 22 22 22 22 22 1C 00 00 00 00 00 00 00
00 00 1C 20 1C 22 1C 02 1C 00 00 00 00 00 00 00
00 00 04 0A 08 1C 08 0A 3C 00 00 00 00 00 00 00
00 00 08 08 3E 08 08 00 3E 00 00 00 00 00 00 00
00 00 04 0A 04 00 00 00 00 00 00 00 00 00 00 00
00 00 04 0A 08 1C 08 08 28 10 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 08 08 08 08 08 00 08 00 00 00 00 00 00 00
00 00 14 14 14 00 00 00 00 00 00 00 00 00 00 00
00 00 14 14 3E 14 3E 14 14 00 00 00 00 00 00 00
00 00 08 1E 28 1C 0A 3C 08 00 00 00 00 00 00 00
00 00 32 32 04 08 10 26 26 00 00 00 00 00 00 00
00 00 10 28 28 10 2A 24 1A 00 00 00 00 00 00 00
00 00 08 08 10 00 00 00 00 00 00 00 00 00 00 00
00 00 08 10 20 20 20 10 08 00 00 00 00 00 00 00
00 00 08 04 02 02 02 04 08 00 00 00 00 00 00 00
00 00 00 08 2A 1C 1C 2A 08 00 00 00 00 00 00 00
00 00 00 08 08 3E 08 08 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 08 08 10 00 00 00 00 00 00
00 00 00 00 00 3E 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 08 00 00 00 00 00 00 00
00 00 00 02 04 08 10 20 00 00 00 00 00 00 00 00
00 00 1C 22 26 2A 32 22 1C 00 00 00 00 00 00 00
00 00 08 18 08 08 08 08 1C 00 00 00 00 00 00 00
00 00 1C 22 02 1C 20 20 3E 00 00 00 00 00 00 00
00 00 1C 22 02 04 02 22 1C 00 00 00 00 00 00 00
00 00 04 0C 14 24 3E 04 04 00 00 00 00 00 00 00
00 00 3E 20 3C 02 02 02 3C 00 00 00 00 00 00 00
00 00 1C 20 20 3C 22 22 1C 00 00 00 00 00 00 00
00 00 3E 02 04 08 10 20 20 00 00 00 00 00 00 00
00 00 1C 22 22 1C 22 22 1C 00 00 00 00 00 00 00
00 00 1C 22 22 1E 02 02 1C 00 00 00 00 00 00 00
00 00 00 00 08 00 00 08 00 00 00 00 00 00 00 00
00 00 00 00 08 00 00 08 08 10 00 00 00 00 00 00
00 00 04 08 10 20 10 08 04 00 00 00 00 00 00 00
00 00 00 00 3E 00 3E 00 00 00 00 00 00 00 00 00
00 00 10 08 04 02 04 08 10 00 00 00 00 00 00 00
00 00 1C 22 02 04 08 00 08 00 00 00 00 00 00 00
00 00 1C 22 02 1A 2A 2A 1C 00 00 00 00 00 00 00
00 00 08 14 22 22 3E 22 22 00 00 00 00 00 00 00
00 00 3C 12 12 1C 12 12 3C 00 00 00 00 00 00 00
00 00 1C 22 20 20 20 22 1C 00 00 00 00 00 00 00
00 00 3C 12 12 12 12 12 3C 00 00 00 00 00 00 00
00 00 3E 20 20 3C 20 20 3E 00 00 00 00 00 00 00
00 00 3E 20 20 3C 20 20 20 00 00 00 00 00 00 00
00 00 1E 20 20 26 22 22 1C 00 00 00 00 00 00 00
00 00 22 22 22 3E 22 22 22 00 00 00 00 00 00 00
00 00 1C 08 08 08 08 08 1C 00 00 00 00 00 00 00
00 00 02 02 02 02 22 22 1C 00 00 00 00 00 00 00
00 00 22 24 28 30 28 24 22 00 00 00 00 00 00 00
00 00 20 20 20 20 20 20 3E 00 00 00 00 00 00 00
00 00 22 36 2A 2A 22 22 22 00 00 00 00 00 00 00
00 00 22 32 2A 26 22 22 22 00 00 00 00 00 00 00
00 00 1C 22 22 22 22 22 1C 00 00 00 00 00 00 00
00 00 3C 22 22 3C 20 20 20 00 00 00 00 00 00 00
00 00 1C 22 22 22 2A 24 1A 00 00 00 00 00 00 00
00 00 3C 22 22 3C 28 24 22 00 00 00 00 00 00 00
00 00 1C 22 10 08 04 22 1C 00 00 00 00 00 00 00
00 00 3E 08 08 08 08 08 08 00 00 00 00 00 00 00
00 00 22 22 22 22 22 22 1C 00 00 00 00 00 00 00
00 00 22 22 22 14 14 08 08 00 00 00 00 00 00 00
00 00 22 22 22 2A 2A 36 22 00 00 00 00 00 00 00
00 00 22 22 14 08 14 22 22 00 00 00 00 00 00 00
00 00 22 22 14 08 08 08 08 00 00 00 00 00 00 00
00 00 3E 02 04 08 10 20 3E 00 00 00 00 00 00 00
00 00 38 20 20 20 20 20 38 00 00 00 00 00 00 00
00 00 20 20 10 08 04 02 02 00 00 00 00 00 00 00
00 00 0E 02 02 02 02 02 0E 00 00 00 00 00 00 00
00 00 08 1C 2A 08 08 08 08 00 00 00 00 00 00 00
00 00 00 08 10 3E 10 08 00 00 00 00 00 00 00 00
00 00 08 14 22 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 1C 02 1E 22 1E 00 00 00 00 00 00 00
00 00 20 20 2C 32 22 32 2C 00 00 00 00 00 00 00
00 00 00 00 1C 22 20 22 1C 00 00 00 00 00 00 00
00 00 02 02 1A 26 22 26 1A 00 00 00 00 00 00 00
00 00 00 00 1C 22 3E 20 1C 00 00 00 00 00 00 00
00 00 04 0A 08 1C 08 08 08 00 00 00 00 00 00 00
00 00 00 00 1A 26 26 1A 02 1C 00 00 00 00 00 00
00 00 20 20 2C 32 22 22 22 00 00 00 00 00 00 00
00 00 00 08 00 18 08 08 1C 00 00 00 00 00 00 00
00 00 00 02 00 02 02 02 22 1C 00 00 00 00 00 00
00 00 20 20 24 28 30 28 24 00 00 00 00 00 00 00
00 00 18 08 08 08 08 08 1C 00 00 00 00 00 00 00
00 00 00 00 14 2A 2A 2A 2A 00 00 00 00 00 00 00
00 00 00 00 2C 32 22 22 22 00 00 00 00 00 00 00
00 00 00 00 1C 22 22 22 1C 00 00 00 00 00 00 00
00 00 00 00 2C 32 32 2C 20 20 00 00 00 00 00 00
00 00 00 00 1A 26 26 1A 02 02 00 00 00 00 00 00
00 00 00 00 2C 32 20 20 20 00 00 00 00 00 00 00
00 00 00 00 1E 20 1C 02 3C 00 00 00 00 00 00 00
00 00 10 10 38 10 10 12 0C 00 00 00 00 00 00 00
00 00 00 00 22 22 22 26 1A 00 00 00 00 00 00 00
00 00 00 00 22 22 22 14 08 00 00 00 00 00 00 00
00 00 00 00 22 2A 2A 14 14 00 00 00 00 00 00 00
00 00 00 00 22 14 08 14 22 00 00 00 00 00 00 00
00 00 00 00 22 22 22 1E 02 1C 00 00 00 00 00 00
00 00 00 00 3E 04 08 10 3E 00 00 00 00 00 00 00
00 00 08 10 10 20 10 10 08 00 00 00 00 00 00 00
00 00 08 08 08 00 08 08 08 00 00 00 00 00 00 00
00 00 08 04 04 02 04 04 08 00 00 00 00 00 00 00
00 00 10 2A 04 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 3E 00 00 00 00 00 00 00
+102
View File
@@ -0,0 +1,102 @@
//============================================================================
// Verilog conversions of the CoCo3 ROM entities in rtl/rom/*.vhd.
//
// Line-for-line translations: same entity names, same ports, same clocking.
// The three loadable ROMs are single-clock RAMs filled over ioctl; while a
// write is in progress the read register holds its previous value, exactly as
// the VHDL `if WRITE = '1' ... else DATA <= ...` does.
//============================================================================
// rtl/rom/coco_rom_32K.vhd -- CoCo3 system ROM (boot0.rom, ioctl index 0)
module COCO_ROM_32K
(
input [14:0] ADDR,
output reg [7:0] DATA,
input CLK,
input [14:0] WR_ADDR,
input [7:0] WR_DATA,
input WRITE
);
reg [7:0] ROM [0:32767];
always @(posedge CLK) begin
if (WRITE) ROM[WR_ADDR] <= WR_DATA;
else DATA <= ROM[ADDR];
end
endmodule
// rtl/rom/coco_rom_8K.vhd -- Disk BASIC ROM (boot1.rom, ioctl index 64)
module COCO_ROM_8K
(
input [12:0] ADDR,
output reg [7:0] DATA,
input CLK,
input [12:0] WR_ADDR,
input [7:0] WR_DATA,
input WRITE
);
reg [7:0] ROM [0:8191];
always @(posedge CLK) begin
if (WRITE) ROM[WR_ADDR] <= WR_DATA;
else DATA <= ROM[ADDR];
end
endmodule
// rtl/rom/coco_rom_cart.vhd -- Program Pak, up to 128K (ioctl index 1)
module COCO_ROM_CART
(
input [16:0] ADDR,
output reg [7:0] DATA,
input CLK,
input [16:0] WR_ADDR,
input [7:0] WR_DATA,
input WRITE
);
reg [7:0] ROM [0:131071];
always @(posedge CLK) begin
if (WRITE) ROM[WR_ADDR] <= WR_DATA;
else DATA <= ROM[ADDR];
end
endmodule
// rtl/rom/coco_rom_16.vhd -- the AMW (automatic memory write) script: three
// {valid, a24..a0, data} records followed by a terminator. Asynchronous.
module COCO_ROM_16
(
input [3:0] ADDR,
output reg [7:0] DATA
);
always @(*) begin
case (ADDR)
// Clear $71 [Warm Start Flag]
4'd0: DATA = 8'h80; 4'd1: DATA = 8'h07; 4'd2: DATA = 8'h00;
4'd3: DATA = 8'h71; 4'd4: DATA = 8'h00;
// Set $C000 <- $55 [Clear D in DK identifier in rom]
4'd5: DATA = 8'h80; 4'd6: DATA = 8'h07; 4'd7: DATA = 8'hC0;
4'd8: DATA = 8'h00; 4'd9: DATA = 8'h55;
// Clear $72 [Warm Start Jump]
4'd10: DATA = 8'h80; 4'd11: DATA = 8'h07; 4'd12: DATA = 8'h00;
4'd13: DATA = 8'h72; 4'd14: DATA = 8'h00;
// terminator
default: DATA = 8'h00;
endcase
end
endmodule
// rtl/rom/coco3_char_rom.vhd -- 4K font RAM, preloaded with the CoCo3 font
// (verilator/rtl/coco3_char_rom.mem, extracted from the VHDL by gen_mem.py).
// Separate write and registered-read clocks, as in the VHDL.
module coco3_Char_ROM
(
input RD_CLK,
input [11:0] ADDR_R,
output reg [7:0] DATA_R,
input WR_CLK,
input WE,
input [11:0] ADDR_W,
input [7:0] DATA_W
);
reg [7:0] RAM [0:4095];
initial $readmemh("rtl/coco3_char_rom.mem", RAM);
always @(posedge WR_CLK) if (WE) RAM[ADDR_W] <= DATA_W;
always @(posedge RD_CLK) DATA_R <= RAM[ADDR_R];
endmodule
+33
View File
@@ -0,0 +1,33 @@
//============================================================================
// Verilog conversions of rtl/sram/*.vhd: synchronous write, asynchronous
// read, matching the VHDL (`DATA_O <= SRAM(ADDR)` outside the process).
//============================================================================
// rtl/sram/coco_ram.vhd -- 64K cassette buffer (R_W low = write)
module COCO_SRAM
(
input CLK,
input [15:0] ADDR,
input R_W,
input [7:0] DATA_I,
output [7:0] DATA_O
);
reg [7:0] SRAM [0:65535];
always @(posedge CLK) if (!R_W) SRAM[ADDR] <= DATA_I;
assign DATA_O = SRAM[ADDR];
endmodule
// rtl/sram/coco_vid_ram_buf.vhd -- 512 x 16 video line buffer
module COCO_VID_RAM_BUF
(
input CLK,
input [8:0] ADDR_I,
input [8:0] ADDR_O,
input WE,
input [15:0] DATA_I,
output [15:0] DATA_O
);
reg [15:0] SRAM [0:511];
always @(posedge CLK) if (WE) SRAM[ADDR_I] <= DATA_I;
assign DATA_O = SRAM[ADDR_O];
endmodule
+327
View File
@@ -0,0 +1,327 @@
//============================================================================
// Simulation replacement for rtl/sdram/sdram2.sv (module sdram_32r8w).
//
// The controller below is rtl/sdram/sdram2.sv copied verbatim -- the same
// state machine, refresh schedule, CAS/burst delays and ack/ready timing the
// core is written against. Only the pins changed:
//
// - SDRAM_DQ is not a tristate. The controller's drive is SDRAM_DQ (a reg
// that it sets to 16'bZ when idle, harmless here) and what it samples is
// chip_dq, driven by the chip model at the bottom of this file.
// - The block-local registers of the main always block are declared at
// module scope instead; see the note there.
// - The altddio_out that forwards the (inverted) clock to the chip is gone;
// the chip model samples the controller's registered command one clk
// later, which is where the inverted SDRAM_CLK edge lands.
//
// Chip model: one 32 MB x16 SDR SDRAM, CAS latency 3, sequential burst 2,
// single-word writes, DQM byte masks on A[12:11] -- the mode sdram2.sv
// programs. A READ registered at clk edge k (command <= CMD_READ) makes word 0
// land in dq_reg at edge k+4 and word 1 at k+5, which is exactly when the
// controller's data_*_ready_delay taps say the data is there.
//============================================================================
module sdram_32r8w
(
input init, // reset to initialize RAM
input clk, // clock ~100MHz
// CPU R/W port
input [24:0] sdram_cpu_addr, // 25 bit address for 8bit mode.
output [15:0] sdram_dout, // data output to cpu [for both ports]
input [7:0] sdram_cpu_din, // data input from cpu
input sdram_cpu_req, // request
input sdram_cpu_rnw, // 1 - read, 0 - write
output reg sdram_cpu_ack, // 1 = ack
output reg sdram_cpu_ready, // dout is valid. Ready to accept new read/write.
// Video R port
input [24:0] sdram_vid_addr, // 25 bit A0=0.
input sdram_vid_req, // request
output reg sdram_vid_ack, // 1 = ack
output reg sdram_vid_ready, // dout is valid. Ready to accept new read/write.
output reg sdram_busy // doing something...
);
reg [15:0] SDRAM_DQ;
reg [12:0] SDRAM_A;
reg [1:0] SDRAM_BA;
reg [15:0] chip_dq;
assign sdram_dout = dq_reg;
// Burst length = 4
localparam BURST_LENGTH = 2;
localparam BURST_CODE = (BURST_LENGTH == 8) ? 3'b011 : (BURST_LENGTH == 4) ? 3'b010 : (BURST_LENGTH == 2) ? 3'b001 : 3'b000; // 000=1, 001=2, 010=4, 011=8
localparam ACCESS_TYPE = 1'b0; // 0=sequential, 1=interleaved
localparam CAS_LATENCY = 3'd3; // 2 for < 100MHz, 3 for >100MHz
localparam OP_MODE = 2'b00; // only 00 (standard operation) allowed
localparam NO_WRITE_BURST = 1'b1; // 0= write burst enabled, 1=only single access write
localparam MODE = {3'b000, NO_WRITE_BURST, OP_MODE, CAS_LATENCY, ACCESS_TYPE, BURST_CODE};
localparam sdram_startup_cycles= 14'd12100;// 100us, plus a little more, @ 100MHz
localparam startup_refresh_max = 14'b11111111111111;
//localparam cycles_per_refresh = 14'd780; // (64000*100)/8192-1 Calc'd as (64ms @ 100MHz)/8192 rose
localparam cycles_per_refresh = 14'd890; // (64000*100)/8192-1 Calc'd as (64ms @ 114.560MHz)/8192 rose (act 895)
// SDRAM commands
wire [2:0] CMD_NOP = 3'b111;
wire [2:0] CMD_ACTIVE = 3'b011;
wire [2:0] CMD_READ = 3'b101;
wire [2:0] CMD_WRITE = 3'b100;
wire [2:0] CMD_PRECHARGE = 3'b010;
wire [2:0] CMD_AUTO_REFRESH = 3'b001;
wire [2:0] CMD_LOAD_MODE = 3'b000;
reg [13:0] refresh_count = startup_refresh_max - sdram_startup_cycles;
reg [2:0] command;
localparam STATE_STARTUP = 0;
localparam STATE_WAIT = 1;
localparam STATE_WAIT1 = 2;
localparam STATE_RW1 = 3;
localparam STATE_IDLE = 4;
localparam STATE_DLY1 = 5;
localparam STATE_DLY2 = 6;
localparam STATE_IDLE_7 = 17;
localparam STATE_IDLE_6 = 16;
localparam STATE_IDLE_5 = 15;
localparam STATE_IDLE_4 = 14;
localparam STATE_IDLE_3 = 13;
localparam STATE_IDLE_2 = 12;
localparam STATE_IDLE_1 = 11;
reg [15:0] dq_reg;
// In the original these are declared inside the always block below, with
// `state` initialised there. Verilator (5.044) re-applies a block-local
// initialiser every time the block runs, so `state` was forced back to
// STATE_STARTUP on every clock and no request was ever served. At module scope
// the initialiser runs once, as Quartus treats it.
reg [CAS_LATENCY+BURST_LENGTH:0] data_cpu_ready_delay;
reg [CAS_LATENCY+BURST_LENGTH:0] data_vid_ready_delay;
reg saved_wr;
reg saved_vid;
reg [12:0] cas_addr;
reg [31:0] saved_data;
reg [4:0] state = STATE_STARTUP;
always @(posedge clk) begin
refresh_count <= refresh_count + 1'b1;
data_vid_ready_delay[CAS_LATENCY+BURST_LENGTH] <= 0;
data_cpu_ready_delay[CAS_LATENCY+BURST_LENGTH] <= 0;
data_cpu_ready_delay <= data_cpu_ready_delay>>1;
data_vid_ready_delay <= data_vid_ready_delay>>1;
dq_reg <= chip_dq;
// if(data_ready_delay[1]) sdram_ldout[15:00] <= dq_reg;
// if(data_ready_delay[0]) sdram_ldout[31:16] <= dq_reg;
sdram_cpu_ready <= 1'b0;
sdram_vid_ready <= 1'b0;
if (data_cpu_ready_delay[2]) sdram_cpu_ready <= 1'b1; // Data valid for the first 16 bits
if (data_cpu_ready_delay[1]) sdram_busy <= 1'b0;
if (data_vid_ready_delay[2]) sdram_vid_ready <= 1'b1; // Data valid for the first 16 bits
if (data_vid_ready_delay[1]) sdram_vid_ready <= 1'b1; // Data valid for the second 16 bits
if (data_vid_ready_delay[0]) sdram_busy <= 1'b0;
SDRAM_DQ <= 16'h0000; // was 16'bZ: the bus is not tristated here
command <= CMD_NOP;
if (!sdram_cpu_req)
sdram_cpu_ack <= 1'b0;
if (!sdram_vid_req)
sdram_vid_ack <= 1'b0;
case (state)
STATE_STARTUP: begin
SDRAM_A <= 0;
SDRAM_BA <= 0;
sdram_cpu_ready <= 0; //not ready
sdram_vid_ready <= 0; //not ready
sdram_busy <= 1'b1;
// All the commands during the startup are NOPS, except these
if (refresh_count == startup_refresh_max-31) begin
// ensure all rows are closed
command <= CMD_PRECHARGE;
SDRAM_A[10] <= 1; // all banks
SDRAM_BA <= 2'b00;
end
if (refresh_count == startup_refresh_max-23) begin
// these refreshes need to be at least tREF (66ns) apart
command <= CMD_AUTO_REFRESH;
end
if (refresh_count == startup_refresh_max-15) begin
command <= CMD_AUTO_REFRESH;
end
if (refresh_count == startup_refresh_max-7) begin
// Now load the mode register
command <= CMD_LOAD_MODE;
SDRAM_A <= MODE;
end
if (!refresh_count) begin
state <= STATE_IDLE;
sdram_busy <= 1'b0;
refresh_count <= 0;
end
end
STATE_IDLE_7: state <= STATE_IDLE_6;
STATE_IDLE_6: state <= STATE_IDLE_5;
STATE_IDLE_5: state <= STATE_IDLE_4;
STATE_IDLE_4: state <= STATE_IDLE_3;
STATE_IDLE_3: state <= STATE_IDLE_2;
STATE_IDLE_2: state <= STATE_IDLE_1;
STATE_IDLE_1: begin
state <= STATE_IDLE;
sdram_busy <= 1'b0;
// mask possible refresh to reduce colliding.
if(refresh_count > cycles_per_refresh) begin
state <= STATE_IDLE_7;
command <= CMD_AUTO_REFRESH;
refresh_count <= 0;
sdram_busy <= 1'b1;
end
end
STATE_IDLE: begin
saved_vid <= 1'b0;
if(refresh_count > (cycles_per_refresh<<1))
begin
state <= STATE_IDLE_1;
sdram_busy <= 1'b1;
end
else
begin
if(sdram_cpu_req & !sdram_cpu_ack) // request has to go away after ready=0
begin
// fix byte writes [no new command until data is actually written]
if (~sdram_cpu_rnw)
{cas_addr[12:9],SDRAM_BA,SDRAM_A,cas_addr[8:0]} <= {~sdram_cpu_addr[0], sdram_cpu_addr[0], 2'b10, sdram_cpu_addr[24:1]}; // Bytes by A0 for writes
else
{cas_addr[12:9],SDRAM_BA,SDRAM_A,cas_addr[8:0]} <= {2'b00, 2'b10, sdram_cpu_addr[24:1]}; // No bytes for reads...
saved_data <= {sdram_cpu_din, sdram_cpu_din};
saved_wr <= ~sdram_cpu_rnw;
command <= CMD_ACTIVE;
state <= STATE_WAIT;
sdram_busy <= 1'b1;
end
else
begin
if (sdram_vid_req)
begin
{cas_addr[12:9],SDRAM_BA,SDRAM_A,cas_addr[8:0]} <= {2'b00, 2'b10, sdram_vid_addr[24:1]}; // No bytes for reads...
command <= CMD_ACTIVE;
saved_vid <= 1'b1;
saved_wr <= 1'b0;
sdram_busy <= 1'b1;
state <= STATE_WAIT;
end
end
end
end
STATE_WAIT: state <= STATE_WAIT1;
STATE_WAIT1: begin
if (saved_wr)
begin
if ((data_vid_ready_delay[5:1] == 5'b00000) && (data_cpu_ready_delay[5:1] == 5'b00000))
state <= STATE_RW1; // added for clk > 100Mhz
end
else
state <= STATE_RW1; // added for clk > 100Mhz
end
STATE_RW1: begin
SDRAM_A <= cas_addr;
if (saved_vid)
sdram_vid_ack <= 1'b1;
else
sdram_cpu_ack <= 1'b1;
if(saved_wr) begin
command <= CMD_WRITE;
SDRAM_DQ <= saved_data[15:0];
// state <= STATE_IDLE;
state <= STATE_DLY1;
sdram_cpu_ready <= 1'b1; // write done
sdram_busy <= 1'b0;
end
else begin
command <= CMD_READ;
state <= STATE_IDLE;
if (saved_vid)
begin
data_vid_ready_delay[CAS_LATENCY+BURST_LENGTH] <= 1;
state <= STATE_DLY1;
end
else
data_cpu_ready_delay[CAS_LATENCY+BURST_LENGTH] <= 1;
state <= STATE_DLY1;
end
end
STATE_DLY1:
state <= STATE_DLY2;
STATE_DLY2:
state <= STATE_IDLE;
endcase
if (init) begin
sdram_cpu_ack <= 1'b0;
sdram_vid_ack <= 1'b0;
state <= STATE_STARTUP;
refresh_count <= startup_refresh_max - sdram_startup_cycles;
end
end
//----------------------------------------------------------------------------
// SDR SDRAM chip model
//----------------------------------------------------------------------------
reg [15:0] chip_mem [0:(1<<24)-1];
reg [12:0] chip_row [0:3];
reg rd_p1, rd_p2, rd_w1;
reg [23:0] rd_a1, rd_a2, rd_aw;
wire [23:0] cmd_addr = {SDRAM_BA, chip_row[SDRAM_BA], SDRAM_A[8:0]};
always @(posedge clk) begin
case (command)
3'b011: chip_row[SDRAM_BA] <= SDRAM_A; // ACTIVE
3'b100: begin // WRITE
if (!SDRAM_A[11]) chip_mem[cmd_addr][7:0] <= SDRAM_DQ[7:0];
if (!SDRAM_A[12]) chip_mem[cmd_addr][15:8] <= SDRAM_DQ[15:8];
end
default: ;
endcase
// READ: two pipeline stages, then word 0 and word 1 on consecutive edges.
rd_p1 <= (command == 3'b101);
rd_a1 <= cmd_addr;
rd_p2 <= rd_p1;
rd_a2 <= rd_a1;
rd_w1 <= rd_p2;
rd_aw <= {rd_a2[23:1], ~rd_a2[0]}; // burst 2, sequential
if (rd_p2) chip_dq <= chip_mem[rd_a2];
else if (rd_w1) chip_dq <= chip_mem[rd_aw];
else chip_dq <= 16'h0000;
end
endmodule
+32
View File
@@ -0,0 +1,32 @@
0000 0010 0020 0030 0040 0050 0060 0070
0080 0090 00A0 00B0 00C0 00D0 00E0 00F0
0100 0110 0120 0130 0140 0150 0160 0170
0180 0190 01A0 01B0 01C0 01D0 01E0 01F0
0200 0210 0220 0230 0240 0250 0260 0270
0280 0290 02A0 02B0 02C0 02D0 02E0 02F0
0300 0310 0320 0330 0340 0350 0360 0370
0380 0390 03A0 03B0 03C0 03D0 03E0 03F0
0400 0410 0420 0430 0440 0450 0460 0470
0480 0490 04A0 04B0 04C0 04D0 04E0 04F0
0500 0510 0520 0530 0540 0550 0560 0570
0580 0590 05A0 05B0 05C0 05D0 05E0 05F0
0600 0610 0620 0630 0640 0650 0660 0670
0680 0690 06A0 06B0 06C0 06D0 06E0 06F0
0700 0710 0720 0730 0740 0750 0760 0770
0780 0790 07A0 07B0 07C0 07D0 07E0 07F0
0800 0810 0820 0830 0840 0850 0860 0870
0880 0890 08A0 08B0 08C0 08D0 08E0 08F0
0900 0910 0920 0930 0940 0950 0960 0970
0980 0990 09A0 09B0 09C0 09D0 09E0 09F0
0A00 0A10 0A20 0A30 0A40 0A50 0A60 0A70
0A80 0A90 0AA0 0AB0 0AC0 0AD0 0AE0 0AF0
0B00 0B10 0B20 0B30 0B40 0B50 0B60 0B70
0B80 0B90 0BA0 0BB0 0BC0 0BD0 0BE0 0BF0
0C00 0C10 0C20 0C30 0C40 0C50 0C60 0C70
0C80 0C90 0CA0 0CB0 0CC0 0CD0 0CE0 0CF0
0D00 0D10 0D20 0D30 0D40 0D50 0D60 0D70
0D80 0D90 0DA0 0DB0 0DC0 0DD0 0DE0 0DF0
0E00 0E10 0E20 0E30 0E40 0E50 0E60 0E70
0E80 0E90 0EA0 0EB0 0EC0 0ED0 0EE0 0EF0
0F00 0F10 0F20 0F30 0F40 0F50 0F60 0F70
0F80 0F90 0FA0 0FB0 0FC0 0FD0 0FE0 0FF0
+112
View File
@@ -0,0 +1,112 @@
#!/usr/bin/env bash
#
# Headless smoke tests for the CoCo3 sim. Each test boots the machine, types at
# BASIC on a frame schedule, and is judged two ways:
#
# * the TEXT SCREEN ($0400, as the CPU wrote it) must contain every expected
# string -- this is what says the machine did the right thing;
# * the final SCREENSHOT is compared byte for byte with $REF/<name>.png --
# this is what catches a video change nobody meant to make.
#
# The sim is deterministic, so a screenshot only moves when the RTL (or the
# harness) moves it. When a change is intentional, bless the new references:
#
# BLESS=1 ./run_tests.sh
#
# A test with no reference is reported "new" and does not fail the run.
# Tests run in parallel; each is a few minutes (the sim runs at ~1.2 frames/s,
# and the core's own power-on reset plus the BASIC banner take ~130 frames).
#
# ./run_tests.sh all tests
# ./run_tests.sh boot disk just those
#
# Needs roms/boot0.rom (CoCo3 ROM) and roms/boot1.rom (Disk BASIC 1.1); see
# README.md.
set -u
cd "$(dirname "$0")"
EXE=./obj_dir/Vemu
OUT=${OUT:-test-out}
SIMARGS=${SIMARGS:-} # extra sim options for every test, e.g. --fast-clocks
REF=${REF:-test-ref}
mkdir -p "$OUT" "$REF"
if [ ! -x "$EXE" ]; then echo "build first: make"; exit 2; fi
for r in roms/boot0.rom roms/boot1.rom; do
[ -f "$r" ] || { echo "missing $r -- see README.md"; exit 2; }
done
[ -f tests/hello.dsk ] || python3 tests/make_test_disk.py >/dev/null
# name | stop frame | extra args | expected strings (;-separated)
TESTS=(
"boot|150||DISK EXTENDED COLOR BASIC 2.1;OK"
"keyboard|260|--type '140:PRINT 2+2\\n'|PRINT 2+2; 4"
"disk|420|--disk tests/hello.dsk --type '140:RUN\"HELLO\\n'|HELLO FROM DISK; 42"
# GIME modes. --ascii only reads the 32-column VDG screen, so these two are
# judged on the screenshot alone.
"width80|330|--type '140:WIDTH 80\\nPRINT \"80 COLUMNS\"\\n'|"
"hscreen|560|--type '140:HSCREEN2:HCIRCLE(160,96),60,4:HLINE(0,0)-(319,191),PSET,B:FORI=1TO9E9:NEXT\\n'|"
)
want=("$@")
selected() {
[ ${#want[@]} -eq 0 ] && return 0
for w in "${want[@]}"; do [ "$w" = "$1" ] && return 0; done
return 1
}
pids=()
names=()
for t in "${TESTS[@]}"; do
IFS='|' read -r name stop extra expect <<<"$t"
selected "$name" || continue
# shellcheck disable=SC2086
eval "set -- $extra"
# shellcheck disable=SC2086
( "$EXE" --headless --stop-at-frame "$stop" $SIMARGS "$@" \
--screenshot "$stop" --screenshot-prefix "$OUT/$name" --ascii-end \
> "$OUT/$name.log" 2>&1 ) &
pids+=($!)
names+=("$name")
done
for p in "${pids[@]}"; do wait "$p"; done
fail=0
printf "%-10s %-6s %-9s %s\n" TEST SCREEN IMAGE NOTES
for t in "${TESTS[@]}"; do
IFS='|' read -r name stop extra expect <<<"$t"
selected "$name" || continue
log="$OUT/$name.log"
shot=$(printf "%s/%s_frame_%04d.png" "$OUT" "$name" "$stop")
notes=""
screen=ok
if [ -n "$expect" ]; then # bash 3.2: an empty array is "unbound" under set -u
IFS=';' read -r -a strings <<<"$expect"
for s in "${strings[@]}"; do
if ! grep -qF -- "|$s" "$log"; then screen=FAIL; notes="$notes missing \"$s\";"; fi
done
else
screen=-
fi
image=ok
if [ ! -f "$shot" ]; then
image=FAIL; notes="$notes no screenshot;"
elif [ -n "${BLESS:-}" ]; then
cp "$shot" "$REF/$name.png"; image=blessed
elif [ ! -f "$REF/$name.png" ]; then
image=new
elif ! cmp -s "$shot" "$REF/$name.png"; then
image=CHANGED; notes="$notes differs from $REF/$name.png;"
fi
[ "$screen" = FAIL ] && fail=1
[ "$image" = FAIL ] || [ "$image" = CHANGED ] && fail=1
notes="$notes $(grep -o 'Finished at frame.*' "$log" | sed 's/, active.*//')"
printf "%-10s %-6s %-9s %s\n" "$name" "$screen" "$image" "$notes"
done
exit $fail
+172
View File
@@ -0,0 +1,172 @@
#include "serial.h"
#include <algorithm>
#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>
static const double CLK_SYS_HZ = 57272727.0;
static const int XTAL_DIV = 31; // coco3fpga.sv CLK_6551_EN
static const size_t HIST_MAX = 4096;
// uart_6551.v: TX_CLK_DIV wraps after this many enables for CTL[3:0]; the
// baud clock toggles on each wrap and pulses on every second one.
static const int wrap_enables[16] = {
0, 1152, 768, 524, 428, 384, 192, 96, 48, 32, 24, 16, 12, 8, 6, 3
};
long SerialPort::bit_clks(uint8_t ctl) {
int sel = ctl & 0x0F;
// CTL[3:0] == 0: "16x external clock", which in this core is the
// 1.8475 MHz enable itself -- 115,469 baud.
long enables_per_16x = sel ? 2L * wrap_enables[sel] : 1L;
return XTAL_DIV * enables_per_16x * 16;
}
long SerialPort::rx_bit_clks(uint8_t ctl) {
// uart_6551.v: RX_CLK = TX_CLK, i.e. the receiver always runs off the baud
// generator. (It used to take the "external" 1.8475 MHz clock when CTL bit 4
// was 0, which made CTL=$0F transmit at 19,200 but receive at 115,200.)
return bit_clks(ctl);
}
double SerialPort::baud(long clks) { return CLK_SYS_HZ / (double)clks; }
bool SerialPort::open_pty() {
pty_fd = posix_openpt(O_RDWR | O_NOCTTY);
if (pty_fd < 0 || grantpt(pty_fd) < 0 || unlockpt(pty_fd) < 0) {
perror("serial: posix_openpt");
return false;
}
const char* name = ptsname(pty_fd);
if (!name) { perror("serial: ptsname"); return false; }
pty_name = name;
// Hold the slave open ourselves: otherwise reads on the master return EIO
// until something connects, and again whenever the far end reconnects.
pty_slave_fd = open(name, O_RDWR | O_NOCTTY);
if (pty_slave_fd >= 0) {
struct termios t;
if (tcgetattr(pty_slave_fd, &t) == 0) {
cfmakeraw(&t);
tcsetattr(pty_slave_fd, TCSANOW, &t);
}
}
fcntl(pty_fd, F_SETFL, fcntl(pty_fd, F_GETFL) | O_NONBLOCK);
printf("Serial: RS-232 Pak on pty %s\n", name);
fflush(stdout);
return true;
}
void SerialPort::queue_rx(const uint8_t* p, size_t n) {
rx_queue.insert(rx_queue.end(), p, p + n);
}
void SerialPort::poll_pty() {
if (pty_fd < 0) return;
uint8_t buf[256];
ssize_t n = read(pty_fd, buf, sizeof(buf));
if (n > 0) queue_rx(buf, (size_t)n);
}
void SerialPort::got_tx_byte(uint8_t b, bool framing_ok, int frame) {
tx_count++;
if (!framing_ok) tx_framing_errors++;
tx_hist.push_back(b);
if (tx_hist.size() > HIST_MAX) tx_hist.erase(tx_hist.begin());
tx_line.push_back(b);
if (log_file)
fprintf(log_file, "%6d TX %02X%s\n", frame, b, framing_ok ? "" : " framing error");
if (pty_fd >= 0) {
ssize_t w = write(pty_fd, &b, 1);
(void)w;
}
}
uint8_t SerialPort::clock(uint8_t txd, uint8_t ctl_now, uint8_t cmd_now, int frame) {
ctl = ctl_now;
cmd = cmd_now;
// ---- TX: decode what the 6551 puts on the pin ---------------------
const long bclk = bit_clks(ctl);
switch (tx_phase) {
case 0:
if (tx_last && !txd) { tx_phase = 1; tx_timer = bclk / 2; }
break;
case 1: // middle of the start bit
if (--tx_timer <= 0) {
if (txd) tx_phase = 0; // glitch, not a start bit
else { tx_phase = 2; tx_timer = bclk; tx_bitn = 0; tx_shift = 0; }
}
break;
case 2: // data bits, LSB first
if (--tx_timer <= 0) {
tx_shift |= (uint16_t)(txd & 1) << tx_bitn;
tx_timer = bclk;
if (++tx_bitn == data_bits(ctl)) tx_phase = (cmd & 0x20) ? 3 : 4;
}
break;
case 3: // parity (not checked)
if (--tx_timer <= 0) { tx_phase = 4; tx_timer = bclk; }
break;
case 4: // stop bit
if (--tx_timer <= 0) {
got_tx_byte((uint8_t)tx_shift, txd != 0, frame);
tx_phase = 0;
}
break;
}
tx_last = txd;
// ---- RX: drive the pin, 8N1 at the far end's rate -------------------
if (++poll_timer >= 4096) { poll_timer = 0; poll_pty(); }
if (rx_timer > 0) rx_timer--;
if (rx_timer == 0) {
if (rx_bits_left == 0 && !rx_queue.empty()) {
uint8_t b = rx_queue.front();
rx_queue.pop_front();
rx_count++;
rx_hist.push_back(b);
if (rx_hist.size() > HIST_MAX) rx_hist.erase(rx_hist.begin());
rx_line.push_back(b);
if (log_file) fprintf(log_file, "%6d RX %02X\n", frame, b);
rx_frame = (uint16_t)(1u << 9) | ((uint16_t)b << 1); // start 0, data, stop 1
rx_bits_left = 10;
}
if (rx_bits_left > 0) {
// Each bit, the stop bit included, is held for a full bit time.
rx_level = rx_frame & 1;
rx_frame >>= 1;
rx_bits_left--;
rx_timer = line_clks();
} else {
rx_level = 1;
}
}
return rx_level;
}
void SerialPort::print_line(const char* dir, std::vector<uint8_t>& v, int frame) {
if (v.empty()) return;
if (print_bytes) {
for (size_t i = 0; i < v.size(); i += 16) {
char hex[16 * 3 + 1] = {0}, asc[17] = {0};
size_t n = std::min<size_t>(16, v.size() - i);
for (size_t j = 0; j < n; j++) {
uint8_t c = v[i + j];
snprintf(hex + j * 3, 4, "%02X ", c);
asc[j] = (c >= 0x20 && c < 0x7f) ? (char)c : '.';
}
printf("SERIAL %s %6d %-48s |%s|\n", dir, frame, hex, asc);
}
fflush(stdout);
}
v.clear();
}
void SerialPort::end_frame(int frame) {
print_line("TX", tx_line, frame);
print_line("RX", rx_line, frame);
}
+81
View File
@@ -0,0 +1,81 @@
#pragma once
//============================================================================
// RS-232 Pak (glb6551) line model for the CoCo3 sim.
//
// Works on the pins, not on the registers: TXD is decoded as the far end of
// the cable would see it, and RXD is driven bit by bit. So a byte is only
// logged as transmitted if the 6551 really shifted it out, at the baud rate
// it was really programmed for.
//
// Clocked once per clk_sys (57.272727 MHz). Bit timing follows
// rtl/UART_6551/uart_6551.v: a 1.8475 MHz enable (clk_sys / 31) feeds the
// divider; the 6551 samples at 16x the bit rate.
//
// Optional pty bridge: the slave side (/dev/ttysNNN) can be opened by a
// DriveWire server or FujiNet-PC, or by socat to reach a TCP one. Note the sim
// runs ~50x slower than real time, so the far end sees ~400 baud of real
// throughput whatever the programmed rate is.
//============================================================================
#include <cstdint>
#include <cstdio>
#include <deque>
#include <string>
#include <vector>
struct SerialPort {
// --- configuration -------------------------------------------------
bool print_bytes = true; // SERIAL TX/RX lines on stdout
FILE* log_file = nullptr; // --serial-log: one line per byte
// Rate the far end sends at, in clk_sys cycles per bit. 0 = the rate the
// 6551 transmits at, i.e. a peer configured to match. RXD is driven at this
// rate whatever the 6551's RECEIVER is clocked at, so a receiver-clock
// mismatch shows up as garbage, as it would on the cable.
long line_bit_clks = 0;
long line_clks() const { return line_bit_clks ? line_bit_clks : bit_clks(ctl); }
// --- state visible to the UI ----------------------------------------
std::string pty_name;
long tx_count = 0, rx_count = 0;
long tx_framing_errors = 0;
std::vector<uint8_t> tx_hist, rx_hist; // capped, for the Serial window
uint8_t ctl = 0, cmd = 0; // last seen 6551 registers
// Bits per word and clk_sys cycles per bit for a control/command value.
static int data_bits(uint8_t ctl) { return 8 - ((ctl >> 5) & 3); }
static long bit_clks(uint8_t ctl); // transmitter / internal generator
static long rx_bit_clks(uint8_t ctl); // receiver (CTL bit 4 picks the source)
static double baud(long clks);
bool open_pty();
void queue_rx(const uint8_t* p, size_t n);
// One clk_sys cycle. Returns the level to drive on RXD.
uint8_t clock(uint8_t txd, uint8_t ctl, uint8_t cmd, int frame);
// Flush the per-frame byte lines.
void end_frame(int frame);
private:
// TX decoder
int tx_phase = 0; // 0 idle, 1 start, 2 data, 3 parity, 4 stop
long tx_timer = 0;
int tx_bitn = 0;
uint16_t tx_shift = 0;
uint8_t tx_last = 1;
// RX driver
std::deque<uint8_t> rx_queue;
uint16_t rx_frame = 0; // bits to send, LSB first
int rx_bits_left = 0;
long rx_timer = 0;
uint8_t rx_level = 1;
// pty
int pty_fd = -1, pty_slave_fd = -1;
long poll_timer = 0;
// per-frame print buffers
std::vector<uint8_t> tx_line, rx_line;
void got_tx_byte(uint8_t b, bool framing_ok, int frame);
void poll_pty();
void print_line(const char* dir, std::vector<uint8_t>& v, int frame);
};
+566
View File
@@ -0,0 +1,566 @@
//============================================================================
// CoCo3 Verilator simulation wrapper
//
// Stands in for CoCo3.sv (the MiSTer top level) without the sys/ framework:
// no hps_io, no PLL, no video_mixer. sim_main.cpp drives the clocks and the
// ioctl/block-device/keyboard ports; everything between those and the core
// is wired the way CoCo3.sv wires it, with the OSD `status` word decoded
// here by the same expressions.
//
// Deliberate differences from CoCo3.sv:
// - CLK_114/57/28/14 come straight from sim_main instead of the PLL. The PLL
// makes them 114.545454 / 57.272727 / 28.636363 / 14.318181 MHz, all
// phase 0, i.e. exact /2 /4 /8 divisions of one clock, which is what
// sim_main produces -- all four change in the same eval, so there is no
// derived-clock race between domains. CLK_50M (rtc.sv, the UART) is
// approximated by sim_main with a phase accumulator.
// - rtl/sdram/sdram2.sv is replaced by verilator/rtl/sdram2.sv: the same
// controller with an SDR chip model hung off it instead of SDRAM_* pins.
// - hps_io's keyboard path is reproduced from its parts: ps2_key events are
// turned into scan-code bytes and pushed into MiSTer's own ps2_device
// (sys/hps_io.sv) clocked exactly as hps_io clocks it with PS2DIV(2400),
// so cocokey.v sees the same PS/2 serial stream as on hardware.
// - The VHDL entities are replaced by their Verilog conversions in this
// directory: rtl/coco_rom.v, rtl/coco_sram.v. VDAC.v's altsyncram becomes an
// equivalent registered dual-port RAM.
//============================================================================
`timescale 1ns / 1ps
module emu
(
input CLK_114,
input CLK_57, // clk_sys
input CLK_28,
input CLK_14,
input CLK_50M,
input RESET,
// The OSD status word, bit-for-bit as hps_io would present it.
input [63:0] status,
input [1:0] buttons,
// [7:0] scancode, [8] extended, [9] pressed, [10] toggles per event
input [10:0] ps2_key,
input [24:0] ps2_mouse,
input [31:0] joy1,
input [31:0] joy2,
input [15:0] joya1,
input [15:0] joya2,
input [64:0] RTC,
// HPS ioctl download
input ioctl_download,
input ioctl_wr,
input [24:0] ioctl_addr,
input [7:0] ioctl_dout,
input [7:0] ioctl_index,
output ioctl_wait,
// MiSTer block device (VDNUM 7): 0-1 SDC, 2-5 floppy, 6 cassette write.
// Widths match SimBlockDevice's member types.
input [15:0] img_mounted,
input img_readonly,
input [63:0] img_size,
output [31:0] sd_lba [7],
output [15:0] sd_rd,
output [15:0] sd_wr,
input [15:0] sd_ack,
input [8:0] sd_buff_addr,
input [7:0] sd_buff_dout,
output [7:0] sd_buff_din [7],
input sd_buff_wr,
output [7:0] VGA_R,
output [7:0] VGA_G,
output [7:0] VGA_B,
output VGA_HS,
output VGA_VS,
output VGA_HB,
output VGA_VB,
output CE_PIXEL, // = PIX_CLK (CLK_14); sample on its rising edge
output [15:0] AUDIO_L,
output [15:0] AUDIO_R,
// RS-232 Pak (glb6551 at $FF68-$FF6B). On MiSTer these are the UART_* pins
// of the sys framework (the FujiNet daemon's /dev/ttyS1); here sim_main
// decodes TXD and drives RXD. Idle is 1.
output uart_txd,
input uart_rxd,
output uart_rts,
output uart_dtr,
// ---- debug taps ----------------------------------------------------
// Hierarchical reads into the core; nothing here drives it.
output [15:0] dbg_pc,
output [7:0] dbg_a, dbg_b, dbg_cc, dbg_dp,
output [15:0] dbg_x, dbg_y, dbg_u, dbg_s,
output dbg_lic, // last instruction cycle
output [15:0] dbg_addr,
output [7:0] dbg_din, // data into the CPU
output [7:0] dbg_dout, // data out of the CPU
output dbg_rw, // 1 = read
output dbg_ena, // cpu_cycle_ena: the CPU advances on this
output dbg_irqn,
output dbg_firqn,
output dbg_reset, // CPU_RESET
output [7:0] dbg_gime_init0, // $FF90
output [2:0] dbg_speed, // assigned_turbo_speed
// ACIA / Multi-Pak state, for the serial trace
output dbg_rs232_en, // $FF68-$FF6B decoded to the 6551 this cycle
output [1:0] dbg_mpi_scs, // $FF7F SCS (I/O slot, 0 = slot 1)
output [1:0] dbg_mpi_cts, // $FF7F CTS (ROM slot)
output [7:0] dbg_acia_ctl, // 6551 control register (baud in [3:0])
output [7:0] dbg_acia_cmd // 6551 command register
);
// The OSD word as the core sees it. hps_io hands `status` over as a register;
// registering it here too keeps it off the top-level input path. Verilator
// re-evaluates everything combinational on a top-level input at EVERY eval,
// and status feeds the video pixel mux (artifact/colour-set options), so as a
// raw input it cost ~20% of the run time.
reg [63:0] status_q = 64'd0;
always @(posedge CLK_14) status_q <= status;
//////////////////////////////////////////////////////////////////
// status decode -- copied from CoCo3.sv
//////////////////////////////////////////////////////////////////
wire clk_sys = CLK_57;
wire [2:0] turbo_speed = status_q[34:32];
wire [2:0] assigned_turbo_speed;
wire [1:0] art = status_q[38:37];
wire [1:0] Auto_Mode = status_q[41:40];
wire AMW_ACK;
wire [1:0] mpi = status_q[13:12] + 1'b1;
wire CASS_REW_RECORD = status_q[14];
wire cartint = status_q[16];
wire sg4v6 = status_q[21];
wire PHASE = status_q[18];
wire coldboot = status_q[22];
wire F_Turbo = status_q[24];
wire [2:0] Mem_Size = status_q[27:25];
wire SWAP_M_J = status_q[28];
wire digitalJoy = status_q[23];
wire easter_egg = status_q[10];
reg [2:0] mpi_d = 2'b00;
reg first_mpi_chg = 1'b0;
reg mpi_reset = 1'b0;
always @(negedge CLK_14) begin
mpi_d <= mpi;
mpi_reset <= 1'b0;
if (~(mpi == mpi_d))
if (~first_mpi_chg)
first_mpi_chg <= 1'b1;
else
mpi_reset <= 1'b1;
end
reg [2:0] Mem_Size_d = 3'b000;
reg first_mem_chg = 1'b0;
reg mem_reset = 1'b0;
always @(negedge CLK_14) begin
Mem_Size_d <= Mem_Size;
mem_reset <= 1'b0;
if (~(Mem_Size == Mem_Size_d))
if (~first_mem_chg)
first_mem_chg <= 1'b1;
else
mem_reset <= 1'b1;
end
// Set bit 9 to swap serial ports...
wire [9:0] switch = { 2'b10,art,sg4v6,cartint,CASS_REW_RECORD,mpi,1'b0};
wire reset = RESET | status_q[0] | buttons[1];
//////////////////////////////////////////////////////////////////
// Joysticks -- copied from CoCo3.sv
//////////////////////////////////////////////////////////////////
wire [9:0] center_joystick_y1 = 8'd128 + joya1[15:8];
wire [9:0] center_joystick_x1 = 8'd128 + joya1[7:0];
wire [9:0] center_joystick_y2 = 8'd128 + joya2[15:8];
wire [9:0] center_joystick_x2 = 8'd128 + joya2[7:0];
wire [31:0] coco_joy1 = status_q[6] ? joy2 : joy1;
wire [31:0] coco_joy2 = status_q[6] ? joy1 : joy2;
wire [15:0] coco_ajoy1 = status_q[6] ? {center_joystick_x2[7:0],center_joystick_y2[7:0]} : {center_joystick_x1[7:0],center_joystick_y1[7:0]};
wire [15:0] coco_ajoy2 = status_q[6] ? {center_joystick_x1[7:0],center_joystick_y1[7:0]} : {center_joystick_x2[7:0],center_joystick_y2[7:0]};
//////////////////////////////////////////////////////////////////
// Keyboard: ps2_key -> PS/2 serial, the way hps_io produces it
//////////////////////////////////////////////////////////////////
reg clk_ps2 = 1'b0;
reg [11:0] ps2_div = 12'd0;
always @(posedge clk_sys) begin
ps2_div <= ps2_div + 1'd1;
if (ps2_div == 12'd2400) begin // hps_io PS2DIV
clk_ps2 <= ~clk_ps2;
ps2_div <= 12'd0;
end
end
// One ps2_key event becomes [E0] [F0] code. Main_MiSTer hands hps_io the same
// bytes one at a time; here they go into ps2_device's FIFO on consecutive
// clk_sys cycles.
reg old_ps2_stb = 1'b0;
reg [1:0] kbd_seq = 2'd0;
reg kbd_ext, kbd_rel;
reg [7:0] kbd_code;
reg [7:0] kbd_data;
reg kbd_we = 1'b0;
always @(posedge clk_sys) begin
kbd_we <= 1'b0;
old_ps2_stb <= ps2_key[10];
if (kbd_seq == 2'd0 && old_ps2_stb != ps2_key[10]) begin
kbd_ext <= ps2_key[8];
kbd_rel <= ~ps2_key[9];
kbd_code <= ps2_key[7:0];
kbd_seq <= 2'd1;
end
else if (kbd_seq == 2'd1) begin
kbd_seq <= 2'd2;
if (kbd_ext) begin kbd_data <= 8'hE0; kbd_we <= 1'b1; end
end
else if (kbd_seq == 2'd2) begin
kbd_seq <= 2'd3;
if (kbd_rel) begin kbd_data <= 8'hF0; kbd_we <= 1'b1; end
end
else if (kbd_seq == 2'd3) begin
kbd_seq <= 2'd0;
kbd_data <= kbd_code;
kbd_we <= 1'b1;
end
end
wire ps2_kbd_clk;
wire ps2_kbd_data;
ps2_device keyboard
(
.clk_sys(clk_sys),
.wdata(kbd_data),
.we(kbd_we),
.ps2_clk(clk_ps2),
.ps2_clk_out(ps2_kbd_clk),
.ps2_dat_out(ps2_kbd_data),
.tx_empty(),
.ps2_clk_in(1'b1), // PS2WE=0: host never talks back
.ps2_dat_in(1'b1),
.rdata(),
.rd(1'b0)
);
//////////////////////////////////////////////////////////////////
// Core
//////////////////////////////////////////////////////////////////
wire Programmed_RESET_N;
wire Programmed_EE;
EE_Cold_Bt COCO3_EE_Cold_Bt (
.CLK(CLK_14),
.RESET(1'b0),
.Display_EE(easter_egg),
.Cold_Boot(AMW_ACK),
.RESET_to_COCO_N(Programmed_RESET_N),
.EE_to_COCO(Programmed_EE)
);
wire [15:0] audio_left;
wire [15:0] audio_right;
assign AUDIO_L = { audio_left[15:14], audio_left[13] ^ (status_q[17] ? casdout : 1'b0), audio_left[12:0]};
assign AUDIO_R = audio_right;
wire [7:0] r, g, b;
wire hblank, vblank, hs, vs, pix_clk;
wire [31:0] probe;
wire [71:0] Config_Data = {"SIMULATE", 8'h00};
wire [24:0] sdram_cpu_addr;
wire [15:0] sdram_dout;
wire [7:0] sdram_cpu_din;
wire sdram_cpu_req, sdram_cpu_rnw;
wire sdram_cpu_ack, sdram_vid_ack;
wire sdram_cpu_ready;
wire [24:0] sdram_vid_addr;
wire sdram_vid_req;
wire sdram_vid_ready;
wire sdram_busy;
wire [6:0] sd_rd_c, sd_wr_c;
wire [5:0] sd_blk_cnt [7];
assign sd_rd = {9'd0, sd_rd_c};
assign sd_wr = {9'd0, sd_wr_c};
wire clk_Q_out;
wire casdout;
wire cas_relay;
wire UART_TXD, UART_RTS, UART_DTR;
coco3fpga coco3 (
.CLK_50M(CLK_50M),
.CLK_114(CLK_114),
.CLK_57(CLK_57),
.CLK_28(CLK_28),
.CLK_14(CLK_14),
.COCO_RESET_N((~reset & Programmed_RESET_N)),
.RED(r),
.GREEN(g),
.BLUE(b),
.EE_N(Programmed_EE),
.PHASE(PHASE),
.H_SYNC(hs),
.V_SYNC(vs),
.HBLANK(hblank),
.VBLANK(vblank),
.PIX_CLK(pix_clk),
.ps2_clk(ps2_kbd_clk),
.ps2_data(ps2_kbd_data),
.ps2_mouse(ps2_mouse),
.joy_use_dpad(digitalJoy),
.joy1(coco_joy1[15:0]),
.joy2(coco_joy2[15:0]),
.joya1(coco_ajoy1),
.joya2(coco_ajoy2),
.SWAP_M_J(SWAP_M_J),
// R1, L2, R2, L1
.P_SWITCH(~{coco_joy2[4],coco_joy1[5],coco_joy2[5],coco_joy1[4]}),
.SWITCH(switch),
.SOUND_LEFT(audio_left),
.SOUND_RIGHT(audio_right),
.ioctl_addr(ioctl_addr),
.ioctl_data(ioctl_dout),
.ioctl_download(ioctl_download),
.ioctl_index({8'd0, ioctl_index}),
.ioctl_wr(ioctl_wr),
.sdram_sz(16'h8001), // SDRAM present, 32 MB
.img_mounted(img_mounted[6:0]),
.img_readonly(img_readonly),
.img_size(img_size),
.sd_lba(sd_lba),
.sd_blk_cnt(sd_blk_cnt),
.sd_rd(sd_rd_c),
.sd_wr(sd_wr_c),
.sd_ack(sd_ack[6:0]),
.sd_buff_addr(sd_buff_addr),
.sd_buff_dout(sd_buff_dout),
.sd_buff_din(sd_buff_din),
.sd_buff_wr(sd_buff_wr),
.GPIO(),
.PROBE(probe),
.clk_Q_out(clk_Q_out),
.casdout(casdout),
.cas_relay(cas_relay),
.sdram_cpu_addr(sdram_cpu_addr),
.sdram_dout(sdram_dout),
.sdram_cpu_din(sdram_cpu_din),
.sdram_cpu_req(sdram_cpu_req),
.sdram_cpu_rnw(sdram_cpu_rnw),
.sdram_cpu_ack(sdram_cpu_ack),
.sdram_cpu_ready(sdram_cpu_ready),
.sdram_vid_addr(sdram_vid_addr),
.sdram_vid_req(sdram_vid_req),
.sdram_vid_ack(sdram_vid_ack),
.sdram_vid_ready(sdram_vid_ready),
.sdram_busy(sdram_busy),
.turbo_speed(turbo_speed),
.assigned_turbo_speed(assigned_turbo_speed),
.RTC(RTC),
.AMW_Trigger(coldboot | mpi_reset | mem_reset),
.AMW_ACK(AMW_ACK),
.F_Turbo(F_Turbo),
.Mem_Size(Mem_Size),
.AUTO_MODE(Auto_Mode),
.Config_Data(Config_Data),
.UART_TXD(UART_TXD),
.UART_RXD(uart_rxd),
.UART_RTS(UART_RTS),
.UART_CTS(1'b0), // active low: always clear to send
.UART_DTR(UART_DTR),
.UART_DSR(1'b0)
);
sdram_32r8w coco3_sdram
(
.init(reset),
.clk(CLK_114),
.sdram_cpu_addr(sdram_cpu_addr),
.sdram_dout(sdram_dout),
.sdram_cpu_din(sdram_cpu_din),
.sdram_cpu_req(sdram_cpu_req),
.sdram_cpu_rnw(sdram_cpu_rnw),
.sdram_cpu_ack(sdram_cpu_ack),
.sdram_cpu_ready(sdram_cpu_ready),
.sdram_vid_addr(sdram_vid_addr),
.sdram_vid_req(sdram_vid_req),
.sdram_vid_ack(sdram_vid_ack),
.sdram_vid_ready(sdram_vid_ready),
.sdram_busy(sdram_busy)
);
//////////////////////////////////////////////////////////////////
// Cassette -- copied from CoCo3.sv
//////////////////////////////////////////////////////////////////
wire load_tape = ioctl_index == 2;
wire [15:0] ram_addr;
wire [7:0] ram_data_o;
reg ram_wr;
reg [15:0] ram_ad_buf;
always @(posedge clk_sys) begin
ram_wr <= ~(ioctl_wr & load_tape);
if (ioctl_download)
ram_ad_buf <= ioctl_addr[15:0];
else
ram_ad_buf <= ram_addr;
end
COCO_SRAM CC3_CAS1(
.CLK(clk_sys),
.ADDR(ram_ad_buf),
.R_W(ram_wr),
.DATA_I(ioctl_dout),
.DATA_O(ram_data_o)
);
cassette cassette(
.clk(clk_sys),
.Q(clk_Q_out),
.rewind(status_q[15]|~ram_wr),
.en(cas_relay),
.sdram_addr(ram_addr),
.sdram_data(ram_data_o),
.data(casdout)
);
assign ioctl_wait = 1'b0;
//////////////////////////////////////////////////////////////////
// Video out
//////////////////////////////////////////////////////////////////
assign VGA_R = r;
assign VGA_G = g;
assign VGA_B = b;
assign VGA_HS = hs;
assign VGA_VS = vs;
assign VGA_HB = hblank;
assign VGA_VB = vblank;
assign CE_PIXEL = pix_clk;
//////////////////////////////////////////////////////////////////
// Debug taps
//////////////////////////////////////////////////////////////////
assign dbg_pc = coco3.GLBCPU09.pc;
assign dbg_a = coco3.GLBCPU09.a;
assign dbg_b = coco3.GLBCPU09.b;
assign dbg_x = coco3.GLBCPU09.x;
assign dbg_y = coco3.GLBCPU09.y;
assign dbg_u = coco3.GLBCPU09.u;
assign dbg_s = coco3.GLBCPU09.s;
assign dbg_cc = coco3.GLBCPU09.cc;
assign dbg_dp = coco3.GLBCPU09.dp;
assign dbg_lic = coco3.GLBCPU09.LIC;
assign dbg_addr = coco3.ADDRESS;
assign dbg_din = coco3.DATA_IN;
assign dbg_dout = coco3.DATA_OUT;
assign dbg_rw = coco3.RW_N;
assign dbg_ena = coco3.cpu_cycle_ena;
assign dbg_irqn = coco3.CPU_IRQ_N;
assign dbg_firqn = coco3.CPU_FIRQ_N;
assign dbg_reset = coco3.CPU_RESET;
assign dbg_gime_init0 = {coco3.COCO1, coco3.MMU_EN, coco3.GIME_IRQ, coco3.GIME_FIRQ,
coco3.VEC_PAG_RAM, coco3.ST_SCS, coco3.ROM};
assign dbg_speed = assigned_turbo_speed;
assign uart_txd = UART_TXD;
assign uart_rts = UART_RTS;
assign uart_dtr = UART_DTR;
assign dbg_rs232_en = coco3.RS232_EN;
assign dbg_mpi_scs = coco3.MPI_SCS;
assign dbg_mpi_cts = coco3.MPI_CTS;
assign dbg_acia_ctl = coco3.RS232.CTL_REG;
assign dbg_acia_cmd = coco3.RS232.CMD_REG;
//////////////////////////////////////////////////////////////////
// FPGA power-up state
//
// Every register starts at 0 in this sim. Quartus does the same, EXCEPT for a
// register with an asynchronous set: it implements the set with NOT-gate
// push-back, so the register powers up at 1. Where that matters it is
// reproduced here.
//
// mc6809x NMILatched: active low (0 = NMI pending), in an
// `always @(negedge NMISample2 or posedge wNMIClear)` block whose async branch
// sets it. At 0 the CPU takes a phantom NMI on its first instruction -- the
// ORCC at the reset entry -- and vectors through $FFFC into uninitialised RAM.
//////////////////////////////////////////////////////////////////
initial coco3.GLBCPU09.NMILatched = 1'b1;
//////////////////////////////////////////////////////////////////
// +acia_any_slot (--acia-any-slot)
//
// coco3fpga.sv used to decode the RS-232 Pak at $FF68-$FF6B only when the
// Multi-Pak I/O select was slot 1 (MPI_SCS == 0), which the OSD cannot select,
// so a cart in slot 3 driving the 6551 -- HDB-DOS SY6551 for FujiNet -- talked
// to an empty bus. The RTL now decodes it in any slot, which makes this a no-op;
// it is kept for testing RTL from before that fix.
//////////////////////////////////////////////////////////////////
// The right-hand side of a procedural force is taken once, when the
// force executes (Verilator 5.044), so it is re-issued whenever the decode it follows
// changes. The net must also be `forceable` (sim.vlt) or the force is lost.
wire acia_any_slot_en = (coco3.ADDRESS[15:2] == 14'b11111111011010);
reg acia_any_slot = 1'b0;
initial acia_any_slot = $test$plusargs("acia_any_slot");
always @(acia_any_slot_en or acia_any_slot)
if (acia_any_slot) force coco3.RS232_EN = acia_any_slot_en;
endmodule
+4
View File
@@ -0,0 +1,4 @@
`verilator_config
// Nets sim.v overrides with `force` for --acia-any-slot. Without this Verilator
// folds RS232_EN into its users and the force has no effect.
forceable -module "coco3fpga" -var "RS232_EN"
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,70 @@
#pragma once
// uncomment and modify defines under for customize ImGuiFileDialog
//#define MAX_FILE_DIALOG_NAME_BUFFER 1024
//#define MAX_PATH_BUFFER_SIZE 1024
//#define USE_EXPLORATION_BY_KEYS
// this mapping by default is for GLFW but you can use another
//#include <GLFW/glfw3.h>
// Up key for explore to the top
//#define IGFD_KEY_UP GLFW_KEY_UP
// Down key for explore to the bottom
//#define IGFD_KEY_DOWN GLFW_KEY_DOWN
// Enter key for open directory
//#define IGFD_KEY_ENTER GLFW_KEY_ENTER
// BackSpace for comming back to the last directory
//#define IGFD_KEY_BACKSPACE GLFW_KEY_BACKSPACE
// widget
// filter combobox width
//#define FILTER_COMBO_WIDTH 120.0f
// button widget use for compose path
//#define IMGUI_PATH_BUTTON ImGui::Button
// standard button
//#define IMGUI_BUTTON ImGui::Button
// locales string
//#define createDirButtonString "+"
//#define okButtonString " OK"
//#define cancelButtonString " Cancel"
//#define resetButtonString "R"
//#define drivesButtonString "Drives"
//#define searchString "Search"
//#define dirEntryString "[DIR] "
//#define linkEntryString "[LINK] "
//#define fileEntryString "[FILE] "
//#define fileNameString "File Name : "
//#define dirNameString "Directory Path :"
//#define buttonResetSearchString "Reset search"
//#define buttonDriveString "Drives"
//#define buttonResetPathString "Reset to current directory"
//#define buttonCreateDirString "Create Directory"
//#define OverWriteDialogTitleString "The file Already Exist !"
//#define OverWriteDialogMessageString "Would you like to OverWrite it ?"
//#define OverWriteDialogConfirmButtonString "Confirm"
//#define OverWriteDialogCancelButtonString "Cancel"
// DateTimeFormat
// see strftime functionin <ctime> for customize
// "%Y/%m/%d %H:%M" give 2021:01:22 11:47
// "%Y/%m/%d %i:%M%p" give 2021:01:22 11:45PM
//#define DateTimeFormat "%Y/%m/%d %i:%M%p"
// theses icons will appear in table headers
//#define USE_CUSTOM_SORTING_ICON
//#define tableHeaderAscendingIcon "A|"
//#define tableHeaderDescendingIcon "D|"
//#define tableHeaderFileNameString " File name"
//#define tableHeaderFileTypeString " Type"
//#define tableHeaderFileSizeString " Size"
//#define tableHeaderFileDateTimeString " Date"
//#define USE_BOOKMARK
//#define bookmarkPaneWith 150.0f
//#define IMGUI_TOGGLE_BUTTON ToggleButton
//#define bookmarksButtonString "Bookmark"
//#define bookmarksButtonHelpString "Bookmark"
//#define addBookmarkButtonString "+"
//#define removeBookmarkButtonString "-"
+21
View File
@@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2014-2022 Omar Cornut
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+78
View File
@@ -0,0 +1,78 @@
#
# Cross Platform Makefile
# Compatible with MSYS2/MINGW, Ubuntu 14.04.1 and Mac OS X
#
# You will need SDL2 (http://www.libsdl.org):
# Linux:
# apt-get install libsdl2-dev
# Mac OS X:
# brew install sdl2
# MSYS2:
# pacman -S mingw-w64-i686-SDL
#
#CXX = g++
#CXX = clang++
EXE = example_sdl_opengl2
SOURCES = main.cpp
SOURCES += ../imgui_impl_sdl.cpp ../imgui_impl_opengl2.cpp
SOURCES += ../../imgui.cpp ../../imgui_demo.cpp ../../imgui_draw.cpp ../../imgui_widgets.cpp
OBJS = $(addsuffix .o, $(basename $(notdir $(SOURCES))))
UNAME_S := $(shell uname -s)
CXXFLAGS = -I../ -I../../
CXXFLAGS += -g -Wall -Wformat
LIBS =
##---------------------------------------------------------------------
## BUILD FLAGS PER PLATFORM
##---------------------------------------------------------------------
ifeq ($(UNAME_S), Linux) #LINUX
ECHO_MESSAGE = "Linux"
LIBS += -lGL -ldl `sdl2-config --libs`
CXXFLAGS += `sdl2-config --cflags`
CFLAGS = $(CXXFLAGS)
endif
ifeq ($(UNAME_S), Darwin) #APPLE
ECHO_MESSAGE = "Mac OS X"
LIBS += -framework OpenGL -framework Cocoa -framework IOKit -framework CoreVideo `sdl2-config --libs`
LIBS += -L/usr/local/lib -L/opt/local/lib
CXXFLAGS += `sdl2-config --cflags`
CXXFLAGS += -I/usr/local/include -I/opt/local/include
CFLAGS = $(CXXFLAGS)
endif
ifeq ($(findstring MINGW,$(UNAME_S)),MINGW)
ECHO_MESSAGE = "MinGW"
LIBS += -lgdi32 -lopengl32 -limm32 `pkg-config --static --libs sdl2`
CXXFLAGS += `pkg-config --cflags sdl2`
CFLAGS = $(CXXFLAGS)
endif
##---------------------------------------------------------------------
## BUILD RULES
##---------------------------------------------------------------------
%.o:%.cpp
$(CXX) $(CXXFLAGS) -c -o $@ $<
%.o:../%.cpp
$(CXX) $(CXXFLAGS) -c -o $@ $<
%.o:../../%.cpp
$(CXX) $(CXXFLAGS) -c -o $@ $<
all: $(EXE)
@echo Build complete for $(ECHO_MESSAGE)
$(EXE): $(OBJS)
$(CXX) -o $@ $^ $(CXXFLAGS) $(LIBS)
clean:
rm -f $(EXE) $(OBJS)
+129
View File
@@ -0,0 +1,129 @@
2018-05-08 Toni Rönkkö
* Version 1.23.2: fixes bad scandir prototype.
2017-08-27 Toni Rönkkö
* Version 1.23: support readdir_r and scandir functions.
2017-07-18 Toni Rönkkö
* Created release branches v1.22 and v1.21 to Git. Published version
1.22 at softagalleria.net.
2016-09-11 Toni Rönkkö
* Version 1.22: added support for CMake. Thanks to Paul Fultz II.
2014-09-25 Toni Rönkkö
* Version 1.21: compiles correctly under Open Watcom. Thanks to
Virgil Banowetz for a patch!
2014-04-07 Toni Rönkkö
* Version 1.20.1: the zip file from the previous version did not open
correctly with Microsoft's compressed folders. Thanks to Alexandre
for info!
2014-03-17 Toni Ronkko
* Version 1.20: dirent.h compiles correctly in 64-bit architecture.
Thanks to Aaron Simmons!
2014-03-03 Toni Ronkko
* Version 1.13.2: define DT_LNK for compatibility with Unix
programs. Thanks to Joel Bruick for suggestion!
2013-01-27 Toni Ronkko
* Version 1.13.1: patch from Edward Berner fixes set_errno() on
Windows NT 4.0.
* Revised wcstombs() and mbstowcs() wrappers to make sure that they do
not write past their target string.
* PATH_MAX from windows.h includes zero terminator so there is no
need to add one extra byte to variables and structures.
2012-12-12 Toni Ronkko
* Version 1.13: use the traditional 8+3 file naming scheme if a file
name cannot be represented in the default ANSI code page. Now
compiles again with MSVC 6.0. Thanks to Konstantin Khomoutov for
testing.
2012-10-01 Toni Ronkko
* Version 1.12.1: renamed wide-character DIR structure _wDIR to
_WDIR (with capital W) in order to maintain compatibility with MingW.
2012-09-30 Toni Ronkko
* Version 1.12: define PATH_MAX and NAME_MAX. Added wide-character
variants _wDIR, _wdirent, _wopendir(), _wreaddir(), _wclosedir() and
_wrewinddir(). Thanks to Edgar Buerkle and Jan Nijtmans for ideas
and code.
* Now avoiding windows.h. This allows dirent.h to be integrated
more easily into programs using winsock. Thanks to Fernando
Azaldegui.
2011-03-15 Toni Ronkko
* Version 1.11: defined FILE_ATTRIBUTE_DEVICE for MSVC 6.0.
2010-08-11 Toni Ronkko
* Version 1.10: added d_type and d_namlen fields to dirent structure.
The former is especially useful for determining whether directory
entry represents a file or a directory. For more information, see
http://www.delorie.com/gnu/docs/glibc/libc_270.html
* Improved conformance to the standards. For example, errno is now
set properly on failure and assert() is never used. Thanks to Peter
Brockam for suggestions.
* Fixed a bug in rewinddir(): when using relative directory names,
change of working directory no longer causes rewinddir() to fail.
2009-12-15 John Cunningham
* Version 1.9: added rewinddir member function
2008-01-18 Toni Ronkko
* Version 1.8: Using FindFirstFileA and WIN32_FIND_DATAA to avoid
converting string between multi-byte and unicode representations.
This makes the code simpler and also allows the code to be compiled
under MingW. Thanks to Azriel Fasten for the suggestion.
2007-03-04 Toni Ronkko
* Bug fix: due to the strncpy_s() function this file only compiled in
Visual Studio 2005. Using the new string functions only when the
compiler version allows.
2006-11-02 Toni Ronkko
* Major update: removed support for Watcom C, MS-DOS and Turbo C to
simplify the file, updated the code to compile cleanly on Visual
Studio 2005 with both unicode and multi-byte character strings,
removed rewinddir() as it had a bug.
2006-08-20 Toni Ronkko
* Removed all remarks about MSVC 1.0, which is antiqued now.
Simplified comments by removing SGML tags.
2002-05-14 Toni Ronkko
* Embedded the function definitions directly to the header so that no
source modules need to be included in the Visual Studio project.
Removed all the dependencies to other projects so that this header
file can be used independently.
1998-05-28 Toni Ronkko
* First version.
+21
View File
@@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 1998-2019 Toni Ronkko
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+96
View File
@@ -0,0 +1,96 @@
# Dirent
Dirent is a C/C++ programming interface that allows programmers to retrieve
information about files and directories under Linux/UNIX. This project
provides Linux compatible Dirent interface for Microsoft Windows.
# Installation
Download the latest Dirent installation package from
[GitHub](https://github.com/tronkko/dirent/releases) and
unpack the installation file with 7-zip, for example. The installation
package contains dirent.h file as well as a few example programs and
tests.
## Install Dirent for All Programs
To make dirent.h available for all C/C++ programs, simply copy the
``include/dirent.h`` file to the system include directory. System include
directory contains header files such as assert.h and windows.h. In Visual
Studio 2008, for example, the system include may be found at
``C:\Program Files\Microsoft Visual Studio 9.0\VC\include``.
Everything you need is included in the single dirent.h file, and you can
start using Dirent immediately -- there is no need to add files to your
Visual Studio project.
## Embed Dirent into Your Own Project
If you wish to distribute dirent.h alongside with your own source code, then
copy ``include/dirent.h`` file to a new sub-directory within your project and
add that directory to include path on Windows while omitting the directory
under Linux/UNIX. This allows your project to be compiled against native
dirent.h on Linux/UNIX while substituting the functionality on Microsoft
Windows.
## Examples
The installation package contains four example programs:
Program | Purpose
-------- | -----------------------------------------------------------------
ls | List files in a directory, e.g. ls "c:\Program Files"
find | Find files in subdirectories, e.g. find "c:\Program Files\CMake"
updatedb | Build database of files in a drive, e.g. updatedb c:\
locate | Locate a file from database, e.g. locate notepad.exe
To build the example programs, first install [CMake](https://cmake.org/).
Then, with CMake installed, open command prompt and create a temporary
directory ``c:\temp\dirent`` for the build files as
```
c:\
mkdir temp
mkdir temp\dirent
cd temp\dirent
```
Generate build files as
```
cmake d:\dirent
```
where ``d:\dirent`` is the root directory of the Dirent package (containing
this README.md and LICENSE file).
Once CMake is finished, open Visual Studio, load the generated dirent.sln file
from the build directory and build the solution. Once the build completes, run
the example programs from the command prompt as
```
cd Debug
ls .
find .
updatedb c:\
locate cmd.exe
```
# Copying
Dirent may be freely distributed under the MIT license. See the
[LICENSE](LICENSE) file for details.
# Alternatives to Dirent
I ported Dirent to Microsoft Windows in 1998 when only a few alternatives
were available. However, the situation has changed since then and nowadays
both [Cygwin](http://www.cygwin.com) and [MingW](http://www.mingw.org)
allow you to compile a great number of UNIX programs in Microsoft Windows.
They both provide a full dirent API as well as many other UNIX APIs. MingW
can even be used for commercial applications!
File diff suppressed because it is too large. Load diff
+124
View File
@@ -0,0 +1,124 @@
//-----------------------------------------------------------------------------
// COMPILE-TIME OPTIONS FOR DEAR IMGUI
// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
//-----------------------------------------------------------------------------
// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your modifications to it)
// B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own file without touching this template.
//-----------------------------------------------------------------------------
// You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the imgui*.cpp
// files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
// Call IMGUI_CHECKVERSION() from your .cpp files to verify that the data structures your files are using are matching the ones imgui.cpp is using.
//-----------------------------------------------------------------------------
#pragma once
//---- Define assertion handler. Defaults to calling assert().
// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
//#define IM_ASSERT(_EXPR) MyAssert(_EXPR)
//#define IM_ASSERT(_EXPR) ((void)(_EXPR)) // Disable asserts
//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
// DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
// for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
//#define IMGUI_API __declspec( dllexport )
//#define IMGUI_API __declspec( dllimport )
//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to avoid using soon-to-be obsolete function/names.
//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
//#define IMGUI_DISABLE_OBSOLETE_KEYIO // 1.87: disable legacy io.KeyMap[]+io.KeysDown[] in favor io.AddKeyEvent(). This will be folded into IMGUI_DISABLE_OBSOLETE_FUNCTIONS in a few versions.
//---- Disable all of Dear ImGui or don't implement standard windows.
// It is very strongly recommended to NOT disable the demo windows during development. Please read comments in imgui_demo.cpp.
//#define IMGUI_DISABLE // Disable everything: all headers and source files will be empty.
//#define IMGUI_DISABLE_DEMO_WINDOWS // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty. Not recommended.
//#define IMGUI_DISABLE_METRICS_WINDOW // Disable metrics/debugger and other debug tools: ShowMetricsWindow() and ShowStackToolWindow() will be empty.
//---- Don't implement some functions to reduce linkage requirements.
//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
//#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
//#define IMGUI_DISABLE_WIN32_FUNCTIONS // [Win32] Won't use and link with any Win32 function (clipboard, ime).
//#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
//#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
//#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
//#define IMGUI_DISABLE_FILE_FUNCTIONS // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
//#define IMGUI_DISABLE_SSE // Disable use of SSE intrinsics even if available
//---- Include imgui_user.h at the end of imgui.h as a convenience
//#define IMGUI_INCLUDE_IMGUI_USER_H
//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
//#define IMGUI_USE_BGRA_PACKED_COLOR
//---- Use 32-bit for ImWchar (default is 16-bit) to support unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
//#define IMGUI_USE_WCHAR32
//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
//#define IMGUI_STB_TRUETYPE_FILENAME "my_folder/stb_truetype.h"
//#define IMGUI_STB_RECT_PACK_FILENAME "my_folder/stb_rect_pack.h"
//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
//---- Use stb_printf's faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
// Requires 'stb_sprintf.h' to be available in the include path. Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by STB sprintf.
// #define IMGUI_USE_STB_SPRINTF
//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
// Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
// On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
//#define IMGUI_ENABLE_FREETYPE
//---- Use stb_truetype to build and rasterize the font atlas (default)
// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
//#define IMGUI_ENABLE_STB_TRUETYPE
//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
// This will be inlined as part of ImVec2 and ImVec4 class declarations.
/*
#define IM_VEC2_CLASS_EXTRA \
ImVec2(const MyVec2& f) { x = f.x; y = f.y; } \
operator MyVec2() const { return MyVec2(x,y); }
#define IM_VEC4_CLASS_EXTRA \
ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; } \
operator MyVec4() const { return MyVec4(x,y,z,w); }
*/
//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
// Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
//#define ImDrawIdx unsigned int
//---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
//struct ImDrawList;
//struct ImDrawCmd;
//typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
//#define ImDrawCallback MyImDrawCallback
//---- Debug Tools: Macro to break in Debugger
// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
//#define IM_DEBUG_BREAK IM_ASSERT(0)
//#define IM_DEBUG_BREAK __debugbreak()
//---- Debug Tools: Have the Item Picker break in the ItemAdd() function instead of ItemHoverable(),
// (which comes earlier in the code, will catch a few extra items, allow picking items other than Hovered one.)
// This adds a small runtime cost which is why it is not enabled by default.
//#define IMGUI_DEBUG_TOOL_ITEM_PICKER_EX
//---- Debug Tools: Enable slower asserts
//#define IMGUI_DEBUG_PARANOID
//---- Tip: You can add extra functions within the ImGui:: namespace, here or in your own headers files.
/*
namespace ImGui
{
void MyFunction(const char* name, const MyMatrix44& v);
}
*/
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+594
View File
@@ -0,0 +1,594 @@
// dear imgui: Renderer Backend for DirectX11
// This needs to be used along with a Platform Backend (e.g. Win32)
// Implemented features:
// [X] Renderer: User texture binding. Use 'ID3D11ShaderResourceView*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Support for large meshes (64k+ vertices) with 16-bit indices.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
// 2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
// 2021-05-19: DirectX11: Replaced direct access to ImDrawCmd::TextureId with a call to ImDrawCmd::GetTexID(). (will become a requirement)
// 2021-02-18: DirectX11: Change blending equation to preserve alpha in output buffer.
// 2019-08-01: DirectX11: Fixed code querying the Geometry Shader state (would generally error with Debug layer enabled).
// 2019-07-21: DirectX11: Backup, clear and restore Geometry Shader is any is bound when calling ImGui_ImplDX10_RenderDrawData. Clearing Hull/Domain/Compute shaders without backup/restore.
// 2019-05-29: DirectX11: Added support for large mesh (64K+ vertices), enable ImGuiBackendFlags_RendererHasVtxOffset flag.
// 2019-04-30: DirectX11: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
// 2018-12-03: Misc: Added #pragma comment statement to automatically link with d3dcompiler.lib when using D3DCompile().
// 2018-11-30: Misc: Setting up io.BackendRendererName so it can be displayed in the About Window.
// 2018-08-01: DirectX11: Querying for IDXGIFactory instead of IDXGIFactory1 to increase compatibility.
// 2018-07-13: DirectX11: Fixed unreleased resources in Init and Shutdown functions.
// 2018-06-08: Misc: Extracted imgui_impl_dx11.cpp/.h away from the old combined DX11+Win32 example.
// 2018-06-08: DirectX11: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle.
// 2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplDX11_RenderDrawData() in the .h file so you can call it yourself.
// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
// 2016-05-07: DirectX11: Disabling depth-write.
#include "imgui.h"
#include "imgui_impl_dx11.h"
// DirectX
#include <stdio.h>
#include <d3d11.h>
#include <d3dcompiler.h>
#ifdef _MSC_VER
#pragma comment(lib, "d3dcompiler") // Automatically link with d3dcompiler.lib as we are using D3DCompile() below.
#endif
// DirectX11 data
struct ImGui_ImplDX11_Data
{
ID3D11Device* pd3dDevice;
ID3D11DeviceContext* pd3dDeviceContext;
IDXGIFactory* pFactory;
ID3D11Buffer* pVB;
ID3D11Buffer* pIB;
ID3D11VertexShader* pVertexShader;
ID3D11InputLayout* pInputLayout;
ID3D11Buffer* pVertexConstantBuffer;
ID3D11PixelShader* pPixelShader;
ID3D11SamplerState* pFontSampler;
ID3D11ShaderResourceView* pFontTextureView;
ID3D11RasterizerState* pRasterizerState;
ID3D11BlendState* pBlendState;
ID3D11DepthStencilState* pDepthStencilState;
int VertexBufferSize;
int IndexBufferSize;
ImGui_ImplDX11_Data() { memset(this, 0, sizeof(*this)); VertexBufferSize = 5000; IndexBufferSize = 10000; }
};
struct VERTEX_CONSTANT_BUFFER
{
float mvp[4][4];
};
// Backend data stored in io.BackendRendererUserData to allow support for multiple Dear ImGui contexts
// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
static ImGui_ImplDX11_Data* ImGui_ImplDX11_GetBackendData()
{
return ImGui::GetCurrentContext() ? (ImGui_ImplDX11_Data*)ImGui::GetIO().BackendRendererUserData : NULL;
}
// Functions
static void ImGui_ImplDX11_SetupRenderState(ImDrawData* draw_data, ID3D11DeviceContext* ctx)
{
ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
// Setup viewport
D3D11_VIEWPORT vp;
memset(&vp, 0, sizeof(D3D11_VIEWPORT));
vp.Width = draw_data->DisplaySize.x;
vp.Height = draw_data->DisplaySize.y;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = vp.TopLeftY = 0;
ctx->RSSetViewports(1, &vp);
// Setup shader and vertex buffers
unsigned int stride = sizeof(ImDrawVert);
unsigned int offset = 0;
ctx->IASetInputLayout(bd->pInputLayout);
ctx->IASetVertexBuffers(0, 1, &bd->pVB, &stride, &offset);
ctx->IASetIndexBuffer(bd->pIB, sizeof(ImDrawIdx) == 2 ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT, 0);
ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ctx->VSSetShader(bd->pVertexShader, NULL, 0);
ctx->VSSetConstantBuffers(0, 1, &bd->pVertexConstantBuffer);
ctx->PSSetShader(bd->pPixelShader, NULL, 0);
ctx->PSSetSamplers(0, 1, &bd->pFontSampler);
ctx->GSSetShader(NULL, NULL, 0);
ctx->HSSetShader(NULL, NULL, 0); // In theory we should backup and restore this as well.. very infrequently used..
ctx->DSSetShader(NULL, NULL, 0); // In theory we should backup and restore this as well.. very infrequently used..
ctx->CSSetShader(NULL, NULL, 0); // In theory we should backup and restore this as well.. very infrequently used..
// Setup blend state
const float blend_factor[4] = { 0.f, 0.f, 0.f, 0.f };
ctx->OMSetBlendState(bd->pBlendState, blend_factor, 0xffffffff);
ctx->OMSetDepthStencilState(bd->pDepthStencilState, 0);
ctx->RSSetState(bd->pRasterizerState);
}
// Render function
void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
{
// Avoid rendering when minimized
if (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f)
return;
ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
ID3D11DeviceContext* ctx = bd->pd3dDeviceContext;
// Create and grow vertex/index buffers if needed
if (!bd->pVB || bd->VertexBufferSize < draw_data->TotalVtxCount)
{
if (bd->pVB) { bd->pVB->Release(); bd->pVB = NULL; }
bd->VertexBufferSize = draw_data->TotalVtxCount + 5000;
D3D11_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.ByteWidth = bd->VertexBufferSize * sizeof(ImDrawVert);
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
if (bd->pd3dDevice->CreateBuffer(&desc, NULL, &bd->pVB) < 0)
return;
}
if (!bd->pIB || bd->IndexBufferSize < draw_data->TotalIdxCount)
{
if (bd->pIB) { bd->pIB->Release(); bd->pIB = NULL; }
bd->IndexBufferSize = draw_data->TotalIdxCount + 10000;
D3D11_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.ByteWidth = bd->IndexBufferSize * sizeof(ImDrawIdx);
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
if (bd->pd3dDevice->CreateBuffer(&desc, NULL, &bd->pIB) < 0)
return;
}
// Upload vertex/index data into a single contiguous GPU buffer
D3D11_MAPPED_SUBRESOURCE vtx_resource, idx_resource;
if (ctx->Map(bd->pVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &vtx_resource) != S_OK)
return;
if (ctx->Map(bd->pIB, 0, D3D11_MAP_WRITE_DISCARD, 0, &idx_resource) != S_OK)
return;
ImDrawVert* vtx_dst = (ImDrawVert*)vtx_resource.pData;
ImDrawIdx* idx_dst = (ImDrawIdx*)idx_resource.pData;
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
memcpy(vtx_dst, cmd_list->VtxBuffer.Data, cmd_list->VtxBuffer.Size * sizeof(ImDrawVert));
memcpy(idx_dst, cmd_list->IdxBuffer.Data, cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx));
vtx_dst += cmd_list->VtxBuffer.Size;
idx_dst += cmd_list->IdxBuffer.Size;
}
ctx->Unmap(bd->pVB, 0);
ctx->Unmap(bd->pIB, 0);
// Setup orthographic projection matrix into our constant buffer
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
{
D3D11_MAPPED_SUBRESOURCE mapped_resource;
if (ctx->Map(bd->pVertexConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_resource) != S_OK)
return;
VERTEX_CONSTANT_BUFFER* constant_buffer = (VERTEX_CONSTANT_BUFFER*)mapped_resource.pData;
float L = draw_data->DisplayPos.x;
float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
float T = draw_data->DisplayPos.y;
float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
float mvp[4][4] =
{
{ 2.0f/(R-L), 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/(T-B), 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.5f, 0.0f },
{ (R+L)/(L-R), (T+B)/(B-T), 0.5f, 1.0f },
};
memcpy(&constant_buffer->mvp, mvp, sizeof(mvp));
ctx->Unmap(bd->pVertexConstantBuffer, 0);
}
// Backup DX state that will be modified to restore it afterwards (unfortunately this is very ugly looking and verbose. Close your eyes!)
struct BACKUP_DX11_STATE
{
UINT ScissorRectsCount, ViewportsCount;
D3D11_RECT ScissorRects[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
D3D11_VIEWPORT Viewports[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
ID3D11RasterizerState* RS;
ID3D11BlendState* BlendState;
FLOAT BlendFactor[4];
UINT SampleMask;
UINT StencilRef;
ID3D11DepthStencilState* DepthStencilState;
ID3D11ShaderResourceView* PSShaderResource;
ID3D11SamplerState* PSSampler;
ID3D11PixelShader* PS;
ID3D11VertexShader* VS;
ID3D11GeometryShader* GS;
UINT PSInstancesCount, VSInstancesCount, GSInstancesCount;
ID3D11ClassInstance *PSInstances[256], *VSInstances[256], *GSInstances[256]; // 256 is max according to PSSetShader documentation
D3D11_PRIMITIVE_TOPOLOGY PrimitiveTopology;
ID3D11Buffer* IndexBuffer, *VertexBuffer, *VSConstantBuffer;
UINT IndexBufferOffset, VertexBufferStride, VertexBufferOffset;
DXGI_FORMAT IndexBufferFormat;
ID3D11InputLayout* InputLayout;
};
BACKUP_DX11_STATE old = {};
old.ScissorRectsCount = old.ViewportsCount = D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
ctx->RSGetScissorRects(&old.ScissorRectsCount, old.ScissorRects);
ctx->RSGetViewports(&old.ViewportsCount, old.Viewports);
ctx->RSGetState(&old.RS);
ctx->OMGetBlendState(&old.BlendState, old.BlendFactor, &old.SampleMask);
ctx->OMGetDepthStencilState(&old.DepthStencilState, &old.StencilRef);
ctx->PSGetShaderResources(0, 1, &old.PSShaderResource);
ctx->PSGetSamplers(0, 1, &old.PSSampler);
old.PSInstancesCount = old.VSInstancesCount = old.GSInstancesCount = 256;
ctx->PSGetShader(&old.PS, old.PSInstances, &old.PSInstancesCount);
ctx->VSGetShader(&old.VS, old.VSInstances, &old.VSInstancesCount);
ctx->VSGetConstantBuffers(0, 1, &old.VSConstantBuffer);
ctx->GSGetShader(&old.GS, old.GSInstances, &old.GSInstancesCount);
ctx->IAGetPrimitiveTopology(&old.PrimitiveTopology);
ctx->IAGetIndexBuffer(&old.IndexBuffer, &old.IndexBufferFormat, &old.IndexBufferOffset);
ctx->IAGetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset);
ctx->IAGetInputLayout(&old.InputLayout);
// Setup desired DX state
ImGui_ImplDX11_SetupRenderState(draw_data, ctx);
// Render command lists
// (Because we merged all buffers into a single one, we maintain our own offset into them)
int global_idx_offset = 0;
int global_vtx_offset = 0;
ImVec2 clip_off = draw_data->DisplayPos;
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
if (pcmd->UserCallback != NULL)
{
// User callback, registered via ImDrawList::AddCallback()
// (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
ImGui_ImplDX11_SetupRenderState(draw_data, ctx);
else
pcmd->UserCallback(cmd_list, pcmd);
}
else
{
// Project scissor/clipping rectangles into framebuffer space
ImVec2 clip_min(pcmd->ClipRect.x - clip_off.x, pcmd->ClipRect.y - clip_off.y);
ImVec2 clip_max(pcmd->ClipRect.z - clip_off.x, pcmd->ClipRect.w - clip_off.y);
if (clip_max.x <= clip_min.x || clip_max.y <= clip_min.y)
continue;
// Apply scissor/clipping rectangle
const D3D11_RECT r = { (LONG)clip_min.x, (LONG)clip_min.y, (LONG)clip_max.x, (LONG)clip_max.y };
ctx->RSSetScissorRects(1, &r);
// Bind texture, Draw
ID3D11ShaderResourceView* texture_srv = (ID3D11ShaderResourceView*)pcmd->GetTexID();
ctx->PSSetShaderResources(0, 1, &texture_srv);
ctx->DrawIndexed(pcmd->ElemCount, pcmd->IdxOffset + global_idx_offset, pcmd->VtxOffset + global_vtx_offset);
}
}
global_idx_offset += cmd_list->IdxBuffer.Size;
global_vtx_offset += cmd_list->VtxBuffer.Size;
}
// Restore modified DX state
ctx->RSSetScissorRects(old.ScissorRectsCount, old.ScissorRects);
ctx->RSSetViewports(old.ViewportsCount, old.Viewports);
ctx->RSSetState(old.RS); if (old.RS) old.RS->Release();
ctx->OMSetBlendState(old.BlendState, old.BlendFactor, old.SampleMask); if (old.BlendState) old.BlendState->Release();
ctx->OMSetDepthStencilState(old.DepthStencilState, old.StencilRef); if (old.DepthStencilState) old.DepthStencilState->Release();
ctx->PSSetShaderResources(0, 1, &old.PSShaderResource); if (old.PSShaderResource) old.PSShaderResource->Release();
ctx->PSSetSamplers(0, 1, &old.PSSampler); if (old.PSSampler) old.PSSampler->Release();
ctx->PSSetShader(old.PS, old.PSInstances, old.PSInstancesCount); if (old.PS) old.PS->Release();
for (UINT i = 0; i < old.PSInstancesCount; i++) if (old.PSInstances[i]) old.PSInstances[i]->Release();
ctx->VSSetShader(old.VS, old.VSInstances, old.VSInstancesCount); if (old.VS) old.VS->Release();
ctx->VSSetConstantBuffers(0, 1, &old.VSConstantBuffer); if (old.VSConstantBuffer) old.VSConstantBuffer->Release();
ctx->GSSetShader(old.GS, old.GSInstances, old.GSInstancesCount); if (old.GS) old.GS->Release();
for (UINT i = 0; i < old.VSInstancesCount; i++) if (old.VSInstances[i]) old.VSInstances[i]->Release();
ctx->IASetPrimitiveTopology(old.PrimitiveTopology);
ctx->IASetIndexBuffer(old.IndexBuffer, old.IndexBufferFormat, old.IndexBufferOffset); if (old.IndexBuffer) old.IndexBuffer->Release();
ctx->IASetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset); if (old.VertexBuffer) old.VertexBuffer->Release();
ctx->IASetInputLayout(old.InputLayout); if (old.InputLayout) old.InputLayout->Release();
}
static void ImGui_ImplDX11_CreateFontsTexture()
{
// Build texture atlas
ImGuiIO& io = ImGui::GetIO();
ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
unsigned char* pixels;
int width, height;
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
// Upload texture to graphics system
{
D3D11_TEXTURE2D_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Width = width;
desc.Height = height;
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = 0;
ID3D11Texture2D* pTexture = NULL;
D3D11_SUBRESOURCE_DATA subResource;
subResource.pSysMem = pixels;
subResource.SysMemPitch = desc.Width * 4;
subResource.SysMemSlicePitch = 0;
bd->pd3dDevice->CreateTexture2D(&desc, &subResource, &pTexture);
IM_ASSERT(pTexture != NULL);
// Create texture view
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
ZeroMemory(&srvDesc, sizeof(srvDesc));
srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = desc.MipLevels;
srvDesc.Texture2D.MostDetailedMip = 0;
bd->pd3dDevice->CreateShaderResourceView(pTexture, &srvDesc, &bd->pFontTextureView);
pTexture->Release();
}
// Store our identifier
io.Fonts->SetTexID((ImTextureID)bd->pFontTextureView);
// Create texture sampler
{
D3D11_SAMPLER_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
desc.MipLODBias = 0.f;
desc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
desc.MinLOD = 0.f;
desc.MaxLOD = 0.f;
bd->pd3dDevice->CreateSamplerState(&desc, &bd->pFontSampler);
}
}
bool ImGui_ImplDX11_CreateDeviceObjects()
{
ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
if (!bd->pd3dDevice)
return false;
if (bd->pFontSampler)
ImGui_ImplDX11_InvalidateDeviceObjects();
// By using D3DCompile() from <d3dcompiler.h> / d3dcompiler.lib, we introduce a dependency to a given version of d3dcompiler_XX.dll (see D3DCOMPILER_DLL_A)
// If you would like to use this DX11 sample code but remove this dependency you can:
// 1) compile once, save the compiled shader blobs into a file or source code and pass them to CreateVertexShader()/CreatePixelShader() [preferred solution]
// 2) use code to detect any version of the DLL and grab a pointer to D3DCompile from the DLL.
// See https://github.com/ocornut/imgui/pull/638 for sources and details.
// Create the vertex shader
{
static const char* vertexShader =
"cbuffer vertexBuffer : register(b0) \
{\
float4x4 ProjectionMatrix; \
};\
struct VS_INPUT\
{\
float2 pos : POSITION;\
float4 col : COLOR0;\
float2 uv : TEXCOORD0;\
};\
\
struct PS_INPUT\
{\
float4 pos : SV_POSITION;\
float4 col : COLOR0;\
float2 uv : TEXCOORD0;\
};\
\
PS_INPUT main(VS_INPUT input)\
{\
PS_INPUT output;\
output.pos = mul( ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f));\
output.col = input.col;\
output.uv = input.uv;\
return output;\
}";
ID3DBlob* vertexShaderBlob;
if (FAILED(D3DCompile(vertexShader, strlen(vertexShader), NULL, NULL, NULL, "main", "vs_4_0", 0, 0, &vertexShaderBlob, NULL)))
return false; // NB: Pass ID3DBlob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
if (bd->pd3dDevice->CreateVertexShader(vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(), NULL, &bd->pVertexShader) != S_OK)
{
vertexShaderBlob->Release();
return false;
}
// Create the input layout
D3D11_INPUT_ELEMENT_DESC local_layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (UINT)IM_OFFSETOF(ImDrawVert, pos), D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (UINT)IM_OFFSETOF(ImDrawVert, uv), D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, (UINT)IM_OFFSETOF(ImDrawVert, col), D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
if (bd->pd3dDevice->CreateInputLayout(local_layout, 3, vertexShaderBlob->GetBufferPointer(), vertexShaderBlob->GetBufferSize(), &bd->pInputLayout) != S_OK)
{
vertexShaderBlob->Release();
return false;
}
vertexShaderBlob->Release();
// Create the constant buffer
{
D3D11_BUFFER_DESC desc;
desc.ByteWidth = sizeof(VERTEX_CONSTANT_BUFFER);
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
bd->pd3dDevice->CreateBuffer(&desc, NULL, &bd->pVertexConstantBuffer);
}
}
// Create the pixel shader
{
static const char* pixelShader =
"struct PS_INPUT\
{\
float4 pos : SV_POSITION;\
float4 col : COLOR0;\
float2 uv : TEXCOORD0;\
};\
sampler sampler0;\
Texture2D texture0;\
\
float4 main(PS_INPUT input) : SV_Target\
{\
float4 out_col = input.col * texture0.Sample(sampler0, input.uv); \
return out_col; \
}";
ID3DBlob* pixelShaderBlob;
if (FAILED(D3DCompile(pixelShader, strlen(pixelShader), NULL, NULL, NULL, "main", "ps_4_0", 0, 0, &pixelShaderBlob, NULL)))
return false; // NB: Pass ID3DBlob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
if (bd->pd3dDevice->CreatePixelShader(pixelShaderBlob->GetBufferPointer(), pixelShaderBlob->GetBufferSize(), NULL, &bd->pPixelShader) != S_OK)
{
pixelShaderBlob->Release();
return false;
}
pixelShaderBlob->Release();
}
// Create the blending setup
{
D3D11_BLEND_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.AlphaToCoverageEnable = false;
desc.RenderTarget[0].BlendEnable = true;
desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
bd->pd3dDevice->CreateBlendState(&desc, &bd->pBlendState);
}
// Create the rasterizer state
{
D3D11_RASTERIZER_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.FillMode = D3D11_FILL_SOLID;
desc.CullMode = D3D11_CULL_NONE;
desc.ScissorEnable = true;
desc.DepthClipEnable = true;
bd->pd3dDevice->CreateRasterizerState(&desc, &bd->pRasterizerState);
}
// Create depth-stencil State
{
D3D11_DEPTH_STENCIL_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.DepthEnable = false;
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
desc.DepthFunc = D3D11_COMPARISON_ALWAYS;
desc.StencilEnable = false;
desc.FrontFace.StencilFailOp = desc.FrontFace.StencilDepthFailOp = desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
desc.BackFace = desc.FrontFace;
bd->pd3dDevice->CreateDepthStencilState(&desc, &bd->pDepthStencilState);
}
ImGui_ImplDX11_CreateFontsTexture();
return true;
}
void ImGui_ImplDX11_InvalidateDeviceObjects()
{
ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
if (!bd->pd3dDevice)
return;
if (bd->pFontSampler) { bd->pFontSampler->Release(); bd->pFontSampler = NULL; }
if (bd->pFontTextureView) { bd->pFontTextureView->Release(); bd->pFontTextureView = NULL; ImGui::GetIO().Fonts->SetTexID(NULL); } // We copied data->pFontTextureView to io.Fonts->TexID so let's clear that as well.
if (bd->pIB) { bd->pIB->Release(); bd->pIB = NULL; }
if (bd->pVB) { bd->pVB->Release(); bd->pVB = NULL; }
if (bd->pBlendState) { bd->pBlendState->Release(); bd->pBlendState = NULL; }
if (bd->pDepthStencilState) { bd->pDepthStencilState->Release(); bd->pDepthStencilState = NULL; }
if (bd->pRasterizerState) { bd->pRasterizerState->Release(); bd->pRasterizerState = NULL; }
if (bd->pPixelShader) { bd->pPixelShader->Release(); bd->pPixelShader = NULL; }
if (bd->pVertexConstantBuffer) { bd->pVertexConstantBuffer->Release(); bd->pVertexConstantBuffer = NULL; }
if (bd->pInputLayout) { bd->pInputLayout->Release(); bd->pInputLayout = NULL; }
if (bd->pVertexShader) { bd->pVertexShader->Release(); bd->pVertexShader = NULL; }
}
bool ImGui_ImplDX11_Init(ID3D11Device* device, ID3D11DeviceContext* device_context)
{
ImGuiIO& io = ImGui::GetIO();
IM_ASSERT(io.BackendRendererUserData == NULL && "Already initialized a renderer backend!");
// Setup backend capabilities flags
ImGui_ImplDX11_Data* bd = IM_NEW(ImGui_ImplDX11_Data)();
io.BackendRendererUserData = (void*)bd;
io.BackendRendererName = "imgui_impl_dx11";
io.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset; // We can honor the ImDrawCmd::VtxOffset field, allowing for large meshes.
// Get factory from device
IDXGIDevice* pDXGIDevice = NULL;
IDXGIAdapter* pDXGIAdapter = NULL;
IDXGIFactory* pFactory = NULL;
if (device->QueryInterface(IID_PPV_ARGS(&pDXGIDevice)) == S_OK)
if (pDXGIDevice->GetParent(IID_PPV_ARGS(&pDXGIAdapter)) == S_OK)
if (pDXGIAdapter->GetParent(IID_PPV_ARGS(&pFactory)) == S_OK)
{
bd->pd3dDevice = device;
bd->pd3dDeviceContext = device_context;
bd->pFactory = pFactory;
}
if (pDXGIDevice) pDXGIDevice->Release();
if (pDXGIAdapter) pDXGIAdapter->Release();
bd->pd3dDevice->AddRef();
bd->pd3dDeviceContext->AddRef();
return true;
}
void ImGui_ImplDX11_Shutdown()
{
ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
IM_ASSERT(bd != NULL && "No renderer backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
ImGui_ImplDX11_InvalidateDeviceObjects();
if (bd->pFactory) { bd->pFactory->Release(); }
if (bd->pd3dDevice) { bd->pd3dDevice->Release(); }
if (bd->pd3dDeviceContext) { bd->pd3dDeviceContext->Release(); }
io.BackendRendererName = NULL;
io.BackendRendererUserData = NULL;
IM_DELETE(bd);
}
void ImGui_ImplDX11_NewFrame()
{
ImGui_ImplDX11_Data* bd = ImGui_ImplDX11_GetBackendData();
IM_ASSERT(bd != NULL && "Did you call ImGui_ImplDX11_Init()?");
if (!bd->pFontSampler)
ImGui_ImplDX11_CreateDeviceObjects();
}
+26
View File
@@ -0,0 +1,26 @@
// dear imgui: Renderer Backend for DirectX11
// This needs to be used along with a Platform Backend (e.g. Win32)
// Implemented features:
// [X] Renderer: User texture binding. Use 'ID3D11ShaderResourceView*' as ImTextureID. Read the FAQ about ImTextureID!
// [X] Renderer: Support for large meshes (64k+ vertices) with 16-bit indices.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
#pragma once
#include "imgui.h" // IMGUI_IMPL_API
struct ID3D11Device;
struct ID3D11DeviceContext;
IMGUI_IMPL_API bool ImGui_ImplDX11_Init(ID3D11Device* device, ID3D11DeviceContext* device_context);
IMGUI_IMPL_API void ImGui_ImplDX11_Shutdown();
IMGUI_IMPL_API void ImGui_ImplDX11_NewFrame();
IMGUI_IMPL_API void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data);
// Use if you want to reset your rendering device without losing Dear ImGui state.
IMGUI_IMPL_API void ImGui_ImplDX11_InvalidateDeviceObjects();
IMGUI_IMPL_API bool ImGui_ImplDX11_CreateDeviceObjects();
+258
View File
@@ -0,0 +1,258 @@
// dear imgui: Renderer Backend for OpenGL2 (legacy OpenGL, fixed pipeline)
// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
// Implemented features:
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
// **DO NOT USE THIS CODE IF YOUR CODE/ENGINE IS USING MODERN OPENGL (SHADERS, VBO, VAO, etc.)**
// **Prefer using the code in imgui_impl_opengl3.cpp**
// This code is mostly provided as a reference to learn how ImGui integration works, because it is shorter to read.
// If your code is using GL3+ context or any semi modern OpenGL calls, using this is likely to make everything more
// complicated, will require your code to reset every single OpenGL attributes to their initial state, and might
// confuse your GPU driver.
// The GL2 code is unable to reset attributes or even call e.g. "glUseProgram(0)" because they don't exist in that API.
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
// 2021-01-03: OpenGL: Backup, setup and restore GL_SHADE_MODEL state, disable GL_STENCIL_TEST and disable GL_NORMAL_ARRAY client state to increase compatibility with legacy OpenGL applications.
// 2020-01-23: OpenGL: Backup, setup and restore GL_TEXTURE_ENV to increase compatibility with legacy OpenGL applications.
// 2019-04-30: OpenGL: Added support for special ImDrawCallback_ResetRenderState callback to reset render state.
// 2019-02-11: OpenGL: Projecting clipping rectangles correctly using draw_data->FramebufferScale to allow multi-viewports for retina display.
// 2018-11-30: Misc: Setting up io.BackendRendererName so it can be displayed in the About Window.
// 2018-08-03: OpenGL: Disabling/restoring GL_LIGHTING and GL_COLOR_MATERIAL to increase compatibility with legacy OpenGL applications.
// 2018-06-08: Misc: Extracted imgui_impl_opengl2.cpp/.h away from the old combined GLFW/SDL+OpenGL2 examples.
// 2018-06-08: OpenGL: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle.
// 2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplOpenGL2_RenderDrawData() in the .h file so you can call it yourself.
// 2017-09-01: OpenGL: Save and restore current polygon mode.
// 2016-09-10: OpenGL: Uploading font texture as RGBA32 to increase compatibility with users shaders (not ideal).
// 2016-09-05: OpenGL: Fixed save and restore of current scissor rectangle.
#include "imgui.h"
#include "imgui_impl_opengl2.h"
#if defined(_MSC_VER) && _MSC_VER <= 1500 // MSVC 2008 or earlier
#include <stddef.h> // intptr_t
#else
#include <stdint.h> // intptr_t
#endif
// Include OpenGL header (without an OpenGL loader) requires a bit of fiddling
#if defined(_WIN32) && !defined(APIENTRY)
#define APIENTRY __stdcall // It is customary to use APIENTRY for OpenGL function pointer declarations on all platforms. Additionally, the Windows OpenGL header needs APIENTRY.
#endif
#if defined(_WIN32) && !defined(WINGDIAPI)
#define WINGDIAPI __declspec(dllimport) // Some Windows OpenGL headers need this
#endif
#if defined(__APPLE__)
#define GL_SILENCE_DEPRECATION
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
// OpenGL Data
static GLuint g_FontTexture = 0;
// Functions
bool ImGui_ImplOpenGL2_Init()
{
// Setup backend capabilities flags
ImGuiIO& io = ImGui::GetIO();
io.BackendRendererName = "imgui_impl_opengl2";
return true;
}
void ImGui_ImplOpenGL2_Shutdown()
{
ImGui_ImplOpenGL2_DestroyDeviceObjects();
}
void ImGui_ImplOpenGL2_NewFrame()
{
if (!g_FontTexture)
ImGui_ImplOpenGL2_CreateDeviceObjects();
}
static void ImGui_ImplOpenGL2_SetupRenderState(ImDrawData* draw_data, int fb_width, int fb_height)
{
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill.
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA); // In order to composite our output buffer we need to preserve alpha
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glDisable(GL_STENCIL_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glEnable(GL_SCISSOR_TEST);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glEnable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glShadeModel(GL_SMOOTH);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
// If you are using this code with non-legacy OpenGL header/contexts (which you should not, prefer using imgui_impl_opengl3.cpp!!),
// you may need to backup/reset/restore other state, e.g. for current shader using the commented lines below.
// (DO NOT MODIFY THIS FILE! Add the code in your calling function)
// GLint last_program;
// glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
// glUseProgram(0);
// ImGui_ImplOpenGL2_RenderDrawData(...);
// glUseProgram(last_program)
// There are potentially many more states you could need to clear/setup that we can't access from default headers.
// e.g. glBindBuffer(GL_ARRAY_BUFFER, 0), glDisable(GL_TEXTURE_CUBE_MAP).
// Setup viewport, orthographic projection matrix
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps.
glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(draw_data->DisplayPos.x, draw_data->DisplayPos.x + draw_data->DisplaySize.x, draw_data->DisplayPos.y + draw_data->DisplaySize.y, draw_data->DisplayPos.y, -1.0f, +1.0f);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
}
// OpenGL2 Render function.
// Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly.
// This is in order to be able to run within an OpenGL engine that doesn't do so.
void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data)
{
// Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates)
int fb_width = (int)(draw_data->DisplaySize.x * draw_data->FramebufferScale.x);
int fb_height = (int)(draw_data->DisplaySize.y * draw_data->FramebufferScale.y);
if (fb_width == 0 || fb_height == 0)
return;
// Backup GL state
GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
GLint last_polygon_mode[2]; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode);
GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
GLint last_scissor_box[4]; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box);
GLint last_shade_model; glGetIntegerv(GL_SHADE_MODEL, &last_shade_model);
GLint last_tex_env_mode; glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &last_tex_env_mode);
glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT);
// Setup desired GL state
ImGui_ImplOpenGL2_SetupRenderState(draw_data, fb_width, fb_height);
// Will project scissor/clipping rectangles into framebuffer space
ImVec2 clip_off = draw_data->DisplayPos; // (0,0) unless using multi-viewports
ImVec2 clip_scale = draw_data->FramebufferScale; // (1,1) unless using retina display which are often (2,2)
// Render command lists
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data;
const ImDrawIdx* idx_buffer = cmd_list->IdxBuffer.Data;
glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, pos)));
glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, uv)));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (const GLvoid*)((const char*)vtx_buffer + IM_OFFSETOF(ImDrawVert, col)));
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
if (pcmd->UserCallback)
{
// User callback, registered via ImDrawList::AddCallback()
// (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
ImGui_ImplOpenGL2_SetupRenderState(draw_data, fb_width, fb_height);
else
pcmd->UserCallback(cmd_list, pcmd);
}
else
{
// Project scissor/clipping rectangles into framebuffer space
ImVec4 clip_rect;
clip_rect.x = (pcmd->ClipRect.x - clip_off.x) * clip_scale.x;
clip_rect.y = (pcmd->ClipRect.y - clip_off.y) * clip_scale.y;
clip_rect.z = (pcmd->ClipRect.z - clip_off.x) * clip_scale.x;
clip_rect.w = (pcmd->ClipRect.w - clip_off.y) * clip_scale.y;
if (clip_rect.x < fb_width && clip_rect.y < fb_height && clip_rect.z >= 0.0f && clip_rect.w >= 0.0f)
{
// Apply scissor/clipping rectangle
glScissor((int)clip_rect.x, (int)(fb_height - clip_rect.w), (int)(clip_rect.z - clip_rect.x), (int)(clip_rect.w - clip_rect.y));
// Bind texture, Draw
glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer);
}
}
idx_buffer += pcmd->ElemCount;
}
}
// Restore modified GL state
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glBindTexture(GL_TEXTURE_2D, (GLuint)last_texture);
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glPopAttrib();
glPolygonMode(GL_FRONT, (GLenum)last_polygon_mode[0]); glPolygonMode(GL_BACK, (GLenum)last_polygon_mode[1]);
glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
glScissor(last_scissor_box[0], last_scissor_box[1], (GLsizei)last_scissor_box[2], (GLsizei)last_scissor_box[3]);
glShadeModel(last_shade_model);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, last_tex_env_mode);
}
bool ImGui_ImplOpenGL2_CreateFontsTexture()
{
// Build texture atlas
ImGuiIO& io = ImGui::GetIO();
unsigned char* pixels;
int width, height;
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height); // Load as RGBA 32-bit (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory.
// Upload texture to graphics system
GLint last_texture;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
glGenTextures(1, &g_FontTexture);
glBindTexture(GL_TEXTURE_2D, g_FontTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
// Store our identifier
io.Fonts->SetTexID((ImTextureID)(intptr_t)g_FontTexture);
// Restore state
glBindTexture(GL_TEXTURE_2D, last_texture);
return true;
}
void ImGui_ImplOpenGL2_DestroyFontsTexture()
{
if (g_FontTexture)
{
ImGuiIO& io = ImGui::GetIO();
glDeleteTextures(1, &g_FontTexture);
io.Fonts->SetTexID(0);
g_FontTexture = 0;
}
}
bool ImGui_ImplOpenGL2_CreateDeviceObjects()
{
return ImGui_ImplOpenGL2_CreateFontsTexture();
}
void ImGui_ImplOpenGL2_DestroyDeviceObjects()
{
ImGui_ImplOpenGL2_DestroyFontsTexture();
}
+31
View File
@@ -0,0 +1,31 @@
// dear imgui: Renderer Backend for OpenGL2 (legacy OpenGL, fixed pipeline)
// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
// Implemented features:
// [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
// **DO NOT USE THIS CODE IF YOUR CODE/ENGINE IS USING MODERN OPENGL (SHADERS, VBO, VAO, etc.)**
// **Prefer using the code in imgui_impl_opengl3.cpp**
// This code is mostly provided as a reference to learn how ImGui integration works, because it is shorter to read.
// If your code is using GL3+ context or any semi modern OpenGL calls, using this is likely to make everything more
// complicated, will require your code to reset every single OpenGL attributes to their initial state, and might
// confuse your GPU driver.
// The GL2 code is unable to reset attributes or even call e.g. "glUseProgram(0)" because they don't exist in that API.
#pragma once
#include "imgui.h" // IMGUI_IMPL_API
IMGUI_IMPL_API bool ImGui_ImplOpenGL2_Init();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_Shutdown();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_NewFrame();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_RenderDrawData(ImDrawData* draw_data);
// Called by Init/NewFrame/Shutdown
IMGUI_IMPL_API bool ImGui_ImplOpenGL2_CreateFontsTexture();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_DestroyFontsTexture();
IMGUI_IMPL_API bool ImGui_ImplOpenGL2_CreateDeviceObjects();
IMGUI_IMPL_API void ImGui_ImplOpenGL2_DestroyDeviceObjects();
+377
View File
@@ -0,0 +1,377 @@
// dear imgui: Platform Backend for SDL2
// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
// (Info: SDL2 is a cross-platform general purpose library for handling windows, inputs, graphics context creation, etc.)
// (Requires: SDL 2.0. Prefer SDL 2.0.4+ for full feature support.)
// Implemented features:
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
// [X] Platform: Clipboard support.
// [X] Platform: Keyboard arrays indexed using SDL_SCANCODE_* codes, e.g. ImGui::IsKeyPressed(SDL_SCANCODE_SPACE).
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// Missing features:
// [ ] Platform: SDL2 handling of IME under Windows appears to be broken and it explicitly disable the regular Windows IME. You can restore Windows IME by compiling SDL with SDL_DISABLE_WINDOWS_IME.
// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
// 2021-03-22: Rework global mouse pos availability check listing supported platforms explicitly, effectively fixing mouse access on Raspberry Pi. (#2837, #3950)
// 2020-05-25: Misc: Report a zero display-size when window is minimized, to be consistent with other backends.
// 2020-02-20: Inputs: Fixed mapping for ImGuiKey_KeyPadEnter (using SDL_SCANCODE_KP_ENTER instead of SDL_SCANCODE_RETURN2).
// 2019-12-17: Inputs: On Wayland, use SDL_GetMouseState (because there is no global mouse state).
// 2019-12-05: Inputs: Added support for ImGuiMouseCursor_NotAllowed mouse cursor.
// 2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
// 2019-04-23: Inputs: Added support for SDL_GameController (if ImGuiConfigFlags_NavEnableGamepad is set by user application).
// 2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
// 2018-12-21: Inputs: Workaround for Android/iOS which don't seem to handle focus related calls.
// 2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
// 2018-11-14: Changed the signature of ImGui_ImplSDL2_ProcessEvent() to take a 'const SDL_Event*'.
// 2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
// 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
// 2018-06-08: Misc: Extracted imgui_impl_sdl.cpp/.h away from the old combined SDL2+OpenGL/Vulkan examples.
// 2018-06-08: Misc: ImGui_ImplSDL2_InitForOpenGL() now takes a SDL_GLContext parameter.
// 2018-05-09: Misc: Fixed clipboard paste memory leak (we didn't call SDL_FreeMemory on the data returned by SDL_GetClipboardText).
// 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
// 2018-02-16: Inputs: Added support for mouse cursors, honoring ImGui::GetMouseCursor() value.
// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
// 2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
// 2018-02-05: Misc: Using SDL_GetPerformanceCounter() instead of SDL_GetTicks() to be able to handle very high framerate (1000+ FPS).
// 2018-02-05: Inputs: Keyboard mapping is using scancodes everywhere instead of a confusing mixture of keycodes and scancodes.
// 2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
// 2018-01-19: Inputs: When available (SDL 2.0.4+) using SDL_CaptureMouse() to retrieve coordinates outside of client area when dragging. Otherwise (SDL 2.0.3 and before) testing for SDL_WINDOW_INPUT_FOCUS instead of SDL_WINDOW_MOUSE_FOCUS.
// 2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
// 2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
// 2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
#include "imgui.h"
#include "imgui_impl_sdl.h"
// SDL
#include <SDL.h>
#include <SDL_syswm.h>
#if defined(__APPLE__)
#include "TargetConditionals.h"
#endif
#define SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE SDL_VERSION_ATLEAST(2,0,4)
#define SDL_HAS_VULKAN SDL_VERSION_ATLEAST(2,0,6)
// Data
static SDL_Window* g_Window = NULL;
static Uint64 g_Time = 0;
static bool g_MousePressed[3] = { false, false, false };
static SDL_Cursor* g_MouseCursors[ImGuiMouseCursor_COUNT] = {};
static char* g_ClipboardTextData = NULL;
static bool g_MouseCanUseGlobalState = true;
static const char* ImGui_ImplSDL2_GetClipboardText(void*)
{
if (g_ClipboardTextData)
SDL_free(g_ClipboardTextData);
g_ClipboardTextData = SDL_GetClipboardText();
return g_ClipboardTextData;
}
static void ImGui_ImplSDL2_SetClipboardText(void*, const char* text)
{
SDL_SetClipboardText(text);
}
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
// If you have multiple SDL events and some of them are not meant to be used by dear imgui, you may need to filter events based on their windowID field.
bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event)
{
ImGuiIO& io = ImGui::GetIO();
switch (event->type)
{
case SDL_MOUSEWHEEL:
{
if (event->wheel.x > 0) io.MouseWheelH += 1;
if (event->wheel.x < 0) io.MouseWheelH -= 1;
if (event->wheel.y > 0) io.MouseWheel += 1;
if (event->wheel.y < 0) io.MouseWheel -= 1;
return true;
}
case SDL_MOUSEBUTTONDOWN:
{
if (event->button.button == SDL_BUTTON_LEFT) g_MousePressed[0] = true;
if (event->button.button == SDL_BUTTON_RIGHT) g_MousePressed[1] = true;
if (event->button.button == SDL_BUTTON_MIDDLE) g_MousePressed[2] = true;
return true;
}
case SDL_TEXTINPUT:
{
io.AddInputCharactersUTF8(event->text.text);
return true;
}
case SDL_KEYDOWN:
case SDL_KEYUP:
{
int key = event->key.keysym.scancode;
IM_ASSERT(key >= 0 && key < IM_ARRAYSIZE(io.KeysDown));
io.KeysDown[key] = (event->type == SDL_KEYDOWN);
io.KeyShift = ((SDL_GetModState() & KMOD_SHIFT) != 0);
io.KeyCtrl = ((SDL_GetModState() & KMOD_CTRL) != 0);
io.KeyAlt = ((SDL_GetModState() & KMOD_ALT) != 0);
#ifdef _WIN32
io.KeySuper = false;
#else
io.KeySuper = ((SDL_GetModState() & KMOD_GUI) != 0);
#endif
return true;
}
}
return false;
}
static bool ImGui_ImplSDL2_Init(SDL_Window* window)
{
g_Window = window;
// Setup backend capabilities flags
ImGuiIO& io = ImGui::GetIO();
io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
io.BackendPlatformName = "imgui_impl_sdl";
// Keyboard mapping. Dear ImGui will use those indices to peek into the io.KeysDown[] array.
io.KeyMap[ImGuiKey_Tab] = SDL_SCANCODE_TAB;
io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT;
io.KeyMap[ImGuiKey_RightArrow] = SDL_SCANCODE_RIGHT;
io.KeyMap[ImGuiKey_UpArrow] = SDL_SCANCODE_UP;
io.KeyMap[ImGuiKey_DownArrow] = SDL_SCANCODE_DOWN;
io.KeyMap[ImGuiKey_PageUp] = SDL_SCANCODE_PAGEUP;
io.KeyMap[ImGuiKey_PageDown] = SDL_SCANCODE_PAGEDOWN;
io.KeyMap[ImGuiKey_Home] = SDL_SCANCODE_HOME;
io.KeyMap[ImGuiKey_End] = SDL_SCANCODE_END;
io.KeyMap[ImGuiKey_Insert] = SDL_SCANCODE_INSERT;
io.KeyMap[ImGuiKey_Delete] = SDL_SCANCODE_DELETE;
io.KeyMap[ImGuiKey_Backspace] = SDL_SCANCODE_BACKSPACE;
io.KeyMap[ImGuiKey_Space] = SDL_SCANCODE_SPACE;
io.KeyMap[ImGuiKey_Enter] = SDL_SCANCODE_RETURN;
io.KeyMap[ImGuiKey_Escape] = SDL_SCANCODE_ESCAPE;
io.KeyMap[ImGuiKey_KeyPadEnter] = SDL_SCANCODE_KP_ENTER;
io.KeyMap[ImGuiKey_A] = SDL_SCANCODE_A;
io.KeyMap[ImGuiKey_C] = SDL_SCANCODE_C;
io.KeyMap[ImGuiKey_V] = SDL_SCANCODE_V;
io.KeyMap[ImGuiKey_X] = SDL_SCANCODE_X;
io.KeyMap[ImGuiKey_Y] = SDL_SCANCODE_Y;
io.KeyMap[ImGuiKey_Z] = SDL_SCANCODE_Z;
io.SetClipboardTextFn = ImGui_ImplSDL2_SetClipboardText;
io.GetClipboardTextFn = ImGui_ImplSDL2_GetClipboardText;
io.ClipboardUserData = NULL;
// Load mouse cursors
g_MouseCursors[ImGuiMouseCursor_Arrow] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW);
g_MouseCursors[ImGuiMouseCursor_TextInput] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_IBEAM);
g_MouseCursors[ImGuiMouseCursor_ResizeAll] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEALL);
g_MouseCursors[ImGuiMouseCursor_ResizeNS] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENS);
g_MouseCursors[ImGuiMouseCursor_ResizeEW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEWE);
g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENESW);
g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENWSE);
g_MouseCursors[ImGuiMouseCursor_Hand] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND);
g_MouseCursors[ImGuiMouseCursor_NotAllowed] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_NO);
// Check and store if we are on a SDL backend that supports global mouse position
// ("wayland" and "rpi" don't support it, but we chose to use a white-list instead of a black-list)
const char* sdl_backend = SDL_GetCurrentVideoDriver();
const char* global_mouse_whitelist[] = { "windows", "cocoa", "x11", "DIVE", "VMAN" };
g_MouseCanUseGlobalState = false;
for (int n = 0; n < IM_ARRAYSIZE(global_mouse_whitelist); n++)
if (strncmp(sdl_backend, global_mouse_whitelist[n], strlen(global_mouse_whitelist[n])) == 0)
g_MouseCanUseGlobalState = true;
#ifdef _WIN32
SDL_SysWMinfo wmInfo;
SDL_VERSION(&wmInfo.version);
SDL_GetWindowWMInfo(window, &wmInfo);
io.ImeWindowHandle = wmInfo.info.win.window;
#else
(void)window;
#endif
return true;
}
bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window, void* sdl_gl_context)
{
(void)sdl_gl_context; // Viewport branch will need this.
return ImGui_ImplSDL2_Init(window);
}
bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window)
{
#if !SDL_HAS_VULKAN
IM_ASSERT(0 && "Unsupported");
#endif
return ImGui_ImplSDL2_Init(window);
}
bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window)
{
#if !defined(_WIN32)
IM_ASSERT(0 && "Unsupported");
#endif
return ImGui_ImplSDL2_Init(window);
}
bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window)
{
return ImGui_ImplSDL2_Init(window);
}
void ImGui_ImplSDL2_Shutdown()
{
g_Window = NULL;
// Destroy last known clipboard data
if (g_ClipboardTextData)
SDL_free(g_ClipboardTextData);
g_ClipboardTextData = NULL;
// Destroy SDL mouse cursors
for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
SDL_FreeCursor(g_MouseCursors[cursor_n]);
memset(g_MouseCursors, 0, sizeof(g_MouseCursors));
}
static void ImGui_ImplSDL2_UpdateMousePosAndButtons()
{
ImGuiIO& io = ImGui::GetIO();
// Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
if (io.WantSetMousePos)
SDL_WarpMouseInWindow(g_Window, (int)io.MousePos.x, (int)io.MousePos.y);
else
io.MousePos = ImVec2(-FLT_MAX, -FLT_MAX);
int mx, my;
Uint32 mouse_buttons = SDL_GetMouseState(&mx, &my);
io.MouseDown[0] = g_MousePressed[0] || (mouse_buttons & SDL_BUTTON(SDL_BUTTON_LEFT)) != 0; // If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame.
io.MouseDown[1] = g_MousePressed[1] || (mouse_buttons & SDL_BUTTON(SDL_BUTTON_RIGHT)) != 0;
io.MouseDown[2] = g_MousePressed[2] || (mouse_buttons & SDL_BUTTON(SDL_BUTTON_MIDDLE)) != 0;
g_MousePressed[0] = g_MousePressed[1] = g_MousePressed[2] = false;
#if SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE && !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) && !(defined(__APPLE__) && TARGET_OS_IOS)
SDL_Window* focused_window = SDL_GetKeyboardFocus();
if (g_Window == focused_window)
{
if (g_MouseCanUseGlobalState)
{
// SDL_GetMouseState() gives mouse position seemingly based on the last window entered/focused(?)
// The creation of a new windows at runtime and SDL_CaptureMouse both seems to severely mess up with that, so we retrieve that position globally.
// Won't use this workaround on SDL backends that have no global mouse position, like Wayland or RPI
int wx, wy;
SDL_GetWindowPosition(focused_window, &wx, &wy);
SDL_GetGlobalMouseState(&mx, &my);
mx -= wx;
my -= wy;
}
io.MousePos = ImVec2((float)mx, (float)my);
}
// SDL_CaptureMouse() let the OS know e.g. that our imgui drag outside the SDL window boundaries shouldn't e.g. trigger the OS window resize cursor.
// The function is only supported from SDL 2.0.4 (released Jan 2016)
bool any_mouse_button_down = ImGui::IsAnyMouseDown();
SDL_CaptureMouse(any_mouse_button_down ? SDL_TRUE : SDL_FALSE);
#else
if (SDL_GetWindowFlags(g_Window) & SDL_WINDOW_INPUT_FOCUS)
io.MousePos = ImVec2((float)mx, (float)my);
#endif
}
static void ImGui_ImplSDL2_UpdateMouseCursor()
{
ImGuiIO& io = ImGui::GetIO();
if (io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange)
return;
ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
if (io.MouseDrawCursor || imgui_cursor == ImGuiMouseCursor_None)
{
// Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
SDL_ShowCursor(SDL_FALSE);
}
else
{
// Show OS mouse cursor
SDL_SetCursor(g_MouseCursors[imgui_cursor] ? g_MouseCursors[imgui_cursor] : g_MouseCursors[ImGuiMouseCursor_Arrow]);
SDL_ShowCursor(SDL_TRUE);
}
}
static void ImGui_ImplSDL2_UpdateGamepads()
{
ImGuiIO& io = ImGui::GetIO();
memset(io.NavInputs, 0, sizeof(io.NavInputs));
if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0)
return;
// Get gamepad
SDL_GameController* game_controller = SDL_GameControllerOpen(0);
if (!game_controller)
{
io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
return;
}
// Update gamepad inputs
#define MAP_BUTTON(NAV_NO, BUTTON_NO) { io.NavInputs[NAV_NO] = (SDL_GameControllerGetButton(game_controller, BUTTON_NO) != 0) ? 1.0f : 0.0f; }
#define MAP_ANALOG(NAV_NO, AXIS_NO, V0, V1) { float vn = (float)(SDL_GameControllerGetAxis(game_controller, AXIS_NO) - V0) / (float)(V1 - V0); if (vn > 1.0f) vn = 1.0f; if (vn > 0.0f && io.NavInputs[NAV_NO] < vn) io.NavInputs[NAV_NO] = vn; }
const int thumb_dead_zone = 8000; // SDL_gamecontroller.h suggests using this value.
MAP_BUTTON(ImGuiNavInput_Activate, SDL_CONTROLLER_BUTTON_A); // Cross / A
MAP_BUTTON(ImGuiNavInput_Cancel, SDL_CONTROLLER_BUTTON_B); // Circle / B
MAP_BUTTON(ImGuiNavInput_Menu, SDL_CONTROLLER_BUTTON_X); // Square / X
MAP_BUTTON(ImGuiNavInput_Input, SDL_CONTROLLER_BUTTON_Y); // Triangle / Y
MAP_BUTTON(ImGuiNavInput_DpadLeft, SDL_CONTROLLER_BUTTON_DPAD_LEFT); // D-Pad Left
MAP_BUTTON(ImGuiNavInput_DpadRight, SDL_CONTROLLER_BUTTON_DPAD_RIGHT); // D-Pad Right
MAP_BUTTON(ImGuiNavInput_DpadUp, SDL_CONTROLLER_BUTTON_DPAD_UP); // D-Pad Up
MAP_BUTTON(ImGuiNavInput_DpadDown, SDL_CONTROLLER_BUTTON_DPAD_DOWN); // D-Pad Down
MAP_BUTTON(ImGuiNavInput_FocusPrev, SDL_CONTROLLER_BUTTON_LEFTSHOULDER); // L1 / LB
MAP_BUTTON(ImGuiNavInput_FocusNext, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER); // R1 / RB
MAP_BUTTON(ImGuiNavInput_TweakSlow, SDL_CONTROLLER_BUTTON_LEFTSHOULDER); // L1 / LB
MAP_BUTTON(ImGuiNavInput_TweakFast, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER); // R1 / RB
MAP_ANALOG(ImGuiNavInput_LStickLeft, SDL_CONTROLLER_AXIS_LEFTX, -thumb_dead_zone, -32768);
MAP_ANALOG(ImGuiNavInput_LStickRight, SDL_CONTROLLER_AXIS_LEFTX, +thumb_dead_zone, +32767);
MAP_ANALOG(ImGuiNavInput_LStickUp, SDL_CONTROLLER_AXIS_LEFTY, -thumb_dead_zone, -32767);
MAP_ANALOG(ImGuiNavInput_LStickDown, SDL_CONTROLLER_AXIS_LEFTY, +thumb_dead_zone, +32767);
io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
#undef MAP_BUTTON
#undef MAP_ANALOG
}
void ImGui_ImplSDL2_NewFrame(SDL_Window* window)
{
ImGuiIO& io = ImGui::GetIO();
IM_ASSERT(io.Fonts->IsBuilt() && "Font atlas not built! It is generally built by the renderer backend. Missing call to renderer _NewFrame() function? e.g. ImGui_ImplOpenGL3_NewFrame().");
// Setup display size (every frame to accommodate for window resizing)
int w, h;
int display_w, display_h;
SDL_GetWindowSize(window, &w, &h);
if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)
w = h = 0;
SDL_GL_GetDrawableSize(window, &display_w, &display_h);
io.DisplaySize = ImVec2((float)w, (float)h);
if (w > 0 && h > 0)
io.DisplayFramebufferScale = ImVec2((float)display_w / w, (float)display_h / h);
// Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution)
static Uint64 frequency = SDL_GetPerformanceFrequency();
Uint64 current_time = SDL_GetPerformanceCounter();
io.DeltaTime = g_Time > 0 ? (float)((double)(current_time - g_Time) / frequency) : (float)(1.0f / 60.0f);
g_Time = current_time;
ImGui_ImplSDL2_UpdateMousePosAndButtons();
ImGui_ImplSDL2_UpdateMouseCursor();
// Update game controllers (if enabled and available)
ImGui_ImplSDL2_UpdateGamepads();
}
+29
View File
@@ -0,0 +1,29 @@
// dear imgui: Platform Backend for SDL2
// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
// (Info: SDL2 is a cross-platform general purpose library for handling windows, inputs, graphics context creation, etc.)
// Implemented features:
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
// [X] Platform: Clipboard support.
// [X] Platform: Keyboard arrays indexed using SDL_SCANCODE_* codes, e.g. ImGui::IsKeyPressed(SDL_SCANCODE_SPACE).
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// Missing features:
// [ ] Platform: SDL2 handling of IME under Windows appears to be broken and it explicitly disable the regular Windows IME. You can restore Windows IME by compiling SDL with SDL_DISABLE_WINDOWS_IME.
// You can copy and use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
#pragma once
#include "imgui.h" // IMGUI_IMPL_API
struct SDL_Window;
typedef union SDL_Event SDL_Event;
IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window, void* sdl_gl_context);
IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window);
IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window);
IMGUI_IMPL_API bool ImGui_ImplSDL2_InitForMetal(SDL_Window* window);
IMGUI_IMPL_API void ImGui_ImplSDL2_Shutdown();
IMGUI_IMPL_API void ImGui_ImplSDL2_NewFrame(SDL_Window* window);
IMGUI_IMPL_API bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event);
+790
View File
@@ -0,0 +1,790 @@
// dear imgui: Platform Backend for Windows (standard windows API for 32 and 64 bits applications)
// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
// Implemented features:
// [X] Platform: Clipboard support (for Win32 this is actually part of core dear imgui)
// [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy VK_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
#include "imgui.h"
#include "imgui_impl_win32.h"
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#include <windowsx.h> // GET_X_LPARAM(), GET_Y_LPARAM()
#include <tchar.h>
#include <dwmapi.h>
// Configuration flags to add in your imconfig.h file:
//#define IMGUI_IMPL_WIN32_DISABLE_GAMEPAD // Disable gamepad support. This was meaningful before <1.81 but we now load XInput dynamically so the option is now less relevant.
// Using XInput for gamepad (will load DLL dynamically)
#ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
#include <xinput.h>
typedef DWORD (WINAPI *PFN_XInputGetCapabilities)(DWORD, DWORD, XINPUT_CAPABILITIES*);
typedef DWORD (WINAPI *PFN_XInputGetState)(DWORD, XINPUT_STATE*);
#endif
// CHANGELOG
// (minor and older changes stripped away, please see git history for details)
// 2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago)with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
// 2021-01-20: Inputs: calling new io.AddKeyAnalogEvent() for gamepad support, instead of writing directly to io.NavInputs[].
// 2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
// 2022-01-17: Inputs: always update key mods next and before a key event (not in NewFrame) to fix input queue with very low framerates.
// 2022-01-12: Inputs: Update mouse inputs using WM_MOUSEMOVE/WM_MOUSELEAVE + fallback to provide it when focused but not hovered/captured. More standard and will allow us to pass it to future input queue API.
// 2022-01-12: Inputs: Maintain our own copy of MouseButtonsDown mask instead of using ImGui::IsAnyMouseDown() which will be obsoleted.
// 2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
// 2021-12-16: Inputs: Fill VK_LCONTROL/VK_RCONTROL/VK_LSHIFT/VK_RSHIFT/VK_LMENU/VK_RMENU for completeness.
// 2021-08-17: Calling io.AddFocusEvent() on WM_SETFOCUS/WM_KILLFOCUS messages.
// 2021-08-02: Inputs: Fixed keyboard modifiers being reported when host window doesn't have focus.
// 2021-07-29: Inputs: MousePos is correctly reported when the host platform window is hovered but not focused (using TrackMouseEvent() to receive WM_MOUSELEAVE events).
// 2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
// 2021-06-08: Fixed ImGui_ImplWin32_EnableDpiAwareness() and ImGui_ImplWin32_GetDpiScaleForMonitor() to handle Windows 8.1/10 features without a manifest (per-monitor DPI, and properly calls SetProcessDpiAwareness() on 8.1).
// 2021-03-23: Inputs: Clearing keyboard down array when losing focus (WM_KILLFOCUS).
// 2021-02-18: Added ImGui_ImplWin32_EnableAlphaCompositing(). Non Visual Studio users will need to link with dwmapi.lib (MinGW/gcc: use -ldwmapi).
// 2021-02-17: Fixed ImGui_ImplWin32_EnableDpiAwareness() attempting to get SetProcessDpiAwareness from shcore.dll on Windows 8 whereas it is only supported on Windows 8.1.
// 2021-01-25: Inputs: Dynamically loading XInput DLL.
// 2020-12-04: Misc: Fixed setting of io.DisplaySize to invalid/uninitialized data when after hwnd has been closed.
// 2020-03-03: Inputs: Calling AddInputCharacterUTF16() to support surrogate pairs leading to codepoint >= 0x10000 (for more complete CJK inputs)
// 2020-02-17: Added ImGui_ImplWin32_EnableDpiAwareness(), ImGui_ImplWin32_GetDpiScaleForHwnd(), ImGui_ImplWin32_GetDpiScaleForMonitor() helper functions.
// 2020-01-14: Inputs: Added support for #define IMGUI_IMPL_WIN32_DISABLE_GAMEPAD/IMGUI_IMPL_WIN32_DISABLE_LINKING_XINPUT.
// 2019-12-05: Inputs: Added support for ImGuiMouseCursor_NotAllowed mouse cursor.
// 2019-05-11: Inputs: Don't filter value from WM_CHAR before calling AddInputCharacter().
// 2019-01-17: Misc: Using GetForegroundWindow()+IsChild() instead of GetActiveWindow() to be compatible with windows created in a different thread or parent.
// 2019-01-17: Inputs: Added support for mouse buttons 4 and 5 via WM_XBUTTON* messages.
// 2019-01-15: Inputs: Added support for XInput gamepads (if ImGuiConfigFlags_NavEnableGamepad is set by user application).
// 2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
// 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
// 2018-06-10: Inputs: Fixed handling of mouse wheel messages to support fine position messages (typically sent by track-pads).
// 2018-06-08: Misc: Extracted imgui_impl_win32.cpp/.h away from the old combined DX9/DX10/DX11/DX12 examples.
// 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors and ImGuiBackendFlags_HasSetMousePos flags + honor ImGuiConfigFlags_NoMouseCursorChange flag.
// 2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value and WM_SETCURSOR message handling).
// 2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
// 2018-02-06: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
// 2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
// 2018-01-08: Inputs: Added mapping for ImGuiKey_Insert.
// 2018-01-05: Inputs: Added WM_LBUTTONDBLCLK double-click handlers for window classes with the CS_DBLCLKS flag.
// 2017-10-23: Inputs: Added WM_SYSKEYDOWN / WM_SYSKEYUP handlers so e.g. the VK_MENU key can be read.
// 2017-10-23: Inputs: Using Win32 ::SetCapture/::GetCapture() to retrieve mouse positions outside the client area when dragging.
// 2016-11-12: Inputs: Only call Win32 ::SetCursor(NULL) when io.MouseDrawCursor is set.
struct ImGui_ImplWin32_Data
{
HWND hWnd;
HWND MouseHwnd;
bool MouseTracked;
int MouseButtonsDown;
INT64 Time;
INT64 TicksPerSecond;
ImGuiMouseCursor LastMouseCursor;
bool HasGamepad;
bool WantUpdateHasGamepad;
#ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
HMODULE XInputDLL;
PFN_XInputGetCapabilities XInputGetCapabilities;
PFN_XInputGetState XInputGetState;
#endif
ImGui_ImplWin32_Data() { memset(this, 0, sizeof(*this)); }
};
// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
static ImGui_ImplWin32_Data* ImGui_ImplWin32_GetBackendData()
{
return ImGui::GetCurrentContext() ? (ImGui_ImplWin32_Data*)ImGui::GetIO().BackendPlatformUserData : NULL;
}
// Functions
bool ImGui_ImplWin32_Init(void* hwnd)
{
ImGuiIO& io = ImGui::GetIO();
IM_ASSERT(io.BackendPlatformUserData == NULL && "Already initialized a platform backend!");
INT64 perf_frequency, perf_counter;
if (!::QueryPerformanceFrequency((LARGE_INTEGER*)&perf_frequency))
return false;
if (!::QueryPerformanceCounter((LARGE_INTEGER*)&perf_counter))
return false;
// Setup backend capabilities flags
ImGui_ImplWin32_Data* bd = IM_NEW(ImGui_ImplWin32_Data)();
io.BackendPlatformUserData = (void*)bd;
io.BackendPlatformName = "imgui_impl_win32";
io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
bd->hWnd = (HWND)hwnd;
bd->WantUpdateHasGamepad = true;
bd->TicksPerSecond = perf_frequency;
bd->Time = perf_counter;
bd->LastMouseCursor = ImGuiMouseCursor_COUNT;
// Set platform dependent data in viewport
ImGui::GetMainViewport()->PlatformHandleRaw = (void*)hwnd;
// Dynamically load XInput library
#ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
const char* xinput_dll_names[] =
{
"xinput1_4.dll", // Windows 8+
"xinput1_3.dll", // DirectX SDK
"xinput9_1_0.dll", // Windows Vista, Windows 7
"xinput1_2.dll", // DirectX SDK
"xinput1_1.dll" // DirectX SDK
};
for (int n = 0; n < IM_ARRAYSIZE(xinput_dll_names); n++)
if (HMODULE dll = ::LoadLibraryA(xinput_dll_names[n]))
{
bd->XInputDLL = dll;
bd->XInputGetCapabilities = (PFN_XInputGetCapabilities)::GetProcAddress(dll, "XInputGetCapabilities");
bd->XInputGetState = (PFN_XInputGetState)::GetProcAddress(dll, "XInputGetState");
break;
}
#endif // IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
return true;
}
void ImGui_ImplWin32_Shutdown()
{
ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
IM_ASSERT(bd != NULL && "No platform backend to shutdown, or already shutdown?");
ImGuiIO& io = ImGui::GetIO();
// Unload XInput library
#ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
if (bd->XInputDLL)
::FreeLibrary(bd->XInputDLL);
#endif // IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
io.BackendPlatformName = NULL;
io.BackendPlatformUserData = NULL;
IM_DELETE(bd);
}
static bool ImGui_ImplWin32_UpdateMouseCursor()
{
ImGuiIO& io = ImGui::GetIO();
if (io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange)
return false;
ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor)
{
// Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
::SetCursor(NULL);
}
else
{
// Show OS mouse cursor
LPTSTR win32_cursor = IDC_ARROW;
switch (imgui_cursor)
{
case ImGuiMouseCursor_Arrow: win32_cursor = IDC_ARROW; break;
case ImGuiMouseCursor_TextInput: win32_cursor = IDC_IBEAM; break;
case ImGuiMouseCursor_ResizeAll: win32_cursor = IDC_SIZEALL; break;
case ImGuiMouseCursor_ResizeEW: win32_cursor = IDC_SIZEWE; break;
case ImGuiMouseCursor_ResizeNS: win32_cursor = IDC_SIZENS; break;
case ImGuiMouseCursor_ResizeNESW: win32_cursor = IDC_SIZENESW; break;
case ImGuiMouseCursor_ResizeNWSE: win32_cursor = IDC_SIZENWSE; break;
case ImGuiMouseCursor_Hand: win32_cursor = IDC_HAND; break;
case ImGuiMouseCursor_NotAllowed: win32_cursor = IDC_NO; break;
}
::SetCursor(::LoadCursor(NULL, win32_cursor));
}
return true;
}
static bool IsVkDown(int vk)
{
return (::GetKeyState(vk) & 0x8000) != 0;
}
static void ImGui_ImplWin32_AddKeyEvent(ImGuiKey key, bool down, int native_keycode, int native_scancode = -1)
{
ImGuiIO& io = ImGui::GetIO();
io.AddKeyEvent(key, down);
io.SetKeyEventNativeData(key, native_keycode, native_scancode); // To support legacy indexing (<1.87 user code)
IM_UNUSED(native_scancode);
}
static void ImGui_ImplWin32_ProcessKeyEventsWorkarounds()
{
// Left & right Shift keys: when both are pressed together, Windows tend to not generate the WM_KEYUP event for the first released one.
if (ImGui::IsKeyDown(ImGuiKey_LeftShift) && !IsVkDown(VK_LSHIFT))
ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftShift, false, VK_LSHIFT);
if (ImGui::IsKeyDown(ImGuiKey_RightShift) && !IsVkDown(VK_RSHIFT))
ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightShift, false, VK_RSHIFT);
// Sometimes WM_KEYUP for Win key is not passed down to the app (e.g. for Win+V on some setups, according to GLFW).
if (ImGui::IsKeyDown(ImGuiKey_LeftSuper) && !IsVkDown(VK_LWIN))
ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftSuper, false, VK_LWIN);
if (ImGui::IsKeyDown(ImGuiKey_RightSuper) && !IsVkDown(VK_RWIN))
ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightSuper, false, VK_RWIN);
}
static void ImGui_ImplWin32_UpdateKeyModifiers()
{
ImGuiIO& io = ImGui::GetIO();
io.AddKeyEvent(ImGuiKey_ModCtrl, IsVkDown(VK_CONTROL));
io.AddKeyEvent(ImGuiKey_ModShift, IsVkDown(VK_SHIFT));
io.AddKeyEvent(ImGuiKey_ModAlt, IsVkDown(VK_MENU));
io.AddKeyEvent(ImGuiKey_ModSuper, IsVkDown(VK_APPS));
}
static void ImGui_ImplWin32_UpdateMouseData()
{
ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
ImGuiIO& io = ImGui::GetIO();
IM_ASSERT(bd->hWnd != 0);
const bool is_app_focused = (::GetForegroundWindow() == bd->hWnd);
if (is_app_focused)
{
// (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
if (io.WantSetMousePos)
{
POINT pos = { (int)io.MousePos.x, (int)io.MousePos.y };
if (::ClientToScreen(bd->hWnd, &pos))
::SetCursorPos(pos.x, pos.y);
}
// (Optional) Fallback to provide mouse position when focused (WM_MOUSEMOVE already provides this when hovered or captured)
if (!io.WantSetMousePos && !bd->MouseTracked)
{
POINT pos;
if (::GetCursorPos(&pos) && ::ScreenToClient(bd->hWnd, &pos))
io.AddMousePosEvent((float)pos.x, (float)pos.y);
}
}
}
// Gamepad navigation mapping
static void ImGui_ImplWin32_UpdateGamepads()
{
#ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
ImGuiIO& io = ImGui::GetIO();
ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0)
return;
// Calling XInputGetState() every frame on disconnected gamepads is unfortunately too slow.
// Instead we refresh gamepad availability by calling XInputGetCapabilities() _only_ after receiving WM_DEVICECHANGE.
if (bd->WantUpdateHasGamepad)
{
XINPUT_CAPABILITIES caps = {};
bd->HasGamepad = bd->XInputGetCapabilities ? (bd->XInputGetCapabilities(0, XINPUT_FLAG_GAMEPAD, &caps) == ERROR_SUCCESS) : false;
bd->WantUpdateHasGamepad = false;
}
io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
XINPUT_STATE xinput_state;
XINPUT_GAMEPAD& gamepad = xinput_state.Gamepad;
if (!bd->HasGamepad || bd->XInputGetState == NULL || bd->XInputGetState(0, &xinput_state) != ERROR_SUCCESS)
return;
io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
#define IM_SATURATE(V) (V < 0.0f ? 0.0f : V > 1.0f ? 1.0f : V)
#define MAP_BUTTON(KEY_NO, BUTTON_ENUM) { io.AddKeyEvent(KEY_NO, (gamepad.wButtons & BUTTON_ENUM) != 0); }
#define MAP_ANALOG(KEY_NO, VALUE, V0, V1) { float vn = (float)(VALUE - V0) / (float)(V1 - V0); io.AddKeyAnalogEvent(KEY_NO, vn > 0.10f, IM_SATURATE(vn)); }
MAP_BUTTON(ImGuiKey_GamepadStart, XINPUT_GAMEPAD_START);
MAP_BUTTON(ImGuiKey_GamepadBack, XINPUT_GAMEPAD_BACK);
MAP_BUTTON(ImGuiKey_GamepadFaceDown, XINPUT_GAMEPAD_A);
MAP_BUTTON(ImGuiKey_GamepadFaceRight, XINPUT_GAMEPAD_B);
MAP_BUTTON(ImGuiKey_GamepadFaceLeft, XINPUT_GAMEPAD_X);
MAP_BUTTON(ImGuiKey_GamepadFaceUp, XINPUT_GAMEPAD_Y);
MAP_BUTTON(ImGuiKey_GamepadDpadLeft, XINPUT_GAMEPAD_DPAD_LEFT);
MAP_BUTTON(ImGuiKey_GamepadDpadRight, XINPUT_GAMEPAD_DPAD_RIGHT);
MAP_BUTTON(ImGuiKey_GamepadDpadUp, XINPUT_GAMEPAD_DPAD_UP);
MAP_BUTTON(ImGuiKey_GamepadDpadDown, XINPUT_GAMEPAD_DPAD_DOWN);
MAP_BUTTON(ImGuiKey_GamepadL1, XINPUT_GAMEPAD_LEFT_SHOULDER);
MAP_BUTTON(ImGuiKey_GamepadR1, XINPUT_GAMEPAD_RIGHT_SHOULDER);
MAP_ANALOG(ImGuiKey_GamepadL2, gamepad.bLeftTrigger, XINPUT_GAMEPAD_TRIGGER_THRESHOLD, 255);
MAP_ANALOG(ImGuiKey_GamepadR2, gamepad.bRightTrigger, XINPUT_GAMEPAD_TRIGGER_THRESHOLD, 255);
MAP_BUTTON(ImGuiKey_GamepadL3, XINPUT_GAMEPAD_LEFT_THUMB);
MAP_BUTTON(ImGuiKey_GamepadR3, XINPUT_GAMEPAD_RIGHT_THUMB);
MAP_ANALOG(ImGuiKey_GamepadLStickLeft, gamepad.sThumbLX, -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, -32768);
MAP_ANALOG(ImGuiKey_GamepadLStickRight, gamepad.sThumbLX, +XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, +32767);
MAP_ANALOG(ImGuiKey_GamepadLStickUp, gamepad.sThumbLY, +XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, +32767);
MAP_ANALOG(ImGuiKey_GamepadLStickDown, gamepad.sThumbLY, -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, -32768);
MAP_ANALOG(ImGuiKey_GamepadRStickLeft, gamepad.sThumbRX, -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, -32768);
MAP_ANALOG(ImGuiKey_GamepadRStickRight, gamepad.sThumbRX, +XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, +32767);
MAP_ANALOG(ImGuiKey_GamepadRStickUp, gamepad.sThumbRY, +XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, +32767);
MAP_ANALOG(ImGuiKey_GamepadRStickDown, gamepad.sThumbRY, -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, -32768);
#undef MAP_BUTTON
#undef MAP_ANALOG
#endif // #ifndef IMGUI_IMPL_WIN32_DISABLE_GAMEPAD
}
void ImGui_ImplWin32_NewFrame()
{
ImGuiIO& io = ImGui::GetIO();
ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
IM_ASSERT(bd != NULL && "Did you call ImGui_ImplWin32_Init()?");
// Setup display size (every frame to accommodate for window resizing)
RECT rect = { 0, 0, 0, 0 };
::GetClientRect(bd->hWnd, &rect);
io.DisplaySize = ImVec2((float)(rect.right - rect.left), (float)(rect.bottom - rect.top));
// Setup time step
INT64 current_time = 0;
::QueryPerformanceCounter((LARGE_INTEGER*)&current_time);
io.DeltaTime = (float)(current_time - bd->Time) / bd->TicksPerSecond;
bd->Time = current_time;
// Update OS mouse position
ImGui_ImplWin32_UpdateMouseData();
// Process workarounds for known Windows key handling issues
ImGui_ImplWin32_ProcessKeyEventsWorkarounds();
// Update OS mouse cursor with the cursor requested by imgui
ImGuiMouseCursor mouse_cursor = io.MouseDrawCursor ? ImGuiMouseCursor_None : ImGui::GetMouseCursor();
if (bd->LastMouseCursor != mouse_cursor)
{
bd->LastMouseCursor = mouse_cursor;
ImGui_ImplWin32_UpdateMouseCursor();
}
// Update game controllers (if enabled and available)
ImGui_ImplWin32_UpdateGamepads();
}
// There is no distinct VK_xxx for keypad enter, instead it is VK_RETURN + KF_EXTENDED, we assign it an arbitrary value to make code more readable (VK_ codes go up to 255)
#define IM_VK_KEYPAD_ENTER (VK_RETURN + 256)
// Map VK_xxx to ImGuiKey_xxx.
static ImGuiKey ImGui_ImplWin32_VirtualKeyToImGuiKey(WPARAM wParam)
{
switch (wParam)
{
case VK_TAB: return ImGuiKey_Tab;
case VK_LEFT: return ImGuiKey_LeftArrow;
case VK_RIGHT: return ImGuiKey_RightArrow;
case VK_UP: return ImGuiKey_UpArrow;
case VK_DOWN: return ImGuiKey_DownArrow;
case VK_PRIOR: return ImGuiKey_PageUp;
case VK_NEXT: return ImGuiKey_PageDown;
case VK_HOME: return ImGuiKey_Home;
case VK_END: return ImGuiKey_End;
case VK_INSERT: return ImGuiKey_Insert;
case VK_DELETE: return ImGuiKey_Delete;
case VK_BACK: return ImGuiKey_Backspace;
case VK_SPACE: return ImGuiKey_Space;
case VK_RETURN: return ImGuiKey_Enter;
case VK_ESCAPE: return ImGuiKey_Escape;
case VK_OEM_7: return ImGuiKey_Apostrophe;
case VK_OEM_COMMA: return ImGuiKey_Comma;
case VK_OEM_MINUS: return ImGuiKey_Minus;
case VK_OEM_PERIOD: return ImGuiKey_Period;
case VK_OEM_2: return ImGuiKey_Slash;
case VK_OEM_1: return ImGuiKey_Semicolon;
case VK_OEM_PLUS: return ImGuiKey_Equal;
case VK_OEM_4: return ImGuiKey_LeftBracket;
case VK_OEM_5: return ImGuiKey_Backslash;
case VK_OEM_6: return ImGuiKey_RightBracket;
case VK_OEM_3: return ImGuiKey_GraveAccent;
case VK_CAPITAL: return ImGuiKey_CapsLock;
case VK_SCROLL: return ImGuiKey_ScrollLock;
case VK_NUMLOCK: return ImGuiKey_NumLock;
case VK_SNAPSHOT: return ImGuiKey_PrintScreen;
case VK_PAUSE: return ImGuiKey_Pause;
case VK_NUMPAD0: return ImGuiKey_Keypad0;
case VK_NUMPAD1: return ImGuiKey_Keypad1;
case VK_NUMPAD2: return ImGuiKey_Keypad2;
case VK_NUMPAD3: return ImGuiKey_Keypad3;
case VK_NUMPAD4: return ImGuiKey_Keypad4;
case VK_NUMPAD5: return ImGuiKey_Keypad5;
case VK_NUMPAD6: return ImGuiKey_Keypad6;
case VK_NUMPAD7: return ImGuiKey_Keypad7;
case VK_NUMPAD8: return ImGuiKey_Keypad8;
case VK_NUMPAD9: return ImGuiKey_Keypad9;
case VK_DECIMAL: return ImGuiKey_KeypadDecimal;
case VK_DIVIDE: return ImGuiKey_KeypadDivide;
case VK_MULTIPLY: return ImGuiKey_KeypadMultiply;
case VK_SUBTRACT: return ImGuiKey_KeypadSubtract;
case VK_ADD: return ImGuiKey_KeypadAdd;
case IM_VK_KEYPAD_ENTER: return ImGuiKey_KeypadEnter;
case VK_LSHIFT: return ImGuiKey_LeftShift;
case VK_LCONTROL: return ImGuiKey_LeftCtrl;
case VK_LMENU: return ImGuiKey_LeftAlt;
case VK_LWIN: return ImGuiKey_LeftSuper;
case VK_RSHIFT: return ImGuiKey_RightShift;
case VK_RCONTROL: return ImGuiKey_RightCtrl;
case VK_RMENU: return ImGuiKey_RightAlt;
case VK_RWIN: return ImGuiKey_RightSuper;
case VK_APPS: return ImGuiKey_Menu;
case '0': return ImGuiKey_0;
case '1': return ImGuiKey_1;
case '2': return ImGuiKey_2;
case '3': return ImGuiKey_3;
case '4': return ImGuiKey_4;
case '5': return ImGuiKey_5;
case '6': return ImGuiKey_6;
case '7': return ImGuiKey_7;
case '8': return ImGuiKey_8;
case '9': return ImGuiKey_9;
case 'A': return ImGuiKey_A;
case 'B': return ImGuiKey_B;
case 'C': return ImGuiKey_C;
case 'D': return ImGuiKey_D;
case 'E': return ImGuiKey_E;
case 'F': return ImGuiKey_F;
case 'G': return ImGuiKey_G;
case 'H': return ImGuiKey_H;
case 'I': return ImGuiKey_I;
case 'J': return ImGuiKey_J;
case 'K': return ImGuiKey_K;
case 'L': return ImGuiKey_L;
case 'M': return ImGuiKey_M;
case 'N': return ImGuiKey_N;
case 'O': return ImGuiKey_O;
case 'P': return ImGuiKey_P;
case 'Q': return ImGuiKey_Q;
case 'R': return ImGuiKey_R;
case 'S': return ImGuiKey_S;
case 'T': return ImGuiKey_T;
case 'U': return ImGuiKey_U;
case 'V': return ImGuiKey_V;
case 'W': return ImGuiKey_W;
case 'X': return ImGuiKey_X;
case 'Y': return ImGuiKey_Y;
case 'Z': return ImGuiKey_Z;
case VK_F1: return ImGuiKey_F1;
case VK_F2: return ImGuiKey_F2;
case VK_F3: return ImGuiKey_F3;
case VK_F4: return ImGuiKey_F4;
case VK_F5: return ImGuiKey_F5;
case VK_F6: return ImGuiKey_F6;
case VK_F7: return ImGuiKey_F7;
case VK_F8: return ImGuiKey_F8;
case VK_F9: return ImGuiKey_F9;
case VK_F10: return ImGuiKey_F10;
case VK_F11: return ImGuiKey_F11;
case VK_F12: return ImGuiKey_F12;
default: return ImGuiKey_None;
}
}
// Allow compilation with old Windows SDK. MinGW doesn't have default _WIN32_WINNT/WINVER versions.
#ifndef WM_MOUSEHWHEEL
#define WM_MOUSEHWHEEL 0x020E
#endif
#ifndef DBT_DEVNODES_CHANGED
#define DBT_DEVNODES_CHANGED 0x0007
#endif
// Win32 message handler (process Win32 mouse/keyboard inputs, etc.)
// Call from your application's message handler.
// When implementing your own backend, you can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if Dear ImGui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
// Generally you may always pass all inputs to Dear ImGui, and hide them from your application based on those two flags.
// PS: In this Win32 handler, we use the capture API (GetCapture/SetCapture/ReleaseCapture) to be able to read mouse coordinates when dragging mouse outside of our window bounds.
// PS: We treat DBLCLK messages as regular mouse down messages, so this code will work on windows classes that have the CS_DBLCLKS flag set. Our own example app code doesn't set this flag.
#if 0
// Copy this line into your .cpp file to forward declare the function.
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
#endif
IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (ImGui::GetCurrentContext() == NULL)
return 0;
ImGuiIO& io = ImGui::GetIO();
ImGui_ImplWin32_Data* bd = ImGui_ImplWin32_GetBackendData();
switch (msg)
{
case WM_MOUSEMOVE:
// We need to call TrackMouseEvent in order to receive WM_MOUSELEAVE events
bd->MouseHwnd = hwnd;
if (!bd->MouseTracked)
{
TRACKMOUSEEVENT tme = { sizeof(tme), TME_LEAVE, hwnd, 0 };
::TrackMouseEvent(&tme);
bd->MouseTracked = true;
}
io.AddMousePosEvent((float)GET_X_LPARAM(lParam), (float)GET_Y_LPARAM(lParam));
break;
case WM_MOUSELEAVE:
if (bd->MouseHwnd == hwnd)
bd->MouseHwnd = NULL;
bd->MouseTracked = false;
io.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
break;
case WM_LBUTTONDOWN: case WM_LBUTTONDBLCLK:
case WM_RBUTTONDOWN: case WM_RBUTTONDBLCLK:
case WM_MBUTTONDOWN: case WM_MBUTTONDBLCLK:
case WM_XBUTTONDOWN: case WM_XBUTTONDBLCLK:
{
int button = 0;
if (msg == WM_LBUTTONDOWN || msg == WM_LBUTTONDBLCLK) { button = 0; }
if (msg == WM_RBUTTONDOWN || msg == WM_RBUTTONDBLCLK) { button = 1; }
if (msg == WM_MBUTTONDOWN || msg == WM_MBUTTONDBLCLK) { button = 2; }
if (msg == WM_XBUTTONDOWN || msg == WM_XBUTTONDBLCLK) { button = (GET_XBUTTON_WPARAM(wParam) == XBUTTON1) ? 3 : 4; }
if (bd->MouseButtonsDown == 0 && ::GetCapture() == NULL)
::SetCapture(hwnd);
bd->MouseButtonsDown |= 1 << button;
io.AddMouseButtonEvent(button, true);
return 0;
}
case WM_LBUTTONUP:
case WM_RBUTTONUP:
case WM_MBUTTONUP:
case WM_XBUTTONUP:
{
int button = 0;
if (msg == WM_LBUTTONUP) { button = 0; }
if (msg == WM_RBUTTONUP) { button = 1; }
if (msg == WM_MBUTTONUP) { button = 2; }
if (msg == WM_XBUTTONUP) { button = (GET_XBUTTON_WPARAM(wParam) == XBUTTON1) ? 3 : 4; }
bd->MouseButtonsDown &= ~(1 << button);
if (bd->MouseButtonsDown == 0 && ::GetCapture() == hwnd)
::ReleaseCapture();
io.AddMouseButtonEvent(button, false);
return 0;
}
case WM_MOUSEWHEEL:
io.AddMouseWheelEvent(0.0f, (float)GET_WHEEL_DELTA_WPARAM(wParam) / (float)WHEEL_DELTA);
return 0;
case WM_MOUSEHWHEEL:
io.AddMouseWheelEvent((float)GET_WHEEL_DELTA_WPARAM(wParam) / (float)WHEEL_DELTA, 0.0f);
return 0;
case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
{
const bool is_key_down = (msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN);
if (wParam < 256)
{
// Submit modifiers
ImGui_ImplWin32_UpdateKeyModifiers();
// Obtain virtual key code
// (keypad enter doesn't have its own... VK_RETURN with KF_EXTENDED flag means keypad enter, see IM_VK_KEYPAD_ENTER definition for details, it is mapped to ImGuiKey_KeyPadEnter.)
int vk = (int)wParam;
if ((wParam == VK_RETURN) && (HIWORD(lParam) & KF_EXTENDED))
vk = IM_VK_KEYPAD_ENTER;
// Submit key event
const ImGuiKey key = ImGui_ImplWin32_VirtualKeyToImGuiKey(vk);
const int scancode = (int)LOBYTE(HIWORD(lParam));
if (key != ImGuiKey_None)
ImGui_ImplWin32_AddKeyEvent(key, is_key_down, vk, scancode);
// Submit individual left/right modifier events
if (vk == VK_SHIFT)
{
// Important: Shift keys tend to get stuck when pressed together, missing key-up events are corrected in ImGui_ImplWin32_ProcessKeyEventsWorkarounds()
if (IsVkDown(VK_LSHIFT) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftShift, is_key_down, VK_LSHIFT, scancode); }
if (IsVkDown(VK_RSHIFT) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightShift, is_key_down, VK_RSHIFT, scancode); }
}
else if (vk == VK_CONTROL)
{
if (IsVkDown(VK_LCONTROL) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftCtrl, is_key_down, VK_LCONTROL, scancode); }
if (IsVkDown(VK_RCONTROL) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightCtrl, is_key_down, VK_RCONTROL, scancode); }
}
else if (vk == VK_MENU)
{
if (IsVkDown(VK_LMENU) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_LeftAlt, is_key_down, VK_LMENU, scancode); }
if (IsVkDown(VK_RMENU) == is_key_down) { ImGui_ImplWin32_AddKeyEvent(ImGuiKey_RightAlt, is_key_down, VK_RMENU, scancode); }
}
}
return 0;
}
case WM_SETFOCUS:
case WM_KILLFOCUS:
io.AddFocusEvent(msg == WM_SETFOCUS);
return 0;
case WM_CHAR:
// You can also use ToAscii()+GetKeyboardState() to retrieve characters.
if (wParam > 0 && wParam < 0x10000)
io.AddInputCharacterUTF16((unsigned short)wParam);
return 0;
case WM_SETCURSOR:
if (LOWORD(lParam) == HTCLIENT && ImGui_ImplWin32_UpdateMouseCursor())
return 1;
return 0;
case WM_DEVICECHANGE:
if ((UINT)wParam == DBT_DEVNODES_CHANGED)
bd->WantUpdateHasGamepad = true;
return 0;
}
return 0;
}
//--------------------------------------------------------------------------------------------------------
// DPI-related helpers (optional)
//--------------------------------------------------------------------------------------------------------
// - Use to enable DPI awareness without having to create an application manifest.
// - Your own app may already do this via a manifest or explicit calls. This is mostly useful for our examples/ apps.
// - In theory we could call simple functions from Windows SDK such as SetProcessDPIAware(), SetProcessDpiAwareness(), etc.
// but most of the functions provided by Microsoft require Windows 8.1/10+ SDK at compile time and Windows 8/10+ at runtime,
// neither we want to require the user to have. So we dynamically select and load those functions to avoid dependencies.
//---------------------------------------------------------------------------------------------------------
// This is the scheme successfully used by GLFW (from which we borrowed some of the code) and other apps aiming to be highly portable.
// ImGui_ImplWin32_EnableDpiAwareness() is just a helper called by main.cpp, we don't call it automatically.
// If you are trying to implement your own backend for your own engine, you may ignore that noise.
//---------------------------------------------------------------------------------------------------------
// Perform our own check with RtlVerifyVersionInfo() instead of using functions from <VersionHelpers.h> as they
// require a manifest to be functional for checks above 8.1. See https://github.com/ocornut/imgui/issues/4200
static BOOL _IsWindowsVersionOrGreater(WORD major, WORD minor, WORD)
{
typedef LONG(WINAPI* PFN_RtlVerifyVersionInfo)(OSVERSIONINFOEXW*, ULONG, ULONGLONG);
static PFN_RtlVerifyVersionInfo RtlVerifyVersionInfoFn = NULL;
if (RtlVerifyVersionInfoFn == NULL)
if (HMODULE ntdllModule = ::GetModuleHandleA("ntdll.dll"))
RtlVerifyVersionInfoFn = (PFN_RtlVerifyVersionInfo)GetProcAddress(ntdllModule, "RtlVerifyVersionInfo");
if (RtlVerifyVersionInfoFn == NULL)
return FALSE;
RTL_OSVERSIONINFOEXW versionInfo = { };
ULONGLONG conditionMask = 0;
versionInfo.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
versionInfo.dwMajorVersion = major;
versionInfo.dwMinorVersion = minor;
VER_SET_CONDITION(conditionMask, VER_MAJORVERSION, VER_GREATER_EQUAL);
VER_SET_CONDITION(conditionMask, VER_MINORVERSION, VER_GREATER_EQUAL);
return (RtlVerifyVersionInfoFn(&versionInfo, VER_MAJORVERSION | VER_MINORVERSION, conditionMask) == 0) ? TRUE : FALSE;
}
#define _IsWindowsVistaOrGreater() _IsWindowsVersionOrGreater(HIBYTE(0x0600), LOBYTE(0x0600), 0) // _WIN32_WINNT_VISTA
#define _IsWindows8OrGreater() _IsWindowsVersionOrGreater(HIBYTE(0x0602), LOBYTE(0x0602), 0) // _WIN32_WINNT_WIN8
#define _IsWindows8Point1OrGreater() _IsWindowsVersionOrGreater(HIBYTE(0x0603), LOBYTE(0x0603), 0) // _WIN32_WINNT_WINBLUE
#define _IsWindows10OrGreater() _IsWindowsVersionOrGreater(HIBYTE(0x0A00), LOBYTE(0x0A00), 0) // _WIN32_WINNT_WINTHRESHOLD / _WIN32_WINNT_WIN10
#ifndef DPI_ENUMS_DECLARED
typedef enum { PROCESS_DPI_UNAWARE = 0, PROCESS_SYSTEM_DPI_AWARE = 1, PROCESS_PER_MONITOR_DPI_AWARE = 2 } PROCESS_DPI_AWARENESS;
typedef enum { MDT_EFFECTIVE_DPI = 0, MDT_ANGULAR_DPI = 1, MDT_RAW_DPI = 2, MDT_DEFAULT = MDT_EFFECTIVE_DPI } MONITOR_DPI_TYPE;
#endif
#ifndef _DPI_AWARENESS_CONTEXTS_
DECLARE_HANDLE(DPI_AWARENESS_CONTEXT);
#define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE (DPI_AWARENESS_CONTEXT)-3
#endif
#ifndef DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
#define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 (DPI_AWARENESS_CONTEXT)-4
#endif
typedef HRESULT(WINAPI* PFN_SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS); // Shcore.lib + dll, Windows 8.1+
typedef HRESULT(WINAPI* PFN_GetDpiForMonitor)(HMONITOR, MONITOR_DPI_TYPE, UINT*, UINT*); // Shcore.lib + dll, Windows 8.1+
typedef DPI_AWARENESS_CONTEXT(WINAPI* PFN_SetThreadDpiAwarenessContext)(DPI_AWARENESS_CONTEXT); // User32.lib + dll, Windows 10 v1607+ (Creators Update)
// Helper function to enable DPI awareness without setting up a manifest
void ImGui_ImplWin32_EnableDpiAwareness()
{
if (_IsWindows10OrGreater())
{
static HINSTANCE user32_dll = ::LoadLibraryA("user32.dll"); // Reference counted per-process
if (PFN_SetThreadDpiAwarenessContext SetThreadDpiAwarenessContextFn = (PFN_SetThreadDpiAwarenessContext)::GetProcAddress(user32_dll, "SetThreadDpiAwarenessContext"))
{
SetThreadDpiAwarenessContextFn(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
return;
}
}
if (_IsWindows8Point1OrGreater())
{
static HINSTANCE shcore_dll = ::LoadLibraryA("shcore.dll"); // Reference counted per-process
if (PFN_SetProcessDpiAwareness SetProcessDpiAwarenessFn = (PFN_SetProcessDpiAwareness)::GetProcAddress(shcore_dll, "SetProcessDpiAwareness"))
{
SetProcessDpiAwarenessFn(PROCESS_PER_MONITOR_DPI_AWARE);
return;
}
}
#if _WIN32_WINNT >= 0x0600
::SetProcessDPIAware();
#endif
}
#if defined(_MSC_VER) && !defined(NOGDI)
#pragma comment(lib, "gdi32") // Link with gdi32.lib for GetDeviceCaps(). MinGW will require linking with '-lgdi32'
#endif
float ImGui_ImplWin32_GetDpiScaleForMonitor(void* monitor)
{
UINT xdpi = 96, ydpi = 96;
if (_IsWindows8Point1OrGreater())
{
static HINSTANCE shcore_dll = ::LoadLibraryA("shcore.dll"); // Reference counted per-process
static PFN_GetDpiForMonitor GetDpiForMonitorFn = NULL;
if (GetDpiForMonitorFn == NULL && shcore_dll != NULL)
GetDpiForMonitorFn = (PFN_GetDpiForMonitor)::GetProcAddress(shcore_dll, "GetDpiForMonitor");
if (GetDpiForMonitorFn != NULL)
{
GetDpiForMonitorFn((HMONITOR)monitor, MDT_EFFECTIVE_DPI, &xdpi, &ydpi);
IM_ASSERT(xdpi == ydpi); // Please contact me if you hit this assert!
return xdpi / 96.0f;
}
}
#ifndef NOGDI
const HDC dc = ::GetDC(NULL);
xdpi = ::GetDeviceCaps(dc, LOGPIXELSX);
ydpi = ::GetDeviceCaps(dc, LOGPIXELSY);
IM_ASSERT(xdpi == ydpi); // Please contact me if you hit this assert!
::ReleaseDC(NULL, dc);
#endif
return xdpi / 96.0f;
}
float ImGui_ImplWin32_GetDpiScaleForHwnd(void* hwnd)
{
HMONITOR monitor = ::MonitorFromWindow((HWND)hwnd, MONITOR_DEFAULTTONEAREST);
return ImGui_ImplWin32_GetDpiScaleForMonitor(monitor);
}
//---------------------------------------------------------------------------------------------------------
// Transparency related helpers (optional)
//--------------------------------------------------------------------------------------------------------
#if defined(_MSC_VER)
#pragma comment(lib, "dwmapi") // Link with dwmapi.lib. MinGW will require linking with '-ldwmapi'
#endif
// [experimental]
// Borrowed from GLFW's function updateFramebufferTransparency() in src/win32_window.c
// (the Dwm* functions are Vista era functions but we are borrowing logic from GLFW)
void ImGui_ImplWin32_EnableAlphaCompositing(void* hwnd)
{
if (!_IsWindowsVistaOrGreater())
return;
BOOL composition;
if (FAILED(::DwmIsCompositionEnabled(&composition)) || !composition)
return;
BOOL opaque;
DWORD color;
if (_IsWindows8OrGreater() || (SUCCEEDED(::DwmGetColorizationColor(&color, &opaque)) && !opaque))
{
HRGN region = ::CreateRectRgn(0, 0, -1, -1);
DWM_BLURBEHIND bb = {};
bb.dwFlags = DWM_BB_ENABLE | DWM_BB_BLURREGION;
bb.hRgnBlur = region;
bb.fEnable = TRUE;
::DwmEnableBlurBehindWindow((HWND)hwnd, &bb);
::DeleteObject(region);
}
else
{
DWM_BLURBEHIND bb = {};
bb.dwFlags = DWM_BB_ENABLE;
::DwmEnableBlurBehindWindow((HWND)hwnd, &bb);
}
}
//---------------------------------------------------------------------------------------------------------
+42
View File
@@ -0,0 +1,42 @@
// dear imgui: Platform Backend for Windows (standard windows API for 32 and 64 bits applications)
// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
// Implemented features:
// [X] Platform: Clipboard support (for Win32 this is actually part of core dear imgui)
// [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy VK_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
// [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
#pragma once
#include "imgui.h" // IMGUI_IMPL_API
IMGUI_IMPL_API bool ImGui_ImplWin32_Init(void* hwnd);
IMGUI_IMPL_API void ImGui_ImplWin32_Shutdown();
IMGUI_IMPL_API void ImGui_ImplWin32_NewFrame();
// Win32 message handler your application need to call.
// - Intentionally commented out in a '#if 0' block to avoid dragging dependencies on <windows.h> from this helper.
// - You should COPY the line below into your .cpp code to forward declare the function and then you can call it.
#if 0
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
#endif
// DPI-related helpers (optional)
// - Use to enable DPI awareness without having to create an application manifest.
// - Your own app may already do this via a manifest or explicit calls. This is mostly useful for our examples/ apps.
// - In theory we could call simple functions from Windows SDK such as SetProcessDPIAware(), SetProcessDpiAwareness(), etc.
// but most of the functions provided by Microsoft require Windows 8.1/10+ SDK at compile time and Windows 8/10+ at runtime,
// neither we want to require the user to have. So we dynamically select and load those functions to avoid dependencies.
IMGUI_IMPL_API void ImGui_ImplWin32_EnableDpiAwareness();
IMGUI_IMPL_API float ImGui_ImplWin32_GetDpiScaleForHwnd(void* hwnd); // HWND hwnd
IMGUI_IMPL_API float ImGui_ImplWin32_GetDpiScaleForMonitor(void* monitor); // HMONITOR monitor
// Transparency related helpers (optional) [experimental]
// - Use to enable alpha compositing transparency with the desktop.
// - Use together with e.g. clearing your framebuffer with zero-alpha.
IMGUI_IMPL_API void ImGui_ImplWin32_EnableAlphaCompositing(void* hwnd); // HWND hwnd
File diff suppressed because it is too large. Load diff
+751
View File
@@ -0,0 +1,751 @@
// Mini memory editor for Dear ImGui (to embed in your game/tools)
// Get latest version at http://www.github.com/ocornut/imgui_club
//
// Right-click anywhere to access the Options menu!
// You can adjust the keyboard repeat delay/rate in ImGuiIO.
// The code assume a mono-space font for simplicity!
// If you don't use the default font, use ImGui::PushFont()/PopFont() to switch to a mono-space font before calling this.
//
// Usage:
// // Create a window and draw memory editor inside it:
// static MemoryEditor mem_edit_1;
// static char data[0x10000];
// size_t data_size = 0x10000;
// mem_edit_1.DrawWindow("Memory Editor", data, data_size);
//
// Usage:
// // If you already have a window, use DrawContents() instead:
// static MemoryEditor mem_edit_2;
// ImGui::Begin("MyWindow")
// mem_edit_2.DrawContents(this, sizeof(*this), (size_t)this);
// ImGui::End();
//
// Changelog:
// - v0.10: initial version
// - v0.23 (2017/08/17): added to github. fixed right-arrow triggering a byte write.
// - v0.24 (2018/06/02): changed DragInt("Rows" to use a %d data format (which is desirable since imgui 1.61).
// - v0.25 (2018/07/11): fixed wording: all occurrences of "Rows" renamed to "Columns".
// - v0.26 (2018/08/02): fixed clicking on hex region
// - v0.30 (2018/08/02): added data preview for common data types
// - v0.31 (2018/10/10): added OptUpperCaseHex option to select lower/upper casing display [@samhocevar]
// - v0.32 (2018/10/10): changed signatures to use void* instead of unsigned char*
// - v0.33 (2018/10/10): added OptShowOptions option to hide all the interactive option setting.
// - v0.34 (2019/05/07): binary preview now applies endianness setting [@nicolasnoble]
// - v0.35 (2020/01/29): using ImGuiDataType available since Dear ImGui 1.69.
// - v0.36 (2020/05/05): minor tweaks, minor refactor.
// - v0.40 (2020/10/04): fix misuse of ImGuiListClipper API, broke with Dear ImGui 1.79. made cursor position appears on left-side of edit box. option popup appears on mouse release. fix MSVC warnings where _CRT_SECURE_NO_WARNINGS wasn't working in recent versions.
// - v0.41 (2020/10/05): fix when using with keyboard/gamepad navigation enabled.
// - v0.42 (2020/10/14): fix for . character in ASCII view always being greyed out.
// - v0.43 (2021/03/12): added OptFooterExtraHeight to allow for custom drawing at the bottom of the editor [@leiradel]
// - v0.44 (2021/03/12): use ImGuiInputTextFlags_AlwaysOverwrite in 1.82 + fix hardcoded width.
//
// Todo/Bugs:
// - This is generally old code, it should work but please don't use this as reference!
// - Arrows are being sent to the InputText() about to disappear which for LeftArrow makes the text cursor appear at position 1 for one frame.
// - Using InputText() is awkward and maybe overkill here, consider implementing something custom.
#pragma once
#include <stdio.h> // sprintf, scanf
#include <stdint.h> // uint8_t, etc.
#ifdef _MSC_VER
#define _PRISizeT "I"
#define ImSnprintf _snprintf
#else
#define _PRISizeT "z"
#define ImSnprintf snprintf
#endif
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable: 4996) // warning C4996: 'sprintf': This function or variable may be unsafe.
#endif
struct MemoryEditor
{
enum DataFormat
{
DataFormat_Bin = 0,
DataFormat_Dec = 1,
DataFormat_Hex = 2,
DataFormat_COUNT
};
// Settings
bool Open; // = true // set to false when DrawWindow() was closed. ignore if not using DrawWindow().
bool ReadOnly; // = false // disable any editing.
int Cols; // = 16 // number of columns to display.
bool OptShowOptions; // = true // display options button/context menu. when disabled, options will be locked unless you provide your own UI for them.
bool OptShowDataPreview; // = false // display a footer previewing the decimal/binary/hex/float representation of the currently selected bytes.
bool OptShowHexII; // = false // display values in HexII representation instead of regular hexadecimal: hide null/zero bytes, ascii values as ".X".
bool OptShowAscii; // = true // display ASCII representation on the right side.
bool OptGreyOutZeroes; // = true // display null/zero bytes using the TextDisabled color.
bool OptUpperCaseHex; // = true // display hexadecimal values as "FF" instead of "ff".
int OptMidColsCount; // = 8 // set to 0 to disable extra spacing between every mid-cols.
int OptAddrDigitsCount; // = 0 // number of addr digits to display (default calculated based on maximum displayed addr).
float OptFooterExtraHeight; // = 0 // space to reserve at the bottom of the widget to add custom widgets
ImU32 HighlightColor; // // background color of highlighted bytes.
ImU8 (*ReadFn)(const ImU8* data, size_t off); // = 0 // optional handler to read bytes.
void (*WriteFn)(ImU8* data, size_t off, ImU8 d); // = 0 // optional handler to write bytes.
bool (*HighlightFn)(const ImU8* data, size_t off);//= 0 // optional handler to return Highlight property (to support non-contiguous highlighting).
// [Internal State]
bool ContentsWidthChanged;
size_t DataPreviewAddr;
size_t DataEditingAddr;
bool DataEditingTakeFocus;
char DataInputBuf[32];
char AddrInputBuf[32];
size_t GotoAddr;
size_t HighlightMin, HighlightMax;
int PreviewEndianess;
ImGuiDataType PreviewDataType;
MemoryEditor()
{
// Settings
Open = true;
ReadOnly = false;
Cols = 16;
OptShowOptions = true;
OptShowDataPreview = false;
OptShowHexII = false;
OptShowAscii = true;
OptGreyOutZeroes = true;
OptUpperCaseHex = true;
OptMidColsCount = 8;
OptAddrDigitsCount = 0;
OptFooterExtraHeight = 0.0f;
HighlightColor = IM_COL32(255, 255, 255, 50);
ReadFn = NULL;
WriteFn = NULL;
HighlightFn = NULL;
// State/Internals
ContentsWidthChanged = false;
DataPreviewAddr = DataEditingAddr = (size_t)-1;
DataEditingTakeFocus = false;
memset(DataInputBuf, 0, sizeof(DataInputBuf));
memset(AddrInputBuf, 0, sizeof(AddrInputBuf));
GotoAddr = (size_t)-1;
HighlightMin = HighlightMax = (size_t)-1;
PreviewEndianess = 0;
PreviewDataType = ImGuiDataType_S32;
}
void GotoAddrAndHighlight(size_t addr_min, size_t addr_max)
{
GotoAddr = addr_min;
HighlightMin = addr_min;
HighlightMax = addr_max;
}
struct Sizes
{
int AddrDigitsCount;
float LineHeight;
float GlyphWidth;
float HexCellWidth;
float SpacingBetweenMidCols;
float PosHexStart;
float PosHexEnd;
float PosAsciiStart;
float PosAsciiEnd;
float WindowWidth;
Sizes() { memset(this, 0, sizeof(*this)); }
};
void CalcSizes(Sizes& s, size_t mem_size, size_t base_display_addr)
{
ImGuiStyle& style = ImGui::GetStyle();
s.AddrDigitsCount = OptAddrDigitsCount;
if (s.AddrDigitsCount == 0)
for (size_t n = base_display_addr + mem_size - 1; n > 0; n >>= 4)
s.AddrDigitsCount++;
s.LineHeight = ImGui::GetTextLineHeight();
s.GlyphWidth = ImGui::CalcTextSize("F").x + 1; // We assume the font is mono-space
s.HexCellWidth = (float)(int)(s.GlyphWidth * 2.5f); // "FF " we include trailing space in the width to easily catch clicks everywhere
s.SpacingBetweenMidCols = (float)(int)(s.HexCellWidth * 0.25f); // Every OptMidColsCount columns we add a bit of extra spacing
s.PosHexStart = (s.AddrDigitsCount + 2) * s.GlyphWidth;
s.PosHexEnd = s.PosHexStart + (s.HexCellWidth * Cols);
s.PosAsciiStart = s.PosAsciiEnd = s.PosHexEnd;
if (OptShowAscii)
{
s.PosAsciiStart = s.PosHexEnd + s.GlyphWidth * 1;
if (OptMidColsCount > 0)
s.PosAsciiStart += (float)((Cols + OptMidColsCount - 1) / OptMidColsCount) * s.SpacingBetweenMidCols;
s.PosAsciiEnd = s.PosAsciiStart + Cols * s.GlyphWidth;
}
s.WindowWidth = s.PosAsciiEnd + style.ScrollbarSize + style.WindowPadding.x * 2 + s.GlyphWidth;
}
// Standalone Memory Editor window
void DrawWindow(const char* title, void* mem_data, size_t mem_size, size_t base_display_addr = 0x0000)
{
Sizes s;
CalcSizes(s, mem_size, base_display_addr);
ImGui::SetNextWindowSizeConstraints(ImVec2(0.0f, 0.0f), ImVec2(s.WindowWidth, FLT_MAX));
Open = true;
if (ImGui::Begin(title, &Open, ImGuiWindowFlags_NoScrollbar))
{
if (ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows) && ImGui::IsMouseReleased(ImGuiMouseButton_Right))
ImGui::OpenPopup("context");
DrawContents(mem_data, mem_size, base_display_addr);
if (ContentsWidthChanged)
{
CalcSizes(s, mem_size, base_display_addr);
ImGui::SetWindowSize(ImVec2(s.WindowWidth, ImGui::GetWindowSize().y));
}
}
ImGui::End();
}
// Memory Editor contents only
void DrawContents(void* mem_data_void, size_t mem_size, size_t base_display_addr = 0x0000)
{
if (Cols < 1)
Cols = 1;
ImU8* mem_data = (ImU8*)mem_data_void;
Sizes s;
CalcSizes(s, mem_size, base_display_addr);
ImGuiStyle& style = ImGui::GetStyle();
// We begin into our scrolling region with the 'ImGuiWindowFlags_NoMove' in order to prevent click from moving the window.
// This is used as a facility since our main click detection code doesn't assign an ActiveId so the click would normally be caught as a window-move.
const float height_separator = style.ItemSpacing.y;
float footer_height = OptFooterExtraHeight;
if (OptShowOptions)
footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1;
if (OptShowDataPreview)
footer_height += height_separator + ImGui::GetFrameHeightWithSpacing() * 1 + ImGui::GetTextLineHeightWithSpacing() * 3;
ImGui::BeginChild("##scrolling", ImVec2(0, -footer_height), false, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNav);
ImDrawList* draw_list = ImGui::GetWindowDrawList();
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
// We are not really using the clipper API correctly here, because we rely on visible_start_addr/visible_end_addr for our scrolling function.
const int line_total_count = (int)((mem_size + Cols - 1) / Cols);
ImGuiListClipper clipper;
clipper.Begin(line_total_count, s.LineHeight);
clipper.Step();
const size_t visible_start_addr = clipper.DisplayStart * Cols;
const size_t visible_end_addr = clipper.DisplayEnd * Cols;
bool data_next = false;
if (ReadOnly || DataEditingAddr >= mem_size)
DataEditingAddr = (size_t)-1;
if (DataPreviewAddr >= mem_size)
DataPreviewAddr = (size_t)-1;
size_t preview_data_type_size = OptShowDataPreview ? DataTypeGetSize(PreviewDataType) : 0;
size_t data_editing_addr_backup = DataEditingAddr;
size_t data_editing_addr_next = (size_t)-1;
if (DataEditingAddr != (size_t)-1)
{
// Move cursor but only apply on next frame so scrolling with be synchronized (because currently we can't change the scrolling while the window is being rendered)
if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_UpArrow)) && DataEditingAddr >= (size_t)Cols) { data_editing_addr_next = DataEditingAddr - Cols; DataEditingTakeFocus = true; }
else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_DownArrow)) && DataEditingAddr < mem_size - Cols) { data_editing_addr_next = DataEditingAddr + Cols; DataEditingTakeFocus = true; }
else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_LeftArrow)) && DataEditingAddr > 0) { data_editing_addr_next = DataEditingAddr - 1; DataEditingTakeFocus = true; }
else if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_RightArrow)) && DataEditingAddr < mem_size - 1) { data_editing_addr_next = DataEditingAddr + 1; DataEditingTakeFocus = true; }
}
if (data_editing_addr_next != (size_t)-1 && (data_editing_addr_next / Cols) != (data_editing_addr_backup / Cols))
{
// Track cursor movements
const int scroll_offset = ((int)(data_editing_addr_next / Cols) - (int)(data_editing_addr_backup / Cols));
const bool scroll_desired = (scroll_offset < 0 && data_editing_addr_next < visible_start_addr + Cols * 2) || (scroll_offset > 0 && data_editing_addr_next > visible_end_addr - Cols * 2);
if (scroll_desired)
ImGui::SetScrollY(ImGui::GetScrollY() + scroll_offset * s.LineHeight);
}
// Draw vertical separator
ImVec2 window_pos = ImGui::GetWindowPos();
if (OptShowAscii)
draw_list->AddLine(ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y), ImVec2(window_pos.x + s.PosAsciiStart - s.GlyphWidth, window_pos.y + 9999), ImGui::GetColorU32(ImGuiCol_Border));
const ImU32 color_text = ImGui::GetColorU32(ImGuiCol_Text);
const ImU32 color_disabled = OptGreyOutZeroes ? ImGui::GetColorU32(ImGuiCol_TextDisabled) : color_text;
const char* format_address = OptUpperCaseHex ? "%0*" _PRISizeT "X: " : "%0*" _PRISizeT "x: ";
const char* format_data = OptUpperCaseHex ? "%0*" _PRISizeT "X" : "%0*" _PRISizeT "x";
const char* format_byte = OptUpperCaseHex ? "%02X" : "%02x";
const char* format_byte_space = OptUpperCaseHex ? "%02X " : "%02x ";
for (int line_i = clipper.DisplayStart; line_i < clipper.DisplayEnd; line_i++) // display only visible lines
{
size_t addr = (size_t)(line_i * Cols);
ImGui::Text(format_address, s.AddrDigitsCount, base_display_addr + addr);
// Draw Hexadecimal
for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
{
float byte_pos_x = s.PosHexStart + s.HexCellWidth * n;
if (OptMidColsCount > 0)
byte_pos_x += (float)(n / OptMidColsCount) * s.SpacingBetweenMidCols;
ImGui::SameLine(byte_pos_x);
// Draw highlight
bool is_highlight_from_user_range = (addr >= HighlightMin && addr < HighlightMax);
bool is_highlight_from_user_func = (HighlightFn && HighlightFn(mem_data, addr));
bool is_highlight_from_preview = (addr >= DataPreviewAddr && addr < DataPreviewAddr + preview_data_type_size);
if (is_highlight_from_user_range || is_highlight_from_user_func || is_highlight_from_preview)
{
ImVec2 pos = ImGui::GetCursorScreenPos();
float highlight_width = s.GlyphWidth * 2;
bool is_next_byte_highlighted = (addr + 1 < mem_size) && ((HighlightMax != (size_t)-1 && addr + 1 < HighlightMax) || (HighlightFn && HighlightFn(mem_data, addr + 1)));
if (is_next_byte_highlighted || (n + 1 == Cols))
{
highlight_width = s.HexCellWidth;
if (OptMidColsCount > 0 && n > 0 && (n + 1) < Cols && ((n + 1) % OptMidColsCount) == 0)
highlight_width += s.SpacingBetweenMidCols;
}
draw_list->AddRectFilled(pos, ImVec2(pos.x + highlight_width, pos.y + s.LineHeight), HighlightColor);
}
if (DataEditingAddr == addr)
{
// Display text input on current byte
bool data_write = false;
ImGui::PushID((void*)addr);
if (DataEditingTakeFocus)
{
ImGui::SetKeyboardFocusHere();
ImGui::CaptureKeyboardFromApp(true);
sprintf(AddrInputBuf, format_data, s.AddrDigitsCount, base_display_addr + addr);
sprintf(DataInputBuf, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
}
struct UserData
{
// FIXME: We should have a way to retrieve the text edit cursor position more easily in the API, this is rather tedious. This is such a ugly mess we may be better off not using InputText() at all here.
static int Callback(ImGuiInputTextCallbackData* data)
{
UserData* user_data = (UserData*)data->UserData;
if (!data->HasSelection())
user_data->CursorPos = data->CursorPos;
if (data->SelectionStart == 0 && data->SelectionEnd == data->BufTextLen)
{
// When not editing a byte, always rewrite its content (this is a bit tricky, since InputText technically "owns" the master copy of the buffer we edit it in there)
data->DeleteChars(0, data->BufTextLen);
data->InsertChars(0, user_data->CurrentBufOverwrite);
data->SelectionStart = 0;
data->SelectionEnd = 2;
data->CursorPos = 0;
}
return 0;
}
char CurrentBufOverwrite[3]; // Input
int CursorPos; // Output
};
UserData user_data;
user_data.CursorPos = -1;
sprintf(user_data.CurrentBufOverwrite, format_byte, ReadFn ? ReadFn(mem_data, addr) : mem_data[addr]);
ImGuiInputTextFlags flags = ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_NoHorizontalScroll | ImGuiInputTextFlags_CallbackAlways;
#if IMGUI_VERSION_NUM >= 18104
flags |= ImGuiInputTextFlags_AlwaysOverwrite;
#else
flags |= ImGuiInputTextFlags_AlwaysInsertMode;
#endif
ImGui::SetNextItemWidth(s.GlyphWidth * 2);
if (ImGui::InputText("##data", DataInputBuf, IM_ARRAYSIZE(DataInputBuf), flags, UserData::Callback, &user_data))
data_write = data_next = true;
else if (!DataEditingTakeFocus && !ImGui::IsItemActive())
DataEditingAddr = data_editing_addr_next = (size_t)-1;
DataEditingTakeFocus = false;
if (user_data.CursorPos >= 2)
data_write = data_next = true;
if (data_editing_addr_next != (size_t)-1)
data_write = data_next = false;
unsigned int data_input_value = 0;
if (data_write && sscanf(DataInputBuf, "%X", &data_input_value) == 1)
{
if (WriteFn)
WriteFn(mem_data, addr, (ImU8)data_input_value);
else
mem_data[addr] = (ImU8)data_input_value;
}
ImGui::PopID();
}
else
{
// NB: The trailing space is not visible but ensure there's no gap that the mouse cannot click on.
ImU8 b = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];
if (OptShowHexII)
{
if ((b >= 32 && b < 128))
ImGui::Text(".%c ", b);
else if (b == 0xFF && OptGreyOutZeroes)
ImGui::TextDisabled("## ");
else if (b == 0x00)
ImGui::Text(" ");
else
ImGui::Text(format_byte_space, b);
}
else
{
if (b == 0 && OptGreyOutZeroes)
ImGui::TextDisabled("00 ");
else
ImGui::Text(format_byte_space, b);
}
if (!ReadOnly && ImGui::IsItemHovered() && ImGui::IsMouseClicked(0))
{
DataEditingTakeFocus = true;
data_editing_addr_next = addr;
}
}
}
if (OptShowAscii)
{
// Draw ASCII values
ImGui::SameLine(s.PosAsciiStart);
ImVec2 pos = ImGui::GetCursorScreenPos();
addr = line_i * Cols;
ImGui::PushID(line_i);
if (ImGui::InvisibleButton("ascii", ImVec2(s.PosAsciiEnd - s.PosAsciiStart, s.LineHeight)))
{
DataEditingAddr = DataPreviewAddr = addr + (size_t)((ImGui::GetIO().MousePos.x - pos.x) / s.GlyphWidth);
DataEditingTakeFocus = true;
}
ImGui::PopID();
for (int n = 0; n < Cols && addr < mem_size; n++, addr++)
{
if (addr == DataEditingAddr)
{
draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_FrameBg));
draw_list->AddRectFilled(pos, ImVec2(pos.x + s.GlyphWidth, pos.y + s.LineHeight), ImGui::GetColorU32(ImGuiCol_TextSelectedBg));
}
unsigned char c = ReadFn ? ReadFn(mem_data, addr) : mem_data[addr];
char display_c = (c < 32 || c >= 128) ? '.' : c;
draw_list->AddText(pos, (display_c == c) ? color_text : color_disabled, &display_c, &display_c + 1);
pos.x += s.GlyphWidth;
}
}
}
IM_ASSERT(clipper.Step() == false);
clipper.End();
ImGui::PopStyleVar(2);
ImGui::EndChild();
// Notify the main window of our ideal child content size (FIXME: we are missing an API to get the contents size from the child)
ImGui::SetCursorPosX(s.WindowWidth);
if (data_next && DataEditingAddr < mem_size)
{
DataEditingAddr = DataPreviewAddr = DataEditingAddr + 1;
DataEditingTakeFocus = true;
}
else if (data_editing_addr_next != (size_t)-1)
{
DataEditingAddr = DataPreviewAddr = data_editing_addr_next;
}
const bool lock_show_data_preview = OptShowDataPreview;
if (OptShowOptions)
{
ImGui::Separator();
DrawOptionsLine(s, mem_data, mem_size, base_display_addr);
}
if (lock_show_data_preview)
{
ImGui::Separator();
DrawPreviewLine(s, mem_data, mem_size, base_display_addr);
}
}
void DrawOptionsLine(const Sizes& s, void* mem_data, size_t mem_size, size_t base_display_addr)
{
IM_UNUSED(mem_data);
ImGuiStyle& style = ImGui::GetStyle();
const char* format_range = OptUpperCaseHex ? "Range %0*" _PRISizeT "X..%0*" _PRISizeT "X" : "Range %0*" _PRISizeT "x..%0*" _PRISizeT "x";
// Options menu
if (ImGui::Button("Options"))
ImGui::OpenPopup("context");
if (ImGui::BeginPopup("context"))
{
ImGui::SetNextItemWidth(s.GlyphWidth * 7 + style.FramePadding.x * 2.0f);
if (ImGui::DragInt("##cols", &Cols, 0.2f, 4, 32, "%d cols")) { ContentsWidthChanged = true; if (Cols < 1) Cols = 1; }
ImGui::Checkbox("Show Data Preview", &OptShowDataPreview);
ImGui::Checkbox("Show HexII", &OptShowHexII);
if (ImGui::Checkbox("Show Ascii", &OptShowAscii)) { ContentsWidthChanged = true; }
ImGui::Checkbox("Grey out zeroes", &OptGreyOutZeroes);
ImGui::Checkbox("Uppercase Hex", &OptUpperCaseHex);
ImGui::EndPopup();
}
ImGui::SameLine();
ImGui::Text(format_range, s.AddrDigitsCount, base_display_addr, s.AddrDigitsCount, base_display_addr + mem_size - 1);
ImGui::SameLine();
ImGui::SetNextItemWidth((s.AddrDigitsCount + 1) * s.GlyphWidth + style.FramePadding.x * 2.0f);
if (ImGui::InputText("##addr", AddrInputBuf, IM_ARRAYSIZE(AddrInputBuf), ImGuiInputTextFlags_CharsHexadecimal | ImGuiInputTextFlags_EnterReturnsTrue))
{
size_t goto_addr;
if (sscanf(AddrInputBuf, "%" _PRISizeT "X", &goto_addr) == 1)
{
GotoAddr = goto_addr - base_display_addr;
HighlightMin = HighlightMax = (size_t)-1;
}
}
if (GotoAddr != (size_t)-1)
{
if (GotoAddr < mem_size)
{
ImGui::BeginChild("##scrolling");
ImGui::SetScrollFromPosY(ImGui::GetCursorStartPos().y + (GotoAddr / Cols) * ImGui::GetTextLineHeight());
ImGui::EndChild();
DataEditingAddr = DataPreviewAddr = GotoAddr;
DataEditingTakeFocus = true;
}
GotoAddr = (size_t)-1;
}
}
void DrawPreviewLine(const Sizes& s, void* mem_data_void, size_t mem_size, size_t base_display_addr)
{
IM_UNUSED(base_display_addr);
ImU8* mem_data = (ImU8*)mem_data_void;
ImGuiStyle& style = ImGui::GetStyle();
ImGui::AlignTextToFramePadding();
ImGui::Text("Preview as:");
ImGui::SameLine();
ImGui::SetNextItemWidth((s.GlyphWidth * 10.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x);
if (ImGui::BeginCombo("##combo_type", DataTypeGetDesc(PreviewDataType), ImGuiComboFlags_HeightLargest))
{
for (int n = 0; n < ImGuiDataType_COUNT; n++)
if (ImGui::Selectable(DataTypeGetDesc((ImGuiDataType)n), PreviewDataType == n))
PreviewDataType = (ImGuiDataType)n;
ImGui::EndCombo();
}
ImGui::SameLine();
ImGui::SetNextItemWidth((s.GlyphWidth * 6.0f) + style.FramePadding.x * 2.0f + style.ItemInnerSpacing.x);
ImGui::Combo("##combo_endianess", &PreviewEndianess, "LE\0BE\0\0");
char buf[128] = "";
float x = s.GlyphWidth * 6.0f;
bool has_value = DataPreviewAddr != (size_t)-1;
if (has_value)
DrawPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Dec, buf, (size_t)IM_ARRAYSIZE(buf));
ImGui::Text("Dec"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A");
if (has_value)
DrawPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Hex, buf, (size_t)IM_ARRAYSIZE(buf));
ImGui::Text("Hex"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A");
if (has_value)
DrawPreviewData(DataPreviewAddr, mem_data, mem_size, PreviewDataType, DataFormat_Bin, buf, (size_t)IM_ARRAYSIZE(buf));
buf[IM_ARRAYSIZE(buf) - 1] = 0;
ImGui::Text("Bin"); ImGui::SameLine(x); ImGui::TextUnformatted(has_value ? buf : "N/A");
}
// Utilities for Data Preview
const char* DataTypeGetDesc(ImGuiDataType data_type) const
{
const char* descs[] = { "Int8", "Uint8", "Int16", "Uint16", "Int32", "Uint32", "Int64", "Uint64", "Float", "Double" };
IM_ASSERT(data_type >= 0 && data_type < ImGuiDataType_COUNT);
return descs[data_type];
}
size_t DataTypeGetSize(ImGuiDataType data_type) const
{
const size_t sizes[] = { 1, 1, 2, 2, 4, 4, 8, 8, sizeof(float), sizeof(double) };
IM_ASSERT(data_type >= 0 && data_type < ImGuiDataType_COUNT);
return sizes[data_type];
}
const char* DataFormatGetDesc(DataFormat data_format) const
{
const char* descs[] = { "Bin", "Dec", "Hex" };
IM_ASSERT(data_format >= 0 && data_format < DataFormat_COUNT);
return descs[data_format];
}
bool IsBigEndian() const
{
uint16_t x = 1;
char c[2];
memcpy(c, &x, 2);
return c[0] != 0;
}
static void* EndianessCopyBigEndian(void* _dst, void* _src, size_t s, int is_little_endian)
{
if (is_little_endian)
{
uint8_t* dst = (uint8_t*)_dst;
uint8_t* src = (uint8_t*)_src + s - 1;
for (int i = 0, n = (int)s; i < n; ++i)
memcpy(dst++, src--, 1);
return _dst;
}
else
{
return memcpy(_dst, _src, s);
}
}
static void* EndianessCopyLittleEndian(void* _dst, void* _src, size_t s, int is_little_endian)
{
if (is_little_endian)
{
return memcpy(_dst, _src, s);
}
else
{
uint8_t* dst = (uint8_t*)_dst;
uint8_t* src = (uint8_t*)_src + s - 1;
for (int i = 0, n = (int)s; i < n; ++i)
memcpy(dst++, src--, 1);
return _dst;
}
}
void* EndianessCopy(void* dst, void* src, size_t size) const
{
static void* (*fp)(void*, void*, size_t, int) = NULL;
if (fp == NULL)
fp = IsBigEndian() ? EndianessCopyBigEndian : EndianessCopyLittleEndian;
return fp(dst, src, size, PreviewEndianess);
}
const char* FormatBinary(const uint8_t* buf, int width) const
{
IM_ASSERT(width <= 64);
size_t out_n = 0;
static char out_buf[64 + 8 + 1];
int n = width / 8;
for (int j = n - 1; j >= 0; --j)
{
for (int i = 0; i < 8; ++i)
out_buf[out_n++] = (buf[j] & (1 << (7 - i))) ? '1' : '0';
out_buf[out_n++] = ' ';
}
IM_ASSERT(out_n < IM_ARRAYSIZE(out_buf));
out_buf[out_n] = 0;
return out_buf;
}
// [Internal]
void DrawPreviewData(size_t addr, const ImU8* mem_data, size_t mem_size, ImGuiDataType data_type, DataFormat data_format, char* out_buf, size_t out_buf_size) const
{
uint8_t buf[8];
size_t elem_size = DataTypeGetSize(data_type);
size_t size = addr + elem_size > mem_size ? mem_size - addr : elem_size;
if (ReadFn)
for (int i = 0, n = (int)size; i < n; ++i)
buf[i] = ReadFn(mem_data, addr + i);
else
memcpy(buf, mem_data + addr, size);
if (data_format == DataFormat_Bin)
{
uint8_t binbuf[8];
EndianessCopy(binbuf, buf, size);
ImSnprintf(out_buf, out_buf_size, "%s", FormatBinary(binbuf, (int)size * 8));
return;
}
out_buf[0] = 0;
switch (data_type)
{
case ImGuiDataType_S8:
{
int8_t int8 = 0;
EndianessCopy(&int8, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hhd", int8); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%02x", int8 & 0xFF); return; }
break;
}
case ImGuiDataType_U8:
{
uint8_t uint8 = 0;
EndianessCopy(&uint8, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hhu", uint8); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%02x", uint8 & 0XFF); return; }
break;
}
case ImGuiDataType_S16:
{
int16_t int16 = 0;
EndianessCopy(&int16, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hd", int16); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%04x", int16 & 0xFFFF); return; }
break;
}
case ImGuiDataType_U16:
{
uint16_t uint16 = 0;
EndianessCopy(&uint16, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%hu", uint16); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%04x", uint16 & 0xFFFF); return; }
break;
}
case ImGuiDataType_S32:
{
int32_t int32 = 0;
EndianessCopy(&int32, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%d", int32); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%08x", int32); return; }
break;
}
case ImGuiDataType_U32:
{
uint32_t uint32 = 0;
EndianessCopy(&uint32, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%u", uint32); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%08x", uint32); return; }
break;
}
case ImGuiDataType_S64:
{
int64_t int64 = 0;
EndianessCopy(&int64, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%lld", (long long)int64); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%016llx", (long long)int64); return; }
break;
}
case ImGuiDataType_U64:
{
uint64_t uint64 = 0;
EndianessCopy(&uint64, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%llu", (long long)uint64); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "0x%016llx", (long long)uint64); return; }
break;
}
case ImGuiDataType_Float:
{
float float32 = 0.0f;
EndianessCopy(&float32, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%f", float32); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "%a", float32); return; }
break;
}
case ImGuiDataType_Double:
{
double float64 = 0.0;
EndianessCopy(&float64, buf, size);
if (data_format == DataFormat_Dec) { ImSnprintf(out_buf, out_buf_size, "%f", float64); return; }
if (data_format == DataFormat_Hex) { ImSnprintf(out_buf, out_buf_size, "%a", float64); return; }
break;
}
case ImGuiDataType_COUNT:
break;
} // Switch
IM_ASSERT(0); // Shouldn't reach
}
};
#undef _PRISizeT
#undef ImSnprintf
#ifdef _MSC_VER
#pragma warning (pop)
#endif
+263
View File
@@ -0,0 +1,263 @@
#include <imgui_plot.h>
#include <imgui.h>
#ifndef IMGUI_DEFINE_MATH_OPERATORS
#define IMGUI_DEFINE_MATH_OPERATORS
#endif
#include <imgui_internal.h>
namespace ImGui {
// [0..1] -> [0..1]
static float rescale(float t, float min, float max, PlotConfig::Scale::Type type) {
switch (type) {
case PlotConfig::Scale::Linear:
return t;
case PlotConfig::Scale::Log10:
return log10(ImLerp(min, max, t) / min) / log10(max / min);
}
return 0;
}
// [0..1] -> [0..1]
static float rescale_inv(float t, float min, float max, PlotConfig::Scale::Type type) {
switch (type) {
case PlotConfig::Scale::Linear:
return t;
case PlotConfig::Scale::Log10:
return (pow(max/min, t) * min - min) / (max - min);
}
return 0;
}
static int cursor_to_idx(const ImVec2& pos, const ImRect& bb, const PlotConfig& conf, float x_min, float x_max) {
const float t = ImClamp((pos.x - bb.Min.x) / (bb.Max.x - bb.Min.x), 0.0f, 0.9999f);
const int v_idx = (int)(rescale_inv(t, x_min, x_max, conf.scale.type) * (conf.values.count - 1));
IM_ASSERT(v_idx >= 0 && v_idx < conf.values.count);
return v_idx;
}
PlotStatus Plot(const char* label, const PlotConfig& conf) {
PlotStatus status = PlotStatus::nothing;
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return status;
const float* const* ys_list = conf.values.ys_list;
int ys_count = conf.values.ys_count;
const ImU32* colors = conf.values.colors;
if (conf.values.ys != nullptr) { // draw only a single plot
ys_list = &conf.values.ys;
ys_count = 1;
colors = &conf.values.color;
}
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiID id = window->GetID(label);
const ImRect frame_bb(
window->DC.CursorPos,
window->DC.CursorPos + conf.frame_size);
const ImRect inner_bb(
frame_bb.Min + style.FramePadding,
frame_bb.Max - style.FramePadding);
const ImRect total_bb = frame_bb;
ItemSize(total_bb, style.FramePadding.y);
if (!ItemAdd(total_bb, 0, &frame_bb))
return status;
const bool hovered = ItemHoverable(frame_bb, id);
RenderFrame(
frame_bb.Min,
frame_bb.Max,
GetColorU32(ImGuiCol_FrameBg),
true,
style.FrameRounding);
if (conf.values.count > 0) {
int res_w;
if (conf.skip_small_lines)
res_w = ImMin((int)conf.frame_size.x, conf.values.count);
else
res_w = conf.values.count;
res_w -= 1;
int item_count = conf.values.count - 1;
float x_min = conf.values.offset;
float x_max = conf.values.offset + conf.values.count - 1;
if (conf.values.xs) {
x_min = conf.values.xs[size_t(x_min)];
x_max = conf.values.xs[size_t(x_max)];
}
// Tooltip on hover
int v_hovered = -1;
if (conf.tooltip.show && hovered && inner_bb.Contains(g.IO.MousePos)) {
const int v_idx = cursor_to_idx(g.IO.MousePos, inner_bb, conf, x_min, x_max);
const size_t data_idx = conf.values.offset + (v_idx % conf.values.count);
const float x0 = conf.values.xs ? conf.values.xs[data_idx] : v_idx;
const float y0 = ys_list[0][data_idx]; // TODO: tooltip is only shown for the first y-value!
SetTooltip(conf.tooltip.format, x0, y0);
v_hovered = v_idx;
}
const float t_step = 1.0f / (float)res_w;
const float inv_scale = (conf.scale.min == conf.scale.max) ?
0.0f : (1.0f / (conf.scale.max - conf.scale.min));
if (conf.grid_x.show) {
int y0 = inner_bb.Min.y;
int y1 = inner_bb.Max.y;
switch (conf.scale.type) {
case PlotConfig::Scale::Linear: {
float cnt = conf.values.count / (conf.grid_x.size / conf.grid_x.subticks);
float inc = 1.f / cnt;
for (int i = 0; i <= cnt; ++i) {
int x0 = ImLerp(inner_bb.Min.x, inner_bb.Max.x, i * inc);
window->DrawList->AddLine(
ImVec2(x0, y0),
ImVec2(x0, y1),
IM_COL32(200, 200, 200, (i % conf.grid_x.subticks) ? 128 : 255));
}
break;
}
case PlotConfig::Scale::Log10: {
float start = 1.f;
while (start < x_max) {
for (int i = 1; i < 10; ++i) {
float x = start * i;
if (x < x_min) continue;
if (x > x_max) break;
float t = log10(x / x_min) / log10(x_max / x_min);
int x0 = ImLerp(inner_bb.Min.x, inner_bb.Max.x, t);
window->DrawList->AddLine(
ImVec2(x0, y0),
ImVec2(x0, y1),
IM_COL32(200, 200, 200, (i > 1) ? 128 : 255));
}
start *= 10.f;
}
break;
}
}
}
if (conf.grid_y.show) {
int x0 = inner_bb.Min.x;
int x1 = inner_bb.Max.x;
float cnt = (conf.scale.max - conf.scale.min) / (conf.grid_y.size / conf.grid_y.subticks);
float inc = 1.f / cnt;
for (int i = 0; i <= cnt; ++i) {
int y0 = ImLerp(inner_bb.Min.y, inner_bb.Max.y, i * inc);
window->DrawList->AddLine(
ImVec2(x0, y0),
ImVec2(x1, y0),
IM_COL32(0, 0, 0, (i % conf.grid_y.subticks) ? 16 : 64));
}
}
const ImU32 col_hovered = GetColorU32(ImGuiCol_PlotLinesHovered);
ImU32 col_base = GetColorU32(ImGuiCol_PlotLines);
for (int i = 0; i < ys_count; ++i) {
if (colors) {
if (colors[i]) col_base = colors[i];
else col_base = GetColorU32(ImGuiCol_PlotLines);
}
float v0 = ys_list[i][conf.values.offset];
float t0 = 0.0f;
// Point in the normalized space of our target rectangle
ImVec2 tp0 = ImVec2(t0, 1.0f - ImSaturate((v0 - conf.scale.min) * inv_scale));
for (int n = 0; n < res_w; n++)
{
const float t1 = t0 + t_step;
const int v1_idx = (int)(t0 * item_count + 0.5f);
IM_ASSERT(v1_idx >= 0 && v1_idx < conf.values.count);
const float v1 = ys_list[i][conf.values.offset + (v1_idx + 1) % conf.values.count];
const ImVec2 tp1 = ImVec2(
rescale(t1, x_min, x_max, conf.scale.type),
1.0f - ImSaturate((v1 - conf.scale.min) * inv_scale));
// NB: Draw calls are merged together by the DrawList system. Still, we should render our batch are lower level to save a bit of CPU.
ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max, tp0);
ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max, tp1);
if (v1_idx == v_hovered) {
window->DrawList->AddCircleFilled(pos0, 3, col_hovered);
}
window->DrawList->AddLine(
pos0,
pos1,
col_base,
conf.line_thickness);
t0 = t1;
tp0 = tp1;
}
}
if (conf.v_lines.show) {
for (size_t i = 0; i < conf.v_lines.count; ++i) {
const size_t idx = conf.v_lines.indices[i];
const float t1 = rescale(idx * t_step, x_min, x_max, conf.scale.type);
ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max, ImVec2(t1, 0.f));
ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max, ImVec2(t1, 1.f));
window->DrawList->AddLine(pos0, pos1, IM_COL32(0xff, 0, 0, 0x88));
}
}
if (conf.selection.show) {
if (hovered) {
if (g.IO.MouseClicked[0]) {
SetActiveID(id, window);
FocusWindow(window);
const int v_idx = cursor_to_idx(g.IO.MousePos, inner_bb, conf, x_min, x_max);
uint32_t start = conf.values.offset + (v_idx % conf.values.count);
uint32_t end = start;
if (conf.selection.sanitize_fn)
end = conf.selection.sanitize_fn(end - start) + start;
if (end < conf.values.offset + conf.values.count) {
*conf.selection.start = start;
*conf.selection.length = end - start;
status = PlotStatus::selection_updated;
}
}
}
if (g.ActiveId == id) {
if (g.IO.MouseDown[0]) {
const int v_idx = cursor_to_idx(g.IO.MousePos, inner_bb, conf, x_min, x_max);
const uint32_t start = *conf.selection.start;
uint32_t end = conf.values.offset + (v_idx % conf.values.count);
if (end > start) {
if (conf.selection.sanitize_fn)
end = conf.selection.sanitize_fn(end - start) + start;
if (end < conf.values.offset + conf.values.count) {
*conf.selection.length = end - start;
status = PlotStatus::selection_updated;
}
}
} else {
ClearActiveID();
}
}
float fSelectionStep = 1.0 / item_count;
ImVec2 pos0 = ImLerp(inner_bb.Min, inner_bb.Max,
ImVec2(fSelectionStep * *conf.selection.start, 0.f));
ImVec2 pos1 = ImLerp(inner_bb.Min, inner_bb.Max,
ImVec2(fSelectionStep * (*conf.selection.start + *conf.selection.length), 1.f));
window->DrawList->AddRectFilled(pos0, pos1, IM_COL32(128, 128, 128, 32));
window->DrawList->AddRect(pos0, pos1, IM_COL32(128, 128, 128, 128));
}
}
// Text overlay
if (conf.overlay_text)
RenderTextClipped(ImVec2(frame_bb.Min.x, frame_bb.Min.y + style.FramePadding.y), frame_bb.Max, conf.overlay_text, NULL, NULL, ImVec2(0.5f,0.0f));
return status;
}
}
+75
View File
@@ -0,0 +1,75 @@
#pragma once
#include <cstdint>
#include <imgui.h>
namespace ImGui {
// Use this structure to pass the plot data and settings into the Plot function
struct PlotConfig {
struct Values {
// if necessary, you can provide x-axis values
const float *xs = nullptr;
// array of y values. If null, use ys_list (below)
const float *ys = nullptr;
// the number of values in each array
int count;
// at which offset to start plotting.
// Warning: count+offset must be <= length of array!
int offset = 0;
// Plot color. If 0, use ImGuiCol_PlotLines.
ImU32 color = 0;
// in case you need to draw multiple plots at once, use this instead of ys
const float **ys_list = nullptr;
// the number of plots to draw
int ys_count = 0;
// colors for each plot
const ImU32* colors = nullptr;
} values;
struct Scale {
// Minimum plot value
float min;
// Maximum plot value
float max;
enum Type {
Linear,
Log10,
};
// How to scale the x-axis
Type type = Linear;
} scale;
struct Tooltip {
bool show = false;
const char* format = "%g: %8.4g";
} tooltip;
struct Grid {
bool show = false;
float size = 100; // at which intervals to draw the grid
int subticks = 10; // how many subticks in each tick
} grid_x, grid_y;
struct Selection {
bool show = false;
uint32_t* start = nullptr;
uint32_t* length = nullptr;
// "Sanitize" function. Give it selection length, and it will return
// the "allowed" length. Useful for FFT, where selection must be
// of power of two
uint32_t(*sanitize_fn)(uint32_t) = nullptr;
} selection;
struct VerticalLines {
bool show = false;
const size_t* indices = nullptr; // at which indices to draw the lines
size_t count = 0;
} v_lines;
ImVec2 frame_size = ImVec2(0.f, 0.f);
float line_thickness = 1.f;
bool skip_small_lines = true;
const char* overlay_text = nullptr;
};
enum class PlotStatus {
nothing,
selection_updated,
};
IMGUI_API PlotStatus Plot(const char* label, const PlotConfig& conf);
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+639
View File
@@ -0,0 +1,639 @@
// [DEAR IMGUI]
// This is a slightly modified version of stb_rect_pack.h 1.00.
// Those changes would need to be pushed into nothings/stb:
// - Added STBRP__CDECL
// Grep for [DEAR IMGUI] to find the changes.
// stb_rect_pack.h - v1.00 - public domain - rectangle packing
// Sean Barrett 2014
//
// Useful for e.g. packing rectangular textures into an atlas.
// Does not do rotation.
//
// Not necessarily the awesomest packing method, but better than
// the totally naive one in stb_truetype (which is primarily what
// this is meant to replace).
//
// Has only had a few tests run, may have issues.
//
// More docs to come.
//
// No memory allocations; uses qsort() and assert() from stdlib.
// Can override those by defining STBRP_SORT and STBRP_ASSERT.
//
// This library currently uses the Skyline Bottom-Left algorithm.
//
// Please note: better rectangle packers are welcome! Please
// implement them to the same API, but with a different init
// function.
//
// Credits
//
// Library
// Sean Barrett
// Minor features
// Martins Mozeiko
// github:IntellectualKitty
//
// Bugfixes / warning fixes
// Jeremy Jaussaud
// Fabian Giesen
//
// Version history:
//
// 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles
// 0.99 (2019-02-07) warning fixes
// 0.11 (2017-03-03) return packing success/fail result
// 0.10 (2016-10-25) remove cast-away-const to avoid warnings
// 0.09 (2016-08-27) fix compiler warnings
// 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0)
// 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0)
// 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort
// 0.05: added STBRP_ASSERT to allow replacing assert
// 0.04: fixed minor bug in STBRP_LARGE_RECTS support
// 0.01: initial release
//
// LICENSE
//
// See end of file for license information.
//////////////////////////////////////////////////////////////////////////////
//
// INCLUDE SECTION
//
#ifndef STB_INCLUDE_STB_RECT_PACK_H
#define STB_INCLUDE_STB_RECT_PACK_H
#define STB_RECT_PACK_VERSION 1
#ifdef STBRP_STATIC
#define STBRP_DEF static
#else
#define STBRP_DEF extern
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef struct stbrp_context stbrp_context;
typedef struct stbrp_node stbrp_node;
typedef struct stbrp_rect stbrp_rect;
#ifdef STBRP_LARGE_RECTS
typedef int stbrp_coord;
#else
typedef unsigned short stbrp_coord;
#endif
STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
// Assign packed locations to rectangles. The rectangles are of type
// 'stbrp_rect' defined below, stored in the array 'rects', and there
// are 'num_rects' many of them.
//
// Rectangles which are successfully packed have the 'was_packed' flag
// set to a non-zero value and 'x' and 'y' store the minimum location
// on each axis (i.e. bottom-left in cartesian coordinates, top-left
// if you imagine y increasing downwards). Rectangles which do not fit
// have the 'was_packed' flag set to 0.
//
// You should not try to access the 'rects' array from another thread
// while this function is running, as the function temporarily reorders
// the array while it executes.
//
// To pack into another rectangle, you need to call stbrp_init_target
// again. To continue packing into the same rectangle, you can call
// this function again. Calling this multiple times with multiple rect
// arrays will probably produce worse packing results than calling it
// a single time with the full rectangle array, but the option is
// available.
//
// The function returns 1 if all of the rectangles were successfully
// packed and 0 otherwise.
struct stbrp_rect
{
// reserved for your use:
int id;
// input:
stbrp_coord w, h;
// output:
stbrp_coord x, y;
int was_packed; // non-zero if valid packing
}; // 16 bytes, nominally
STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
// Initialize a rectangle packer to:
// pack a rectangle that is 'width' by 'height' in dimensions
// using temporary storage provided by the array 'nodes', which is 'num_nodes' long
//
// You must call this function every time you start packing into a new target.
//
// There is no "shutdown" function. The 'nodes' memory must stay valid for
// the following stbrp_pack_rects() call (or calls), but can be freed after
// the call (or calls) finish.
//
// Note: to guarantee best results, either:
// 1. make sure 'num_nodes' >= 'width'
// or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
//
// If you don't do either of the above things, widths will be quantized to multiples
// of small integers to guarantee the algorithm doesn't run out of temporary storage.
//
// If you do #2, then the non-quantized algorithm will be used, but the algorithm
// may run out of temporary storage and be unable to pack some rectangles.
STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
// Optionally call this function after init but before doing any packing to
// change the handling of the out-of-temp-memory scenario, described above.
// If you call init again, this will be reset to the default (false).
STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
// Optionally select which packing heuristic the library should use. Different
// heuristics will produce better/worse results for different data sets.
// If you call init again, this will be reset to the default.
enum
{
STBRP_HEURISTIC_Skyline_default=0,
STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
STBRP_HEURISTIC_Skyline_BF_sortHeight
};
//////////////////////////////////////////////////////////////////////////////
//
// the details of the following structures don't matter to you, but they must
// be visible so you can handle the memory allocations for them
struct stbrp_node
{
stbrp_coord x,y;
stbrp_node *next;
};
struct stbrp_context
{
int width;
int height;
int align;
int init_mode;
int heuristic;
int num_nodes;
stbrp_node *active_head;
stbrp_node *free_head;
stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
};
#ifdef __cplusplus
}
#endif
#endif
//////////////////////////////////////////////////////////////////////////////
//
// IMPLEMENTATION SECTION
//
#ifdef STB_RECT_PACK_IMPLEMENTATION
#ifndef STBRP_SORT
#include <stdlib.h>
#define STBRP_SORT qsort
#endif
#ifndef STBRP_ASSERT
#include <assert.h>
#define STBRP_ASSERT assert
#endif
// [DEAR IMGUI] Added STBRP__CDECL
#ifdef _MSC_VER
#define STBRP__NOTUSED(v) (void)(v)
#define STBRP__CDECL __cdecl
#else
#define STBRP__NOTUSED(v) (void)sizeof(v)
#define STBRP__CDECL
#endif
enum
{
STBRP__INIT_skyline = 1
};
STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
{
switch (context->init_mode) {
case STBRP__INIT_skyline:
STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
context->heuristic = heuristic;
break;
default:
STBRP_ASSERT(0);
}
}
STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
{
if (allow_out_of_mem)
// if it's ok to run out of memory, then don't bother aligning them;
// this gives better packing, but may fail due to OOM (even though
// the rectangles easily fit). @TODO a smarter approach would be to only
// quantize once we've hit OOM, then we could get rid of this parameter.
context->align = 1;
else {
// if it's not ok to run out of memory, then quantize the widths
// so that num_nodes is always enough nodes.
//
// I.e. num_nodes * align >= width
// align >= width / num_nodes
// align = ceil(width/num_nodes)
context->align = (context->width + context->num_nodes-1) / context->num_nodes;
}
}
STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
{
int i;
#ifndef STBRP_LARGE_RECTS
STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
#endif
for (i=0; i < num_nodes-1; ++i)
nodes[i].next = &nodes[i+1];
nodes[i].next = NULL;
context->init_mode = STBRP__INIT_skyline;
context->heuristic = STBRP_HEURISTIC_Skyline_default;
context->free_head = &nodes[0];
context->active_head = &context->extra[0];
context->width = width;
context->height = height;
context->num_nodes = num_nodes;
stbrp_setup_allow_out_of_mem(context, 0);
// node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
context->extra[0].x = 0;
context->extra[0].y = 0;
context->extra[0].next = &context->extra[1];
context->extra[1].x = (stbrp_coord) width;
#ifdef STBRP_LARGE_RECTS
context->extra[1].y = (1<<30);
#else
context->extra[1].y = 65535;
#endif
context->extra[1].next = NULL;
}
// find minimum y position if it starts at x1
static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
{
stbrp_node *node = first;
int x1 = x0 + width;
int min_y, visited_width, waste_area;
STBRP__NOTUSED(c);
STBRP_ASSERT(first->x <= x0);
#if 0
// skip in case we're past the node
while (node->next->x <= x0)
++node;
#else
STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
#endif
STBRP_ASSERT(node->x <= x0);
min_y = 0;
waste_area = 0;
visited_width = 0;
while (node->x < x1) {
if (node->y > min_y) {
// raise min_y higher.
// we've accounted for all waste up to min_y,
// but we'll now add more waste for everything we've visted
waste_area += visited_width * (node->y - min_y);
min_y = node->y;
// the first time through, visited_width might be reduced
if (node->x < x0)
visited_width += node->next->x - x0;
else
visited_width += node->next->x - node->x;
} else {
// add waste area
int under_width = node->next->x - node->x;
if (under_width + visited_width > width)
under_width = width - visited_width;
waste_area += under_width * (min_y - node->y);
visited_width += under_width;
}
node = node->next;
}
*pwaste = waste_area;
return min_y;
}
typedef struct
{
int x,y;
stbrp_node **prev_link;
} stbrp__findresult;
static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
{
int best_waste = (1<<30), best_x, best_y = (1 << 30);
stbrp__findresult fr;
stbrp_node **prev, *node, *tail, **best = NULL;
// align to multiple of c->align
width = (width + c->align - 1);
width -= width % c->align;
STBRP_ASSERT(width % c->align == 0);
// if it can't possibly fit, bail immediately
if (width > c->width || height > c->height) {
fr.prev_link = NULL;
fr.x = fr.y = 0;
return fr;
}
node = c->active_head;
prev = &c->active_head;
while (node->x + width <= c->width) {
int y,waste;
y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
// bottom left
if (y < best_y) {
best_y = y;
best = prev;
}
} else {
// best-fit
if (y + height <= c->height) {
// can only use it if it first vertically
if (y < best_y || (y == best_y && waste < best_waste)) {
best_y = y;
best_waste = waste;
best = prev;
}
}
}
prev = &node->next;
node = node->next;
}
best_x = (best == NULL) ? 0 : (*best)->x;
// if doing best-fit (BF), we also have to try aligning right edge to each node position
//
// e.g, if fitting
//
// ____________________
// |____________________|
//
// into
//
// | |
// | ____________|
// |____________|
//
// then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
//
// This makes BF take about 2x the time
if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
tail = c->active_head;
node = c->active_head;
prev = &c->active_head;
// find first node that's admissible
while (tail->x < width)
tail = tail->next;
while (tail) {
int xpos = tail->x - width;
int y,waste;
STBRP_ASSERT(xpos >= 0);
// find the left position that matches this
while (node->next->x <= xpos) {
prev = &node->next;
node = node->next;
}
STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
if (y + height <= c->height) {
if (y <= best_y) {
if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
best_x = xpos;
STBRP_ASSERT(y <= best_y);
best_y = y;
best_waste = waste;
best = prev;
}
}
}
tail = tail->next;
}
}
fr.prev_link = best;
fr.x = best_x;
fr.y = best_y;
return fr;
}
static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
{
// find best position according to heuristic
stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
stbrp_node *node, *cur;
// bail if:
// 1. it failed
// 2. the best node doesn't fit (we don't always check this)
// 3. we're out of memory
if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
res.prev_link = NULL;
return res;
}
// on success, create new node
node = context->free_head;
node->x = (stbrp_coord) res.x;
node->y = (stbrp_coord) (res.y + height);
context->free_head = node->next;
// insert the new node into the right starting point, and
// let 'cur' point to the remaining nodes needing to be
// stiched back in
cur = *res.prev_link;
if (cur->x < res.x) {
// preserve the existing one, so start testing with the next one
stbrp_node *next = cur->next;
cur->next = node;
cur = next;
} else {
*res.prev_link = node;
}
// from here, traverse cur and free the nodes, until we get to one
// that shouldn't be freed
while (cur->next && cur->next->x <= res.x + width) {
stbrp_node *next = cur->next;
// move the current node to the free list
cur->next = context->free_head;
context->free_head = cur;
cur = next;
}
// stitch the list back in
node->next = cur;
if (cur->x < res.x + width)
cur->x = (stbrp_coord) (res.x + width);
#ifdef _DEBUG
cur = context->active_head;
while (cur->x < context->width) {
STBRP_ASSERT(cur->x < cur->next->x);
cur = cur->next;
}
STBRP_ASSERT(cur->next == NULL);
{
int count=0;
cur = context->active_head;
while (cur) {
cur = cur->next;
++count;
}
cur = context->free_head;
while (cur) {
cur = cur->next;
++count;
}
STBRP_ASSERT(count == context->num_nodes+2);
}
#endif
return res;
}
// [DEAR IMGUI] Added STBRP__CDECL
static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
{
const stbrp_rect *p = (const stbrp_rect *) a;
const stbrp_rect *q = (const stbrp_rect *) b;
if (p->h > q->h)
return -1;
if (p->h < q->h)
return 1;
return (p->w > q->w) ? -1 : (p->w < q->w);
}
// [DEAR IMGUI] Added STBRP__CDECL
static int STBRP__CDECL rect_original_order(const void *a, const void *b)
{
const stbrp_rect *p = (const stbrp_rect *) a;
const stbrp_rect *q = (const stbrp_rect *) b;
return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
}
#ifdef STBRP_LARGE_RECTS
#define STBRP__MAXVAL 0xffffffff
#else
#define STBRP__MAXVAL 0xffff
#endif
STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
{
int i, all_rects_packed = 1;
// we use the 'was_packed' field internally to allow sorting/unsorting
for (i=0; i < num_rects; ++i) {
rects[i].was_packed = i;
}
// sort according to heuristic
STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
for (i=0; i < num_rects; ++i) {
if (rects[i].w == 0 || rects[i].h == 0) {
rects[i].x = rects[i].y = 0; // empty rect needs no space
} else {
stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
if (fr.prev_link) {
rects[i].x = (stbrp_coord) fr.x;
rects[i].y = (stbrp_coord) fr.y;
} else {
rects[i].x = rects[i].y = STBRP__MAXVAL;
}
}
}
// unsort
STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
// set was_packed flags and all_rects_packed status
for (i=0; i < num_rects; ++i) {
rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
if (!rects[i].was_packed)
all_rects_packed = 0;
}
// return the all_rects_packed status
return all_rects_packed;
}
#endif
/*
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2017 Sean Barrett
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------------------------
*/
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+62
View File
@@ -0,0 +1,62 @@
#include "sim_audio.h"
#include <iostream>
#include <fstream>
#include <list>
using namespace std;
SimClock clk;
bool outputToFile;
ofstream audioFile;
SimAudio::SimAudio(int systemClockFrequency, bool saveToFile)
{
clk = SimClock(systemClockFrequency / 44100);
outputToFile = saveToFile;
}
SimAudio::~SimAudio()
{
}
void SimAudio::Clock(signed short left, signed short right) {
clk.Tick();
if (clk.IsRising()) {
// Output audio (left channel only for now)
float l = left / 32768.0f;
if (outputToFile) {
audioFile.write((const char*)&l, sizeof(float));
}
}
}
void SimAudio::CollectDebug(signed short left, signed short right) {
float vol_l = left / 32768.0f;
float vol_r = right / 32768.0f;
debug_pos++;
if (debug_pos == debug_max_samples) { debug_pos = 0; }
debug_wave_l[debug_pos] = vol_l;
debug_wave_r[debug_pos] = vol_r;
}
void SimAudio::Initialise() {
// Reset plot data
for (int c = 0; c < debug_max_samples; c++) {
debug_wave_l[c] = 0;
debug_wave_r[c] = 0;
debug_positions[c] = (double)c / (double)debug_max_samples;
}
if (outputToFile)
{
// Setup Audio output stream
audioFile.open("audio.wav", ios::binary);
}
}
void SimAudio::CleanUp() {
if (outputToFile)
{
audioFile.close();
}
}
+23
View File
@@ -0,0 +1,23 @@
#pragma once
#include <string>
#include "sim_clock.h"
struct SimAudio {
public:
SimClock clock;
static const unsigned short debug_max_samples = 600;
float debug_positions[debug_max_samples];
float debug_wave_l[debug_max_samples];
float debug_wave_r[debug_max_samples];
int debug_pos;
SimAudio(int systemClockFrequency, bool saveToFile);
~SimAudio();
void Clock(signed short left, signed short right);
void CollectDebug(signed short left, signed short right);
void Initialise();
void CleanUp();
};
+210
View File
@@ -0,0 +1,210 @@
#include <iostream>
#include <queue>
#include <string>
#include "sim_blkdevice.h"
#include "sim_console.h"
#include "verilated.h"
#ifndef _MSC_VER
#else
#define WIN32
#endif
static DebugConsole console;
IData* sd_lba[kVDNUM]= {NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL};
SData* sd_rd=NULL;
SData* sd_wr=NULL;
SData* sd_ack=NULL;
SData* sd_buff_addr=NULL;
CData* sd_buff_dout=NULL;
CData* sd_buff_din[kVDNUM]= {NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL};
CData* sd_buff_wr=NULL;
SData* img_mounted=NULL;
CData* img_readonly=NULL;
QData* img_size=NULL;
// Writes reach the mounted .d77 ONLY when this is set. It defaults off because
// the harness opens every image read-write and a sweep runs hundreds of them:
// two disks in cohort 02 (FM Sound Editor V1.0 and F-BASIC V3.3L11 System Disk,
// both titles that legitimately save to disk) were silently modified at
// 2026-08-27 17:40:08 while the sweep ran. That mutates the user's collection,
// and it also breaks the cohort bookkeeping, which identifies a disk by its
// content hash -- the two showed up as retired-but-not-in-population.
//
// The core is still told the disk is writable (img_readonly stays 0) and the
// write still takes the same number of cycles, so emulated behaviour and the
// gate's counters are unchanged; only the file on disk is spared.
bool disk_persist_writes = false;
#define bitset(byte,nbit) ((byte) |= (1<<(nbit)))
#define bitclear(byte,nbit) ((byte) &= ~(1<<(nbit)))
#define bitflip(byte,nbit) ((byte) ^= (1<<(nbit)))
#define bitcheck(byte,nbit) ((byte) & (1<<(nbit)))
void SimBlockDevice::MountDisk( std::string file, int index) {
disk[index].open(file.c_str(), std::ios::out | std::ios::in | std::ios::binary | std::ios::ate);
if (disk[index]) {
// we shouldn't do the actual mount here..
disk_size[index]= disk[index].tellg();
disk[index].seekg(0);
mountQueue[index]=1;
printf("BLKDEV: disk %d inserted (%s) size=%ld bytes\n", index, file.c_str(), disk_size[index]);
// (The Apple-IIgs original checked for a 232960-byte NIB image here.
// FM-7 images are .d77, whose size is self-describing -- the header
// carries the total length at offset 0x1c -- so no size check.)
}else {
fprintf(stderr,"BLKDEV ERROR: Failed to open: %s\n",file.c_str());
}
}
void SimBlockDevice::BeforeEval(uint64_t cycles)
{
//
// switch to a new disk if current_disk is -1
// check to see if we need a read or a write or a mount
//
// wait until the computer boots to start mounting, etc
if (cycles<2000) return;
for (int i=0; i<kVDNUM;i++)
{
//fprintf(stderr,"current_disk = %d *sd_rd %x ack_delay %x reading %d writing %d\n",current_disk,*sd_rd,ack_delay,reading,writing);
if (current_disk == i) {
// send data
if (ack_delay==1) {
if (reading && (*sd_buff_wr==0) && (bytecnt<kBLKSZ)) {
*sd_buff_dout = disk[i].get();
*sd_buff_addr = bytecnt++;
*sd_buff_wr= 1;
} else if(writing && *sd_buff_addr != bytecnt && (*sd_buff_addr< kBLKSZ)) {
//} else if(writing && (bytecnt < kBLKSZ)) {
//printf("writing disk %i at sd_buff_addr %x data %x ack %x\n",i,*sd_buff_addr,*sd_buff_din[i],*sd_ack);
if (disk_persist_writes) disk[i].put(*(sd_buff_din[i]));
*sd_buff_addr = bytecnt;
} else {
*sd_buff_wr=0;
if (writing) {
if (bytecnt>=kBLKSZ) {
writing=0;
//printf("writing stopped: bytecnt %x sd_buff_addr %x \n",bytecnt,*sd_buff_addr);
}
if (bytecnt<kBLKSZ)
bytecnt++;
}
else if (reading) {
if(bytecnt == kBLKSZ) {
reading = 0;
}
}
}
} else {
*sd_buff_wr=0;
}
}
// issue a mount if we aren't doing anything, and the img_mounted has no bits set
if (!reading && !writing && mountQueue[i] && !*img_mounted) {
const size_t extrabytes = disk_size[i] % kBLKSZ;
if (disk_size[i] >= (kBLKSZ + 64) && extrabytes == 64) {
char hdr[4];
disk[i].seekg(0);
disk[i].read(hdr, 4);
if (!memcmp(hdr, "2IMG", 4)) {
fprintf(stderr, "Detected \"2IMG\" signature; adjusting sizes\n");
header_size[i] = 64;
disk_size[i] -= header_size[i];
}
}
printf("BLKDEV: Mounting drive %d, img_size=%ld, header_offset=%ld\n", i, disk_size[i], header_size[i]);
mountQueue[i]=0;
*img_size = disk_size[i];
*img_readonly=0;
disk[i].seekg(header_size[i]);
bitset(*img_mounted,i);
ack_delay=1200;
} else if (ack_delay==1 && bitcheck(*img_mounted,i) ) {
printf("BLKDEV: Mount flag cleared for drive %d\n", i);
bitclear(*img_mounted,i) ;
//*img_size = 0;
} else { if (!reading && !writing && ack_delay>0) ack_delay--; }
// start reading when sd_rd pulses high
if ((current_disk==-1 || current_disk==i) && (bitcheck(*sd_rd,i) || bitcheck(*sd_wr,i) )) {
// set current disk here..
current_disk=i;
if (!ack_delay) {
int lba = *(sd_lba[i]);
if (bitcheck(*sd_rd,i)) {
reading = true;
}
if (bitcheck(*sd_wr,i)) {
writing = true;
}
disk[i].clear();
disk[i].seekg((lba) * kBLKSZ + header_size[i]);
printf("BLKDEV: drive=%d LBA=%d seek=%06X reading=%d writing=%d\n",
i, lba, (int)((lba) * kBLKSZ + header_size[i]), reading, writing);
bytecnt = 0;
*sd_buff_addr = 0;
ack_delay = 1200;
}
}
if (current_disk == i) {
if (ack_delay==1) {
bitset(*sd_ack,i);
//printf("setting sd_ack: %x\n",*sd_ack);
} else {
bitclear(*sd_ack,i);
//printf("clearing sd_ack: %x\n",*sd_ack);
}
if((ack_delay > 1) || ((ack_delay == 1) && !reading && !writing))
ack_delay--;
if (ack_delay==0 && !reading && !writing)
current_disk=-1;
}
}
}
void SimBlockDevice::AfterEval()
{
}
SimBlockDevice::SimBlockDevice(DebugConsole c) {
console = c;
current_disk=-1;
sd_rd = NULL;
sd_wr = NULL;
sd_ack = NULL;
sd_buff_addr = NULL;
sd_buff_dout = NULL;
for (int i=0;i<kVDNUM;i++) {
sd_lba[i] = NULL;
sd_buff_din[i] = NULL;
mountQueue[i]=0;
}
sd_buff_wr=NULL;
img_mounted=NULL;
img_readonly=NULL;
img_size=NULL;
}
SimBlockDevice::~SimBlockDevice() {
}
+63
View File
@@ -0,0 +1,63 @@
#pragma once
#include <iostream>
#include <fstream>
#include "verilated.h"
#include "sim_console.h"
// Off by default: a sweep must never modify the user's disk images.
extern bool disk_persist_writes;
#ifndef _MSC_VER
#else
#define WIN32
#endif
#define kVDNUM 10
#define kBLKSZ 512
struct SimBlockDevice {
public:
IData* sd_lba[kVDNUM];
SData* sd_rd;
SData* sd_wr;
SData* sd_ack;
SData* sd_buff_addr;
CData* sd_buff_dout;
CData* sd_buff_din[kVDNUM];
CData* sd_buff_wr;
SData* img_mounted;
CData* img_readonly;
QData* img_size;
int bytecnt;
long int disk_size[kVDNUM];
long int header_size[kVDNUM];
bool reading;
bool writing;
int ack_delay;
int current_disk;
bool mountQueue[kVDNUM];
std::fstream disk[kVDNUM];
// 64-bit, not int. main_time passes INT_MAX around frame 2666 at 48 MHz /
// 60 Hz (~800k cycles a frame); truncating it made `cycles` go negative, the
// `cycles < 2000` guard below became permanently true, and the block device
// silently stopped servicing every request from then on. See TODO.md P4-5.
void BeforeEval(uint64_t cycles);
void AfterEval(void);
//void QueueDownload(std::string file, int index);
//void QueueDownload(std::string file, int index, bool restart);
//bool HasQueue();
void MountDisk( std::string file, int index);
SimBlockDevice(DebugConsole c);
~SimBlockDevice();
private:
//std::queue<SimBus_DownloadChunk> downloadQueue;
//SimBus_DownloadChunk currentDownload;
//void SetDownload(std::string file, int index);
};
+148
View File
@@ -0,0 +1,148 @@
#include <iostream>
#include <queue>
#include <string>
#include "sim_bus.h"
#include "sim_console.h"
#include "verilated.h"
#ifndef _MSC_VER
#else
#define WIN32
#endif
static DebugConsole console;
FILE* ioctl_file = NULL;
int ioctl_next_addr = -1;
int ioctl_last_index = -1;
IData* ioctl_addr = NULL;
CData* ioctl_index = NULL;
CData* ioctl_wait = NULL;
CData* ioctl_download = NULL;
CData* ioctl_upload = NULL;
CData* ioctl_wr = NULL;
CData* ioctl_dout = NULL;
CData* ioctl_din = NULL;
std::queue<SimBus_DownloadChunk> downloadQueue;
void SimBus::QueueDownload(std::string file, int index) {
SimBus_DownloadChunk chunk = SimBus_DownloadChunk(file, index);
downloadQueue.push(chunk);
}
void SimBus::QueueDownload(std::string file, int index, bool restart) {
SimBus_DownloadChunk chunk = SimBus_DownloadChunk(file, index, restart);
downloadQueue.push(chunk);
}
bool SimBus::HasQueue() {
return downloadQueue.size() > 0;
}
int nextchar = 0;
void SimBus::BeforeEval()
{
// If no file is open and there is a download queued
if (!ioctl_file && downloadQueue.size() > 0) {
// Get chunk from queue
currentDownload = downloadQueue.front();
downloadQueue.pop();
// If last index differs from this one then reset the addresses
if (currentDownload.index != *ioctl_index) { ioctl_next_addr = -1; }
// if we want to restart the ioctl_addr then reset it
// leave it the same if we want to be able to load two roms sequentially
if (currentDownload.restart) { ioctl_next_addr = -1; }
// Set address and index
*ioctl_addr = ioctl_next_addr;
*ioctl_index = currentDownload.index;
// Open file
ioctl_file = fopen(currentDownload.file.c_str(), "rb");
if (!ioctl_file) {
console.AddLog("Cannot open file for download %s\n", currentDownload.file.c_str());
}
else {
console.AddLog("Starting download: %s %d", currentDownload.file.c_str(), ioctl_next_addr, ioctl_next_addr);
fprintf(stderr, "IOCTL: Starting download: %s\n", currentDownload.file.c_str());
}
}
if (ioctl_file) {
//console.AddLog("ioctl_download addr %x ioctl_wait %x", *ioctl_addr, *ioctl_wait);
if (*ioctl_wait != 0) {
// Match the real HPS (data_io.v): ioctl_wr is a one-shot strobe
// per byte, deasserted while the core throttles via ioctl_wait.
// Holding it high across wait cycles (the old behavior) breaks
// any core logic that treats each wr assertion as a new byte
// (e.g. the SDRAM_SIM ch2 upload channel's req/ack toggle).
*ioctl_wr = 0;
}
else if (*ioctl_wr) {
// One-shot, and this is the half that was missing. ioctl_wait
// alone is not enough: whenever `ready` stays high for two cycles
// the old code left wr high and advanced to the next byte anyway,
// so the SDRAM controller -- which EDGE-detects `we` -- never saw
// a new request and that byte vanished. It dropped every second
// byte of the tape, which is why a .t77 loaded with all its levels
// correct but nearly all its durations reading back as zero, and
// why F-BASIC sat on "Searching" forever (TODO.md P4-4). Insert a
// gap so the next assertion is always a fresh edge. hps_io does
// exactly this on hardware: `ioctl_wr <= wr; wr <= 0;`.
*ioctl_wr = 0;
}
else {
*ioctl_download = 1;
*ioctl_wr = 1;
if (feof(ioctl_file)) {
fclose(ioctl_file);
ioctl_file = NULL;
*ioctl_download = 0;
*ioctl_wr = 0;
console.AddLog("ioctl_download complete %d", ioctl_next_addr);
fprintf(stderr, "IOCTL: Download complete, %d bytes\n", ioctl_next_addr);
}
if (ioctl_file) {
int curchar = fgetc(ioctl_file);
if (feof(ioctl_file) == 0) {
nextchar = curchar;
//console.AddLog("ioctl_download: dout %x \n", *ioctl_dout);
ioctl_next_addr++;
}
}
}
}
else {
*ioctl_download = 0;
*ioctl_wr = 0;
}
}
void SimBus::AfterEval()
{
*ioctl_addr = ioctl_next_addr;
*ioctl_dout = (unsigned char)nextchar;
if (ioctl_file) {
// console.AddLog("ioctl_download %x wr %x dl %x\n", *ioctl_addr, *ioctl_wr, *ioctl_download);
}
}
SimBus::SimBus(DebugConsole c) {
console = c;
ioctl_addr = NULL;
ioctl_index = NULL;
ioctl_wait = NULL;
ioctl_download = NULL;
ioctl_upload = NULL;
ioctl_wr = NULL;
ioctl_dout = NULL;
ioctl_din = NULL;
}
SimBus::~SimBus() {
}
+58
View File
@@ -0,0 +1,58 @@
#pragma once
#include <queue>
#include "verilated.h"
#include "sim_console.h"
#ifndef _MSC_VER
#else
#define WIN32
#endif
struct SimBus_DownloadChunk {
public:
std::string file;
int index;
bool restart;
SimBus_DownloadChunk() {
file = "";
index = -1;
}
SimBus_DownloadChunk(std::string file, int index) {
SimBus_DownloadChunk(file, index, false);
}
SimBus_DownloadChunk(std::string file, int index, bool restart) {
this->restart = restart;
this->file = std::string(file);
this->index = index;
}
};
struct SimBus {
public:
IData* ioctl_addr;
CData* ioctl_index;
CData* ioctl_wait;
CData* ioctl_download;
CData* ioctl_upload;
CData* ioctl_wr;
CData* ioctl_dout;
CData* ioctl_din;
void BeforeEval(void);
void AfterEval(void);
void QueueDownload(std::string file, int index);
void QueueDownload(std::string file, int index, bool restart);
bool HasQueue();
SimBus(DebugConsole c);
~SimBus();
private:
std::queue<SimBus_DownloadChunk> downloadQueue;
SimBus_DownloadChunk currentDownload;
void SetDownload(std::string file, int index);
};
+39
View File
@@ -0,0 +1,39 @@
#include "sim_clock.h"
#include <string>
SimClock::SimClock() {
ratio = 1;
count = 0;
clk = false;
old = false;
}
SimClock::SimClock(int r) {
ratio = r;
count = 0;
clk = false;
old = false;
}
SimClock::~SimClock() {
}
void SimClock::Tick() {
old = clk;
count++;
if (count > ratio) {
count = 0;
}
clk = (count == 0);
}
void SimClock::Reset() {
count = 0;
clk = false;
old = false;
}
bool SimClock::IsRising() {
return clk && !old;
}
+18
View File
@@ -0,0 +1,18 @@
#pragma once
class SimClock
{
public:
bool clk, old;
SimClock();
SimClock(int r);
~SimClock();
void Tick();
void Reset();
bool IsRising();
private:
int ratio, count;
};
+370
View File
@@ -0,0 +1,370 @@
#include "sim_console.h"
#include <string>
#include "imgui.h"
// Demonstrate creating a simple console window, with scrolling, filtering, completion and history.
// For the console example, here we are using a more C++ like approach of declaring a class to hold the data and the functions.
struct RevFilter : ImGuiTextFilter
{
unsigned int ChangeCount = 0;
void Clear() { InputBuf[0] = 0; Build(); ChangeCount++; }
void Draw(const char* label, float width) {
if (ImGuiTextFilter::Draw(label, width))
ChangeCount++;
}
};
char InputBuf[256];
ImVector<const char*> Commands;
ImVector<char*> History;
int HistoryPos; // -1: new line, 0..History.Size-1 browsing history.
RevFilter Filter;
unsigned int OldFilterCount;
bool AutoScroll;
bool ScrollToBottom;
ImVector<char*> Items;
ImVector<char*> FilteredItems;
static char* Strdup(const char* str) { size_t len = strlen(str) + 1; void* buf = malloc(len); IM_ASSERT(buf); return (char*)memcpy(buf, (const void*)str, len); }
//void DebugConsole::AddLog(const char* fmt, ...) IM_FMTARGS(2)
void DebugConsole::AddLog(const char* fmt, ...)
{
// FIXME-OPT
char buf[1024];
va_list args;
va_start(args, fmt);
vsnprintf(buf, IM_ARRAYSIZE(buf), fmt, args);
buf[IM_ARRAYSIZE(buf) - 1] = 0;
va_end(args);
Items.push_back(Strdup(buf));
if (Filter.IsActive() && Filter.PassFilter(buf))
FilteredItems.push_back(Strdup(buf));
}
DebugConsole::DebugConsole()
{
ClearLog();
memset(InputBuf, 0, sizeof(InputBuf));
HistoryPos = -1;
Commands.push_back("HELP");
Commands.push_back("HISTORY");
Commands.push_back("CLEAR");
AutoScroll = true;
ScrollToBottom = false;
AddLog("Sim start");
AddLog("");
}
DebugConsole::~DebugConsole()
{
ClearLog();
/*for (int i = 0; i < History.Size; i++)
free(History[i]);*/
}
// Portable helpers
static int Stricmp(const char* str1, const char* str2) { int d; while ((d = toupper(*str2) - toupper(*str1)) == 0 && *str1) { str1++; str2++; } return d; }
static int Strnicmp(const char* str1, const char* str2, int n) { int d = 0; while (n > 0 && (d = toupper(*str2) - toupper(*str1)) == 0 && *str1) { str1++; str2++; n--; } return d; }
static void Strtrim(char* str) { char* str_end = str + strlen(str); while (str_end > str && str_end[-1] == ' ') str_end--; *str_end = 0; }
void DebugConsole::ClearLogTop(int n)
{
for (int i=0;i<n;i++)
Items.erase(Items.begin());
if (Filter.IsActive())
{
ClearFiltered();
CopyFiltered();
}
}
void DebugConsole::ClearFiltered()
{
for (int i = 0; i < FilteredItems.Size; i++)
free(FilteredItems[i]);
FilteredItems.clear();
}
void DebugConsole::CopyFiltered()
{
if (!Filter.IsActive())
return;
for (int i = 0; i < Items.Size; i++)
if (Filter.IsActive() && Filter.PassFilter(Items[i]))
FilteredItems.push_back(Strdup(Items[i]));
}
void DebugConsole::ClearLog()
{
for (int i = 0; i < Items.Size; i++)
free(Items[i]);
Items.clear();
ClearFiltered();
}
void DebugConsole::Draw(const char* title, bool* p_open, ImVec2 size)
{
ImGui::SetWindowSize(title, size, ImGuiCond_Once);
if (!ImGui::Begin(title, p_open))
{
ImGui::End();
return;
}
// As a specific feature guaranteed by the library, after calling Begin() the last Item represent the title bar. So e.g. IsItemHovered() will return true when hovering the title bar.
// Here we create a context menu only available from the title bar.
if (ImGui::BeginPopupContextItem())
{
if (ImGui::MenuItem("Close Console"))
*p_open = false;
ImGui::EndPopup();
}
//ImGui::TextWrapped("This example implements a console with basic coloring, completion and history. A more elaborate implementation may want to store entries along with extra data such as timestamp, emitter, etc.");
//ImGui::TextWrapped("Enter 'HELP' for help, press TAB to use text completion.");
// TODO: display items starting from the bottom
if (ImGui::SmallButton("Clear 10,000")) { ClearLogTop(10000); } ImGui::SameLine();
if (ImGui::SmallButton("Clear")) { ClearLog(); } ImGui::SameLine();
bool copy_to_clipboard = ImGui::SmallButton("Copy");
ImGui::Separator();
// Options menu
if (ImGui::BeginPopup("Options"))
{
ImGui::Checkbox("Auto-scroll", &AutoScroll);
ImGui::EndPopup();
}
// Options, Filter
if (ImGui::Button("Options"))
ImGui::OpenPopup("Options");
ImGui::SameLine();
Filter.Draw("Filter (\"incl,-excl\") (\"error\")", 180);
ImGui::Separator();
const float footer_height_to_reserve = ImGui::GetStyle().ItemSpacing.y + ImGui::GetFrameHeightWithSpacing(); // 1 separator, 1 input text
ImGui::BeginChild("ScrollingRegion", ImVec2(0, -footer_height_to_reserve), false, ImGuiWindowFlags_HorizontalScrollbar); // Leave room for 1 separator + 1 InputText
if (ImGui::BeginPopupContextWindow())
{
if (ImGui::Selectable("Clear")) ClearLog();
ImGui::EndPopup();
}
// Display every line as a separate entry so we can change their color or add custom widgets. If you only want raw text you can use ImGui::TextUnformatted(log.begin(), log.end());
// NB- if you have thousands of entries this approach may be too inefficient and may require user-side clipping to only process visible items.
// You can seek and display only the lines that are visible using the ImGuiListClipper helper, if your elements are evenly spaced and you have cheap random access to the elements.
// To use the clipper we could replace the 'for (int i = 0; i < Items.Size; i++)' loop with:
// ImGuiListClipper clipper(Items.Size);
// while (clipper.Step())
// for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
// However, note that you can not use this code as is if a filter is active because it breaks the 'cheap random-access' property. We would need random-access on the post-filtered list.
// A typical application wanting coarse clipping and filtering may want to pre-compute an array of indices that passed the filtering test, recomputing this array when user changes the filter,
// and appending newly elements as they are inserted. This is left as a task to the user until we can manage to improve this example code!
// If your items are of variable size you may want to implement code similar to what ImGuiListClipper does. Or split your data into fixed height items to allow random-seeking into your list.
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4, 1)); // Tighten spacing
if (copy_to_clipboard)
ImGui::LogToClipboard();
// for (int i = 0; i < Items.Size; i++)
ImVector<char*>& DispItems = Filter.IsActive() ? FilteredItems : Items;
ImGuiListClipper clipper(DispItems.Size);
while (clipper.Step())
for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
{
const char* item = DispItems[i];
// Normally you would store more information in your item (e.g. make Items[] an array of structure, store color/type etc.)
bool pop_color = false;
if (strstr(item, "[error]")) { ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.4f, 0.4f, 1.0f)); pop_color = true; }
else if (strncmp(item, "# ", 2) == 0) { ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.8f, 0.6f, 1.0f)); pop_color = true; }
ImGui::TextUnformatted(item);
if (pop_color)
ImGui::PopStyleColor();
}
if (copy_to_clipboard)
ImGui::LogFinish();
if (ScrollToBottom || (AutoScroll && ImGui::GetScrollY() >= ImGui::GetScrollMaxY()))
ImGui::SetScrollHereY(1.0f);
ScrollToBottom = false;
if (OldFilterCount != Filter.ChangeCount)
{
ClearFiltered();
CopyFiltered();
OldFilterCount = Filter.ChangeCount;
}
ImGui::PopStyleVar();
ImGui::EndChild();
ImGui::Separator();
// Command-line
bool reclaim_focus = false;
if (ImGui::InputText("Input", InputBuf, IM_ARRAYSIZE(InputBuf), ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackCompletion | ImGuiInputTextFlags_CallbackHistory,
[](ImGuiInputTextCallbackData * data)->int { DebugConsole* console = (DebugConsole*)data->UserData; return console->TextEditCallback(data); }, (void*)this))
{
char* s = InputBuf;
Strtrim(s);
if (s[0])
ExecCommand(s);
strcpy(s, "");
reclaim_focus = true;
}
// Auto-focus on window apparition
ImGui::SetItemDefaultFocus();
if (reclaim_focus)
ImGui::SetKeyboardFocusHere(-1); // Auto focus previous widget
ImGui::End();
}
void DebugConsole::ExecCommand(const char* command_line)
{
AddLog("# %s\n", command_line);
// Insert into history. First find match and delete it so it can be pushed to the back. This isn't trying to be smart or optimal.
HistoryPos = -1;
for (int i = History.Size - 1; i >= 0; i--)
if (Stricmp(History[i], command_line) == 0)
{
free(History[i]);
History.erase(History.begin() + i);
break;
}
History.push_back(Strdup(command_line));
// Process command
if (Stricmp(command_line, "CLEAR") == 0)
{
ClearLog();
}
else if (Stricmp(command_line, "HELP") == 0)
{
this->AddLog("Commands:");
for (int i = 0; i < Commands.Size; i++)
this->AddLog("- %s", Commands[i]);
}
else if (Stricmp(command_line, "HISTORY") == 0)
{
int first = History.Size - 10;
for (int i = first > 0 ? first : 0; i < History.Size; i++)
this->AddLog("%3d: %s\n", i, History[i]);
}
else
{
this->AddLog("Unknown command: '%s'\n", command_line);
}
// On commad input, we scroll to bottom even if AutoScroll==false
ScrollToBottom = true;
}
int DebugConsole::TextEditCallback(ImGuiInputTextCallbackData* data)
{
//AddLog("cursor: %d, selection: %d-%d", data->CursorPos, data->SelectionStart, data->SelectionEnd);
switch (data->EventFlag)
{
case ImGuiInputTextFlags_CallbackCompletion:
{
// Example of TEXT COMPLETION
// Locate beginning of current word
const char* word_end = data->Buf + data->CursorPos;
const char* word_start = word_end;
while (word_start > data->Buf)
{
const char c = word_start[-1];
if (c == ' ' || c == '\t' || c == ',' || c == ';')
break;
word_start--;
}
// Build a list of candidates
ImVector<const char*> candidates;
for (int i = 0; i < Commands.Size; i++)
if (Strnicmp(Commands[i], word_start, (int)(word_end - word_start)) == 0)
candidates.push_back(Commands[i]);
if (candidates.Size == 0)
{
// No match
DebugConsole::AddLog("No match for \"%.*s\"!\n", (int)(word_end - word_start), word_start);
}
else if (candidates.Size == 1)
{
// Single match. Delete the beginning of the word and replace it entirely so we've got nice casing
data->DeleteChars((int)(word_start - data->Buf), (int)(word_end - word_start));
data->InsertChars(data->CursorPos, candidates[0]);
data->InsertChars(data->CursorPos, " ");
}
else
{
// Multiple matches. Complete as much as we can, so inputing "C" will complete to "CL" and display "CLEAR" and "CLASSIFY"
int match_len = (int)(word_end - word_start);
for (;;)
{
int c = 0;
bool all_candidates_matches = true;
for (int i = 0; i < candidates.Size && all_candidates_matches; i++)
if (i == 0)
c = toupper(candidates[i][match_len]);
else if (c == 0 || c != toupper(candidates[i][match_len]))
all_candidates_matches = false;
if (!all_candidates_matches)
break;
match_len++;
}
if (match_len > 0)
{
data->DeleteChars((int)(word_start - data->Buf), (int)(word_end - word_start));
data->InsertChars(data->CursorPos, candidates[0], candidates[0] + match_len);
}
// List matches
this->AddLog("Possible matches:\n");
for (int i = 0; i < candidates.Size; i++)
this->AddLog("- %s\n", candidates[i]);
}
break;
}
case ImGuiInputTextFlags_CallbackHistory:
{
// Example of HISTORY
const int prev_history_pos = HistoryPos;
if (data->EventKey == ImGuiKey_UpArrow)
{
if (HistoryPos == -1)
HistoryPos = History.Size - 1;
else if (HistoryPos > 0)
HistoryPos--;
}
else if (data->EventKey == ImGuiKey_DownArrow)
{
if (HistoryPos != -1)
if (++HistoryPos >= History.Size)
HistoryPos = -1;
}
// A better implementation would preserve the data on the current input line along with cursor position.
if (prev_history_pos != HistoryPos)
{
const char* history_str = (HistoryPos >= 0) ? History[HistoryPos] : "";
data->DeleteChars(0, data->BufTextLen);
data->InsertChars(0, history_str);
}
}
}
return 0;
};
+16
View File
@@ -0,0 +1,16 @@
#pragma once
#include "imgui.h"
struct DebugConsole {
public:
void AddLog(const char* fmt, ...) IM_FMTARGS(2);
DebugConsole();
~DebugConsole();
void ClearFiltered();
void CopyFiltered();
void ClearLog();
void ClearLogTop(int);
void Draw(const char* title, bool* p_open, ImVec2 size);
void ExecCommand(const char* command_line);
int TextEditCallback(ImGuiInputTextCallbackData* data);
};
+703
View File
@@ -0,0 +1,703 @@
#include "sim_console.h"
#include "sim_input.h"
#include <string>
#include <stdlib.h>
#ifndef _MSC_VER
#include <SDL2/SDL.h>
extern bool headless; // defined in sim_main.cpp
int m_keyboardStateCount;
const Uint8* m_keyboardState;
Uint8* m_keyboardState_last = NULL;
#else
#define WIN32
#include <dinput.h>
//#define DIRECTINPUT_VERSION 0x0800
IDirectInput8* m_directInput;
IDirectInputDevice8* m_keyboard;
unsigned char m_keyboardState[256];
unsigned char m_keyboardState_last[256];
#endif
#include <vector>
static DebugConsole console;
#ifdef WIN32
static const unsigned int ev2ps2[] =
{
NONE, //0 KEY_RESERVED
0x76, //1 KEY_ESC
0x16, //2 KEY_1
0x1e, //3 KEY_2
0x26, //4 KEY_3
0x25, //5 KEY_4
0x2e, //6 KEY_5
0x36, //7 KEY_6
0x3d, //8 KEY_7
0x3e, //9 KEY_8
0x46, //10 KEY_9
0x45, //11 KEY_0
0x4e, //12 KEY_MINUS
0x55, //13 KEY_EQUAL
0x66, //14 KEY_BACKSPACE
0x0d, //15 KEY_TAB
0x15, //16 KEY_Q
0x1d, //17 KEY_W
0x24, //18 KEY_E
0x2d, //19 KEY_R
0x2c, //20 KEY_T
0x35, //21 KEY_Y
0x3c, //22 KEY_U
0x43, //23 KEY_I
0x44, //24 KEY_O
0x4d, //25 KEY_P
0x54, //26 KEY_LEFTBRACE
0x5b, //27 KEY_RIGHTBRACE
0x5a, //28 KEY_ENTER
0x14, //29 KEY_LEFTCTRL
0x1c, //30 KEY_A
0x1b, //31 KEY_S
0x23, //32 KEY_D
0x2b, //33 KEY_F
0x34, //34 KEY_G
0x33, //35 KEY_H
0x3b, //36 KEY_J
0x42, //37 KEY_K
0x4b, //38 KEY_L
0x4c, //39 KEY_SEMICOLON
0x52, //40 KEY_APOSTROPHE
0x0e, //41 KEY_GRAVE
0x12, //42 KEY_LEFTSHIFT
0x5d, //43 KEY_BACKSLASH
0x1a, //44 KEY_Z
0x22, //45 KEY_X
0x21, //46 KEY_C
0x2a, //47 KEY_V
0x32, //48 KEY_B
0x31, //49 KEY_N
0x3a, //50 KEY_M
0x41, //51 KEY_COMMA
0x49, //52 KEY_DOT
0x4a, //53 KEY_SLASH
0x59, //54 KEY_RIGHTSHIFT
0x7c, //55 KEY_KPASTERISK
0x11, //56 KEY_LEFTALT
0x29, //57 KEY_SPACE
0x58, //58 KEY_CAPSLOCK
0x05, //59 KEY_F1
0x06, //60 KEY_F2
0x04, //61 KEY_F3
0x0c, //62 KEY_F4
0x03, //63 KEY_F5
0x0b, //64 KEY_F6
0x83, //65 KEY_F7
0x0a, //66 KEY_F8
0x01, //67 KEY_F9
0x09, //68 KEY_F10
EMU_SWITCH_2 | 0x77, //69 KEY_NUMLOCK
EMU_SWITCH_1 | 0x7E, //70 KEY_SCROLLLOCK
0x6c, //71 KEY_KP7
0x75, //72 KEY_KP8
0x7d, //73 KEY_KP9
0x7b, //74 KEY_KPMINUS
0x6b, //75 KEY_KP4
0x73, //76 KEY_KP5
0x74, //77 KEY_KP6
0x79, //78 KEY_KPPLUS
0x69, //79 KEY_KP1
0x72, //80 KEY_KP2
0x7a, //81 KEY_KP3
0x70, //82 KEY_KP0
0x71, //83 KEY_KPDOT
NONE, //84 ???
NONE, //85 KEY_ZENKAKU
0x61, //86 KEY_102ND
0x78, //87 KEY_F11
0x07, //88 KEY_F12
NONE, //89 KEY_RO
NONE, //90 KEY_KATAKANA
NONE, //91 KEY_HIRAGANA
NONE, //92 KEY_HENKAN
NONE, //93 KEY_KATAKANA
NONE, //94 KEY_MUHENKAN
NONE, //95 KEY_KPJPCOMMA
EXT | 0x5a, //96 KEY_KPENTER
EXT | 0x14, //97 KEY_RIGHTCTRL
EXT | 0x4a, //98 KEY_KPSLASH
0xE2, //99 KEY_SYSRQ
EXT | 0x11, //100 KEY_RIGHTALT
NONE, //101 KEY_LINEFEED
EXT | 0x6c, //102 KEY_HOME
EXT | 0x75, //103 KEY_UP
EXT | 0x7d, //104 KEY_PAGEUP
EXT | 0x6b, //105 KEY_LEFT
EXT | 0x74, //106 KEY_RIGHT
EXT | 0x69, //107 KEY_END
EXT | 0x72, //108 KEY_DOWN
EXT | 0x7a, //109 KEY_PAGEDOWN
EXT | 0x70, //110 KEY_INSERT
EXT | 0x71, //111 KEY_DELETE
NONE, //112 KEY_MACRO
NONE, //113 KEY_MUTE
NONE, //114 KEY_VOLUMEDOWN
NONE, //115 KEY_VOLUMEUP
NONE, //116 KEY_POWER
NONE, //117 KEY_KPEQUAL
NONE, //118 KEY_KPPLUSMINUS
0xE1, //119 KEY_PAUSE
NONE, //120 KEY_SCALE
NONE, //121 KEY_KPCOMMA
NONE, //122 KEY_HANGEUL
NONE, //123 KEY_HANJA
NONE, //124 KEY_YEN
EXT | 0x1f, //125 KEY_LEFTMETA
EXT | 0x27, //126 KEY_RIGHTMETA
NONE, //127 KEY_COMPOSE
NONE, //128 KEY_STOP
NONE, //129 KEY_AGAIN
NONE, //130 KEY_PROPS
NONE, //131 KEY_UNDO
NONE, //132 KEY_FRONT
NONE, //133 KEY_COPY
NONE, //134 KEY_OPEN
NONE, //135 KEY_PASTE
NONE, //136 KEY_FIND
NONE, //137 KEY_CUT
NONE, //138 KEY_HELP
NONE, //139 KEY_MENU
NONE, //140 KEY_CALC
NONE, //141 KEY_SETUP
NONE, //142 KEY_SLEEP
NONE, //143 KEY_WAKEUP
NONE, //144 KEY_FILE
NONE, //145 KEY_SENDFILE
NONE, //146 KEY_DELETEFILE
NONE, //147 KEY_XFER
NONE, //148 KEY_PROG1
NONE, //149 KEY_PROG2
NONE, //150 KEY_WWW
NONE, //151 KEY_MSDOS
NONE, //152 KEY_SCREENLOCK
NONE, //153 KEY_DIRECTION
NONE, //154 KEY_CYCLEWINDOWS
NONE, //155 KEY_MAIL
NONE, //156 KEY_BOOKMARKS
NONE, //157 KEY_COMPUTER
NONE, //158 KEY_BACK
NONE, //159 KEY_FORWARD
NONE, //160 KEY_CLOSECD
NONE, //161 KEY_EJECTCD
NONE, //162 KEY_EJECTCLOSECD
NONE, //163 KEY_NEXTSONG
NONE, //164 KEY_PLAYPAUSE
NONE, //165 KEY_PREVIOUSSONG
NONE, //166 KEY_STOPCD
NONE, //167 KEY_RECORD
NONE, //168 KEY_REWIND
NONE, //169 KEY_PHONE
NONE, //170 KEY_ISO
NONE, //171 KEY_CONFIG
NONE, //172 KEY_HOMEPAGE
NONE, //173 KEY_REFRESH
NONE, //174 KEY_EXIT
NONE, //175 KEY_MOVE
NONE, //176 KEY_EDIT
NONE, //177 KEY_SCROLLUP
NONE, //178 KEY_SCROLLDOWN
NONE, //179 KEY_KPLEFTPAREN
NONE, //180 KEY_KPRIGHTPAREN
NONE, //181 KEY_NEW
NONE, //182 KEY_REDO
NONE, //183 KEY_F13
NONE, //184 KEY_F14
NONE, //185 KEY_F15
NONE, //186 KEY_F16
EMU_SWITCH_1 | 1, //187 KEY_F17
EMU_SWITCH_1 | 2, //188 KEY_F18
EMU_SWITCH_1 | 3, //189 KEY_F19
EMU_SWITCH_1 | 4, //190 KEY_F20
NONE, //191 KEY_F21
NONE, //192 KEY_F22
NONE, //193 KEY_F23
0x5D, //194 U-mlaut on DE mapped to backslash
NONE, //195 ???
NONE, //196 ???
NONE, //197 ???
NONE, //198 ???
NONE, //199 ???
EXT | 0x75, //200 KEY_UP
NONE, //201 ???
NONE, //202 ???
EXT | 0x6b, //203 KEY_LEFT
NONE, //204 ???
EXT | 0x74, //205 KEY_RIGHT
NONE, //206 ???
NONE, //207 ???
EXT | 0x72, //208 KEY_DOWN
NONE, //209 ???
NONE, //210 ???
NONE, //211 ???
NONE, //212 ???
NONE, //213 ???
NONE, //214 ???
NONE, //215 ???
NONE, //216 ???
NONE, //217 ???
NONE, //218 ???
NONE, //219 ???
NONE, //220 ???
NONE, //221 ???
NONE, //222 ???
NONE, //223 ???
NONE, //224 ???
NONE, //225 ???
NONE, //226 ???
NONE, //227 ???
NONE, //228 ???
NONE, //229 ???
NONE, //230 ???
NONE, //231 ???
NONE, //232 ???
NONE, //233 ???
NONE, //234 ???
NONE, //235 ???
NONE, //236 ???
NONE, //237 ???
NONE, //238 ???
NONE, //239 ???
NONE, //240 ???
NONE, //241 ???
NONE, //242 ???
NONE, //243 ???
NONE, //244 ???
NONE, //245 ???
NONE, //246 ???
NONE, //247 ???
NONE, //248 ???
NONE, //249 ???
NONE, //250 ???
NONE, //251 ???
NONE, //252 ???
NONE, //253 ???
NONE, //254 ???
NONE //255 ???
};
#else
static const int ev2ps2[] =
{
NONE, //0 KEY_RESERVED
NONE, //1 KEY_RESERVED
NONE, //2 KEY_RESERVED
NONE, //3 KEY_RESERVED
0x1c, //4 KEY_A
0x32, //5 KEY_B
0x21, //6 KEY_C
0x23, //7 KEY_D
0x24, //8 KEY_E
0x2b, //9 KEY_F
0x34, //10 KEY_G
0x33, //11 KEY_H
0x43, //12 KEY_I
0x3b, //13 KEY_J
0x42, //14 KEY_K
0x4b, //15 KEY_L
0x3a, //16 KEY_M
0x31, //17 KEY_N
0x44, //18 KEY_O
0x4d, //19 KEY_P
0x15, //20 KEY_Q
0x2d, //21 KEY_R
0x1b, //22 KEY_S
0x2c, //23 KEY_T
0x3c, //24 KEY_U
0x2a, //25 KEY_V
0x1d, //26 KEY_W
0x22, //27 KEY_X
0x35, //28 KEY_Y
0x1a, //29 KEY_Z
0x16, //30 KEY_1
0x1e, //31 KEY_2
0x26, //32 KEY_3
0x25, //33 KEY_4
0x2e, //34 KEY_5
0x36, //35 KEY_6
0x3d, //36 KEY_7
0x3e, //37 KEY_8
0x46, //38 KEY_9
0x45, //39 KEY_0
0x5a, //40 KEY_ENTER
0x76, //41 KEY_ESC
0x66, //42 KEY_BACKSPACE
0x0d, //43 KEY_TAB
0x29, //44 KEY_SPACE
0x4e, //45 KEY_MINUS
0x55, //46 KEY_EQUAL
0x54, //47 KEY_LEFTBRACE
0x5b, //48 KEY_RIGHTBRACE
0x5d, //49 KEY_BACKSLASH
NONE, //50 KEY_RESERVED
0x4c, //51 KEY_SEMICOLON
0x52, //52 KEY_APOSTROPHE
0x0e, //53 KEY_GRAVE
0x41, //54 KEY_COMMA
0x49, //55 KEY_DOT
0x4a, //56 KEY_SLASH
0x58, //57 KEY_CAPSLOCK
0x05, //58 KEY_F1
0x06, //59 KEY_F2
0x04, //60 KEY_F3
0x0c, //61 KEY_F4
0x03, //62 KEY_F5
0x0b, //63 KEY_F6
0x83, //64 KEY_F7
0x0a, //65 KEY_F8
0x01, //66 KEY_F9
0x09, //67 KEY_F10
0x78, //68 KEY_F11
0x07, //69 KEY_F12
NONE, //70 KEY_PRINT
EMU_SWITCH_1 | 0x7E, //71 KEY_SCROLLLOCK
0xE1, //72 KEY_PAUSE
EXT | 0x70, //73 KEY_INSERT
EXT | 0x6c, //74 KEY_HOME
EXT | 0x7d, //75 KEY_PAGEUP
EXT | 0x71, //76 KEY_DELETE
EXT | 0x69, //77 KEY_END
EXT | 0x7a, //78 KEY_PAGEDOWN
EXT | 0x74, //79 KEY_RIGHT
EXT | 0x6b, //80 KEY_LEFT
EXT | 0x72, //81 KEY_DOWN
EXT | 0x75, //82 KEY_UP
0x77, //83 SDL_SCANCODE_NUMLOCKCLEAR (Mac keypad Clear -> ADB 0x47 via adb.v)
EXT | 0x4a, //84 KEY_KPSLASH
0x7c, //85 KEY_KPASTERISK
0x7b, //86 KEY_KPMINUS
0x79, //87 KEY_KPPLUS
EXT | 0x5a, //88 KEY_KPENTER
0x69, //89 KEY_KP1
0x72, //90 KEY_KP2
0x7a, //91 KEY_KP3
0x6b, //92 KEY_KP4
0x73, //93 KEY_KP5
0x74, //94 KEY_KP6
0x6c, //95 KEY_KP7
0x75, //96 KEY_KP8
0x7d, //97 KEY_KP9
0x70, //98 KEY_KP0
0x71, //99 KEY_KPDOT
0x61, //100 SDL_SCANCODE_NONUSBACKSLASH (102nd key / ISO <> between LShift and Z)
EXT | 0x27, //101 SDL_SCANCODE_APPLICATION (reuse PS/2 R-Windows code -> Option/Closed Apple)
NONE, //102 KEY_POWER
0x0F, //103 SDL_SCANCODE_KP_EQUALS (numeric keypad =)
NONE, //104 KEY_F13
NONE, //105 KEY_F14
NONE, //106 KEY_F15
NONE, //107 KEY_F16
EMU_SWITCH_1 | 1, //108 KEY_F17
EMU_SWITCH_1 | 2, //109 KEY_F18
EMU_SWITCH_1 | 3, //110 KEY_F19
EMU_SWITCH_1 | 4, //111 KEY_F20
NONE, //112 KEY_F21
NONE, //113 KEY_F22
NONE, //114 KEY_F23
NONE, //115 KEY_F24
NONE, //116
NONE, //117 KEY_HELP
NONE, //118
NONE, //119
NONE, //120
NONE, //121
NONE, //122
NONE, //123
NONE, //124
NONE, //125
NONE, //126
NONE, //127
NONE, //128
NONE, //129
NONE, //130
NONE, //131
NONE, //132
NONE, //133
NONE, //134
NONE, //135
NONE, //136
NONE, //137
NONE, //138
NONE, //139
NONE, //140
NONE, //141
NONE, //142
NONE, //143
NONE, //144
NONE, //145
NONE, //146
NONE, //147
NONE, //148
NONE, //149
NONE, //150
NONE, //151
NONE, //152
NONE, //153
NONE, //154
NONE, //155
NONE, //156
NONE, //157
NONE, //158
NONE, //159
NONE, //160
NONE, //161
NONE, //162
NONE, //163
NONE, //164
NONE, //165
NONE, //166
NONE, //167
NONE, //168
NONE, //169
NONE, //170
NONE, //171
NONE, //172
NONE, //173
NONE, //174
NONE, //175
NONE, //176
NONE, //177
NONE, //178
NONE, //179
NONE, //180
NONE, //181
NONE, //182
NONE, //183
NONE, //184
NONE, //185
NONE, //186
NONE, //187
NONE, //188
NONE, //189
NONE, //180
NONE, //191
NONE, //192
NONE, //193
NONE, //194
NONE, //195
NONE, //196
NONE, //197
NONE, //198
NONE, //109
NONE, //200
NONE, //201
NONE, //202
NONE, //203
NONE, //204
NONE, //205
NONE, //206
NONE, //207
NONE, //208
NONE, //209
NONE, //210
NONE, //211
NONE, //212
NONE, //213
NONE, //214
NONE, //215
NONE, //216
NONE, //217
NONE, //218
NONE, //219
NONE, //220
NONE, //221
NONE, //222
NONE, //223
0x14, //224 SDL_SCANCODE_LCTRL
0x12, //225 SDL_SCANCODE_LSHIFT
0x11, //226 SDL_SCANCODE_LALT (Open Apple / Command)
EXT | 0x1F, //227 SDL_SCANCODE_LGUI (Mac ⌘, Win key) -> Closed Apple / Option
EXT | 0x14, //228 SDL_SCANCODE_RCTRL
0x59, //229 SDL_SCANCODE_RSHIFT
EXT | 0x11, //230 SDL_SCANCODE_RALT
EXT | 0x27, //231 SDL_SCANCODE_RGUI (RightGUI) -> Closed Apple / Option (menu key PS/2 code)
};
/* http://www-personal.umich.edu/~bazald/l/api/_s_d_l__scancode_8h.html */
#endif
bool ReadKeyboard()
{
#ifdef WIN32
HRESULT result;
// Read the keyboard device.
result = m_keyboard->GetDeviceState(sizeof(m_keyboardState), (LPVOID)&m_keyboardState);
if (FAILED(result))
{
// If the keyboard lost focus or was not acquired then try to get control back.
if ((result == DIERR_INPUTLOST) || (result == DIERR_NOTACQUIRED)) { m_keyboard->Acquire(); }
else { return false; }
}
#else
if (headless) {
m_keyboardStateCount = 0;
m_keyboardState = nullptr;
return true;
}
m_keyboardState = SDL_GetKeyboardState(&m_keyboardStateCount);
if (!m_keyboardState_last) m_keyboardState_last = (Uint8*)calloc(m_keyboardStateCount, sizeof(Uint8));
////fprintf(stderr,"count: %d\n",m_keyboardStateCount);
#endif
return true;
}
int SimInput::Initialise() {
#ifdef WIN32
m_directInput = 0;
m_keyboard = 0;
HRESULT result;
// Initialize the main direct input interface.
result = DirectInput8Create(GetModuleHandle(nullptr), DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&m_directInput, NULL);
if (FAILED(result)) { return false; }
// Initialize the direct input interface for the keyboard.
result = m_directInput->CreateDevice(GUID_SysKeyboard, &m_keyboard, NULL);
if (FAILED(result)) { return false; }
// Set the data format. In this case since it is a keyboard we can use the predefined data format.
result = m_keyboard->SetDataFormat(&c_dfDIKeyboard);
if (FAILED(result)) { return false; }
// Now acquire the keyboard.
result = m_keyboard->Acquire();
if (FAILED(result)) { return false; }
#endif
return 0;
}
void SimInput::Read() {
// Read keyboard state
bool pr = ReadKeyboard();
// Collect inputs
for (int i = 0; i < inputCount; i++) {
#ifdef WIN32
inputs[i] = m_keyboardState[mappings[i]] & 0x80;
#else
inputs[i] = headless ? 0 : m_keyboardState[mappings[i]];
#endif
}
#ifdef WIN32
for (unsigned char k = 0; k < 220; k++) {
if (m_keyboardState_last[k] != m_keyboardState[k]) {
unsigned int ext = ev2ps2[k] & EXT;
//fprintf(stderr, "ev2ps2[k] = %x ext = %x temp = %x\n", ev2ps2[k], ext, EXT | 0x6b);
SimInput_PS2KeyEvent evt = SimInput_PS2KeyEvent(k, m_keyboardState[k], ext, ev2ps2[k]);
keyEvents.push(evt);
}
m_keyboardState_last[k] = m_keyboardState[k];
}
#else
if (!headless) {
// Caps Lock: macOS SDL delivers the latch as a transient scancode
// blip that polling typically misses, but SDL_GetModState() &
// KMOD_CAPS reflects latch transitions reliably. Synthesize one
// PS/2 key-down activation per toggle; adb.v owns the IIgs latch
// state and ignores the matching physical key-up edge.
static int caps_mod_last = -1;
int caps_mod_now = (SDL_GetModState() & KMOD_CAPS) ? 1 : 0;
if (caps_mod_last == -1) caps_mod_last = caps_mod_now;
if (caps_mod_last != caps_mod_now) {
const unsigned int CAPSLOCK_PS2 = 0x58;
SimInput_PS2KeyEvent evt(57, true, false, CAPSLOCK_PS2);
keyEvents.push(evt);
caps_mod_last = caps_mod_now;
if (m_keyboardState_last && m_keyboardStateCount > 57) {
m_keyboardState_last[57] = caps_mod_now;
}
}
for (int k = 0; k < m_keyboardStateCount; k++) {
if (m_keyboardState_last[k] != m_keyboardState[k]) {
if (suppressScancodes.count(k)) {
// Claimed by the harness (capture hotkeys); never reaches
// the core, so it cannot also type into the machine.
m_keyboardState_last[k] = m_keyboardState[k];
continue;
}
if (k == 57) {
// Caps Lock handled via SDL_GetModState above.
m_keyboardState_last[k] = m_keyboardState[k];
continue;
}
unsigned int mapped = ev2ps2[k];
bool ext = (mapped & EXT) != 0;
SimInput_PS2KeyEvent evt = SimInput_PS2KeyEvent(k, m_keyboardState[k], ext, mapped);
keyEvents.push(evt);
}
m_keyboardState_last[k] = m_keyboardState[k];
}
}
#endif
}
void SimInput::SetMapping(int index, int code) {
//printf("index %d code %d\n", index, code);
if (code < 256)
mappings[index] = code;
else
mappings[index] = 0;
}
void SimInput::CleanUp() {
#ifdef WIN32
// Release keyboard
if (m_keyboard) { m_keyboard->Unacquire(); m_keyboard->Release(); m_keyboard = 0; }
// Release direct input
if (m_directInput) { m_directInput->Release(); m_directInput = 0; }
#endif
}
unsigned int ps2_key_temp;
bool ps2_clock = 1;
void SimInput::BeforeEval()
{
if (keyEventTimer == 0) {
if (keyEvents.size() > 0) {
// Get chunk from queue
SimInput_PS2KeyEvent evt = keyEvents.front();
keyEvents.pop();
//ps2_key_temp = ev2ps2[evt.code];
ps2_key_temp = evt.mapped;
/*fprintf(stderr, "PS2 KEY: code=%02x pressed=%d ext=%d mapped=%02x\n", evt.code, evt.pressed, evt.extended, evt.mapped);*/
if (evt.extended) { ps2_key_temp |= (1UL << 8); }
if (evt.pressed) { ps2_key_temp |= (1UL << 9); }
if (ps2_clock) { ps2_key_temp |= (1UL << 10); }
ps2_clock = !ps2_clock;
*ps2_key = ps2_key_temp;
keyEventTimer = keyEventWait;
}
}
else {
keyEventTimer--;
}
}
SimInput::SimInput(int count, DebugConsole c)
{
inputCount = count;
console = c;
}
SimInput::~SimInput()
{
}
+71
View File
@@ -0,0 +1,71 @@
#pragma once
#ifndef _MSC_VER
#else
#define WIN32
#pragma comment(lib, "dinput8.lib")
#pragma comment(lib, "dxguid.lib")
#endif
#include "verilated.h"
#include <queue>
#include <vector>
#include <set>
struct SimInput_PS2KeyEvent {
public:
char code;
bool pressed;
bool extended;
unsigned int mapped;
SimInput_PS2KeyEvent(char code, bool pressed, bool extended, unsigned int mapped) {
this->code = code;
this->pressed = pressed;
this->extended = extended;
this->mapped = mapped;
}
};
struct SimInput {
public:
int inputCount = 0;
bool inputs[16];
int mappings[16];
SData* ps2_key = NULL;
// Host scancodes the harness claims for itself and must NOT forward to the
// core. The capture hotkeys are ordinary printable keys -- see sim_main.cpp
// for why they are not function keys -- so without this, grabbing a frame
// also types a bracket into whatever the machine is running.
std::set<int> suppressScancodes;
std::queue<SimInput_PS2KeyEvent> keyEvents;
unsigned int keyEventTimer = 0;
unsigned int keyEventWait = 50000;
#define NONE 0xFF
#define LCTRL 0x000100
#define LSHIFT 0x000200
#define LALT 0x000400
#define LGUI 0x000800
#define RCTRL 0x001000
#define RSHIFT 0x002000
#define RALT 0x004000
#define RGUI 0x008000
#define MODMASK 0x00FF00
#define OSD 0x010000 // to be used by OSD, not the core itself
#define OSD_OPEN 0x020000 // OSD key not forwarded to core, but queued in arm controller
#define CAPS_TOGGLE 0x040000 // caps lock toggle behaviour
#define EXT 0x080000
#define EMU_SWITCH_1 0x100000
#define EMU_SWITCH_2 0x200000
void Read();
int Initialise();
void CleanUp();
void SetMapping(int index, int code);
void BeforeEval(void);
SimInput(int count, DebugConsole c);
~SimInput();
};
+509
View File
@@ -0,0 +1,509 @@
#include "sim_video.h"
#include <string>
#ifndef _MSC_VER
#include "imgui_impl_sdl.h"
#include "imgui_impl_opengl2.h"
#include <stdio.h>
#include <SDL.h>
#include <SDL_opengl.h>
#include <sys/time.h>
#else
#define WIN32
#include "imgui_impl_win32.h"
#include "imgui_impl_dx11.h"
#include <d3d11.h>
#include <tchar.h>
#endif
// Renderer variables
// ------------------
int output_width = 512;
int output_height = 512;
int output_rotate = 0;
bool output_vflip = false;
bool output_usevsync = 1;
uint32_t* output_ptr = NULL;
unsigned int output_size;
#ifdef WIN32
HWND hwnd;
WNDCLASSEX wc;
#else
SDL_Window* window;
SDL_GLContext gl_context;
GLuint tex;
#endif
ImTextureID texture_id;
ImGuiIO io;
extern bool headless; // from sim_main.cpp
ImVec4 clear_color = ImVec4(0.25f, 0.35f, 0.40f, 0.80f);
int count_pixel;
int count_line;
int count_frame;
bool last_hblank;
bool last_vblank;
bool last_hsync;
bool last_vsync;
bool frame_ready = 1;
// Statistics
#ifdef WIN32
SYSTEMTIME actualtime;
LONG time_ms;
LONG old_time;
LONG stats_frameTime;
#else
double time_ms;
double old_time;
double stats_frameTime;
#endif
float stats_fps;
int stats_xMax;
int stats_yMax;
int stats_xMin;
int stats_yMin;
#ifndef WIN32
SDL_Renderer* renderer = NULL;
SDL_Texture* texture = NULL;
#else
// DirectX data
static ID3D11Device* g_pd3dDevice = NULL;
static ID3D11DeviceContext* g_pd3dDeviceContext = NULL;
static IDXGIFactory* g_pFactory = NULL;
static ID3D11Buffer* g_pVB = NULL;
static ID3D11Buffer* g_pIB = NULL;
static ID3D10Blob* g_pVertexShaderBlob = NULL;
static ID3D11VertexShader* g_pVertexShader = NULL;
static ID3D11InputLayout* g_pInputLayout = NULL;
static ID3D11Buffer* g_pVertexConstantBuffer = NULL;
static ID3D10Blob* g_pPixelShaderBlob = NULL;
static ID3D11PixelShader* g_pPixelShader = NULL;
static ID3D11SamplerState* g_pFontSampler = NULL;
static ID3D11ShaderResourceView* g_pFontTextureView = NULL;
static ID3D11RasterizerState* g_pRasterizerState = NULL;
static ID3D11BlendState* g_pBlendState = NULL;
static ID3D11DepthStencilState* g_pDepthStencilState = NULL;
static int g_VertexBufferSize = 5000, g_IndexBufferSize = 10000;
static ID3D11Texture2D* texture = NULL;
#endif
#ifdef WIN32
// Data
static IDXGISwapChain* g_pSwapChain = NULL;
static ID3D11RenderTargetView* g_mainRenderTargetView = NULL;
void CreateRenderTarget()
{
ID3D11Texture2D* pBackBuffer;
g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_mainRenderTargetView);
pBackBuffer->Release();
}
void CleanupRenderTarget()
{
if (g_mainRenderTargetView) { g_mainRenderTargetView->Release(); g_mainRenderTargetView = NULL; }
}
HRESULT CreateDeviceD3D(HWND hWnd)
{
// Setup swap chain
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 2;
sd.BufferDesc.Width = output_width;
sd.BufferDesc.Height = output_height;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
UINT createDeviceFlags = 0;
D3D_FEATURE_LEVEL featureLevel;
const D3D_FEATURE_LEVEL featureLevelArray[2] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_0, };
if (D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, featureLevelArray, 2, D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &featureLevel, &g_pd3dDeviceContext) != S_OK)
return E_FAIL;
CreateRenderTarget();
return S_OK;
}
void CleanupDeviceD3D()
{
CleanupRenderTarget();
if (g_pSwapChain) { g_pSwapChain->Release(); g_pSwapChain = NULL; }
if (g_pd3dDeviceContext) { g_pd3dDeviceContext->Release(); g_pd3dDeviceContext = NULL; }
if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = NULL; }
}
extern LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam))
return true;
switch (msg)
{
case WM_SIZE:
if (g_pd3dDevice != NULL && wParam != SIZE_MINIMIZED)
{
CleanupRenderTarget();
g_pSwapChain->ResizeBuffers(0, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam), DXGI_FORMAT_UNKNOWN, 0);
CreateRenderTarget();
}
return 0;
case WM_SYSCOMMAND:
if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu
return 0;
break;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hWnd, msg, wParam, lParam);
}
#else
#endif
SimVideo::SimVideo(int width, int height, int rotate)
{
output_width = width;
output_height = height;
output_size = output_width * output_height * 4;
output_rotate = rotate;
output_vflip = 0;
count_pixel = 0;
count_line = 0;
count_frame = 0;
last_hblank = 0;
last_vblank = 0;
old_time = 0;
stats_frameTime = 0;
stats_fps = 0.0;
stats_xMax = -1000;
stats_yMax = -1000;
stats_xMin = 1000;
stats_yMin = 1000;
}
SimVideo::~SimVideo()
{
}
int SimVideo::Initialise(const char* windowTitle) {
// Setup pointers for video texture
output_ptr = (uint32_t*)malloc(output_size);
#ifdef WIN32
// Create application window
wc = { sizeof(WNDCLASSEX), CS_CLASSDC, WndProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, _T(windowTitle), NULL };
RegisterClassEx(&wc);
hwnd = CreateWindow(wc.lpszClassName, _T(windowTitle), WS_OVERLAPPEDWINDOW, 100, 100, 1600, 1100, NULL, NULL, wc.hInstance, NULL);
// Initialize Direct3D
if (CreateDeviceD3D(hwnd) < 0)
{
CleanupDeviceD3D();
UnregisterClass(wc.lpszClassName, wc.hInstance);
return 1;
}
// Show the window
ShowWindow(hwnd, SW_SHOWDEFAULT);
UpdateWindow(hwnd);
#else
// Setup SDL
if (!headless && SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0)
{
printf("Error: %s\n", SDL_GetError());
return -1;
}
// Setup window (skip when headless)
if (!headless) {
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
window = SDL_CreateWindow("Verilator Simulator", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
gl_context = SDL_GL_CreateContext(window);
SDL_GL_MakeCurrent(window, gl_context);
SDL_GL_SetSwapInterval(0);
}
#endif
// Setup Dear ImGui context (skip when headless)
if (!headless) {
IMGUI_CHECKVERSION();
ImGui::CreateContext();
io = ImGui::GetIO();
(void)io;
ImGui::StyleColorsDark();
}
#ifdef WIN32
// Setup Platform/Renderer bindings
if (!headless) {
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX11_Init(g_pd3dDevice, g_pd3dDeviceContext);
}
#else
// Setup Platform/Renderer bindings
if (!headless) {
ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
ImGui_ImplOpenGL2_Init();
}
#endif
memset(output_ptr, 0xAA, output_size);
#ifdef WIN32
// Upload texture to graphics system
D3D11_TEXTURE2D_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Width = output_width;
desc.Height = output_height;
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
D3D11_SUBRESOURCE_DATA subResource;
subResource.pSysMem = output_ptr;
subResource.SysMemPitch = desc.Width * 4;
subResource.SysMemSlicePitch = 0;
g_pd3dDevice->CreateTexture2D(&desc, &subResource, &texture);
// Create texture view
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
ZeroMemory(&srvDesc, sizeof(srvDesc));
srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = desc.MipLevels;
srvDesc.Texture2D.MostDetailedMip = 0;
g_pd3dDevice->CreateShaderResourceView(texture, &srvDesc, &g_pFontTextureView);
texture->Release();
// Store our identifier
texture_id = (ImTextureID)g_pFontTextureView;
// Create texture sampler
{
D3D11_SAMPLER_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
desc.MipLODBias = 0.f;
desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
desc.MinLOD = 0.f;
desc.MaxLOD = 0.f;
g_pd3dDevice->CreateSamplerState(&desc, &g_pFontSampler);
}
#else
// the texture should match the GPU so it doesn't have to copy
if (!headless) {
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, output_width, output_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, output_ptr);
texture_id = (ImTextureID)tex;
}
#endif
return 0;
}
void SimVideo::UpdateTexture() {
#ifdef WIN32
// Update the texture!
// D3D11_USAGE_DEFAULT MUST be set in the texture description (somewhere above) for this to work.
// (D3D11_USAGE_DYNAMIC is for use with map / unmap.) ElectronAsh.
if (frame_ready) {
g_pd3dDeviceContext->UpdateSubresource(texture, 0, NULL, output_ptr, output_width * 4, 0);
}
// Rendering
ImGui::Render();
g_pd3dDeviceContext->OMSetRenderTargets(1, &g_mainRenderTargetView, NULL);
g_pd3dDeviceContext->ClearRenderTargetView(g_mainRenderTargetView, (float*)&clear_color);
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
g_pSwapChain->Present(output_usevsync, 0); // Present without vsync
#else
if (frame_ready) {
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, output_width, output_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, output_ptr);
}
if (!headless) {
// Rendering
ImGui::Render();
glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
SDL_GL_SwapWindow(window);
}
#endif
frame_ready = 0;
}
void SimVideo::CleanUp() {
#ifdef WIN32
// Close imgui stuff properly...
if (!headless) {
ImGui_ImplDX11_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
}
CleanupDeviceD3D();
DestroyWindow(hwnd);
UnregisterClass(wc.lpszClassName, wc.hInstance);
#else
// Cleanup
if (!headless) {
ImGui_ImplOpenGL2_Shutdown();
ImGui_ImplSDL2_Shutdown();
ImGui::DestroyContext();
SDL_GL_DeleteContext(gl_context);
SDL_DestroyWindow(window);
SDL_Quit();
}
#endif
}
void SimVideo::StartFrame() {
#ifdef WIN32
ImGui_ImplDX11_NewFrame();
ImGui_ImplWin32_NewFrame();
#else
if (!headless) {
ImGui_ImplOpenGL2_NewFrame();
ImGui_ImplSDL2_NewFrame(window);
}
#endif
}
void SimVideo::Clock(bool hblank, bool vblank, bool hsync, bool vsync, uint32_t colour) {
bool de = !(hblank || vblank);
bool hs_falling = (!hsync && last_hsync);
bool hs_rising = (hsync && !last_hsync);
bool hb_falling = (!hblank && last_hblank);
bool hb_rising = (hblank && !last_hblank);
bool vs_falling = (!vsync && last_vsync);
bool vs_rising = (vsync && !last_vsync);
bool vb_falling = (!vblank && last_vblank);
bool vb_rising = (vblank && !last_vblank);
if (!vblank) {
// Next line on end of hblank
if (hb_falling) {
// Increment line and reset pixel count
count_line++;
count_pixel = 0;
}
if (de) {
count_pixel++;
}
}
//frame_ready = 1;
// Reset on vblank falling edge (start of visible frame at vcount=0)
if (vb_falling) {
count_frame++;
count_line = 0;
frame_ready = 1;
#ifdef WIN32
GetSystemTime(&actualtime);
time_ms = (actualtime.wSecond * 1000) + actualtime.wMilliseconds;
#else
struct timeval tv;
gettimeofday(&tv, NULL);
time_ms = (tv.tv_sec) * 1000 + (tv.tv_usec) / 1000; // convert tv_sec & tv_usec to millisecond
#endif
stats_frameTime = time_ms - old_time;
old_time = time_ms;
stats_fps = (float)(1000.0 / stats_frameTime);
}
// Only draw outside of blanks
if (de) {
int ox = count_pixel - 1;
int oy = count_line - 1;
int x = ox, xs = output_width, y = oy;
if (output_rotate == -1) {
// Rotate output by 90 degrees clockwise
y = output_height - ox;
xs = output_width;
x = oy;
}
if (output_rotate == 1) {
// Rotate output by 90 degrees clockwise
y = ox;
xs = output_width;
x = output_width - oy;
}
if (output_vflip) {
y = output_height - y;
}
// Clamp values to stop access violations on texture
if (x < 0) { x = 0; }
if (x > output_width - 1) { x = output_width - 1; }
if (y < 0) { y = 0; }
if (y > output_height - 1) { y = output_height - 1; }
// Generate texture address
uint32_t vga_addr = (y * xs) + x;
// Write pixel to texture
output_ptr[vga_addr] = colour;
}
// Track bounds (debug)
if (count_pixel > stats_xMax) { stats_xMax = count_pixel; }
if (count_line > stats_yMax) { stats_yMax = count_line; }
if (count_pixel < stats_xMin) { stats_xMin = count_pixel; }
if (count_line < stats_yMin) { stats_yMin = count_line; }
last_hblank = hblank;
last_vblank = vblank;
last_hsync = hsync;
last_vsync = vsync;
}
+49
View File
@@ -0,0 +1,49 @@
#pragma once
#include <string>
#include <cstdint>
#ifndef _MSC_VER
#include "imgui_impl_sdl.h"
#include "imgui_impl_opengl2.h"
#else
#define WIN32
#include "imgui_impl_win32.h"
#include "imgui_impl_dx11.h"
#include <d3d11.h>
#include <tchar.h>
#endif
struct SimVideo {
public:
int output_width;
int output_height;
int output_rotate;
bool output_vflip;
int count_pixel;
int count_line;
int count_frame;
float stats_fps;
float stats_frameTime;
int stats_xMax;
int stats_xMin;
int stats_yMax;
int stats_yMin;
ImTextureID texture_id;
SimVideo(int width, int height, int rotate);
~SimVideo();
void UpdateTexture();
void CleanUp();
void StartFrame();
void Clock(bool hblank, bool vblank, bool hsync, bool vsync, uint32_t colour);
int Initialise(const char* windowTitle);
};
// External access to screen buffer for screenshots
extern uint32_t* output_ptr;
extern int output_width;
extern int output_height;
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
Binary file not shown.

After

Width:  |  Height:  |  Size: 7.2 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 7.5 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 6.3 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 7.4 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 6.3 KiB

+123
View File
@@ -0,0 +1,123 @@
#!/usr/bin/env python3
"""Minimal DriveWire 3 server for the sim's --serial-pty.
Serves one or more .dsk images (256-byte sectors, LSN n at offset n*256) to
HDB-DOS DW over the pty the sim prints at start-up:
./obj_dir/Vemu --serial-pty ... & # prints "Serial: ... on pty /dev/ttysNNN"
python3 tests/dwserver.py /dev/ttysNNN tests/hello.dsk
It is a test stand-in for FujiNet / pyDriveWire, covering only what HDB-DOS
uses: READ/READEX/REREAD(EX), WRITE/REWRITE, TIME, INIT/TERM/RESET/NOP and
DWINIT. Every operation is logged. Writes go to memory, never to the file.
Uses only the standard library.
"""
import os
import sys
import termios
import time
import tty
OP_NOP, OP_TIME, OP_INIT, OP_TERM = 0x00, 0x23, 0x49, 0x54
OP_READ, OP_REREAD, OP_READEX, OP_REREADEX = 0x52, 0x72, 0xD2, 0xF2
OP_WRITE, OP_REWRITE, OP_DWINIT = 0x57, 0x77, 0x5A
OP_RESETS = (0xFE, 0xFF, 0xF8)
E_OK, E_CRC, E_NOTRDY = 0x00, 0xF3, 0xF6
def log(msg):
print(f"[dw {time.strftime('%H:%M:%S')}] {msg}", flush=True)
class Port:
def __init__(self, path):
self.fd = os.open(path, os.O_RDWR | os.O_NOCTTY)
tty.setraw(self.fd)
attrs = termios.tcgetattr(self.fd)
attrs[3] &= ~termios.ECHO
termios.tcsetattr(self.fd, termios.TCSANOW, attrs)
def read(self, n):
out = b""
while len(out) < n:
chunk = os.read(self.fd, n - len(out))
if not chunk:
raise EOFError
out += chunk
return out
def write(self, data):
os.write(self.fd, data)
def main():
if len(sys.argv) < 3:
sys.exit(__doc__)
port = Port(sys.argv[1])
disks = [bytearray(open(p, "rb").read()) for p in sys.argv[2:]]
for i, p in enumerate(sys.argv[2:]):
log(f"drive {i}: {p} ({len(disks[i]) // 256} sectors)")
def sector(drive, lsn):
if drive >= len(disks):
return None
d = disks[drive]
off = lsn * 256
return bytes(d[off:off + 256]).ljust(256, b"\x00") if off < len(d) else bytes(256)
while True:
op = port.read(1)[0]
if op in (OP_READEX, OP_REREADEX):
drive, *l = port.read(4)
lsn = (l[0] << 16) | (l[1] << 8) | l[2]
data = sector(drive, lsn)
port.write(data if data is not None else bytes(256))
csum = int.from_bytes(port.read(2), "big")
ok = data is not None and csum == sum(data) & 0xFFFF
err = E_OK if ok else (E_NOTRDY if data is None else E_CRC)
port.write(bytes([err]))
log(f"{'REREADEX' if op == OP_REREADEX else 'READEX'} drive {drive} LSN {lsn}"
f" -> {'ok' if ok else f'error ${err:02X} (their checksum ${csum:04X})'}")
elif op in (OP_READ, OP_REREAD):
drive, *l = port.read(4)
lsn = (l[0] << 16) | (l[1] << 8) | l[2]
data = sector(drive, lsn)
if data is None:
port.write(bytes([E_NOTRDY]))
else:
port.write(bytes([E_OK]) + data + (sum(data) & 0xFFFF).to_bytes(2, "big"))
log(f"READ drive {drive} LSN {lsn}")
elif op in (OP_WRITE, OP_REWRITE):
drive, *l = port.read(4)
lsn = (l[0] << 16) | (l[1] << 8) | l[2]
data = port.read(256)
csum = int.from_bytes(port.read(2), "big")
ok = csum == sum(data) & 0xFFFF and drive < len(disks)
if ok:
d = disks[drive]
need = (lsn + 1) * 256
if len(d) < need:
d.extend(bytes(need - len(d)))
d[lsn * 256:need] = data
port.write(bytes([E_OK if ok else E_CRC]))
log(f"WRITE drive {drive} LSN {lsn} -> {'ok' if ok else 'checksum error'}")
elif op == OP_TIME:
t = time.localtime()
port.write(bytes([t.tm_year - 1900, t.tm_mon, t.tm_mday,
t.tm_hour, t.tm_min, t.tm_sec]))
log("TIME")
elif op == OP_DWINIT:
caps = port.read(1)[0]
port.write(bytes([0x00]))
log(f"DWINIT (client caps ${caps:02X})")
elif op in (OP_INIT, OP_TERM, OP_NOP) or op in OP_RESETS:
log(f"op ${op:02X}")
else:
log(f"unknown op ${op:02X} -- ignored")
if __name__ == "__main__":
try:
main()
except (EOFError, KeyboardInterrupt):
pass
+51
View File
@@ -0,0 +1,51 @@
#!/usr/bin/env bash
#
# Boot a FujiNet cart against the real FujiNet daemon (FujiNet-PC, the same code
# the MiSTer build runs on the HPS), bridged to the sim's RS-232 Pak by a pty.
#
# tests/fujinet_boot.sh FUJINET_DIST CART STOP_FRAME [extra sim args...]
#
# FUJINET_DIST a FujiNet-PC `make dist` directory for FUJINET_TARGET=COCO
# (fujinet binary + data/). A copy is made; the original is not
# touched.
# CONFIG env: fnconfig.ini to start from (default: FujiNet_MiSTer's
# config/fnconfig.ini). Only [Serial] port is changed.
#
# tests/fujinet_boot.sh ~/fn/dist ../../FujiNet_MiSTer/roms/HDBDW3L3_19200.CCC 400 \
# --fast-clocks
#
# Output in $OUT (default fujinet_boot/): sim.log, fujinet.log, screenshot.
set -u
cd "$(dirname "$0")/.."
[ $# -ge 3 ] || { sed -n 3,18p "$0"; exit 2; }
dist=$1; cart=$2; stop=$3; shift 3
config=${CONFIG:-../../FujiNet_MiSTer/config/fnconfig.ini}
out=${OUT:-fujinet_boot}
rm -rf "$out"; mkdir -p "$out/fn"
cp -R "$dist"/. "$out/fn/"
mkdir -p "$out/fn/SD"
./obj_dir/Vemu --headless --cart "$cart" --serial-pty --stop-at-frame "$stop" \
--screenshot "$stop" --screenshot-prefix "$out/shot" --ascii-end "$@" > "$out/sim.log" 2>&1 &
sim=$!
pty=
for _ in $(seq 1 100); do
pty=$(grep -o '/dev/ttys[0-9]*\|/dev/pts/[0-9]*' "$out/sim.log" | head -1)
[ -n "$pty" ] && break
sleep 0.1
done
[ -n "$pty" ] || { echo "sim did not open a pty"; kill $sim; exit 1; }
sed "s|^port=.*|port=$pty|" "$config" > "$out/fn/fnconfig.ini"
echo "sim on $pty; FujiNet config from $config"
( cd "$out/fn" && exec ./fujinet -c fnconfig.ini -s SD ) > "$out/fujinet.log" 2>&1 &
fn=$!
trap 'kill $sim $fn 2>/dev/null' INT TERM
wait $sim
kill $fn 2>/dev/null
echo "--- sim"
grep -E '^\||^Serial' "$out/sim.log" | grep -v '^| *|$'
echo "--- FujiNet (DriveWire lines)"
grep -a -i -E 'drivewire|op_|readex|read |sector|lsn|timeout|checksum|mount|serial' "$out/fujinet.log" | head -60
+46
View File
@@ -0,0 +1,46 @@
#!/usr/bin/env python3
"""Build tests/hello.dsk: a Disk BASIC (DECB) floppy holding one ASCII BASIC
program, HELLO.BAS. Used by run_tests.sh to exercise the FDC path end to end:
wd1793 -> fdc.sv -> hps block device -> sim_blkdevice.
Layout (35 tracks x 18 sectors x 256 bytes, sectors numbered from 1):
track 17 sector 2 FAT, one byte per granule (68 granules of 9 sectors)
track 17 sectors 3-11 directory, 32-byte entries
Granules 0/1 are track 0 sectors 1-9 / 10-18, granule 2k is track k (k<17),
and so on, skipping the directory track.
"""
import os
TRACKS, SECTORS, SSIZE = 35, 18, 256
img = bytearray(b'\xff' * (TRACKS * SECTORS * SSIZE))
def sector(track, sec): # sec is 1-based
off = (track * SECTORS + sec - 1) * SSIZE
return off
prog = b'10 PRINT "HELLO FROM DISK"\r20 PRINT 6*7\r'
# The program goes in granule 0 (track 0, sectors 1..9); it fits in one sector.
img[sector(0, 1):sector(0, 1) + SSIZE] = prog.ljust(SSIZE, b'\x00')
# FAT: granule 0 is the last granule of the file and uses 1 sector.
fat = sector(17, 2)
img[fat:fat + SSIZE] = b'\xff' * SSIZE
img[fat + 0] = 0xC0 | 1
img[fat + 68:fat + SSIZE] = b'\x00' * (SSIZE - 68)
# Directory: first entry HELLO.BAS, BASIC (type 0), ASCII (flag $FF).
d = sector(17, 3)
entry = bytearray(32)
entry[0:8] = b'HELLO '
entry[8:11] = b'BAS'
entry[11] = 0x00 # file type: BASIC program
entry[12] = 0xFF # ASCII
entry[13] = 0 # first granule
entry[14:16] = len(prog).to_bytes(2, 'big') # bytes used in the last sector
img[d:d + 32] = entry
# Unused entries start with $FF ("never used"); the rest of the track is $FF.
out = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'hello.dsk')
open(out, 'wb').write(img)
print(f'wrote {out} ({len(img)} bytes)')