diff --git a/Cargo.toml b/Cargo.toml index fd400a37..c7451d02 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,6 +20,25 @@ developerx = [] # Extended developer logging: breaks on IBE/DBE/ADEL/ADES/TL # reproduces at full JIT speed. Cheap enough to carry in a `lightning` build — # a fixed-size direct-mapped table, no allocation, no hashing. llstats = [] +# REX3 per-GO activity bits and dispatch counters (`rex status`, `perf +# snapshot`): the DIAG_LOOP_EXECUTE_GO / DIAG_LOOP_DRAW_BLOCK flips and the +# jit_go_count / interp_go_count / simd_fill_rows increments. +# +# Each is a lock-prefixed read-modify-write, i.e. a full fence on x86, and the +# per-GO ones fire 3-6 times per primitive on the REX3-Processor thread. After a +# span that touched dozens of cache lines that fence waits on the tail of those +# framebuffer RFOs instead of letting them overlap the next primitive's register +# writes, which at the small-primitive end is a measurable fraction of a GO. +# +# On by default so the monitor and the tests keep working. A last-drops build +# drops it with `--no-default-features` (plus whatever else it wants); the gate +# is deliberately on this flag ALONE rather than `not(lightning)`, so that +# `--features lightning,rexdiag` stays expressible and the cost of these RMWs +# can actually be A/B measured on the build that cares. The per-lock DIAG_LOCK_* +# bits are once per mutex acquisition rather than per primitive, so they stay +# live either way. jit_go_count is load-bearing in tests: several JIT tests +# assert on it to prove they compared compiled code, not the interpreter. +rexdiag = [] # Stale-code detector: verify, at execution time, that the instruction word an # engine is about to run still matches what memory holds at that VA. # @@ -134,7 +153,7 @@ tcache = ["ppmem"] # Panics at the exact diverging access instead of letting corruption surface as # a guest crash much later. Very slow; diagnostic only. tcache_verify = ["tcache"] -default = ["tlbvmap"] +default = ["tlbvmap", "rexdiag"] # Cranelift-based JIT compiler for REX3 graphics draw shaders. rex-jit = ["cranelift-codegen", "cranelift-frontend", "cranelift-jit", "cranelift-module", "cranelift-native"] # JIT v2: physical-page PIC region compiler (see rules/jitv2/jit-v2-design.md). diff --git a/rules/perf/gfifo-backend-experiment.md b/rules/perf/gfifo-backend-experiment.md new file mode 100644 index 00000000..86f1b29d --- /dev/null +++ b/rules/perf/gfifo-backend-experiment.md @@ -0,0 +1,74 @@ +# GFIFO backend: swappable ring for benchmarking — 2026-09-14 + +The CPU→REX3-painter command queue (`src/gfifo.rs`) can be built on any of four +ring implementations, picked at compile time: + +``` +cargo build --release # custom (hand-written, default) +cargo build --release --features gfifo-rtrb # rtrb::RingBuffer +cargo build --release --features gfifo-heapless # heapless::spsc::Queue +cargo build --release --features gfifo-ringbuf # ringbuf::HeapRb (agerasev) +``` + +`rex status` prints the live backend, so a number can never be misattributed to +the wrong build. Enabling two at once is a `compile_error!`, not a silent pick. + +## Why compile-time and not an env var + +A runtime enum would put a dispatch branch on `push`/`peek`/`consume` — the +exact three functions being measured. Feature flags cost four builds but leave +each variant as direct as a hand-written ring. If you want to A/B without +rebuilding, that convenience is paid for out of the measurement itself. + +## Benchmark with `--tribench`, not `--bench` + +`gltest --bench N` measures **fill rate**: a handful of GFIFO commands per +full-screen quad, then ~480k rasterized pixels. That is rasterizer-bound, so it +is nearly blind to the queue — expect it to move very little between backends, +and do not read a flat result there as "the backends are equivalent". + +`gltest --tribench N [--trisize PX]` (added for this) draws many *small* +triangles instead. Per-primitive GL work — and so the REX3 register writes +queued through the GFIFO — dominates, while pixels per primitive stay small. +That is the workload whose cost actually lands on the queue. Default leg length +is 8px; shrink it to push the ratio further toward queue-bound. + +## Things that are easy to get wrong here + +- **`len()` is called off-thread.** The perf monitor, `rex status`, and the + refresh thread all ask for occupancy, and they are neither the producer nor + the consumer. All three third-party backends split into `!Sync` halves that + cannot answer from another thread, so `GFifo` keeps a shared counter for them. + The custom ring still derives `len()` from its own indices (`TRACKS_LEN`), so + the default path pays nothing and keeps its original arithmetic exactly. + +- **The API must stay peek-then-consume, never pop.** The consumer has to + process an entry *completely* — including `execute_go()`, which can rasterize + a whole primitive — before it stops counting as pending, because REX3 register + reads are gated on "is the queue drained". Popping up front would report the + queue empty mid-draw. All four backends support peek-without-advance; that was + the gating requirement when choosing candidates. + +- **Producers are not strictly single.** Usually only the CPU thread pushes, but + MC's VDMA worker does too. They do not overlap in practice (the CPU does not + write REX3 registers mid-DMA) — but three of the four backends are strictly + SPSC, so every push takes `push_lock`. It is uncontended in the common case, + which is the case that matters for throughput. + +- **heapless 0.9 erases the capacity const-generic** from the split halves: + `Producer<'a, T>`, not `Producer<'a, T, N>` — only `Queue` carries `N`. Its + `split()` also borrows the queue, so the queue is boxed and leaked once per + process to give the halves `'static`. That matches the real lifetime (`Rex3` + lives until exit, and `reset()` reuses the queue rather than rebuilding it). + +- **`rtrb` is a hard dependency regardless** — hal2, seeq8003 and net use it — + so `gfifo-rtrb` enables no `dep:`. Making it optional breaks those three. + +## Test coverage + +`cargo test --release [--features gfifo-*] gfifo_tests` runs the same suite +against whichever backend compiled in: SPSC and MPSC ordering/integrity, plus +`len()`-tracks-occupancy, peek-does-not-advance, reset-discards-and-stays-usable, +wraparound (3× depth in lockstep) and fill-to-capacity. The last five were added +with this work — the original two covered ordering only, and `len()`/`reset()`/ +`flush_head()` were untested, which is precisely where the backends differ. diff --git a/rules/rex3/fastclear-cid-divergence.md b/rules/rex3/fastclear-cid-divergence.md new file mode 100644 index 00000000..b020338d --- /dev/null +++ b/rules/rex3/fastclear-cid-divergence.md @@ -0,0 +1,101 @@ +# FASTCLEAR + CID checking: three code paths, two of which ignored CID — 2026-09-15 + +**Status: FIXED.** `rex3_simd` deleted; JIT clears the FASTCLEAR bit when CID checking is +on; regression test `jit_fastclear_with_cid_checking_matches_interp` added and verified to +fail without the fix (interpreter `0x605040` vs JIT `0xabcdef`). + +Kept because the *shape* of the bug is worth remembering: two independent code paths +silently agreed on wrong behaviour, so a comparison test could not see it, and the +first diagnosis was wrong in a way that only measurement caught. + +## What the spec says + +`rex3.pdf` says it three times: + +- DRAWMODE1 bit 17: "**FASTCLEAR** — Enables fast-clear write mode **when CID checking + disabled** (CLIPMODE CIDMATCH = 0xF). Valid with DRAW SPAN/BLOCK only." +- §3.5.5: "No support for any per pixel operations, such as shade, stipple, dither, + blend. Flat fill only, via value previously written by host into the COLORVRAM + register. […] **CID checking is not allowed for this drawing mode.**" +- Programming notes: "**REX3 will disable FASTCLEAR mode if CID checking is enabled.** + Therefore host must setup fast clear operation by writing COLORVRAM and also setting up + DRAWMODE and COLORI (for example) register. This is necessary because GL will not know + if window system invokes CID check." + +So with CID checking on, hardware ignores FASTCLEAR and the draw proceeds as an ordinary +one — which is why the host is told to set up COLORI as well. + +## What IRIS actually does + +There are **three** fastclear implementations, and they do not agree: + +| Path | CID honoured? | +|---|---| +| `execute_go` processor select ([rex3.rs:3862](../../src/rex3.rs)) — `fastclear() && no_cid && no_host` | ✅ yes | +| `rex3_simd::try_fastclear_block` ([rex3_simd.rs:23](../../src/rex3_simd.rs)) | ❌ **no** | +| rex-jit `emit_pixel_write` ([compiler.rs:543](../../src/rex3_jit/compiler.rs)) — `dm1.fastclear() && !is_hostw` | ❌ **no** | + +`try_fastclear_block` runs as a pre-loop bailout at the top of `draw_block` +([rex3.rs:1772](../../src/rex3.rs)), *before* `execute_go` selects a pixel processor. It +gates on fastclear, patterns, host mode and BLOCK adrmode — but never on CIDMATCH — then +fills the whole block with `fastclear_color` and returns `true`. + +**Consequence: the `no_cid` term in `execute_go` is unreachable for BLOCK draws.** The +SIMD bailout has already handled them. It only has effect for SPAN, where no such bailout +runs (`try_src_span_rgb`'s call site is commented out). + +Measured with a 16x16 fastclear BLOCK, `CIDMATCH=0x1`, COLORVRAM=0xABCDEF: interpreter +and JIT both write `0xabcdef` to every pixel. The interpreter *does* select +`process_pixel_draw` — the gate works — but the pixel loop never runs, because +`try_fastclear_block` returned true before it. + +## What I got wrong + +The first version of this note claimed a clean interpreter-vs-JIT divergence: interpreter +correct, JIT wrong. That came from reading `execute_go`'s processor selection and stopping +there. A test built on that prediction **passed**, which is what exposed the error. + +Two lessons worth keeping: + +1. **The pre-loop bailouts in `draw_block` bypass processor selection entirely.** Any + reasoning about "which pixel path runs" that starts at `execute_go` is incomplete + while `rex3_simd` exists. +2. The test that passed was not useless — it falsified the hypothesis. But it was written + to confirm an expected failure, and had it been written with an `assert_ne!` it would + have "passed" for the wrong reason. Probing what each engine actually wrote is what + settled it. + +A second error in that test, found while debugging: `COLORRED` was set to `0x00112233` as +though it were packed RGB24, but in RGB mode `get_colori` reads it as an o12.11 DDA +register (`>> 11`, then clamp), so the general path would have produced black, not the +distinct colour intended. Same class of bug as the vacuous-test fixes in `9340810`. + +## The fix that landed + +1. **`rex3_simd.rs` deleted entirely** (module, both call sites in `draw_block`, the + commented-out span call, and the `simd_fill_rows` counter and its `perf snapshot` + line). It was never SIMD — a prior session confirmed zero vector instructions by + objdump — just the interpreter loop with mode checks hoisted, and its gates shadowed + the interpreter's own. Removing it changed no test result, confirming it was pure + redundancy. The interpreter immediately became spec-correct here, because + `execute_go`'s `no_cid` term finally became reachable for BLOCK draws. +2. **JIT clears the FASTCLEAR bit when `cidmatch != 0xF`**, in `compile_shader` right + after `normalize_dm1` — one edit covering all four `emit_pixel_write` call sites, + rather than threading `cidmatch` through each. +3. **Regression test** `jit_fastclear_with_cid_checking_matches_interp`, verified to fail + with the fix disabled: interpreter `0x605040`, JIT `0xabcdef`. Colour registers are + written as `component << 11` because `get_colori` reads them as o12.11 DDA values — + packed RGB24 would clamp to black and make the test vacuous. + +Suite: 546/0 with `rex-jit`, 498/0 without. + +## Why this was hard to see, and what to take from it + +Two independent implementations were wrong **in the same direction**, so the +JIT-vs-interpreter comparison harness — the tool built precisely to catch engine +disagreement — could not detect it. Agreement between engines is evidence only when at +least one of them is independently known to be right. + +The general lesson: a pre-loop bailout that intercepts a primitive before dispatch can +silently override correctness logic downstream of it, and nothing type-checks that its +gate conditions match the ones it is bypassing. diff --git a/rules/rex3/gfifo-batching-constraints.md b/rules/rex3/gfifo-batching-constraints.md new file mode 100644 index 00000000..41dab2ee --- /dev/null +++ b/rules/rex3/gfifo-batching-constraints.md @@ -0,0 +1,146 @@ +# Batching GFIFO publication: what must still be ordered + +Measured cost of one REX3 register write through the bus, at ~105 MHz emulated +(9.52 ns per guest instruction): + +| component | ns | guest instrs | share | +|---|---|---|---| +| ring push (3 atomics) | 11.6 | 1.2 | 20% | +| **producer/consumer cache-line contention** | **29.2** | **3.1** | **50%** | +| bus path (register match, parked load) | 17.5 | 1.8 | 30% | +| **total `write32`** | **58.3** | **6.1** | | + +The guest issues one store; we charge it six instructions of wall-clock. A +Gouraud span (~8 register writes) costs ~24 guest instructions of queue overhead +against ~5 instructions of actual drawing. + +**Half the cost is contention, not instructions.** Shaving the push itself +targets the 20%. The lever is publishing the tail once per burst instead of once +per entry: hold a producer-local tail across a run of writes, and store it +`Release` once. The consumer's `head`/`tail` traffic then drops by the batch +factor. + +## What batching must not break + +### 1. Read-after-write — the real hazard + +`read32`/`read64` already flush correctly, via `busy_or_val!`: + +```rust +if self.gfxbusy.load(Acquire) || !self.gfifo.is_empty() { + return BusRead32::busy(); // BUS_BUSY == EXEC_RETRY, CPU retries the load +} +``` + +So a read is already a pipeline flush: it returns busy until the queue drains. + +**But `is_empty()` compares `head` against the *published* tail.** Entries held +in an unpublished batch are invisible to it, so the read would see an empty +queue, skip the retry, and return register state from before those writes landed. +A silent stale read, under timing a test would rarely hit. + +**Requirement: publish the batch before the `busy_or_val!` check, in every read +path.** Not after — the check must see the pending entries. + +### 2. GO — already safe + +A GO is not a separate signal: it rides in the queue, either as the 0x0800 bit on +a register write's address or as a `GFIFO_PURE_GO` entry. Queue order is +preserved whatever the publication granularity, so a draw cannot overtake the +register writes that configure it. No flush needed — only the guarantee that the +batch is eventually published so the consumer is not starved (a timer or a +batch-size cap). + +### 3. STATUS reads — must flush + +`STATUS`/`USER_STATUS` is the guest's flow control. It reports `gfifo.len()` and +GFXBUSY: + +```rust +let pending = self.gfifo.len(); +if self.gfxbusy.load(Acquire) || pending > 0 { val |= STATUS_GFXBUSY; } +let level = /* derived from pending */; +``` + +With a deferred tail, `len()` under-reports: the guest sees a shallower queue +than reality, and may conclude the engine is idle while writes sit unpublished. +Worse than a stale register read — it is the signal the guest throttles on. + +**Requirement: publish before reading STATUS.** + +### 3b. DCB — a different bus, no ordering to preserve + +DCB is not "async relative to drawing"; it does not go through the drawing engine +at all. It is a separate physical bus out to VC2/XMAP/CMAP with its own address/ +data registers and its own state machine. `DCBMODE`/`DCBDATA0/1` read and write +straight to `self.dcb` on the CPU thread and never touch `Rex3Context` or the +queue. + +There is no ordering question because there is no shared path. **No flush, either +direction.** + +### 3c. CONFIG — no flush, and none is owed + +`CONFIG` also reads back directly from `self.config` on the CPU thread. But the +reason it needs no flush is different from DCB's: it is not a separate bus, it is +the configuration of *this* FIFO — depth, interrupt thresholds, bus width. + +Hardware offers no ordering guarantee between a CONFIG write and in-flight +drawing, so neither do we. Writing it mid-stream is the driver's problem, and a +driver that does so is expected to have quiesced the engine first. **Accessing +CONFIG assumes you know what you are doing** — that is the contract, not an +implementation shortcut. + +### 4. LSSAVE / LSRESTORE — already safe + +These have side effects beyond storing the value: + +```rust +REX3_LSSAVE => { ctx.lssave = val; ctx.lspatsave = ctx.lspattern; + ctx.lsmode.set_lsrcntsave(ctx.lsmode.lsrcount()); } +REX3_LSRESTORE => { ctx.lsrestore = val; ctx.lspattern = ctx.lspatsave; + ctx.lsmode.set_lsrcount(ctx.lsmode.lsrcntsave()); } +``` + +They run in `process_register` on the **consumer** thread, in queue order, and +mutate `Rex3Context`, which only the consumer touches. So they are already +"top-of-pipe, observable at read or next primitive": the effect happens when the +consumer reaches the entry, and is visible to a later read only because that read +flushes (case 1). Batching does not change their ordering relative to draws. + +No flush needed for these specifically — case 1 covers the observability. + +## Sketch + +Producer-side local tail, published on any of: + +- a **GO** (bit 0x0800, or `GFIFO_PURE_GO`) — for latency, not ordering: the GO + is where the consumer has real work, and it is the natural span boundary + (~8 register writes), so this fires first in practice; +- a **`busy_or_val!` read** or a **STATUS read** — correctness, cases 1 and 3; +- a **batch-size cap of ~8** — backstop. The contention saving is + `29.2/N` ns per write, so N=8 captures 1.78x of the 1.97x ceiling; going to + N=64 buys another 11% while holding entries eight times longer; +- **another producer taking the lock** — there are two (CPU, and MC's VDMA worker + for pixmap blits). A deferred tail must have a single owner, so whoever takes + the lock publishes what it finds pending before adding its own. IRIX does not + run DMA while the CPU writes REX3 registers, but that is an invariant to lean + on, not one to require. + +The `try_push2` capacity check is the model: reserve for the whole batch before +writing any slot, so a full queue never leaves a partial burst. Note the same +retry rule applies — a batch that cannot be published in full must report +`BUS_BUSY` having committed nothing, or the CPU's retry double-pushes (the bug +`try_push2` fixed for the 64-bit pair case). + +## Not yet built + +Written up at the point of understanding the constraints, before implementing. +The contention number (29.2 ns, 50%) is what justifies the work; the cases above +are what makes it correct. + +**One number to re-measure first.** The 29.2 ns came from a consumer thread +spinning as fast as it could drain. A real consumer spends most of its time +*executing* a draw, not polling `tail`, so true contention may be lower and the +batching win correspondingly smaller. Confirm against the real topology before +building this. diff --git a/rules/rex3/hostrw-batching-design.md b/rules/rex3/hostrw-batching-design.md new file mode 100644 index 00000000..569e4017 --- /dev/null +++ b/rules/rex3/hostrw-batching-design.md @@ -0,0 +1,128 @@ +# Batched HOSTRW / VDMA — design sketch + +Not built. Written while the analysis is fresh. + +## What it costs today + +Per 8 bytes transferred, derived from the 58.3 ns push cost measured this +session (~9.52 ns per guest instruction at ~105 MHz emulated): + +**GIO -> Mem (reading pixels out of REX3)** — `mc.rs` `dma_read64` path: + +| step | ns | +|---|---| +| `gfifo_push(REX3_DMA_PURE_GO)` | 58.3 | +| **`wait_idle()` — full pipeline drain, per qword** | ~200 (unmeasured) | +| 8x `translate_addr` + `write8`, **per byte** | ~200 | +| **total** | **~458 ns/qword ≈ 17 MB/s** | + +**Mem -> GIO (writing pixels in)**: + +| step | ns | +|---|---| +| 8x `translate_addr` + read, per byte | ~200 | +| `dma_write64` -> gfifo push | 58.3 | +| **total** | **~258 ns/qword ≈ 31 MB/s** | + +Two separate pathologies: + +1. **`wait_idle()` per qword.** The read path pushes a GO, drains the *entire* + pipeline, reads one latched word, and repeats. That is the double round-trip: + every 8 bytes costs a full producer/consumer synchronisation. +2. **Per-byte TLB translation.** Both directions walk one byte at a time calling + `translate_addr` for each, even when the whole line sits in one page. + +## The design + +Move the bulk transfer *into* the shader, and let VDMA hand it a buffer rather +than a word. + +**HOSTRW becomes an array, and a single transfer is length 1.** No batched-vs- +single special case anywhere: the pixel bodies index `buf[cursor]` instead of +touching a scalar `ctx.hostrw`, and a PIO register access is simply `cursor = 0, +len = 1`. One code path, one shader, no const-selected arm — which is the whole +point of doing it this way rather than adding a parallel batched pipeline. + +### Where the buffer lives — not in `Rex3Context` + +`Rex3Context` is `#[derive(Copy)]` and is serialised field-by-field to TOML on +every snapshot (`save_rex3_context`). A multi-megabyte array inside it would make +each context copy a multi-megabyte memcpy and write ~131k qwords of TOML per +snapshot per megabyte. + +So: **the buffer sits on `Rex3`, beside `fb_rgb`/`fb_aux`; only the cursor and +length live in the context.** The shader already receives the two framebuffers as +pointer arguments — the host buffer is the third, and reaching it costs the same +as reaching a framebuffer. `Rex3Context` grows by ~8 bytes and the snapshot +format is untouched. + +That also keeps the JIT working unchanged: `offset_of!(hostrw)` stays valid for +the cursor field, and Cranelift's existing HOSTRW handling can keep using element +0 until it is taught about the buffer. + +### Writes (Mem -> GIO) + +- Extend HOSTRW backing store from one qword to a real buffer (a few MB). +- VDMA leads the transfer with a **batch-write command** pushed through the + GFIFO: `(buffer, length)` rather than N separate qword pushes. +- The consumer streams the payload into the buffer and hands it to the draw + engine **once**, so the shader consumes host pixels from memory instead of + being fed one qword at a time through `fetch_host_pixel`. + +### Reads (GIO -> Mem) + +- VDMA pushes a **batch-read GO** with the destination buffer and length. +- The shader fills the buffer directly — it already computes every pixel; it just + writes them contiguously instead of latching one at a time into `ctx.hostrw`. +- VDMA consumes the whole buffer in **one** `dma_read` call. + +That removes `wait_idle()` from the per-qword path entirely: one synchronisation +per *batch* instead of per 8 bytes. + +### While in there: fix the per-byte TLB walk + +Translate once per page and copy the run, rather than per byte. A 4KB page holds +512 qwords; at ~25 ns per translation that is most of the remaining cost in both +directions. + +## Constraints this must respect + +- **The pixel bodies already take the host pixel from `ctx`** (`fetch_host_pixel` + / `store_host_pixel`, now in `rex3_generic.rs` and shape-driven). They index + `buf[cursor]` instead of a scalar — and because a single transfer is just + `len = 1`, there is no batched-vs-single branch to select. Same code, same + shader, whatever the length. +- **`host_count`/`host_shift` still govern packing** — 1 to 16 pixels per 64-bit + word depending on HOSTDEPTH/RWPACKED/RWDOUBLE. Batching changes where the words + come from, not how they unpack. +- **`dma_read64`'s ordering inversion must be preserved.** CPU-driven PIO gets + read-then-advance for free; VDMA has no software discard loop, so the current + code pushes a GO, waits, *then* reads. A batch read has the same requirement at + batch granularity: the buffer must be filled before VDMA consumes it. +- **BUS_BUSY/retry discipline.** `dma_write64` spins on BUS_BUSY because the DMA + worker has no EXEC_RETRY. A batch command must either be accepted whole or + rejected whole — the same rule `try_push2` enforces for the 64-bit pair, and + the same bug class if it is got wrong (partial commit + retry = duplicate). +- **Two producers.** CPU and the VDMA worker both push. A batch command occupies + one queue entry, so this does not change the producer-lock story, but the + buffer itself needs a clear owner while in flight. + +## Expected win + +If the batch amortises both `wait_idle()` and the TLB walk over, say, a 4KB page +(512 qwords): + +- read: ~458 ns/qword -> roughly the memcpy cost plus one sync per batch +- write: ~258 ns/qword -> likewise + +Both directions should land in the hundreds of MB/s rather than tens. Worth +measuring rather than promising: the numbers above have one unmeasured term +(`wait_idle`), and the real gain depends on typical transfer length, which the +corpus does not record. + +## Why it also cleans up `mc.rs` + +The current `dma_loop` interleaves address translation, byte packing, direction +handling, zoom/stride bookkeeping and BUS_BUSY spinning in one nest. Batching +splits it: translate a run, hand a slice to the device, advance. The zoom/stride +logic stays, but it stops being tangled with per-byte bus access. diff --git a/rules/rex3/line-plus-host-not-jittable.md b/rules/rex3/line-plus-host-not-jittable.md new file mode 100644 index 00000000..6c12e873 --- /dev/null +++ b/rules/rex3/line-plus-host-not-jittable.md @@ -0,0 +1,84 @@ +# Lines with COLORHOST/ALPHAHOST: legal, but Cranelift refuses them + +`rex shaders list` reports these as `failed`: + +``` +failed 0x0000008a 0x3165f011 0x00001e03 DRAW ILINE ALPHAHOST | RGB 12bpp host:12bpp DITHER BLEND(SA+MSA) +failed 0x0000008a 0x3165f031 0x00001e03 ... + DBLSRC +``` + +`dm0 = 0x8a` decodes to OPCODE=DRAW, ADRMODE=I_LINE, ALPHAHOST=1. They are +rejected by the guard at `rex3_jit/compiler.rs`: + +```rust +if is_line && (is_hostr || is_hostw) { + eprintln!("REX JIT: not jittable (line+host) ..."); + return None; +} +``` + +This is a **deliberate gap in Cranelift's line emitter**, not a compile error and +not an invalid draw mode. + +## The mode is legal — do not sanitise it away + +`rex3.pdf` §3.5.1 (Lines: Overview) and the framebuffer-access paragraph above it: + +> The framebuffer may be accessed as points, **lines**, spans, or blocks of data. +> […] In the following subsections, **"Segments I" refers to packed host data, +> using the HOSTRW registers with COLORHOST or ALPHAHOST set**; "Segments II" +> refers to remaining cases which have DRAWMODE0 bit LENGTH32 set. + +Host-sourced pixels are an access *pattern* available to the framebuffer +generally — lines included — not a span-only feature. DRAWMODE0 bits 6/7 are +documented plainly as "RGB/CI draw source: 0=DDAs; 1=HOSTRW register" and "Alpha +draw source", with no adrmode restriction. + +Nothing in §3.5.1, §3.6 (Line Draw Instructions) or the DRAWMODE0 table excludes +lines. So **`unpack` must not fold COLORHOST/ALPHAHOST to 0 for line adrmodes.** +Doing so would silently drop the alpha source from a blended, dithered Gouraud +line — which is what these two shapes are, i.e. GL drawing antialiased or +translucent lines. + +## What actually runs them + +The generic path handles them correctly and always has: `pixel_draw` fetches the +host pixel on its own terms, and the walker (line/span/block) is orthogonal to +the pixel body. The same is true of a generated LLVM shader — `ConstMode` with +`ALPHAHOST=1` and `ADRMODE=I_LINE` is an ordinary instantiation. + +So the dispatch order already does the right thing: + +1. generated LLVM shader, if the corpus covered the shape +2. Cranelift — declines these +3. generic `DynMode` path — correct for everything + +The only cost of the Cranelift gap is that these shapes miss the *JIT* tier. Once +the corpus records them (it does now — see below) the generator emits real +shaders and they get the fastest tier anyway. + +## Why they were missing from the corpus + +`save_profile` used to persist `cache.keys()` — only shapes Cranelift +successfully compiled. A shape Cranelift *refused* could therefore never enter +the corpus, so the generator never saw it, so it never got an LLVM shader either. +A rejected shape was permanently stuck on the slowest tier. + +Fixed by recording at dispatch (`Rex3::seen_shapes`) rather than at compile, and +by saving in every build rather than only under `rex-jit`. + +## MAME is not a reference here + +`newport.cpp`'s `do_iline`/`do_fline` take a precomputed `color` argument and +never consult the HOSTRW registers — it models no host-on-line support at all. +Consistent with its divergence from the spec on +[shading](shade-dda-clamp-open-question.md) and +[fastclear](fastclear-cid-divergence.md): MAME is the reference for TLB, not for +the REX3 pixel pipeline. + +## If someone wants to close the Cranelift gap + +The line emitter would need the host-pixel fetch the span/block emitter already +has. Low value: the LLVM table covers these shapes now, and the generic path is +correct meanwhile. Worth doing only if a workload appears that draws host-sourced +lines in shapes the table does not cover. diff --git a/rules/rex3/shade-dda-clamp-open-question.md b/rules/rex3/shade-dda-clamp-open-question.md new file mode 100644 index 00000000..ab390606 --- /dev/null +++ b/rules/rex3/shade-dda-clamp-open-question.md @@ -0,0 +1,104 @@ +# Shade DDA clamping: clamped accumulator, or clamped output? — OPEN, 2026-09-15 + +**Unresolved. Needs a real XL Indy to settle.** Do not "optimise" the shade path +on the assumption that the loop-carried DDA value is already clamped until this +is answered — a JIT change resting on exactly that assumption is parked in a +stash for this reason (see the bottom of this note). + +## The question + +`rex3.pdf` (line ~6834 of `pdftotext` output) says: + +> DDA values of R,G,B,A are clamped each iteration before sending down the +> pipeline. As each of these components has an additional, overflow bit at the +> DDA, a normalized range of [-.5 to +1.5) is handled prior to clamping. + +and immediately after: + +> Color index DDA values can be clamped to desired range by setting the +> DRAWMODE0 bit ENCICLAMP. + +Two readings, and they are not equivalent: + +**(A) Clamped accumulator.** The clamp is applied to the DDA register itself +each iteration, so the next `+= slope` starts from the clamped value. This is +what IRIS currently implements: `iterate_shade_rgb_clamp` (rex3.rs) writes the +clamped result back into `ctx.colorred/grn/blue/alpha`. + +**(B) Clamped output only.** The accumulator keeps running unclamped and the +clamp happens where the value is handed to the rest of the pixel path — i.e. +when packing to RGBA8888. "Another turn of the interpolator" is arguably not +"down the pipeline", so the clamp would sit at the boundary, not on the state. + +## Why it matters + +The two agree for any monotonic ramp that stays in range, and for one that +saturates and never comes back. They diverge when a component **overshoots and +returns**: + +- Under (A) the value is pinned at the clamp (0 or 0x7FFFF) and a negative slope + walks back from the *clamped* value. +- Under (B) the accumulator sailed past, and a negative slope walks back from + the true value, so the visible colour stays clamped for longer and then + resumes at a different place. + +Long Gouraud spans with steep slopes are where this shows. Nothing in the +current test suite distinguishes them: `jit_shade_ramp_255_to_0` ramps down from +255 and never exceeds range, and `jit_shade_span_saturate` saturates upward and +stays there. + +## What the other implementations do + +- **IRIS interpreter**: reading (A). RGB clamps every iteration + unconditionally; ENCICLAMP consults only the CI paths + (`iterate_shade_ci8_clamp` / `ci12`), matching "ENCICLAMP governs CI". +- **IRIS rex-jit**: same as the interpreter (`clamp_shade` on the loop-carried + values), so the two engines agree with each other either way. +- **MAME `newport.cpp`** (`iterate_shade`, ~line 3212): gates **even the RGB + clamp** on CICLAMP (DRAWMODE0 bit 21). With CICLAMP clear it does not clamp + RGB at all. That contradicts the spec text above on its face, and contradicts + IRIS. MAME is the reference for TLB conformance; it is evidently *not* a + reference here. + +So all three differ in some respect, and the spec sentence is ambiguous enough +to support two of them. + +## How to settle it on hardware + +Draw one long Gouraud span in RGB mode whose red component overshoots the top of +range and then comes back — e.g. start red near max, positive slope for the +first stretch, then re-issue with a negative slope (or use a slope large enough +that the 21.11 value wraps well past 0x7FFFF and back). Capture the span. + +- Reading (A): red stays pinned at the ceiling and only starts descending after + the *clamped* value minus accumulated slope drops below it. +- Reading (B): red stays at the ceiling longer, then reappears at the value the + unclamped accumulator actually reached. + +Compare against both IRIS engines. Also worth checking the same with CICLAMP set +and clear in RGB mode, which discriminates IRIS from MAME directly. + +## Facts already established (no hardware needed) + +Brute-forced over the full u32 domain, assuming reading (A): + +- `clamp_shade` can **never** produce a value whose `(c >> 11) & 0x1FF` exceeds + 0xFF — 0 cases. Its own saturation constant `0x0007_FFFF` has `val == 0xFF` + exactly. So the `val > 0xFF` arm of `clamp_color_component` is dead code on + shade input, and the per-pixel colour extraction collapses to a plain + shift-and-mask. +- On *raw* (unclamped) input the cheap form differs from the full clamp in + 2.68e9 cases, so under reading (B) the per-pixel clamp is load-bearing and + cannot be reduced. + +That is precisely why the answer changes the optimisation: under (A) the +per-pixel clamp is nearly free to remove; under (B) it is mandatory. + +## The parked work + +A JIT change implementing the (A)-only optimisation — entry-block pre-clamp plus +a reduced per-pixel extraction, gated on `dm1.rgbmode()` — is in +`git stash` (`WIP on main: 3f4aec5`). It passed 530 tests and looked like +roughly +24% on long-span Gouraud across two runs, but that measurement never +got a same-session baseline and one intervening sweep was thermally +contaminated, so the number is unconfirmed as well as the premise. diff --git a/src/lib.rs b/src/lib.rs index 9515a7da..9c6a34ee 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -209,7 +209,9 @@ pub mod hal2; pub mod ps2; pub mod ui; pub mod rex3; -pub mod rex3_simd; +pub mod rex3_generic; +pub mod rex3_shaders; +pub mod rex3_shape; pub mod compositor; pub mod gl_compositor; pub mod headless_gl; @@ -246,6 +248,10 @@ pub mod xz; pub mod mgras; pub mod ultra_proto; pub mod ultra64; +/// Draw-shape corpus persistence. Deliberately NOT behind `rex-jit`: the corpus +/// records what the guest draws, and the generated shader table serves draws in +/// builds with no Cranelift at all. +pub mod rex3_profile; #[cfg(feature = "rex-jit")] pub mod rex3_jit; #[cfg(feature = "jitv2")] diff --git a/src/mc.rs b/src/mc.rs index 2380712f..dc0e0ea7 100644 --- a/src/mc.rs +++ b/src/mc.rs @@ -740,7 +740,18 @@ impl MemoryController { else { mem_vaddr = mem_vaddr.wrapping_sub(1); } shift = shift.wrapping_sub(8); } - phys.dma_write64(gio_addr, data); + // Spin on BUS_BUSY, same as the GIO->Mem read + // path above: the DMA worker has no EXEC_RETRY + // mechanism, so dropping the status here would + // silently lose pixel data whenever REX3's GFIFO + // is full (write64 reports BUS_BUSY rather than + // blocking, so the CPU can retry — but only a + // caller that checks it actually retries). + while phys.dma_write64(gio_addr, data) + == crate::traits::BUS_BUSY + { + std::hint::spin_loop(); + } byte_count = byte_count.saturating_sub(length); } } diff --git a/src/perf_monitor.rs b/src/perf_monitor.rs index 6c97f5d7..55924a37 100644 --- a/src/perf_monitor.rs +++ b/src/perf_monitor.rs @@ -70,6 +70,18 @@ impl PerfMonitor { writeln!(writer, "{}", crate::thread_affinity::status_line()).map_err(|e| e.to_string())?; if let Some(rex) = &self.rex3 { + // The per-GO counters and DIAG_LOOP_* bits are compiled out under + // `lightning` (see the `rexdiag` feature). Say so rather than print + // the frozen zeros they would otherwise report as measurements. + #[cfg(not(feature = "rexdiag"))] + writeln!( + writer, + "REX3 GO: counters disabled in this build (rexdiag off/lightning) gfifo {}/{}", + rex.gfifo.len(), crate::rex3::GFIFO_DEPTH, + ).map_err(|e| e.to_string())?; + + #[cfg(feature = "rexdiag")] + { let jit = rex.jit_go_count.load(Ordering::Relaxed); let interp = rex.interp_go_count.load(Ordering::Relaxed); let total = jit + interp; @@ -77,9 +89,8 @@ impl PerfMonitor { let diag = rex.diag.load(Ordering::Relaxed); writeln!( writer, - "REX3 GO: {} total JIT {}% gfifo {}/{} simd_fills {}", + "REX3 GO: {} total JIT {}% gfifo {}/{}", total, pct, rex.gfifo.len(), crate::rex3::GFIFO_DEPTH, - rex.simd_fill_rows.load(Ordering::Relaxed), ).map_err(|e| e.to_string())?; writeln!( writer, @@ -87,6 +98,7 @@ impl PerfMonitor { diag, rex.gfxbusy.load(Ordering::Relaxed), ).map_err(|e| e.to_string())?; + } #[cfg(feature = "rex-jit")] if let Some(ref jit) = rex.rex_jit { writeln!(writer, "REX3 JIT cache: {} shaders", jit.shader_list().len()).map_err(|e| e.to_string())?; diff --git a/src/rex3.rs b/src/rex3.rs index 45531e29..7ec4345d 100644 --- a/src/rex3.rs +++ b/src/rex3.rs @@ -1,5 +1,6 @@ use std::sync::Arc; -use parking_lot::Mutex; +use std::collections::HashMap; +use parking_lot::{Mutex, RwLock}; use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, AtomicUsize, Ordering}; use std::thread; use crossbeam_utils::CachePadded; @@ -152,7 +153,14 @@ pub const REX3_DCBRESET: u32 = 0x1340; pub(crate) fn decode_dm0(v: u32) -> String { let dm = DrawMode0(v); let opcode = match dm.opcode() { 0=>"NOOP", 1=>"READ", 2=>"DRAW", 3=>"SCR2SCR", _=>"?" }; - let adrmode = match dm.adrmode() { 0=>"SPAN", 1=>"BLOCK", 2=>"ILINE", 3=>"FLINE", 4=>"ALINE", _=>"?" }; + let adrmode = match dm.adrmode() { + DRAWMODE0_ADRMODE_SPAN => "SPAN", + DRAWMODE0_ADRMODE_BLOCK => "BLOCK", + DRAWMODE0_ADRMODE_I_LINE => "ILINE", + DRAWMODE0_ADRMODE_F_LINE => "FLINE", + DRAWMODE0_ADRMODE_A_LINE => "ALINE", + _ => "?", + }; let mut flags = String::new(); if dm.dosetup() { flags.push_str(" DOSETUP"); } if dm.colorhost() { flags.push_str(" COLORHOST"); } @@ -179,8 +187,20 @@ pub(crate) fn decode_dm0(v: u32) -> String { pub(crate) fn decode_dm1(v: u32) -> String { let dm = DrawMode1(v); let planes = match dm.planes() { 0=>"NONE", 1=>"RGB", 2=>"RGBA", 4=>"OLAY", 5=>"PUP", 6=>"CID", _=>"?" }; - let depth = match dm.drawdepth() { 0=>"4bpp", 1=>"8bpp", 2=>"12bpp", 3=>"24bpp", _=>"?" }; - let hdepth = match dm.hostdepth() { 0=>"12bpp", 1=>"8bpp", 2=>"4bpp", 3=>"32bpp", _=>"?" }; + let depth = match dm.drawdepth() { + DRAWMODE1_DRAWDEPTH_4 => "4bpp", + DRAWMODE1_DRAWDEPTH_8 => "8bpp", + DRAWMODE1_DRAWDEPTH_12 => "12bpp", + DRAWMODE1_DRAWDEPTH_24 => "24bpp", + _ => "?", + }; + let hdepth = match dm.hostdepth() { + DRAWMODE1_HOSTDEPTH_12 => "12bpp", + DRAWMODE1_HOSTDEPTH_8 => "8bpp", + DRAWMODE1_HOSTDEPTH_4 => "4bpp", + DRAWMODE1_HOSTDEPTH_32 => "32bpp", + _ => "?", + }; let logicop = match dm.logicop() { 0=>"ZERO",1=>"AND",2=>"ANDR",3=>"SRC",4=>"ANDI",5=>"DST", 6=>"XOR",7=>"OR",8=>"NOR",9=>"XNOR",10=>"NDST",11=>"ORR",12=>"NSRC",13=>"ORI",14=>"NAND",15=>"ONE", _=>"?" }; // rex3 spec Tables 13/14: SFACTOR 010/011 select the *destination* colour while @@ -320,11 +340,19 @@ pub const DRAWMODE0_OPCODE_SCR2SCR: u32 = 0x3; pub const DRAWMODE0_ADRMODE_MASK: u32 = 0x1C; pub const DRAWMODE0_ADRMODE_SHIFT: u32 = 2; -pub const DRAWMODE0_ADRMODE_SPAN: u32 = 0x0 << 2; -pub const DRAWMODE0_ADRMODE_BLOCK: u32 = 0x1 << 2; -pub const DRAWMODE0_ADRMODE_I_LINE: u32 = 0x2 << 2; -pub const DRAWMODE0_ADRMODE_F_LINE: u32 = 0x3 << 2; -pub const DRAWMODE0_ADRMODE_A_LINE: u32 = 0x4 << 2; +// ADRMODE field values — what `dm0_adrmode` returns. Compare against these. +pub const DRAWMODE0_ADRMODE_SPAN: u32 = 0x0; +pub const DRAWMODE0_ADRMODE_BLOCK: u32 = 0x1; +pub const DRAWMODE0_ADRMODE_I_LINE: u32 = 0x2; +pub const DRAWMODE0_ADRMODE_F_LINE: u32 = 0x3; +pub const DRAWMODE0_ADRMODE_A_LINE: u32 = 0x4; + +// Register-position forms (`_SH`), for OR-ing into a DRAWMODE0 word. +pub const DRAWMODE0_ADRMODE_SPAN_SH: u32 = DRAWMODE0_ADRMODE_SPAN << DRAWMODE0_ADRMODE_SHIFT; +pub const DRAWMODE0_ADRMODE_BLOCK_SH: u32 = DRAWMODE0_ADRMODE_BLOCK << DRAWMODE0_ADRMODE_SHIFT; +pub const DRAWMODE0_ADRMODE_I_LINE_SH: u32 = DRAWMODE0_ADRMODE_I_LINE << DRAWMODE0_ADRMODE_SHIFT; +pub const DRAWMODE0_ADRMODE_F_LINE_SH: u32 = DRAWMODE0_ADRMODE_F_LINE << DRAWMODE0_ADRMODE_SHIFT; +pub const DRAWMODE0_ADRMODE_A_LINE_SH: u32 = DRAWMODE0_ADRMODE_A_LINE << DRAWMODE0_ADRMODE_SHIFT; bitfield! { #[derive(Clone, Copy, Default)] @@ -372,6 +400,11 @@ pub const DRAWMODE1_INTERP_SETUP_MASK: u32 = /// colour as DFACTOR (BF_SC/BF_MSC). BF_SA/BF_MSA mean source alpha in both. pub const DRAWMODE1_BF_ZERO: u32 = 0; pub const DRAWMODE1_BF_ONE: u32 = 1; +/// The *other* operand's colour: destination when used as SFACTOR, source when +/// used as DFACTOR. Named BF_DC/BF_SC respectively in the spec tables. +pub const DRAWMODE1_BF_OC: u32 = 2; +/// 255 minus [`DRAWMODE1_BF_OC`] (BF_MDC / BF_MSC). +pub const DRAWMODE1_BF_MOC: u32 = 3; pub const DRAWMODE1_BF_SA: u32 = 4; pub const DRAWMODE1_BF_MSA: u32 = 5; @@ -384,24 +417,75 @@ pub const DRAWMODE1_PLANES_CID: u32 = 6; /// COMPARE=0x7 (all three relations OR'ed) — afunction always passes, i.e. disabled. /// Hardware reset default; real drawmode1 words always carry this explicitly. -pub const DRAWMODE1_COMPARE_DISABLE: u32 = 0x7 << 12; - -pub const DRAWMODE1_LOGICOP_ZERO: u32 = 0 << 28; -pub const DRAWMODE1_LOGICOP_AND: u32 = 1 << 28; -pub const DRAWMODE1_LOGICOP_ANDR: u32 = 2 << 28; -pub const DRAWMODE1_LOGICOP_SRC: u32 = 3 << 28; -pub const DRAWMODE1_LOGICOP_ANDI: u32 = 4 << 28; -pub const DRAWMODE1_LOGICOP_DST: u32 = 5 << 28; -pub const DRAWMODE1_LOGICOP_XOR: u32 = 6 << 28; -pub const DRAWMODE1_LOGICOP_OR: u32 = 7 << 28; -pub const DRAWMODE1_LOGICOP_NOR: u32 = 8 << 28; -pub const DRAWMODE1_LOGICOP_XNOR: u32 = 9 << 28; -pub const DRAWMODE1_LOGICOP_NDST: u32 = 10 << 28; -pub const DRAWMODE1_LOGICOP_ORR: u32 = 11 << 28; -pub const DRAWMODE1_LOGICOP_NSRC: u32 = 12 << 28; -pub const DRAWMODE1_LOGICOP_ORI: u32 = 13 << 28; -pub const DRAWMODE1_LOGICOP_NAND: u32 = 14 << 28; -pub const DRAWMODE1_LOGICOP_ONE: u32 = 15 << 28; +/// COMPARE field position in DRAWMODE1. +pub const DRAWMODE1_COMPARE_SHIFT: u32 = 12; +/// COMPARE=0x7 (all three relations OR'ed) — afunction always passes. +// DRAWDEPTH: bits per pixel in the framebuffer plane. +pub const DRAWMODE1_DRAWDEPTH_4: u32 = 0; +pub const DRAWMODE1_DRAWDEPTH_8: u32 = 1; +pub const DRAWMODE1_DRAWDEPTH_12: u32 = 2; +pub const DRAWMODE1_DRAWDEPTH_24: u32 = 3; + +// HOSTDEPTH: bits per pixel in a host transfer. **Not the same encoding as +// DRAWDEPTH** — the order is 12/8/4/32, not 4/8/12/24. Mixing the two silently +// picks the wrong slot width, which is why both have named constants. +pub const DRAWMODE1_HOSTDEPTH_12: u32 = 0; +pub const DRAWMODE1_HOSTDEPTH_8: u32 = 1; +pub const DRAWMODE1_HOSTDEPTH_4: u32 = 2; +pub const DRAWMODE1_HOSTDEPTH_32: u32 = 3; + +// COMPARE is three OR-able relation bits (spec §3.8.1): LT | EQ | GT. All three +// set (0x7) means every comparison passes, i.e. afunction disabled. +pub const DRAWMODE1_COMPARE_NEVER: u32 = 0x0; +pub const DRAWMODE1_COMPARE_LT: u32 = 0x1; +pub const DRAWMODE1_COMPARE_EQ: u32 = 0x2; +pub const DRAWMODE1_COMPARE_LE: u32 = 0x3; +pub const DRAWMODE1_COMPARE_GT: u32 = 0x4; +pub const DRAWMODE1_COMPARE_NE: u32 = 0x5; +pub const DRAWMODE1_COMPARE_GE: u32 = 0x6; +pub const DRAWMODE1_COMPARE_DISABLE: u32 = 0x7; +pub const DRAWMODE1_COMPARE_DISABLE_SH: u32 = + DRAWMODE1_COMPARE_DISABLE << DRAWMODE1_COMPARE_SHIFT; + +/// LOGICOP field position in DRAWMODE1. +pub const DRAWMODE1_LOGICOP_SHIFT: u32 = 28; +pub const DRAWMODE1_LOGICOP_MASK: u32 = 0xF << DRAWMODE1_LOGICOP_SHIFT; + +// LOGICOP field values — what `dm1_logicop` returns. Compare against these; +// the `_SH` forms below are for OR-ing into a DRAWMODE1 word. +pub const DRAWMODE1_LOGICOP_ZERO: u32 = 0; +pub const DRAWMODE1_LOGICOP_AND: u32 = 1; +pub const DRAWMODE1_LOGICOP_ANDR: u32 = 2; +pub const DRAWMODE1_LOGICOP_SRC: u32 = 3; +pub const DRAWMODE1_LOGICOP_ANDI: u32 = 4; +pub const DRAWMODE1_LOGICOP_DST: u32 = 5; +pub const DRAWMODE1_LOGICOP_XOR: u32 = 6; +pub const DRAWMODE1_LOGICOP_OR: u32 = 7; +pub const DRAWMODE1_LOGICOP_NOR: u32 = 8; +pub const DRAWMODE1_LOGICOP_XNOR: u32 = 9; +pub const DRAWMODE1_LOGICOP_NDST: u32 = 10; +pub const DRAWMODE1_LOGICOP_ORR: u32 = 11; +pub const DRAWMODE1_LOGICOP_NSRC: u32 = 12; +pub const DRAWMODE1_LOGICOP_ORI: u32 = 13; +pub const DRAWMODE1_LOGICOP_NAND: u32 = 14; +pub const DRAWMODE1_LOGICOP_ONE: u32 = 15; + +pub const DRAWMODE1_LOGICOP_ZERO_SH: u32 = DRAWMODE1_LOGICOP_ZERO << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_AND_SH: u32 = DRAWMODE1_LOGICOP_AND << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_ANDR_SH: u32 = DRAWMODE1_LOGICOP_ANDR << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_SRC_SH: u32 = DRAWMODE1_LOGICOP_SRC << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_ANDI_SH: u32 = DRAWMODE1_LOGICOP_ANDI << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_DST_SH: u32 = DRAWMODE1_LOGICOP_DST << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_XOR_SH: u32 = DRAWMODE1_LOGICOP_XOR << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_OR_SH: u32 = DRAWMODE1_LOGICOP_OR << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_NOR_SH: u32 = DRAWMODE1_LOGICOP_NOR << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_XNOR_SH: u32 = DRAWMODE1_LOGICOP_XNOR << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_NDST_SH: u32 = DRAWMODE1_LOGICOP_NDST << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_ORR_SH: u32 = DRAWMODE1_LOGICOP_ORR << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_NSRC_SH: u32 = DRAWMODE1_LOGICOP_NSRC << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_ORI_SH: u32 = DRAWMODE1_LOGICOP_ORI << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_NAND_SH: u32 = DRAWMODE1_LOGICOP_NAND << DRAWMODE1_LOGICOP_SHIFT; +pub const DRAWMODE1_LOGICOP_ONE_SH: u32 = DRAWMODE1_LOGICOP_ONE << DRAWMODE1_LOGICOP_SHIFT; bitfield! { #[derive(Clone, Copy, Default)] @@ -466,6 +550,11 @@ pub const CONFIG_FB_TYPE: u32 = 1 << 20; // CLIPMODE Register Bits pub const CLIPMODE_ENSMASK_MASK: u32 = 0x1F; +/// SMASK0 enable — the window-relative scissor (bit 0 of ENSMASK). +pub const CLIPMODE_ENSMASK_SMASK0: u32 = 0x01; +/// SMASK1-4 enables — the screen-absolute scissors (bits 1-4). A pixel passes +/// if it is inside *any* enabled one. +pub const CLIPMODE_ENSMASK_SMASK1_4: u32 = 0x1E; pub const CLIPMODE_CIDMATCH_MASK: u32 = 0xF << 9; pub const CLIPMODE_CIDMATCH_SHIFT: u32 = 9; /// Bits of clipmode that affect JIT shader code generation (ensmask + cidmatch). @@ -494,7 +583,7 @@ pub const OCTANT_XMAJOR: u32 = 1 << 2; // per-pixel walk) — both interpreter code paths, but setup() also gates what the // JIT sees (see setup()'s doc comment on why the fractional correction lives there). #[rustfmt::skip] -const REX3_BRES_OCTANTS: [(i32, i32, i32, i32, bool); 8] = [ +pub(crate) const REX3_BRES_OCTANTS: [(i32, i32, i32, i32, bool); 8] = [ ( 0, 1, -1, -1, true ), // octant 0 ( 0, 1, 1, 1, true ), // octant 1 ( 0, -1, -1, -1, true ), // octant 2 @@ -619,7 +708,7 @@ fn to12_4_7(val: i32) -> u32 { // get_colori() in CI mode: integer part = bits[22:11], i.e. (colorred >> 11) & 0xFFF. fn from_color_red(val: u32, drawmode1: DrawMode1) -> u32 { - if !drawmode1.rgbmode() && drawmode1.drawdepth() == 2 { + if !drawmode1.rgbmode() && drawmode1.drawdepth() == DRAWMODE1_DRAWDEPTH_12 { // 12-bit CI mode: bus value is o12.9, shift left 2 to store as o12.11. (val << 2) & 0xFFFFFF } else { @@ -855,8 +944,28 @@ pub struct Rex3Context { pub stepz: u32, pub stall0: u32, pub stall1: u32, + + /// Back-pointer to the owning `Rex3`, for host services the draw path needs + /// but cannot compute from the context alone (block logging, the host FIFO). + /// + /// Lets the draw functions take the same arguments the compiled shader does + /// — `(ctx, fb_rgb, fb_aux)` — instead of threading a `&Rex3` through every + /// call. Null until `Rex3::new` wires it up; the accessors below treat null + /// as "no host attached" so a bare `Rex3Context` (tests, snapshots) is still + /// usable. + /// + /// Not part of the register state: excluded from snapshots and never + /// compared. `Rex3Context` is `Copy`, and copies share the pointer, which is + /// correct — they all refer to the same device. + pub host: *const Rex3, } +// Safety: `host` is only ever set to the owning Rex3, which outlives every +// context that points at it, and is only dereferenced from the draw path (the +// GFIFO consumer thread) for services that take their own locks. +unsafe impl Send for Rex3Context {} +unsafe impl Sync for Rex3Context {} + impl Rex3Context { /// Power-on/reset state: like `Default::default()`, but with DRAWMODE1.COMPARE /// at its documented hardware reset value (0x7 = afunction disabled/always-pass). @@ -1063,6 +1172,57 @@ impl GFifo { true } + /// Push two consecutive register writes as one atomic unit. + /// + /// A 64-bit store to REX3 is two register writes, and IRIX/GL issues them + /// constantly — coordinate pairs, colour pairs, Bresenham terms. Pushing + /// both under one lock acquisition rather than two costs three atomics + /// instead of six and skips a second trip through the `write32` register + /// match. + /// + /// **It also fixes a real bug.** The old path called `write32` twice and + /// returned the second one's status, so a queue that filled between them + /// left the first word pushed and still reported `BUS_BUSY` — and the CPU + /// re-executes the *whole* store on retry, pushing that first word a second + /// time. Duplicated register writes into the GFIFO, exactly what + /// `try_push`'s "commit no other state first" rule exists to prevent. Here + /// the capacity check covers both slots before either is written, so the + /// pair either lands completely or not at all. + #[inline] + pub fn try_push2(&self, addr0: u32, val0: u64, addr1: u32, val1: u64) -> bool { + if self.lock.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed).is_err() { + return false; + } + let tail = self.tail.load(Ordering::Relaxed); + let next = tail.wrapping_add(1) & GFIFO_MASK; + let next2 = tail.wrapping_add(2) & GFIFO_MASK; + // Room for BOTH before writing either: a partial push is what the old + // two-`write32` path got wrong. + let mut cached_head = self.shadow_head.get(); + if next == cached_head || next2 == cached_head { + cached_head = self.head.load(Ordering::Acquire); + self.shadow_head.set(cached_head); + if next == cached_head || next2 == cached_head { + self.lock.store(false, Ordering::Release); + return false; + } + } + // SAFETY: we hold the lock; no other producer touches these slots. + unsafe { + let slot0 = self.buf.as_ptr().add(tail) as *mut GFIFOEntry; + (*slot0).addr = addr0; + (*slot0).val = val0; + let slot1 = self.buf.as_ptr().add(next) as *mut GFIFOEntry; + (*slot1).addr = addr1; + (*slot1).val = val1; + } + // One Release publishes both slots: the consumer's Acquire on tail + // orders it after every write above. + self.tail.store(next2, Ordering::Release); + self.lock.store(false, Ordering::Release); + true + } + /// Push an entry, spinning until it fits. Safe to call from multiple /// producers concurrently. /// @@ -1132,7 +1292,43 @@ impl GFifo { self.head.store(self.local_head.get(), Ordering::Release); } + /// Reconcile the published `tail` from a reader thread, under the producer + /// lock. + /// + /// `try_push` publishes `tail` on every push today, so this is a no-op in + /// the current topology — but it is the hook a deferred/batched tail needs, + /// and taking the lock is what makes it safe to call from a thread that is + /// neither the producer nor the consumer. See + /// `rules/rex3/gfifo-batching-constraints.md`: a batched producer must + /// publish before any `busy_or_val!` or STATUS read, or the reader sees an + /// emptier queue than reality and skips the retry it owed. + /// + /// Returns `false` if the lock was contended — the caller should treat that + /// as "busy, retry" rather than spin, for the same reason `try_push` does: + /// spinning inside the CPU's load path starves IP7 and dilates guest time. + #[inline] + pub fn publish_tail(&self) -> bool { + if self.lock.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed).is_err() { + return false; + } + // A producer-local tail would be published here. With eager publication + // the authoritative `tail` is already current; re-storing it under the + // lock is harmless and keeps this the single place that changes when + // batching lands. + let tail = self.tail.load(Ordering::Relaxed); + self.tail.store(tail, Ordering::Release); + self.lock.store(false, Ordering::Release); + true + } + /// True when no entries are pending. + /// + /// Reads the *published* `head`, which the consumer advances in batches of + /// 64 (plus immediately on drain-to-empty, see `consume`). So a `true` here + /// is authoritative — the consumer publishes the moment it empties the ring + /// — while a `false` may be up to 63 entries pessimistic mid-drain. That + /// direction is the safe one for every caller: it over-reports busy, never + /// under-reports. #[inline] pub fn is_empty(&self) -> bool { self.head.load(Ordering::Acquire) == self.tail.load(Ordering::Acquire) @@ -1172,31 +1368,6 @@ pub struct Rex3 { // Each bit of a pixel represents a plane. pub fb_rgb: UnsafeCell>, pub fb_aux: UnsafeCell>, - pub px_rd: UnsafeCell u32>, - pub px_wr: UnsafeCell, - pub px_amp: UnsafeCell u32>, - pub px_logic: UnsafeCell u32>, - /// Afunction test: (src_alpha, alpharef) -> pass. Selected in planes_setup from - /// DRAWMODE1 COMPARE/RGBMODE; a no-op always-pass fn outside rgbmode or COMPARE==0x7. - pub px_afunc: UnsafeCell bool>, - /// Pack bayer index into bits [27:24] for dither compress functions (rgbmode=1 only). - /// In CI mode this is a no-op (returns color unchanged) — CI values need no dithering. - pub px_bayer: UnsafeCell u32>, - /// Compress 24-bit BGR → plane-depth pixel (rgbmode=1 only; identity otherwise). - pub px_compress: UnsafeCell u32>, - /// Expand plane-depth pixel → 24-bit BGR (for blend dst; identity for CI/24bpp). - pub px_expand: UnsafeCell u32>, - pub px_proc: UnsafeCell, - /// Per-pixel shade DDA step + optional clamp. Called after every pixel (draw_block, draw_iline). - pub px_shade: UnsafeCell, - /// Per-pixel pattern bit advance for lspattern and/or zpattern. - /// Handles lsmode repeat/length for lspattern; simple rotate for zpattern. - /// Called after every pixel (draw_block, draw_iline). - pub px_pattern: UnsafeCell, - pub host_unpack: UnsafeCell u32>, - pub host_pack: UnsafeCell u64>, - pub host_shift: UnsafeCell, - pub host_count: UnsafeCell, pub gfifo: GFifo, pub vc2: Mutex, @@ -1225,8 +1396,6 @@ pub struct Rex3 { /// re-uploading the whole framebuffer at 60 Hz on a static screen. Starts /// true so the first frame always renders. fb_dirty: AtomicBool, - /// Rows filled via rex3_simd fastclear path (monitor `perf snapshot`). - pub simd_fill_rows: AtomicU64, pub screen: Arc>, /// Drives the real REX3 `VV_INT_N` pin (vertical retrace / Kaleidoscope). pub vblank_cb: Mutex>>, @@ -1258,6 +1427,24 @@ pub struct Rex3 { pub diag: AtomicU64, debug_state: Mutex, pub renderer: Mutex>>, + /// Compiled shaders, keyed by `(dm0, dm1_normalized, clipmode_key)`. + /// + /// Always present, not gated on `rex-jit`: the LLVM-compiled shaders in + /// `rex3_shaders` are built into every binary, and they use the same ABI as + /// a Cranelift one. Seeded from the static table at construction; with + /// `rex-jit` the compiler thread adds to it as new shapes appear. + pub shaders: Arc>>, + /// One-entry memo in front of `shaders`, on the GFIFO consumer thread only. + pub shader_last: std::cell::Cell<(u32, u32, u32, Option)>, + /// Every draw shape this run has dispatched — the corpus the shader + /// generator consumes. + /// + /// Lives on `Rex3` rather than `RexJit` because it must be recorded in every + /// build: without `rex-jit` the generated table serves draws and Cranelift + /// never runs, so a JIT-owned corpus would record nothing and could never + /// grow to cover new shapes. Written on the GFIFO consumer thread only when + /// a shape is new, which the `shader_last` memo makes rare. + pub seen_shapes: Mutex, #[cfg(feature = "rex-jit")] pub rex_jit: Option>, /// Whether the JIT is enabled for dispatch (can be toggled at runtime via `rex jit on/off`). @@ -1267,11 +1454,6 @@ pub struct Rex3 { /// the same as the previous GO. Only accessed from the GFIFO consumer thread — no sync needed. #[cfg(feature = "rex-jit")] pub jit_last: std::cell::Cell<(u32, u32, u32, Option)>, - /// Cached interpreter setup key: (dm0 & DRAWMODE0_INTERP_SETUP_MASK, - /// dm1_normalized & DRAWMODE1_INTERP_SETUP_MASK, clipmode_cidmatch). - /// When these match the current GO, planes_setup/host_setup and function-pointer - /// selection are skipped since nothing they depend on has changed. - interp_setup_cache: std::cell::Cell<(u32, u32, u32)>, /// Shared activity heartbeat — set by all devices, polled+cleared by the refresh thread. /// bit 0 = enet TX, bit 1 = enet RX, bits 2-3 = red/green LED (persistent), bits 8-13 = SCSI IDs 0-5 pub heartbeat: Arc, @@ -1281,7 +1463,7 @@ pub struct Rex3 { /// the CPU exists (`Rex3::new` runs before it does, so this can't be a /// constructor parameter; see `MipsCpu::cycles_ptr`) but strictly before /// any device thread (including this struct's own refresh thread) is - /// spawned, so a plain `Cell` (same as `interp_setup_cache` above) is + /// spawned, so a plain `Cell` is /// enough — no atomicity needed for the pointer variable itself. /// `CyclesPtr::dangling()` until `set_cpu_cycles` runs; its own `get()` /// treats that as "not wired up yet" and reports 0. @@ -1314,8 +1496,36 @@ pub struct Rex3 { unsafe impl Sync for Rex3 {} +/// One row of `rex jit list`: a draw shape and what serves it. +pub struct ShaderRow { + pub dm0: u32, + pub dm1: u32, + pub cm: u32, + /// `precompiled` (generated Rust), `jit` (Cranelift), `queued`, `failed`, + /// `disabled`, or `generic` (no specialised shader — the runtime `DynMode` + /// path serves it). + pub origin: &'static str, + /// Native code size, for Cranelift shaders. 0 for the others: precompiled + /// shaders are inlined into the binary and have no separately tracked size. + pub bytes: u32, +} + impl Rex3 { pub fn new(heartbeat: Arc, fasttick_count: Arc, decoded_count: Arc, l1i_hit_count: Arc, l1i_fetch_count: Arc, uncached_fetch_count: Arc) -> Self { + // The dispatch map, shared with the Cranelift compiler thread so both + // shader sources publish into one place. + // + // Seeded with the generated LLVM shaders — except under cfg(test), where + // the JIT-vs-generic comparison tests need Cranelift to actually run: + // a pre-seeded LLVM shader would serve those shapes first and the test + // would compare the generic path against itself. + #[cfg(not(test))] + let shaders_shared: Arc>> = + Arc::new(RwLock::new(crate::rex3_shaders::SHADERS.iter().copied().collect())); + #[cfg(test)] + let shaders_shared: Arc>> = + Arc::new(RwLock::new(crate::rex3_shape::ShapeMap::default())); + let config = Rex3Config::default(); config.config.store(CONFIG_BUSWIDTH | CONFIG_EXTREGXCVR | (8 << CONFIG_BFIFODEPTH_SHIFT) | @@ -1346,21 +1556,6 @@ impl Rex3 { context: UnsafeCell::new(Rex3Context::power_on_default()), fb_rgb: UnsafeCell::new(fb_rgb), fb_aux: UnsafeCell::new(fb_aux), - px_rd: UnsafeCell::new(Self::default_px_rd), - px_wr: UnsafeCell::new(Self::default_px_wr), - px_amp: UnsafeCell::new(Self::amplify_nop), - px_logic: UnsafeCell::new(Self::logic_op_src), - px_afunc: UnsafeCell::new(Self::afunc_always), - px_bayer: UnsafeCell::new(Self::bayer_pack), - px_compress: UnsafeCell::new(Self::identity), - px_expand: UnsafeCell::new(Self::identity), - px_proc: UnsafeCell::new(Self::process_pixel_noop), - px_shade: UnsafeCell::new(Self::iterate_shade_noop), - px_pattern: UnsafeCell::new(Self::iterate_pattern_noop), - host_unpack: UnsafeCell::new(Self::host_unpack_nop), - host_pack: UnsafeCell::new(Self::host_pack_nop), - host_shift: UnsafeCell::new(0), - host_count: UnsafeCell::new(0), gfifo: GFifo::new(), vc2: Mutex::new(Vc2::new()), xmap0: Mutex::new(Xmap9::new()), @@ -1378,7 +1573,6 @@ impl Rex3 { #[cfg(feature = "idle-pause")] processor_unparker: std::sync::OnceLock::new(), fb_dirty: AtomicBool::new(true), - simd_fill_rows: AtomicU64::new(0), screen, vblank_cb: Mutex::new(None), fifo_full_cb: Mutex::new(None), @@ -1408,13 +1602,26 @@ impl Rex3 { rex_jit: if std::env::var_os("IRIS_NO_JIT").is_some() { None } else { - Some(std::sync::Arc::new(crate::rex3_jit::RexJit::new())) + Some(std::sync::Arc::new(crate::rex3_jit::RexJit::new( + Arc::clone(&shaders_shared), + ))) }, #[cfg(feature = "rex-jit")] jit_enabled: AtomicBool::new(std::env::var_os("IRIS_NO_JIT").is_none()), + // Seed with every LLVM-compiled shader. These are available in all + // builds; Cranelift only ever adds to this map. + // + // Not seeded under `cfg(test)`: the JIT-vs-interpreter comparison + // tests exist to check that *Cranelift's* output matches the generic + // path, and a pre-seeded LLVM shader would serve those shapes first, + // so the test would compare the generic path against itself and pass + // vacuously. Tests that want the generated table exercise + // `rex3_shaders::lookup` directly. + shaders: Arc::clone(&shaders_shared), + shader_last: std::cell::Cell::new((0, 0, 0, None)), + seen_shapes: Mutex::new(crate::rex3_shape::ShapeSet::default()), #[cfg(feature = "rex-jit")] jit_last: std::cell::Cell::new((0, 0, 0, None)), - interp_setup_cache: std::cell::Cell::new((u32::MAX, u32::MAX, u32::MAX)), heartbeat, cycles: std::cell::Cell::new(crate::mips_core::CyclesPtr::dangling()), fasttick_count, @@ -1470,14 +1677,6 @@ impl Rex3 { pub const DIAG_LOOP_DRAW_BLOCK: u64 = 1 << 24; pub const DIAG_LOOP_EXECUTE_GO: u64 = 1 << 25; - fn default_px_rd(rex: &Rex3, addr: u32) -> u32 { - unsafe { (*rex.fb_rgb.get())[addr as usize] } - } - - fn default_px_wr(rex: &Rex3, addr: u32, val: u32) { - unsafe { (*rex.fb_rgb.get())[addr as usize] = val; } - } - pub fn set_vblank_callback(&self, cb: Arc) { *self.vblank_cb.lock() = Some(cb); } @@ -1593,13 +1792,13 @@ impl Rex3 { // correction only in draw_line_bresenham (the old approach) left the JIT // silently drawing plain-I_LINE trajectories for F_LINE/A_LINE, since the // JIT never reaches that interpreter-only code path. - let adrmode = ctx.drawmode0.adrmode() << 2; + let adrmode = ctx.drawmode0.adrmode(); let is_fractional = adrmode == DRAWMODE0_ADRMODE_F_LINE || adrmode == DRAWMODE0_ADRMODE_A_LINE; if is_fractional { let (_incrx1, incrx2, _incry1, incry2, y_major) = REX3_BRES_OCTANTS[(octant & 7) as usize]; let mut x = ctx.xstart >> 11; let mut y = ctx.ystart >> 11; - Self::fline_apply_fract(ctx, &mut d, &mut x, &mut y, incrx2, incry2, y_major); + crate::rex3_generic::fline_apply_fract(ctx, &mut d, &mut x, &mut y, incrx2, incry2, y_major); ctx.xstart = x << 11; ctx.ystart = y << 11; } @@ -1635,10 +1834,10 @@ impl Rex3 { #[cfg(not(feature = "developer"))] #[inline(always)] - fn log_block(&self, _ctx: &Rex3Context, _opcode: u32) {} + pub(crate) fn log_block(&self, _ctx: &Rex3Context, _opcode: u32) {} #[cfg(feature = "developer")] - fn log_block(&self, ctx: &Rex3Context, opcode: u32) { + pub(crate) fn log_block(&self, ctx: &Rex3Context, opcode: u32) { let need_block_log = self.block_log.lock().is_some(); let need_draw_ring = self.draw_debug_active(); if ctx.mid_primitive || (!need_block_log && !need_draw_ring) { return; } @@ -1682,7 +1881,13 @@ impl Rex3 { DRAWMODE1_PLANES_OLAY => "OLAY", DRAWMODE1_PLANES_PUP => "PUP", DRAWMODE1_PLANES_CID => "CID", _ => "?" }; - let bpp = match ctx.drawmode1.drawdepth() { 0=>4, 1=>8, 2=>12, 3=>24, _=>0 }; + let bpp = match ctx.drawmode1.drawdepth() { + DRAWMODE1_DRAWDEPTH_4 => 4, + DRAWMODE1_DRAWDEPTH_8 => 8, + DRAWMODE1_DRAWDEPTH_12 => 12, + DRAWMODE1_DRAWDEPTH_24 => 24, + _ => 0, + }; let opcode_str = match opcode { DRAWMODE0_OPCODE_READ => "READ", DRAWMODE0_OPCODE_DRAW => "DRAW", @@ -1768,713 +1973,6 @@ impl Rex3 { } } - fn draw_block(&self, ctx: &mut Rex3Context) { - if crate::rex3_simd::try_fastclear_block(self, ctx) { - return; - } - if crate::rex3_simd::try_src_block_rgb(self, ctx) { - return; - } - - let _w = (ctx.xend - ctx.xstart).abs(); - let _h = (ctx.yend - ctx.ystart).abs(); - - let stopony = ctx.drawmode0.stopony(); - let length32 = ctx.drawmode0.length32(); - let ystride = ctx.drawmode0.ystride(); - let opcode = ctx.drawmode0.opcode(); - let colorhost = ctx.drawmode0.colorhost(); - let mut first = true; - let skipfirst = ctx.drawmode0.skipfirst(); - let skiplast = ctx.drawmode0.skiplast(); - - - // In host mode (READ or DRAW+colorhost), each GO processes exactly one word's worth - // of pixels (host_count pixels). stop_on_word causes the loop to exit after the - // word boundary so the next GO picks up where we left off. - let stop_on_word = opcode == DRAWMODE0_OPCODE_READ || colorhost; - - // stop_on_word takes priority over stoponx — host mode governs its own stop. - let stoponx = ctx.drawmode0.stoponx() || stop_on_word; - - let octant = ctx.bresoctinc1.octant(); - let lronly = ctx.drawmode0.lronly(); - let x_dec = (octant & OCTANT_XDEC) != 0; - let y_dec = (octant & OCTANT_YDEC) != 0; - let lrskip = lronly && x_dec; - // it is important to note that lrskip still performs y advance operations otherwise some triangles grow weird tails - // Coordinate steps in 21.11 fixed-point: ±1 integer = ±2048 - let stepx: i32 = if x_dec { -(1 << 11) } else { 1 << 11 }; - let y_inc: i32 = if ystride { 2 } else { 1 }; - let stepy: i32 = if y_dec { -(y_inc << 11) } else { y_inc << 11 }; - - // length32 only clamps if span is >= 32 pixels wide - let span_len = ((ctx.xend - ctx.xstart).abs()) >> 11; - let xstop = if length32 && span_len >= 32 { Some(ctx.xstart + stepx * 32) } else { None }; - - let proc_fn = unsafe { *self.px_proc.get() }; - let shade_fn = unsafe { *self.px_shade.get() }; - let pattern_fn = unsafe { *self.px_pattern.get() }; - - ctx.mid_primitive = true; - self.diag.fetch_or(Self::DIAG_LOOP_DRAW_BLOCK, Ordering::Relaxed); - loop { - let x = ctx.xstart >> 11; - let y = ctx.ystart >> 11; - - ctx.xstart += stepx; - - let x_end_reached = if x_dec { ctx.xstart < ctx.xend } else { ctx.xstart > ctx.xend }; - - if !(first && skipfirst || x_end_reached && skiplast || lrskip) { - proc_fn(self, ctx, x, y); - } - - shade_fn(ctx); - pattern_fn(ctx); - - if x_end_reached { - // advance y, wrap x; reset pattern bits so each row starts at bit 31 - ctx.ystart += stepy; - ctx.xstart = ctx.xsave; - ctx.pat_bit = 31; - ctx.zpat_bit = 31; - // lsrcount continues across rows — iterate_pattern_ls manages it per-pixel. - - if !stopony { - // Without STOPONY, hardware doesn't auto-advance rows — each row is - // its own complete primitive and the next GO starts a fresh one. - // Mirrors the JIT's emit_shader (!stopony branch in end_x_block), - // which already clears mid_primitive here. Leaving this true (as - // before) permanently wedged log_block()'s "primitive start" guard - // after the first non-stopony block ever ran, hiding every - // subsequent block/READ/DRAW header from block.log. - ctx.mid_primitive = false; - break; - } - - let y_end_reached = if y_dec { ctx.ystart < ctx.yend } else { ctx.ystart > ctx.yend }; - - if y_end_reached { - // All rows consumed — primitive done. - ctx.mid_primitive = false; - break; - } - - // Host mode: a row boundary is always a forced word boundary too, - // even if the row's width doesn't divide evenly into host_count - // (e.g. a 17px-wide CI8 row's last word only has 1 of 4 slots - // filled). Without this, a still-open partial word from this row - // would keep accumulating pixels from the next row instead of - // being flushed — hardware sends one word per GO in host mode, - // full or not. Checked here (not just via the hostcnt==0 check - // below) because that check alone never fires for a word that - // never reaches host_count pixels. - if stop_on_word && ctx.hostcnt > 0 { - break; - } - - first = true; // pixel in next row will be first - } else if let Some(limit) = xstop { - let limit_reached = if x_dec { ctx.xstart <= limit } else { ctx.xstart >= limit }; - if limit_reached { - break; - } - } - - // Host mode: stop after one word (after y-advance so row boundary is handled first). - // Primitive continues on next GO — mid_primitive stays true. - if stop_on_word && ctx.hostcnt == 0 { - break; - } - - // stoponx/stopony: next GO advances to next step — mid_primitive stays true. - if !stoponx { - break; - } - } - - - self.diag.fetch_and(!Self::DIAG_LOOP_DRAW_BLOCK, Ordering::Relaxed); - - if opcode == DRAWMODE0_OPCODE_READ { - self.flush_host_pixel(ctx); - } - } - - fn draw_span(&self, ctx: &mut Rex3Context) { - //if crate::rex3_simd::try_src_span_rgb(self, ctx) { - // return; - //} - if ctx.drawmode0.lronly() && (ctx.bresoctinc1.octant() & OCTANT_XDEC) != 0{ - return; - } - let length32 = ctx.drawmode0.length32(); - let ystride = ctx.drawmode0.ystride(); - let opcode = ctx.drawmode0.opcode(); - let colorhost = ctx.drawmode0.colorhost(); - let mut first = true; - let skipfirst = ctx.drawmode0.skipfirst(); - let skiplast = ctx.drawmode0.skiplast(); - - // In host mode (READ or DRAW+colorhost), each GO processes exactly one word's worth - // of pixels (host_count pixels). stop_on_word causes the loop to exit after the - // word boundary so the next GO picks up where we left off. - let stop_on_word = opcode == DRAWMODE0_OPCODE_READ || colorhost; - - // stop_on_word takes priority over stoponx — host mode governs its own stop. - let stoponx = ctx.drawmode0.stoponx() || stop_on_word; - - // Spans always advance left-to-right (+1 in 21.11 fixed-point). - // length32 only clamps if span is >= 32 pixels wide. - let span_len = (ctx.xend - ctx.xstart) >> 11; - let xstop = if length32 && span_len >= 32 { Some(ctx.xstart + (32 << 11)) } else { None }; - - let proc_fn = unsafe { *self.px_proc.get() }; - let shade_fn = unsafe { *self.px_shade.get() }; - let pattern_fn = unsafe { *self.px_pattern.get() }; - - ctx.mid_primitive = true; - self.diag.fetch_or(Self::DIAG_LOOP_DRAW_BLOCK, Ordering::Relaxed); - let x_end_reached = loop { - let x = ctx.xstart >> 11; - let y = ctx.ystart >> 11; - - ctx.xstart += 1 << 11; - - let x_end_reached = ctx.xstart > ctx.xend; - - if !(first && skipfirst || x_end_reached && skiplast) { - proc_fn(self, ctx, x, y); - } - - shade_fn(ctx); - pattern_fn(ctx); - - if x_end_reached { - break true; - } else if let Some(limit) = xstop { - if ctx.xstart >= limit { - break false; - } - } - - // Host mode: stop after one word. - // Primitive continues on next GO — mid_primitive stays true. - if stop_on_word && ctx.hostcnt == 0 { - break false; - } - - // stoponx: next GO advances to next step — mid_primitive stays true. - if !stoponx { - break false; - } - - first = false; - }; - - if x_end_reached { - // Span fully consumed — advance to next row and reset state. - //let y_inc: i32 = if ystride { 2 } else { 1 }; - //ctx.ystart += y_inc << 11; - //ctx.xstart = ctx.xsave; - ctx.pat_bit = 31; - ctx.zpat_bit = 31; - ctx.mid_primitive = false; - } - - - self.diag.fetch_and(!Self::DIAG_LOOP_DRAW_BLOCK, Ordering::Relaxed); - - if opcode == DRAWMODE0_OPCODE_READ { - self.flush_host_pixel(ctx); - } - } - - /// Fractional d correction for F_LINE/A_LINE from 21.11 endpoint sub-pixel position. - /// Fractional nibble is bits [10:7] of the 21.11 coordinate (16.4(7) layout). - fn fline_apply_fract( - ctx: &Rex3Context, - d: &mut i32, - x: &mut i32, - y: &mut i32, - incrx2: i32, - incry2: i32, - y_major: bool, - ) { - let octant = ctx.bresoctinc1.octant() & 7; - let x1p = ctx.xstart >> 11; - let y1p = ctx.ystart >> 11; - let x2p = ctx.xend >> 11; - let y2p = ctx.yend >> 11; - let mut dx = (x1p - x2p).abs(); - let mut dy = (y1p - y2p).abs(); - let mut xf = ((ctx.xstart >> 7) & 0xF) as i32; - let mut yf = ((ctx.ystart >> 7) & 0xF) as i32; - - match octant { - 1 => { - std::mem::swap(&mut xf, &mut yf); - std::mem::swap(&mut dx, &mut dy); - } - 3 => { - xf = 0x10 - xf; - std::mem::swap(&mut xf, &mut yf); - std::mem::swap(&mut dx, &mut dy); - } - 7 => { xf = 0x10 - xf; } - 6 => { - xf = 0x10 - xf; - yf = 0x10 - yf; - } - 2 => { - let t = 0x10 - xf; - xf = 0x10 - yf; - yf = t; - std::mem::swap(&mut dx, &mut dy); - } - 0 => { - let t = 0x10 - yf; - yf = xf; - xf = t; - std::mem::swap(&mut dx, &mut dy); - } - 4 => { yf = 0x10 - yf; } - _ => {} - } - - // `*d` arrives holding the I_LINE decision variable (2*minor - major, - // computed by setup() and shared by all line adrmodes). The REX3 spec - // (rex3_pdf.md 3.6.1.2/3.6.2.1) defines F_LINE/A_LINE's base d as - // 3*minor - 2*major instead — confirmed against MAME's do_fline, - // which independently derives the same 3dy-2dx formula. The two - // formulas differ by exactly (minor - major); apply that correction - // before adding the fractional term below. Without it, the fractional - // term is added to the wrong baseline and can flip d's sign on the - // very first step for near-degenerate (small minor-axis) lines, - // producing a spurious extra step in the minor-axis direction that - // the line never recovers from (confirmed via a real R4400/REX3 - // fractional-line test that undershot its endpoint by one row). - *d += dy - dx; - *d += 2 * (((dx * yf) >> 4) - ((dy * xf) >> 4)); - let major_delta = if y_major { dy } else { dx }; - let e = *d - 2 * major_delta; - if e > 0 { - *d = e; - let x_major = !y_major; - if x_major { - *y -= incry2; - } else { - *x += incrx2; - } - } - } - - fn draw_iline(&self, ctx: &mut Rex3Context) { - self.draw_line_bresenham(ctx, false, false, false); - } - - fn draw_fline(&self, ctx: &mut Rex3Context) { - self.draw_line_bresenham(ctx, true, false, false); - } - - fn draw_aline(&self, ctx: &mut Rex3Context) { - let mut extra_skip_first = false; - let mut extra_skip_last = false; - if ctx.drawmode0.endptfilter() { - // Basic endpoint filter: consult AWEIGHT LUT for sub-pixel coverage. - let xsf = (ctx.xstart >> 7) & 0xF; - let ysf = (ctx.ystart >> 7) & 0xF; - let xef = (ctx.xend >> 7) & 0xF; - let yef = (ctx.yend >> 7) & 0xF; - if xsf != 0 || ysf != 0 { - let wi = ((xsf + ysf) as usize).min(15); - let w = (ctx.aweight0 >> (wi * 4)) & 0xF; - if w == 0 { - extra_skip_first = true; - } - } - if xef != 0 || yef != 0 { - let wi = ((xef + yef) as usize).min(15); - let w = (ctx.aweight1 >> (wi * 4)) & 0xF; - if w == 0 { - extra_skip_last = true; - } - } - } - self.draw_line_bresenham(ctx, true, extra_skip_first, extra_skip_last); - } - - fn draw_line_bresenham( - &self, - ctx: &mut Rex3Context, - fract: bool, - extra_skip_first: bool, - extra_skip_last: bool, - ) { - let octant = (ctx.bresoctinc1.octant() & 7) as usize; - let (incrx1, incrx2, incry1, incry2, y_major) = REX3_BRES_OCTANTS[octant]; - - let x2 = ctx.xend >> 11; - let y2 = ctx.yend >> 11; - let mut x = ctx.xstart >> 11; - let mut y = ctx.ystart >> 11; - - // All Bresenham state comes from registers — set by setup() or restored across GOs. - // incr1: 20-bit, always positive (no sign extension needed). - let incr1 = ctx.bresoctinc1.incr1() as i32; - // incr2: 21-bit signed — sign-extend from bit 20. - let incr2 = { - let raw = ctx.bresrndinc2.incr2(); - if raw & (1 << 20) != 0 { (raw | 0xFFE0_0000) as i32 } else { raw as i32 } - }; - // d: 27-bit signed — sign-extend from bit 26. Persisted across step-mode GOs. - // For F_LINE/A_LINE (fract=true), the fractional-endpoint correction was - // already applied in setup() (see setup()'s doc comment) — bresd/xstart/ystart - // read here are already correct, no further adjustment needed. - let mut d = { - let raw = ctx.bresd & 0x7FF_FFFF; - if raw & (1 << 26) != 0 { (raw | 0xF800_0000) as i32 } else { raw as i32 } - }; - - // pixel_count = major_axis_length + 1 (both endpoints inclusive). - // max(|dx|,|dy|): continuation GOs (dosetup clear) must still walk the full - // segment when persisted octant y_major disagrees with start→end (e.g. a - // degenerate setup GO followed by a horizontal stipple continuation). - let adx = (x2 - x).abs(); - let ady = (y2 - y).abs(); - let major = adx.max(ady); - let mut pixel_count = major + 1; - if ctx.drawmode0.length32() && pixel_count > 32 { - pixel_count = 32; - } - - let iterate_one = !ctx.drawmode0.stoponx() && !ctx.drawmode0.stopony(); - let mut skip_first = ctx.drawmode0.skipfirst() || extra_skip_first; - let mut skip_last = ctx.drawmode0.skiplast() || extra_skip_last; - if iterate_one { - pixel_count = 1; - skip_first = false; - skip_last = false; - } - - let proc_fn = unsafe { *self.px_proc.get() }; - let shade_fn = unsafe { *self.px_shade.get() }; - let pattern_fn = unsafe { *self.px_pattern.get() }; - let lsadvlast = ctx.drawmode0.lsadvlast(); - - macro_rules! bres_step { - () => { - if d < 0 { - x += incrx1; y -= incry1; d += incr1; - } else { - x += incrx2; y -= incry2; d += incr2; - } - }; - } - - for i in 0..pixel_count { - let is_first = i == 0; - let is_last = i == pixel_count - 1; - - // Write pixel unless suppressed by skip_first/skip_last. - // iterate_one overrides skip_first so single-step mode always draws. - let draw = (!is_first || !skip_first) && (!is_last || !skip_last); - if draw { - proc_fn(self, ctx, x, y); - } - - shade_fn(ctx); - if !is_last || lsadvlast { - pattern_fn(ctx); - } - - // On the last pixel of a full I_LINE draw, verify Bresenham landed on x2,y2 — - // integer Bresenham is exact, so this is a real invariant for I_LINE. - // F_LINE/A_LINE do NOT get this check: a fractional start biases the initial - // error term but the loop still steps by whole pixels along the major axis, - // so the minor-axis position at the final major-axis step is the closest - // integer approximation to the true (fractional) line, not necessarily the - // literal requested endpoint — this is expected behavior for fractional - // Bresenham (confirmed independently: real hardware/software fractional-DDA - // implementations only guarantee landing in the endpoint's pixel *column/row*, - // not its exact minor-axis coordinate). - debug_assert!( - fract || iterate_one || !is_last || (x == x2 && y == y2), - "I_LINE bres mismatch: pos ({},{}) != end ({},{})", x, y, x2, y2 - ); - - // In full-line mode: do NOT step after the last pixel — that would leave - // xstart/ystart one position beyond the endpoint, breaking the next XYENDI GO - // (dosetup re-derives Bresenham from xstart). - // In step mode: always step so the next single-step GO starts at the next position. - if !is_last || iterate_one { - bres_step!(); - } - } - - ctx.xstart = x << 11; - ctx.ystart = y << 11; - // Persist d so the next GO (step mode) picks up where we left off. - ctx.bresd = (d as u32) & 0x7FF_FFFF; - } - - fn identity(val: u32) -> u32 { val } - - fn amplify_rgb_4(val: u32) -> u32 { val | (val << 4) } - fn amplify_rgb_8(val: u32) -> u32 { val | (val << 8) } - fn amplify_rgb_12(val: u32) -> u32 { val | (val << 12) } - fn amplify_rgb_24(val: u32) -> u32 { val } - fn amplify_olay(val: u32) -> u32 { (val << 8) | (val << 16) } - fn amplify_cid(val: u32) -> u32 { val | (val << 4) } - fn amplify_pup(val: u32) -> u32 { (val << 2) | (val << 6) } - fn amplify_nop(_val: u32) -> u32 { 0 } - - // ── Shade iterate functions ──────────────────────────────────────────────── - // Called once per pixel after drawing. Advance color DDAs and, when - // CICLAMP is set, clamp the result to legal range. - // - // The spec (§3.8 / DRAWMODE0 bit CICLAMP) says: - // • RGB mode: each component is in o12.11 format (integer part bits[22:11]). - // Clamp: if negative (bit 31 set) or integer >= 0x180 → 0; if > 0xFF → 0x7FFFF. - // • CI mode: only colorred clamped; depth-specific overflow bit check. - // 8bpp: clamp if bit 19 set. 12bpp: clamp if bit 21 set. - // (4bpp: bit 15; 24bpp: no clamp per spec.) - - #[inline(always)] - fn shade_add(ctx: &mut Rex3Context) { - ctx.colorred = ctx.colorred.wrapping_add(ctx.slopered as u32); - ctx.colorgrn = ctx.colorgrn.wrapping_add(ctx.slopegrn as u32); - ctx.colorblue = ctx.colorblue.wrapping_add(ctx.slopeblue as u32); - ctx.coloralpha = ctx.coloralpha.wrapping_add(ctx.slopealpha as u32); - } - - fn iterate_shade_noop(_ctx: &mut Rex3Context) {} - - /// SHADE only, no clamping (CICLAMP=0). - fn iterate_shade_unclamped(ctx: &mut Rex3Context) { - Self::shade_add(ctx); - } - - /// SHADE + CICLAMP, CI 8bpp: clamp colorred if bit 19 set. - fn iterate_shade_ci8_clamp(ctx: &mut Rex3Context) { - Self::shade_add(ctx); - if ctx.colorred & (1 << 19) != 0 { - ctx.colorred = 0x0007_FFFF; - } - } - - /// SHADE + CICLAMP, CI 12bpp: clamp colorred if bit 21 set. - fn iterate_shade_ci12_clamp(ctx: &mut Rex3Context) { - Self::shade_add(ctx); - if ctx.colorred & (1 << 21) != 0 { - ctx.colorred = 0x001F_FFFF; - } - } - - /// SHADE + RGB mode: clamp R,G,B,A each iteration, this happens even if we dont draw pixel - /// integer = bits[22:11] & 0x1FF; negative (bit31) or int >= 0x180 → 0; int > 0xFF → 0x7FFFF. - fn iterate_shade_rgb_clamp(ctx: &mut Rex3Context) { - Self::shade_add(ctx); - #[inline(always)] - fn clamp(c: u32) -> u32 { - let val = (c >> 11) & 0x1FF; - if c & (1 << 31) != 0 || val >= 0x180 { 0 } - else if val > 0xFF { 0x0007_FFFF } - else { c } - } - ctx.colorred = clamp(ctx.colorred); - ctx.colorgrn = clamp(ctx.colorgrn); - ctx.colorblue = clamp(ctx.colorblue); - ctx.coloralpha = clamp(ctx.coloralpha); - } - - // ── Pattern iterate functions ────────────────────────────────────────────── - // Called once per pixel after drawing. Advance lspattern and/or zpattern - // bit counters. - // - // ZPATTERN: always 32-bit, simple rotate — zpat_bit = (zpat_bit - 1) & 31. - // - // LSPATTERN (via lsmode): - // LSRCOUNT (down counter, 0..LSREPEAT-1): decremented each pixel. - // When LSRCOUNT == 0 after decrement → advance pat_bit, reload LSRCOUNT = LSREPEAT-1. - // LSLENGTH (4 bits): pattern length = lslength + 17 (range 17..32). - // pat_bit wraps: when it would go below (32 - length), reset to 31. - // LSREPEAT==0 is treated as 1 (no-repeat is the degenerate case). - // - // Cursors start at 31 (MSB) on DOSETUP/row start (see execute_go) and walk - // DOWN toward the wrap point — a contiguous MSB-to-LSB sweep. f2d0bff - // briefly flipped this to increment-from-31 (+ an lspattern rotate-on-wrap - // in place of the reset), but incrementing from 31 immediately wraps to 0 - // after a single step (`(31+1)&31 == 0`), producing a discontinuous, - // backwards bit walk — confirmed as the cause of garbled/mirrored PROM - // text. Reverted back to decrement/reset-to-31. - - fn iterate_pattern_noop(_ctx: &mut Rex3Context) {} - - #[inline(always)] - fn advance_zpat(ctx: &mut Rex3Context) { - ctx.zpat_bit = ctx.zpat_bit.wrapping_sub(1) & 31; - } - - #[inline(always)] - fn advance_lspat(ctx: &mut Rex3Context) { - let lsrepeat = ctx.lsmode.lsrepeat() as u8; - let repeat = if lsrepeat == 0 { 1 } else { lsrepeat }; - if ctx.lsmode.lsrcount() == 0 { - // Reload counter, advance bit - ctx.lsmode.set_lsrcount((repeat - 1) as u32); - let length = ctx.lsmode.lslength() as u8 + 17; // 17..=32 - let wrap_point = 32u8.saturating_sub(length); // bit index of pattern end - if ctx.pat_bit == wrap_point { - ctx.pat_bit = 31; // recirculate - } else { - ctx.pat_bit = ctx.pat_bit.wrapping_sub(1) & 31; - } - } else { - ctx.lsmode.set_lsrcount(ctx.lsmode.lsrcount() - 1); - } - } - - fn iterate_pattern_z(ctx: &mut Rex3Context) { - Self::advance_zpat(ctx); - } - - fn iterate_pattern_ls(ctx: &mut Rex3Context) { - Self::advance_lspat(ctx); - } - - fn iterate_pattern_both(ctx: &mut Rex3Context) { - Self::advance_zpat(ctx); - Self::advance_lspat(ctx); - } - - - fn rgb4_to_rgb24(val: u32) -> u32 { - let r = if (val & 1) != 0 { 0xFF } else { 0 }; - let g_raw = (val >> 1) & 3; - let g = (g_raw << 6) | (g_raw << 4) | (g_raw << 2) | g_raw; - let b = if (val & 8) != 0 { 0xFF } else { 0 }; - (b << 16) | (g << 8) | r - } - - fn rgb24_to_rgb4(val: u32) -> u32 { - let r = (val >> 7) & 1; - let g = (val >> 14) & 3; - let b = (val >> 23) & 1; - (b << 3) | (g << 1) | r - } - - fn rgb8_to_rgb24(val: u32) -> u32 { - let r_raw = val & 7; - let r = (r_raw << 5) | (r_raw << 2) | (r_raw >> 1); - let g_raw = (val >> 3) & 7; - let g = (g_raw << 5) | (g_raw << 2) | (g_raw >> 1); - let b_raw = (val >> 6) & 3; - let b = (b_raw << 6) | (b_raw << 4) | (b_raw << 2) | b_raw; - (b << 16) | (g << 8) | r - } - - fn rgb24_to_rgb8(val: u32) -> u32 { - let r = (val >> 5) & 7; - let g = (val >> 13) & 7; - let b = (val >> 22) & 3; - (b << 6) | (g << 3) | r - } - - fn rgb12_to_rgb24(val: u32) -> u32 { - let r_raw = val & 0xF; - let r = (r_raw << 4) | r_raw; - let g_raw = (val >> 4) & 0xF; - let g = (g_raw << 4) | g_raw; - let b_raw = (val >> 8) & 0xF; - let b = (b_raw << 4) | b_raw; - (b << 16) | (g << 8) | r - } - - fn rgb24_to_rgb12(val: u32) -> u32 { - let r = (val >> 4) & 0xF; - let g = (val >> 12) & 0xF; - let b = (val >> 20) & 0xF; - (b << 8) | (g << 4) | r - } - - // Bayer 4x4 dither matrix packed as 16 nibbles in a u64. - // Indexed by (y&3)<<2|(x&3): threshold = (BAYER_PACKED >> (idx*4)) & 0xF. - // Table: [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5] - const BAYER_PACKED: u64 = 0x5D7F91B36E4CA280; - - /// Pack bayer index into bits 27:24 of color value (top byte unused by 24-bit BGR). - /// Encoding: bits[3:2] = y&3, bits[1:0] = x&3 → index = (y&3)<<2|(x&3). - /// Non-dither compress variants ignore these bits. - #[inline(always)] - fn bayer_pack(color: u32, x: i32, y: i32) -> u32 { - (color & 0x00FFFFFF) | (((y as u32 & 3) << 2 | (x as u32 & 3)) << 24) - } - fn bayer_nop(color: u32, _x: i32, _y: i32) -> u32 { color } - - #[inline(always)] - fn bayer_threshold(idx: u32) -> u32 { - ((Self::BAYER_PACKED >> (idx * 4)) & 0xF) as u32 - } - - fn rgb24_to_rgb4_dither(val: u32) -> u32 { - let bayer = Self::bayer_threshold(val >> 24); - let r = (val & 0xFF) as u8; - let g = ((val >> 8) & 0xFF) as u8; - let b = ((val >> 16) & 0xFF) as u8; - // 4bpp: 1-2-1 BGR. Each channel dithered down from 8-bit. - let sr = (r >> 3).wrapping_sub(r >> 4); - let sg = (g >> 2).wrapping_sub(g >> 4); - let sb = (b >> 3).wrapping_sub(b >> 4); - let mut dr = (sr >> 4) & 1; - let mut dg = (sg >> 4) & 3; - let mut db = (sb >> 4) & 1; - if (sr & 0xf) as u32 > bayer { dr = (dr + 1).min(1); } - if (sg & 0xf) as u32 > bayer { dg = (dg + 1).min(3); } - if (sb & 0xf) as u32 > bayer { db = (db + 1).min(1); } - ((db << 3) | (dg << 1) | dr) as u32 - } - - fn rgb24_to_rgb8_dither(val: u32) -> u32 { - let bayer = Self::bayer_threshold(val >> 24); - let r = (val & 0xFF) as u8; - let g = ((val >> 8) & 0xFF) as u8; - let b = ((val >> 16) & 0xFF) as u8; - // 8bpp: 3-3-2 BGR. - let sr = (r >> 1).wrapping_sub(r >> 4); - let sg = (g >> 1).wrapping_sub(g >> 4); - let sb = (b >> 2).wrapping_sub(b >> 4); - let mut dr = (sr >> 4) & 7; - let mut dg = (sg >> 4) & 7; - let mut db = (sb >> 4) & 3; - if (sr & 0xf) as u32 > bayer { dr = (dr + 1).min(7); } - if (sg & 0xf) as u32 > bayer { dg = (dg + 1).min(7); } - if (sb & 0xf) as u32 > bayer { db = (db + 1).min(3); } - ((db << 6) | (dg << 3) | dr) as u32 - } - - fn rgb24_to_rgb12_dither(val: u32) -> u32 { - let bayer = Self::bayer_threshold(val >> 24); - let r = (val & 0xFF) as u32; - let g = ((val >> 8) & 0xFF) as u32; - let b = ((val >> 16) & 0xFF) as u32; - // 12bpp: 4-4-4 BGR. - let sr = r - (r >> 4); - let sg = g - (g >> 4); - let sb = b - (b >> 4); - let mut dr = (sr >> 4) & 15; - let mut dg = (sg >> 4) & 15; - let mut db = (sb >> 4) & 15; - if (sr & 0xf) > bayer { dr = (dr + 1).min(15); } - if (sg & 0xf) > bayer { dg = (dg + 1).min(15); } - if (sb & 0xf) > bayer { db = (db + 1).min(15); } - (db << 8) | (dg << 4) | dr - } - - fn host_unpack_nop(_val: u64) -> u32 { 0 } - fn host_pack_nop(acc: u64, _val: u32) -> u64 { acc } - // 4-bit (1-2-1 BGR) expansion pub fn expand_4_rgb(val: u32) -> u32 { let b = (val >> 3) & 1; @@ -2501,570 +1999,183 @@ impl Rex3 { let g = (0x92 * g2) | (0x49 * g1) | (0x24 * g0); // Red: bits 2,1,0 (3 bits) -> 0x92, 0x49, 0x24 - let r2 = (val >> 2) & 1; - let r1 = (val >> 1) & 1; - let r0 = val & 1; - let r = (0x92 * r2) | (0x49 * r1) | (0x24 * r0); - - (b << 16) | (g << 8) | r - } - - // 12-bit (4-4-4 BGR) expansion - pub fn expand_12_rgb(val: u32) -> u32 { - let b = (val >> 8) & 0xF; - let g = (val >> 4) & 0xF; - let r = val & 0xF; - // 4 bits: 0..15 -> 0..255 (x17 or 0x11) - (b * 0x11) << 16 | (g * 0x11) << 8 | (r * 0x11) - } - - // 32-bit (ABGR) expansion - fn expand_32_rgb(val: u32) -> u32 { - // ARGB -> ARGB (internal format AABBGGRR) - val - } - - // Compression functions (Internal -> Host) - fn compress_4_rgb(val: u32) -> u32 { - let b = (val >> 16) & 0xFF; - let g = (val >> 8) & 0xFF; - let r = val & 0xFF; - ((b >> 7) << 3) | ((g >> 6) << 1) | (r >> 7) - } - - fn compress_8_rgb(val: u32) -> u32 { - let b = (val >> 16) & 0xFF; - let g = (val >> 8) & 0xFF; - let r = val & 0xFF; - // BBGGGRRR - ((b >> 6) << 6) | ((g >> 5) << 3) | (r >> 5) - } - - fn compress_12_rgb(val: u32) -> u32 { - let b = (val >> 16) & 0xFF; - let g = (val >> 8) & 0xFF; - let r = val & 0xFF; - ((b >> 4) << 8) | ((g >> 4) << 4) | (r >> 4) - } - - fn compress_32_rgb(val: u32) -> u32 { - val | 0xFF000000 // Set Alpha to 0xFF - } - - // Host Unpack Functions - // All extract from the top of the 64-bit shifter - // We left-shift the shifter after each pixel so current pixel is always at the MSB. - // 4bpp: 8-bit slot, pixel in low nibble → mask 0xf from bit 56 - // 8bpp: 8-bit slot → mask 0xff from bit 56 - // 12bpp: 16-bit slot → mask 0xfff from bit 48 - // 32bpp: 32-bit slot → bits [63:32] - fn host_unpack_4_64(val: u64) -> u32 { - Self::expand_4_rgb(((val >> 56) & 0xF) as u32) - } - fn host_unpack_8_64(val: u64) -> u32 { - Self::expand_8_rgb(((val >> 56) & 0xFF) as u32) - } - fn host_unpack_12_64(val: u64) -> u32 { - Self::expand_12_rgb(((val >> 48) & 0xFFF) as u32) - } - fn host_unpack_32_64(val: u64) -> u32 { - Self::expand_32_rgb((val >> 32) as u32) - } - - fn host_unpack_4_64_ci(val: u64) -> u32 { - ((val >> 56) & 0xF) as u32 - } - fn host_unpack_8_64_ci(val: u64) -> u32 { - ((val >> 56) & 0xFF) as u32 - } - fn host_unpack_12_64_ci(val: u64) -> u32 { - ((val >> 48) & 0xFFF) as u32 - } - fn host_unpack_32_64_ci(val: u64) -> u32 { - (val >> 32) as u32 - } - - // Host Pack Functions — inverse of unpack. - // Each pixel occupies the same slot size as unpack reads: shift acc left by slot, insert pixel in low bits. - // 4bpp: 8-bit slot (shift=8), pixel in low nibble. - // 12bpp: 16-bit slot (shift=16), pixel in low 12 bits. - fn host_pack_4_rgb(acc: u64, pixel: u32) -> u64 { - (acc << 8) | (Self::compress_4_rgb(pixel) as u64) - } - fn host_pack_8_rgb(acc: u64, pixel: u32) -> u64 { - (acc << 8) | (Self::compress_8_rgb(pixel) as u64) - } - fn host_pack_12_rgb(acc: u64, pixel: u32) -> u64 { - (acc << 16) | (Self::compress_12_rgb(pixel) as u64) - } - fn host_pack_32_rgb(acc: u64, pixel: u32) -> u64 { - (acc << 32) | (Self::compress_32_rgb(pixel) as u64) - } - - // CI Mode (Direct) - fn host_pack_4_ci(acc: u64, pixel: u32) -> u64 { - (acc << 8) | ((pixel & 0xF) as u64) - } - fn host_pack_8_ci(acc: u64, pixel: u32) -> u64 { - (acc << 8) | ((pixel & 0xFF) as u64) - } - fn host_pack_12_ci(acc: u64, pixel: u32) -> u64 { - (acc << 16) | ((pixel & 0xFFF) as u64) - } - fn host_pack_32_ci(acc: u64, pixel: u32) -> u64 { - (acc << 32) | (pixel as u64) - } - - fn host_setup(&self, drawmode1: DrawMode1) { - let depth = drawmode1.hostdepth(); - let double = drawmode1.rwdouble(); - let packed = drawmode1.rwpacked(); - let rgb = drawmode1.rgbmode(); - - // 4bpp pixels occupy an 8-bit slot (low nibble); shift is 8 not 4. - // Non-packed: shift is 0 (count=1, shift never used). - let shift = if packed { - match depth { 0 | 1 => 8, 2 => 16, 3 => 32, _ => 0 } - } else { - 0 - }; - - // packed+double: 64/shift_bits pixels; packed+!double: 32/shift_bits pixels; non-packed: 1. - // depth=0 (4bpp) uses 8-bit slots (shift=8), same counts as depth=1 (8bpp). - let count = if packed { - if double { - match depth { 0 | 1 => 8, 2 => 4, 3 => 2, _ => 1 } - } else { - match depth { 0 | 1 => 4, 2 => 2, 3 => 1, _ => 1 } - } - } else { - 1 - }; - - let unpack: fn(u64) -> u32 = if rgb { - match depth { - 0 => Self::host_unpack_4_64, - 1 => Self::host_unpack_8_64, - 2 => Self::host_unpack_12_64, - 3 => Self::host_unpack_32_64, - _ => Self::host_unpack_nop, - } - } else { - match depth { - 0 => Self::host_unpack_4_64_ci, - 1 => Self::host_unpack_8_64_ci, - 2 => Self::host_unpack_12_64_ci, - 3 => Self::host_unpack_32_64_ci, - _ => Self::host_unpack_nop, - } - }; - - let pack: fn(u64, u32) -> u64 = if rgb { - match depth { - 0 => Self::host_pack_4_rgb, - 1 => Self::host_pack_8_rgb, - 2 => Self::host_pack_12_rgb, - 3 => Self::host_pack_32_rgb, - _ => Self::host_pack_nop, - } - } else { - match depth { - 0 => Self::host_pack_4_ci, - 1 => Self::host_pack_8_ci, - 2 => Self::host_pack_12_ci, - 3 => Self::host_pack_32_ci, - _ => Self::host_pack_nop, - } - }; - - unsafe { - *self.host_unpack.get() = unpack; - *self.host_pack.get() = pack; - *self.host_shift.get() = shift; - *self.host_count.get() = count; - } - } - - fn fetch_host_pixel(&self, ctx: &mut Rex3Context) -> u32 { - let rwdouble = ctx.drawmode1.rwdouble(); - let swapendian = ctx.drawmode1.swapendian(); - - if ctx.hostcnt == 0 { - // 32-bit writes land in the high half [63:32] via HOSTRW0, so data is already at MSB. - ctx.host_shifter = ctx.hostrw; - if swapendian { - ctx.host_shifter = if rwdouble { - ctx.host_shifter.swap_bytes() - } else { - // swap only the high 32-bit word - let hi = (ctx.host_shifter >> 32) as u32; - ((hi.swap_bytes() as u64) << 32) | (ctx.host_shifter & 0xFFFF_FFFF) - }; - } - ctx.hostcnt = unsafe { *self.host_count.get() }; - } - - let unpack = unsafe { *self.host_unpack.get() }; - let pixel = unpack(ctx.host_shifter); - - // Shift for next pixel - let shift = unsafe { *self.host_shift.get() }; - - ctx.host_shifter <<= shift; - ctx.hostcnt -= 1; - - pixel - } - - fn send_host_word(&self, ctx: &mut Rex3Context) { - let rwdouble = ctx.drawmode1.rwdouble(); - let swapendian = ctx.drawmode1.swapendian(); - let mut val = ctx.host_shifter; - - if swapendian { - val = val.swap_bytes(); - } else if !rwdouble { - val <<= 32; - } - - ctx.hostrw = val; - } - - fn store_host_pixel(&self, ctx: &mut Rex3Context, pixel: u32) { - if ctx.hostcnt == 0 { - ctx.hostcnt = unsafe { *self.host_count.get() }; - ctx.host_shifter = 0; - } - - let pack = unsafe { *self.host_pack.get() }; - ctx.host_shifter = pack(ctx.host_shifter, pixel); - ctx.hostcnt -= 1; - - if ctx.hostcnt == 0 { - self.send_host_word(ctx); - } - } - - fn flush_host_pixel(&self, ctx: &mut Rex3Context) { - if ctx.hostcnt > 0 { - // Shift remaining bits to align to MSB (since we pack LSB to MSB) - let shift = unsafe { *self.host_shift.get() }; - ctx.host_shifter <<= ctx.hostcnt * shift; - - self.send_host_word(ctx); - ctx.hostcnt = 0; - } - } - - fn combine_host_dda(ctx: &Rex3Context, host_pixel: u32) -> u32 { - let color = if ctx.drawmode0.colorhost() { host_pixel } else { ctx.get_colori() }; - // Afunction's source alpha comes from "either DDA or host" (selected by - // ALPHAHOST) independent of RGB/CI plane format (rex3 spec §3.8.1) — CI-mode - // GL apps can stream a color index alongside a host alpha byte for ALPHAREF - // comparison. Always overlay bits 31:24 with the resolved alpha so afunction - // sees the right value in both modes; compress_fn/write paths for CI already - // mask down to the plane-depth index and never look at these high bits. - let a = if ctx.drawmode0.alphahost() { - (host_pixel >> 24) & 0xFF - } else { - Rex3Context::clamp_color_component(ctx.coloralpha) - }; - (color & 0x00FFFFFF) | (a << 24) - } - - /// Replicate colorvram to fill plane-depth slots, matching MAME get_default_color() with fastclear=1. - pub(crate) fn fastclear_color(ctx: &Rex3Context) -> u32 { - let v = ctx.colorvram; - match ctx.drawmode1.drawdepth() { - 0 => { let c = v & 0xf; c | (c << 4) | (c << 8) | (c << 16) } - 1 => { let c = v & 0xff; c | (c << 8) | (c << 16) } - 2 => { - // 12bpp: in RGB mode use nibbles from colorvram, else lower 12 bits - let c = if ctx.drawmode1.rgbmode() { - ((v & 0xf00000) >> 12) | ((v & 0xf000) >> 8) | ((v & 0xf0) >> 4) - } else { - v & 0x000fff - }; - c | (c << 12) - } - _ => v & 0xffffff, // 24bpp - } - } - - fn blend(&self, ctx: &Rex3Context, src: u32, dst: u32) -> u32 { - let s_factor_sel = ctx.drawmode1.sfactor(); - let d_factor_sel = ctx.drawmode1.dfactor(); - - // BLENDALPHA (DRAWMODE1 bit 27) substitutes the SOURCE multiplier only. - // Spec §3.8: "When source multiplier is set to source alpha (SFACTOR=4) ... - // When BLENDALPHA is set to 0, the source multiplier for blending alpha is - // one instead of source alpha AND DESTINATION MULTIPLIER IS DEFINED BY - // DFACTOR." The trailing clause is load-bearing: DFACTOR keeps its own - // definition, so a DFACTOR of BF_MSA still evaluates 1 - source alpha - // against the real alpha. Substituting in both factors would zero BF_MSA - // and discard the destination entirely, which the spec does not say. - let sa_real = (src >> 24) & 0xFF; - let sa_src = if ctx.drawmode1.blendalpha() { sa_real } else { 255 }; - - let get_factor = |sel: u32, c: u32, a: u32| -> u32 { - match sel { - 0 => 0, // BF_ZERO - 1 => 255, // BF_ONE - 2 => c, // BF_DC (sfactor) / BF_SC (dfactor) - 3 => 255 - c, // BF_MDC (sfactor) / BF_MSC (dfactor) - 4 => a, // BF_SA - 5 => 255 - a, // BF_MSA - _ => 0, // 110/111 undefined by the hardware - } - }; - - let mut res = 0; - for i in 0..4 { - let shift = i * 8; - let s_c = (src >> shift) & 0xFF; - let d_c = (dst >> shift) & 0xFF; - - let sf = get_factor(s_factor_sel, d_c, sa_src); - let df = get_factor(d_factor_sel, s_c, sa_real); - - let val = (s_c * sf + d_c * df) / 255; - let val_clamped = if val > 255 { 255 } else { val }; - - res |= val_clamped << shift; - } - res - } - - fn calculate_src_address(&self, x: i32, y: i32, ctx: &Rex3Context) -> Option { - // xymove affects the destination, not the source. - // Source is just (x, y) + xywin. - let x_win = ((ctx.xywin >> 16) & 0xFFFF) as i16 as i32; - let y_win = (ctx.xywin & 0xFFFF) as i16 as i32; - - let x_abs = x + x_win; - let y_abs = y + y_win; - - let x_phys = x_abs - REX3_COORD_BIAS; - let y_phys = if ctx.drawmode1.yflip() { 0x23FF - y_abs } else { y_abs - REX3_COORD_BIAS }; + let r2 = (val >> 2) & 1; + let r1 = (val >> 1) & 1; + let r0 = val & 1; + let r = (0x92 * r2) | (0x49 * r1) | (0x24 * r0); - if x_phys < 0 || x_phys >= REX3_SCREEN_WIDTH || y_phys < 0 || y_phys >= REX3_SCREEN_HEIGHT { - return None; - } + (b << 16) | (g << 8) | r + } - Some((y_phys as u32) * 2048 + (x_phys as u32)) + // 12-bit (4-4-4 BGR) expansion + pub fn expand_12_rgb(val: u32) -> u32 { + let b = (val >> 8) & 0xF; + let g = (val >> 4) & 0xF; + let r = val & 0xF; + // 4 bits: 0..15 -> 0..255 (x17 or 0x11) + (b * 0x11) << 16 | (g * 0x11) << 8 | (r * 0x11) } - fn process_pixel_noop(&self, _ctx: &mut Rex3Context, _x: i32, _y: i32) {} + // 32-bit (ABGR) expansion + pub(crate) fn expand_32_rgb(val: u32) -> u32 { + // ARGB -> ARGB (internal format AABBGGRR) + val + } - fn process_pixel_fastclear(&self, ctx: &mut Rex3Context, x: i32, y: i32) { - if let Some(addr) = self.calculate_fb_address(x, y, ctx, true) { - let wr_fn = unsafe { *self.px_wr.get() }; - wr_fn(self, addr, Self::fastclear_color(ctx)); - } + // Compression functions (Internal -> Host) + pub(crate) fn compress_4_rgb(val: u32) -> u32 { + let b = (val >> 16) & 0xFF; + let g = (val >> 8) & 0xFF; + let r = val & 0xFF; + ((b >> 7) << 3) | ((g >> 6) << 1) | (r >> 7) } - fn process_pixel_read(&self, ctx: &mut Rex3Context, x: i32, y: i32) { - let rd_fn = unsafe { *self.px_rd.get() }; - let expand_fn = unsafe { *self.px_expand.get() }; - let pixel = if let Some(addr) = self.calculate_fb_address(x, y, ctx, false) { - // Expand plane-depth pixel to 24-bit BGR before packing into host buffer. - // host_pack_N_rgb expects 24-bit BGR; expand is identity in CI mode. - expand_fn(rd_fn(self, addr)) - } else { - 0 - }; - self.store_host_pixel(ctx, pixel); + pub(crate) fn compress_8_rgb(val: u32) -> u32 { + let b = (val >> 16) & 0xFF; + let g = (val >> 8) & 0xFF; + let r = val & 0xFF; + // BBGGGRRR + ((b >> 6) << 6) | ((g >> 5) << 3) | (r >> 5) } - fn cid_allows_write(&self, ctx: &Rex3Context, addr: u32) -> bool { - let enabled = (ctx.clipmode >> CLIPMODE_CIDMATCH_SHIFT) & 0xF; - if enabled == 0xF { return true; } - // REX3 spec, CLIPMODE table 16: each bit enables one of the four - // two-bit CID values. AUX bits 3:2 are popup data, not part of CID. - let cid = unsafe { (*self.fb_aux.get())[addr as usize] } & 3; - enabled & (1 << cid) != 0 + pub(crate) fn compress_12_rgb(val: u32) -> u32 { + let b = (val >> 16) & 0xFF; + let g = (val >> 8) & 0xFF; + let r = val & 0xFF; + ((b >> 4) << 8) | ((g >> 4) << 4) | (r >> 4) } - fn process_pixel_draw(&self, ctx: &mut Rex3Context, x: i32, y: i32) { - let colorhost = ctx.drawmode0.colorhost(); - let alphahost = ctx.drawmode0.alphahost(); - - let mut use_bg = false; - let mut check_ls = true; - - // Pattern checks first — host pixel only consumed when the pixel is actually drawn. - // MAME: get_host_color() called only inside if(BIT(pattern, bit)), never on skip/opaque paths. - if ctx.drawmode0.enzpattern() { - let bit = (ctx.zpattern >> ctx.zpat_bit) & 1 != 0; - if !bit { - if ctx.drawmode0.zpopaque() { - use_bg = true; - check_ls = false; - } else { - return; - } - } - } + pub(crate) fn compress_32_rgb(val: u32) -> u32 { + val | 0xFF000000 // Set Alpha to 0xFF + } - if ctx.drawmode0.enlspattern() { - let bit = (ctx.lspattern >> ctx.pat_bit) & 1 != 0; - if check_ls && !bit { - if ctx.drawmode0.lsopaque() { - use_bg = true; - } else { - return; - } - } - } + /// Summary counts for `rex jit status` / `rex jit list`. + fn write_shader_summary(&self, writer: &mut Box) { + let rows = self.shader_report(); + let count = |o: &str| rows.iter().filter(|r| r.origin == o).count(); + let jit_bytes: u32 = rows.iter().filter(|r| r.origin == "jit").map(|r| r.bytes).sum(); - // Fetch host pixel only when the pattern passes and we're drawing from host (not colorback). - let host_pixel = if !use_bg && (alphahost || colorhost) { - self.fetch_host_pixel(ctx) - } else { - 0 + #[cfg(feature = "rex-jit")] + let engine = match self.rex_jit { + Some(_) if self.jit_enabled.load(Ordering::Relaxed) => "cranelift enabled", + Some(_) => "cranelift DISABLED", + None => "cranelift not initialised", }; + #[cfg(not(feature = "rex-jit"))] + let engine = "cranelift not compiled in"; + + writeln!(writer, "REX3 shaders: {engine}").unwrap(); + writeln!( + writer, + " precompiled={} jit={} ({} bytes) generic={} queued={} failed={}", + count("precompiled"), + count("jit"), + jit_bytes, + count("generic"), + count("queued"), + count("failed"), + ).unwrap(); + writeln!( + writer, + " {} draw shapes seen this session, {} shapes known in total", + self.seen_shapes.lock().len(), + rows.len(), + ).unwrap(); + } + + /// One row of the shader report. + pub fn shader_report(&self) -> Vec { + use std::collections::BTreeSet; + + let precompiled: std::collections::HashSet<(u32, u32, u32)> = + crate::rex3_shaders::SHADERS.iter().map(|(k, _)| *k).collect(); + + // Every shape worth reporting: what was drawn, what is precompiled, and + // (with rex-jit) what Cranelift knows about. + let mut keys: BTreeSet<(u32, u32, u32)> = + self.seen_shapes.lock().iter().copied().collect(); + keys.extend(precompiled.iter().copied()); - if let Some(addr) = self.calculate_fb_address(x, y, ctx, true) { - if !self.cid_allows_write(ctx, addr) { return; } - - // src color: 24-bit BGR in rgbmode, plane-depth index in CI mode - let raw_src = if use_bg { - ctx.colorback - } else { - Self::combine_host_dda(ctx, host_pixel) + #[cfg(feature = "rex-jit")] + let jit_info: std::collections::HashMap<(u32, u32, u32), (&'static str, u32)> = + match self.rex_jit { + Some(ref jit) => { + let list = jit.shader_list(); + keys.extend(list.iter().map(|s| (s.dm0, s.dm1, s.cm))); + list.iter() + .map(|s| ((s.dm0, s.dm1, s.cm), (s.status, s.code_bytes))) + .collect() + } + None => std::collections::HashMap::new(), }; - // Afunction: inhibit the write unless source alpha (raw_src bits 31:24) - // passes the DRAWMODE1 COMPARE relation against ALPHAREF. px_afunc is - // selected once per mode change in planes_setup (see afunc_* below); - // it's a no-op always-pass function outside rgbmode or when COMPARE==0x7. - let afunc_fn = unsafe { *self.px_afunc.get() }; - if !afunc_fn(raw_src >> 24 & 0xFF, ctx.alpharef & 0xFF) { - return; - } - - let rd_fn = unsafe { *self.px_rd.get() }; - let wr_fn = unsafe { *self.px_wr.get() }; - let compress_fn = unsafe { *self.px_compress.get() }; - - let res = if ctx.drawmode1.blend() { - // Blend path: work in 24-bit BGR space throughout. - // src is already 24-bit BGR (rgbmode) or CI index (expand=identity). - // dst is read as plane-depth then expanded to 24-bit BGR. - let expand_fn = unsafe { *self.px_expand.get() }; - let dst_raw = if ctx.drawmode1.backblend() { - ctx.colorback - } else { - expand_fn(rd_fn(self, addr)) - }; - let blended = self.blend(ctx, raw_src, dst_raw); - // Compress blended 24-bit result back to plane-depth, then amplify for - // dblsrc packing exactly as the logic-op path below does: at 12bpp two - // pixels share a 24-bit word, so compress leaves the value in bits 11:0 - // and whichever slot WRMASK selects must be fed by amplify. Without it - // every WRMASK that covers the high slot (0xfff000, or 0xffffff for both) - // writes zeros there — i.e. black. - let bayer_fn = unsafe { *self.px_bayer.get() }; - let amp_fn = unsafe { *self.px_amp.get() }; - amp_fn(compress_fn(bayer_fn(blended, x, y))) - } else { - // Logic op path: compress src to plane-depth, amplify for dblsrc, then logic op. - // dst also needs amplify: rd_fn shifts the value down (e.g. bits 15:8 → 7:0 for - // dblsrc slot 1), so we must shift it back up to match the write mask position. - let bayer_fn = unsafe { *self.px_bayer.get() }; - let amp_fn = unsafe { *self.px_amp.get() }; - let logic_fn = unsafe { *self.px_logic.get() }; - let src = amp_fn(compress_fn(bayer_fn(raw_src, x, y))); - let dst = amp_fn(rd_fn(self, addr)); - logic_fn(src, dst) - }; - wr_fn(self, addr, res); - } + keys.into_iter() + .map(|(dm0, dm1, cm)| { + // Precompiled wins: the dispatch map is seeded with those, so a + // shape covered by Rust is never sent to Cranelift. + if precompiled.contains(&(dm0, dm1, cm)) { + return ShaderRow { dm0, dm1, cm, origin: "precompiled", bytes: 0 }; + } + #[cfg(feature = "rex-jit")] + if let Some((status, bytes)) = jit_info.get(&(dm0, dm1, cm)) { + let origin = match *status { + "compiled" => "jit", + other => other, // queued / failed / disabled + }; + return ShaderRow { dm0, dm1, cm, origin, bytes: *bytes }; + } + ShaderRow { dm0, dm1, cm, origin: "generic", bytes: 0 } + }) + .collect() } - /// Specialization for character/glyph drawing: zpattern test only, SRC logicop, - /// no blend, no colorhost, no CID check. Skips pixel on zpattern bit=0. - /// Selected when: DRAW + enzpattern + !enlspattern + !zpopaque + !blend + !colorhost + !alphahost - /// + CID==0xF + logicop==SRC. - fn process_pixel_zpattern(&self, ctx: &mut Rex3Context, x: i32, y: i32) { - if (ctx.zpattern >> ctx.zpat_bit) & 1 == 0 { + /// Write the draw-shape corpus to disk. + /// + /// Unions this run's shapes with whatever the profile already held, so a run + /// can only ever add. The generated shader table's keys go in too: those + /// shapes are served by compiled-in Rust and may never reach Cranelift, and + /// without them a regeneration would emit a smaller table than the one it + /// replaced. + fn save_shape_corpus(&self) { + let drawn: std::collections::HashSet<(u32, u32, u32)> = + self.seen_shapes.lock().iter().copied().collect(); + let on_disk = crate::rex3_profile::load_profile_quiet(); + + // Union of three sources. A run can only ever add: a session that drew + // two shapes must not shrink a corpus collected over many. + let mut all: std::collections::HashSet<(u32, u32, u32)> = drawn.clone(); + all.extend(on_disk.iter().copied()); + // The generated table's keys: those shapes are served by compiled-in + // Rust and may never reach Cranelift, so without this a regeneration + // would emit a smaller table than the one it replaced. + all.extend(crate::rex3_shaders::SHADERS.iter().map(|(k, _)| *k)); + + if all.is_empty() { return; } - if let Some(addr) = self.calculate_fb_address(x, y, ctx, true) { - let wr_fn = unsafe { *self.px_wr.get() }; - let amp_fn = unsafe { *self.px_amp.get() }; - let bayer_fn = unsafe { *self.px_bayer.get() }; - let compress_fn = unsafe { *self.px_compress.get() }; - // SRC logicop: result = src, no dst read needed. - wr_fn(self, addr, amp_fn(compress_fn(bayer_fn(ctx.get_colori(), x, y)))); - } - } - - /// Specialization for common solid draws: no blend, no colorhost, no alphahost, no CID check. - /// Handles patterns (use_bg) and any logicop, but skips the blend and host-fetch paths. - /// Selected when: DRAW + !blend + !colorhost + !alphahost + CID==0xF. - fn process_pixel_noblend(&self, ctx: &mut Rex3Context, x: i32, y: i32) { - let mut use_bg = false; - - if ctx.drawmode0.enzpattern() { - let bit = (ctx.zpattern >> ctx.zpat_bit) & 1 != 0; - if !bit { - if ctx.drawmode0.zpopaque() { use_bg = true; } else { return; } - } - } - - if ctx.drawmode0.enlspattern() { - let bit = (ctx.lspattern >> ctx.pat_bit) & 1 != 0; - if !bit { - if ctx.drawmode0.lsopaque() { use_bg = true; } else { return; } - } - } - - if let Some(addr) = self.calculate_fb_address(x, y, ctx, true) { - let raw_src = if use_bg { ctx.colorback } else { ctx.get_colori() }; - let rd_fn = unsafe { *self.px_rd.get() }; - let wr_fn = unsafe { *self.px_wr.get() }; - let amp_fn = unsafe { *self.px_amp.get() }; - let bayer_fn = unsafe { *self.px_bayer.get() }; - let compress_fn = unsafe { *self.px_compress.get() }; - let logic_fn = unsafe { *self.px_logic.get() }; - let src = amp_fn(compress_fn(bayer_fn(raw_src, x, y))); - let dst = amp_fn(rd_fn(self, addr)); - wr_fn(self, addr, logic_fn(src, dst)); - } - } - - fn process_pixel_scr2scr(&self, ctx: &mut Rex3Context, x: i32, y: i32) { - let rd_fn = unsafe { *self.px_rd.get() }; - let amp_fn = unsafe { *self.px_amp.get() }; - let expand_fn = unsafe { *self.px_expand.get() }; - let compress_fn = unsafe { *self.px_compress.get() }; - // src: read plane-depth pixel, expand to 24-bit (rgbmode) or leave as-is (CI), amplify. - let raw_src = if let Some(src_addr) = self.calculate_src_address(x, y, ctx) { - expand_fn(rd_fn(self, src_addr)) - } else { - 0 - }; - - if let Some(dst_addr) = self.calculate_fb_address(x, y, ctx, true) { - if !self.cid_allows_write(ctx, dst_addr) { return; } - let wr_fn = unsafe { *self.px_wr.get() }; - - let res = if ctx.drawmode1.blend() { - let dst_raw = if ctx.drawmode1.backblend() { - ctx.colorback - } else { - expand_fn(rd_fn(self, dst_addr)) - }; - compress_fn(self.blend(ctx, raw_src, dst_raw)) - } else { - let logic_fn = unsafe { *self.px_logic.get() }; - let src = amp_fn(compress_fn(raw_src)); - let dst = amp_fn(rd_fn(self, dst_addr)); - logic_fn(src, dst) - }; - wr_fn(self, dst_addr, res); + // How much this session actually contributed, which is the number worth + // seeing: a run that discovers nothing new should say so. + let known: std::collections::HashSet<(u32, u32, u32)> = on_disk + .iter() + .copied() + .chain(crate::rex3_shaders::SHADERS.iter().map(|(k, _)| *k)) + .collect(); + let new_this_run = drawn.difference(&known).count(); + + let mut triples: Vec<(u32, u32, u32)> = all.into_iter().collect(); + triples.sort_unstable(); + + eprintln!( + "REX3 corpus: {} drawn this session ({} new), {} on disk, {} precompiled -> saving {}", + drawn.len(), + new_this_run, + on_disk.len(), + crate::rex3_shaders::SHADERS.len(), + triples.len(), + ); + if let Err(e) = crate::rex3_profile::save_profile(&triples) { + eprintln!("REX3: failed to save shape corpus: {e}"); } } @@ -3277,144 +2388,64 @@ impl Rex3 { val } - fn logic_op_zero(_src: u32, _dst: u32) -> u32 { 0 } - fn logic_op_and(src: u32, dst: u32) -> u32 { src & dst } - fn logic_op_andr(src: u32, dst: u32) -> u32 { src & !dst } - fn logic_op_src(src: u32, _dst: u32) -> u32 { src } - fn logic_op_andi(src: u32, dst: u32) -> u32 { !src & dst } - fn logic_op_dst(_src: u32, dst: u32) -> u32 { dst } - fn logic_op_xor(src: u32, dst: u32) -> u32 { src ^ dst } - fn logic_op_or(src: u32, dst: u32) -> u32 { src | dst } - fn logic_op_nor(src: u32, dst: u32) -> u32 { !(src | dst) } - fn logic_op_xnor(src: u32, dst: u32) -> u32 { !(src ^ dst) } - fn logic_op_ndst(_src: u32, dst: u32) -> u32 { !dst } - fn logic_op_orr(src: u32, dst: u32) -> u32 { src | !dst } - fn logic_op_nsrc(src: u32, _dst: u32) -> u32 { !src } - fn logic_op_ori(src: u32, dst: u32) -> u32 { !src | dst } - fn logic_op_nand(src: u32, dst: u32) -> u32 { !(src & dst) } - fn logic_op_one(_src: u32, _dst: u32) -> u32 { !0 } - - // Afunction: (src_alpha, alpharef) -> pass. COMPARE is three OR'ed enable - // bits — src>ref(2), src=ref(1), src bool { true } - fn afunc_never(_sa: u32, _aref: u32) -> bool { false } - fn afunc_lt(sa: u32, aref: u32) -> bool { sa < aref } - fn afunc_eq(sa: u32, aref: u32) -> bool { sa == aref } - fn afunc_le(sa: u32, aref: u32) -> bool { sa <= aref } - fn afunc_gt(sa: u32, aref: u32) -> bool { sa > aref } - fn afunc_ne(sa: u32, aref: u32) -> bool { sa != aref } - fn afunc_ge(sa: u32, aref: u32) -> bool { sa >= aref } - - fn read_rgb_4_0(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_rgb.get())[addr as usize] }; - val & 0xF - } - - fn read_rgb_4_1(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_rgb.get())[addr as usize] }; - (val >> 4) & 0xF - } - - fn read_rgb_8_0(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_rgb.get())[addr as usize] }; - val & 0xFF - } - - fn read_rgb_8_1(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_rgb.get())[addr as usize] }; - (val >> 8) & 0xFF - } - - fn read_rgb_12_0(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_rgb.get())[addr as usize] }; - val & 0xFFF - } - - fn read_rgb_12_1(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_rgb.get())[addr as usize] }; - (val >> 12) & 0xFFF - } - - fn read_rgb_24(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_rgb.get())[addr as usize] }; - val & 0xFFFFFF - } - - fn read_olay_0(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_aux.get())[addr as usize] }; - (val >> 8) & 0xFF - } - - fn read_olay_1(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_aux.get())[addr as usize] }; - (val >> 16) & 0xFF - } - - fn read_cid_0(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_aux.get())[addr as usize] }; - val & 0x3 - } - - fn read_cid_1(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_aux.get())[addr as usize] }; - (val >> 4) & 0x3 - } - fn read_pup_0(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_aux.get())[addr as usize] }; - (val >> 2) & 0x3 - } - - fn read_pup_1(rex: &Rex3, addr: u32) -> u32 { - let val = unsafe { (*rex.fb_aux.get())[addr as usize] }; - (val >> 6) & 0x3 - } - - fn read_zero(_rex: &Rex3, _addr: u32) -> u32 { 0 } - - fn write_rgb_4(rex: &Rex3, addr: u32, val: u32) { - let mask = unsafe { (*rex.context.get()).wrmask }; - let fb = unsafe { &mut *rex.fb_rgb.get() }; - fb[addr as usize] = (fb[addr as usize] & !mask) | (val & mask); - } - - fn write_rgb_8(rex: &Rex3, addr: u32, val: u32) { - let mask = unsafe { (*rex.context.get()).wrmask }; - let fb = unsafe { &mut *rex.fb_rgb.get() }; - fb[addr as usize] = (fb[addr as usize] & !mask) | (val & mask); - } - fn write_rgb_12(rex: &Rex3, addr: u32, val: u32) { - let mask = unsafe { (*rex.context.get()).wrmask }; - let fb = unsafe { &mut *rex.fb_rgb.get() }; - fb[addr as usize] = (fb[addr as usize] & !mask) | (val & mask); - } - - fn write_rgb_24(rex: &Rex3, addr: u32, val: u32) { - let mask = unsafe { (*rex.context.get()).wrmask }; - let fb = unsafe { &mut *rex.fb_rgb.get() }; - fb[addr as usize] = (fb[addr as usize] & !mask) | (val & mask); - } - fn write_olay(rex: &Rex3, addr: u32, val: u32) { - let mask = unsafe { (*rex.context.get()).wrmask }; - let fb = unsafe { &mut *rex.fb_aux.get() }; - fb[addr as usize] = (fb[addr as usize] & !mask) | (val & mask); + /// The `(shift, mask)` a plane read applies, derived from + /// `(planes, drawdepth, dblsrc)`. + /// + /// `None` means the read yields zero (unmapped plane). + #[inline(always)] + pub(crate) const fn plane_read_shift_mask( + planes: u32, + drawdepth: u32, + dblsrc: bool, + ) -> Option<(u32, u32)> { + match planes { + DRAWMODE1_PLANES_RGB | DRAWMODE1_PLANES_RGBA => match drawdepth { + 0 => Some((if dblsrc { 4 } else { 0 }, 0xF)), + 1 => Some((if dblsrc { 8 } else { 0 }, 0xFF)), + 2 => Some((if dblsrc { 12 } else { 0 }, 0xFFF)), + 3 => Some((0, 0xFFFFFF)), + _ => None, + }, + DRAWMODE1_PLANES_OLAY => Some((if dblsrc { 16 } else { 8 }, 0xFF)), + DRAWMODE1_PLANES_PUP => Some((if dblsrc { 6 } else { 2 }, 0x3)), + DRAWMODE1_PLANES_CID => Some((if dblsrc { 4 } else { 0 }, 0x3)), + _ => None, + } } - fn write_cid(rex: &Rex3, addr: u32, val: u32) { - let mask = unsafe { (*rex.context.get()).wrmask }; - let fb = unsafe { &mut *rex.fb_aux.get() }; - fb[addr as usize] = (fb[addr as usize] & !mask) | (val & mask); + /// True when this plane selection reads from `fb_aux` rather than `fb_rgb`. + #[inline(always)] + pub(crate) const fn plane_is_aux(planes: u32) -> bool { + matches!( + planes, + DRAWMODE1_PLANES_OLAY | DRAWMODE1_PLANES_PUP | DRAWMODE1_PLANES_CID + ) } - fn write_pup(rex: &Rex3, addr: u32, val: u32) { - let mask = unsafe { (*rex.context.get()).wrmask }; - let fb = unsafe { &mut *rex.fb_aux.get() }; - fb[addr as usize] = (fb[addr as usize] & !mask) | (val & mask); + /// Masked read-modify-write of one framebuffer word. + /// + /// The single implementation behind every plane write: the variants differed + /// only in which framebuffer they touched, and each re-derived `wrmask` from + /// `rex.context` even though every caller already held the context. Taking + /// the mask as an argument removes that second route to the same data, which + /// is what lets the generic draw path hold `&mut Rex3Context` across a pixel + /// write. + #[inline(always)] + pub(crate) fn write_masked(fb: &mut [u32], addr: u32, val: u32, mask: u32) { + let slot = &mut fb[addr as usize]; + *slot = (*slot & !mask) | (val & mask); } - fn write_nop(_rex: &Rex3, _addr: u32, _val: u32) {} + // ── Shims for the generic draw path (src/rex3_generic.rs) ──────────────── + // The generic path selects among these bodies by decoded shape instead of + // through the px_* function pointers. They are re-exported rather than + // reimplemented: the colour packings are irregular (1-2-1 at 4bpp, 3-3-2 at + // 8bpp), the dither variants carry a specific error-diffusion form, and + // blend has spec-cited factor semantics — all of which a second copy would + // get subtly wrong. fn gfifo_push(&self, addr: u32, val: u64) { #[cfg(feature = "developer")] @@ -3465,8 +2496,45 @@ impl Rex3 { true } + /// Does this register offset need handling on the CPU thread rather than + /// through the queue? Mirrors `write32`'s match arms. + #[inline(always)] + fn reg_needs_cpu_side_effect(reg_offset: u32) -> bool { + matches!( + reg_offset & !0x0800, + REX3_CONFIG | REX3_DCBMODE | REX3_DCBDATA0 | REX3_DCBDATA1 | REX3_DCBRESET + ) + } + + /// Two-entry `gfifo_try_push`, for a 64-bit store's register pair. + #[must_use] + fn gfifo_try_push2(&self, addr0: u32, val0: u64, addr1: u32, val1: u64) -> bool { + #[cfg(feature = "developer")] + { + let len = self.gfifo.len() + 2; + let _ = self.gfifo_hwm.try_update(Ordering::Relaxed, Ordering::Relaxed, |hwm| { + if len > hwm { Some(len) } else { None } + }); + } + if !self.gfifo.try_push2(addr0, val0, addr1, val1) { + return false; + } + #[cfg(feature = "idle-pause")] + if self.processor_parked.load(Ordering::Acquire) { + if let Some(t) = self.processor_unparker.get() { + t.unpark(); + } + } + true + } + fn wait_idle(&self) { loop { + // Publish before testing: unlike the bus read paths this one has no + // retry escape — it spins here until the queue reports empty — so a + // queue that looks emptier or fuller than it is turns into a hang + // rather than an extra round trip. + self.gfifo.publish_tail(); // Acquire load: when gfxbusy goes false, all execute_go() writes become visible. let busy = self.gfxbusy.load(Ordering::Acquire); if !busy && self.gfifo.is_empty() { break; } @@ -3475,93 +2543,6 @@ impl Rex3 { } } - pub fn calculate_fb_address(&self, x: i32, y: i32, ctx: &Rex3Context, is_write: bool) -> Option { - // 1. XYOFFSET (Draw only, not SCR2SCR source) - let opcode = ctx.drawmode0.opcode(); - let is_scr2scr = opcode == DRAWMODE0_OPCODE_SCR2SCR; - - let mut x_curr = x; - let mut y_curr = y; - - // In scr2scr mode xymove is unconditional (it offsets the destination). - // In regular paint mode it is conditional on the xyoffset flag. - let apply_xymove = is_scr2scr || ctx.drawmode0.xyoffset(); - if apply_xymove { - let x_move = (ctx.xymove >> 16) as i16 as i32; - let y_move = (ctx.xymove & 0xFFFF) as i16 as i32; - x_curr += x_move; - y_curr += y_move; - } - - // Apply XYWIN offset - // XYWIN is 16,16. Assuming High=X, Low=Y. - // Treated as signed 16-bit integers for coordinate biasing. - let x_off = ((ctx.xywin >> 16) & 0xFFFF) as i16 as i32; - let y_off = (ctx.xywin & 0xFFFF) as i16 as i32; - - let x_abs = x_curr + x_off; - let y_abs = y_curr + y_off; - - if is_write { - let clipmode = ctx.clipmode; - let ensmask = clipmode & CLIPMODE_ENSMASK_MASK; - - // SMASK0 (Window Relative) — high16=min, low16=max - if (ensmask & 1) != 0 { - let min_x = ((ctx.smask0x >> 16) & 0xFFFF) as i16 as i32; - let max_x = (ctx.smask0x & 0xFFFF) as i16 as i32; - let min_y = ((ctx.smask0y >> 16) & 0xFFFF) as i16 as i32; - let max_y = (ctx.smask0y & 0xFFFF) as i16 as i32; - - if x_curr < min_x || x_curr > max_x || y_curr < min_y || y_curr > max_y { - return None; - } - } - - // SMASK1-4 (Screen Absolute, unaffected by XYWIN per spec). - // Host pre-biases smask values with the 4K,4K offset. The equivalent - // pixel coordinate is x_phys + 0x1000 = (x_abs - 0x1000) + 0x1000 = x_abs. - // So compare x_abs/y_abs directly against raw smask values. high16=min, low16=max. - // Logic: pixel must be inside at least one enabled mask. - let smask_enabled = (ensmask & 0x1E) != 0; - if smask_enabled { - let smasks = [ - (ctx.smask1x, ctx.smask1y), - (ctx.smask2x, ctx.smask2y), - (ctx.smask3x, ctx.smask3y), - (ctx.smask4x, ctx.smask4y), - ]; - let mut inside_any = false; - for (bit, (sx, sy)) in smasks.iter().enumerate() { - if (ensmask & (1 << (bit + 1))) == 0 { continue; } - let min_x = (sx >> 16) as i16 as i32; - let max_x = (sx & 0xFFFF) as i16 as i32; - let min_y = (sy >> 16) as i16 as i32; - let max_y = (sy & 0xFFFF) as i16 as i32; - if x_abs >= min_x && x_abs <= max_x && y_abs >= min_y && y_abs <= max_y { - inside_any = true; - break; - } - } - if !inside_any { - return None; - } - } - } - // Physical Address Calculation - let x_phys = x_abs - REX3_COORD_BIAS; - let y_phys = if ctx.drawmode1.yflip() { 0x23FF - y_abs } else { y_abs - REX3_COORD_BIAS }; - - // Sector Clipping (VRAM bounds) - // Reads are not culled (but must be within VRAM allocation) - let width_limit = if is_write { REX3_SCREEN_WIDTH } else { 2048 }; - if x_phys < 0 || x_phys >= width_limit || y_phys < 0 || y_phys >= REX3_SCREEN_HEIGHT { - return None; - } - - Some((y_phys as u32) * 2048 + (x_phys as u32)) - } - fn register_processor(&self) { // Publish our thread handle so gfifo_push can unpark us when we park. #[cfg(feature = "idle-pause")] @@ -3660,6 +2641,7 @@ impl Rex3 { } pub(crate) fn execute_go(&self) { + #[cfg(feature = "rexdiag")] self.diag.fetch_or(Self::DIAG_LOOP_EXECUTE_GO, Ordering::Relaxed); let ctx = unsafe { &mut *self.context.get() }; let opcode = ctx.drawmode0.opcode(); @@ -3685,7 +2667,7 @@ impl Rex3 { } else { // Continuation GO: re-derive Bresenham when the segment axis disagrees with // the persisted octant (e.g. degenerate setup point, then horizontal cont). - let adrmode = ctx.drawmode0.adrmode() << 2; + let adrmode = ctx.drawmode0.adrmode(); let is_line = adrmode == DRAWMODE0_ADRMODE_I_LINE || adrmode == DRAWMODE0_ADRMODE_F_LINE || adrmode == DRAWMODE0_ADRMODE_A_LINE; @@ -3724,290 +2706,114 @@ impl Rex3 { ctx.xend as f32 / 2048.0, ctx.yend as f32 / 2048.0); } - #[cfg(feature = "rex-jit")] + // ── Shader dispatch ────────────────────────────────────────────── + // + // One map, two producers. LLVM-compiled shaders (rex3_shaders) are built + // into every binary and seeded at construction; Cranelift adds to the + // same map when `rex-jit` is on. Both use the identical ABI, so the call + // below does not care which compiled the entry it found. + // + // Only the *compile request* is gated on `rex-jit` — the lookup, the + // memo and the call are unconditional, which is what lets the generated + // table work in the default build. { - if self.jit_enabled.load(Ordering::Relaxed) { - if let Some(ref jit) = self.rex_jit { - let dm0 = ctx.drawmode0.0; - // Normalize dm1 key to match compile_shader's normalization: - // fastclear clears blend; scr2scr clears dither (copies quantized pixels). - let dm1_raw = ctx.drawmode1.0; - let dm1 = if dm1_raw & (1 << 17) != 0 { dm1_raw & !(1 << 18) } // fastclear→no blend - else if opcode == DRAWMODE0_OPCODE_SCR2SCR { dm1_raw & !(1 << 16) } // scr2scr→no dither - else { dm1_raw }; - let adrmode = ctx.drawmode0.adrmode() << 2; - let is_line = adrmode == DRAWMODE0_ADRMODE_I_LINE - || adrmode == DRAWMODE0_ADRMODE_F_LINE - || adrmode == DRAWMODE0_ADRMODE_A_LINE; - let is_jittable = (opcode == DRAWMODE0_OPCODE_DRAW - || opcode == DRAWMODE0_OPCODE_SCR2SCR - || opcode == DRAWMODE0_OPCODE_READ) - && (adrmode == DRAWMODE0_ADRMODE_BLOCK || adrmode == DRAWMODE0_ADRMODE_SPAN || is_line); - if is_jittable { - let cm = ctx.clipmode & CLIPMODE_JIT_KEY_MASK; - // Fast path: same (dm0, dm1, cm) as last GO — skip the HashMap lookup. - let last = self.jit_last.get(); - let entry = if last.0 == dm0 && last.1 == dm1 && last.2 == cm && last.3.is_some() { - last.3 + let dm0 = ctx.drawmode0.0; + // Shared with compile_shader and the interpreter setup key below — + // all three must agree or shaders get filed under a key nobody looks up. + let dm1 = crate::rex3_shape::normalize_dm1(ctx.drawmode1.0, opcode); + let adrmode = ctx.drawmode0.adrmode(); + let is_line = adrmode == DRAWMODE0_ADRMODE_I_LINE + || adrmode == DRAWMODE0_ADRMODE_F_LINE + || adrmode == DRAWMODE0_ADRMODE_A_LINE; + let is_shadeable = (opcode == DRAWMODE0_OPCODE_DRAW + || opcode == DRAWMODE0_OPCODE_SCR2SCR + || opcode == DRAWMODE0_OPCODE_READ) + && (adrmode == DRAWMODE0_ADRMODE_BLOCK || adrmode == DRAWMODE0_ADRMODE_SPAN || is_line); + + #[cfg(feature = "rex-jit")] + let dispatch_on = self.jit_enabled.load(Ordering::Relaxed); + #[cfg(not(feature = "rex-jit"))] + let dispatch_on = true; + + if is_shadeable { + let cm = ctx.clipmode & CLIPMODE_JIT_KEY_MASK; + // Record the shape: this is the corpus, and it has to reflect + // what the guest draws regardless of which engine serves it. + // Skipped when the memo already holds this key, so a run of + // same-shape GOs costs one compare rather than a lock. + let last = self.shader_last.get(); + if (last.0, last.1, last.2) != (dm0, dm1, cm) { + self.seen_shapes.lock().insert((dm0, dm1, cm)); + } + } + + if is_shadeable && dispatch_on { + let cm = ctx.clipmode & CLIPMODE_JIT_KEY_MASK; + // Fast path: same key as the last GO — skip the map lookup. + let last = self.shader_last.get(); + let entry = if last.0 == dm0 && last.1 == dm1 && last.2 == cm && last.3.is_some() { + last.3 + } else { + let e = self.shaders.read().get(&(dm0, dm1, cm)).copied(); + if e.is_some() { + self.shader_last.set((dm0, dm1, cm, e)); } else { - let e = jit.lookup(dm0, dm1, cm); - if let Some(_) = e { self.jit_last.set((dm0, dm1, cm, e)); } - else { jit.request_compile(dm0, dm1, cm); } - e - }; - if let Some(entry) = entry { - // Mirror the interpreter's log_block() calls (see bottom of this - // function) so block/span primitives are traced identically whether - // dispatched via JIT or interpreter — block_debug/draw_debug were - // previously silent for JIT-compiled GOs since this path returns - // before ever reaching the interpreter's log_block() calls. - if adrmode == DRAWMODE0_ADRMODE_BLOCK || adrmode == DRAWMODE0_ADRMODE_SPAN { - self.log_block(ctx, opcode); + // Nothing precompiled for this shape. Ask Cranelift to + // build one (if it is compiled in) and run the generic + // path meanwhile; without rex-jit the generic path is + // simply what always runs for uncovered shapes. + #[cfg(feature = "rex-jit")] + if let Some(ref jit) = self.rex_jit { + jit.request_compile(dm0, dm1, cm); } - let fb_rgb = unsafe { (*self.fb_rgb.get()).as_mut_ptr() }; - let fb_aux = unsafe { (*self.fb_aux.get()).as_mut_ptr() }; - unsafe { entry(ctx as *mut Rex3Context, fb_rgb, fb_aux); } - self.jit_go_count.fetch_add(1, Ordering::Relaxed); - self.diag.fetch_and(!Self::DIAG_LOOP_EXECUTE_GO, Ordering::Relaxed); - return; } - // fall through to interpreter + e + }; + if let Some(entry) = entry { + // Mirror the interpreter's log_block() calls so block/span + // primitives trace identically whichever engine ran them. + if adrmode == DRAWMODE0_ADRMODE_BLOCK || adrmode == DRAWMODE0_ADRMODE_SPAN { + self.log_block(ctx, opcode); + } + let fb_rgb = unsafe { (*self.fb_rgb.get()).as_mut_ptr() }; + let fb_aux = unsafe { (*self.fb_aux.get()).as_mut_ptr() }; + unsafe { entry(ctx as *mut Rex3Context, fb_rgb, fb_aux); } + #[cfg(feature = "rexdiag")] + self.jit_go_count.fetch_add(1, Ordering::Relaxed); + #[cfg(feature = "rexdiag")] + self.diag.fetch_and(!Self::DIAG_LOOP_EXECUTE_GO, Ordering::Relaxed); + return; } + // fall through to the generic draw path } - } // jit_enabled } // Interpreter-only setup: function pointer selection and host/planes dispatch tables. // Skipped when JIT handles the draw (returned above) or when nothing affecting these // tables has changed since the last GO. let cidmatch_bits = (ctx.clipmode >> CLIPMODE_CIDMATCH_SHIFT) & 0xF; - // SCR2SCR: normalize dm1 key the same way planes_setup does (clear dither bit). - let dm1_norm = if opcode == DRAWMODE0_OPCODE_SCR2SCR { - ctx.drawmode1.0 & !(1 << 16) - } else { - ctx.drawmode1.0 - }; + // Same normalization as the JIT dispatch key above and compile_shader. + // Previously this did only the SCR2SCR half, so a fastclear draw that + // toggled BLEND re-ran planes_setup for a bit planes_setup ignores. + // Folding it out here is safe — see planes_setup: BLEND is not among the + // fields it reads — and it keeps the three keys identical, which the + // generated draw table will depend on. + let dm1_norm = crate::rex3_shape::normalize_dm1(ctx.drawmode1.0, opcode); let setup_key = ( ctx.drawmode0.0 & DRAWMODE0_INTERP_SETUP_MASK, dm1_norm & DRAWMODE1_INTERP_SETUP_MASK, cidmatch_bits, ); - if self.interp_setup_cache.get() != setup_key { - self.interp_setup_cache.set(setup_key); - - self.planes_setup(DrawMode1(dm1_norm)); - - let proc = match opcode { - DRAWMODE0_OPCODE_READ => Self::process_pixel_read, - DRAWMODE0_OPCODE_DRAW => { - let no_cid = cidmatch_bits == 0xF; - let no_host = !ctx.drawmode0.colorhost() && !ctx.drawmode0.alphahost(); - let is_src_op = ctx.drawmode1.logicop() == DRAWMODE1_LOGICOP_SRC >> 28; - let no_blend = !ctx.drawmode1.blend(); - let en_z = ctx.drawmode0.enzpattern(); - let en_ls = ctx.drawmode0.enlspattern(); - let no_zpopaque = !ctx.drawmode0.zpopaque(); - // Afunction (alpha-vs-ALPHAREF compare) applies regardless of rgbmode; - // only inhibits writes when COMPARE != 0x7 (always-pass/disabled). - let no_afunction = ctx.drawmode1.compare() == 0x7; - - if ctx.drawmode1.fastclear() && no_cid && no_host { - Self::process_pixel_fastclear - } else if no_cid && no_host && no_blend && no_afunction && en_z && !en_ls && no_zpopaque && is_src_op { - // Character/glyph: zpattern kill only, SRC logicop — no dst read needed. - Self::process_pixel_zpattern - } else if no_cid && no_host && no_blend && no_afunction { - // Common solid fills, spans, lines: no blend, no host FIFO. - Self::process_pixel_noblend - } else { - Self::process_pixel_draw - } - } - DRAWMODE0_OPCODE_SCR2SCR => Self::process_pixel_scr2scr, - _ => Self::process_pixel_noop, - }; - unsafe { *self.px_proc.get() = proc; } - - // Select shade iterate fn. - // RGB mode: always clamp (spec §3.8: "DDA values of R,G,B,A are clamped each - // iteration before sending down the pipeline"). - // CI mode: clamp only when CICLAMP is set (DRAWMODE0 bit 21 = ENCICLAMP). - let shade_fn: fn(&mut Rex3Context) = if ctx.drawmode0.shade() { - if ctx.drawmode1.rgbmode() { - Self::iterate_shade_rgb_clamp - } else if ctx.drawmode0.ciclamp() { - match ctx.drawmode1.drawdepth() { - 1 => Self::iterate_shade_ci8_clamp, - 2 => Self::iterate_shade_ci12_clamp, - _ => Self::iterate_shade_unclamped, // 4bpp / 24bpp: no CI clamp per spec - } - } else { - Self::iterate_shade_unclamped - } - } else { - Self::iterate_shade_noop - }; - unsafe { *self.px_shade.get() = shade_fn; } - - // Select pattern iterate fn. - let en_z = ctx.drawmode0.enzpattern(); - let en_ls = ctx.drawmode0.enlspattern(); - let pat_fn: fn(&mut Rex3Context) = match (en_z, en_ls) { - (false, false) => Self::iterate_pattern_noop, - (true, false) => Self::iterate_pattern_z, - (false, true) => Self::iterate_pattern_ls, - (true, true) => Self::iterate_pattern_both, - }; - unsafe { *self.px_pattern.get() = pat_fn; } - - } // interp_setup_cache miss - - if opcode != DRAWMODE0_OPCODE_NOOP { - let adrmode = ctx.drawmode0.adrmode() << 2; - if adrmode == DRAWMODE0_ADRMODE_I_LINE { - self.draw_iline(ctx); - } else if adrmode == DRAWMODE0_ADRMODE_F_LINE { - self.draw_fline(ctx); - } else if adrmode == DRAWMODE0_ADRMODE_A_LINE { - self.draw_aline(ctx); - } else if adrmode == DRAWMODE0_ADRMODE_BLOCK { - self.log_block(ctx, opcode); - self.draw_block(ctx); - } else if adrmode == DRAWMODE0_ADRMODE_SPAN { - self.log_block(ctx, opcode); - self.draw_span(ctx); - } - } + // One decode, one entry point. rex3_generic::draw fans out to the + // per-adrmode walkers; every shape-selecting field reaches it as its own + // argument, which is the list stage 5 promotes to const generics. + crate::rex3_generic::draw_primitive(ctx); + #[cfg(feature = "rexdiag")] self.interp_go_count.fetch_add(1, Ordering::Relaxed); + #[cfg(feature = "rexdiag")] self.diag.fetch_and(!Self::DIAG_LOOP_EXECUTE_GO, Ordering::Relaxed); } - fn planes_setup(&self, drawmode1: DrawMode1) { - let planes = drawmode1.planes(); - let depth = drawmode1.drawdepth(); - let dblsrc = drawmode1.dblsrc(); - - let (rd, wr, amp): (fn(&Rex3, u32) -> u32, fn(&Rex3, u32, u32), fn(u32) -> u32) = match planes { - DRAWMODE1_PLANES_RGB | DRAWMODE1_PLANES_RGBA => { - match depth { - 0 => ( // 4-bit - if dblsrc { Self::read_rgb_4_1 } else { Self::read_rgb_4_0 }, - Self::write_rgb_4, - Self::amplify_rgb_4 - ), - 1 => ( // 8-bit - if dblsrc { Self::read_rgb_8_1 } else { Self::read_rgb_8_0 }, - Self::write_rgb_8, - Self::amplify_rgb_8 - ), - 2 => ( // 12-bit - if dblsrc { Self::read_rgb_12_1 } else { Self::read_rgb_12_0 }, - Self::write_rgb_12, - Self::amplify_rgb_12 - ), - 3 => ( // 24-bit - Self::read_rgb_24, - Self::write_rgb_24, - Self::amplify_rgb_24 - ), - _ => (Self::read_zero, Self::write_nop, Self::amplify_nop) - } - }, - DRAWMODE1_PLANES_OLAY => ( - if dblsrc { Self::read_olay_1 } else { Self::read_olay_0 }, - Self::write_olay, - Self::amplify_olay - ), - DRAWMODE1_PLANES_PUP => ( - if dblsrc { Self::read_pup_1 } else { Self::read_pup_0 }, - Self::write_pup, - Self::amplify_pup - ), - DRAWMODE1_PLANES_CID => ( - if dblsrc { Self::read_cid_1 } else { Self::read_cid_0 }, - Self::write_cid, - Self::amplify_cid - ), - _ => (Self::read_zero, Self::write_nop, Self::amplify_nop) - }; - - let logic_op = drawmode1.logicop(); - let logic_fn = match logic_op { - 0 => Self::logic_op_zero, - 1 => Self::logic_op_and, - 2 => Self::logic_op_andr, - 3 => Self::logic_op_src, - 4 => Self::logic_op_andi, - 5 => Self::logic_op_dst, - 6 => Self::logic_op_xor, - 7 => Self::logic_op_or, - 8 => Self::logic_op_nor, - 9 => Self::logic_op_xnor, - 10 => Self::logic_op_ndst, - 11 => Self::logic_op_orr, - 12 => Self::logic_op_nsrc, - 13 => Self::logic_op_ori, - 14 => Self::logic_op_nand, - 15 => Self::logic_op_one, - _ => Self::logic_op_src, - }; - - let rgbmode = drawmode1.rgbmode(); - let dither = drawmode1.dither(); - // compress: 24-bit BGR → plane-depth pixel (only when rgbmode=1; CI src already plane-depth) - // Dither variants expect bayer index packed in bits 27:24 via bayer_pack(). - let compress: fn(u32) -> u32 = if rgbmode { - match depth { - 0 => if dither { Self::rgb24_to_rgb4_dither } else { Self::rgb24_to_rgb4 }, - 1 => if dither { Self::rgb24_to_rgb8_dither } else { Self::rgb24_to_rgb8 }, - 2 => if dither { Self::rgb24_to_rgb12_dither } else { Self::rgb24_to_rgb12 }, - _ => Self::identity, // 24bpp: no dithering needed - } - } else { - Self::identity - }; - // expand: plane-depth pixel → 24-bit BGR (for blend dst in RGB planes mode) - let expand: fn(u32) -> u32 = if rgbmode { - match depth { - 0 => Self::rgb4_to_rgb24, - 1 => Self::rgb8_to_rgb24, - 2 => Self::rgb12_to_rgb24, - _ => Self::identity, - } - } else { - Self::identity - }; - - let bayer_fn: fn(u32, i32, i32) -> u32 = if rgbmode { Self::bayer_pack } else { Self::bayer_nop }; - - // Afunction: "source alpha (either from DDA or host)" vs ALPHAREF — applies in - // both RGB and CI mode (spec doesn't scope it to RGB; combine_host_dda leaves - // raw_src bits 31:24 as 0 in CI/DDA mode, so afunc_eq there degenerates to - // "alpharef==0", which is the correct behavior, not a special case). - let afunc_fn: fn(u32, u32) -> bool = match drawmode1.compare() { - 0b000 => Self::afunc_never, - 0b001 => Self::afunc_lt, - 0b010 => Self::afunc_eq, - 0b011 => Self::afunc_le, - 0b100 => Self::afunc_gt, - 0b101 => Self::afunc_ne, - 0b110 => Self::afunc_ge, - _ => Self::afunc_always, // 0b111: disabled - }; - - unsafe { - *self.px_rd.get() = rd; - *self.px_wr.get() = wr; - *self.px_amp.get() = amp; - *self.px_logic.get() = logic_fn; - *self.px_afunc.get() = afunc_fn; - *self.px_bayer.get() = bayer_fn; - *self.px_compress.get() = compress; - *self.px_expand.get() = expand; - self.host_setup(drawmode1); - } - } - fn refresh_loop(&self) { let frame_duration = std::time::Duration::from_micros(16667); // ~60Hz let mut status_bar = crate::disp::StatusBar::new(); @@ -4574,10 +3380,10 @@ impl Device for Rex3 { let _ = handle.join(); } - #[cfg(feature = "rex-jit")] - if let Some(ref jit) = self.rex_jit { - jit.save_profile(); - } + // Save the corpus in every build. `seen_shapes` is device state, so this + // works with or without `rex-jit` and with IRIS_NO_JIT set — the cases + // where the old JIT-owned save wrote nothing at all. + self.save_shape_corpus(); if let Some(handle) = self.refresh_thread.lock().take() { let _ = handle.join(); @@ -4593,6 +3399,12 @@ impl Device for Rex3 { let rex3 = unsafe { std::mem::transmute::<&Rex3, &'static Rex3>(self) }; + // Wire the context's back-pointer now that `self` is at its final + // address. The draw path reaches host services (block logging, the host + // FIFO) through this, which is what lets its functions take the same + // arguments the compiled shader does instead of a `&Rex3`. + unsafe { (*self.context.get()).host = rex3 as *const Rex3; } + *self.processor_thread.lock() = Some(thread::Builder::new().name("REX3-Processor".to_string()).spawn(move || { crate::thread_affinity::pin_current(crate::thread_affinity::PerfRole::Rex3Processor); rex3.register_processor() @@ -4844,6 +3656,31 @@ impl Device for Rex3 { return Err("rex buslog is only available in developer builds".to_string()); } + // Shader reporting works in every build: the precompiled table serves + // draws with no Cranelift present, so `rex jit status` being gated on + // rex-jit hid exactly the case worth inspecting. + if cmd == "rex" && (args[0] == "shaders" || args[0] == "shader") { + match args.get(1).copied() { + Some("list") => { + self.write_shader_summary(&mut writer); + let rows = self.shader_report(); + if rows.is_empty() { + writeln!(writer, "No draw shapes seen yet.").unwrap(); + } else { + writeln!(writer, "{:>11} {:>10} {:>10} {:>10} {:>6} {}", + "origin", "dm0", "dm1", "cm", "bytes", "description").unwrap(); + for r in &rows { + writeln!(writer, "{:>11} {:#010x} {:#010x} {:#010x} {:>6} {} | {}", + r.origin, r.dm0, r.dm1, r.cm, r.bytes, + decode_dm0(r.dm0), decode_dm1(r.dm1)).unwrap(); + } + } + } + _ => self.write_shader_summary(&mut writer), + } + return Ok(()); + } + #[cfg(feature = "rex-jit")] if cmd == "rex" && args[0] == "jit" { match args.get(1).copied() { @@ -4854,52 +3691,20 @@ impl Device for Rex3 { writeln!(writer, "REX JIT dispatch: {}", if val { "enabled" } else { "disabled" }).unwrap(); } Some("status") => { - if let Some(ref jit) = self.rex_jit { - let enabled = self.jit_enabled.load(Ordering::Relaxed); - let shaders = jit.shader_list(); - let compiled: Vec<_> = shaders.iter().filter(|s| s.status == "compiled" || s.status == "disabled").collect(); - let total_bytes: u32 = compiled.iter().map(|s| s.code_bytes).sum(); - writeln!(writer, "REX3 JIT: {} compiled={} queued={} failed={} code={} bytes", - if enabled { "enabled" } else { "DISABLED" }, - compiled.len(), jit.queued_count(), - shaders.iter().filter(|s| s.status == "failed").count(), - total_bytes).unwrap(); - if !compiled.is_empty() { - #[cfg(feature = "developer")] - writeln!(writer, "{:>8} {:>10} {:>10} {:>10} {:>6} {:>8} {}", - "status", "dm0", "dm1", "cm", "bytes", "hits", "description").unwrap(); - #[cfg(not(feature = "developer"))] - writeln!(writer, "{:>8} {:>10} {:>10} {:>10} {:>6} {}", - "status", "dm0", "dm1", "cm", "bytes", "description").unwrap(); - for s in &shaders { - if s.status == "compiled" || s.status == "disabled" { - #[cfg(feature = "developer")] - writeln!(writer, "{:>8} {:#010x} {:#010x} {:#010x} {:>6} {:>8} {} | {}", - s.status, s.dm0, s.dm1, s.cm, s.code_bytes, s.hit_count, - decode_dm0(s.dm0), decode_dm1(s.dm1)).unwrap(); - #[cfg(not(feature = "developer"))] - writeln!(writer, "{:>8} {:#010x} {:#010x} {:#010x} {:>6} {} | {}", - s.status, s.dm0, s.dm1, s.cm, s.code_bytes, - decode_dm0(s.dm0), decode_dm1(s.dm1)).unwrap(); - } - } - } - } else { - writeln!(writer, "REX JIT: not initialised").unwrap(); - } + self.write_shader_summary(&mut writer); } Some("list") => { - if let Some(ref jit) = self.rex_jit { - let shaders = jit.shader_list(); - if shaders.is_empty() { - writeln!(writer, "No shaders compiled yet.").unwrap(); - } else { - writeln!(writer, "{:>8} {:>10} {:>10} {:>10} {:>6} {}", "status", "dm0", "dm1", "cm", "bytes", "description").unwrap(); - for s in &shaders { - writeln!(writer, "{:>8} {:#010x} {:#010x} {:#010x} {:>6} {} | {}", - s.status, s.dm0, s.dm1, s.cm, s.code_bytes, - decode_dm0(s.dm0), decode_dm1(s.dm1)).unwrap(); - } + self.write_shader_summary(&mut writer); + let rows = self.shader_report(); + if rows.is_empty() { + writeln!(writer, "No draw shapes seen yet.").unwrap(); + } else { + writeln!(writer, "{:>11} {:>10} {:>10} {:>10} {:>6} {}", + "origin", "dm0", "dm1", "cm", "bytes", "description").unwrap(); + for r in &rows { + writeln!(writer, "{:>11} {:#010x} {:#010x} {:#010x} {:>6} {} | {}", + r.origin, r.dm0, r.dm1, r.cm, r.bytes, + decode_dm0(r.dm0), decode_dm1(r.dm1)).unwrap(); } } } @@ -5058,6 +3863,14 @@ impl BusDevice for Rex3 { // Used for registers that require the GFIFO to be drained before reading. macro_rules! busy_or_val { ($val:expr) => {{ + // Publish any producer-side pending entries before testing + // emptiness: a read must see the queue as it really is, or it + // skips the retry it owed and returns pre-write register state. + // Contention here means a producer is mid-push, which is itself + // "not empty" — report busy and let the CPU retry. + if !self.gfifo.publish_tail() { + return BusRead32::busy(); + } if self.gfxbusy.load(Ordering::Acquire) || !self.gfifo.is_empty() { return BusRead32::busy(); } @@ -5069,6 +3882,11 @@ impl BusDevice for Rex3 { REX3_CONFIG => BusRead32::ok(self.config.config.load(Ordering::Relaxed) & 0x1FFFFF), REX3_STATUS | REX3_USER_STATUS => { + // STATUS is the guest's flow control — it reports queue depth and + // GFXBUSY, and the driver throttles on it. An under-reported depth + // is worse than a stale register read: the guest concludes the + // engine is idle and keeps writing. Publish before sampling. + self.gfifo.publish_tail(); let mut val = self.config.status.load(Ordering::Relaxed) & 0xFFFFF; val |= 3 << STATUS_VERSION_SHIFT; let pending = self.gfifo.len(); @@ -5366,6 +4184,10 @@ impl BusDevice for Rex3 { let is_go64r = (offset & 0x0800) != 0; let reg_offset64r = offset & !0x0800; if reg_offset64r == REX3_HOSTRW0 { + // Same rule as busy_or_val! on the 32-bit path: publish, then test. + if !self.gfifo.publish_tail() { + return BusRead64::busy(); + } if self.gfxbusy.load(Ordering::Acquire) || !self.gfifo.is_empty() { return BusRead64::busy(); } @@ -5440,14 +4262,36 @@ impl BusDevice for Rex3 { return BUS_OK; } - // Two-register 64-bit write: write high word first WITHOUT go, then low word with go. + // Two-register 64-bit write: high word first WITHOUT go, then low word + // with go. Pushed as one atomic pair. + // + // This used to be two `write32` calls returning the second's status, + // which was wrong twice over: six atomics where three suffice, and a + // queue that filled between the two left the high word pushed while + // still reporting BUS_BUSY — so the CPU's retry re-pushed it. See + // `GFifo::try_push2`. let high = (val >> 32) as u32; let low = val as u32; - match self.write32(addr & !0x0800, high) { - BUS_OK => self.write32(addr + 4, low), - status => status, + let off_hi = offset & !0x0800; + let off_lo = off_hi + 4; + + // Registers with CPU-thread side effects cannot take the queue path; + // they are rare (CONFIG, DCB*) and never part of a hot pair. + if Self::reg_needs_cpu_side_effect(off_hi) || Self::reg_needs_cpu_side_effect(off_lo) { + return match self.write32(addr & !0x0800, high) { + BUS_OK => self.write32(addr + 4, low), + status => status, + }; } + + // `is_go` puts the GO bit on the low word, matching the two-write order. + let go_lo = if is_go { off_lo | 0x0800 } else { off_lo }; + if !self.gfifo_try_push2(off_hi, high as u64, go_lo, low as u64) { + return BUS_BUSY; + } + BUS_OK } + } // ============================================================================ diff --git a/src/rex3_generic.rs b/src/rex3_generic.rs new file mode 100644 index 00000000..d87dddd2 --- /dev/null +++ b/src/rex3_generic.rs @@ -0,0 +1,1809 @@ +//! Generic REX3 draw path. +//! +//! **One expression of the draw logic, usable two ways.** The pipeline is +//! written once against the [`Mode`] trait; a [`ConstMode`] implementor carries +//! the draw-mode fields as const generics (so every `if m.blend() != 0` folds at +//! monomorphisation and LLVM deletes the dead arms — the same specialisation +//! Cranelift gets), while [`DynMode`] holds them as plain fields read from the +//! registers. +//! +//! That is what makes a generated table possible without a second +//! implementation: a table entry instantiates the pipeline with `ConstMode`, and +//! anything not in the table runs the *same source* with `DynMode`. Const +//! generic arguments must be compile-time literals, so the table is the bridge +//! from runtime register values to constants — but the logic it dispatches into +//! is shared, not duplicated. + +use crate::rex3::{ + Rex3, Rex3Context, OCTANT_XDEC, OCTANT_YDEC, REX3_BRES_OCTANTS, CLIPMODE_CIDMATCH_SHIFT, CLIPMODE_ENSMASK_MASK, + CLIPMODE_ENSMASK_SMASK0, CLIPMODE_ENSMASK_SMASK1_4, + DRAWMODE0_ADRMODE_A_LINE, DRAWMODE0_ADRMODE_BLOCK, DRAWMODE0_ADRMODE_F_LINE, + DRAWMODE0_ADRMODE_I_LINE, DRAWMODE0_ADRMODE_SPAN, DRAWMODE0_OPCODE_DRAW, + DRAWMODE0_OPCODE_NOOP, DRAWMODE0_OPCODE_READ, DRAWMODE0_OPCODE_SCR2SCR, + DRAWMODE1_PLANES_CID, DRAWMODE1_PLANES_OLAY, DRAWMODE1_PLANES_PUP, + DRAWMODE1_PLANES_RGB, DRAWMODE1_PLANES_RGBA, + REX3_COORD_BIAS, REX3_SCREEN_HEIGHT, REX3_SCREEN_WIDTH, + DRAWMODE1_BF_MOC, DRAWMODE1_BF_MSA, DRAWMODE1_BF_OC, DRAWMODE1_BF_ONE, + DRAWMODE1_BF_SA, DRAWMODE1_BF_ZERO, + DRAWMODE1_COMPARE_EQ, DRAWMODE1_COMPARE_GE, DRAWMODE1_COMPARE_GT, + DRAWMODE1_COMPARE_LE, DRAWMODE1_COMPARE_LT, DRAWMODE1_COMPARE_NE, + DRAWMODE1_COMPARE_NEVER, + DRAWMODE1_DRAWDEPTH_12, DRAWMODE1_DRAWDEPTH_24, DRAWMODE1_DRAWDEPTH_4, + DRAWMODE1_DRAWDEPTH_8, DRAWMODE1_HOSTDEPTH_12, DRAWMODE1_HOSTDEPTH_8, + DRAWMODE1_HOSTDEPTH_4, + DRAWMODE1_LOGICOP_ZERO, + DRAWMODE1_LOGICOP_AND, + DRAWMODE1_LOGICOP_ANDR, + DRAWMODE1_LOGICOP_SRC, + DRAWMODE1_LOGICOP_ANDI, + DRAWMODE1_LOGICOP_DST, + DRAWMODE1_LOGICOP_XOR, + DRAWMODE1_LOGICOP_OR, + DRAWMODE1_LOGICOP_NOR, + DRAWMODE1_LOGICOP_XNOR, + DRAWMODE1_LOGICOP_NDST, + DRAWMODE1_LOGICOP_ORR, + DRAWMODE1_LOGICOP_NSRC, + DRAWMODE1_LOGICOP_ORI, + DRAWMODE1_LOGICOP_NAND, +}; +use crate::rex3_shape as sh; + +/// The two framebuffer planes, as the JIT shader receives them. +/// +/// Matching the compiled shader's `(ctx, fb_rgb, fb_aux)` ABI means the pixel +/// path needs no `&Rex3` at all: everything it touches is the context plus these +/// two pointers. +#[derive(Clone, Copy)] +pub struct Framebuffers { + pub rgb: *mut u32, + pub aux: *mut u32, +} + +// ── Mode ───────────────────────────────────────────────────────────────────── + +/// The draw-mode fields the pipeline branches on. +/// +/// Implemented twice: once with const generics, once with runtime fields. Every +/// accessor is `#[inline(always)]`, so under [`ConstMode`] each call becomes a +/// literal and the surrounding branch disappears; under [`DynMode`] it is a +/// field read. +pub trait Mode: Copy { + fn opcode(&self) -> u32; + fn planes(&self) -> u32; + fn drawdepth(&self) -> u32; + fn dblsrc(&self) -> u32; + fn rgbmode(&self) -> u32; + fn dither(&self) -> u32; + fn logicop(&self) -> u32; + fn compare(&self) -> u32; + fn blend(&self) -> u32; + fn backblend(&self) -> u32; + fn blendalpha(&self) -> u32; + fn fastclear(&self) -> u32; + fn colorhost(&self) -> u32; + fn alphahost(&self) -> u32; + fn enzpattern(&self) -> u32; + fn enlspattern(&self) -> u32; + fn zpopaque(&self) -> u32; + fn lsopaque(&self) -> u32; + fn cidtest(&self) -> u32; + fn shade(&self) -> u32; + fn ciclamp(&self) -> u32; + fn stoponx(&self) -> u32; + fn stopony(&self) -> u32; + fn skipfirst(&self) -> u32; + fn skiplast(&self) -> u32; + fn lsadvlast(&self) -> u32; + fn length32(&self) -> u32; + fn lronly(&self) -> u32; + fn ystride(&self) -> u32; + fn endptfilter(&self) -> u32; + fn adrmode(&self) -> u32; + fn xyoffset(&self) -> u32; + fn yflip(&self) -> u32; + fn ensmask(&self) -> u32; + /// CIDMATCH nibble. Data rather than a code selector — `cidtest` decides + /// whether the test is emitted — but it lives here so there is one mode + /// object rather than two. + fn cid_mask(&self) -> u32; + fn sfactor(&self) -> u32; + fn dfactor(&self) -> u32; + fn rwpacked(&self) -> u32; + fn hostdepth(&self) -> u32; + fn rwdouble(&self) -> u32; + fn swapendian(&self) -> u32; +} + +/// Compile-time mode: every field a const generic, so the pipeline specialises. +#[derive(Clone, Copy)] +pub struct ConstMode< + const OPCODE: u32, + const PLANES: u32, + const DRAWDEPTH: u32, + const DBLSRC: u32, + const RGBMODE: u32, + const DITHER: u32, + const LOGICOP: u32, + const COMPARE: u32, + const BLEND: u32, + const BACKBLEND: u32, + const BLENDALPHA: u32, + const FASTCLEAR: u32, + const COLORHOST: u32, + const ALPHAHOST: u32, + const ENZPATTERN: u32, + const ENLSPATTERN: u32, + const ZPOPAQUE: u32, + const LSOPAQUE: u32, + const CIDTEST: u32, + const SHADE: u32, + const CICLAMP: u32, + const STOPONX: u32, + const STOPONY: u32, + const SKIPFIRST: u32, + const SKIPLAST: u32, + const LSADVLAST: u32, + const LENGTH32: u32, + const LRONLY: u32, + const YSTRIDE: u32, + const ENDPTFILTER: u32, + const ADRMODE: u32, + const XYOFFSET: u32, + const YFLIP: u32, + const ENSMASK: u32, + const CID_MASK: u32, + const SFACTOR: u32, + const DFACTOR: u32, + const RWPACKED: u32, + const HOSTDEPTH: u32, + const RWDOUBLE: u32, + const SWAPENDIAN: u32, +>; + +#[rustfmt::skip] +impl< + const OPCODE: u32, const PLANES: u32, const DRAWDEPTH: u32, const DBLSRC: u32, + const RGBMODE: u32, const DITHER: u32, const LOGICOP: u32, const COMPARE: u32, + const BLEND: u32, const BACKBLEND: u32, const BLENDALPHA: u32, const FASTCLEAR: u32, + const COLORHOST: u32, const ALPHAHOST: u32, const ENZPATTERN: u32, + const ENLSPATTERN: u32, const ZPOPAQUE: u32, const LSOPAQUE: u32, const CIDTEST: u32, + const SHADE: u32, const CICLAMP: u32, const STOPONX: u32, const STOPONY: u32, + const SKIPFIRST: u32, const SKIPLAST: u32, const LSADVLAST: u32, const LENGTH32: u32, + const LRONLY: u32, const YSTRIDE: u32, const ENDPTFILTER: u32, const ADRMODE: u32, + const XYOFFSET: u32, const YFLIP: u32, const ENSMASK: u32, const CID_MASK: u32, + const SFACTOR: u32, const DFACTOR: u32, const RWPACKED: u32, const HOSTDEPTH: u32, + const RWDOUBLE: u32, const SWAPENDIAN: u32, +> Mode for ConstMode< + OPCODE, PLANES, DRAWDEPTH, DBLSRC, RGBMODE, DITHER, LOGICOP, COMPARE, BLEND, + BACKBLEND, BLENDALPHA, FASTCLEAR, COLORHOST, ALPHAHOST, ENZPATTERN, ENLSPATTERN, + ZPOPAQUE, LSOPAQUE, CIDTEST, SHADE, CICLAMP, STOPONX, STOPONY, SKIPFIRST, SKIPLAST, + LSADVLAST, LENGTH32, LRONLY, YSTRIDE, ENDPTFILTER, ADRMODE, XYOFFSET, YFLIP, + ENSMASK, CID_MASK, SFACTOR, DFACTOR, RWPACKED, HOSTDEPTH, RWDOUBLE, SWAPENDIAN, +> { + #[inline(always)] fn opcode(&self) -> u32 { OPCODE } + #[inline(always)] fn planes(&self) -> u32 { PLANES } + #[inline(always)] fn drawdepth(&self) -> u32 { DRAWDEPTH } + #[inline(always)] fn dblsrc(&self) -> u32 { DBLSRC } + #[inline(always)] fn rgbmode(&self) -> u32 { RGBMODE } + #[inline(always)] fn dither(&self) -> u32 { DITHER } + #[inline(always)] fn logicop(&self) -> u32 { LOGICOP } + #[inline(always)] fn compare(&self) -> u32 { COMPARE } + #[inline(always)] fn blend(&self) -> u32 { BLEND } + #[inline(always)] fn backblend(&self) -> u32 { BACKBLEND } + #[inline(always)] fn blendalpha(&self) -> u32 { BLENDALPHA } + #[inline(always)] fn fastclear(&self) -> u32 { FASTCLEAR } + #[inline(always)] fn colorhost(&self) -> u32 { COLORHOST } + #[inline(always)] fn alphahost(&self) -> u32 { ALPHAHOST } + #[inline(always)] fn enzpattern(&self) -> u32 { ENZPATTERN } + #[inline(always)] fn enlspattern(&self) -> u32 { ENLSPATTERN } + #[inline(always)] fn zpopaque(&self) -> u32 { ZPOPAQUE } + #[inline(always)] fn lsopaque(&self) -> u32 { LSOPAQUE } + #[inline(always)] fn cidtest(&self) -> u32 { CIDTEST } + #[inline(always)] fn shade(&self) -> u32 { SHADE } + #[inline(always)] fn ciclamp(&self) -> u32 { CICLAMP } + #[inline(always)] fn stoponx(&self) -> u32 { STOPONX } + #[inline(always)] fn stopony(&self) -> u32 { STOPONY } + #[inline(always)] fn skipfirst(&self) -> u32 { SKIPFIRST } + #[inline(always)] fn skiplast(&self) -> u32 { SKIPLAST } + #[inline(always)] fn lsadvlast(&self) -> u32 { LSADVLAST } + #[inline(always)] fn length32(&self) -> u32 { LENGTH32 } + #[inline(always)] fn lronly(&self) -> u32 { LRONLY } + #[inline(always)] fn ystride(&self) -> u32 { YSTRIDE } + #[inline(always)] fn endptfilter(&self) -> u32 { ENDPTFILTER } + #[inline(always)] fn adrmode(&self) -> u32 { ADRMODE } + #[inline(always)] fn xyoffset(&self) -> u32 { XYOFFSET } + #[inline(always)] fn yflip(&self) -> u32 { YFLIP } + #[inline(always)] fn ensmask(&self) -> u32 { ENSMASK } + #[inline(always)] fn cid_mask(&self) -> u32 { CID_MASK } + #[inline(always)] fn sfactor(&self) -> u32 { SFACTOR } + #[inline(always)] fn dfactor(&self) -> u32 { DFACTOR } + #[inline(always)] fn rwpacked(&self) -> u32 { RWPACKED } + #[inline(always)] fn hostdepth(&self) -> u32 { HOSTDEPTH } + #[inline(always)] fn rwdouble(&self) -> u32 { RWDOUBLE } + #[inline(always)] fn swapendian(&self) -> u32 { SWAPENDIAN } +} + +/// Runtime mode: the same fields, read from the registers. +/// +/// Instantiating the pipeline with this gives a single correct-for-everything +/// instance — the permanent fallback for shapes no table entry covers. +#[derive(Clone, Copy, Default, PartialEq, Eq, Hash, Debug)] +#[rustfmt::skip] +pub struct DynMode { + pub opcode: u32, pub planes: u32, pub drawdepth: u32, pub dblsrc: u32, + pub rgbmode: u32, pub dither: u32, pub logicop: u32, pub compare: u32, + pub blend: u32, pub backblend: u32, pub blendalpha: u32, pub fastclear: u32, + pub colorhost: u32, pub alphahost: u32, pub enzpattern: u32, pub enlspattern: u32, + pub zpopaque: u32, pub lsopaque: u32, pub cidtest: u32, pub shade: u32, + pub ciclamp: u32, pub stoponx: u32, pub stopony: u32, pub skipfirst: u32, + pub skiplast: u32, pub lsadvlast: u32, pub length32: u32, pub lronly: u32, + pub ystride: u32, pub endptfilter: u32, pub adrmode: u32, pub xyoffset: u32, + pub yflip: u32, pub ensmask: u32, pub cid_mask: u32, + // Blend inputs and host-transfer shape. Not read by the pixel path directly + // (blend goes through Rex3::blend, host setup through host_setup), but they + // are part of the canonical mode: unpack folds them to 0 when dead, which is + // what keeps two equivalent draws producing one identical mode. + pub sfactor: u32, pub dfactor: u32, + pub rwpacked: u32, pub hostdepth: u32, pub rwdouble: u32, pub swapendian: u32, +} + +#[rustfmt::skip] +impl Mode for DynMode { + #[inline(always)] fn opcode(&self) -> u32 { self.opcode } + #[inline(always)] fn planes(&self) -> u32 { self.planes } + #[inline(always)] fn drawdepth(&self) -> u32 { self.drawdepth } + #[inline(always)] fn dblsrc(&self) -> u32 { self.dblsrc } + #[inline(always)] fn rgbmode(&self) -> u32 { self.rgbmode } + #[inline(always)] fn dither(&self) -> u32 { self.dither } + #[inline(always)] fn logicop(&self) -> u32 { self.logicop } + #[inline(always)] fn compare(&self) -> u32 { self.compare } + #[inline(always)] fn blend(&self) -> u32 { self.blend } + #[inline(always)] fn backblend(&self) -> u32 { self.backblend } + #[inline(always)] fn blendalpha(&self) -> u32 { self.blendalpha } + #[inline(always)] fn fastclear(&self) -> u32 { self.fastclear } + #[inline(always)] fn colorhost(&self) -> u32 { self.colorhost } + #[inline(always)] fn alphahost(&self) -> u32 { self.alphahost } + #[inline(always)] fn enzpattern(&self) -> u32 { self.enzpattern } + #[inline(always)] fn enlspattern(&self) -> u32 { self.enlspattern } + #[inline(always)] fn zpopaque(&self) -> u32 { self.zpopaque } + #[inline(always)] fn lsopaque(&self) -> u32 { self.lsopaque } + #[inline(always)] fn cidtest(&self) -> u32 { self.cidtest } + #[inline(always)] fn shade(&self) -> u32 { self.shade } + #[inline(always)] fn ciclamp(&self) -> u32 { self.ciclamp } + #[inline(always)] fn stoponx(&self) -> u32 { self.stoponx } + #[inline(always)] fn stopony(&self) -> u32 { self.stopony } + #[inline(always)] fn skipfirst(&self) -> u32 { self.skipfirst } + #[inline(always)] fn skiplast(&self) -> u32 { self.skiplast } + #[inline(always)] fn lsadvlast(&self) -> u32 { self.lsadvlast } + #[inline(always)] fn length32(&self) -> u32 { self.length32 } + #[inline(always)] fn lronly(&self) -> u32 { self.lronly } + #[inline(always)] fn ystride(&self) -> u32 { self.ystride } + #[inline(always)] fn endptfilter(&self) -> u32 { self.endptfilter } + #[inline(always)] fn adrmode(&self) -> u32 { self.adrmode } + #[inline(always)] fn xyoffset(&self) -> u32 { self.xyoffset } + #[inline(always)] fn yflip(&self) -> u32 { self.yflip } + #[inline(always)] fn ensmask(&self) -> u32 { self.ensmask } + #[inline(always)] fn cid_mask(&self) -> u32 { self.cid_mask } + #[inline(always)] fn sfactor(&self) -> u32 { self.sfactor } + #[inline(always)] fn dfactor(&self) -> u32 { self.dfactor } + #[inline(always)] fn rwpacked(&self) -> u32 { self.rwpacked } + #[inline(always)] fn hostdepth(&self) -> u32 { self.hostdepth } + #[inline(always)] fn rwdouble(&self) -> u32 { self.rwdouble } + #[inline(always)] fn swapendian(&self) -> u32 { self.swapendian } +} + +// ── Colour conversion and DDA primitives ───────────────────────────────────── +// Moved here from `impl Rex3`: none of these ever touched `self`. They were +// associated functions only because the function-pointer draw path selected +// among them by pointer, and reaching them from here then needed a `_pub` +// forwarding shim per function. Both layers are gone. + +// ── Shade iterate functions ──────────────────────────────────────────────── +// Called once per pixel after drawing. Advance color DDAs and, when +// CICLAMP is set, clamp the result to legal range. +// +// The spec (§3.8 / DRAWMODE0 bit CICLAMP) says: +// • RGB mode: each component is in o12.11 format (integer part bits[22:11]). +// Clamp: if negative (bit 31 set) or integer >= 0x180 → 0; if > 0xFF → 0x7FFFF. +// • CI mode: only colorred clamped; depth-specific overflow bit check. +// 8bpp: clamp if bit 19 set. 12bpp: clamp if bit 21 set. +// (4bpp: bit 15; 24bpp: no clamp per spec.) + +#[inline(always)] +pub(crate) fn shade_add(ctx: &mut Rex3Context) { + ctx.colorred = ctx.colorred.wrapping_add(ctx.slopered as u32); + ctx.colorgrn = ctx.colorgrn.wrapping_add(ctx.slopegrn as u32); + ctx.colorblue = ctx.colorblue.wrapping_add(ctx.slopeblue as u32); + ctx.coloralpha = ctx.coloralpha.wrapping_add(ctx.slopealpha as u32); +} + +// ── Pattern iterate functions ────────────────────────────────────────────── +// Called once per pixel after drawing. Advance lspattern and/or zpattern +// bit counters. +// +// ZPATTERN: always 32-bit, simple rotate — zpat_bit = (zpat_bit - 1) & 31. +// +// LSPATTERN (via lsmode): +// LSRCOUNT (down counter, 0..LSREPEAT-1): decremented each pixel. +// When LSRCOUNT == 0 after decrement → advance pat_bit, reload LSRCOUNT = LSREPEAT-1. +// LSLENGTH (4 bits): pattern length = lslength + 17 (range 17..32). +// pat_bit wraps: when it would go below (32 - length), reset to 31. +// LSREPEAT==0 is treated as 1 (no-repeat is the degenerate case). +// +// Cursors start at 31 (MSB) on DOSETUP/row start (see execute_go) and walk +// DOWN toward the wrap point — a contiguous MSB-to-LSB sweep. f2d0bff +// briefly flipped this to increment-from-31 (+ an lspattern rotate-on-wrap +// in place of the reset), but incrementing from 31 immediately wraps to 0 +// after a single step (`(31+1)&31 == 0`), producing a discontinuous, +// backwards bit walk — confirmed as the cause of garbled/mirrored PROM +// text. Reverted back to decrement/reset-to-31. + +#[inline(always)] +pub(crate) fn advance_zpat(ctx: &mut Rex3Context) { + ctx.zpat_bit = ctx.zpat_bit.wrapping_sub(1) & 31; +} + +#[inline(always)] +pub(crate) fn advance_lspat(ctx: &mut Rex3Context) { + let lsrepeat = ctx.lsmode.lsrepeat() as u8; + let repeat = if lsrepeat == 0 { 1 } else { lsrepeat }; + if ctx.lsmode.lsrcount() == 0 { + // Reload counter, advance bit + ctx.lsmode.set_lsrcount((repeat - 1) as u32); + let length = ctx.lsmode.lslength() as u8 + 17; // 17..=32 + let wrap_point = 32u8.saturating_sub(length); // bit index of pattern end + if ctx.pat_bit == wrap_point { + ctx.pat_bit = 31; // recirculate + } else { + ctx.pat_bit = ctx.pat_bit.wrapping_sub(1) & 31; + } + } else { + ctx.lsmode.set_lsrcount(ctx.lsmode.lsrcount() - 1); + } +} + +pub(crate) fn rgb4_to_rgb24(val: u32) -> u32 { + let r = if (val & 1) != 0 { 0xFF } else { 0 }; + let g_raw = (val >> 1) & 3; + let g = (g_raw << 6) | (g_raw << 4) | (g_raw << 2) | g_raw; + let b = if (val & 8) != 0 { 0xFF } else { 0 }; + (b << 16) | (g << 8) | r +} + +pub(crate) fn rgb24_to_rgb4(val: u32) -> u32 { + let r = (val >> 7) & 1; + let g = (val >> 14) & 3; + let b = (val >> 23) & 1; + (b << 3) | (g << 1) | r +} + +pub(crate) fn rgb8_to_rgb24(val: u32) -> u32 { + let r_raw = val & 7; + let r = (r_raw << 5) | (r_raw << 2) | (r_raw >> 1); + let g_raw = (val >> 3) & 7; + let g = (g_raw << 5) | (g_raw << 2) | (g_raw >> 1); + let b_raw = (val >> 6) & 3; + let b = (b_raw << 6) | (b_raw << 4) | (b_raw << 2) | b_raw; + (b << 16) | (g << 8) | r +} + +pub(crate) fn rgb24_to_rgb8(val: u32) -> u32 { + let r = (val >> 5) & 7; + let g = (val >> 13) & 7; + let b = (val >> 22) & 3; + (b << 6) | (g << 3) | r +} + +pub(crate) fn rgb12_to_rgb24(val: u32) -> u32 { + let r_raw = val & 0xF; + let r = (r_raw << 4) | r_raw; + let g_raw = (val >> 4) & 0xF; + let g = (g_raw << 4) | g_raw; + let b_raw = (val >> 8) & 0xF; + let b = (b_raw << 4) | b_raw; + (b << 16) | (g << 8) | r +} + +pub(crate) fn rgb24_to_rgb12(val: u32) -> u32 { + let r = (val >> 4) & 0xF; + let g = (val >> 12) & 0xF; + let b = (val >> 20) & 0xF; + (b << 8) | (g << 4) | r +} + +// Bayer 4x4 dither matrix packed as 16 nibbles in a u64. +// Indexed by (y&3)<<2|(x&3): threshold = (BAYER_PACKED >> (idx*4)) & 0xF. +// Table: [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5] +const BAYER_PACKED: u64 = 0x5D7F91B36E4CA280; + +/// Pack bayer index into bits 27:24 of color value (top byte unused by 24-bit BGR). +/// Encoding: bits[3:2] = y&3, bits[1:0] = x&3 → index = (y&3)<<2|(x&3). +/// Non-dither compress variants ignore these bits. +#[inline(always)] +pub(crate) fn bayer_pack(color: u32, x: i32, y: i32) -> u32 { + (color & 0x00FFFFFF) | (((y as u32 & 3) << 2 | (x as u32 & 3)) << 24) +} + +#[inline(always)] +pub(crate) fn bayer_threshold(idx: u32) -> u32 { + ((BAYER_PACKED >> (idx * 4)) & 0xF) as u32 +} + +pub(crate) fn rgb24_to_rgb4_dither(val: u32) -> u32 { + let bayer = bayer_threshold(val >> 24); + let r = (val & 0xFF) as u8; + let g = ((val >> 8) & 0xFF) as u8; + let b = ((val >> 16) & 0xFF) as u8; + // 4bpp: 1-2-1 BGR. Each channel dithered down from 8-bit. + let sr = (r >> 3).wrapping_sub(r >> 4); + let sg = (g >> 2).wrapping_sub(g >> 4); + let sb = (b >> 3).wrapping_sub(b >> 4); + let mut dr = (sr >> 4) & 1; + let mut dg = (sg >> 4) & 3; + let mut db = (sb >> 4) & 1; + if (sr & 0xf) as u32 > bayer { dr = (dr + 1).min(1); } + if (sg & 0xf) as u32 > bayer { dg = (dg + 1).min(3); } + if (sb & 0xf) as u32 > bayer { db = (db + 1).min(1); } + ((db << 3) | (dg << 1) | dr) as u32 +} + +pub(crate) fn rgb24_to_rgb8_dither(val: u32) -> u32 { + let bayer = bayer_threshold(val >> 24); + let r = (val & 0xFF) as u8; + let g = ((val >> 8) & 0xFF) as u8; + let b = ((val >> 16) & 0xFF) as u8; + // 8bpp: 3-3-2 BGR. + let sr = (r >> 1).wrapping_sub(r >> 4); + let sg = (g >> 1).wrapping_sub(g >> 4); + let sb = (b >> 2).wrapping_sub(b >> 4); + let mut dr = (sr >> 4) & 7; + let mut dg = (sg >> 4) & 7; + let mut db = (sb >> 4) & 3; + if (sr & 0xf) as u32 > bayer { dr = (dr + 1).min(7); } + if (sg & 0xf) as u32 > bayer { dg = (dg + 1).min(7); } + if (sb & 0xf) as u32 > bayer { db = (db + 1).min(3); } + ((db << 6) | (dg << 3) | dr) as u32 +} + +pub(crate) fn rgb24_to_rgb12_dither(val: u32) -> u32 { + let bayer = bayer_threshold(val >> 24); + let r = (val & 0xFF) as u32; + let g = ((val >> 8) & 0xFF) as u32; + let b = ((val >> 16) & 0xFF) as u32; + // 12bpp: 4-4-4 BGR. + let sr = r - (r >> 4); + let sg = g - (g >> 4); + let sb = b - (b >> 4); + let mut dr = (sr >> 4) & 15; + let mut dg = (sg >> 4) & 15; + let mut db = (sb >> 4) & 15; + if (sr & 0xf) > bayer { dr = (dr + 1).min(15); } + if (sg & 0xf) > bayer { dg = (dg + 1).min(15); } + if (sb & 0xf) > bayer { db = (db + 1).min(15); } + (db << 8) | (dg << 4) | dr +} + + +// ── Colour helpers ─────────────────────────────────────────────────────────── + +/// Compress 24-bit BGR to plane depth, optionally dithering. +/// +/// Delegates to the existing `rgb24_to_rgb{4,8,12}[_dither]` bodies rather than +/// restating them: the packings are irregular (1-2-1 at 4bpp, 3-3-2 at 8bpp, +/// 4-4-4 at 12bpp) and the dither variants carry a specific error-diffusion +/// form. In CI mode the source is already plane-depth, so this is the identity. +#[inline(always)] +fn compress(m: &M, val: u32, x: i32, y: i32) -> u32 { + if m.rgbmode() == 0 { + return val; + } + if m.dither() != 0 { + // The `_dither` bodies expect the bayer cell index in bits 27:24. + let packed = bayer_pack(val, x, y); + match m.drawdepth() { + DRAWMODE1_DRAWDEPTH_4 => rgb24_to_rgb4_dither(packed), + DRAWMODE1_DRAWDEPTH_8 => rgb24_to_rgb8_dither(packed), + DRAWMODE1_DRAWDEPTH_12 => rgb24_to_rgb12_dither(packed), + // 24bpp: nothing to quantise, so nothing to dither. + _ => val, + } + } else { + match m.drawdepth() { + DRAWMODE1_DRAWDEPTH_4 => rgb24_to_rgb4(val), + DRAWMODE1_DRAWDEPTH_8 => rgb24_to_rgb8(val), + DRAWMODE1_DRAWDEPTH_12 => rgb24_to_rgb12(val), + _ => val, + } + } +} + +/// Expand a plane-depth pixel to 24-bit BGR (blend destination, scr2scr source). +#[inline(always)] +fn expand(m: &M, val: u32) -> u32 { + if m.rgbmode() == 0 { + return val; + } + match m.drawdepth() { + DRAWMODE1_DRAWDEPTH_4 => rgb4_to_rgb24(val), + DRAWMODE1_DRAWDEPTH_8 => rgb8_to_rgb24(val), + DRAWMODE1_DRAWDEPTH_12 => rgb12_to_rgb24(val), + _ => val, + } +} + +/// Replicate a plane-depth value into the slots WRMASK may select (dblsrc +/// packing). +#[inline(always)] +fn amplify(m: &M, val: u32) -> u32 { + match m.planes() { + DRAWMODE1_PLANES_RGB | DRAWMODE1_PLANES_RGBA => match m.drawdepth() { + DRAWMODE1_DRAWDEPTH_4 => val | (val << 4), + DRAWMODE1_DRAWDEPTH_8 => val | (val << 8), + DRAWMODE1_DRAWDEPTH_12 => val | (val << 12), + // 24bpp fills the word; nothing to replicate. + _ => val, + }, + DRAWMODE1_PLANES_OLAY => (val << 8) | (val << 16), + DRAWMODE1_PLANES_CID => val | (val << 4), + DRAWMODE1_PLANES_PUP => (val << 2) | (val << 6), + _ => 0, + } +} + +/// Apply the DRAWMODE1 LOGICOP selector. +#[inline(always)] +fn logic_op(m: &M, src: u32, dst: u32) -> u32 { + match m.logicop() { + DRAWMODE1_LOGICOP_ZERO => 0, + DRAWMODE1_LOGICOP_AND => src & dst, + DRAWMODE1_LOGICOP_ANDR => src & !dst, + DRAWMODE1_LOGICOP_SRC => src, + DRAWMODE1_LOGICOP_ANDI => !src & dst, + DRAWMODE1_LOGICOP_DST => dst, + DRAWMODE1_LOGICOP_XOR => src ^ dst, + DRAWMODE1_LOGICOP_OR => src | dst, + DRAWMODE1_LOGICOP_NOR => !(src | dst), + DRAWMODE1_LOGICOP_XNOR => !(src ^ dst), + DRAWMODE1_LOGICOP_NDST => !dst, + DRAWMODE1_LOGICOP_ORR => src | !dst, + DRAWMODE1_LOGICOP_NSRC => !src, + DRAWMODE1_LOGICOP_ORI => !src | dst, + DRAWMODE1_LOGICOP_NAND => !(src & dst), + // ONE (0xF) and any unreachable encoding. + _ => !0, + } +} + +/// Alpha-vs-ALPHAREF compare; 0x7 means disabled. +#[inline(always)] +fn afunc(m: &M, sa: u32, aref: u32) -> bool { + match m.compare() { + DRAWMODE1_COMPARE_NEVER => false, + DRAWMODE1_COMPARE_LT => sa < aref, + DRAWMODE1_COMPARE_EQ => sa == aref, + DRAWMODE1_COMPARE_LE => sa <= aref, + DRAWMODE1_COMPARE_GT => sa > aref, + DRAWMODE1_COMPARE_NE => sa != aref, + DRAWMODE1_COMPARE_GE => sa >= aref, + // DISABLE (0x7): every relation set, so everything passes. + _ => true, + } +} + +/// The `(shift, mask)` this plane selection reads with, or `None` for an +/// unmapped plane (the old `read_zero` / `write_nop` case). +#[inline(always)] +fn plane_shift_mask(m: &M) -> Option<(u32, u32)> { + let dbl = m.dblsrc() != 0; + match m.planes() { + DRAWMODE1_PLANES_RGB | DRAWMODE1_PLANES_RGBA => match m.drawdepth() { + DRAWMODE1_DRAWDEPTH_4 => Some((if dbl { 4 } else { 0 }, 0xF)), + DRAWMODE1_DRAWDEPTH_8 => Some((if dbl { 8 } else { 0 }, 0xFF)), + DRAWMODE1_DRAWDEPTH_12 => Some((if dbl { 12 } else { 0 }, 0xFFF)), + DRAWMODE1_DRAWDEPTH_24 => Some((0, 0xFFFFFF)), + _ => None, + }, + DRAWMODE1_PLANES_OLAY => Some((if dbl { 16 } else { 8 }, 0xFF)), + DRAWMODE1_PLANES_PUP => Some((if dbl { 6 } else { 2 }, 0x3)), + DRAWMODE1_PLANES_CID => Some((if dbl { 4 } else { 0 }, 0x3)), + _ => None, + } +} + +/// True when this plane lives in the aux framebuffer rather than RGB. +#[inline(always)] +fn plane_is_aux(m: &M) -> bool { + matches!( + m.planes(), + DRAWMODE1_PLANES_OLAY | DRAWMODE1_PLANES_PUP | DRAWMODE1_PLANES_CID + ) +} + +/// Read one plane-depth pixel. +#[inline(always)] +fn read_plane(fb: &Framebuffers, m: &M, addr: u32) -> u32 { + let Some((shift, mask)) = plane_shift_mask(m) else { + return 0; + }; + let plane = if plane_is_aux(m) { fb.aux } else { fb.rgb }; + let raw = unsafe { *plane.add(addr as usize) }; + (raw >> shift) & mask +} + +/// Masked write to the plane this mode selects. +#[inline(always)] +fn write_plane(fb: &Framebuffers, m: &M, ctx: &Rex3Context, addr: u32, val: u32) { + if plane_shift_mask(m).is_none() { + return; // unmapped plane: write_nop + } + let plane = if plane_is_aux(m) { fb.aux } else { fb.rgb }; + let slot = unsafe { &mut *plane.add(addr as usize) }; + let mask = ctx.wrmask; + *slot = (*slot & !mask) | (val & mask); +} + +/// CIDMATCH is a mask of permitted CIDs: the 2-bit CID from the aux plane +/// indexes a bit of it. 0xF (all permitted) is handled by `cidtest() == 0`, so +/// this is only reached when the test is live. +#[inline(always)] +fn cid_allows_write(fb: &Framebuffers, cid_mask: u32, addr: u32) -> bool { + let cid = unsafe { *fb.aux.add(addr as usize) } & 3; + cid_mask & (1 << cid) != 0 +} + + +// ── Addressing and blending ────────────────────────────────────────────────── +// +// Moved off `Rex3`: none of these touched `self`, they only ever read the +// context. As free functions they sit next to the pipeline that uses them, and +// the draw path no longer needs a `&Rex3` to reach them — which is what lets its +// signature converge on the JIT shader's (ctx, fb_rgb, fb_aux). + +pub fn calculate_fb_address( + m: &M, + x: i32, + y: i32, + ctx: &Rex3Context, +) -> Option { + // Mode fields come from `m`, so a const instance folds these away: a draw + // with no scissor enabled drops both clip blocks entirely, and one without + // YFLIP loses that branch. + let is_scr2scr = m.opcode() == DRAWMODE0_OPCODE_SCR2SCR; + + let mut x_curr = x; + let mut y_curr = y; + + // In scr2scr mode xymove is unconditional (it offsets the destination). + // In regular paint mode it is conditional on the xyoffset flag. + let apply_xymove = is_scr2scr || m.xyoffset() != 0; + if apply_xymove { + let x_move = (ctx.xymove >> 16) as i16 as i32; + let y_move = (ctx.xymove & 0xFFFF) as i16 as i32; + x_curr += x_move; + y_curr += y_move; + } + + // Apply XYWIN offset + // XYWIN is 16,16. Assuming High=X, Low=Y. + // Treated as signed 16-bit integers for coordinate biasing. + let x_off = ((ctx.xywin >> 16) & 0xFFFF) as i16 as i32; + let y_off = (ctx.xywin & 0xFFFF) as i16 as i32; + + let x_abs = x_curr + x_off; + let y_abs = y_curr + y_off; + + if IS_WRITE { + let ensmask = m.ensmask(); + + // SMASK0 (Window Relative) — high16=min, low16=max + if (ensmask & CLIPMODE_ENSMASK_SMASK0) != 0 { + let min_x = ((ctx.smask0x >> 16) & 0xFFFF) as i16 as i32; + let max_x = (ctx.smask0x & 0xFFFF) as i16 as i32; + let min_y = ((ctx.smask0y >> 16) & 0xFFFF) as i16 as i32; + let max_y = (ctx.smask0y & 0xFFFF) as i16 as i32; + + if x_curr < min_x || x_curr > max_x || y_curr < min_y || y_curr > max_y { + return None; + } + } + + // SMASK1-4 (Screen Absolute, unaffected by XYWIN per spec). + // Host pre-biases smask values with the 4K,4K offset. The equivalent + // pixel coordinate is x_phys + 0x1000 = (x_abs - 0x1000) + 0x1000 = x_abs. + // So compare x_abs/y_abs directly against raw smask values. high16=min, low16=max. + // Logic: pixel must be inside at least one enabled mask. + let smask_enabled = (ensmask & CLIPMODE_ENSMASK_SMASK1_4) != 0; + if smask_enabled { + let smasks = [ + (ctx.smask1x, ctx.smask1y), + (ctx.smask2x, ctx.smask2y), + (ctx.smask3x, ctx.smask3y), + (ctx.smask4x, ctx.smask4y), + ]; + let mut inside_any = false; + for (bit, (sx, sy)) in smasks.iter().enumerate() { + if (ensmask & (1 << (bit + 1))) == 0 { continue; } + let min_x = (sx >> 16) as i16 as i32; + let max_x = (sx & 0xFFFF) as i16 as i32; + let min_y = (sy >> 16) as i16 as i32; + let max_y = (sy & 0xFFFF) as i16 as i32; + if x_abs >= min_x && x_abs <= max_x && y_abs >= min_y && y_abs <= max_y { + inside_any = true; + break; + } + } + if !inside_any { + return None; + } + } + } + // Physical Address Calculation + let x_phys = x_abs - REX3_COORD_BIAS; + let y_phys = if m.yflip() != 0 { 0x23FF - y_abs } else { y_abs - REX3_COORD_BIAS }; + + // Sector Clipping (VRAM bounds) + // Reads are not culled (but must be within VRAM allocation) + let width_limit = if IS_WRITE { REX3_SCREEN_WIDTH } else { 2048 }; + if x_phys < 0 || x_phys >= width_limit || y_phys < 0 || y_phys >= REX3_SCREEN_HEIGHT { + return None; + } + + Some((y_phys as u32) * 2048 + (x_phys as u32)) +} + + +pub fn calculate_src_address(m: &M, x: i32, y: i32, ctx: &Rex3Context) -> Option { + // xymove affects the destination, not the source. + // Source is just (x, y) + xywin. + let x_win = ((ctx.xywin >> 16) & 0xFFFF) as i16 as i32; + let y_win = (ctx.xywin & 0xFFFF) as i16 as i32; + + let x_abs = x + x_win; + let y_abs = y + y_win; + + let x_phys = x_abs - REX3_COORD_BIAS; + let y_phys = if m.yflip() != 0 { 0x23FF - y_abs } else { y_abs - REX3_COORD_BIAS }; + + if x_phys < 0 || x_phys >= REX3_SCREEN_WIDTH || y_phys < 0 || y_phys >= REX3_SCREEN_HEIGHT { + return None; + } + + Some((y_phys as u32) * 2048 + (x_phys as u32)) +} + + +pub fn blend(m: &M, src: u32, dst: u32) -> u32 { + let s_factor_sel = m.sfactor(); + let d_factor_sel = m.dfactor(); + + // BLENDALPHA (DRAWMODE1 bit 27) substitutes the SOURCE multiplier only. + // Spec §3.8: "When source multiplier is set to source alpha (SFACTOR=4) ... + // When BLENDALPHA is set to 0, the source multiplier for blending alpha is + // one instead of source alpha AND DESTINATION MULTIPLIER IS DEFINED BY + // DFACTOR." The trailing clause is load-bearing: DFACTOR keeps its own + // definition, so a DFACTOR of BF_MSA still evaluates 1 - source alpha + // against the real alpha. Substituting in both factors would zero BF_MSA + // and discard the destination entirely, which the spec does not say. + let sa_real = (src >> 24) & 0xFF; + let sa_src = if m.blendalpha() != 0 { sa_real } else { 255 }; + + // `c` is the *other* operand's channel — destination when computing the + // source factor, source when computing the destination factor — which is + // why BF_OC/BF_MOC read as BF_DC/BF_MDC for SFACTOR and BF_SC/BF_MSC for + // DFACTOR (spec Tables 13/14). + let get_factor = |sel: u32, c: u32, a: u32| -> u32 { + match sel { + DRAWMODE1_BF_ZERO => 0, + DRAWMODE1_BF_ONE => 255, + DRAWMODE1_BF_OC => c, + DRAWMODE1_BF_MOC => 255 - c, + DRAWMODE1_BF_SA => a, + DRAWMODE1_BF_MSA => 255 - a, + // 110/111 are undefined by the hardware. + _ => 0, + } + }; + + let mut res = 0; + for i in 0..4 { + let shift = i * 8; + let s_c = (src >> shift) & 0xFF; + let d_c = (dst >> shift) & 0xFF; + + let sf = get_factor(s_factor_sel, d_c, sa_src); + let df = get_factor(d_factor_sel, s_c, sa_real); + + let val = (s_c * sf + d_c * df) / 255; + let val_clamped = if val > 255 { 255 } else { val }; + + res |= val_clamped << shift; + } + res +} + + +// ── Per-pixel iteration ────────────────────────────────────────────────────── + +/// Advance the shade DDAs. +/// +/// RGB mode clamps every iteration per spec §3.8; CI mode clamps only under +/// CICLAMP, and only at 8/12bpp. The DDA advances whether or not the pixel was +/// drawn. Whether the clamp writes back into the accumulator (as here) or only +/// affects the value sent downstream is an open hardware question — see +/// `rules/rex3/shade-dda-clamp-open-question.md`. +#[inline(always)] +pub fn iterate_shade(ctx: &mut Rex3Context, m: &M) { + if m.shade() == 0 { + return; + } + shade_add(ctx); + if m.rgbmode() != 0 { + ctx.colorred = clamp_shade(ctx.colorred); + ctx.colorgrn = clamp_shade(ctx.colorgrn); + ctx.colorblue = clamp_shade(ctx.colorblue); + ctx.coloralpha = clamp_shade(ctx.coloralpha); + } else if m.ciclamp() != 0 { + match m.drawdepth() { + DRAWMODE1_DRAWDEPTH_8 => { + if ctx.colorred & (1 << 19) != 0 { + ctx.colorred = 0x0007_FFFF; + } + } + DRAWMODE1_DRAWDEPTH_12 => { + if ctx.colorred & (1 << 21) != 0 { + ctx.colorred = 0x001F_FFFF; + } + } + // 4bpp / 24bpp: no CI clamp per spec. + _ => {} + } + } +} + +/// integer = bits[22:11] & 0x1FF; negative or >= 0x180 clamps to 0, > 0xFF to +/// the saturation constant. +#[inline(always)] +fn clamp_shade(c: u32) -> u32 { + let val = (c >> 11) & 0x1FF; + if c & (1 << 31) != 0 || val >= 0x180 { + 0 + } else if val > 0xFF { + 0x0007_FFFF + } else { + c + } +} + +/// Advance the pattern bit counters. +#[inline(always)] +pub fn iterate_pattern(ctx: &mut Rex3Context, m: &M) { + if m.enzpattern() != 0 { + advance_zpat(ctx); + } + if m.enlspattern() != 0 { + advance_lspat(ctx); + } +} + +// ── Pixel bodies ───────────────────────────────────────────────────────────── + +/// One pixel of a DRAW primitive. +/// +/// The pattern prologue follows the old `process_pixel_noblend` and the rex-jit +/// shader: the lspattern test is evaluated unconditionally, with no suppression +/// on the zpopaque path. `process_pixel_draw` suppressed it; two of the three +/// implementations did not, and the JIT is one of them, so that is what the +/// comparison tests enforce. Whether hardware suppresses is open. +#[inline(always)] +fn pixel_draw( + fb: &Framebuffers, + ctx: &mut Rex3Context, + m: &M, + fc_color: u32, + x: i32, + y: i32, +) { + let mut use_bg = false; + + if m.enzpattern() != 0 && (ctx.zpattern >> ctx.zpat_bit) & 1 == 0 { + if m.zpopaque() != 0 { + use_bg = true; + } else { + return; + } + } + + if m.enlspattern() != 0 && (ctx.lspattern >> ctx.pat_bit) & 1 == 0 { + if m.lsopaque() != 0 { + use_bg = true; + } else { + return; + } + } + + // Host pixel is consumed only when the pattern passed and the source is the + // host FIFO — matching MAME's get_host_color() placement. + let host_pixel = if !use_bg && (m.alphahost() != 0 || m.colorhost() != 0) { + fetch_host_pixel(ctx, m) + } else { + 0 + }; + + let Some(addr) = calculate_fb_address::(m, x, y, ctx) else { + return; + }; + + if m.cidtest() != 0 && !cid_allows_write(fb, m.cid_mask(), addr) { + return; + } + + // FASTCLEAR: flat fill from COLORVRAM, no per-pixel operation at all + // (rex3.pdf §3.5.5). Only set where hardware honours it — DRAW opcode, CID + // checking off, not overridden by colorhost. + if m.fastclear() != 0 { + // Hoisted by the caller: depends only on the mode and COLORVRAM, both + // fixed for the primitive, so recomputing it per pixel is pure waste. + write_plane(fb, m, ctx, addr, fc_color); + return; + } + + let raw_src = if use_bg { + ctx.colorback + } else { + combine_host_dda(ctx, m, host_pixel) + }; + + if m.compare() != 0x7 && !afunc(m, (raw_src >> 24) & 0xFF, ctx.alpharef & 0xFF) { + return; + } + + let res = if m.blend() != 0 { + let dst_raw = if m.backblend() != 0 { + ctx.colorback + } else { + expand(m, read_plane(fb, m, addr)) + }; + let blended = blend(m, raw_src, dst_raw); + amplify(m, compress(m, blended, x, y)) + } else { + let src = amplify(m, compress(m, raw_src, x, y)); + let dst = amplify(m, read_plane(fb, m, addr)); + logic_op(m, src, dst) + }; + + write_plane(fb, m, ctx, addr, res); +} + +/// One pixel of a READ (HOSTR) primitive: framebuffer to host FIFO. No write, so +/// no CID check and no write-side clipping. +#[inline(always)] +fn pixel_read(fb: &Framebuffers, ctx: &mut Rex3Context, m: &M, x: i32, y: i32) { + let pixel = match calculate_fb_address::(m, x, y, ctx) { + // Expand to 24-bit BGR before packing: host_pack_*_rgb expects that, + // and expand is the identity in CI mode. + Some(addr) => expand(m, read_plane(fb, m, addr)), + None => 0, + }; + store_host_pixel(ctx, m, pixel); +} + +/// One pixel of a SCR2SCR primitive. +/// +/// Two deliberate differences from the DRAW path, both matching the original +/// `process_pixel_scr2scr`: the blend arm does not amplify after compressing, +/// and there is no pattern or afunction handling. +#[inline(always)] +fn pixel_scr2scr(fb: &Framebuffers, ctx: &mut Rex3Context, m: &M, x: i32, y: i32) { + let raw_src = match calculate_src_address(m, x, y, ctx) { + Some(src_addr) => expand(m, read_plane(fb, m, src_addr)), + None => 0, + }; + + let Some(dst_addr) = calculate_fb_address::(m, x, y, ctx) else { + return; + }; + if m.cidtest() != 0 && !cid_allows_write(fb, m.cid_mask(), dst_addr) { + return; + } + + let res = if m.blend() != 0 { + let dst_raw = if m.backblend() != 0 { + ctx.colorback + } else { + expand(m, read_plane(fb, m, dst_addr)) + }; + // No amplify here — matches process_pixel_scr2scr. + compress(m, blend(m, raw_src, dst_raw), x, y) + } else { + let src = amplify(m, compress(m, raw_src, x, y)); + let dst = amplify(m, read_plane(fb, m, dst_addr)); + logic_op(m, src, dst) + }; + + write_plane(fb, m, ctx, dst_addr, res); +} + +/// Dispatch one pixel to the body this opcode selects. +#[inline(always)] +pub fn pixel( + fb: &Framebuffers, + ctx: &mut Rex3Context, + m: &M, + fc_color: u32, + x: i32, + y: i32, +) { + match m.opcode() { + DRAWMODE0_OPCODE_READ => pixel_read(fb, ctx, m, x, y), + DRAWMODE0_OPCODE_SCR2SCR => pixel_scr2scr(fb, ctx, m, x, y), + DRAWMODE0_OPCODE_NOOP => {} + _ => pixel_draw(fb, ctx, m, fc_color, x, y), + } +} + +/// Set/clear a `rexdiag` activity bit. No-op without the feature. +#[inline(always)] +pub fn diag_set(ctx: &Rex3Context, bits: u64, on: bool) { + let _ = (ctx, bits, on); + #[cfg(feature = "rexdiag")] + { + let host = ctx.host; + if !host.is_null() { + use std::sync::atomic::Ordering; + let d = unsafe { &(*host).diag }; + if on { + d.fetch_or(bits, Ordering::Relaxed); + } else { + d.fetch_and(!bits, Ordering::Relaxed); + } + } + } +} + +/// Developer block/span trace. Compiles to nothing without the feature. +#[inline(always)] +fn log_block(ctx: &Rex3Context, opcode: u32) { + let host = ctx.host; + if host.is_null() { + return; + } + unsafe { (*host).log_block(ctx, opcode) } +} + + +// ── Host FIFO ──────────────────────────────────────────────────────────────── +// +// HOSTRW transfers, moved off `Rex3`: the pack/unpack variant is selected from +// the mode rather than through the `host_pack`/`host_unpack` function pointers +// these replaced, and the slot geometry comes from `Mode::hostdepth`/`rwpacked`/ +// `rwdouble` instead of the `host_count`/`host_shift` cells. + +/// Pixels per 64-bit host word. +#[inline(always)] +fn host_count(m: &M) -> u32 { + if m.rwpacked() == 0 { + return 1; + } + if m.rwdouble() != 0 { + match m.hostdepth() { + DRAWMODE1_HOSTDEPTH_12 | DRAWMODE1_HOSTDEPTH_8 => 8, + DRAWMODE1_HOSTDEPTH_4 => 4, + _ => 2, + } + } else { + match m.hostdepth() { + DRAWMODE1_HOSTDEPTH_12 | DRAWMODE1_HOSTDEPTH_8 => 4, + DRAWMODE1_HOSTDEPTH_4 => 2, + _ => 1, + } + } +} + +/// Bits per host pixel slot. 4bpp pixels sit in an 8-bit slot, so the shift is +/// 8 rather than 4. +#[inline(always)] +fn host_shift(m: &M) -> u32 { + if m.rwpacked() == 0 { + return 0; + } + match m.hostdepth() { + DRAWMODE1_HOSTDEPTH_12 | DRAWMODE1_HOSTDEPTH_8 => 8, + DRAWMODE1_HOSTDEPTH_4 => 16, + _ => 32, + } +} + +/// Extract the leading pixel from the host shifter, expanding to 24-bit BGR in +/// RGB mode and leaving a plane-depth index in CI mode. +#[inline(always)] +fn host_unpack(m: &M, val: u64) -> u32 { + let rgb = m.rgbmode() != 0; + match m.hostdepth() { + DRAWMODE1_HOSTDEPTH_12 => { + let v = ((val >> 56) & 0xF) as u32; + if rgb { Rex3::expand_4_rgb(v) } else { v } + } + DRAWMODE1_HOSTDEPTH_8 => { + let v = ((val >> 56) & 0xFF) as u32; + if rgb { Rex3::expand_8_rgb(v) } else { v } + } + DRAWMODE1_HOSTDEPTH_4 => { + let v = ((val >> 48) & 0xFFF) as u32; + if rgb { Rex3::expand_12_rgb(v) } else { v } + } + _ => { + let v = (val >> 32) as u32; + if rgb { Rex3::expand_32_rgb(v) } else { v } + } + } +} + +/// Inverse of [`host_unpack`]: shift the accumulator up by one slot and insert. +#[inline(always)] +fn host_pack(m: &M, acc: u64, pixel: u32) -> u64 { + let rgb = m.rgbmode() != 0; + match m.hostdepth() { + DRAWMODE1_HOSTDEPTH_12 => { + let v = if rgb { Rex3::compress_4_rgb(pixel) } else { pixel & 0xF }; + (acc << 8) | v as u64 + } + DRAWMODE1_HOSTDEPTH_8 => { + let v = if rgb { Rex3::compress_8_rgb(pixel) } else { pixel & 0xFF }; + (acc << 8) | v as u64 + } + DRAWMODE1_HOSTDEPTH_4 => { + let v = if rgb { Rex3::compress_12_rgb(pixel) } else { pixel & 0xFFF }; + (acc << 16) | v as u64 + } + _ => { + let v = if rgb { Rex3::compress_32_rgb(pixel) } else { pixel }; + (acc << 32) | v as u64 + } + } +} + +/// Pull one pixel from the HOSTRW FIFO, refilling the shifter when empty. +#[inline(always)] +pub fn fetch_host_pixel(ctx: &mut Rex3Context, m: &M) -> u32 { + if ctx.hostcnt == 0 { + // 32-bit writes land in the high half [63:32] via HOSTRW0, so the data + // is already at the MSB. + ctx.host_shifter = ctx.hostrw; + if m.swapendian() != 0 { + ctx.host_shifter = if m.rwdouble() != 0 { + ctx.host_shifter.swap_bytes() + } else { + // Swap only the high 32-bit word. + let hi = (ctx.host_shifter >> 32) as u32; + ((hi.swap_bytes() as u64) << 32) | (ctx.host_shifter & 0xFFFF_FFFF) + }; + } + ctx.hostcnt = host_count(m); + } + + let pixel = host_unpack(m, ctx.host_shifter); + ctx.host_shifter <<= host_shift(m); + ctx.hostcnt -= 1; + pixel +} + +/// Publish the assembled shifter back to HOSTRW for the CPU to read. +#[inline(always)] +fn send_host_word(ctx: &mut Rex3Context, m: &M) { + let mut val = ctx.host_shifter; + if m.swapendian() != 0 { + val = val.swap_bytes(); + } else if m.rwdouble() == 0 { + val <<= 32; + } + ctx.hostrw = val; +} + +/// Append one pixel to the host word, publishing when it fills. +#[inline(always)] +pub fn store_host_pixel(ctx: &mut Rex3Context, m: &M, pixel: u32) { + if ctx.hostcnt == 0 { + ctx.hostcnt = host_count(m); + ctx.host_shifter = 0; + } + ctx.host_shifter = host_pack(m, ctx.host_shifter, pixel); + ctx.hostcnt -= 1; + if ctx.hostcnt == 0 { + send_host_word(ctx, m); + } +} + +/// Publish a partially-filled word at the end of a primitive. +#[inline(always)] +pub fn flush_host_pixel(ctx: &mut Rex3Context, m: &M) { + if ctx.hostcnt > 0 { + // Align the remaining bits to the MSB, since packing runs LSB to MSB. + ctx.host_shifter <<= ctx.hostcnt * host_shift(m); + send_host_word(ctx, m); + ctx.hostcnt = 0; + } +} + +/// Combine the host pixel with the DDA colour and alpha. +#[inline(always)] +fn combine_host_dda(ctx: &Rex3Context, m: &M, host_pixel: u32) -> u32 { + let color = if m.colorhost() != 0 { host_pixel } else { ctx.get_colori() }; + // Afunction's source alpha comes from "either DDA or host" (selected by + // ALPHAHOST) independent of plane format (spec §3.8.1) — a CI-mode app can + // stream a colour index alongside a host alpha byte. Always overlay bits + // 31:24 so afunction sees the right value in both modes; the CI write paths + // mask down to the plane-depth index and never look at these bits. + let a = if m.alphahost() != 0 { + (host_pixel >> 24) & 0xFF + } else { + Rex3Context::clamp_color_component(ctx.coloralpha) + }; + (color & 0x00FF_FFFF) | (a << 24) +} + +/// Replicate COLORVRAM into every plane slot for a fastclear fill. +/// +/// Depends only on the mode and COLORVRAM, so the draw loops hoist it out of +/// the pixel loop rather than recomputing it per pixel. +#[inline(always)] +pub fn fastclear_color(ctx: &Rex3Context, m: &M) -> u32 { + let v = ctx.colorvram; + match m.drawdepth() { + DRAWMODE1_DRAWDEPTH_4 => { + let c = v & 0xf; + c | (c << 4) | (c << 8) | (c << 16) + } + DRAWMODE1_DRAWDEPTH_8 => { + let c = v & 0xff; + c | (c << 8) | (c << 16) + } + DRAWMODE1_DRAWDEPTH_12 => { + // 12bpp: RGB mode takes nibbles from colorvram, CI the low 12 bits. + let c = if m.rgbmode() != 0 { + ((v & 0xf00000) >> 12) | ((v & 0xf000) >> 8) | ((v & 0xf0) >> 4) + } else { + v & 0x000fff + }; + c | (c << 12) + } + _ => v & 0xffffff, + } +} + +// ── Draw ───────────────────────────────────────────────────────────────────── + +/// The draw pipeline, written once. +/// +/// Instantiated with [`ConstMode`] every `m.*()` call is a literal and the dead +/// arms vanish; instantiated with [`DynMode`] the same source reads fields at +/// runtime. That is the point: one expression, two ways of running it. +#[inline] +pub fn draw(ctx: &mut Rex3Context, m: &M) { + // Derive the framebuffers from the device, then run the shared core. A + // generated shader skips this and calls draw_with_fb directly, because the + // compiled-shader ABI hands it the two pointers already. + let host = ctx.host; + if host.is_null() { + return; + } + let rex: &Rex3 = unsafe { &*host }; + let fb = Framebuffers { + rgb: unsafe { (*rex.fb_rgb.get()).as_mut_ptr() }, + aux: unsafe { (*rex.fb_aux.get()).as_mut_ptr() }, + }; + draw_with_fb(ctx, &fb, m); +} + +/// The draw core, taking the framebuffers the caller already holds. +#[inline] +pub fn draw_with_fb(ctx: &mut Rex3Context, fb: &Framebuffers, m: &M) { + if m.opcode() == DRAWMODE0_OPCODE_NOOP { + return; + } + match m.adrmode() { + DRAWMODE0_ADRMODE_I_LINE => draw_iline_g(fb, ctx, m), + DRAWMODE0_ADRMODE_F_LINE => draw_fline_g(fb, ctx, m), + DRAWMODE0_ADRMODE_A_LINE => draw_aline_g(fb, ctx, m), + DRAWMODE0_ADRMODE_BLOCK => { + log_block(ctx, m.opcode()); + draw_block_g(fb, ctx, m); + } + DRAWMODE0_ADRMODE_SPAN => { + log_block(ctx, m.opcode()); + draw_span_g(fb, ctx, m); + } + _ => {} + } +} + +// ── Entry point ────────────────────────────────────────────────────────────── + +/// Draw one primitive, reading the mode registers directly. +/// +/// Builds a [`DynMode`] from DRAWMODE0/DRAWMODE1/CLIPMODE and runs the pipeline +/// with it. A generated table will sit in front of this, matching the extracted +/// values against known shapes and instantiating [`ConstMode`] for the hits — +/// the const path and this one share the same `draw`, so a table entry is a +/// specialisation, never a second implementation. +#[inline]// ── Primitive walkers ──────────────────────────────────────────────────────── +// Moved here from `impl Rex3`: like the colour helpers these never touched +// `self`, and their only callers are in this module. They walk the primitive +// (block/span/line) and call into the pixel bodies above. + +pub fn draw_block_g(fb: &Framebuffers, ctx: &mut Rex3Context, m: &M) { + // The rex3_simd pre-loop bailouts used to live here. They were removed: + // despite the name they contained no vector code (objdump: zero xmm/ymm + // instructions), and they intercepted the primitive *before* execute_go's + // pixel-processor selection — so their own mode gates silently shadowed + // the interpreter's. try_fastclear_block never checked CIDMATCH, which + // made execute_go's `no_cid` term unreachable for BLOCK draws and let a + // fastclear block ignore CID checking entirely, against the spec. See + // rules/rex3/fastclear-cid-divergence.md. + + let _w = (ctx.xend - ctx.xstart).abs(); + let _h = (ctx.yend - ctx.ystart).abs(); + + // Draw-loop control flow reads the decoded shape, not the raw registers: + // one decode per primitive, and the same values the pixel path uses. + let stopony = m.stopony() != 0; + let length32 = m.length32() != 0; + let ystride = m.ystride() != 0; + let opcode = m.opcode(); + let colorhost = m.colorhost() != 0; + let mut first = true; + let skipfirst = m.skipfirst() != 0; + let skiplast = m.skiplast() != 0; + + + // In host mode (READ or DRAW+colorhost), each GO processes exactly one word's worth + // of pixels (host_count pixels). stop_on_word causes the loop to exit after the + // word boundary so the next GO picks up where we left off. + let stop_on_word = opcode == DRAWMODE0_OPCODE_READ || colorhost; + + // stop_on_word takes priority over stoponx — host mode governs its own stop. + let stoponx = m.stoponx() != 0 || stop_on_word; + + let octant = ctx.bresoctinc1.octant(); + let lronly = m.lronly() != 0; + let x_dec = (octant & OCTANT_XDEC) != 0; + let y_dec = (octant & OCTANT_YDEC) != 0; + let lrskip = lronly && x_dec; + // it is important to note that lrskip still performs y advance operations otherwise some triangles grow weird tails + // Coordinate steps in 21.11 fixed-point: ±1 integer = ±2048 + let stepx: i32 = if x_dec { -(1 << 11) } else { 1 << 11 }; + let y_inc: i32 = if ystride { 2 } else { 1 }; + let stepy: i32 = if y_dec { -(y_inc << 11) } else { y_inc << 11 }; + + // length32 only clamps if span is >= 32 pixels wide + let span_len = ((ctx.xend - ctx.xstart).abs()) >> 11; + let xstop = if length32 && span_len >= 32 { Some(ctx.xstart + stepx * 32) } else { None }; + + + + // Loop-invariant: fastclear writes COLORVRAM replicated across plane + // slots, and neither input changes within a primitive. + let fc_color = fastclear_color(ctx, m); + + ctx.mid_primitive = true; + #[cfg(feature = "rexdiag")] + diag_set(ctx, Rex3::DIAG_LOOP_DRAW_BLOCK, true); + loop { + let x = ctx.xstart >> 11; + let y = ctx.ystart >> 11; + + ctx.xstart += stepx; + + let x_end_reached = if x_dec { ctx.xstart < ctx.xend } else { ctx.xstart > ctx.xend }; + + if !(first && skipfirst || x_end_reached && skiplast || lrskip) { + pixel(fb, ctx, m, fc_color, x, y); + } + + iterate_shade(ctx, m); + iterate_pattern(ctx, m); + + if x_end_reached { + // advance y, wrap x; reset pattern bits so each row starts at bit 31 + ctx.ystart += stepy; + ctx.xstart = ctx.xsave; + ctx.pat_bit = 31; + ctx.zpat_bit = 31; + // lsrcount continues across rows — iterate_pattern_ls manages it per-pixel. + + if !stopony { + // Without STOPONY, hardware doesn't auto-advance rows — each row is + // its own complete primitive and the next GO starts a fresh one. + // Mirrors the JIT's emit_shader (!stopony branch in end_x_block), + // which already clears mid_primitive here. Leaving this true (as + // before) permanently wedged log_block()'s "primitive start" guard + // after the first non-stopony block ever ran, hiding every + // subsequent block/READ/DRAW header from block.log. + ctx.mid_primitive = false; + break; + } + + let y_end_reached = if y_dec { ctx.ystart < ctx.yend } else { ctx.ystart > ctx.yend }; + + if y_end_reached { + // All rows consumed — primitive done. + ctx.mid_primitive = false; + break; + } + + // Host mode: a row boundary is always a forced word boundary too, + // even if the row's width doesn't divide evenly into host_count + // (e.g. a 17px-wide CI8 row's last word only has 1 of 4 slots + // filled). Without this, a still-open partial word from this row + // would keep accumulating pixels from the next row instead of + // being flushed — hardware sends one word per GO in host mode, + // full or not. Checked here (not just via the hostcnt==0 check + // below) because that check alone never fires for a word that + // never reaches host_count pixels. + if stop_on_word && ctx.hostcnt > 0 { + break; + } + + first = true; // pixel in next row will be first + } else if let Some(limit) = xstop { + let limit_reached = if x_dec { ctx.xstart <= limit } else { ctx.xstart >= limit }; + if limit_reached { + break; + } + } + + // Host mode: stop after one word (after y-advance so row boundary is handled first). + // Primitive continues on next GO — mid_primitive stays true. + if stop_on_word && ctx.hostcnt == 0 { + break; + } + + // stoponx/stopony: next GO advances to next step — mid_primitive stays true. + if !stoponx { + break; + } + } + + + #[cfg(feature = "rexdiag")] + diag_set(ctx, Rex3::DIAG_LOOP_DRAW_BLOCK, false); + + if opcode == DRAWMODE0_OPCODE_READ { + flush_host_pixel(ctx, m); + } +} + +pub fn draw_span_g(fb: &Framebuffers, ctx: &mut Rex3Context, m: &M) { + if m.lronly() != 0 && (ctx.bresoctinc1.octant() & OCTANT_XDEC) != 0{ + return; + } + let length32 = m.length32() != 0; + let ystride = m.ystride() != 0; + let opcode = m.opcode(); + let colorhost = m.colorhost() != 0; + let mut first = true; + let skipfirst = m.skipfirst() != 0; + let skiplast = m.skiplast() != 0; + + // In host mode (READ or DRAW+colorhost), each GO processes exactly one word's worth + // of pixels (host_count pixels). stop_on_word causes the loop to exit after the + // word boundary so the next GO picks up where we left off. + let stop_on_word = opcode == DRAWMODE0_OPCODE_READ || colorhost; + + // stop_on_word takes priority over stoponx — host mode governs its own stop. + let stoponx = m.stoponx() != 0 || stop_on_word; + + // Spans always advance left-to-right (+1 in 21.11 fixed-point). + // length32 only clamps if span is >= 32 pixels wide. + let span_len = (ctx.xend - ctx.xstart) >> 11; + let xstop = if length32 && span_len >= 32 { Some(ctx.xstart + (32 << 11)) } else { None }; + + + + // Loop-invariant: fastclear writes COLORVRAM replicated across plane + // slots, and neither input changes within a primitive. + let fc_color = fastclear_color(ctx, m); + + ctx.mid_primitive = true; + #[cfg(feature = "rexdiag")] + diag_set(ctx, Rex3::DIAG_LOOP_DRAW_BLOCK, true); + let x_end_reached = loop { + let x = ctx.xstart >> 11; + let y = ctx.ystart >> 11; + + ctx.xstart += 1 << 11; + + let x_end_reached = ctx.xstart > ctx.xend; + + if !(first && skipfirst || x_end_reached && skiplast) { + pixel(fb, ctx, m, fc_color, x, y); + } + + iterate_shade(ctx, m); + iterate_pattern(ctx, m); + + if x_end_reached { + break true; + } else if let Some(limit) = xstop { + if ctx.xstart >= limit { + break false; + } + } + + // Host mode: stop after one word. + // Primitive continues on next GO — mid_primitive stays true. + if stop_on_word && ctx.hostcnt == 0 { + break false; + } + + // stoponx: next GO advances to next step — mid_primitive stays true. + if !stoponx { + break false; + } + + first = false; + }; + + if x_end_reached { + // Span fully consumed — advance to next row and reset state. + //let y_inc: i32 = if ystride { 2 } else { 1 }; + //ctx.ystart += y_inc << 11; + //ctx.xstart = ctx.xsave; + ctx.pat_bit = 31; + ctx.zpat_bit = 31; + ctx.mid_primitive = false; + } + + + #[cfg(feature = "rexdiag")] + diag_set(ctx, Rex3::DIAG_LOOP_DRAW_BLOCK, false); + + if opcode == DRAWMODE0_OPCODE_READ { + flush_host_pixel(ctx, m); + } +} + +/// Fractional d correction for F_LINE/A_LINE from 21.11 endpoint sub-pixel position. +/// Fractional nibble is bits [10:7] of the 21.11 coordinate (16.4(7) layout). +pub fn fline_apply_fract( + ctx: &Rex3Context, + d: &mut i32, + x: &mut i32, + y: &mut i32, + incrx2: i32, + incry2: i32, + y_major: bool, +) { + let octant = ctx.bresoctinc1.octant() & 7; + let x1p = ctx.xstart >> 11; + let y1p = ctx.ystart >> 11; + let x2p = ctx.xend >> 11; + let y2p = ctx.yend >> 11; + let mut dx = (x1p - x2p).abs(); + let mut dy = (y1p - y2p).abs(); + let mut xf = ((ctx.xstart >> 7) & 0xF) as i32; + let mut yf = ((ctx.ystart >> 7) & 0xF) as i32; + + match octant { + 1 => { + std::mem::swap(&mut xf, &mut yf); + std::mem::swap(&mut dx, &mut dy); + } + 3 => { + xf = 0x10 - xf; + std::mem::swap(&mut xf, &mut yf); + std::mem::swap(&mut dx, &mut dy); + } + 7 => { xf = 0x10 - xf; } + 6 => { + xf = 0x10 - xf; + yf = 0x10 - yf; + } + 2 => { + let t = 0x10 - xf; + xf = 0x10 - yf; + yf = t; + std::mem::swap(&mut dx, &mut dy); + } + 0 => { + let t = 0x10 - yf; + yf = xf; + xf = t; + std::mem::swap(&mut dx, &mut dy); + } + 4 => { yf = 0x10 - yf; } + _ => {} + } + + // `*d` arrives holding the I_LINE decision variable (2*minor - major, + // computed by setup() and shared by all line adrmodes). The REX3 spec + // (rex3_pdf.md 3.6.1.2/3.6.2.1) defines F_LINE/A_LINE's base d as + // 3*minor - 2*major instead — confirmed against MAME's do_fline, + // which independently derives the same 3dy-2dx formula. The two + // formulas differ by exactly (minor - major); apply that correction + // before adding the fractional term below. Without it, the fractional + // term is added to the wrong baseline and can flip d's sign on the + // very first step for near-degenerate (small minor-axis) lines, + // producing a spurious extra step in the minor-axis direction that + // the line never recovers from (confirmed via a real R4400/REX3 + // fractional-line test that undershot its endpoint by one row). + *d += dy - dx; + *d += 2 * (((dx * yf) >> 4) - ((dy * xf) >> 4)); + let major_delta = if y_major { dy } else { dx }; + let e = *d - 2 * major_delta; + if e > 0 { + *d = e; + let x_major = !y_major; + if x_major { + *y -= incry2; + } else { + *x += incrx2; + } + } +} + +pub fn draw_iline_g(fb: &Framebuffers, ctx: &mut Rex3Context, m: &M) { + draw_line_bresenham(fb, ctx, m, false, false, false); +} + +pub fn draw_fline_g(fb: &Framebuffers, ctx: &mut Rex3Context, m: &M) { + draw_line_bresenham(fb, ctx, m, true, false, false); +} + +pub fn draw_aline_g(fb: &Framebuffers, ctx: &mut Rex3Context, m: &M) { + let mut extra_skip_first = false; + let mut extra_skip_last = false; + if m.endptfilter() != 0 { + // Basic endpoint filter: consult AWEIGHT LUT for sub-pixel coverage. + let xsf = (ctx.xstart >> 7) & 0xF; + let ysf = (ctx.ystart >> 7) & 0xF; + let xef = (ctx.xend >> 7) & 0xF; + let yef = (ctx.yend >> 7) & 0xF; + if xsf != 0 || ysf != 0 { + let wi = ((xsf + ysf) as usize).min(15); + let w = (ctx.aweight0 >> (wi * 4)) & 0xF; + if w == 0 { + extra_skip_first = true; + } + } + if xef != 0 || yef != 0 { + let wi = ((xef + yef) as usize).min(15); + let w = (ctx.aweight1 >> (wi * 4)) & 0xF; + if w == 0 { + extra_skip_last = true; + } + } + } + draw_line_bresenham(fb, ctx, m, true, extra_skip_first, extra_skip_last); +} + +fn draw_line_bresenham( + fb: &Framebuffers, + ctx: &mut Rex3Context, + m: &M, + fract: bool, + extra_skip_first: bool, + extra_skip_last: bool, +) { + let octant = (ctx.bresoctinc1.octant() & 7) as usize; + let (incrx1, incrx2, incry1, incry2, y_major) = REX3_BRES_OCTANTS[octant]; + + let x2 = ctx.xend >> 11; + let y2 = ctx.yend >> 11; + let mut x = ctx.xstart >> 11; + let mut y = ctx.ystart >> 11; + + // All Bresenham state comes from registers — set by setup() or restored across GOs. + // incr1: 20-bit, always positive (no sign extension needed). + let incr1 = ctx.bresoctinc1.incr1() as i32; + // incr2: 21-bit signed — sign-extend from bit 20. + let incr2 = { + let raw = ctx.bresrndinc2.incr2(); + if raw & (1 << 20) != 0 { (raw | 0xFFE0_0000) as i32 } else { raw as i32 } + }; + // d: 27-bit signed — sign-extend from bit 26. Persisted across step-mode GOs. + // For F_LINE/A_LINE (fract=true), the fractional-endpoint correction was + // already applied in setup() (see setup()'s doc comment) — bresd/xstart/ystart + // read here are already correct, no further adjustment needed. + let mut d = { + let raw = ctx.bresd & 0x7FF_FFFF; + if raw & (1 << 26) != 0 { (raw | 0xF800_0000) as i32 } else { raw as i32 } + }; + + // pixel_count = major_axis_length + 1 (both endpoints inclusive). + // max(|dx|,|dy|): continuation GOs (dosetup clear) must still walk the full + // segment when persisted octant y_major disagrees with start→end (e.g. a + // degenerate setup GO followed by a horizontal stipple continuation). + let adx = (x2 - x).abs(); + let ady = (y2 - y).abs(); + let major = adx.max(ady); + let mut pixel_count = major + 1; + if m.length32() != 0 && pixel_count > 32 { + pixel_count = 32; + } + + let iterate_one = m.stoponx() == 0 && m.stopony() == 0; + let mut skip_first = m.skipfirst() != 0 || extra_skip_first; + let mut skip_last = m.skiplast() != 0 || extra_skip_last; + if iterate_one { + pixel_count = 1; + skip_first = false; + skip_last = false; + } + + + let lsadvlast = m.lsadvlast() != 0; + + macro_rules! bres_step { + () => { + if d < 0 { + x += incrx1; y -= incry1; d += incr1; + } else { + x += incrx2; y -= incry2; d += incr2; + } + }; + } + + // Loop-invariant: fastclear writes COLORVRAM replicated across plane + // slots, and neither input changes within a primitive. + let fc_color = fastclear_color(ctx, m); + + for i in 0..pixel_count { + let is_first = i == 0; + let is_last = i == pixel_count - 1; + + // Write pixel unless suppressed by skip_first/skip_last. + // iterate_one overrides skip_first so single-step mode always draws. + let draw = (!is_first || !skip_first) && (!is_last || !skip_last); + if draw { + pixel(fb, ctx, m, fc_color, x, y); + } + + iterate_shade(ctx, m); + if !is_last || lsadvlast { + iterate_pattern(ctx, m); + } + + // On the last pixel of a full I_LINE draw, verify Bresenham landed on x2,y2 — + // integer Bresenham is exact, so this is a real invariant for I_LINE. + // F_LINE/A_LINE do NOT get this check: a fractional start biases the initial + // error term but the loop still steps by whole pixels along the major axis, + // so the minor-axis position at the final major-axis step is the closest + // integer approximation to the true (fractional) line, not necessarily the + // literal requested endpoint — this is expected behavior for fractional + // Bresenham (confirmed independently: real hardware/software fractional-DDA + // implementations only guarantee landing in the endpoint's pixel *column/row*, + // not its exact minor-axis coordinate). + debug_assert!( + fract || iterate_one || !is_last || (x == x2 && y == y2), + "I_LINE bres mismatch: pos ({},{}) != end ({},{})", x, y, x2, y2 + ); + + // In full-line mode: do NOT step after the last pixel — that would leave + // xstart/ystart one position beyond the endpoint, breaking the next XYENDI GO + // (dosetup re-derives Bresenham from xstart). + // In step mode: always step so the next single-step GO starts at the next position. + if !is_last || iterate_one { + bres_step!(); + } + } + + ctx.xstart = x << 11; + ctx.ystart = y << 11; + // Persist d so the next GO (step mode) picks up where we left off. + ctx.bresd = (d as u32) & 0x7FF_FFFF; +} + + + +pub fn draw_primitive(ctx: &mut Rex3Context) { + let dm0 = ctx.drawmode0.0; + let dm1 = ctx.drawmode1.0; + let clipmode = ctx.clipmode; + + // One decoder. `unpack` owns the canonicalisation — the FASTCLEAR fold, the + // dead blend inputs, the host fields — so it is not restated here. + let m = sh::unpack(dm0, dm1, clipmode); + + draw(ctx, &m); +} diff --git a/src/rex3_jit/compiler.rs b/src/rex3_jit/compiler.rs index e5e785f6..03a3ef90 100644 --- a/src/rex3_jit/compiler.rs +++ b/src/rex3_jit/compiler.rs @@ -43,6 +43,7 @@ use crate::rex3::{ DRAWMODE1_PLANES_OLAY, DRAWMODE1_PLANES_PUP, DRAWMODE1_PLANES_CID, OCTANT_XDEC, OCTANT_YDEC, OCTANT_XMAJOR, REX3_COORD_BIAS, REX3_SCREEN_WIDTH, REX3_SCREEN_HEIGHT, + CLIPMODE_CIDMATCH_SHIFT, }; // ── Context field offsets (must match #[repr(C)] Rex3Context layout) ───────── @@ -65,6 +66,12 @@ impl Dm0 { fn skiplast(&self) -> bool { self.val & (1 << 11) != 0 } fn enzpattern(&self) -> bool { self.val & (1 << 12) != 0 } fn enlspattern(&self) -> bool { self.val & (1 << 13) != 0 } + /// LSADVLAST: advance the line-stipple pattern on the primitive's last + /// pixel too. When clear, the last pixel does NOT advance the pattern, so + /// connected segments of a polyline resume mid-pattern instead of drifting + /// one bit per segment (see draw_line_bresenham in rex3.rs: the pattern + /// step is `if !is_last || lsadvlast`). + fn lsadvlast(&self) -> bool { self.val & (1 << 14) != 0 } fn length32(&self) -> bool { self.val & (1 << 15) != 0 } fn zpopaque(&self) -> bool { self.val & (1 << 16) != 0 } fn lsopaque(&self) -> bool { self.val & (1 << 17) != 0 } @@ -157,7 +164,7 @@ impl ShaderCompiler { // DRAW/SCR2SCR/READ opcodes; SPAN, BLOCK, or I/F/A_LINE adrmode. // Lines do not support host modes (READ/colorhost) — guard below. let opcode = dm0.opcode(); - let adrmode = dm0.adrmode() << 2; // match the <<2 convention from rex3.rs + let adrmode = dm0.adrmode(); let is_scr2scr = opcode == DRAWMODE0_OPCODE_SCR2SCR; let is_hostr = opcode == DRAWMODE0_OPCODE_READ; let is_hostw = opcode == DRAWMODE0_OPCODE_DRAW @@ -178,11 +185,27 @@ impl ShaderCompiler { return None; } - // fastclear takes priority over blend — hardware ignores blend when fastclear=1. - // SCR2SCR copies already-quantized pixels — dithering would corrupt them (matches execute_go). - let dm1_val = if dm1_val & (1 << 17) != 0 { dm1_val & !(1 << 18) } - else if is_scr2scr { dm1_val & !(1 << 16) } // clear DITHER - else { dm1_val }; + // Shared with execute_go's dispatch key and interpreter setup key. If this + // and the dispatch site ever disagree, shaders compile under a key the draw + // path never asks for and every GO silently falls back to the interpreter. + let dm1_val = crate::rex3_shape::normalize_dm1(dm1_val, opcode); + + // Hardware disables FASTCLEAR when CID checking is enabled — rex3.pdf + // says so in DRAWMODE1 bit 17 ("when CID checking disabled (CLIPMODE + // CIDMATCH = 0xF)"), §3.5.5 ("CID checking is not allowed for this + // drawing mode") and the programming notes. The interpreter honours this + // in its processor selection (`fastclear() && no_cid`); clearing the bit + // here is the equivalent, and covers every emit_pixel_write below at + // once rather than threading cidmatch through each. + // + // This was invisible until rex3_simd::try_fastclear_block was removed: + // that pre-loop bailout also ignored CID, so both engines wrote + // COLORVRAM and agreed. See rules/rex3/fastclear-cid-divergence.md. + let dm1_val = if (clipmode_key >> CLIPMODE_CIDMATCH_SHIFT) & 0xF != 0xF { + dm1_val & !(1 << 17) + } else { + dm1_val + }; let dm1 = Dm1 { val: dm1_val }; let name = format!("rex_shader_{:08x}_{:08x}_{:08x}_{}", dm0_val, dm1_val, clipmode_key, self.counter); @@ -266,7 +289,6 @@ impl ShaderCompiler { struct PixelCtx { xywin_v: Value, // packed: hi=xwin, lo=ywin xymove_v: Value, - clipmode_v: Value, wrmask_v: Value, colorback_v: Value, colorvram_v: Value, @@ -615,7 +637,19 @@ fn emit_pixel_write( }; // Write: (fb[addr] & !wrmask) | (result & wrmask) - let old_val = b.ins().load(types::I32, *memv, px_ptr, ir::immediates::Offset32::new(0)); + // + // Reuse the destination load above when there was one. `fb_px_raw` is the + // same address, loaded with no intervening store, so a second load fetches + // a value we already have. (Note this is only the *plane* pixel: the CID + // match test reads fb_aux at a different pointer and is a genuinely + // separate access, not part of this pair.) Cranelift's redundant-load + // elimination will not merge them itself — the loads use `memv`, the + // possibly-aliased flag, so it cannot prove nothing wrote in between. + let old_val = if needs_dst { + fb_px_raw + } else { + b.ins().load(types::I32, *memv, px_ptr, ir::immediates::Offset32::new(0)) + }; let inv_mask = b.ins().bnot(pctx.wrmask_v); let kept = b.ins().band(old_val, inv_mask); let written = b.ins().band(result_val, pctx.wrmask_v); @@ -667,23 +701,99 @@ fn emit_shader( let xsave_v = ld32!(ctx_off!(xsave)); let yend_v = ld32!(ctx_off!(yend)); let xywin_v = ld32!(ctx_off!(xywin)); - let xymove_v = ld32!(ctx_off!(xymove)); - let clipmode_v= ld32!(ctx_off!(clipmode)); let wrmask_v = ld32!(ctx_off!(wrmask)); - let colorback_v = ld32!(ctx_off!(colorback)); - let colorvram_v = ld32!(ctx_off!(colorvram)); - - // smask fields - let smask0x_v = ld32!(ctx_off!(smask0x)); - let smask0y_v = ld32!(ctx_off!(smask0y)); - let smask1x_v = ld32!(ctx_off!(smask1x)); - let smask1y_v = ld32!(ctx_off!(smask1y)); - let smask2x_v = ld32!(ctx_off!(smask2x)); - let smask2y_v = ld32!(ctx_off!(smask2y)); - let smask3x_v = ld32!(ctx_off!(smask3x)); - let smask3y_v = ld32!(ctx_off!(smask3y)); - let smask4x_v = ld32!(ctx_off!(smask4x)); - let smask4y_v = ld32!(ctx_off!(smask4y)); + + // Conditional ctx loads: the JIT key already proves whether these are used, + // so loading them unconditionally put dead loads in every shader prologue. + // A zero placeholder keeps PixelCtx's shape (it wants a Value per field) + // while emitting no memory access on the paths that never read it. + let c0_early = b.ins().iconst(types::I32, 0); + let xymove_v = if is_scr2scr || dm0.xyoffset() { + ld32!(ctx_off!(xymove)) + } else { c0_early }; + // fastclear reads colorvram; colorhost beats fastclear (see emit_pixel_write). + let colorvram_v = if dm1.fastclear() { + ld32!(ctx_off!(colorvram)) + } else { c0_early }; + // colorback feeds backblend and the opaque-pattern (zpopaque/lsopaque) select. + let colorback_v = if dm1.backblend() || dm0.zpopaque() || dm0.lsopaque() { + ld32!(ctx_off!(colorback)) + } else { c0_early }; + // Each smask pair is gated by its own ensmask bit; ensmask_key == 0 (the + // ordinary unclipped case) now loads none of the ten. + let smask0x_v = if ensmask_key & 1 != 0 { ld32!(ctx_off!(smask0x)) } else { c0_early }; + let smask0y_v = if ensmask_key & 1 != 0 { ld32!(ctx_off!(smask0y)) } else { c0_early }; + let smask1x_v = if ensmask_key & 2 != 0 { ld32!(ctx_off!(smask1x)) } else { c0_early }; + let smask1y_v = if ensmask_key & 2 != 0 { ld32!(ctx_off!(smask1y)) } else { c0_early }; + let smask2x_v = if ensmask_key & 4 != 0 { ld32!(ctx_off!(smask2x)) } else { c0_early }; + let smask2y_v = if ensmask_key & 4 != 0 { ld32!(ctx_off!(smask2y)) } else { c0_early }; + let smask3x_v = if ensmask_key & 8 != 0 { ld32!(ctx_off!(smask3x)) } else { c0_early }; + let smask3y_v = if ensmask_key & 8 != 0 { ld32!(ctx_off!(smask3y)) } else { c0_early }; + let smask4x_v = if ensmask_key & 16 != 0 { ld32!(ctx_off!(smask4x)) } else { c0_early }; + let smask4y_v = if ensmask_key & 16 != 0 { ld32!(ctx_off!(smask4y)) } else { c0_early }; + + + // Flat-shade colour, hoisted out of the pixel loop. + // + // With `!dm0.shade()` the primitive colour is constant for the whole draw, + // but the packing (3-4 loads, 3-4 clamps, shifts, ORs) used to be emitted + // inside the per-pixel body, so a flat fill re-derived the same 32-bit + // value for every pixel. Cranelift will not hoist it itself: loads are + // skeleton instructions, and its redundant-load elimination cannot prove + // the framebuffer stores do not alias `ctx` (both use the default alias + // region). Computing it once here is deterministic and costs nothing when + // `shade` is set, where the value comes from loop-carried block params + // instead and this is never emitted. + let flat_color_v: Option = if !dm0.shade() && !(is_hostw && dm0.colorhost()) { + if dm1.rgbmode() { + let r = ld32!(ctx_off!(colorred)); + let g = ld32!(ctx_off!(colorgrn)); + let bl = ld32!(ctx_off!(colorblue)); + let r_c = clamp_color_component(&mut b, r); + let g_c = clamp_color_component(&mut b, g); + let b_c = clamp_color_component(&mut b, bl); + let g8 = b.ins().ishl_imm_s(g_c, 8); + let bl16 = b.ins().ishl_imm_s(b_c, 16); + let rb = b.ins().bor(r_c, g8); + Some(b.ins().bor(rb, bl16)) + } else { + let cr = ld32!(ctx_off!(colorred)); + let c11_tmp = b.ins().iconst(types::I32, 11); + Some(b.ins().sshr(cr, c11_tmp)) + } + } else { None }; + + // Flat alpha, same reasoning: constant unless ALPHAHOST feeds it per pixel. + let flat_alpha_v: Option = if !dm0.alphahost() { + let ca = ld32!(ctx_off!(coloralpha)); + let ca_c = clamp_color_component(&mut b, ca); + Some(b.ins().ishl_imm_s(ca_c, 24)) + } else { None }; + + // Loop-invariant `ctx` inputs, hoisted to the entry block. + // + // These are pure inputs for the whole draw: `emit_writeback` stores back + // xstart/ystart, the DDA colours, zpat_bit/pat_bit and lsmode, but never + // these — so nothing the shader does can change them mid-draw. (Note the + // pairing: `lsmode` is mutated and correctly stays loop-carried, while + // `lspattern`, the mask itself, is invariant.) + // + // Cranelift will not hoist them on its own: loads are skeleton + // instructions, and its redundant-load elimination cannot prove the + // framebuffer stores do not alias `ctx`, since both use the default alias + // region. So each was re-issued per pixel. The four slope loads matter + // most — they sit directly on the DDA dependency chain. + let zpattern_hoisted_v = if dm0.enzpattern() { Some(ld32!(ctx_off!(zpattern))) } else { None }; + let lspattern_hoisted_v = if dm0.enlspattern() { Some(ld32!(ctx_off!(lspattern))) } else { None }; + let alpharef_hoisted_v = ld32!(ctx_off!(alpharef)); + let slopes_hoisted_v: Option<(Value, Value, Value, Value)> = if dm0.shade() { + Some(( + ld32!(ctx_off!(slopered)), + ld32!(ctx_off!(slopegrn)), + ld32!(ctx_off!(slopeblue)), + ld32!(ctx_off!(slopealpha)), + )) + } else { None }; // Constants let coord_bias = b.ins().iconst(types::I32, REX3_COORD_BIAS as i64); @@ -721,7 +831,7 @@ fn emit_shader( let y_inc_pos = b.ins().iconst(types::I32, y_inc_bits); let stepy_v = b.ins().select(y_dec_v, y_inc_neg, y_inc_pos); - let is_block = dm0.adrmode() << 2 == DRAWMODE0_ADRMODE_BLOCK; + let is_block = dm0.adrmode() == DRAWMODE0_ADRMODE_BLOCK; let stopony = dm0.stopony() && is_block; // span has no stopony // ── Loop blocks ─────────────────────────────────────────────────────────── @@ -991,7 +1101,7 @@ fn emit_shader( b.seal_block(pixel_block); let pctx = PixelCtx { - xywin_v, xymove_v, clipmode_v, wrmask_v, colorback_v, colorvram_v, + xywin_v, xymove_v, wrmask_v, colorback_v, colorvram_v, smask0x_v, smask0y_v, smask1x_v, smask1y_v, smask2x_v, smask2y_v, smask3x_v, smask3y_v, smask4x_v, smask4y_v, fb_rgb, fb_aux, @@ -1035,6 +1145,45 @@ fn emit_shader( ensmask_key, coord_bias, c0, c2048, ptr_type, ); + // Early transparent-pattern reject. + // + // Placement is load-bearing. It sits AFTER emit_calculate_fb_address, so + // clipped and out-of-bounds pixels have already branched to skip_block and + // the pattern test sees exactly the pixel set it saw before — that + // ordering is what a first attempt got wrong, by testing above the address + // calculation and letting scissor-rejected pixels consume a pattern + // position, which put the JIT one bit out of phase with the interpreter. + // + // It sits BEFORE the CIDMATCH block, which is the part worth skipping: that + // reads fb_aux at a second pointer, a whole extra cache line per pixel, + // and a transparent miss draws nothing so the CID answer is irrelevant. + // Everything after this point (source colour resolution, blend/logicop, the + // destination load, the write) is skipped too. + // + // Correctness of the skip edge: skip_block performs the shade DDA step and + // the zpat_bit/pat_bit/lsmode advance itself, so a pixel that leaves here + // advances exactly as one that leaves from the in-body pattern test below. + // `clip_skip_args` is the same "did not consume a host word" arg set those + // in-body pattern skips use (no_fetch_skip_args_buf). + // + // Only for a transparent miss: with ZPOPAQUE a miss still draws colorback, + // so those keep the in-body path. LSPATTERN is excluded because its miss + // handling carries the lsrcount repeat counter, and HOSTR reads rather + // than writes. + let early_zpat_reject = dm0.enzpattern() && !dm0.zpopaque() + && !dm0.enlspattern() + && !is_hostr; + if early_zpat_reject { + let zpattern_v = zpattern_hoisted_v.expect("hoisted when enzpattern"); + let zpat_bit32 = b.ins().uextend(types::I32, zpat_bit_v); + let zpat_shifted = b.ins().ushr(zpattern_v, zpat_bit32); + let bit_v = b.ins().band_imm_s(zpat_shifted, 1); + let bit_set = b.ins().icmp_imm_s(IntCC::NotEqual, bit_v, 0); + let zpat_ok = b.create_block(); + b.ins().brif(bit_set, zpat_ok, &[], skip_block, &block_args(clip_skip_args)); + b.switch_to_block(zpat_ok); b.seal_block(zpat_ok); + } + // CIDMATCH selects permitted two-bit CIDs; popup bits are unrelated. // Only emitted when cidmatch != 0xF (0xF = disabled). // Does not apply to HOSTR (READ) since that reads from fb, not writes to it. @@ -1126,20 +1275,9 @@ fn emit_shader( b.ins().bor(rb, bl16) } else if is_hostw && dm0.colorhost() { host_pixel_v - } else if dm1.rgbmode() { - let r = ld32!(ctx_off!(colorred)); - let g = ld32!(ctx_off!(colorgrn)); - let bl = ld32!(ctx_off!(colorblue)); - let r_c = clamp_color_component(&mut b, r); - let g_c = clamp_color_component(&mut b, g); - let b_c = clamp_color_component(&mut b, bl); - let g8 = b.ins().ishl_imm_s(g_c, 8); - let bl16 = b.ins().ishl_imm_s(b_c, 16); - let rb = b.ins().bor(r_c, g8); - b.ins().bor(rb, bl16) } else { - let cr = ld32!(ctx_off!(colorred)); - b.ins().sshr(cr, c11) + // Hoisted to the entry block — constant for the whole draw. + flat_color_v.expect("flat_color_v must exist when !shade && !colorhost") }; // Afunction's source alpha is "either DDA or host" (selected by ALPHAHOST), @@ -1149,9 +1287,8 @@ fn emit_shader( let alpha_byte = if dm0.alphahost() { b.ins().band_imm_s(host_pixel_v, 0xFF00_0000u64 as i64) } else { - let ca = ld32!(ctx_off!(coloralpha)); - let ca_c = clamp_color_component(&mut b, ca); - b.ins().ishl_imm_s(ca_c, 24) + // Hoisted to the entry block — constant for the whole draw. + flat_alpha_v.expect("flat_alpha_v must exist when !alphahost") }; let color24 = b.ins().band_imm_s(raw_src, 0x00FF_FFFFi64); let raw_src = b.ins().bor(color24, alpha_byte); @@ -1161,11 +1298,14 @@ fn emit_shader( b.append_block_param(draw_block, types::I8); let mut cur_use_bg: Value = b.ins().iconst(types::I8, 0); - if dm0.enzpattern() { + // Skipped when early_zpat_reject already tested this bit: same + // bit, same pixel, and nothing between the two points changes + // zpat_bit or zpattern. Re-testing would just re-emit the branch. + if dm0.enzpattern() && !early_zpat_reject { let zp_block = b.create_block(); let zp_pass = b.create_block(); b.append_block_param(zp_pass, types::I8); - let zpattern_v = ld32!(ctx_off!(zpattern)); + let zpattern_v = zpattern_hoisted_v.expect("hoisted when enzpattern"); let zpat_bit32 = b.ins().uextend(types::I32, zpat_bit_v); let zpat_shifted = b.ins().ushr(zpattern_v, zpat_bit32); let bit_v = b.ins().band_imm_s(zpat_shifted, 1); @@ -1188,7 +1328,7 @@ fn emit_shader( let ls_block = b.create_block(); let ls_pass = b.create_block(); b.append_block_param(ls_pass, types::I8); - let lspattern_v = ld32!(ctx_off!(lspattern)); + let lspattern_v = lspattern_hoisted_v.expect("hoisted when enlspattern"); let pat_bit32 = b.ins().uextend(types::I32, pat_bit_v); let lspat_shifted = b.ins().ushr(lspattern_v, pat_bit32); let bit_v = b.ins().band_imm_s(lspat_shifted, 1); @@ -1232,7 +1372,7 @@ fn emit_shader( } else { let sa = b.ins().ushr_imm_s(src_color, 24); let sa8 = b.ins().band_imm_s(sa, 0xFF); - let aref_v = ld32!(ctx_off!(alpharef)); + let aref_v = alpharef_hoisted_v; let aref8 = b.ins().band_imm_s(aref_v, 0xFF); let cc = match afunc_cmp { 1 => IntCC::UnsignedLessThan, @@ -1281,10 +1421,8 @@ fn emit_shader( // Shade DDA step let (new_cr, new_cg, new_cb, new_ca) = if dm0.shade() { - let slopered_v = ld32!(ctx_off!(slopered)); - let slopegrn_v = ld32!(ctx_off!(slopegrn)); - let slopeblue_v = ld32!(ctx_off!(slopeblue)); - let slopealpha_v = ld32!(ctx_off!(slopealpha)); + let (slopered_v, slopegrn_v, slopeblue_v, slopealpha_v) = + slopes_hoisted_v.expect("hoisted when shade"); let ncr = b.ins().iadd(colorred_v, slopered_v); let ncg = b.ins().iadd(colorgrn_v, slopegrn_v); @@ -1612,21 +1750,53 @@ fn emit_draw_iline( let xend_v = ld32!(ctx_off!(xend)); let yend_v = ld32!(ctx_off!(yend)); let xywin_v = ld32!(ctx_off!(xywin)); - let xymove_v = ld32!(ctx_off!(xymove)); - let clipmode_v= ld32!(ctx_off!(clipmode)); let wrmask_v = ld32!(ctx_off!(wrmask)); - let colorback_v = ld32!(ctx_off!(colorback)); - let colorvram_v = ld32!(ctx_off!(colorvram)); - let smask0x_v = ld32!(ctx_off!(smask0x)); - let smask0y_v = ld32!(ctx_off!(smask0y)); - let smask1x_v = ld32!(ctx_off!(smask1x)); - let smask1y_v = ld32!(ctx_off!(smask1y)); - let smask2x_v = ld32!(ctx_off!(smask2x)); - let smask2y_v = ld32!(ctx_off!(smask2y)); - let smask3x_v = ld32!(ctx_off!(smask3x)); - let smask3y_v = ld32!(ctx_off!(smask3y)); - let smask4x_v = ld32!(ctx_off!(smask4x)); - let smask4y_v = ld32!(ctx_off!(smask4y)); + + // Conditional ctx loads: the JIT key already proves whether these are used, + // so loading them unconditionally put dead loads in every shader prologue. + // A zero placeholder keeps PixelCtx's shape (it wants a Value per field) + // while emitting no memory access on the paths that never read it. + let c0_early = b.ins().iconst(types::I32, 0); + let xymove_v = if dm0.xyoffset() { + ld32!(ctx_off!(xymove)) + } else { c0_early }; + // fastclear reads colorvram; colorhost beats fastclear (see emit_pixel_write). + let colorvram_v = if dm1.fastclear() { + ld32!(ctx_off!(colorvram)) + } else { c0_early }; + // colorback feeds backblend and the opaque-pattern (zpopaque/lsopaque) select. + let colorback_v = if dm1.backblend() || dm0.zpopaque() || dm0.lsopaque() { + ld32!(ctx_off!(colorback)) + } else { c0_early }; + // Each smask pair is gated by its own ensmask bit; ensmask_key == 0 (the + // ordinary unclipped case) now loads none of the ten. + let smask0x_v = if ensmask_key & 1 != 0 { ld32!(ctx_off!(smask0x)) } else { c0_early }; + let smask0y_v = if ensmask_key & 1 != 0 { ld32!(ctx_off!(smask0y)) } else { c0_early }; + let smask1x_v = if ensmask_key & 2 != 0 { ld32!(ctx_off!(smask1x)) } else { c0_early }; + let smask1y_v = if ensmask_key & 2 != 0 { ld32!(ctx_off!(smask1y)) } else { c0_early }; + let smask2x_v = if ensmask_key & 4 != 0 { ld32!(ctx_off!(smask2x)) } else { c0_early }; + let smask2y_v = if ensmask_key & 4 != 0 { ld32!(ctx_off!(smask2y)) } else { c0_early }; + let smask3x_v = if ensmask_key & 8 != 0 { ld32!(ctx_off!(smask3x)) } else { c0_early }; + let smask3y_v = if ensmask_key & 8 != 0 { ld32!(ctx_off!(smask3y)) } else { c0_early }; + let smask4x_v = if ensmask_key & 16 != 0 { ld32!(ctx_off!(smask4x)) } else { c0_early }; + let smask4y_v = if ensmask_key & 16 != 0 { ld32!(ctx_off!(smask4y)) } else { c0_early }; + + + // Loop-invariant ctx inputs, hoisted — same reasoning as emit_shader's + // block: emit_writeback never stores these back, so they cannot change + // mid-draw, and Cranelift will not hoist loads across the framebuffer + // stores because both use the default alias region. + let zpattern_hoisted_v = if dm0.enzpattern() { Some(ld32!(ctx_off!(zpattern))) } else { None }; + let lspattern_hoisted_v = if dm0.enlspattern() { Some(ld32!(ctx_off!(lspattern))) } else { None }; + let alpharef_hoisted_v = ld32!(ctx_off!(alpharef)); + let slopes_hoisted_v: Option<(Value, Value, Value, Value)> = if dm0.shade() { + Some(( + ld32!(ctx_off!(slopered)), + ld32!(ctx_off!(slopegrn)), + ld32!(ctx_off!(slopeblue)), + ld32!(ctx_off!(slopealpha)), + )) + } else { None }; // Bresenham state from registers let bres_v = ld32!(ctx_off!(bresoctinc1)); @@ -1812,7 +1982,7 @@ fn emit_draw_iline( b.seal_block(pixel_block); let pctx = PixelCtx { - xywin_v, xymove_v, clipmode_v, wrmask_v, colorback_v, colorvram_v, + xywin_v, xymove_v, wrmask_v, colorback_v, colorvram_v, smask0x_v, smask0y_v, smask1x_v, smask1y_v, smask2x_v, smask2y_v, smask3x_v, smask3y_v, smask4x_v, smask4y_v, fb_rgb, fb_aux, @@ -1891,7 +2061,7 @@ fn emit_draw_iline( let zp_block = b.create_block(); let zp_pass = b.create_block(); b.append_block_param(zp_pass, types::I8); - let zpattern_v = ld32!(ctx_off!(zpattern)); + let zpattern_v = zpattern_hoisted_v.expect("hoisted when enzpattern"); let zpat_bit32 = b.ins().uextend(types::I32, zpat_bit_v); let zpat_shifted = b.ins().ushr(zpattern_v, zpat_bit32); let bit_v = b.ins().band_imm_s(zpat_shifted, 1); @@ -1912,7 +2082,7 @@ fn emit_draw_iline( let ls_block = b.create_block(); let ls_pass = b.create_block(); b.append_block_param(ls_pass, types::I8); - let lspattern_v = ld32!(ctx_off!(lspattern)); + let lspattern_v = lspattern_hoisted_v.expect("hoisted when enlspattern"); let pat_bit32 = b.ins().uextend(types::I32, pat_bit_v); let lspat_shifted = b.ins().ushr(lspattern_v, pat_bit32); let bit_v = b.ins().band_imm_s(lspat_shifted, 1); @@ -1947,7 +2117,7 @@ fn emit_draw_iline( } else { let sa = b.ins().ushr_imm_s(src_color, 24); let sa8 = b.ins().band_imm_s(sa, 0xFF); - let aref_v = ld32!(ctx_off!(alpharef)); + let aref_v = alpharef_hoisted_v; let aref8 = b.ins().band_imm_s(aref_v, 0xFF); let cc = match afunc_cmp { 1 => IntCC::UnsignedLessThan, @@ -1975,10 +2145,8 @@ fn emit_draw_iline( // Shade DDA step (mirrors draw_iline calling shade_fn) let (new_cr, new_cg, new_cb, new_ca) = if dm0.shade() { - let slopered_v = ld32!(ctx_off!(slopered)); - let slopegrn_v = ld32!(ctx_off!(slopegrn)); - let slopeblue_v = ld32!(ctx_off!(slopeblue)); - let slopealpha_v = ld32!(ctx_off!(slopealpha)); + let (slopered_v, slopegrn_v, slopeblue_v, slopealpha_v) = + slopes_hoisted_v.expect("hoisted when shade"); let ncr = b.ins().iadd(colorred_v, slopered_v); let ncg = b.ins().iadd(colorgrn_v, slopegrn_v); let ncb = b.ins().iadd(colorblue_v, slopeblue_v); @@ -2008,10 +2176,40 @@ fn emit_draw_iline( // Pattern advance (mirrors pattern_fn in draw_iline) — decrement, reset to // 31 on wrap (see emit_shader's identical block for the full rationale). + // + // LSADVLAST: the interpreter advances the pattern only `if !is_last || + // lsadvlast` (draw_line_bresenham, rex3.rs); the JIT advanced + // unconditionally. `advance_pattern` is the runtime predicate; when + // LSADVLAST is set it folds to a constant true and the selects below are + // optimised away. Applies to I_LINE, F_LINE and A_LINE alike, since all + // three run this shader and all three funnel through draw_line_bresenham + // on the interpreter side. + // + // UNVERIFIED AGAINST HARDWARE. This makes the JIT match our interpreter, + // which is the invariant we can actually enforce, but no test demonstrates + // an observable difference and two attempts failed to construct one: + // - DOSETUP resets pat_bit to 31, and a real connected polyline issues + // DOSETUP per segment (each segment needs its own Bresenham setup), so + // a one-bit pat_bit drift is wiped before the next segment draws. + // - The state that survives DOSETUP is lsrcount (LSREPEAT > 1 only), but + // the LSSAVE/LSRESTORE bracketing GL uses for connected stipples + // round-trips lsrcount and erases the difference too. + // MAME is no reference: newport.cpp models the stipple as a local + // `bit = 31` per draw with no persistent cursor, no lsrcount, and no + // LSADVLAST (it only logs bit 14). Spec text for bit 14 is just "Enables + // stipple advance at the end of a line" (docs/rex3.md). To be checked + // against a real XL Indy before treating either behaviour as settled. + let advance_pattern: Value = if dm0.lsadvlast() || iterate_one { + b.ins().iconst(types::I8, 1) + } else { + b.ins().icmp_imm_s(IntCC::Equal, is_last_v, 0) + }; + let new_zpat_bit = if dm0.enzpattern() { let c1_i8 = b.ins().iconst(types::I8, 1); let dec = b.ins().isub(zpat_bit_v, c1_i8); - b.ins().band_imm_s(dec, 31) + let advanced = b.ins().band_imm_s(dec, 31); + b.ins().select(advance_pattern, advanced, zpat_bit_v) } else { zpat_bit_v }; let (new_pat_bit, new_lsmode) = if dm0.enlspattern() { @@ -2039,7 +2237,13 @@ fn emit_draw_iline( let new_pb = b.ins().ireduce(types::I8, new_pat32_masked); let lsm_cleared = b.ins().band_imm_s(lsmode_v, !0xFF_i64); let new_lsm = b.ins().bor(lsm_cleared, new_count); - (new_pb, new_lsm) + // Hold both pat_bit and the lsrcount in lsmode when the advance is + // suppressed — the interpreter skips the whole pattern_fn call, which + // leaves both untouched, so suppressing only pat_bit would still drift + // the repeat counter. + let held_pb = b.ins().select(advance_pattern, new_pb, pat_bit_v); + let held_lsm = b.ins().select(advance_pattern, new_lsm, lsmode_v); + (held_pb, held_lsm) } else { (pat_bit_v, lsmode_v) }; // ── Bresenham step (mirrors bres_step! macro in draw_iline) ────────────── diff --git a/src/rex3_jit/mod.rs b/src/rex3_jit/mod.rs index 15de5674..5b802f7b 100644 --- a/src/rex3_jit/mod.rs +++ b/src/rex3_jit/mod.rs @@ -13,7 +13,7 @@ //! - DrawMode pairs seen at runtime are persisted to disk and pre-compiled on next boot. pub mod compiler; -pub mod profile; +pub use crate::rex3_profile as profile; use std::collections::{HashMap, HashSet}; use std::sync::{Arc, RwLock}; @@ -57,27 +57,74 @@ impl CompiledShader { unsafe impl Send for CompiledShader {} unsafe impl Sync for CompiledShader {} -/// Shared shader store: the RwLock-protected cache of compiled shaders. +/// What Cranelift has made of one draw shape. +/// +/// These are mutually exclusive, which is why they are an enum rather than the +/// four parallel sets this used to be (`cache` / `queued` / `failed` / `seen`). +/// Four containers keyed identically meant four hashes and four lock +/// acquisitions to answer one question, and nothing enforced that a key sat in +/// exactly one of them — `request_compile` had to probe three in order. +pub enum ShaderState { + /// Queued for compilation; no shader yet. + Queued, + /// Compiled and dispatchable. + Compiled(CompiledShader), + /// Compiled but turned off via `rex jit disable` — kept so it can be + /// re-enabled without recompiling. + Disabled(CompiledShader), + /// Cranelift declined this shape. Never retried. Not an error: the line + /// emitter has no host-pixel support, for instance — see + /// rules/rex3/line-plus-host-not-jittable.md. + Failed, +} + +impl ShaderState { + /// The compiled shader, if there is one and it is enabled. + #[inline] + fn entry(&self) -> Option<&CompiledShader> { + match self { + ShaderState::Compiled(s) => Some(s), + _ => None, + } + } + + fn label(&self) -> &'static str { + match self { + ShaderState::Queued => "queued", + ShaderState::Compiled(_) => "compiled", + ShaderState::Disabled(_) => "disabled", + ShaderState::Failed => "failed", + } + } +} + +/// Shared shader store: one map from draw shape to compilation state. +/// +/// The corpus of *seen* shapes is deliberately not here — it lives on `Rex3` +/// (`seen_shapes`), because it must be recorded in builds with no Cranelift at +/// all. Keeping a second copy here was pure duplication once that moved. pub struct ShaderStore { - pub cache: RwLock>, - /// Set of keys for which compilation has been requested (to avoid duplicate requests). - pub queued: RwLock>, - /// Set of keys that failed to compile — never retried. - pub failed: RwLock>, + pub shaders: RwLock>, } impl ShaderStore { fn new() -> Self { Self { - cache: RwLock::new(HashMap::new()), - queued: RwLock::new(HashSet::new()), - failed: RwLock::new(HashSet::new()), + shaders: RwLock::new(crate::rex3_shape::ShapeMap::default()), } } } /// The REX3 JIT subsystem. /// Constructed once per Rex3 instance; lives as long as Rex3 does. +/// Where compiled shaders are published for dispatch. +/// +/// `Rex3` owns the map and the draw path reads it; the compiler thread inserts +/// through this handle. Shared with the generated LLVM shaders — both use the +/// same ABI, so the dispatch never needs to know which produced an entry. +pub type PublishMap = + Arc>>; + pub struct RexJit { store: Arc, compile_tx: SyncSender, @@ -92,9 +139,10 @@ enum CompileRequest { impl RexJit { /// Create the JIT subsystem and start the compiler thread. /// Immediately queues all keys from the saved profile for warm-up compilation. - pub fn new() -> Self { + pub fn new(publish: PublishMap) -> Self { let store = Arc::new(ShaderStore::new()); let store_clone = Arc::clone(&store); + let publish_clone = Arc::clone(&publish); // Bounded channel: if the queue fills (many unique draw modes on first boot), // request_compile() drops new requests rather than blocking the draw thread. @@ -124,19 +172,25 @@ impl RexJit { Some((entry, code_bytes)) => { let shader = CompiledShader::new(entry, code_bytes); let count = { - let mut cache = store_clone.cache.write().unwrap(); - cache.insert((dm0, dm1, cm), shader); - cache.len() + let mut map = store_clone.shaders.write().unwrap(); + // Publish into the dispatch map too: that is + // what execute_go reads, and it is shared with + // the generated LLVM shaders. + publish_clone.write().insert((dm0, dm1, cm), entry); + map.insert((dm0, dm1, cm), ShaderState::Compiled(shader)); + map.len() }; - store_clone.queued.write().unwrap().remove(&(dm0, dm1, cm)); crate::dlog!( crate::devlog::LogModule::Rex3, "REX JIT: compiled dm0={dm0:#010x} dm1={dm1:#010x} cm={cm:#010x} ({code_bytes}B, total: {count})" ); } None => { - store_clone.queued.write().unwrap().remove(&(dm0, dm1, cm)); - store_clone.failed.write().unwrap().insert((dm0, dm1, cm)); + store_clone + .shaders + .write() + .unwrap() + .insert((dm0, dm1, cm), ShaderState::Failed); } } } @@ -160,11 +214,62 @@ impl RexJit { #[cfg(test)] let profile: Vec<(u32, u32, u32)> = Vec::new(); let warmup_count = profile.len(); - for (dm0, dm1, cm) in profile { - jit.request_compile(dm0, dm1, cm); + // Seed `seen` with everything loaded, BEFORE queueing compiles. + // + // The profile used to be written back from `cache.keys()` — only shapes + // Cranelift compiled — while `request_compile` silently drops requests + // once its 256-slot channel is full and permanently skips anything in + // `failed`. So each run rewrote the file with a subset of what it read + // and the corpus bled away across runs (observed: 160 entries decaying + // to 48). Seeding here makes the round-trip lossless: a key that was + // ever seen stays in the corpus even if this run never compiled it. + // Feed the queue from a thread: `request_compile_blocking` waits when the + // channel is full, and `RexJit::new` runs inside `Rex3::new`, so doing + // this inline would stall emulator startup behind the whole profile. + // Off-thread, a profile of any size is queued in full without dropping + // entries and without delaying boot. + { + let tx = jit.compile_tx.clone(); + let store = Arc::clone(&jit.store); + let to_queue = profile.clone(); + thread::Builder::new() + .name("rex3-jit-warmup".into()) + .spawn(move || { + for (dm0, dm1, cm) in to_queue { + // Skip anything the generated table already serves. + // Dispatch checks the shader map first, so a Cranelift + // shader for a covered shape would never be called — + // compiling it burns startup CPU (and competes with the + // guest for cores) to produce code nothing dispatches. + if crate::rex3_shaders::lookup(dm0, dm1, cm).is_some() { + continue; + } + // One lookup answers "is this already known?" — where the + // four-set version probed cache, then failed, then queued. + { + let mut map = store.shaders.write().unwrap(); + if map.contains_key(&(dm0, dm1, cm)) { + continue; + } + map.insert((dm0, dm1, cm), ShaderState::Queued); + } + if tx.send(CompileRequest::Compile(dm0, dm1, cm)).is_err() { + store.shaders.write().unwrap().remove(&(dm0, dm1, cm)); + break; // receiver gone: shutting down + } + } + }) + .expect("failed to spawn rex3-jit-warmup thread"); } + let precompiled = profile + .iter() + .filter(|(d0, d1, c)| crate::rex3_shaders::lookup(*d0, *d1, *c).is_some()) + .count(); if warmup_count > 0 { - eprintln!("REX JIT: started, queued {warmup_count} shader(s) from profile for warm-up"); + eprintln!( + "REX JIT: {} profile shape(s): {} already precompiled, {} queued for Cranelift", + warmup_count, precompiled, warmup_count - precompiled + ); } else { eprintln!("REX JIT: started (no profile — shaders will compile on first use)"); } @@ -178,81 +283,115 @@ impl RexJit { pub fn lookup(&self, dm0: u32, dm1: u32, cm: u32) -> Option { - let cache = self.store.cache.read().unwrap(); - let shader = cache.get(&(dm0, dm1, cm))?; - if shader.disabled { - return None; - } + // The corpus is recorded by `Rex3` at dispatch, not here: it has to be + // kept in builds with no Cranelift at all. + let map = self.store.shaders.read().unwrap(); + let shader = map.get(&(dm0, dm1, cm))?.entry()?; #[cfg(feature = "developer")] shader.hit_count.fetch_add(1, AtomicOrd::Relaxed); Some(shader.entry) } - /// Disable a specific compiled shader (force interpreter fallback). + /// Disable a specific compiled shader (force the generic path). pub fn disable_shader(&self, dm0: u32, dm1: u32, cm: u32) { - if let Some(shader) = self.store.cache.write().unwrap().get_mut(&(dm0, dm1, cm)) { - shader.disabled = true; + let mut map = self.store.shaders.write().unwrap(); + if let Some(st) = map.remove(&(dm0, dm1, cm)) { + let next = match st { + ShaderState::Compiled(s) => ShaderState::Disabled(s), + other => other, + }; + map.insert((dm0, dm1, cm), next); } } /// Re-enable a previously disabled shader. pub fn enable_shader(&self, dm0: u32, dm1: u32, cm: u32) { - if let Some(shader) = self.store.cache.write().unwrap().get_mut(&(dm0, dm1, cm)) { - shader.disabled = false; + let mut map = self.store.shaders.write().unwrap(); + if let Some(st) = map.remove(&(dm0, dm1, cm)) { + let next = match st { + ShaderState::Disabled(s) => ShaderState::Compiled(s), + other => other, + }; + map.insert((dm0, dm1, cm), next); } } /// Return info about all known shaders for `rex jit list` / `rex jit status`. /// status: "compiled" | "disabled" | "failed" | "queued" pub fn shader_list(&self) -> Vec { - let cache = self.store.cache.read().unwrap(); - let failed = self.store.failed.read().unwrap(); - let queued = self.store.queued.read().unwrap(); - - let mut all: std::collections::BTreeSet<(u32, u32, u32)> = cache.keys().copied().collect(); - all.extend(failed.iter().copied()); - all.extend(queued.iter().copied()); - - all.into_iter().map(|(dm0, dm1, cm)| { - if let Some(s) = cache.get(&(dm0, dm1, cm)) { - ShaderInfo { - dm0, dm1, cm, - status: if s.disabled { "disabled" } else { "compiled" }, - code_bytes: s.code_bytes, - #[cfg(feature = "developer")] - hit_count: s.hit_count.load(AtomicOrd::Relaxed), - } - } else { + let map = self.store.shaders.read().unwrap(); + // BTreeSet only to sort the output; the map itself is unordered. + let keys: std::collections::BTreeSet<(u32, u32, u32)> = map.keys().copied().collect(); + keys.into_iter() + .map(|(dm0, dm1, cm)| { + let st = &map[&(dm0, dm1, cm)]; + let (code_bytes, _hits) = match st { + ShaderState::Compiled(s) | ShaderState::Disabled(s) => { + #[cfg(feature = "developer")] + let h = s.hit_count.load(AtomicOrd::Relaxed); + #[cfg(not(feature = "developer"))] + let h = 0u64; + (s.code_bytes, h) + } + _ => (0, 0), + }; ShaderInfo { - dm0, dm1, cm, - status: if failed.contains(&(dm0, dm1, cm)) { "failed" } else { "queued" }, - code_bytes: 0, + dm0, + dm1, + cm, + status: st.label(), + code_bytes, #[cfg(feature = "developer")] - hit_count: 0, + hit_count: _hits, } - } - }).collect() + }) + .collect() } /// Request background compilation for the given (dm0, dm1, clipmode_key) triple. /// No-op if already compiled, permanently failed, or already queued. pub fn request_compile(&self, dm0: u32, dm1: u32, cm: u32) { - if self.store.cache.read().unwrap().contains_key(&(dm0, dm1, cm)) { - return; + // One lock, one lookup. Any existing entry — compiled, disabled, queued + // or failed — means there is nothing to request; the four-set version + // needed three probes in a fixed order to establish the same thing. + { + let mut map = self.store.shaders.write().unwrap(); + if map.contains_key(&(dm0, dm1, cm)) { + return; + } + map.insert((dm0, dm1, cm), ShaderState::Queued); } - if self.store.failed.read().unwrap().contains(&(dm0, dm1, cm)) { - return; + if self.compile_tx.try_send(CompileRequest::Compile(dm0, dm1, cm)).is_err() { + // A full channel did not accept this shader. Drop the Queued marker + // so a later draw retries, rather than leaving a phantom entry that + // suppresses every future request (see + // rules/testing/rex-jit-queue-retry.md). + // + // This path must not block: it runs on the GFIFO consumer thread, + // and stalling there stalls the guest. Warm-up uses + // `request_compile_blocking` instead, which can afford to wait. + self.store.shaders.write().unwrap().remove(&(dm0, dm1, cm)); } + } + + /// Queue a compile, waiting for room if the channel is full. + /// + /// Only for warm-up, which runs on its own thread before the guest is + /// drawing: blocking there costs nothing and means a profile larger than the + /// 256-slot channel is fully compiled instead of silently truncated. The + /// draw path must keep using [`Self::request_compile`]. + pub fn request_compile_blocking(&self, dm0: u32, dm1: u32, cm: u32) { { - let mut queued = self.store.queued.write().unwrap(); - if !queued.insert((dm0, dm1, cm)) { + let mut map = self.store.shaders.write().unwrap(); + if map.contains_key(&(dm0, dm1, cm)) { return; } + map.insert((dm0, dm1, cm), ShaderState::Queued); } - if self.compile_tx.try_send(CompileRequest::Compile(dm0, dm1, cm)).is_err() { - // A full queue did not accept this shader. Permit a later draw to - // retry instead of leaving the key permanently marked as queued. - self.store.queued.write().unwrap().remove(&(dm0, dm1, cm)); + // `send` blocks until the compiler thread drains a slot. It only fails + // if the receiver is gone, i.e. we are shutting down. + if self.compile_tx.send(CompileRequest::Compile(dm0, dm1, cm)).is_err() { + self.store.shaders.write().unwrap().remove(&(dm0, dm1, cm)); } } @@ -262,13 +401,18 @@ impl RexJit { pub fn wait_compiled(&self, dm0: u32, dm1: u32, cm: u32) -> bool { let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30); loop { - if self.store.cache.read().unwrap().contains_key(&(dm0, dm1, cm)) { - return true; - } - if !self.store.queued.read().unwrap().contains(&(dm0, dm1, cm)) { - eprintln!("REX JIT: wait_compiled: dm0={dm0:#010x} dm1={dm1:#010x} cm={cm:#010x} compile failed"); - return false; + match self.store.shaders.read().unwrap().get(&(dm0, dm1, cm)) { + Some(ShaderState::Compiled(_)) | Some(ShaderState::Disabled(_)) => return true, + Some(ShaderState::Failed) | None => { + // Failed, or never requested — either way it will not appear. + if self.store.shaders.read().unwrap().get(&(dm0, dm1, cm)).is_some() { + eprintln!("REX JIT: wait_compiled: dm0={dm0:#010x} dm1={dm1:#010x} cm={cm:#010x} compile failed"); + return false; + } + } + Some(ShaderState::Queued) => {} } + if std::time::Instant::now() > deadline { eprintln!("REX JIT: wait_compiled: timeout for dm0={dm0:#010x} dm1={dm1:#010x} cm={cm:#010x}"); return false; @@ -277,30 +421,37 @@ impl RexJit { } } - /// Save the set of compiled draw mode triples to the profile on disk. - pub fn save_profile(&self) { - let cache = self.store.cache.read().unwrap(); - let triples: Vec<(u32, u32, u32)> = cache.keys().copied().collect(); - drop(cache); - if let Err(e) = profile::save_profile(&triples) { - eprintln!("REX JIT: failed to save profile: {}", e); - } - } - - /// Return the number of compiled shaders in the cache. + /// Number of shapes Cranelift has compiled and can dispatch. pub fn compiled_count(&self) -> usize { - self.store.cache.read().unwrap().len() + self.store + .shaders + .read() + .unwrap() + .values() + .filter(|s| matches!(s, ShaderState::Compiled(_))) + .count() } - /// Return the number of shaders currently queued for compilation. + /// Number of shapes waiting on the compiler thread. pub fn queued_count(&self) -> usize { - self.store.queued.read().unwrap().len() + self.store + .shaders + .read() + .unwrap() + .values() + .filter(|s| matches!(s, ShaderState::Queued)) + .count() } - /// Return a sorted list of all compiled (dm0, dm1, cm) triples. + /// Sorted list of the shapes Cranelift has compiled. pub fn compiled_pairs(&self) -> Vec<(u32, u32, u32)> { - let mut triples: Vec<(u32, u32, u32)> = self.store.cache.read().unwrap().keys().copied().collect(); - triples.sort(); + let map = self.store.shaders.read().unwrap(); + let mut triples: Vec<(u32, u32, u32)> = map + .iter() + .filter(|(_, s)| matches!(s, ShaderState::Compiled(_))) + .map(|(k, _)| *k) + .collect(); + triples.sort_unstable(); triples } } diff --git a/src/rex3_jit/profile.rs b/src/rex3_profile.rs similarity index 87% rename from src/rex3_jit/profile.rs rename to src/rex3_profile.rs index c28f1287..f2c100f4 100644 --- a/src/rex3_jit/profile.rs +++ b/src/rex3_profile.rs @@ -25,8 +25,17 @@ pub fn profile_path() -> PathBuf { } } +/// Load without the informational message, for the exit-time merge. +pub fn load_profile_quiet() -> Vec<(u32, u32, u32)> { + load_profile_inner(false) +} + /// Load (dm0, dm1, clipmode_key) triples from disk. Returns empty vec on any error. pub fn load_profile() -> Vec<(u32, u32, u32)> { + load_profile_inner(true) +} + +fn load_profile_inner(verbose: bool) -> Vec<(u32, u32, u32)> { let path = profile_path(); let file = match fs::File::open(&path) { Ok(f) => f, @@ -64,7 +73,9 @@ pub fn load_profile() -> Vec<(u32, u32, u32)> { entries.push((dm0, dm1, cm)); } - eprintln!("REX JIT profile: loaded {} entries from {:?}", entries.len(), path); + if verbose { + eprintln!("REX3 corpus: loaded {} draw shapes from {:?}", entries.len(), path); + } entries } @@ -90,6 +101,7 @@ pub fn save_profile(entries: &[(u32, u32, u32)]) -> io::Result<()> { } writer.flush()?; - eprintln!("REX JIT profile: saved {} entries to {:?}", entries.len(), path); + eprintln!("REX3 corpus: saved {} draw shapes to {:?}", entries.len(), path); Ok(()) } + diff --git a/src/rex3_shaders.rs b/src/rex3_shaders.rs new file mode 100644 index 00000000..fc9be1e9 --- /dev/null +++ b/src/rex3_shaders.rs @@ -0,0 +1,24986 @@ +// @generated by tools/gen_rex3_shaders.py — do not edit. +// Source: /home/dbehr/.iris/rex-jit-profile.bin +// +// One wrapper per draw mode seen in the corpus, each instantiating the +// generic pipeline with every mode field as a compile-time constant. +// The constants are derived by calling `rex3_shape::unpack` in const +// position, so this file cannot disagree with the runtime decoder. +// +// Regenerate after collecting a fatter corpus: +// tools/gen_rex3_shaders.py -o src/rex3_shaders.rs + +use crate::rex3::Rex3Context; +use crate::rex3_generic::{draw_with_fb, ConstMode, Framebuffers}; +use crate::rex3_shape::unpack; + +/// A specialised draw entry point. +/// +/// **Identical to the Cranelift shader ABI** (`CompiledShader::entry`), so +/// an LLVM-compiled shader and a Cranelift one are interchangeable at the +/// dispatch site: `(ctx, fb_rgb, fb_aux)`, `extern "C"`. +pub type ShaderFn = unsafe extern "C" fn(*mut Rex3Context, *mut u32, *mut u32); + +/// dm0=0x00000002 dm1=0x3009d011 cm=0x00001e03 +unsafe extern "C" fn shader_00000002_3009d011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000002, 0x3009d011, 0x00001e03).opcode }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).planes }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).drawdepth }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).dblsrc }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).rgbmode }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).dither }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).logicop }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).compare }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).blend }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).backblend }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).blendalpha }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).fastclear }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).colorhost }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).alphahost }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).enzpattern }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).enlspattern }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).zpopaque }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).lsopaque }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).cidtest }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).shade }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).ciclamp }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).stoponx }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).stopony }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).skipfirst }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).skiplast }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).lsadvlast }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).length32 }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).lronly }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).ystride }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).endptfilter }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).adrmode }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).xyoffset }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).yflip }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).ensmask }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).cid_mask }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).sfactor }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).dfactor }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).rwpacked }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).hostdepth }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).rwdouble }, + { unpack(0x00000002, 0x3009d011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000002 dm1=0x3009d031 cm=0x00001e03 +unsafe extern "C" fn shader_00000002_3009d031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000002, 0x3009d031, 0x00001e03).opcode }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).planes }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).drawdepth }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).dblsrc }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).rgbmode }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).dither }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).logicop }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).compare }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).blend }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).backblend }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).blendalpha }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).fastclear }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).colorhost }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).alphahost }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).enzpattern }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).enlspattern }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).zpopaque }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).lsopaque }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).cidtest }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).shade }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).ciclamp }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).stoponx }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).stopony }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).skipfirst }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).skiplast }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).lsadvlast }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).length32 }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).lronly }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).ystride }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).endptfilter }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).adrmode }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).xyoffset }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).yflip }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).ensmask }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).cid_mask }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).sfactor }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).dfactor }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).rwpacked }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).hostdepth }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).rwdouble }, + { unpack(0x00000002, 0x3009d031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000002 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00000002_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000002, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00000002, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000002 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00000002_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000002, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00000002, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000002 dm1=0x3165d011 cm=0x00001e03 +unsafe extern "C" fn shader_00000002_3165d011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000002, 0x3165d011, 0x00001e03).opcode }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).planes }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).drawdepth }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).dblsrc }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).rgbmode }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).dither }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).logicop }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).compare }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).blend }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).backblend }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).blendalpha }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).fastclear }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).colorhost }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).alphahost }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).enzpattern }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).enlspattern }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).zpopaque }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).lsopaque }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).cidtest }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).shade }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).ciclamp }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).stoponx }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).stopony }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).skipfirst }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).skiplast }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).lsadvlast }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).length32 }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).lronly }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).ystride }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).endptfilter }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).adrmode }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).xyoffset }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).yflip }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).ensmask }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).cid_mask }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).sfactor }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).dfactor }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).rwpacked }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).hostdepth }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).rwdouble }, + { unpack(0x00000002, 0x3165d011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000002 dm1=0x3165d031 cm=0x00001e03 +unsafe extern "C" fn shader_00000002_3165d031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000002, 0x3165d031, 0x00001e03).opcode }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).planes }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).drawdepth }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).dblsrc }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).rgbmode }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).dither }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).logicop }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).compare }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).blend }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).backblend }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).blendalpha }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).fastclear }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).colorhost }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).alphahost }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).enzpattern }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).enlspattern }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).zpopaque }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).lsopaque }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).cidtest }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).shade }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).ciclamp }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).stoponx }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).stopony }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).skipfirst }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).skiplast }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).lsadvlast }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).length32 }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).lronly }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).ystride }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).endptfilter }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).adrmode }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).xyoffset }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).yflip }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).ensmask }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).cid_mask }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).sfactor }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).dfactor }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).rwpacked }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).hostdepth }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).rwdouble }, + { unpack(0x00000002, 0x3165d031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x30007109 cm=0x00001e02 +unsafe extern "C" fn shader_0000000a_30007109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x30007109, 0x00001e02).opcode }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).planes }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).drawdepth }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).dblsrc }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).rgbmode }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).dither }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).logicop }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).compare }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).blend }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).backblend }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).blendalpha }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).fastclear }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).colorhost }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).alphahost }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).enzpattern }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).enlspattern }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).zpopaque }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).lsopaque }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).cidtest }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).shade }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).ciclamp }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).stoponx }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).stopony }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).skipfirst }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).skiplast }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).lsadvlast }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).length32 }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).lronly }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).ystride }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).endptfilter }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).adrmode }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).xyoffset }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).yflip }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).ensmask }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).cid_mask }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).sfactor }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).dfactor }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).rwpacked }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).hostdepth }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).rwdouble }, + { unpack(0x0000000a, 0x30007109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x30007109 cm=0x00001e06 +unsafe extern "C" fn shader_0000000a_30007109_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x30007109, 0x00001e06).opcode }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).planes }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).drawdepth }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).dblsrc }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).rgbmode }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).dither }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).logicop }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).compare }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).blend }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).backblend }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).blendalpha }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).fastclear }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).colorhost }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).alphahost }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).enzpattern }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).enlspattern }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).zpopaque }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).lsopaque }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).cidtest }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).shade }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).ciclamp }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).stoponx }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).stopony }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).skipfirst }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).skiplast }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).lsadvlast }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).length32 }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).lronly }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).ystride }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).endptfilter }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).adrmode }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).xyoffset }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).yflip }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).ensmask }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).cid_mask }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).sfactor }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).dfactor }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).rwpacked }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).hostdepth }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).rwdouble }, + { unpack(0x0000000a, 0x30007109, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x30007109 cm=0x00001e0e +unsafe extern "C" fn shader_0000000a_30007109_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x30007109, 0x00001e0e).opcode }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).planes }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).drawdepth }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).dblsrc }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).rgbmode }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).dither }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).logicop }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).compare }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).blend }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).backblend }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).blendalpha }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).fastclear }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).colorhost }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).alphahost }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).enzpattern }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).enlspattern }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).zpopaque }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).lsopaque }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).cidtest }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).shade }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).ciclamp }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).stoponx }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).stopony }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).skipfirst }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).skiplast }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).lsadvlast }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).length32 }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).lronly }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).ystride }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).endptfilter }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).adrmode }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).xyoffset }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).yflip }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).ensmask }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).cid_mask }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).sfactor }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).dfactor }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).rwpacked }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).hostdepth }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).rwdouble }, + { unpack(0x0000000a, 0x30007109, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x30007109 cm=0x00001e1e +unsafe extern "C" fn shader_0000000a_30007109_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x30007109, 0x00001e1e).opcode }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).planes }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).drawdepth }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).dblsrc }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).rgbmode }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).dither }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).logicop }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).compare }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).blend }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).backblend }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).blendalpha }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).fastclear }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).colorhost }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).alphahost }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).enzpattern }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).enlspattern }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).zpopaque }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).lsopaque }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).cidtest }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).shade }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).ciclamp }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).stoponx }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).stopony }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).skipfirst }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).skiplast }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).lsadvlast }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).length32 }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).lronly }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).ystride }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).endptfilter }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).adrmode }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).xyoffset }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).yflip }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).ensmask }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).cid_mask }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).sfactor }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).dfactor }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).rwpacked }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).hostdepth }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).rwdouble }, + { unpack(0x0000000a, 0x30007109, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000710d cm=0x00001e02 +unsafe extern "C" fn shader_0000000a_3000710d_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000710d, 0x00001e02).opcode }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).planes }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).drawdepth }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).dblsrc }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).rgbmode }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).dither }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).logicop }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).compare }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).blend }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).backblend }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).blendalpha }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).fastclear }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).colorhost }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).alphahost }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).enzpattern }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).enlspattern }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).zpopaque }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).lsopaque }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).cidtest }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).shade }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).ciclamp }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).stoponx }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).stopony }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).skipfirst }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).skiplast }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).lsadvlast }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).length32 }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).lronly }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).ystride }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).endptfilter }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).adrmode }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).xyoffset }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).yflip }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).ensmask }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).cid_mask }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).sfactor }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).dfactor }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).rwpacked }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).hostdepth }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).rwdouble }, + { unpack(0x0000000a, 0x3000710d, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000710d cm=0x00001e1e +unsafe extern "C" fn shader_0000000a_3000710d_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).opcode }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).planes }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).drawdepth }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).dblsrc }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).rgbmode }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).dither }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).logicop }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).compare }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).blend }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).backblend }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).blendalpha }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).fastclear }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).colorhost }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).alphahost }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).enzpattern }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).enlspattern }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).zpopaque }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).lsopaque }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).cidtest }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).shade }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).ciclamp }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).stoponx }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).stopony }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).skipfirst }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).skiplast }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).lsadvlast }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).length32 }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).lronly }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).ystride }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).endptfilter }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).adrmode }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).xyoffset }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).yflip }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).ensmask }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).cid_mask }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).sfactor }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).dfactor }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).rwpacked }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).hostdepth }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).rwdouble }, + { unpack(0x0000000a, 0x3000710d, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x30007211 cm=0x00001e02 +unsafe extern "C" fn shader_0000000a_30007211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x30007211, 0x00001e02).opcode }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).planes }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).drawdepth }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).dblsrc }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).rgbmode }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).dither }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).logicop }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).compare }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).blend }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).backblend }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).blendalpha }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).fastclear }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).colorhost }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).alphahost }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).enzpattern }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).enlspattern }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).zpopaque }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).lsopaque }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).cidtest }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).shade }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).ciclamp }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).stoponx }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).stopony }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).skipfirst }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).skiplast }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).lsadvlast }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).length32 }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).lronly }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).ystride }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).endptfilter }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).adrmode }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).xyoffset }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).yflip }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).ensmask }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).cid_mask }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).sfactor }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).dfactor }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).rwpacked }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).hostdepth }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).rwdouble }, + { unpack(0x0000000a, 0x30007211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x30007211 cm=0x00001e1e +unsafe extern "C" fn shader_0000000a_30007211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x30007211, 0x00001e1e).opcode }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).planes }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).drawdepth }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).dblsrc }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).rgbmode }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).dither }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).logicop }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).compare }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).blend }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).backblend }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).blendalpha }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).fastclear }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).colorhost }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).alphahost }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).enzpattern }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).enlspattern }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).zpopaque }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).lsopaque }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).cidtest }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).shade }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).ciclamp }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).stoponx }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).stopony }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).skipfirst }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).skiplast }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).lsadvlast }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).length32 }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).lronly }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).ystride }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).endptfilter }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).adrmode }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).xyoffset }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).yflip }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).ensmask }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).cid_mask }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).sfactor }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).dfactor }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).rwpacked }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).hostdepth }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).rwdouble }, + { unpack(0x0000000a, 0x30007211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f109 cm=0x00001e02 +unsafe extern "C" fn shader_0000000a_3000f109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f109, 0x00001e02).opcode }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).planes }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).drawdepth }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).dblsrc }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).rgbmode }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).dither }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).logicop }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).compare }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).blend }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).backblend }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).blendalpha }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).fastclear }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).colorhost }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).alphahost }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).enzpattern }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).enlspattern }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).zpopaque }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).lsopaque }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).cidtest }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).shade }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).ciclamp }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).stoponx }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).stopony }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).skipfirst }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).skiplast }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).lsadvlast }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).length32 }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).lronly }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).ystride }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).endptfilter }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).adrmode }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).xyoffset }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).yflip }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).ensmask }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).cid_mask }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).sfactor }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).dfactor }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).rwpacked }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).hostdepth }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).rwdouble }, + { unpack(0x0000000a, 0x3000f109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f109 cm=0x00001e1e +unsafe extern "C" fn shader_0000000a_3000f109_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).opcode }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).planes }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).drawdepth }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).dblsrc }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).rgbmode }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).dither }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).logicop }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).compare }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).blend }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).backblend }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).blendalpha }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).fastclear }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).colorhost }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).alphahost }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).enzpattern }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).enlspattern }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).zpopaque }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).lsopaque }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).cidtest }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).shade }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).ciclamp }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).stoponx }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).stopony }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).skipfirst }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).skiplast }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).lsadvlast }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).length32 }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).lronly }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).ystride }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).endptfilter }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).adrmode }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).xyoffset }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).yflip }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).ensmask }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).cid_mask }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).sfactor }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).dfactor }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).rwpacked }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).hostdepth }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).rwdouble }, + { unpack(0x0000000a, 0x3000f109, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f211 cm=0x00001e02 +unsafe extern "C" fn shader_0000000a_3000f211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f211, 0x00001e02).opcode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).planes }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).drawdepth }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).dblsrc }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).rgbmode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).dither }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).logicop }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).compare }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).blend }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).backblend }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).blendalpha }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).fastclear }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).colorhost }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).alphahost }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).enzpattern }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).enlspattern }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).zpopaque }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).lsopaque }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).cidtest }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).shade }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).ciclamp }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).stoponx }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).stopony }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).skipfirst }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).skiplast }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).lsadvlast }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).length32 }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).lronly }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).ystride }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).endptfilter }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).adrmode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).xyoffset }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).yflip }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).ensmask }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).cid_mask }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).sfactor }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).dfactor }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).rwpacked }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).hostdepth }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).rwdouble }, + { unpack(0x0000000a, 0x3000f211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f211 cm=0x00001e06 +unsafe extern "C" fn shader_0000000a_3000f211_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f211, 0x00001e06).opcode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).planes }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).drawdepth }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).dblsrc }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).rgbmode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).dither }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).logicop }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).compare }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).blend }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).backblend }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).blendalpha }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).fastclear }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).colorhost }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).alphahost }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).enzpattern }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).enlspattern }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).zpopaque }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).lsopaque }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).cidtest }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).shade }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).ciclamp }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).stoponx }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).stopony }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).skipfirst }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).skiplast }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).lsadvlast }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).length32 }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).lronly }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).ystride }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).endptfilter }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).adrmode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).xyoffset }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).yflip }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).ensmask }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).cid_mask }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).sfactor }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).dfactor }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).rwpacked }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).hostdepth }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).rwdouble }, + { unpack(0x0000000a, 0x3000f211, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f211 cm=0x00001e0e +unsafe extern "C" fn shader_0000000a_3000f211_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).opcode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).planes }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).drawdepth }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).dblsrc }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).rgbmode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).dither }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).logicop }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).compare }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).blend }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).backblend }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).blendalpha }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).fastclear }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).colorhost }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).alphahost }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).enzpattern }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).enlspattern }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).zpopaque }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).lsopaque }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).cidtest }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).shade }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).ciclamp }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).stoponx }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).stopony }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).skipfirst }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).skiplast }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).lsadvlast }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).length32 }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).lronly }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).ystride }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).endptfilter }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).adrmode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).xyoffset }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).yflip }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).ensmask }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).cid_mask }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).sfactor }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).dfactor }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).rwpacked }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).hostdepth }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).rwdouble }, + { unpack(0x0000000a, 0x3000f211, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f211 cm=0x00001e1e +unsafe extern "C" fn shader_0000000a_3000f211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).opcode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).planes }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).drawdepth }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).dblsrc }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).rgbmode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).dither }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).logicop }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).compare }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).blend }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).backblend }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).blendalpha }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).fastclear }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).colorhost }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).alphahost }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).enzpattern }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).enlspattern }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).zpopaque }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).lsopaque }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).cidtest }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).shade }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).ciclamp }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).stoponx }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).stopony }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).skipfirst }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).skiplast }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).lsadvlast }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).length32 }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).lronly }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).ystride }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).endptfilter }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).adrmode }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).xyoffset }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).yflip }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).ensmask }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).cid_mask }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).sfactor }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).dfactor }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).rwpacked }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).hostdepth }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).rwdouble }, + { unpack(0x0000000a, 0x3000f211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f231 cm=0x00001e02 +unsafe extern "C" fn shader_0000000a_3000f231_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f231, 0x00001e02).opcode }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).planes }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).drawdepth }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).dblsrc }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).rgbmode }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).dither }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).logicop }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).compare }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).blend }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).backblend }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).blendalpha }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).fastclear }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).colorhost }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).alphahost }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).enzpattern }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).enlspattern }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).zpopaque }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).lsopaque }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).cidtest }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).shade }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).ciclamp }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).stoponx }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).stopony }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).skipfirst }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).skiplast }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).lsadvlast }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).length32 }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).lronly }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).ystride }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).endptfilter }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).adrmode }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).xyoffset }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).yflip }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).ensmask }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).cid_mask }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).sfactor }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).dfactor }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).rwpacked }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).hostdepth }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).rwdouble }, + { unpack(0x0000000a, 0x3000f231, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f231 cm=0x00001e06 +unsafe extern "C" fn shader_0000000a_3000f231_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f231, 0x00001e06).opcode }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).planes }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).drawdepth }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).dblsrc }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).rgbmode }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).dither }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).logicop }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).compare }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).blend }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).backblend }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).blendalpha }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).fastclear }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).colorhost }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).alphahost }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).enzpattern }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).enlspattern }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).zpopaque }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).lsopaque }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).cidtest }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).shade }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).ciclamp }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).stoponx }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).stopony }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).skipfirst }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).skiplast }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).lsadvlast }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).length32 }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).lronly }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).ystride }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).endptfilter }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).adrmode }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).xyoffset }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).yflip }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).ensmask }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).cid_mask }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).sfactor }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).dfactor }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).rwpacked }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).hostdepth }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).rwdouble }, + { unpack(0x0000000a, 0x3000f231, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f231 cm=0x00001e1e +unsafe extern "C" fn shader_0000000a_3000f231_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).opcode }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).planes }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).drawdepth }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).dblsrc }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).rgbmode }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).dither }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).logicop }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).compare }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).blend }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).backblend }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).blendalpha }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).fastclear }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).colorhost }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).alphahost }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).enzpattern }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).enlspattern }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).zpopaque }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).lsopaque }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).cidtest }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).shade }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).ciclamp }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).stoponx }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).stopony }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).skipfirst }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).skiplast }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).lsadvlast }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).length32 }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).lronly }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).ystride }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).endptfilter }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).adrmode }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).xyoffset }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).yflip }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).ensmask }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).cid_mask }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).sfactor }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).dfactor }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).rwpacked }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).hostdepth }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).rwdouble }, + { unpack(0x0000000a, 0x3000f231, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f319 cm=0x00001e02 +unsafe extern "C" fn shader_0000000a_3000f319_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f319, 0x00001e02).opcode }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).planes }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).drawdepth }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).dblsrc }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).rgbmode }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).dither }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).logicop }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).compare }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).blend }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).backblend }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).blendalpha }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).fastclear }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).colorhost }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).alphahost }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).enzpattern }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).enlspattern }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).zpopaque }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).lsopaque }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).cidtest }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).shade }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).ciclamp }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).stoponx }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).stopony }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).skipfirst }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).skiplast }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).lsadvlast }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).length32 }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).lronly }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).ystride }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).endptfilter }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).adrmode }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).xyoffset }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).yflip }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).ensmask }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).cid_mask }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).sfactor }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).dfactor }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).rwpacked }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).hostdepth }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).rwdouble }, + { unpack(0x0000000a, 0x3000f319, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3000f319 cm=0x00001e0e +unsafe extern "C" fn shader_0000000a_3000f319_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).opcode }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).planes }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).drawdepth }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).dblsrc }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).rgbmode }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).dither }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).logicop }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).compare }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).blend }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).backblend }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).blendalpha }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).fastclear }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).colorhost }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).alphahost }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).enzpattern }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).enlspattern }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).zpopaque }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).lsopaque }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).cidtest }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).shade }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).ciclamp }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).stoponx }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).stopony }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).skipfirst }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).skiplast }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).lsadvlast }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).length32 }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).lronly }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).ystride }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).endptfilter }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).adrmode }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).xyoffset }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).yflip }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).ensmask }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).cid_mask }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).sfactor }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).dfactor }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).rwpacked }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).hostdepth }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).rwdouble }, + { unpack(0x0000000a, 0x3000f319, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_0000000a_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).planes }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).dither }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).compare }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).blend }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).shade }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x0000000a, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_0000000a_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).planes }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).dither }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).compare }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).blend }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).shade }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x0000000a, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_0000000a_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).planes }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).dither }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).compare }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).blend }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).shade }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x0000000a, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3161f031 cm=0x00000203 +unsafe extern "C" fn shader_0000000a_3161f031_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3161f031, 0x00000203).opcode }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).planes }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).drawdepth }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).dblsrc }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).rgbmode }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).dither }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).logicop }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).compare }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).blend }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).backblend }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).blendalpha }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).fastclear }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).colorhost }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).alphahost }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).enzpattern }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).enlspattern }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).zpopaque }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).lsopaque }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).cidtest }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).shade }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).ciclamp }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).stoponx }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).stopony }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).skipfirst }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).skiplast }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).lsadvlast }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).length32 }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).lronly }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).ystride }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).endptfilter }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).adrmode }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).xyoffset }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).yflip }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).ensmask }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).cid_mask }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).sfactor }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).dfactor }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).rwpacked }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).hostdepth }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).rwdouble }, + { unpack(0x0000000a, 0x3161f031, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_0000000a_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).planes }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).dither }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).compare }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).blend }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).shade }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x0000000a, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_0000000a_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).planes }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).dither }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).compare }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).blend }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).shade }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x0000000a, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000000a dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_0000000a_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000000a, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).planes }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).dither }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).compare }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).blend }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).shade }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x0000000a, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000022 dm1=0x3065f011 cm=0x00001e03 +unsafe extern "C" fn shader_00000022_3065f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000022, 0x3065f011, 0x00001e03).opcode }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).planes }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).drawdepth }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).dblsrc }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).rgbmode }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).dither }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).logicop }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).compare }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).blend }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).backblend }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).blendalpha }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).fastclear }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).colorhost }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).alphahost }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).enzpattern }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).enlspattern }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).zpopaque }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).lsopaque }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).cidtest }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).shade }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).ciclamp }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).stoponx }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).stopony }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).skipfirst }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).skiplast }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).lsadvlast }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).length32 }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).lronly }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).ystride }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).endptfilter }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).adrmode }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).xyoffset }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).yflip }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).ensmask }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).cid_mask }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).sfactor }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).dfactor }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).rwpacked }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).hostdepth }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).rwdouble }, + { unpack(0x00000022, 0x3065f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000022 dm1=0x3065f031 cm=0x00001e03 +unsafe extern "C" fn shader_00000022_3065f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000022, 0x3065f031, 0x00001e03).opcode }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).planes }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).drawdepth }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).dblsrc }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).rgbmode }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).dither }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).logicop }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).compare }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).blend }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).backblend }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).blendalpha }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).fastclear }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).colorhost }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).alphahost }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).enzpattern }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).enlspattern }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).zpopaque }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).lsopaque }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).cidtest }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).shade }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).ciclamp }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).stoponx }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).stopony }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).skipfirst }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).skiplast }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).lsadvlast }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).length32 }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).lronly }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).ystride }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).endptfilter }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).adrmode }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).xyoffset }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).yflip }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).ensmask }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).cid_mask }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).sfactor }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).dfactor }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).rwpacked }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).hostdepth }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).rwdouble }, + { unpack(0x00000022, 0x3065f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000022 dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_00000022_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000022, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).planes }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).dither }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).compare }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).blend }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).shade }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x00000022, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000045 dm1=0x04007189 cm=0x00001e00 +unsafe extern "C" fn shader_00000045_04007189_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000045, 0x04007189, 0x00001e00).opcode }, + { unpack(0x00000045, 0x04007189, 0x00001e00).planes }, + { unpack(0x00000045, 0x04007189, 0x00001e00).drawdepth }, + { unpack(0x00000045, 0x04007189, 0x00001e00).dblsrc }, + { unpack(0x00000045, 0x04007189, 0x00001e00).rgbmode }, + { unpack(0x00000045, 0x04007189, 0x00001e00).dither }, + { unpack(0x00000045, 0x04007189, 0x00001e00).logicop }, + { unpack(0x00000045, 0x04007189, 0x00001e00).compare }, + { unpack(0x00000045, 0x04007189, 0x00001e00).blend }, + { unpack(0x00000045, 0x04007189, 0x00001e00).backblend }, + { unpack(0x00000045, 0x04007189, 0x00001e00).blendalpha }, + { unpack(0x00000045, 0x04007189, 0x00001e00).fastclear }, + { unpack(0x00000045, 0x04007189, 0x00001e00).colorhost }, + { unpack(0x00000045, 0x04007189, 0x00001e00).alphahost }, + { unpack(0x00000045, 0x04007189, 0x00001e00).enzpattern }, + { unpack(0x00000045, 0x04007189, 0x00001e00).enlspattern }, + { unpack(0x00000045, 0x04007189, 0x00001e00).zpopaque }, + { unpack(0x00000045, 0x04007189, 0x00001e00).lsopaque }, + { unpack(0x00000045, 0x04007189, 0x00001e00).cidtest }, + { unpack(0x00000045, 0x04007189, 0x00001e00).shade }, + { unpack(0x00000045, 0x04007189, 0x00001e00).ciclamp }, + { unpack(0x00000045, 0x04007189, 0x00001e00).stoponx }, + { unpack(0x00000045, 0x04007189, 0x00001e00).stopony }, + { unpack(0x00000045, 0x04007189, 0x00001e00).skipfirst }, + { unpack(0x00000045, 0x04007189, 0x00001e00).skiplast }, + { unpack(0x00000045, 0x04007189, 0x00001e00).lsadvlast }, + { unpack(0x00000045, 0x04007189, 0x00001e00).length32 }, + { unpack(0x00000045, 0x04007189, 0x00001e00).lronly }, + { unpack(0x00000045, 0x04007189, 0x00001e00).ystride }, + { unpack(0x00000045, 0x04007189, 0x00001e00).endptfilter }, + { unpack(0x00000045, 0x04007189, 0x00001e00).adrmode }, + { unpack(0x00000045, 0x04007189, 0x00001e00).xyoffset }, + { unpack(0x00000045, 0x04007189, 0x00001e00).yflip }, + { unpack(0x00000045, 0x04007189, 0x00001e00).ensmask }, + { unpack(0x00000045, 0x04007189, 0x00001e00).cid_mask }, + { unpack(0x00000045, 0x04007189, 0x00001e00).sfactor }, + { unpack(0x00000045, 0x04007189, 0x00001e00).dfactor }, + { unpack(0x00000045, 0x04007189, 0x00001e00).rwpacked }, + { unpack(0x00000045, 0x04007189, 0x00001e00).hostdepth }, + { unpack(0x00000045, 0x04007189, 0x00001e00).rwdouble }, + { unpack(0x00000045, 0x04007189, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000045 dm1=0x0400718d cm=0x00001e00 +unsafe extern "C" fn shader_00000045_0400718d_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000045, 0x0400718d, 0x00001e00).opcode }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).planes }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).drawdepth }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).dblsrc }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).rgbmode }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).dither }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).logicop }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).compare }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).blend }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).backblend }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).blendalpha }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).fastclear }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).colorhost }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).alphahost }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).enzpattern }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).enlspattern }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).zpopaque }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).lsopaque }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).cidtest }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).shade }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).ciclamp }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).stoponx }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).stopony }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).skipfirst }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).skiplast }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).lsadvlast }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).length32 }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).lronly }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).ystride }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).endptfilter }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).adrmode }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).xyoffset }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).yflip }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).ensmask }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).cid_mask }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).sfactor }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).dfactor }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).rwpacked }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).hostdepth }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).rwdouble }, + { unpack(0x00000045, 0x0400718d, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000045 dm1=0x0400f189 cm=0x00001e00 +unsafe extern "C" fn shader_00000045_0400f189_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000045, 0x0400f189, 0x00001e00).opcode }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).planes }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).drawdepth }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).dblsrc }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).rgbmode }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).dither }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).logicop }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).compare }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).blend }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).backblend }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).blendalpha }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).fastclear }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).colorhost }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).alphahost }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).enzpattern }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).enlspattern }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).zpopaque }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).lsopaque }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).cidtest }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).shade }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).ciclamp }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).stoponx }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).stopony }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).skipfirst }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).skiplast }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).lsadvlast }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).length32 }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).lronly }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).ystride }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).endptfilter }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).adrmode }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).xyoffset }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).yflip }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).ensmask }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).cid_mask }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).sfactor }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).dfactor }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).rwpacked }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).hostdepth }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).rwdouble }, + { unpack(0x00000045, 0x0400f189, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000045 dm1=0x0400f291 cm=0x00001e00 +unsafe extern "C" fn shader_00000045_0400f291_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000045, 0x0400f291, 0x00001e00).opcode }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).planes }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).drawdepth }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).dblsrc }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).rgbmode }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).dither }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).logicop }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).compare }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).blend }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).backblend }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).blendalpha }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).fastclear }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).colorhost }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).alphahost }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).enzpattern }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).enlspattern }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).zpopaque }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).lsopaque }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).cidtest }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).shade }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).ciclamp }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).stoponx }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).stopony }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).skipfirst }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).skiplast }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).lsadvlast }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).length32 }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).lronly }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).ystride }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).endptfilter }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).adrmode }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).xyoffset }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).yflip }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).ensmask }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).cid_mask }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).sfactor }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).dfactor }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).rwpacked }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).hostdepth }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).rwdouble }, + { unpack(0x00000045, 0x0400f291, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000045 dm1=0x0400f399 cm=0x00001e00 +unsafe extern "C" fn shader_00000045_0400f399_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000045, 0x0400f399, 0x00001e00).opcode }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).planes }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).drawdepth }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).dblsrc }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).rgbmode }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).dither }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).logicop }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).compare }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).blend }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).backblend }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).blendalpha }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).fastclear }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).colorhost }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).alphahost }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).enzpattern }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).enlspattern }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).zpopaque }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).lsopaque }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).cidtest }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).shade }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).ciclamp }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).stoponx }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).stopony }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).skipfirst }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).skiplast }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).lsadvlast }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).length32 }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).lronly }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).ystride }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).endptfilter }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).adrmode }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).xyoffset }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).yflip }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).ensmask }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).cid_mask }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).sfactor }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).dfactor }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).rwpacked }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).hostdepth }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).rwdouble }, + { unpack(0x00000045, 0x0400f399, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000045 dm1=0x34007291 cm=0x00001e00 +unsafe extern "C" fn shader_00000045_34007291_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000045, 0x34007291, 0x00001e00).opcode }, + { unpack(0x00000045, 0x34007291, 0x00001e00).planes }, + { unpack(0x00000045, 0x34007291, 0x00001e00).drawdepth }, + { unpack(0x00000045, 0x34007291, 0x00001e00).dblsrc }, + { unpack(0x00000045, 0x34007291, 0x00001e00).rgbmode }, + { unpack(0x00000045, 0x34007291, 0x00001e00).dither }, + { unpack(0x00000045, 0x34007291, 0x00001e00).logicop }, + { unpack(0x00000045, 0x34007291, 0x00001e00).compare }, + { unpack(0x00000045, 0x34007291, 0x00001e00).blend }, + { unpack(0x00000045, 0x34007291, 0x00001e00).backblend }, + { unpack(0x00000045, 0x34007291, 0x00001e00).blendalpha }, + { unpack(0x00000045, 0x34007291, 0x00001e00).fastclear }, + { unpack(0x00000045, 0x34007291, 0x00001e00).colorhost }, + { unpack(0x00000045, 0x34007291, 0x00001e00).alphahost }, + { unpack(0x00000045, 0x34007291, 0x00001e00).enzpattern }, + { unpack(0x00000045, 0x34007291, 0x00001e00).enlspattern }, + { unpack(0x00000045, 0x34007291, 0x00001e00).zpopaque }, + { unpack(0x00000045, 0x34007291, 0x00001e00).lsopaque }, + { unpack(0x00000045, 0x34007291, 0x00001e00).cidtest }, + { unpack(0x00000045, 0x34007291, 0x00001e00).shade }, + { unpack(0x00000045, 0x34007291, 0x00001e00).ciclamp }, + { unpack(0x00000045, 0x34007291, 0x00001e00).stoponx }, + { unpack(0x00000045, 0x34007291, 0x00001e00).stopony }, + { unpack(0x00000045, 0x34007291, 0x00001e00).skipfirst }, + { unpack(0x00000045, 0x34007291, 0x00001e00).skiplast }, + { unpack(0x00000045, 0x34007291, 0x00001e00).lsadvlast }, + { unpack(0x00000045, 0x34007291, 0x00001e00).length32 }, + { unpack(0x00000045, 0x34007291, 0x00001e00).lronly }, + { unpack(0x00000045, 0x34007291, 0x00001e00).ystride }, + { unpack(0x00000045, 0x34007291, 0x00001e00).endptfilter }, + { unpack(0x00000045, 0x34007291, 0x00001e00).adrmode }, + { unpack(0x00000045, 0x34007291, 0x00001e00).xyoffset }, + { unpack(0x00000045, 0x34007291, 0x00001e00).yflip }, + { unpack(0x00000045, 0x34007291, 0x00001e00).ensmask }, + { unpack(0x00000045, 0x34007291, 0x00001e00).cid_mask }, + { unpack(0x00000045, 0x34007291, 0x00001e00).sfactor }, + { unpack(0x00000045, 0x34007291, 0x00001e00).dfactor }, + { unpack(0x00000045, 0x34007291, 0x00001e00).rwpacked }, + { unpack(0x00000045, 0x34007291, 0x00001e00).hostdepth }, + { unpack(0x00000045, 0x34007291, 0x00001e00).rwdouble }, + { unpack(0x00000045, 0x34007291, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000046 dm1=0x30007189 cm=0x00001e00 +unsafe extern "C" fn shader_00000046_30007189_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000046, 0x30007189, 0x00001e00).opcode }, + { unpack(0x00000046, 0x30007189, 0x00001e00).planes }, + { unpack(0x00000046, 0x30007189, 0x00001e00).drawdepth }, + { unpack(0x00000046, 0x30007189, 0x00001e00).dblsrc }, + { unpack(0x00000046, 0x30007189, 0x00001e00).rgbmode }, + { unpack(0x00000046, 0x30007189, 0x00001e00).dither }, + { unpack(0x00000046, 0x30007189, 0x00001e00).logicop }, + { unpack(0x00000046, 0x30007189, 0x00001e00).compare }, + { unpack(0x00000046, 0x30007189, 0x00001e00).blend }, + { unpack(0x00000046, 0x30007189, 0x00001e00).backblend }, + { unpack(0x00000046, 0x30007189, 0x00001e00).blendalpha }, + { unpack(0x00000046, 0x30007189, 0x00001e00).fastclear }, + { unpack(0x00000046, 0x30007189, 0x00001e00).colorhost }, + { unpack(0x00000046, 0x30007189, 0x00001e00).alphahost }, + { unpack(0x00000046, 0x30007189, 0x00001e00).enzpattern }, + { unpack(0x00000046, 0x30007189, 0x00001e00).enlspattern }, + { unpack(0x00000046, 0x30007189, 0x00001e00).zpopaque }, + { unpack(0x00000046, 0x30007189, 0x00001e00).lsopaque }, + { unpack(0x00000046, 0x30007189, 0x00001e00).cidtest }, + { unpack(0x00000046, 0x30007189, 0x00001e00).shade }, + { unpack(0x00000046, 0x30007189, 0x00001e00).ciclamp }, + { unpack(0x00000046, 0x30007189, 0x00001e00).stoponx }, + { unpack(0x00000046, 0x30007189, 0x00001e00).stopony }, + { unpack(0x00000046, 0x30007189, 0x00001e00).skipfirst }, + { unpack(0x00000046, 0x30007189, 0x00001e00).skiplast }, + { unpack(0x00000046, 0x30007189, 0x00001e00).lsadvlast }, + { unpack(0x00000046, 0x30007189, 0x00001e00).length32 }, + { unpack(0x00000046, 0x30007189, 0x00001e00).lronly }, + { unpack(0x00000046, 0x30007189, 0x00001e00).ystride }, + { unpack(0x00000046, 0x30007189, 0x00001e00).endptfilter }, + { unpack(0x00000046, 0x30007189, 0x00001e00).adrmode }, + { unpack(0x00000046, 0x30007189, 0x00001e00).xyoffset }, + { unpack(0x00000046, 0x30007189, 0x00001e00).yflip }, + { unpack(0x00000046, 0x30007189, 0x00001e00).ensmask }, + { unpack(0x00000046, 0x30007189, 0x00001e00).cid_mask }, + { unpack(0x00000046, 0x30007189, 0x00001e00).sfactor }, + { unpack(0x00000046, 0x30007189, 0x00001e00).dfactor }, + { unpack(0x00000046, 0x30007189, 0x00001e00).rwpacked }, + { unpack(0x00000046, 0x30007189, 0x00001e00).hostdepth }, + { unpack(0x00000046, 0x30007189, 0x00001e00).rwdouble }, + { unpack(0x00000046, 0x30007189, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000046 dm1=0x3000718d cm=0x00001e00 +unsafe extern "C" fn shader_00000046_3000718d_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000046, 0x3000718d, 0x00001e00).opcode }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).planes }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).drawdepth }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).dblsrc }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).rgbmode }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).dither }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).logicop }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).compare }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).blend }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).backblend }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).blendalpha }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).fastclear }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).colorhost }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).alphahost }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).enzpattern }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).enlspattern }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).zpopaque }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).lsopaque }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).cidtest }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).shade }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).ciclamp }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).stoponx }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).stopony }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).skipfirst }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).skiplast }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).lsadvlast }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).length32 }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).lronly }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).ystride }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).endptfilter }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).adrmode }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).xyoffset }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).yflip }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).ensmask }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).cid_mask }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).sfactor }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).dfactor }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).rwpacked }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).hostdepth }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).rwdouble }, + { unpack(0x00000046, 0x3000718d, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000046 dm1=0x30007589 cm=0x00001e00 +unsafe extern "C" fn shader_00000046_30007589_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000046, 0x30007589, 0x00001e00).opcode }, + { unpack(0x00000046, 0x30007589, 0x00001e00).planes }, + { unpack(0x00000046, 0x30007589, 0x00001e00).drawdepth }, + { unpack(0x00000046, 0x30007589, 0x00001e00).dblsrc }, + { unpack(0x00000046, 0x30007589, 0x00001e00).rgbmode }, + { unpack(0x00000046, 0x30007589, 0x00001e00).dither }, + { unpack(0x00000046, 0x30007589, 0x00001e00).logicop }, + { unpack(0x00000046, 0x30007589, 0x00001e00).compare }, + { unpack(0x00000046, 0x30007589, 0x00001e00).blend }, + { unpack(0x00000046, 0x30007589, 0x00001e00).backblend }, + { unpack(0x00000046, 0x30007589, 0x00001e00).blendalpha }, + { unpack(0x00000046, 0x30007589, 0x00001e00).fastclear }, + { unpack(0x00000046, 0x30007589, 0x00001e00).colorhost }, + { unpack(0x00000046, 0x30007589, 0x00001e00).alphahost }, + { unpack(0x00000046, 0x30007589, 0x00001e00).enzpattern }, + { unpack(0x00000046, 0x30007589, 0x00001e00).enlspattern }, + { unpack(0x00000046, 0x30007589, 0x00001e00).zpopaque }, + { unpack(0x00000046, 0x30007589, 0x00001e00).lsopaque }, + { unpack(0x00000046, 0x30007589, 0x00001e00).cidtest }, + { unpack(0x00000046, 0x30007589, 0x00001e00).shade }, + { unpack(0x00000046, 0x30007589, 0x00001e00).ciclamp }, + { unpack(0x00000046, 0x30007589, 0x00001e00).stoponx }, + { unpack(0x00000046, 0x30007589, 0x00001e00).stopony }, + { unpack(0x00000046, 0x30007589, 0x00001e00).skipfirst }, + { unpack(0x00000046, 0x30007589, 0x00001e00).skiplast }, + { unpack(0x00000046, 0x30007589, 0x00001e00).lsadvlast }, + { unpack(0x00000046, 0x30007589, 0x00001e00).length32 }, + { unpack(0x00000046, 0x30007589, 0x00001e00).lronly }, + { unpack(0x00000046, 0x30007589, 0x00001e00).ystride }, + { unpack(0x00000046, 0x30007589, 0x00001e00).endptfilter }, + { unpack(0x00000046, 0x30007589, 0x00001e00).adrmode }, + { unpack(0x00000046, 0x30007589, 0x00001e00).xyoffset }, + { unpack(0x00000046, 0x30007589, 0x00001e00).yflip }, + { unpack(0x00000046, 0x30007589, 0x00001e00).ensmask }, + { unpack(0x00000046, 0x30007589, 0x00001e00).cid_mask }, + { unpack(0x00000046, 0x30007589, 0x00001e00).sfactor }, + { unpack(0x00000046, 0x30007589, 0x00001e00).dfactor }, + { unpack(0x00000046, 0x30007589, 0x00001e00).rwpacked }, + { unpack(0x00000046, 0x30007589, 0x00001e00).hostdepth }, + { unpack(0x00000046, 0x30007589, 0x00001e00).rwdouble }, + { unpack(0x00000046, 0x30007589, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000046 dm1=0x30007691 cm=0x00001e00 +unsafe extern "C" fn shader_00000046_30007691_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000046, 0x30007691, 0x00001e00).opcode }, + { unpack(0x00000046, 0x30007691, 0x00001e00).planes }, + { unpack(0x00000046, 0x30007691, 0x00001e00).drawdepth }, + { unpack(0x00000046, 0x30007691, 0x00001e00).dblsrc }, + { unpack(0x00000046, 0x30007691, 0x00001e00).rgbmode }, + { unpack(0x00000046, 0x30007691, 0x00001e00).dither }, + { unpack(0x00000046, 0x30007691, 0x00001e00).logicop }, + { unpack(0x00000046, 0x30007691, 0x00001e00).compare }, + { unpack(0x00000046, 0x30007691, 0x00001e00).blend }, + { unpack(0x00000046, 0x30007691, 0x00001e00).backblend }, + { unpack(0x00000046, 0x30007691, 0x00001e00).blendalpha }, + { unpack(0x00000046, 0x30007691, 0x00001e00).fastclear }, + { unpack(0x00000046, 0x30007691, 0x00001e00).colorhost }, + { unpack(0x00000046, 0x30007691, 0x00001e00).alphahost }, + { unpack(0x00000046, 0x30007691, 0x00001e00).enzpattern }, + { unpack(0x00000046, 0x30007691, 0x00001e00).enlspattern }, + { unpack(0x00000046, 0x30007691, 0x00001e00).zpopaque }, + { unpack(0x00000046, 0x30007691, 0x00001e00).lsopaque }, + { unpack(0x00000046, 0x30007691, 0x00001e00).cidtest }, + { unpack(0x00000046, 0x30007691, 0x00001e00).shade }, + { unpack(0x00000046, 0x30007691, 0x00001e00).ciclamp }, + { unpack(0x00000046, 0x30007691, 0x00001e00).stoponx }, + { unpack(0x00000046, 0x30007691, 0x00001e00).stopony }, + { unpack(0x00000046, 0x30007691, 0x00001e00).skipfirst }, + { unpack(0x00000046, 0x30007691, 0x00001e00).skiplast }, + { unpack(0x00000046, 0x30007691, 0x00001e00).lsadvlast }, + { unpack(0x00000046, 0x30007691, 0x00001e00).length32 }, + { unpack(0x00000046, 0x30007691, 0x00001e00).lronly }, + { unpack(0x00000046, 0x30007691, 0x00001e00).ystride }, + { unpack(0x00000046, 0x30007691, 0x00001e00).endptfilter }, + { unpack(0x00000046, 0x30007691, 0x00001e00).adrmode }, + { unpack(0x00000046, 0x30007691, 0x00001e00).xyoffset }, + { unpack(0x00000046, 0x30007691, 0x00001e00).yflip }, + { unpack(0x00000046, 0x30007691, 0x00001e00).ensmask }, + { unpack(0x00000046, 0x30007691, 0x00001e00).cid_mask }, + { unpack(0x00000046, 0x30007691, 0x00001e00).sfactor }, + { unpack(0x00000046, 0x30007691, 0x00001e00).dfactor }, + { unpack(0x00000046, 0x30007691, 0x00001e00).rwpacked }, + { unpack(0x00000046, 0x30007691, 0x00001e00).hostdepth }, + { unpack(0x00000046, 0x30007691, 0x00001e00).rwdouble }, + { unpack(0x00000046, 0x30007691, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000046 dm1=0x3000f189 cm=0x00001e00 +unsafe extern "C" fn shader_00000046_3000f189_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000046, 0x3000f189, 0x00001e00).opcode }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).planes }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).drawdepth }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).dblsrc }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).rgbmode }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).dither }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).logicop }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).compare }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).blend }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).backblend }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).blendalpha }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).fastclear }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).colorhost }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).alphahost }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).enzpattern }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).enlspattern }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).zpopaque }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).lsopaque }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).cidtest }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).shade }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).ciclamp }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).stoponx }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).stopony }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).skipfirst }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).skiplast }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).lsadvlast }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).length32 }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).lronly }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).ystride }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).endptfilter }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).adrmode }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).xyoffset }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).yflip }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).ensmask }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).cid_mask }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).sfactor }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).dfactor }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).rwpacked }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).hostdepth }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).rwdouble }, + { unpack(0x00000046, 0x3000f189, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000046 dm1=0x3000f291 cm=0x00001e00 +unsafe extern "C" fn shader_00000046_3000f291_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000046, 0x3000f291, 0x00001e00).opcode }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).planes }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).drawdepth }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).dblsrc }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).rgbmode }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).dither }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).logicop }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).compare }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).blend }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).backblend }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).blendalpha }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).fastclear }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).colorhost }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).alphahost }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).enzpattern }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).enlspattern }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).zpopaque }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).lsopaque }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).cidtest }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).shade }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).ciclamp }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).stoponx }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).stopony }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).skipfirst }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).skiplast }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).lsadvlast }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).length32 }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).lronly }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).ystride }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).endptfilter }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).adrmode }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).xyoffset }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).yflip }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).ensmask }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).cid_mask }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).sfactor }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).dfactor }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).rwpacked }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).hostdepth }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).rwdouble }, + { unpack(0x00000046, 0x3000f291, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000046 dm1=0x3000f399 cm=0x00001e00 +unsafe extern "C" fn shader_00000046_3000f399_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000046, 0x3000f399, 0x00001e00).opcode }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).planes }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).drawdepth }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).dblsrc }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).rgbmode }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).dither }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).logicop }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).compare }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).blend }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).backblend }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).blendalpha }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).fastclear }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).colorhost }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).alphahost }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).enzpattern }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).enlspattern }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).zpopaque }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).lsopaque }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).cidtest }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).shade }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).ciclamp }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).stoponx }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).stopony }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).skipfirst }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).skiplast }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).lsadvlast }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).length32 }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).lronly }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).ystride }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).endptfilter }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).adrmode }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).xyoffset }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).yflip }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).ensmask }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).cid_mask }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).sfactor }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).dfactor }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).rwpacked }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).hostdepth }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).rwdouble }, + { unpack(0x00000046, 0x3000f399, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000046 dm1=0x3000f799 cm=0x00001e00 +unsafe extern "C" fn shader_00000046_3000f799_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000046, 0x3000f799, 0x00001e00).opcode }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).planes }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).drawdepth }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).dblsrc }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).rgbmode }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).dither }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).logicop }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).compare }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).blend }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).backblend }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).blendalpha }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).fastclear }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).colorhost }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).alphahost }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).enzpattern }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).enlspattern }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).zpopaque }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).lsopaque }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).cidtest }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).shade }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).ciclamp }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).stoponx }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).stopony }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).skipfirst }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).skiplast }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).lsadvlast }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).length32 }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).lronly }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).ystride }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).endptfilter }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).adrmode }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).xyoffset }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).yflip }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).ensmask }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).cid_mask }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).sfactor }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).dfactor }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).rwpacked }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).hostdepth }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).rwdouble }, + { unpack(0x00000046, 0x3000f799, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000046 dm1=0x34007291 cm=0x00001e00 +unsafe extern "C" fn shader_00000046_34007291_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000046, 0x34007291, 0x00001e00).opcode }, + { unpack(0x00000046, 0x34007291, 0x00001e00).planes }, + { unpack(0x00000046, 0x34007291, 0x00001e00).drawdepth }, + { unpack(0x00000046, 0x34007291, 0x00001e00).dblsrc }, + { unpack(0x00000046, 0x34007291, 0x00001e00).rgbmode }, + { unpack(0x00000046, 0x34007291, 0x00001e00).dither }, + { unpack(0x00000046, 0x34007291, 0x00001e00).logicop }, + { unpack(0x00000046, 0x34007291, 0x00001e00).compare }, + { unpack(0x00000046, 0x34007291, 0x00001e00).blend }, + { unpack(0x00000046, 0x34007291, 0x00001e00).backblend }, + { unpack(0x00000046, 0x34007291, 0x00001e00).blendalpha }, + { unpack(0x00000046, 0x34007291, 0x00001e00).fastclear }, + { unpack(0x00000046, 0x34007291, 0x00001e00).colorhost }, + { unpack(0x00000046, 0x34007291, 0x00001e00).alphahost }, + { unpack(0x00000046, 0x34007291, 0x00001e00).enzpattern }, + { unpack(0x00000046, 0x34007291, 0x00001e00).enlspattern }, + { unpack(0x00000046, 0x34007291, 0x00001e00).zpopaque }, + { unpack(0x00000046, 0x34007291, 0x00001e00).lsopaque }, + { unpack(0x00000046, 0x34007291, 0x00001e00).cidtest }, + { unpack(0x00000046, 0x34007291, 0x00001e00).shade }, + { unpack(0x00000046, 0x34007291, 0x00001e00).ciclamp }, + { unpack(0x00000046, 0x34007291, 0x00001e00).stoponx }, + { unpack(0x00000046, 0x34007291, 0x00001e00).stopony }, + { unpack(0x00000046, 0x34007291, 0x00001e00).skipfirst }, + { unpack(0x00000046, 0x34007291, 0x00001e00).skiplast }, + { unpack(0x00000046, 0x34007291, 0x00001e00).lsadvlast }, + { unpack(0x00000046, 0x34007291, 0x00001e00).length32 }, + { unpack(0x00000046, 0x34007291, 0x00001e00).lronly }, + { unpack(0x00000046, 0x34007291, 0x00001e00).ystride }, + { unpack(0x00000046, 0x34007291, 0x00001e00).endptfilter }, + { unpack(0x00000046, 0x34007291, 0x00001e00).adrmode }, + { unpack(0x00000046, 0x34007291, 0x00001e00).xyoffset }, + { unpack(0x00000046, 0x34007291, 0x00001e00).yflip }, + { unpack(0x00000046, 0x34007291, 0x00001e00).ensmask }, + { unpack(0x00000046, 0x34007291, 0x00001e00).cid_mask }, + { unpack(0x00000046, 0x34007291, 0x00001e00).sfactor }, + { unpack(0x00000046, 0x34007291, 0x00001e00).dfactor }, + { unpack(0x00000046, 0x34007291, 0x00001e00).rwpacked }, + { unpack(0x00000046, 0x34007291, 0x00001e00).hostdepth }, + { unpack(0x00000046, 0x34007291, 0x00001e00).rwdouble }, + { unpack(0x00000046, 0x34007291, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000065 dm1=0x34007291 cm=0x00000000 +unsafe extern "C" fn shader_00000065_34007291_00000000( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000065, 0x34007291, 0x00000000).opcode }, + { unpack(0x00000065, 0x34007291, 0x00000000).planes }, + { unpack(0x00000065, 0x34007291, 0x00000000).drawdepth }, + { unpack(0x00000065, 0x34007291, 0x00000000).dblsrc }, + { unpack(0x00000065, 0x34007291, 0x00000000).rgbmode }, + { unpack(0x00000065, 0x34007291, 0x00000000).dither }, + { unpack(0x00000065, 0x34007291, 0x00000000).logicop }, + { unpack(0x00000065, 0x34007291, 0x00000000).compare }, + { unpack(0x00000065, 0x34007291, 0x00000000).blend }, + { unpack(0x00000065, 0x34007291, 0x00000000).backblend }, + { unpack(0x00000065, 0x34007291, 0x00000000).blendalpha }, + { unpack(0x00000065, 0x34007291, 0x00000000).fastclear }, + { unpack(0x00000065, 0x34007291, 0x00000000).colorhost }, + { unpack(0x00000065, 0x34007291, 0x00000000).alphahost }, + { unpack(0x00000065, 0x34007291, 0x00000000).enzpattern }, + { unpack(0x00000065, 0x34007291, 0x00000000).enlspattern }, + { unpack(0x00000065, 0x34007291, 0x00000000).zpopaque }, + { unpack(0x00000065, 0x34007291, 0x00000000).lsopaque }, + { unpack(0x00000065, 0x34007291, 0x00000000).cidtest }, + { unpack(0x00000065, 0x34007291, 0x00000000).shade }, + { unpack(0x00000065, 0x34007291, 0x00000000).ciclamp }, + { unpack(0x00000065, 0x34007291, 0x00000000).stoponx }, + { unpack(0x00000065, 0x34007291, 0x00000000).stopony }, + { unpack(0x00000065, 0x34007291, 0x00000000).skipfirst }, + { unpack(0x00000065, 0x34007291, 0x00000000).skiplast }, + { unpack(0x00000065, 0x34007291, 0x00000000).lsadvlast }, + { unpack(0x00000065, 0x34007291, 0x00000000).length32 }, + { unpack(0x00000065, 0x34007291, 0x00000000).lronly }, + { unpack(0x00000065, 0x34007291, 0x00000000).ystride }, + { unpack(0x00000065, 0x34007291, 0x00000000).endptfilter }, + { unpack(0x00000065, 0x34007291, 0x00000000).adrmode }, + { unpack(0x00000065, 0x34007291, 0x00000000).xyoffset }, + { unpack(0x00000065, 0x34007291, 0x00000000).yflip }, + { unpack(0x00000065, 0x34007291, 0x00000000).ensmask }, + { unpack(0x00000065, 0x34007291, 0x00000000).cid_mask }, + { unpack(0x00000065, 0x34007291, 0x00000000).sfactor }, + { unpack(0x00000065, 0x34007291, 0x00000000).dfactor }, + { unpack(0x00000065, 0x34007291, 0x00000000).rwpacked }, + { unpack(0x00000065, 0x34007291, 0x00000000).hostdepth }, + { unpack(0x00000065, 0x34007291, 0x00000000).rwdouble }, + { unpack(0x00000065, 0x34007291, 0x00000000).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000065 dm1=0x34007291 cm=0x00001e00 +unsafe extern "C" fn shader_00000065_34007291_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000065, 0x34007291, 0x00001e00).opcode }, + { unpack(0x00000065, 0x34007291, 0x00001e00).planes }, + { unpack(0x00000065, 0x34007291, 0x00001e00).drawdepth }, + { unpack(0x00000065, 0x34007291, 0x00001e00).dblsrc }, + { unpack(0x00000065, 0x34007291, 0x00001e00).rgbmode }, + { unpack(0x00000065, 0x34007291, 0x00001e00).dither }, + { unpack(0x00000065, 0x34007291, 0x00001e00).logicop }, + { unpack(0x00000065, 0x34007291, 0x00001e00).compare }, + { unpack(0x00000065, 0x34007291, 0x00001e00).blend }, + { unpack(0x00000065, 0x34007291, 0x00001e00).backblend }, + { unpack(0x00000065, 0x34007291, 0x00001e00).blendalpha }, + { unpack(0x00000065, 0x34007291, 0x00001e00).fastclear }, + { unpack(0x00000065, 0x34007291, 0x00001e00).colorhost }, + { unpack(0x00000065, 0x34007291, 0x00001e00).alphahost }, + { unpack(0x00000065, 0x34007291, 0x00001e00).enzpattern }, + { unpack(0x00000065, 0x34007291, 0x00001e00).enlspattern }, + { unpack(0x00000065, 0x34007291, 0x00001e00).zpopaque }, + { unpack(0x00000065, 0x34007291, 0x00001e00).lsopaque }, + { unpack(0x00000065, 0x34007291, 0x00001e00).cidtest }, + { unpack(0x00000065, 0x34007291, 0x00001e00).shade }, + { unpack(0x00000065, 0x34007291, 0x00001e00).ciclamp }, + { unpack(0x00000065, 0x34007291, 0x00001e00).stoponx }, + { unpack(0x00000065, 0x34007291, 0x00001e00).stopony }, + { unpack(0x00000065, 0x34007291, 0x00001e00).skipfirst }, + { unpack(0x00000065, 0x34007291, 0x00001e00).skiplast }, + { unpack(0x00000065, 0x34007291, 0x00001e00).lsadvlast }, + { unpack(0x00000065, 0x34007291, 0x00001e00).length32 }, + { unpack(0x00000065, 0x34007291, 0x00001e00).lronly }, + { unpack(0x00000065, 0x34007291, 0x00001e00).ystride }, + { unpack(0x00000065, 0x34007291, 0x00001e00).endptfilter }, + { unpack(0x00000065, 0x34007291, 0x00001e00).adrmode }, + { unpack(0x00000065, 0x34007291, 0x00001e00).xyoffset }, + { unpack(0x00000065, 0x34007291, 0x00001e00).yflip }, + { unpack(0x00000065, 0x34007291, 0x00001e00).ensmask }, + { unpack(0x00000065, 0x34007291, 0x00001e00).cid_mask }, + { unpack(0x00000065, 0x34007291, 0x00001e00).sfactor }, + { unpack(0x00000065, 0x34007291, 0x00001e00).dfactor }, + { unpack(0x00000065, 0x34007291, 0x00001e00).rwpacked }, + { unpack(0x00000065, 0x34007291, 0x00001e00).hostdepth }, + { unpack(0x00000065, 0x34007291, 0x00001e00).rwdouble }, + { unpack(0x00000065, 0x34007291, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000066 dm1=0x34007291 cm=0x00000000 +unsafe extern "C" fn shader_00000066_34007291_00000000( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000066, 0x34007291, 0x00000000).opcode }, + { unpack(0x00000066, 0x34007291, 0x00000000).planes }, + { unpack(0x00000066, 0x34007291, 0x00000000).drawdepth }, + { unpack(0x00000066, 0x34007291, 0x00000000).dblsrc }, + { unpack(0x00000066, 0x34007291, 0x00000000).rgbmode }, + { unpack(0x00000066, 0x34007291, 0x00000000).dither }, + { unpack(0x00000066, 0x34007291, 0x00000000).logicop }, + { unpack(0x00000066, 0x34007291, 0x00000000).compare }, + { unpack(0x00000066, 0x34007291, 0x00000000).blend }, + { unpack(0x00000066, 0x34007291, 0x00000000).backblend }, + { unpack(0x00000066, 0x34007291, 0x00000000).blendalpha }, + { unpack(0x00000066, 0x34007291, 0x00000000).fastclear }, + { unpack(0x00000066, 0x34007291, 0x00000000).colorhost }, + { unpack(0x00000066, 0x34007291, 0x00000000).alphahost }, + { unpack(0x00000066, 0x34007291, 0x00000000).enzpattern }, + { unpack(0x00000066, 0x34007291, 0x00000000).enlspattern }, + { unpack(0x00000066, 0x34007291, 0x00000000).zpopaque }, + { unpack(0x00000066, 0x34007291, 0x00000000).lsopaque }, + { unpack(0x00000066, 0x34007291, 0x00000000).cidtest }, + { unpack(0x00000066, 0x34007291, 0x00000000).shade }, + { unpack(0x00000066, 0x34007291, 0x00000000).ciclamp }, + { unpack(0x00000066, 0x34007291, 0x00000000).stoponx }, + { unpack(0x00000066, 0x34007291, 0x00000000).stopony }, + { unpack(0x00000066, 0x34007291, 0x00000000).skipfirst }, + { unpack(0x00000066, 0x34007291, 0x00000000).skiplast }, + { unpack(0x00000066, 0x34007291, 0x00000000).lsadvlast }, + { unpack(0x00000066, 0x34007291, 0x00000000).length32 }, + { unpack(0x00000066, 0x34007291, 0x00000000).lronly }, + { unpack(0x00000066, 0x34007291, 0x00000000).ystride }, + { unpack(0x00000066, 0x34007291, 0x00000000).endptfilter }, + { unpack(0x00000066, 0x34007291, 0x00000000).adrmode }, + { unpack(0x00000066, 0x34007291, 0x00000000).xyoffset }, + { unpack(0x00000066, 0x34007291, 0x00000000).yflip }, + { unpack(0x00000066, 0x34007291, 0x00000000).ensmask }, + { unpack(0x00000066, 0x34007291, 0x00000000).cid_mask }, + { unpack(0x00000066, 0x34007291, 0x00000000).sfactor }, + { unpack(0x00000066, 0x34007291, 0x00000000).dfactor }, + { unpack(0x00000066, 0x34007291, 0x00000000).rwpacked }, + { unpack(0x00000066, 0x34007291, 0x00000000).hostdepth }, + { unpack(0x00000066, 0x34007291, 0x00000000).rwdouble }, + { unpack(0x00000066, 0x34007291, 0x00000000).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000066 dm1=0x34007291 cm=0x00001e00 +unsafe extern "C" fn shader_00000066_34007291_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000066, 0x34007291, 0x00001e00).opcode }, + { unpack(0x00000066, 0x34007291, 0x00001e00).planes }, + { unpack(0x00000066, 0x34007291, 0x00001e00).drawdepth }, + { unpack(0x00000066, 0x34007291, 0x00001e00).dblsrc }, + { unpack(0x00000066, 0x34007291, 0x00001e00).rgbmode }, + { unpack(0x00000066, 0x34007291, 0x00001e00).dither }, + { unpack(0x00000066, 0x34007291, 0x00001e00).logicop }, + { unpack(0x00000066, 0x34007291, 0x00001e00).compare }, + { unpack(0x00000066, 0x34007291, 0x00001e00).blend }, + { unpack(0x00000066, 0x34007291, 0x00001e00).backblend }, + { unpack(0x00000066, 0x34007291, 0x00001e00).blendalpha }, + { unpack(0x00000066, 0x34007291, 0x00001e00).fastclear }, + { unpack(0x00000066, 0x34007291, 0x00001e00).colorhost }, + { unpack(0x00000066, 0x34007291, 0x00001e00).alphahost }, + { unpack(0x00000066, 0x34007291, 0x00001e00).enzpattern }, + { unpack(0x00000066, 0x34007291, 0x00001e00).enlspattern }, + { unpack(0x00000066, 0x34007291, 0x00001e00).zpopaque }, + { unpack(0x00000066, 0x34007291, 0x00001e00).lsopaque }, + { unpack(0x00000066, 0x34007291, 0x00001e00).cidtest }, + { unpack(0x00000066, 0x34007291, 0x00001e00).shade }, + { unpack(0x00000066, 0x34007291, 0x00001e00).ciclamp }, + { unpack(0x00000066, 0x34007291, 0x00001e00).stoponx }, + { unpack(0x00000066, 0x34007291, 0x00001e00).stopony }, + { unpack(0x00000066, 0x34007291, 0x00001e00).skipfirst }, + { unpack(0x00000066, 0x34007291, 0x00001e00).skiplast }, + { unpack(0x00000066, 0x34007291, 0x00001e00).lsadvlast }, + { unpack(0x00000066, 0x34007291, 0x00001e00).length32 }, + { unpack(0x00000066, 0x34007291, 0x00001e00).lronly }, + { unpack(0x00000066, 0x34007291, 0x00001e00).ystride }, + { unpack(0x00000066, 0x34007291, 0x00001e00).endptfilter }, + { unpack(0x00000066, 0x34007291, 0x00001e00).adrmode }, + { unpack(0x00000066, 0x34007291, 0x00001e00).xyoffset }, + { unpack(0x00000066, 0x34007291, 0x00001e00).yflip }, + { unpack(0x00000066, 0x34007291, 0x00001e00).ensmask }, + { unpack(0x00000066, 0x34007291, 0x00001e00).cid_mask }, + { unpack(0x00000066, 0x34007291, 0x00001e00).sfactor }, + { unpack(0x00000066, 0x34007291, 0x00001e00).dfactor }, + { unpack(0x00000066, 0x34007291, 0x00001e00).rwpacked }, + { unpack(0x00000066, 0x34007291, 0x00001e00).hostdepth }, + { unpack(0x00000066, 0x34007291, 0x00001e00).rwdouble }, + { unpack(0x00000066, 0x34007291, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000008a dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_0000008a_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000008a, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).planes }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).dither }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).compare }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).blend }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).shade }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x0000008a, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000008a dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_0000008a_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000008a, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).planes }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).dither }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).compare }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).blend }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).shade }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x0000008a, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000000c5 dm1=0x3409f391 cm=0x00001e03 +unsafe extern "C" fn shader_000000c5_3409f391_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000000c5, 0x3409f391, 0x00001e03).opcode }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).planes }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).drawdepth }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).dblsrc }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).rgbmode }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).dither }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).logicop }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).compare }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).blend }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).backblend }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).blendalpha }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).fastclear }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).colorhost }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).alphahost }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).enzpattern }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).enlspattern }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).zpopaque }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).lsopaque }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).cidtest }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).shade }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).ciclamp }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).stoponx }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).stopony }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).skipfirst }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).skiplast }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).lsadvlast }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).length32 }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).lronly }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).ystride }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).endptfilter }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).adrmode }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).xyoffset }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).yflip }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).ensmask }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).cid_mask }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).sfactor }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).dfactor }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).rwpacked }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).hostdepth }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).rwdouble }, + { unpack(0x000000c5, 0x3409f391, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000000c5 dm1=0x3409f3b1 cm=0x00001e03 +unsafe extern "C" fn shader_000000c5_3409f3b1_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).opcode }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).planes }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).drawdepth }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).dblsrc }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).rgbmode }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).dither }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).logicop }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).compare }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).blend }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).backblend }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).blendalpha }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).fastclear }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).colorhost }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).alphahost }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).enzpattern }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).enlspattern }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).zpopaque }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).lsopaque }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).cidtest }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).shade }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).ciclamp }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).stoponx }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).stopony }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).skipfirst }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).skiplast }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).lsadvlast }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).length32 }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).lronly }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).ystride }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).endptfilter }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).adrmode }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).xyoffset }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).yflip }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).ensmask }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).cid_mask }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).sfactor }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).dfactor }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).rwpacked }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).hostdepth }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).rwdouble }, + { unpack(0x000000c5, 0x3409f3b1, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000000c6 dm1=0x30097291 cm=0x00001e03 +unsafe extern "C" fn shader_000000c6_30097291_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000000c6, 0x30097291, 0x00001e03).opcode }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).planes }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).drawdepth }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).dblsrc }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).rgbmode }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).dither }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).logicop }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).compare }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).blend }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).backblend }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).blendalpha }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).fastclear }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).colorhost }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).alphahost }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).enzpattern }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).enlspattern }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).zpopaque }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).lsopaque }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).cidtest }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).shade }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).ciclamp }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).stoponx }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).stopony }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).skipfirst }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).skiplast }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).lsadvlast }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).length32 }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).lronly }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).ystride }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).endptfilter }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).adrmode }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).xyoffset }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).yflip }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).ensmask }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).cid_mask }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).sfactor }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).dfactor }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).rwpacked }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).hostdepth }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).rwdouble }, + { unpack(0x000000c6, 0x30097291, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000000c6 dm1=0x3009f391 cm=0x00001e03 +unsafe extern "C" fn shader_000000c6_3009f391_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000000c6, 0x3009f391, 0x00001e03).opcode }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).planes }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).drawdepth }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).dblsrc }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).rgbmode }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).dither }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).logicop }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).compare }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).blend }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).backblend }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).blendalpha }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).fastclear }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).colorhost }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).alphahost }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).enzpattern }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).enlspattern }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).zpopaque }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).lsopaque }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).cidtest }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).shade }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).ciclamp }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).stoponx }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).stopony }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).skipfirst }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).skiplast }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).lsadvlast }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).length32 }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).lronly }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).ystride }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).endptfilter }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).adrmode }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).xyoffset }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).yflip }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).ensmask }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).cid_mask }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).sfactor }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).dfactor }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).rwpacked }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).hostdepth }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).rwdouble }, + { unpack(0x000000c6, 0x3009f391, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000000c6 dm1=0x3009f399 cm=0x00001e03 +unsafe extern "C" fn shader_000000c6_3009f399_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000000c6, 0x3009f399, 0x00001e03).opcode }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).planes }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).drawdepth }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).dblsrc }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).rgbmode }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).dither }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).logicop }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).compare }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).blend }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).backblend }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).blendalpha }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).fastclear }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).colorhost }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).alphahost }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).enzpattern }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).enlspattern }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).zpopaque }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).lsopaque }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).cidtest }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).shade }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).ciclamp }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).stoponx }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).stopony }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).skipfirst }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).skiplast }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).lsadvlast }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).length32 }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).lronly }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).ystride }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).endptfilter }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).adrmode }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).xyoffset }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).yflip }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).ensmask }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).cid_mask }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).sfactor }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).dfactor }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).rwpacked }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).hostdepth }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).rwdouble }, + { unpack(0x000000c6, 0x3009f399, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000000c6 dm1=0x3009f3b1 cm=0x00001e03 +unsafe extern "C" fn shader_000000c6_3009f3b1_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).opcode }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).planes }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).drawdepth }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).dblsrc }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).rgbmode }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).dither }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).logicop }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).compare }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).blend }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).backblend }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).blendalpha }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).fastclear }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).colorhost }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).alphahost }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).enzpattern }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).enlspattern }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).zpopaque }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).lsopaque }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).cidtest }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).shade }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).ciclamp }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).stoponx }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).stopony }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).skipfirst }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).skiplast }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).lsadvlast }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).length32 }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).lronly }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).ystride }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).endptfilter }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).adrmode }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).xyoffset }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).yflip }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).ensmask }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).cid_mask }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).sfactor }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).dfactor }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).rwpacked }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).hostdepth }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).rwdouble }, + { unpack(0x000000c6, 0x3009f3b1, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000000c6 dm1=0x3009f799 cm=0x00001e03 +unsafe extern "C" fn shader_000000c6_3009f799_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000000c6, 0x3009f799, 0x00001e03).opcode }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).planes }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).drawdepth }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).dblsrc }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).rgbmode }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).dither }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).logicop }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).compare }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).blend }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).backblend }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).blendalpha }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).fastclear }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).colorhost }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).alphahost }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).enzpattern }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).enlspattern }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).zpopaque }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).lsopaque }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).cidtest }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).shade }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).ciclamp }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).stoponx }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).stopony }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).skipfirst }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).skiplast }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).lsadvlast }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).length32 }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).lronly }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).ystride }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).endptfilter }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).adrmode }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).xyoffset }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).yflip }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).ensmask }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).cid_mask }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).sfactor }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).dfactor }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).rwpacked }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).hostdepth }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).rwdouble }, + { unpack(0x000000c6, 0x3009f799, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000000c6 dm1=0x3165f7b1 cm=0x00001e03 +unsafe extern "C" fn shader_000000c6_3165f7b1_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).opcode }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).planes }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).drawdepth }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).dblsrc }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).rgbmode }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).dither }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).logicop }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).compare }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).blend }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).backblend }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).blendalpha }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).fastclear }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).colorhost }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).alphahost }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).enzpattern }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).enlspattern }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).zpopaque }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).lsopaque }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).cidtest }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).shade }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).ciclamp }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).stoponx }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).stopony }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).skipfirst }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).skiplast }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).lsadvlast }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).length32 }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).lronly }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).ystride }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).endptfilter }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).adrmode }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).xyoffset }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).yflip }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).ensmask }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).cid_mask }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).sfactor }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).dfactor }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).rwpacked }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).hostdepth }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).rwdouble }, + { unpack(0x000000c6, 0x3165f7b1, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3000710c cm=0x00001e02 +unsafe extern "C" fn shader_00000102_3000710c_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3000710c, 0x00001e02).opcode }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).planes }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).drawdepth }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).dblsrc }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).rgbmode }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).dither }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).logicop }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).compare }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).blend }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).backblend }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).blendalpha }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).fastclear }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).colorhost }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).alphahost }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).enzpattern }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).enlspattern }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).zpopaque }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).lsopaque }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).cidtest }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).shade }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).ciclamp }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).stoponx }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).stopony }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).skipfirst }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).skiplast }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).lsadvlast }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).length32 }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).lronly }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).ystride }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).endptfilter }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).adrmode }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).xyoffset }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).yflip }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).ensmask }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).cid_mask }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).sfactor }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).dfactor }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).rwpacked }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).hostdepth }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).rwdouble }, + { unpack(0x00000102, 0x3000710c, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3000710d cm=0x00001e00 +unsafe extern "C" fn shader_00000102_3000710d_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3000710d, 0x00001e00).opcode }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).planes }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).drawdepth }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).dblsrc }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).rgbmode }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).dither }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).logicop }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).compare }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).blend }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).backblend }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).blendalpha }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).fastclear }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).colorhost }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).alphahost }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).enzpattern }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).enlspattern }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).zpopaque }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).lsopaque }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).cidtest }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).shade }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).ciclamp }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).stoponx }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).stopony }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).skipfirst }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).skiplast }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).lsadvlast }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).length32 }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).lronly }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).ystride }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).endptfilter }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).adrmode }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).xyoffset }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).yflip }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).ensmask }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).cid_mask }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).sfactor }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).dfactor }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).rwpacked }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).hostdepth }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).rwdouble }, + { unpack(0x00000102, 0x3000710d, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3000710d cm=0x00001e1e +unsafe extern "C" fn shader_00000102_3000710d_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3000710d, 0x00001e1e).opcode }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).planes }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).drawdepth }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).dblsrc }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).rgbmode }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).dither }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).logicop }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).compare }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).blend }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).backblend }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).blendalpha }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).fastclear }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).colorhost }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).alphahost }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).enzpattern }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).enlspattern }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).zpopaque }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).lsopaque }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).cidtest }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).shade }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).ciclamp }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).stoponx }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).stopony }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).skipfirst }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).skiplast }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).lsadvlast }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).length32 }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).lronly }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).ystride }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).endptfilter }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).adrmode }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).xyoffset }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).yflip }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).ensmask }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).cid_mask }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).sfactor }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).dfactor }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).rwpacked }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).hostdepth }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).rwdouble }, + { unpack(0x00000102, 0x3000710d, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3000f019 cm=0x00001e00 +unsafe extern "C" fn shader_00000102_3000f019_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3000f019, 0x00001e00).opcode }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).planes }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).drawdepth }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).dblsrc }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).rgbmode }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).dither }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).logicop }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).compare }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).blend }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).backblend }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).blendalpha }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).fastclear }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).colorhost }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).alphahost }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).enzpattern }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).enlspattern }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).zpopaque }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).lsopaque }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).cidtest }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).shade }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).ciclamp }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).stoponx }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).stopony }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).skipfirst }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).skiplast }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).lsadvlast }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).length32 }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).lronly }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).ystride }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).endptfilter }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).adrmode }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).xyoffset }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).yflip }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).ensmask }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).cid_mask }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).sfactor }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).dfactor }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).rwpacked }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).hostdepth }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).rwdouble }, + { unpack(0x00000102, 0x3000f019, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x30027109 cm=0x00001e00 +unsafe extern "C" fn shader_00000102_30027109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x30027109, 0x00001e00).opcode }, + { unpack(0x00000102, 0x30027109, 0x00001e00).planes }, + { unpack(0x00000102, 0x30027109, 0x00001e00).drawdepth }, + { unpack(0x00000102, 0x30027109, 0x00001e00).dblsrc }, + { unpack(0x00000102, 0x30027109, 0x00001e00).rgbmode }, + { unpack(0x00000102, 0x30027109, 0x00001e00).dither }, + { unpack(0x00000102, 0x30027109, 0x00001e00).logicop }, + { unpack(0x00000102, 0x30027109, 0x00001e00).compare }, + { unpack(0x00000102, 0x30027109, 0x00001e00).blend }, + { unpack(0x00000102, 0x30027109, 0x00001e00).backblend }, + { unpack(0x00000102, 0x30027109, 0x00001e00).blendalpha }, + { unpack(0x00000102, 0x30027109, 0x00001e00).fastclear }, + { unpack(0x00000102, 0x30027109, 0x00001e00).colorhost }, + { unpack(0x00000102, 0x30027109, 0x00001e00).alphahost }, + { unpack(0x00000102, 0x30027109, 0x00001e00).enzpattern }, + { unpack(0x00000102, 0x30027109, 0x00001e00).enlspattern }, + { unpack(0x00000102, 0x30027109, 0x00001e00).zpopaque }, + { unpack(0x00000102, 0x30027109, 0x00001e00).lsopaque }, + { unpack(0x00000102, 0x30027109, 0x00001e00).cidtest }, + { unpack(0x00000102, 0x30027109, 0x00001e00).shade }, + { unpack(0x00000102, 0x30027109, 0x00001e00).ciclamp }, + { unpack(0x00000102, 0x30027109, 0x00001e00).stoponx }, + { unpack(0x00000102, 0x30027109, 0x00001e00).stopony }, + { unpack(0x00000102, 0x30027109, 0x00001e00).skipfirst }, + { unpack(0x00000102, 0x30027109, 0x00001e00).skiplast }, + { unpack(0x00000102, 0x30027109, 0x00001e00).lsadvlast }, + { unpack(0x00000102, 0x30027109, 0x00001e00).length32 }, + { unpack(0x00000102, 0x30027109, 0x00001e00).lronly }, + { unpack(0x00000102, 0x30027109, 0x00001e00).ystride }, + { unpack(0x00000102, 0x30027109, 0x00001e00).endptfilter }, + { unpack(0x00000102, 0x30027109, 0x00001e00).adrmode }, + { unpack(0x00000102, 0x30027109, 0x00001e00).xyoffset }, + { unpack(0x00000102, 0x30027109, 0x00001e00).yflip }, + { unpack(0x00000102, 0x30027109, 0x00001e00).ensmask }, + { unpack(0x00000102, 0x30027109, 0x00001e00).cid_mask }, + { unpack(0x00000102, 0x30027109, 0x00001e00).sfactor }, + { unpack(0x00000102, 0x30027109, 0x00001e00).dfactor }, + { unpack(0x00000102, 0x30027109, 0x00001e00).rwpacked }, + { unpack(0x00000102, 0x30027109, 0x00001e00).hostdepth }, + { unpack(0x00000102, 0x30027109, 0x00001e00).rwdouble }, + { unpack(0x00000102, 0x30027109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x30027109 cm=0x00001e02 +unsafe extern "C" fn shader_00000102_30027109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x30027109, 0x00001e02).opcode }, + { unpack(0x00000102, 0x30027109, 0x00001e02).planes }, + { unpack(0x00000102, 0x30027109, 0x00001e02).drawdepth }, + { unpack(0x00000102, 0x30027109, 0x00001e02).dblsrc }, + { unpack(0x00000102, 0x30027109, 0x00001e02).rgbmode }, + { unpack(0x00000102, 0x30027109, 0x00001e02).dither }, + { unpack(0x00000102, 0x30027109, 0x00001e02).logicop }, + { unpack(0x00000102, 0x30027109, 0x00001e02).compare }, + { unpack(0x00000102, 0x30027109, 0x00001e02).blend }, + { unpack(0x00000102, 0x30027109, 0x00001e02).backblend }, + { unpack(0x00000102, 0x30027109, 0x00001e02).blendalpha }, + { unpack(0x00000102, 0x30027109, 0x00001e02).fastclear }, + { unpack(0x00000102, 0x30027109, 0x00001e02).colorhost }, + { unpack(0x00000102, 0x30027109, 0x00001e02).alphahost }, + { unpack(0x00000102, 0x30027109, 0x00001e02).enzpattern }, + { unpack(0x00000102, 0x30027109, 0x00001e02).enlspattern }, + { unpack(0x00000102, 0x30027109, 0x00001e02).zpopaque }, + { unpack(0x00000102, 0x30027109, 0x00001e02).lsopaque }, + { unpack(0x00000102, 0x30027109, 0x00001e02).cidtest }, + { unpack(0x00000102, 0x30027109, 0x00001e02).shade }, + { unpack(0x00000102, 0x30027109, 0x00001e02).ciclamp }, + { unpack(0x00000102, 0x30027109, 0x00001e02).stoponx }, + { unpack(0x00000102, 0x30027109, 0x00001e02).stopony }, + { unpack(0x00000102, 0x30027109, 0x00001e02).skipfirst }, + { unpack(0x00000102, 0x30027109, 0x00001e02).skiplast }, + { unpack(0x00000102, 0x30027109, 0x00001e02).lsadvlast }, + { unpack(0x00000102, 0x30027109, 0x00001e02).length32 }, + { unpack(0x00000102, 0x30027109, 0x00001e02).lronly }, + { unpack(0x00000102, 0x30027109, 0x00001e02).ystride }, + { unpack(0x00000102, 0x30027109, 0x00001e02).endptfilter }, + { unpack(0x00000102, 0x30027109, 0x00001e02).adrmode }, + { unpack(0x00000102, 0x30027109, 0x00001e02).xyoffset }, + { unpack(0x00000102, 0x30027109, 0x00001e02).yflip }, + { unpack(0x00000102, 0x30027109, 0x00001e02).ensmask }, + { unpack(0x00000102, 0x30027109, 0x00001e02).cid_mask }, + { unpack(0x00000102, 0x30027109, 0x00001e02).sfactor }, + { unpack(0x00000102, 0x30027109, 0x00001e02).dfactor }, + { unpack(0x00000102, 0x30027109, 0x00001e02).rwpacked }, + { unpack(0x00000102, 0x30027109, 0x00001e02).hostdepth }, + { unpack(0x00000102, 0x30027109, 0x00001e02).rwdouble }, + { unpack(0x00000102, 0x30027109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f109 cm=0x00001e00 +unsafe extern "C" fn shader_00000102_3002f109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f109, 0x00001e00).opcode }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).planes }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).drawdepth }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).dblsrc }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).rgbmode }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).dither }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).logicop }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).compare }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).blend }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).backblend }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).blendalpha }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).fastclear }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).colorhost }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).alphahost }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).enzpattern }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).enlspattern }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).zpopaque }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).lsopaque }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).cidtest }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).shade }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).ciclamp }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).stoponx }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).stopony }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).skipfirst }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).skiplast }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).lsadvlast }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).length32 }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).lronly }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).ystride }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).endptfilter }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).adrmode }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).xyoffset }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).yflip }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).ensmask }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).cid_mask }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).sfactor }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).dfactor }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).rwpacked }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).hostdepth }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).rwdouble }, + { unpack(0x00000102, 0x3002f109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f109 cm=0x00001e02 +unsafe extern "C" fn shader_00000102_3002f109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f109, 0x00001e02).opcode }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).planes }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).drawdepth }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).dblsrc }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).rgbmode }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).dither }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).logicop }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).compare }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).blend }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).backblend }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).blendalpha }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).fastclear }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).colorhost }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).alphahost }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).enzpattern }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).enlspattern }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).zpopaque }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).lsopaque }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).cidtest }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).shade }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).ciclamp }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).stoponx }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).stopony }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).skipfirst }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).skiplast }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).lsadvlast }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).length32 }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).lronly }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).ystride }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).endptfilter }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).adrmode }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).xyoffset }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).yflip }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).ensmask }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).cid_mask }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).sfactor }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).dfactor }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).rwpacked }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).hostdepth }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).rwdouble }, + { unpack(0x00000102, 0x3002f109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f109 cm=0x00001e1e +unsafe extern "C" fn shader_00000102_3002f109_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f109, 0x00001e1e).opcode }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).planes }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).drawdepth }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).dblsrc }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).rgbmode }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).dither }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).logicop }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).compare }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).blend }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).backblend }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).blendalpha }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).fastclear }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).colorhost }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).alphahost }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).enzpattern }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).enlspattern }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).zpopaque }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).lsopaque }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).cidtest }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).shade }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).ciclamp }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).stoponx }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).stopony }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).skipfirst }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).skiplast }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).lsadvlast }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).length32 }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).lronly }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).ystride }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).endptfilter }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).adrmode }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).xyoffset }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).yflip }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).ensmask }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).cid_mask }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).sfactor }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).dfactor }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).rwpacked }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).hostdepth }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).rwdouble }, + { unpack(0x00000102, 0x3002f109, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f211 cm=0x00001e00 +unsafe extern "C" fn shader_00000102_3002f211_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f211, 0x00001e00).opcode }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).planes }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).drawdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).dblsrc }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).rgbmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).dither }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).logicop }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).compare }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).blend }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).backblend }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).blendalpha }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).fastclear }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).colorhost }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).alphahost }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).enzpattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).enlspattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).zpopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).lsopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).cidtest }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).shade }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).ciclamp }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).stoponx }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).stopony }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).skipfirst }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).skiplast }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).lsadvlast }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).length32 }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).lronly }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).ystride }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).endptfilter }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).adrmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).xyoffset }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).yflip }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).ensmask }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).cid_mask }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).sfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).dfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).rwpacked }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).hostdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).rwdouble }, + { unpack(0x00000102, 0x3002f211, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f211 cm=0x00001e02 +unsafe extern "C" fn shader_00000102_3002f211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f211, 0x00001e02).opcode }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).planes }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).drawdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).dblsrc }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).rgbmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).dither }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).logicop }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).compare }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).blend }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).backblend }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).blendalpha }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).fastclear }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).colorhost }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).alphahost }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).enzpattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).enlspattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).zpopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).lsopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).cidtest }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).shade }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).ciclamp }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).stoponx }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).stopony }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).skipfirst }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).skiplast }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).lsadvlast }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).length32 }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).lronly }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).ystride }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).endptfilter }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).adrmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).xyoffset }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).yflip }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).ensmask }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).cid_mask }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).sfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).dfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).rwpacked }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).hostdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).rwdouble }, + { unpack(0x00000102, 0x3002f211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f211 cm=0x00001e06 +unsafe extern "C" fn shader_00000102_3002f211_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f211, 0x00001e06).opcode }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).planes }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).drawdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).dblsrc }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).rgbmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).dither }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).logicop }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).compare }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).blend }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).backblend }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).blendalpha }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).fastclear }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).colorhost }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).alphahost }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).enzpattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).enlspattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).zpopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).lsopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).cidtest }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).shade }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).ciclamp }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).stoponx }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).stopony }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).skipfirst }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).skiplast }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).lsadvlast }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).length32 }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).lronly }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).ystride }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).endptfilter }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).adrmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).xyoffset }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).yflip }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).ensmask }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).cid_mask }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).sfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).dfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).rwpacked }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).hostdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).rwdouble }, + { unpack(0x00000102, 0x3002f211, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f211 cm=0x00001e0e +unsafe extern "C" fn shader_00000102_3002f211_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f211, 0x00001e0e).opcode }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).planes }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).drawdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).dblsrc }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).rgbmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).dither }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).logicop }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).compare }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).blend }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).backblend }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).blendalpha }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).fastclear }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).colorhost }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).alphahost }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).enzpattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).enlspattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).zpopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).lsopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).cidtest }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).shade }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).ciclamp }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).stoponx }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).stopony }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).skipfirst }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).skiplast }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).lsadvlast }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).length32 }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).lronly }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).ystride }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).endptfilter }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).adrmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).xyoffset }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).yflip }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).ensmask }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).cid_mask }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).sfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).dfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).rwpacked }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).hostdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).rwdouble }, + { unpack(0x00000102, 0x3002f211, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f211 cm=0x00001e1e +unsafe extern "C" fn shader_00000102_3002f211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f211, 0x00001e1e).opcode }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).planes }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).drawdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).dblsrc }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).rgbmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).dither }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).logicop }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).compare }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).blend }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).backblend }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).blendalpha }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).fastclear }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).colorhost }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).alphahost }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).enzpattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).enlspattern }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).zpopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).lsopaque }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).cidtest }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).shade }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).ciclamp }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).stoponx }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).stopony }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).skipfirst }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).skiplast }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).lsadvlast }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).length32 }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).lronly }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).ystride }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).endptfilter }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).adrmode }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).xyoffset }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).yflip }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).ensmask }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).cid_mask }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).sfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).dfactor }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).rwpacked }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).hostdepth }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).rwdouble }, + { unpack(0x00000102, 0x3002f211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f231 cm=0x00001e00 +unsafe extern "C" fn shader_00000102_3002f231_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f231, 0x00001e00).opcode }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).planes }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).drawdepth }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).dblsrc }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).rgbmode }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).dither }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).logicop }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).compare }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).blend }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).backblend }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).blendalpha }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).fastclear }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).colorhost }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).alphahost }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).enzpattern }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).enlspattern }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).zpopaque }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).lsopaque }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).cidtest }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).shade }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).ciclamp }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).stoponx }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).stopony }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).skipfirst }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).skiplast }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).lsadvlast }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).length32 }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).lronly }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).ystride }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).endptfilter }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).adrmode }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).xyoffset }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).yflip }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).ensmask }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).cid_mask }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).sfactor }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).dfactor }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).rwpacked }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).hostdepth }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).rwdouble }, + { unpack(0x00000102, 0x3002f231, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f231 cm=0x00001e02 +unsafe extern "C" fn shader_00000102_3002f231_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f231, 0x00001e02).opcode }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).planes }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).drawdepth }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).dblsrc }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).rgbmode }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).dither }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).logicop }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).compare }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).blend }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).backblend }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).blendalpha }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).fastclear }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).colorhost }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).alphahost }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).enzpattern }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).enlspattern }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).zpopaque }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).lsopaque }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).cidtest }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).shade }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).ciclamp }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).stoponx }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).stopony }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).skipfirst }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).skiplast }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).lsadvlast }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).length32 }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).lronly }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).ystride }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).endptfilter }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).adrmode }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).xyoffset }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).yflip }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).ensmask }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).cid_mask }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).sfactor }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).dfactor }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).rwpacked }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).hostdepth }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).rwdouble }, + { unpack(0x00000102, 0x3002f231, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f231 cm=0x00001e06 +unsafe extern "C" fn shader_00000102_3002f231_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f231, 0x00001e06).opcode }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).planes }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).drawdepth }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).dblsrc }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).rgbmode }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).dither }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).logicop }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).compare }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).blend }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).backblend }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).blendalpha }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).fastclear }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).colorhost }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).alphahost }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).enzpattern }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).enlspattern }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).zpopaque }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).lsopaque }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).cidtest }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).shade }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).ciclamp }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).stoponx }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).stopony }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).skipfirst }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).skiplast }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).lsadvlast }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).length32 }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).lronly }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).ystride }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).endptfilter }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).adrmode }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).xyoffset }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).yflip }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).ensmask }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).cid_mask }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).sfactor }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).dfactor }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).rwpacked }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).hostdepth }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).rwdouble }, + { unpack(0x00000102, 0x3002f231, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f231 cm=0x00001e1e +unsafe extern "C" fn shader_00000102_3002f231_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f231, 0x00001e1e).opcode }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).planes }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).drawdepth }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).dblsrc }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).rgbmode }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).dither }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).logicop }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).compare }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).blend }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).backblend }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).blendalpha }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).fastclear }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).colorhost }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).alphahost }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).enzpattern }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).enlspattern }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).zpopaque }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).lsopaque }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).cidtest }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).shade }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).ciclamp }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).stoponx }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).stopony }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).skipfirst }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).skiplast }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).lsadvlast }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).length32 }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).lronly }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).ystride }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).endptfilter }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).adrmode }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).xyoffset }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).yflip }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).ensmask }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).cid_mask }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).sfactor }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).dfactor }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).rwpacked }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).hostdepth }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).rwdouble }, + { unpack(0x00000102, 0x3002f231, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f319 cm=0x00001e00 +unsafe extern "C" fn shader_00000102_3002f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f319, 0x00001e00).opcode }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).planes }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).drawdepth }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).dblsrc }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).rgbmode }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).dither }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).logicop }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).compare }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).blend }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).backblend }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).blendalpha }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).fastclear }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).colorhost }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).alphahost }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).enzpattern }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).enlspattern }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).zpopaque }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).lsopaque }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).cidtest }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).shade }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).ciclamp }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).stoponx }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).stopony }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).skipfirst }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).skiplast }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).lsadvlast }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).length32 }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).lronly }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).ystride }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).endptfilter }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).adrmode }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).xyoffset }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).yflip }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).ensmask }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).cid_mask }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).sfactor }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).dfactor }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).rwpacked }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).hostdepth }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).rwdouble }, + { unpack(0x00000102, 0x3002f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f319 cm=0x00001e02 +unsafe extern "C" fn shader_00000102_3002f319_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f319, 0x00001e02).opcode }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).planes }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).drawdepth }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).dblsrc }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).rgbmode }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).dither }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).logicop }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).compare }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).blend }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).backblend }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).blendalpha }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).fastclear }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).colorhost }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).alphahost }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).enzpattern }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).enlspattern }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).zpopaque }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).lsopaque }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).cidtest }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).shade }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).ciclamp }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).stoponx }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).stopony }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).skipfirst }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).skiplast }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).lsadvlast }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).length32 }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).lronly }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).ystride }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).endptfilter }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).adrmode }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).xyoffset }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).yflip }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).ensmask }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).cid_mask }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).sfactor }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).dfactor }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).rwpacked }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).hostdepth }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).rwdouble }, + { unpack(0x00000102, 0x3002f319, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f319 cm=0x00001e06 +unsafe extern "C" fn shader_00000102_3002f319_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f319, 0x00001e06).opcode }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).planes }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).drawdepth }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).dblsrc }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).rgbmode }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).dither }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).logicop }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).compare }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).blend }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).backblend }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).blendalpha }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).fastclear }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).colorhost }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).alphahost }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).enzpattern }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).enlspattern }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).zpopaque }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).lsopaque }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).cidtest }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).shade }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).ciclamp }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).stoponx }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).stopony }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).skipfirst }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).skiplast }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).lsadvlast }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).length32 }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).lronly }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).ystride }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).endptfilter }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).adrmode }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).xyoffset }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).yflip }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).ensmask }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).cid_mask }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).sfactor }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).dfactor }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).rwpacked }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).hostdepth }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).rwdouble }, + { unpack(0x00000102, 0x3002f319, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000102 dm1=0x3002f319 cm=0x00001e1e +unsafe extern "C" fn shader_00000102_3002f319_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000102, 0x3002f319, 0x00001e1e).opcode }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).planes }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).drawdepth }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).dblsrc }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).rgbmode }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).dither }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).logicop }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).compare }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).blend }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).backblend }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).blendalpha }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).fastclear }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).colorhost }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).alphahost }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).enzpattern }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).enlspattern }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).zpopaque }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).lsopaque }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).cidtest }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).shade }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).ciclamp }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).stoponx }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).stopony }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).skipfirst }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).skiplast }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).lsadvlast }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).length32 }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).lronly }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).ystride }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).endptfilter }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).adrmode }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).xyoffset }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).yflip }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).ensmask }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).cid_mask }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).sfactor }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).dfactor }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).rwpacked }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).hostdepth }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).rwdouble }, + { unpack(0x00000102, 0x3002f319, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000122 dm1=0x30007109 cm=0x00001e00 +unsafe extern "C" fn shader_00000122_30007109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000122, 0x30007109, 0x00001e00).opcode }, + { unpack(0x00000122, 0x30007109, 0x00001e00).planes }, + { unpack(0x00000122, 0x30007109, 0x00001e00).drawdepth }, + { unpack(0x00000122, 0x30007109, 0x00001e00).dblsrc }, + { unpack(0x00000122, 0x30007109, 0x00001e00).rgbmode }, + { unpack(0x00000122, 0x30007109, 0x00001e00).dither }, + { unpack(0x00000122, 0x30007109, 0x00001e00).logicop }, + { unpack(0x00000122, 0x30007109, 0x00001e00).compare }, + { unpack(0x00000122, 0x30007109, 0x00001e00).blend }, + { unpack(0x00000122, 0x30007109, 0x00001e00).backblend }, + { unpack(0x00000122, 0x30007109, 0x00001e00).blendalpha }, + { unpack(0x00000122, 0x30007109, 0x00001e00).fastclear }, + { unpack(0x00000122, 0x30007109, 0x00001e00).colorhost }, + { unpack(0x00000122, 0x30007109, 0x00001e00).alphahost }, + { unpack(0x00000122, 0x30007109, 0x00001e00).enzpattern }, + { unpack(0x00000122, 0x30007109, 0x00001e00).enlspattern }, + { unpack(0x00000122, 0x30007109, 0x00001e00).zpopaque }, + { unpack(0x00000122, 0x30007109, 0x00001e00).lsopaque }, + { unpack(0x00000122, 0x30007109, 0x00001e00).cidtest }, + { unpack(0x00000122, 0x30007109, 0x00001e00).shade }, + { unpack(0x00000122, 0x30007109, 0x00001e00).ciclamp }, + { unpack(0x00000122, 0x30007109, 0x00001e00).stoponx }, + { unpack(0x00000122, 0x30007109, 0x00001e00).stopony }, + { unpack(0x00000122, 0x30007109, 0x00001e00).skipfirst }, + { unpack(0x00000122, 0x30007109, 0x00001e00).skiplast }, + { unpack(0x00000122, 0x30007109, 0x00001e00).lsadvlast }, + { unpack(0x00000122, 0x30007109, 0x00001e00).length32 }, + { unpack(0x00000122, 0x30007109, 0x00001e00).lronly }, + { unpack(0x00000122, 0x30007109, 0x00001e00).ystride }, + { unpack(0x00000122, 0x30007109, 0x00001e00).endptfilter }, + { unpack(0x00000122, 0x30007109, 0x00001e00).adrmode }, + { unpack(0x00000122, 0x30007109, 0x00001e00).xyoffset }, + { unpack(0x00000122, 0x30007109, 0x00001e00).yflip }, + { unpack(0x00000122, 0x30007109, 0x00001e00).ensmask }, + { unpack(0x00000122, 0x30007109, 0x00001e00).cid_mask }, + { unpack(0x00000122, 0x30007109, 0x00001e00).sfactor }, + { unpack(0x00000122, 0x30007109, 0x00001e00).dfactor }, + { unpack(0x00000122, 0x30007109, 0x00001e00).rwpacked }, + { unpack(0x00000122, 0x30007109, 0x00001e00).hostdepth }, + { unpack(0x00000122, 0x30007109, 0x00001e00).rwdouble }, + { unpack(0x00000122, 0x30007109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000122 dm1=0x3000710d cm=0x00001e00 +unsafe extern "C" fn shader_00000122_3000710d_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000122, 0x3000710d, 0x00001e00).opcode }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).planes }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).drawdepth }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).dblsrc }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).rgbmode }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).dither }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).logicop }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).compare }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).blend }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).backblend }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).blendalpha }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).fastclear }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).colorhost }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).alphahost }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).enzpattern }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).enlspattern }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).zpopaque }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).lsopaque }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).cidtest }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).shade }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).ciclamp }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).stoponx }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).stopony }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).skipfirst }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).skiplast }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).lsadvlast }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).length32 }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).lronly }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).ystride }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).endptfilter }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).adrmode }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).xyoffset }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).yflip }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).ensmask }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).cid_mask }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).sfactor }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).dfactor }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).rwpacked }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).hostdepth }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).rwdouble }, + { unpack(0x00000122, 0x3000710d, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000122 dm1=0x3000f109 cm=0x00001e00 +unsafe extern "C" fn shader_00000122_3000f109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000122, 0x3000f109, 0x00001e00).opcode }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).planes }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).drawdepth }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).dblsrc }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).rgbmode }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).dither }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).logicop }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).compare }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).blend }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).backblend }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).blendalpha }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).fastclear }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).colorhost }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).alphahost }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).enzpattern }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).enlspattern }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).zpopaque }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).lsopaque }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).cidtest }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).shade }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).ciclamp }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).stoponx }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).stopony }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).skipfirst }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).skiplast }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).lsadvlast }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).length32 }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).lronly }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).ystride }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).endptfilter }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).adrmode }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).xyoffset }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).yflip }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).ensmask }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).cid_mask }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).sfactor }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).dfactor }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).rwpacked }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).hostdepth }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).rwdouble }, + { unpack(0x00000122, 0x3000f109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000122 dm1=0x3000f211 cm=0x00001e00 +unsafe extern "C" fn shader_00000122_3000f211_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000122, 0x3000f211, 0x00001e00).opcode }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).planes }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).drawdepth }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).dblsrc }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).rgbmode }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).dither }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).logicop }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).compare }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).blend }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).backblend }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).blendalpha }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).fastclear }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).colorhost }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).alphahost }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).enzpattern }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).enlspattern }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).zpopaque }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).lsopaque }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).cidtest }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).shade }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).ciclamp }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).stoponx }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).stopony }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).skipfirst }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).skiplast }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).lsadvlast }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).length32 }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).lronly }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).ystride }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).endptfilter }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).adrmode }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).xyoffset }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).yflip }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).ensmask }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).cid_mask }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).sfactor }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).dfactor }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).rwpacked }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).hostdepth }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).rwdouble }, + { unpack(0x00000122, 0x3000f211, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000122 dm1=0x3000f231 cm=0x00001e00 +unsafe extern "C" fn shader_00000122_3000f231_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000122, 0x3000f231, 0x00001e00).opcode }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).planes }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).drawdepth }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).dblsrc }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).rgbmode }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).dither }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).logicop }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).compare }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).blend }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).backblend }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).blendalpha }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).fastclear }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).colorhost }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).alphahost }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).enzpattern }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).enlspattern }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).zpopaque }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).lsopaque }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).cidtest }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).shade }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).ciclamp }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).stoponx }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).stopony }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).skipfirst }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).skiplast }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).lsadvlast }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).length32 }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).lronly }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).ystride }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).endptfilter }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).adrmode }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).xyoffset }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).yflip }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).ensmask }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).cid_mask }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).sfactor }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).dfactor }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).rwpacked }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).hostdepth }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).rwdouble }, + { unpack(0x00000122, 0x3000f231, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000122 dm1=0x3000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00000122_3000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000122, 0x3000f319, 0x00001e00).opcode }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).planes }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).drawdepth }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).dblsrc }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).rgbmode }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).dither }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).logicop }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).compare }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).blend }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).backblend }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).blendalpha }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).fastclear }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).colorhost }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).alphahost }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).enzpattern }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).enlspattern }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).zpopaque }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).lsopaque }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).cidtest }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).shade }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).ciclamp }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).stoponx }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).stopony }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).skipfirst }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).skiplast }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).lsadvlast }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).length32 }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).lronly }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).ystride }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).endptfilter }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).adrmode }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).xyoffset }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).yflip }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).ensmask }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).cid_mask }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).sfactor }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).dfactor }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).rwpacked }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).hostdepth }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).rwdouble }, + { unpack(0x00000122, 0x3000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000145 dm1=0x00007589 cm=0x00001e00 +unsafe extern "C" fn shader_00000145_00007589_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000145, 0x00007589, 0x00001e00).opcode }, + { unpack(0x00000145, 0x00007589, 0x00001e00).planes }, + { unpack(0x00000145, 0x00007589, 0x00001e00).drawdepth }, + { unpack(0x00000145, 0x00007589, 0x00001e00).dblsrc }, + { unpack(0x00000145, 0x00007589, 0x00001e00).rgbmode }, + { unpack(0x00000145, 0x00007589, 0x00001e00).dither }, + { unpack(0x00000145, 0x00007589, 0x00001e00).logicop }, + { unpack(0x00000145, 0x00007589, 0x00001e00).compare }, + { unpack(0x00000145, 0x00007589, 0x00001e00).blend }, + { unpack(0x00000145, 0x00007589, 0x00001e00).backblend }, + { unpack(0x00000145, 0x00007589, 0x00001e00).blendalpha }, + { unpack(0x00000145, 0x00007589, 0x00001e00).fastclear }, + { unpack(0x00000145, 0x00007589, 0x00001e00).colorhost }, + { unpack(0x00000145, 0x00007589, 0x00001e00).alphahost }, + { unpack(0x00000145, 0x00007589, 0x00001e00).enzpattern }, + { unpack(0x00000145, 0x00007589, 0x00001e00).enlspattern }, + { unpack(0x00000145, 0x00007589, 0x00001e00).zpopaque }, + { unpack(0x00000145, 0x00007589, 0x00001e00).lsopaque }, + { unpack(0x00000145, 0x00007589, 0x00001e00).cidtest }, + { unpack(0x00000145, 0x00007589, 0x00001e00).shade }, + { unpack(0x00000145, 0x00007589, 0x00001e00).ciclamp }, + { unpack(0x00000145, 0x00007589, 0x00001e00).stoponx }, + { unpack(0x00000145, 0x00007589, 0x00001e00).stopony }, + { unpack(0x00000145, 0x00007589, 0x00001e00).skipfirst }, + { unpack(0x00000145, 0x00007589, 0x00001e00).skiplast }, + { unpack(0x00000145, 0x00007589, 0x00001e00).lsadvlast }, + { unpack(0x00000145, 0x00007589, 0x00001e00).length32 }, + { unpack(0x00000145, 0x00007589, 0x00001e00).lronly }, + { unpack(0x00000145, 0x00007589, 0x00001e00).ystride }, + { unpack(0x00000145, 0x00007589, 0x00001e00).endptfilter }, + { unpack(0x00000145, 0x00007589, 0x00001e00).adrmode }, + { unpack(0x00000145, 0x00007589, 0x00001e00).xyoffset }, + { unpack(0x00000145, 0x00007589, 0x00001e00).yflip }, + { unpack(0x00000145, 0x00007589, 0x00001e00).ensmask }, + { unpack(0x00000145, 0x00007589, 0x00001e00).cid_mask }, + { unpack(0x00000145, 0x00007589, 0x00001e00).sfactor }, + { unpack(0x00000145, 0x00007589, 0x00001e00).dfactor }, + { unpack(0x00000145, 0x00007589, 0x00001e00).rwpacked }, + { unpack(0x00000145, 0x00007589, 0x00001e00).hostdepth }, + { unpack(0x00000145, 0x00007589, 0x00001e00).rwdouble }, + { unpack(0x00000145, 0x00007589, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000145 dm1=0x0000f799 cm=0x00001e00 +unsafe extern "C" fn shader_00000145_0000f799_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000145, 0x0000f799, 0x00001e00).opcode }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).planes }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).drawdepth }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).dblsrc }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).rgbmode }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).dither }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).logicop }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).compare }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).blend }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).backblend }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).blendalpha }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).fastclear }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).colorhost }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).alphahost }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).enzpattern }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).enlspattern }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).zpopaque }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).lsopaque }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).cidtest }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).shade }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).ciclamp }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).stoponx }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).stopony }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).skipfirst }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).skiplast }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).lsadvlast }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).length32 }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).lronly }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).ystride }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).endptfilter }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).adrmode }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).xyoffset }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).yflip }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).ensmask }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).cid_mask }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).sfactor }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).dfactor }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).rwpacked }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).hostdepth }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).rwdouble }, + { unpack(0x00000145, 0x0000f799, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000001c5 dm1=0x3009f7b1 cm=0x00001e03 +unsafe extern "C" fn shader_000001c5_3009f7b1_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).opcode }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).planes }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).drawdepth }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).dblsrc }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).rgbmode }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).dither }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).logicop }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).compare }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).blend }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).backblend }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).blendalpha }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).fastclear }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).colorhost }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).alphahost }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).enzpattern }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).enlspattern }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).zpopaque }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).lsopaque }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).cidtest }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).shade }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).ciclamp }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).stoponx }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).stopony }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).skipfirst }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).skiplast }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).lsadvlast }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).length32 }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).lronly }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).ystride }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).endptfilter }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).adrmode }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).xyoffset }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).yflip }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).ensmask }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).cid_mask }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).sfactor }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).dfactor }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).rwpacked }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).hostdepth }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).rwdouble }, + { unpack(0x000001c5, 0x3009f7b1, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00000000 +unsafe extern "C" fn shader_00000306_3000f019_00000000( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00000000).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00000000).planes }, + { unpack(0x00000306, 0x3000f019, 0x00000000).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000000).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00000000).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00000000).dither }, + { unpack(0x00000306, 0x3000f019, 0x00000000).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00000000).compare }, + { unpack(0x00000306, 0x3000f019, 0x00000000).blend }, + { unpack(0x00000306, 0x3000f019, 0x00000000).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00000000).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00000000).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00000000).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00000000).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00000000).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00000000).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00000000).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000000).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000000).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00000000).shade }, + { unpack(0x00000306, 0x3000f019, 0x00000000).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00000000).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00000000).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00000000).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00000000).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00000000).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00000000).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00000000).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00000000).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00000000).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00000000).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00000000).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00000000).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00000000).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00000000).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00000000).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000000).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000000).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00000000).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000000).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00000000).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00000200 +unsafe extern "C" fn shader_00000306_3000f019_00000200( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00000200).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00000200).planes }, + { unpack(0x00000306, 0x3000f019, 0x00000200).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000200).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00000200).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00000200).dither }, + { unpack(0x00000306, 0x3000f019, 0x00000200).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00000200).compare }, + { unpack(0x00000306, 0x3000f019, 0x00000200).blend }, + { unpack(0x00000306, 0x3000f019, 0x00000200).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00000200).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00000200).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00000200).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00000200).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00000200).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00000200).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00000200).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000200).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000200).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00000200).shade }, + { unpack(0x00000306, 0x3000f019, 0x00000200).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00000200).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00000200).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00000200).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00000200).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00000200).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00000200).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00000200).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00000200).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00000200).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00000200).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00000200).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00000200).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00000200).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00000200).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00000200).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000200).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000200).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00000200).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000200).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00000200).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00000400 +unsafe extern "C" fn shader_00000306_3000f019_00000400( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00000400).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00000400).planes }, + { unpack(0x00000306, 0x3000f019, 0x00000400).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000400).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00000400).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00000400).dither }, + { unpack(0x00000306, 0x3000f019, 0x00000400).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00000400).compare }, + { unpack(0x00000306, 0x3000f019, 0x00000400).blend }, + { unpack(0x00000306, 0x3000f019, 0x00000400).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00000400).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00000400).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00000400).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00000400).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00000400).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00000400).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00000400).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000400).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000400).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00000400).shade }, + { unpack(0x00000306, 0x3000f019, 0x00000400).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00000400).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00000400).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00000400).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00000400).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00000400).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00000400).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00000400).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00000400).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00000400).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00000400).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00000400).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00000400).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00000400).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00000400).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00000400).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000400).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000400).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00000400).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000400).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00000400).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00000600 +unsafe extern "C" fn shader_00000306_3000f019_00000600( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00000600).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00000600).planes }, + { unpack(0x00000306, 0x3000f019, 0x00000600).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000600).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00000600).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00000600).dither }, + { unpack(0x00000306, 0x3000f019, 0x00000600).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00000600).compare }, + { unpack(0x00000306, 0x3000f019, 0x00000600).blend }, + { unpack(0x00000306, 0x3000f019, 0x00000600).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00000600).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00000600).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00000600).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00000600).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00000600).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00000600).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00000600).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000600).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000600).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00000600).shade }, + { unpack(0x00000306, 0x3000f019, 0x00000600).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00000600).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00000600).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00000600).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00000600).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00000600).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00000600).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00000600).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00000600).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00000600).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00000600).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00000600).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00000600).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00000600).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00000600).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00000600).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000600).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000600).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00000600).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000600).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00000600).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00000800 +unsafe extern "C" fn shader_00000306_3000f019_00000800( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00000800).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00000800).planes }, + { unpack(0x00000306, 0x3000f019, 0x00000800).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000800).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00000800).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00000800).dither }, + { unpack(0x00000306, 0x3000f019, 0x00000800).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00000800).compare }, + { unpack(0x00000306, 0x3000f019, 0x00000800).blend }, + { unpack(0x00000306, 0x3000f019, 0x00000800).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00000800).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00000800).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00000800).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00000800).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00000800).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00000800).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00000800).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000800).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000800).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00000800).shade }, + { unpack(0x00000306, 0x3000f019, 0x00000800).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00000800).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00000800).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00000800).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00000800).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00000800).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00000800).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00000800).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00000800).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00000800).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00000800).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00000800).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00000800).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00000800).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00000800).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00000800).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000800).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000800).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00000800).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000800).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00000800).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00000a00 +unsafe extern "C" fn shader_00000306_3000f019_00000a00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00000a00).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).planes }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).dither }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).compare }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).blend }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).shade }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00000a00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00000c00 +unsafe extern "C" fn shader_00000306_3000f019_00000c00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00000c00).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).planes }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).dither }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).compare }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).blend }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).shade }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00000c00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00000e00 +unsafe extern "C" fn shader_00000306_3000f019_00000e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00000e00).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).planes }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).dither }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).compare }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).blend }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).shade }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00000e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00001000 +unsafe extern "C" fn shader_00000306_3000f019_00001000( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00001000).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00001000).planes }, + { unpack(0x00000306, 0x3000f019, 0x00001000).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001000).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00001000).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00001000).dither }, + { unpack(0x00000306, 0x3000f019, 0x00001000).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00001000).compare }, + { unpack(0x00000306, 0x3000f019, 0x00001000).blend }, + { unpack(0x00000306, 0x3000f019, 0x00001000).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00001000).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00001000).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00001000).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00001000).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00001000).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00001000).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00001000).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001000).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001000).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00001000).shade }, + { unpack(0x00000306, 0x3000f019, 0x00001000).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00001000).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00001000).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00001000).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00001000).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00001000).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00001000).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00001000).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00001000).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00001000).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00001000).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00001000).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00001000).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00001000).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00001000).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00001000).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001000).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001000).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00001000).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001000).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00001000).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00001200 +unsafe extern "C" fn shader_00000306_3000f019_00001200( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00001200).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00001200).planes }, + { unpack(0x00000306, 0x3000f019, 0x00001200).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001200).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00001200).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00001200).dither }, + { unpack(0x00000306, 0x3000f019, 0x00001200).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00001200).compare }, + { unpack(0x00000306, 0x3000f019, 0x00001200).blend }, + { unpack(0x00000306, 0x3000f019, 0x00001200).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00001200).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00001200).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00001200).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00001200).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00001200).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00001200).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00001200).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001200).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001200).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00001200).shade }, + { unpack(0x00000306, 0x3000f019, 0x00001200).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00001200).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00001200).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00001200).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00001200).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00001200).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00001200).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00001200).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00001200).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00001200).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00001200).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00001200).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00001200).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00001200).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00001200).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00001200).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001200).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001200).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00001200).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001200).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00001200).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00001400 +unsafe extern "C" fn shader_00000306_3000f019_00001400( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00001400).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00001400).planes }, + { unpack(0x00000306, 0x3000f019, 0x00001400).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001400).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00001400).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00001400).dither }, + { unpack(0x00000306, 0x3000f019, 0x00001400).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00001400).compare }, + { unpack(0x00000306, 0x3000f019, 0x00001400).blend }, + { unpack(0x00000306, 0x3000f019, 0x00001400).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00001400).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00001400).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00001400).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00001400).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00001400).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00001400).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00001400).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001400).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001400).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00001400).shade }, + { unpack(0x00000306, 0x3000f019, 0x00001400).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00001400).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00001400).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00001400).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00001400).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00001400).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00001400).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00001400).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00001400).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00001400).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00001400).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00001400).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00001400).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00001400).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00001400).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00001400).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001400).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001400).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00001400).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001400).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00001400).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00001600 +unsafe extern "C" fn shader_00000306_3000f019_00001600( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00001600).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00001600).planes }, + { unpack(0x00000306, 0x3000f019, 0x00001600).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001600).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00001600).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00001600).dither }, + { unpack(0x00000306, 0x3000f019, 0x00001600).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00001600).compare }, + { unpack(0x00000306, 0x3000f019, 0x00001600).blend }, + { unpack(0x00000306, 0x3000f019, 0x00001600).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00001600).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00001600).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00001600).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00001600).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00001600).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00001600).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00001600).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001600).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001600).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00001600).shade }, + { unpack(0x00000306, 0x3000f019, 0x00001600).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00001600).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00001600).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00001600).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00001600).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00001600).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00001600).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00001600).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00001600).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00001600).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00001600).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00001600).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00001600).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00001600).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00001600).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00001600).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001600).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001600).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00001600).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001600).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00001600).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00001800 +unsafe extern "C" fn shader_00000306_3000f019_00001800( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00001800).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00001800).planes }, + { unpack(0x00000306, 0x3000f019, 0x00001800).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001800).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00001800).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00001800).dither }, + { unpack(0x00000306, 0x3000f019, 0x00001800).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00001800).compare }, + { unpack(0x00000306, 0x3000f019, 0x00001800).blend }, + { unpack(0x00000306, 0x3000f019, 0x00001800).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00001800).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00001800).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00001800).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00001800).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00001800).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00001800).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00001800).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001800).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001800).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00001800).shade }, + { unpack(0x00000306, 0x3000f019, 0x00001800).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00001800).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00001800).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00001800).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00001800).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00001800).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00001800).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00001800).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00001800).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00001800).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00001800).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00001800).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00001800).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00001800).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00001800).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00001800).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001800).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001800).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00001800).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001800).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00001800).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00001a00 +unsafe extern "C" fn shader_00000306_3000f019_00001a00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00001a00).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).planes }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).dither }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).compare }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).blend }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).shade }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00001a00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00001c00 +unsafe extern "C" fn shader_00000306_3000f019_00001c00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00001c00).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).planes }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).dither }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).compare }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).blend }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).shade }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00001c00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000306 dm1=0x3000f019 cm=0x00001e00 +unsafe extern "C" fn shader_00000306_3000f019_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000306, 0x3000f019, 0x00001e00).opcode }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).planes }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).drawdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).dblsrc }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).rgbmode }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).dither }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).logicop }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).compare }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).blend }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).backblend }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).blendalpha }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).fastclear }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).colorhost }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).alphahost }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).enzpattern }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).enlspattern }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).zpopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).lsopaque }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).cidtest }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).shade }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).ciclamp }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).stoponx }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).stopony }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).skipfirst }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).skiplast }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).lsadvlast }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).length32 }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).lronly }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).ystride }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).endptfilter }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).adrmode }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).xyoffset }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).yflip }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).ensmask }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).cid_mask }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).sfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).dfactor }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).rwpacked }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).hostdepth }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).rwdouble }, + { unpack(0x00000306, 0x3000f019, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30007109 cm=0x00001e00 +unsafe extern "C" fn shader_00000326_30007109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30007109, 0x00001e00).opcode }, + { unpack(0x00000326, 0x30007109, 0x00001e00).planes }, + { unpack(0x00000326, 0x30007109, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x30007109, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x30007109, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x30007109, 0x00001e00).dither }, + { unpack(0x00000326, 0x30007109, 0x00001e00).logicop }, + { unpack(0x00000326, 0x30007109, 0x00001e00).compare }, + { unpack(0x00000326, 0x30007109, 0x00001e00).blend }, + { unpack(0x00000326, 0x30007109, 0x00001e00).backblend }, + { unpack(0x00000326, 0x30007109, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x30007109, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x30007109, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x30007109, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x30007109, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x30007109, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x30007109, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x30007109, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x30007109, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x30007109, 0x00001e00).shade }, + { unpack(0x00000326, 0x30007109, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x30007109, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x30007109, 0x00001e00).stopony }, + { unpack(0x00000326, 0x30007109, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x30007109, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x30007109, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x30007109, 0x00001e00).length32 }, + { unpack(0x00000326, 0x30007109, 0x00001e00).lronly }, + { unpack(0x00000326, 0x30007109, 0x00001e00).ystride }, + { unpack(0x00000326, 0x30007109, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x30007109, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x30007109, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x30007109, 0x00001e00).yflip }, + { unpack(0x00000326, 0x30007109, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x30007109, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x30007109, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x30007109, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x30007109, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x30007109, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x30007109, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x30007109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3000710c cm=0x00001e00 +unsafe extern "C" fn shader_00000326_3000710c_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3000710c, 0x00001e00).opcode }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).planes }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).dither }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).logicop }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).compare }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).blend }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).backblend }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).shade }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).stopony }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).length32 }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).lronly }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).ystride }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).yflip }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x3000710c, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3000710c cm=0x00001e02 +unsafe extern "C" fn shader_00000326_3000710c_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3000710c, 0x00001e02).opcode }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).planes }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).dither }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).logicop }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).compare }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).blend }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).backblend }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).shade }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).stopony }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).length32 }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).lronly }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).ystride }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).yflip }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x3000710c, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3000710d cm=0x00001e00 +unsafe extern "C" fn shader_00000326_3000710d_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3000710d, 0x00001e00).opcode }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).planes }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).dither }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).logicop }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).compare }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).blend }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).backblend }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).shade }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).stopony }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).length32 }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).lronly }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).ystride }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).yflip }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x3000710d, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3000710d cm=0x00001e02 +unsafe extern "C" fn shader_00000326_3000710d_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3000710d, 0x00001e02).opcode }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).planes }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).dither }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).logicop }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).compare }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).blend }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).backblend }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).shade }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).stopony }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).length32 }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).lronly }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).ystride }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).yflip }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x3000710d, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3000710d cm=0x00001e1e +unsafe extern "C" fn shader_00000326_3000710d_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3000710d, 0x00001e1e).opcode }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).planes }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).drawdepth }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).dblsrc }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).rgbmode }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).dither }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).logicop }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).compare }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).blend }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).backblend }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).blendalpha }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).fastclear }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).colorhost }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).alphahost }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).enzpattern }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).enlspattern }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).zpopaque }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).lsopaque }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).cidtest }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).shade }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).ciclamp }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).stoponx }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).stopony }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).skipfirst }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).skiplast }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).lsadvlast }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).length32 }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).lronly }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).ystride }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).endptfilter }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).adrmode }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).xyoffset }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).yflip }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).ensmask }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).cid_mask }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).sfactor }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).dfactor }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).rwpacked }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).hostdepth }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).rwdouble }, + { unpack(0x00000326, 0x3000710d, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3000710e cm=0x00001e00 +unsafe extern "C" fn shader_00000326_3000710e_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3000710e, 0x00001e00).opcode }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).planes }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).dither }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).logicop }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).compare }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).blend }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).backblend }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).shade }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).stopony }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).length32 }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).lronly }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).ystride }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).yflip }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x3000710e, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30007319 cm=0x00001e00 +unsafe extern "C" fn shader_00000326_30007319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30007319, 0x00001e00).opcode }, + { unpack(0x00000326, 0x30007319, 0x00001e00).planes }, + { unpack(0x00000326, 0x30007319, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x30007319, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x30007319, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x30007319, 0x00001e00).dither }, + { unpack(0x00000326, 0x30007319, 0x00001e00).logicop }, + { unpack(0x00000326, 0x30007319, 0x00001e00).compare }, + { unpack(0x00000326, 0x30007319, 0x00001e00).blend }, + { unpack(0x00000326, 0x30007319, 0x00001e00).backblend }, + { unpack(0x00000326, 0x30007319, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x30007319, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x30007319, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x30007319, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x30007319, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x30007319, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x30007319, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x30007319, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x30007319, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x30007319, 0x00001e00).shade }, + { unpack(0x00000326, 0x30007319, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x30007319, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x30007319, 0x00001e00).stopony }, + { unpack(0x00000326, 0x30007319, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x30007319, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x30007319, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x30007319, 0x00001e00).length32 }, + { unpack(0x00000326, 0x30007319, 0x00001e00).lronly }, + { unpack(0x00000326, 0x30007319, 0x00001e00).ystride }, + { unpack(0x00000326, 0x30007319, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x30007319, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x30007319, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x30007319, 0x00001e00).yflip }, + { unpack(0x00000326, 0x30007319, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x30007319, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x30007319, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x30007319, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x30007319, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x30007319, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x30007319, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x30007319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00000326_3000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3000f319, 0x00001e00).opcode }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).planes }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).dither }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).logicop }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).compare }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).blend }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).backblend }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).shade }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).stopony }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).length32 }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).lronly }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).ystride }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).yflip }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x3000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30017009 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_30017009_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30017009, 0x00001e03).opcode }, + { unpack(0x00000326, 0x30017009, 0x00001e03).planes }, + { unpack(0x00000326, 0x30017009, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x30017009, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x30017009, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x30017009, 0x00001e03).dither }, + { unpack(0x00000326, 0x30017009, 0x00001e03).logicop }, + { unpack(0x00000326, 0x30017009, 0x00001e03).compare }, + { unpack(0x00000326, 0x30017009, 0x00001e03).blend }, + { unpack(0x00000326, 0x30017009, 0x00001e03).backblend }, + { unpack(0x00000326, 0x30017009, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x30017009, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x30017009, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x30017009, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x30017009, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x30017009, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x30017009, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x30017009, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x30017009, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x30017009, 0x00001e03).shade }, + { unpack(0x00000326, 0x30017009, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x30017009, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x30017009, 0x00001e03).stopony }, + { unpack(0x00000326, 0x30017009, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x30017009, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x30017009, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x30017009, 0x00001e03).length32 }, + { unpack(0x00000326, 0x30017009, 0x00001e03).lronly }, + { unpack(0x00000326, 0x30017009, 0x00001e03).ystride }, + { unpack(0x00000326, 0x30017009, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x30017009, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x30017009, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x30017009, 0x00001e03).yflip }, + { unpack(0x00000326, 0x30017009, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x30017009, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x30017009, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x30017009, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x30017009, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x30017009, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x30017009, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x30017009, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3001700c cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3001700c_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3001700c, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).planes }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).dither }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).compare }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).blend }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).shade }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3001700c, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30027009 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_30027009_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30027009, 0x00001e03).opcode }, + { unpack(0x00000326, 0x30027009, 0x00001e03).planes }, + { unpack(0x00000326, 0x30027009, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x30027009, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x30027009, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x30027009, 0x00001e03).dither }, + { unpack(0x00000326, 0x30027009, 0x00001e03).logicop }, + { unpack(0x00000326, 0x30027009, 0x00001e03).compare }, + { unpack(0x00000326, 0x30027009, 0x00001e03).blend }, + { unpack(0x00000326, 0x30027009, 0x00001e03).backblend }, + { unpack(0x00000326, 0x30027009, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x30027009, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x30027009, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x30027009, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x30027009, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x30027009, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x30027009, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x30027009, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x30027009, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x30027009, 0x00001e03).shade }, + { unpack(0x00000326, 0x30027009, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x30027009, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x30027009, 0x00001e03).stopony }, + { unpack(0x00000326, 0x30027009, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x30027009, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x30027009, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x30027009, 0x00001e03).length32 }, + { unpack(0x00000326, 0x30027009, 0x00001e03).lronly }, + { unpack(0x00000326, 0x30027009, 0x00001e03).ystride }, + { unpack(0x00000326, 0x30027009, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x30027009, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x30027009, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x30027009, 0x00001e03).yflip }, + { unpack(0x00000326, 0x30027009, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x30027009, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x30027009, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x30027009, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x30027009, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x30027009, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x30027009, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x30027009, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30027109 cm=0x00001e00 +unsafe extern "C" fn shader_00000326_30027109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30027109, 0x00001e00).opcode }, + { unpack(0x00000326, 0x30027109, 0x00001e00).planes }, + { unpack(0x00000326, 0x30027109, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x30027109, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x30027109, 0x00001e00).dither }, + { unpack(0x00000326, 0x30027109, 0x00001e00).logicop }, + { unpack(0x00000326, 0x30027109, 0x00001e00).compare }, + { unpack(0x00000326, 0x30027109, 0x00001e00).blend }, + { unpack(0x00000326, 0x30027109, 0x00001e00).backblend }, + { unpack(0x00000326, 0x30027109, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x30027109, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x30027109, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x30027109, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x30027109, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x30027109, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x30027109, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x30027109, 0x00001e00).shade }, + { unpack(0x00000326, 0x30027109, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x30027109, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x30027109, 0x00001e00).stopony }, + { unpack(0x00000326, 0x30027109, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x30027109, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x30027109, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x30027109, 0x00001e00).length32 }, + { unpack(0x00000326, 0x30027109, 0x00001e00).lronly }, + { unpack(0x00000326, 0x30027109, 0x00001e00).ystride }, + { unpack(0x00000326, 0x30027109, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x30027109, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x30027109, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x30027109, 0x00001e00).yflip }, + { unpack(0x00000326, 0x30027109, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x30027109, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x30027109, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x30027109, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x30027109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30027109 cm=0x00001e02 +unsafe extern "C" fn shader_00000326_30027109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30027109, 0x00001e02).opcode }, + { unpack(0x00000326, 0x30027109, 0x00001e02).planes }, + { unpack(0x00000326, 0x30027109, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x30027109, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x30027109, 0x00001e02).dither }, + { unpack(0x00000326, 0x30027109, 0x00001e02).logicop }, + { unpack(0x00000326, 0x30027109, 0x00001e02).compare }, + { unpack(0x00000326, 0x30027109, 0x00001e02).blend }, + { unpack(0x00000326, 0x30027109, 0x00001e02).backblend }, + { unpack(0x00000326, 0x30027109, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x30027109, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x30027109, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x30027109, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x30027109, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x30027109, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x30027109, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x30027109, 0x00001e02).shade }, + { unpack(0x00000326, 0x30027109, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x30027109, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x30027109, 0x00001e02).stopony }, + { unpack(0x00000326, 0x30027109, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x30027109, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x30027109, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x30027109, 0x00001e02).length32 }, + { unpack(0x00000326, 0x30027109, 0x00001e02).lronly }, + { unpack(0x00000326, 0x30027109, 0x00001e02).ystride }, + { unpack(0x00000326, 0x30027109, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x30027109, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x30027109, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x30027109, 0x00001e02).yflip }, + { unpack(0x00000326, 0x30027109, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x30027109, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x30027109, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x30027109, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x30027109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30027109 cm=0x00001e06 +unsafe extern "C" fn shader_00000326_30027109_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30027109, 0x00001e06).opcode }, + { unpack(0x00000326, 0x30027109, 0x00001e06).planes }, + { unpack(0x00000326, 0x30027109, 0x00001e06).drawdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e06).dblsrc }, + { unpack(0x00000326, 0x30027109, 0x00001e06).rgbmode }, + { unpack(0x00000326, 0x30027109, 0x00001e06).dither }, + { unpack(0x00000326, 0x30027109, 0x00001e06).logicop }, + { unpack(0x00000326, 0x30027109, 0x00001e06).compare }, + { unpack(0x00000326, 0x30027109, 0x00001e06).blend }, + { unpack(0x00000326, 0x30027109, 0x00001e06).backblend }, + { unpack(0x00000326, 0x30027109, 0x00001e06).blendalpha }, + { unpack(0x00000326, 0x30027109, 0x00001e06).fastclear }, + { unpack(0x00000326, 0x30027109, 0x00001e06).colorhost }, + { unpack(0x00000326, 0x30027109, 0x00001e06).alphahost }, + { unpack(0x00000326, 0x30027109, 0x00001e06).enzpattern }, + { unpack(0x00000326, 0x30027109, 0x00001e06).enlspattern }, + { unpack(0x00000326, 0x30027109, 0x00001e06).zpopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e06).lsopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e06).cidtest }, + { unpack(0x00000326, 0x30027109, 0x00001e06).shade }, + { unpack(0x00000326, 0x30027109, 0x00001e06).ciclamp }, + { unpack(0x00000326, 0x30027109, 0x00001e06).stoponx }, + { unpack(0x00000326, 0x30027109, 0x00001e06).stopony }, + { unpack(0x00000326, 0x30027109, 0x00001e06).skipfirst }, + { unpack(0x00000326, 0x30027109, 0x00001e06).skiplast }, + { unpack(0x00000326, 0x30027109, 0x00001e06).lsadvlast }, + { unpack(0x00000326, 0x30027109, 0x00001e06).length32 }, + { unpack(0x00000326, 0x30027109, 0x00001e06).lronly }, + { unpack(0x00000326, 0x30027109, 0x00001e06).ystride }, + { unpack(0x00000326, 0x30027109, 0x00001e06).endptfilter }, + { unpack(0x00000326, 0x30027109, 0x00001e06).adrmode }, + { unpack(0x00000326, 0x30027109, 0x00001e06).xyoffset }, + { unpack(0x00000326, 0x30027109, 0x00001e06).yflip }, + { unpack(0x00000326, 0x30027109, 0x00001e06).ensmask }, + { unpack(0x00000326, 0x30027109, 0x00001e06).cid_mask }, + { unpack(0x00000326, 0x30027109, 0x00001e06).sfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e06).dfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e06).rwpacked }, + { unpack(0x00000326, 0x30027109, 0x00001e06).hostdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e06).rwdouble }, + { unpack(0x00000326, 0x30027109, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30027109 cm=0x00001e0e +unsafe extern "C" fn shader_00000326_30027109_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30027109, 0x00001e0e).opcode }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).planes }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).drawdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).dblsrc }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).rgbmode }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).dither }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).logicop }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).compare }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).blend }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).backblend }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).blendalpha }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).fastclear }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).colorhost }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).alphahost }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).enzpattern }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).enlspattern }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).zpopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).lsopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).cidtest }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).shade }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).ciclamp }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).stoponx }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).stopony }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).skipfirst }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).skiplast }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).lsadvlast }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).length32 }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).lronly }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).ystride }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).endptfilter }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).adrmode }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).xyoffset }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).yflip }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).ensmask }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).cid_mask }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).sfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).dfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).rwpacked }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).hostdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).rwdouble }, + { unpack(0x00000326, 0x30027109, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30027109 cm=0x00001e1e +unsafe extern "C" fn shader_00000326_30027109_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30027109, 0x00001e1e).opcode }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).planes }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).drawdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).dblsrc }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).rgbmode }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).dither }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).logicop }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).compare }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).blend }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).backblend }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).blendalpha }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).fastclear }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).colorhost }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).alphahost }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).enzpattern }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).enlspattern }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).zpopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).lsopaque }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).cidtest }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).shade }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).ciclamp }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).stoponx }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).stopony }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).skipfirst }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).skiplast }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).lsadvlast }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).length32 }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).lronly }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).ystride }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).endptfilter }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).adrmode }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).xyoffset }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).yflip }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).ensmask }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).cid_mask }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).sfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).dfactor }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).rwpacked }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).hostdepth }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).rwdouble }, + { unpack(0x00000326, 0x30027109, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30027211 cm=0x00001e02 +unsafe extern "C" fn shader_00000326_30027211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30027211, 0x00001e02).opcode }, + { unpack(0x00000326, 0x30027211, 0x00001e02).planes }, + { unpack(0x00000326, 0x30027211, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x30027211, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x30027211, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x30027211, 0x00001e02).dither }, + { unpack(0x00000326, 0x30027211, 0x00001e02).logicop }, + { unpack(0x00000326, 0x30027211, 0x00001e02).compare }, + { unpack(0x00000326, 0x30027211, 0x00001e02).blend }, + { unpack(0x00000326, 0x30027211, 0x00001e02).backblend }, + { unpack(0x00000326, 0x30027211, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x30027211, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x30027211, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x30027211, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x30027211, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x30027211, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x30027211, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x30027211, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x30027211, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x30027211, 0x00001e02).shade }, + { unpack(0x00000326, 0x30027211, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x30027211, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x30027211, 0x00001e02).stopony }, + { unpack(0x00000326, 0x30027211, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x30027211, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x30027211, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x30027211, 0x00001e02).length32 }, + { unpack(0x00000326, 0x30027211, 0x00001e02).lronly }, + { unpack(0x00000326, 0x30027211, 0x00001e02).ystride }, + { unpack(0x00000326, 0x30027211, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x30027211, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x30027211, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x30027211, 0x00001e02).yflip }, + { unpack(0x00000326, 0x30027211, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x30027211, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x30027211, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x30027211, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x30027211, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x30027211, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x30027211, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x30027211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x30027211 cm=0x00001e1e +unsafe extern "C" fn shader_00000326_30027211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x30027211, 0x00001e1e).opcode }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).planes }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).drawdepth }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).dblsrc }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).rgbmode }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).dither }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).logicop }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).compare }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).blend }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).backblend }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).blendalpha }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).fastclear }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).colorhost }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).alphahost }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).enzpattern }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).enlspattern }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).zpopaque }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).lsopaque }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).cidtest }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).shade }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).ciclamp }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).stoponx }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).stopony }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).skipfirst }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).skiplast }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).lsadvlast }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).length32 }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).lronly }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).ystride }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).endptfilter }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).adrmode }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).xyoffset }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).yflip }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).ensmask }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).cid_mask }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).sfactor }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).dfactor }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).rwpacked }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).hostdepth }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).rwdouble }, + { unpack(0x00000326, 0x30027211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f109 cm=0x00001e00 +unsafe extern "C" fn shader_00000326_3002f109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f109, 0x00001e00).opcode }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).planes }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).dither }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).logicop }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).compare }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).blend }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).backblend }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).shade }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).stopony }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).length32 }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).lronly }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).ystride }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).yflip }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x3002f109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f109 cm=0x00001e02 +unsafe extern "C" fn shader_00000326_3002f109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f109, 0x00001e02).opcode }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).planes }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).dither }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).logicop }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).compare }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).blend }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).backblend }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).shade }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).stopony }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).length32 }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).lronly }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).ystride }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).yflip }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x3002f109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f211 cm=0x00001e00 +unsafe extern "C" fn shader_00000326_3002f211_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f211, 0x00001e00).opcode }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).planes }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).dither }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).logicop }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).compare }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).blend }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).backblend }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).shade }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).stopony }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).length32 }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).lronly }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).ystride }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).yflip }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x3002f211, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f211 cm=0x00001e02 +unsafe extern "C" fn shader_00000326_3002f211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f211, 0x00001e02).opcode }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).planes }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).dither }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).logicop }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).compare }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).blend }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).backblend }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).shade }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).stopony }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).length32 }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).lronly }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).ystride }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).yflip }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x3002f211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f211 cm=0x00001e06 +unsafe extern "C" fn shader_00000326_3002f211_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f211, 0x00001e06).opcode }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).planes }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).drawdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).dblsrc }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).rgbmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).dither }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).logicop }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).compare }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).blend }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).backblend }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).blendalpha }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).fastclear }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).colorhost }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).alphahost }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).enzpattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).enlspattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).zpopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).lsopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).cidtest }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).shade }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).ciclamp }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).stoponx }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).stopony }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).skipfirst }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).skiplast }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).lsadvlast }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).length32 }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).lronly }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).ystride }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).endptfilter }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).adrmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).xyoffset }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).yflip }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).ensmask }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).cid_mask }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).sfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).dfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).rwpacked }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).hostdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).rwdouble }, + { unpack(0x00000326, 0x3002f211, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f211 cm=0x00001e0e +unsafe extern "C" fn shader_00000326_3002f211_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f211, 0x00001e0e).opcode }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).planes }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).drawdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).dblsrc }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).rgbmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).dither }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).logicop }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).compare }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).blend }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).backblend }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).blendalpha }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).fastclear }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).colorhost }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).alphahost }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).enzpattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).enlspattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).zpopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).lsopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).cidtest }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).shade }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).ciclamp }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).stoponx }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).stopony }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).skipfirst }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).skiplast }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).lsadvlast }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).length32 }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).lronly }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).ystride }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).endptfilter }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).adrmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).xyoffset }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).yflip }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).ensmask }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).cid_mask }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).sfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).dfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).rwpacked }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).hostdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).rwdouble }, + { unpack(0x00000326, 0x3002f211, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f211 cm=0x00001e1e +unsafe extern "C" fn shader_00000326_3002f211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f211, 0x00001e1e).opcode }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).planes }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).drawdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).dblsrc }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).rgbmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).dither }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).logicop }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).compare }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).blend }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).backblend }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).blendalpha }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).fastclear }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).colorhost }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).alphahost }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).enzpattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).enlspattern }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).zpopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).lsopaque }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).cidtest }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).shade }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).ciclamp }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).stoponx }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).stopony }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).skipfirst }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).skiplast }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).lsadvlast }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).length32 }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).lronly }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).ystride }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).endptfilter }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).adrmode }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).xyoffset }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).yflip }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).ensmask }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).cid_mask }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).sfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).dfactor }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).rwpacked }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).hostdepth }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).rwdouble }, + { unpack(0x00000326, 0x3002f211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f231 cm=0x00001e02 +unsafe extern "C" fn shader_00000326_3002f231_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f231, 0x00001e02).opcode }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).planes }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).dither }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).logicop }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).compare }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).blend }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).backblend }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).shade }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).stopony }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).length32 }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).lronly }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).ystride }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).yflip }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x3002f231, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f231 cm=0x00001e06 +unsafe extern "C" fn shader_00000326_3002f231_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f231, 0x00001e06).opcode }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).planes }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).drawdepth }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).dblsrc }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).rgbmode }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).dither }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).logicop }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).compare }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).blend }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).backblend }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).blendalpha }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).fastclear }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).colorhost }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).alphahost }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).enzpattern }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).enlspattern }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).zpopaque }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).lsopaque }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).cidtest }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).shade }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).ciclamp }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).stoponx }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).stopony }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).skipfirst }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).skiplast }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).lsadvlast }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).length32 }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).lronly }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).ystride }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).endptfilter }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).adrmode }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).xyoffset }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).yflip }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).ensmask }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).cid_mask }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).sfactor }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).dfactor }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).rwpacked }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).hostdepth }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).rwdouble }, + { unpack(0x00000326, 0x3002f231, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f231 cm=0x00001e1e +unsafe extern "C" fn shader_00000326_3002f231_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f231, 0x00001e1e).opcode }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).planes }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).drawdepth }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).dblsrc }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).rgbmode }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).dither }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).logicop }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).compare }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).blend }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).backblend }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).blendalpha }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).fastclear }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).colorhost }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).alphahost }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).enzpattern }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).enlspattern }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).zpopaque }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).lsopaque }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).cidtest }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).shade }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).ciclamp }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).stoponx }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).stopony }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).skipfirst }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).skiplast }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).lsadvlast }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).length32 }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).lronly }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).ystride }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).endptfilter }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).adrmode }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).xyoffset }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).yflip }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).ensmask }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).cid_mask }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).sfactor }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).dfactor }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).rwpacked }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).hostdepth }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).rwdouble }, + { unpack(0x00000326, 0x3002f231, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f319 cm=0x00001e00 +unsafe extern "C" fn shader_00000326_3002f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f319, 0x00001e00).opcode }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).planes }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).dither }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).logicop }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).compare }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).blend }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).backblend }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).shade }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).stopony }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).length32 }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).lronly }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).ystride }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).yflip }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x3002f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f319 cm=0x00001e02 +unsafe extern "C" fn shader_00000326_3002f319_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f319, 0x00001e02).opcode }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).planes }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).dither }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).logicop }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).compare }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).blend }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).backblend }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).shade }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).stopony }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).length32 }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).lronly }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).ystride }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).yflip }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x3002f319, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f319 cm=0x00001e06 +unsafe extern "C" fn shader_00000326_3002f319_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f319, 0x00001e06).opcode }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).planes }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).drawdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).dblsrc }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).rgbmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).dither }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).logicop }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).compare }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).blend }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).backblend }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).blendalpha }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).fastclear }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).colorhost }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).alphahost }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).enzpattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).enlspattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).zpopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).lsopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).cidtest }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).shade }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).ciclamp }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).stoponx }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).stopony }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).skipfirst }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).skiplast }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).lsadvlast }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).length32 }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).lronly }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).ystride }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).endptfilter }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).adrmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).xyoffset }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).yflip }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).ensmask }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).cid_mask }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).sfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).dfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).rwpacked }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).hostdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).rwdouble }, + { unpack(0x00000326, 0x3002f319, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f319 cm=0x00001e0e +unsafe extern "C" fn shader_00000326_3002f319_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f319, 0x00001e0e).opcode }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).planes }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).drawdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).dblsrc }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).rgbmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).dither }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).logicop }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).compare }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).blend }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).backblend }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).blendalpha }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).fastclear }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).colorhost }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).alphahost }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).enzpattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).enlspattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).zpopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).lsopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).cidtest }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).shade }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).ciclamp }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).stoponx }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).stopony }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).skipfirst }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).skiplast }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).lsadvlast }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).length32 }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).lronly }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).ystride }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).endptfilter }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).adrmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).xyoffset }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).yflip }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).ensmask }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).cid_mask }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).sfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).dfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).rwpacked }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).hostdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).rwdouble }, + { unpack(0x00000326, 0x3002f319, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f319 cm=0x00001e1e +unsafe extern "C" fn shader_00000326_3002f319_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f319, 0x00001e1e).opcode }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).planes }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).drawdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).dblsrc }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).rgbmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).dither }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).logicop }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).compare }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).blend }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).backblend }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).blendalpha }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).fastclear }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).colorhost }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).alphahost }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).enzpattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).enlspattern }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).zpopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).lsopaque }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).cidtest }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).shade }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).ciclamp }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).stoponx }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).stopony }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).skipfirst }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).skiplast }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).lsadvlast }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).length32 }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).lronly }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).ystride }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).endptfilter }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).adrmode }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).xyoffset }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).yflip }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).ensmask }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).cid_mask }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).sfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).dfactor }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).rwpacked }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).hostdepth }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).rwdouble }, + { unpack(0x00000326, 0x3002f319, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3002f399 cm=0x00001e00 +unsafe extern "C" fn shader_00000326_3002f399_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3002f399, 0x00001e00).opcode }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).planes }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).dither }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).logicop }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).compare }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).blend }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).backblend }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).fastclear }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).colorhost }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).alphahost }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).cidtest }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).shade }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).stoponx }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).stopony }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).skiplast }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).length32 }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).lronly }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).ystride }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).adrmode }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).yflip }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).ensmask }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).sfactor }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).dfactor }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0x3002f399, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3009700c cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3009700c_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3009700c, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).planes }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).dither }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).compare }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).blend }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).shade }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3009700c, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3009700d cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3009700d_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3009700d, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).planes }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).dither }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).compare }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).blend }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).shade }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3009700d, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3009f391 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3009f391_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3009f391, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).planes }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).dither }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).compare }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).blend }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).shade }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3009f391, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3009f3b1 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3009f3b1_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).planes }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).dither }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).compare }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).blend }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).shade }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3009f3b1, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300af009 cm=0x00000203 +unsafe extern "C" fn shader_00000326_300af009_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300af009, 0x00000203).opcode }, + { unpack(0x00000326, 0x300af009, 0x00000203).planes }, + { unpack(0x00000326, 0x300af009, 0x00000203).drawdepth }, + { unpack(0x00000326, 0x300af009, 0x00000203).dblsrc }, + { unpack(0x00000326, 0x300af009, 0x00000203).rgbmode }, + { unpack(0x00000326, 0x300af009, 0x00000203).dither }, + { unpack(0x00000326, 0x300af009, 0x00000203).logicop }, + { unpack(0x00000326, 0x300af009, 0x00000203).compare }, + { unpack(0x00000326, 0x300af009, 0x00000203).blend }, + { unpack(0x00000326, 0x300af009, 0x00000203).backblend }, + { unpack(0x00000326, 0x300af009, 0x00000203).blendalpha }, + { unpack(0x00000326, 0x300af009, 0x00000203).fastclear }, + { unpack(0x00000326, 0x300af009, 0x00000203).colorhost }, + { unpack(0x00000326, 0x300af009, 0x00000203).alphahost }, + { unpack(0x00000326, 0x300af009, 0x00000203).enzpattern }, + { unpack(0x00000326, 0x300af009, 0x00000203).enlspattern }, + { unpack(0x00000326, 0x300af009, 0x00000203).zpopaque }, + { unpack(0x00000326, 0x300af009, 0x00000203).lsopaque }, + { unpack(0x00000326, 0x300af009, 0x00000203).cidtest }, + { unpack(0x00000326, 0x300af009, 0x00000203).shade }, + { unpack(0x00000326, 0x300af009, 0x00000203).ciclamp }, + { unpack(0x00000326, 0x300af009, 0x00000203).stoponx }, + { unpack(0x00000326, 0x300af009, 0x00000203).stopony }, + { unpack(0x00000326, 0x300af009, 0x00000203).skipfirst }, + { unpack(0x00000326, 0x300af009, 0x00000203).skiplast }, + { unpack(0x00000326, 0x300af009, 0x00000203).lsadvlast }, + { unpack(0x00000326, 0x300af009, 0x00000203).length32 }, + { unpack(0x00000326, 0x300af009, 0x00000203).lronly }, + { unpack(0x00000326, 0x300af009, 0x00000203).ystride }, + { unpack(0x00000326, 0x300af009, 0x00000203).endptfilter }, + { unpack(0x00000326, 0x300af009, 0x00000203).adrmode }, + { unpack(0x00000326, 0x300af009, 0x00000203).xyoffset }, + { unpack(0x00000326, 0x300af009, 0x00000203).yflip }, + { unpack(0x00000326, 0x300af009, 0x00000203).ensmask }, + { unpack(0x00000326, 0x300af009, 0x00000203).cid_mask }, + { unpack(0x00000326, 0x300af009, 0x00000203).sfactor }, + { unpack(0x00000326, 0x300af009, 0x00000203).dfactor }, + { unpack(0x00000326, 0x300af009, 0x00000203).rwpacked }, + { unpack(0x00000326, 0x300af009, 0x00000203).hostdepth }, + { unpack(0x00000326, 0x300af009, 0x00000203).rwdouble }, + { unpack(0x00000326, 0x300af009, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300af009 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_300af009_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300af009, 0x00001e03).opcode }, + { unpack(0x00000326, 0x300af009, 0x00001e03).planes }, + { unpack(0x00000326, 0x300af009, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x300af009, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x300af009, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x300af009, 0x00001e03).dither }, + { unpack(0x00000326, 0x300af009, 0x00001e03).logicop }, + { unpack(0x00000326, 0x300af009, 0x00001e03).compare }, + { unpack(0x00000326, 0x300af009, 0x00001e03).blend }, + { unpack(0x00000326, 0x300af009, 0x00001e03).backblend }, + { unpack(0x00000326, 0x300af009, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x300af009, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x300af009, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x300af009, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x300af009, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x300af009, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x300af009, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x300af009, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x300af009, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x300af009, 0x00001e03).shade }, + { unpack(0x00000326, 0x300af009, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x300af009, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x300af009, 0x00001e03).stopony }, + { unpack(0x00000326, 0x300af009, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x300af009, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x300af009, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x300af009, 0x00001e03).length32 }, + { unpack(0x00000326, 0x300af009, 0x00001e03).lronly }, + { unpack(0x00000326, 0x300af009, 0x00001e03).ystride }, + { unpack(0x00000326, 0x300af009, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x300af009, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x300af009, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x300af009, 0x00001e03).yflip }, + { unpack(0x00000326, 0x300af009, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x300af009, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x300af009, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x300af009, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x300af009, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x300af009, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x300af009, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x300af009, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300af011 cm=0x00000203 +unsafe extern "C" fn shader_00000326_300af011_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300af011, 0x00000203).opcode }, + { unpack(0x00000326, 0x300af011, 0x00000203).planes }, + { unpack(0x00000326, 0x300af011, 0x00000203).drawdepth }, + { unpack(0x00000326, 0x300af011, 0x00000203).dblsrc }, + { unpack(0x00000326, 0x300af011, 0x00000203).rgbmode }, + { unpack(0x00000326, 0x300af011, 0x00000203).dither }, + { unpack(0x00000326, 0x300af011, 0x00000203).logicop }, + { unpack(0x00000326, 0x300af011, 0x00000203).compare }, + { unpack(0x00000326, 0x300af011, 0x00000203).blend }, + { unpack(0x00000326, 0x300af011, 0x00000203).backblend }, + { unpack(0x00000326, 0x300af011, 0x00000203).blendalpha }, + { unpack(0x00000326, 0x300af011, 0x00000203).fastclear }, + { unpack(0x00000326, 0x300af011, 0x00000203).colorhost }, + { unpack(0x00000326, 0x300af011, 0x00000203).alphahost }, + { unpack(0x00000326, 0x300af011, 0x00000203).enzpattern }, + { unpack(0x00000326, 0x300af011, 0x00000203).enlspattern }, + { unpack(0x00000326, 0x300af011, 0x00000203).zpopaque }, + { unpack(0x00000326, 0x300af011, 0x00000203).lsopaque }, + { unpack(0x00000326, 0x300af011, 0x00000203).cidtest }, + { unpack(0x00000326, 0x300af011, 0x00000203).shade }, + { unpack(0x00000326, 0x300af011, 0x00000203).ciclamp }, + { unpack(0x00000326, 0x300af011, 0x00000203).stoponx }, + { unpack(0x00000326, 0x300af011, 0x00000203).stopony }, + { unpack(0x00000326, 0x300af011, 0x00000203).skipfirst }, + { unpack(0x00000326, 0x300af011, 0x00000203).skiplast }, + { unpack(0x00000326, 0x300af011, 0x00000203).lsadvlast }, + { unpack(0x00000326, 0x300af011, 0x00000203).length32 }, + { unpack(0x00000326, 0x300af011, 0x00000203).lronly }, + { unpack(0x00000326, 0x300af011, 0x00000203).ystride }, + { unpack(0x00000326, 0x300af011, 0x00000203).endptfilter }, + { unpack(0x00000326, 0x300af011, 0x00000203).adrmode }, + { unpack(0x00000326, 0x300af011, 0x00000203).xyoffset }, + { unpack(0x00000326, 0x300af011, 0x00000203).yflip }, + { unpack(0x00000326, 0x300af011, 0x00000203).ensmask }, + { unpack(0x00000326, 0x300af011, 0x00000203).cid_mask }, + { unpack(0x00000326, 0x300af011, 0x00000203).sfactor }, + { unpack(0x00000326, 0x300af011, 0x00000203).dfactor }, + { unpack(0x00000326, 0x300af011, 0x00000203).rwpacked }, + { unpack(0x00000326, 0x300af011, 0x00000203).hostdepth }, + { unpack(0x00000326, 0x300af011, 0x00000203).rwdouble }, + { unpack(0x00000326, 0x300af011, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300af011 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_300af011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300af011, 0x00001e03).opcode }, + { unpack(0x00000326, 0x300af011, 0x00001e03).planes }, + { unpack(0x00000326, 0x300af011, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x300af011, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x300af011, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x300af011, 0x00001e03).dither }, + { unpack(0x00000326, 0x300af011, 0x00001e03).logicop }, + { unpack(0x00000326, 0x300af011, 0x00001e03).compare }, + { unpack(0x00000326, 0x300af011, 0x00001e03).blend }, + { unpack(0x00000326, 0x300af011, 0x00001e03).backblend }, + { unpack(0x00000326, 0x300af011, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x300af011, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x300af011, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x300af011, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x300af011, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x300af011, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x300af011, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x300af011, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x300af011, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x300af011, 0x00001e03).shade }, + { unpack(0x00000326, 0x300af011, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x300af011, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x300af011, 0x00001e03).stopony }, + { unpack(0x00000326, 0x300af011, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x300af011, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x300af011, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x300af011, 0x00001e03).length32 }, + { unpack(0x00000326, 0x300af011, 0x00001e03).lronly }, + { unpack(0x00000326, 0x300af011, 0x00001e03).ystride }, + { unpack(0x00000326, 0x300af011, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x300af011, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x300af011, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x300af011, 0x00001e03).yflip }, + { unpack(0x00000326, 0x300af011, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x300af011, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x300af011, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x300af011, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x300af011, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x300af011, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x300af011, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x300af011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300af019 cm=0x00000203 +unsafe extern "C" fn shader_00000326_300af019_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300af019, 0x00000203).opcode }, + { unpack(0x00000326, 0x300af019, 0x00000203).planes }, + { unpack(0x00000326, 0x300af019, 0x00000203).drawdepth }, + { unpack(0x00000326, 0x300af019, 0x00000203).dblsrc }, + { unpack(0x00000326, 0x300af019, 0x00000203).rgbmode }, + { unpack(0x00000326, 0x300af019, 0x00000203).dither }, + { unpack(0x00000326, 0x300af019, 0x00000203).logicop }, + { unpack(0x00000326, 0x300af019, 0x00000203).compare }, + { unpack(0x00000326, 0x300af019, 0x00000203).blend }, + { unpack(0x00000326, 0x300af019, 0x00000203).backblend }, + { unpack(0x00000326, 0x300af019, 0x00000203).blendalpha }, + { unpack(0x00000326, 0x300af019, 0x00000203).fastclear }, + { unpack(0x00000326, 0x300af019, 0x00000203).colorhost }, + { unpack(0x00000326, 0x300af019, 0x00000203).alphahost }, + { unpack(0x00000326, 0x300af019, 0x00000203).enzpattern }, + { unpack(0x00000326, 0x300af019, 0x00000203).enlspattern }, + { unpack(0x00000326, 0x300af019, 0x00000203).zpopaque }, + { unpack(0x00000326, 0x300af019, 0x00000203).lsopaque }, + { unpack(0x00000326, 0x300af019, 0x00000203).cidtest }, + { unpack(0x00000326, 0x300af019, 0x00000203).shade }, + { unpack(0x00000326, 0x300af019, 0x00000203).ciclamp }, + { unpack(0x00000326, 0x300af019, 0x00000203).stoponx }, + { unpack(0x00000326, 0x300af019, 0x00000203).stopony }, + { unpack(0x00000326, 0x300af019, 0x00000203).skipfirst }, + { unpack(0x00000326, 0x300af019, 0x00000203).skiplast }, + { unpack(0x00000326, 0x300af019, 0x00000203).lsadvlast }, + { unpack(0x00000326, 0x300af019, 0x00000203).length32 }, + { unpack(0x00000326, 0x300af019, 0x00000203).lronly }, + { unpack(0x00000326, 0x300af019, 0x00000203).ystride }, + { unpack(0x00000326, 0x300af019, 0x00000203).endptfilter }, + { unpack(0x00000326, 0x300af019, 0x00000203).adrmode }, + { unpack(0x00000326, 0x300af019, 0x00000203).xyoffset }, + { unpack(0x00000326, 0x300af019, 0x00000203).yflip }, + { unpack(0x00000326, 0x300af019, 0x00000203).ensmask }, + { unpack(0x00000326, 0x300af019, 0x00000203).cid_mask }, + { unpack(0x00000326, 0x300af019, 0x00000203).sfactor }, + { unpack(0x00000326, 0x300af019, 0x00000203).dfactor }, + { unpack(0x00000326, 0x300af019, 0x00000203).rwpacked }, + { unpack(0x00000326, 0x300af019, 0x00000203).hostdepth }, + { unpack(0x00000326, 0x300af019, 0x00000203).rwdouble }, + { unpack(0x00000326, 0x300af019, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300af019 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_300af019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300af019, 0x00001e03).opcode }, + { unpack(0x00000326, 0x300af019, 0x00001e03).planes }, + { unpack(0x00000326, 0x300af019, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x300af019, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x300af019, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x300af019, 0x00001e03).dither }, + { unpack(0x00000326, 0x300af019, 0x00001e03).logicop }, + { unpack(0x00000326, 0x300af019, 0x00001e03).compare }, + { unpack(0x00000326, 0x300af019, 0x00001e03).blend }, + { unpack(0x00000326, 0x300af019, 0x00001e03).backblend }, + { unpack(0x00000326, 0x300af019, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x300af019, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x300af019, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x300af019, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x300af019, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x300af019, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x300af019, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x300af019, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x300af019, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x300af019, 0x00001e03).shade }, + { unpack(0x00000326, 0x300af019, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x300af019, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x300af019, 0x00001e03).stopony }, + { unpack(0x00000326, 0x300af019, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x300af019, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x300af019, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x300af019, 0x00001e03).length32 }, + { unpack(0x00000326, 0x300af019, 0x00001e03).lronly }, + { unpack(0x00000326, 0x300af019, 0x00001e03).ystride }, + { unpack(0x00000326, 0x300af019, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x300af019, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x300af019, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x300af019, 0x00001e03).yflip }, + { unpack(0x00000326, 0x300af019, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x300af019, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x300af019, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x300af019, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x300af019, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x300af019, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x300af019, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x300af019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300af031 cm=0x00000203 +unsafe extern "C" fn shader_00000326_300af031_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300af031, 0x00000203).opcode }, + { unpack(0x00000326, 0x300af031, 0x00000203).planes }, + { unpack(0x00000326, 0x300af031, 0x00000203).drawdepth }, + { unpack(0x00000326, 0x300af031, 0x00000203).dblsrc }, + { unpack(0x00000326, 0x300af031, 0x00000203).rgbmode }, + { unpack(0x00000326, 0x300af031, 0x00000203).dither }, + { unpack(0x00000326, 0x300af031, 0x00000203).logicop }, + { unpack(0x00000326, 0x300af031, 0x00000203).compare }, + { unpack(0x00000326, 0x300af031, 0x00000203).blend }, + { unpack(0x00000326, 0x300af031, 0x00000203).backblend }, + { unpack(0x00000326, 0x300af031, 0x00000203).blendalpha }, + { unpack(0x00000326, 0x300af031, 0x00000203).fastclear }, + { unpack(0x00000326, 0x300af031, 0x00000203).colorhost }, + { unpack(0x00000326, 0x300af031, 0x00000203).alphahost }, + { unpack(0x00000326, 0x300af031, 0x00000203).enzpattern }, + { unpack(0x00000326, 0x300af031, 0x00000203).enlspattern }, + { unpack(0x00000326, 0x300af031, 0x00000203).zpopaque }, + { unpack(0x00000326, 0x300af031, 0x00000203).lsopaque }, + { unpack(0x00000326, 0x300af031, 0x00000203).cidtest }, + { unpack(0x00000326, 0x300af031, 0x00000203).shade }, + { unpack(0x00000326, 0x300af031, 0x00000203).ciclamp }, + { unpack(0x00000326, 0x300af031, 0x00000203).stoponx }, + { unpack(0x00000326, 0x300af031, 0x00000203).stopony }, + { unpack(0x00000326, 0x300af031, 0x00000203).skipfirst }, + { unpack(0x00000326, 0x300af031, 0x00000203).skiplast }, + { unpack(0x00000326, 0x300af031, 0x00000203).lsadvlast }, + { unpack(0x00000326, 0x300af031, 0x00000203).length32 }, + { unpack(0x00000326, 0x300af031, 0x00000203).lronly }, + { unpack(0x00000326, 0x300af031, 0x00000203).ystride }, + { unpack(0x00000326, 0x300af031, 0x00000203).endptfilter }, + { unpack(0x00000326, 0x300af031, 0x00000203).adrmode }, + { unpack(0x00000326, 0x300af031, 0x00000203).xyoffset }, + { unpack(0x00000326, 0x300af031, 0x00000203).yflip }, + { unpack(0x00000326, 0x300af031, 0x00000203).ensmask }, + { unpack(0x00000326, 0x300af031, 0x00000203).cid_mask }, + { unpack(0x00000326, 0x300af031, 0x00000203).sfactor }, + { unpack(0x00000326, 0x300af031, 0x00000203).dfactor }, + { unpack(0x00000326, 0x300af031, 0x00000203).rwpacked }, + { unpack(0x00000326, 0x300af031, 0x00000203).hostdepth }, + { unpack(0x00000326, 0x300af031, 0x00000203).rwdouble }, + { unpack(0x00000326, 0x300af031, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300af031 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_300af031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300af031, 0x00001e03).opcode }, + { unpack(0x00000326, 0x300af031, 0x00001e03).planes }, + { unpack(0x00000326, 0x300af031, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x300af031, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x300af031, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x300af031, 0x00001e03).dither }, + { unpack(0x00000326, 0x300af031, 0x00001e03).logicop }, + { unpack(0x00000326, 0x300af031, 0x00001e03).compare }, + { unpack(0x00000326, 0x300af031, 0x00001e03).blend }, + { unpack(0x00000326, 0x300af031, 0x00001e03).backblend }, + { unpack(0x00000326, 0x300af031, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x300af031, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x300af031, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x300af031, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x300af031, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x300af031, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x300af031, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x300af031, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x300af031, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x300af031, 0x00001e03).shade }, + { unpack(0x00000326, 0x300af031, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x300af031, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x300af031, 0x00001e03).stopony }, + { unpack(0x00000326, 0x300af031, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x300af031, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x300af031, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x300af031, 0x00001e03).length32 }, + { unpack(0x00000326, 0x300af031, 0x00001e03).lronly }, + { unpack(0x00000326, 0x300af031, 0x00001e03).ystride }, + { unpack(0x00000326, 0x300af031, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x300af031, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x300af031, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x300af031, 0x00001e03).yflip }, + { unpack(0x00000326, 0x300af031, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x300af031, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x300af031, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x300af031, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x300af031, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x300af031, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x300af031, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x300af031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300b7011 cm=0x00000403 +unsafe extern "C" fn shader_00000326_300b7011_00000403( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300b7011, 0x00000403).opcode }, + { unpack(0x00000326, 0x300b7011, 0x00000403).planes }, + { unpack(0x00000326, 0x300b7011, 0x00000403).drawdepth }, + { unpack(0x00000326, 0x300b7011, 0x00000403).dblsrc }, + { unpack(0x00000326, 0x300b7011, 0x00000403).rgbmode }, + { unpack(0x00000326, 0x300b7011, 0x00000403).dither }, + { unpack(0x00000326, 0x300b7011, 0x00000403).logicop }, + { unpack(0x00000326, 0x300b7011, 0x00000403).compare }, + { unpack(0x00000326, 0x300b7011, 0x00000403).blend }, + { unpack(0x00000326, 0x300b7011, 0x00000403).backblend }, + { unpack(0x00000326, 0x300b7011, 0x00000403).blendalpha }, + { unpack(0x00000326, 0x300b7011, 0x00000403).fastclear }, + { unpack(0x00000326, 0x300b7011, 0x00000403).colorhost }, + { unpack(0x00000326, 0x300b7011, 0x00000403).alphahost }, + { unpack(0x00000326, 0x300b7011, 0x00000403).enzpattern }, + { unpack(0x00000326, 0x300b7011, 0x00000403).enlspattern }, + { unpack(0x00000326, 0x300b7011, 0x00000403).zpopaque }, + { unpack(0x00000326, 0x300b7011, 0x00000403).lsopaque }, + { unpack(0x00000326, 0x300b7011, 0x00000403).cidtest }, + { unpack(0x00000326, 0x300b7011, 0x00000403).shade }, + { unpack(0x00000326, 0x300b7011, 0x00000403).ciclamp }, + { unpack(0x00000326, 0x300b7011, 0x00000403).stoponx }, + { unpack(0x00000326, 0x300b7011, 0x00000403).stopony }, + { unpack(0x00000326, 0x300b7011, 0x00000403).skipfirst }, + { unpack(0x00000326, 0x300b7011, 0x00000403).skiplast }, + { unpack(0x00000326, 0x300b7011, 0x00000403).lsadvlast }, + { unpack(0x00000326, 0x300b7011, 0x00000403).length32 }, + { unpack(0x00000326, 0x300b7011, 0x00000403).lronly }, + { unpack(0x00000326, 0x300b7011, 0x00000403).ystride }, + { unpack(0x00000326, 0x300b7011, 0x00000403).endptfilter }, + { unpack(0x00000326, 0x300b7011, 0x00000403).adrmode }, + { unpack(0x00000326, 0x300b7011, 0x00000403).xyoffset }, + { unpack(0x00000326, 0x300b7011, 0x00000403).yflip }, + { unpack(0x00000326, 0x300b7011, 0x00000403).ensmask }, + { unpack(0x00000326, 0x300b7011, 0x00000403).cid_mask }, + { unpack(0x00000326, 0x300b7011, 0x00000403).sfactor }, + { unpack(0x00000326, 0x300b7011, 0x00000403).dfactor }, + { unpack(0x00000326, 0x300b7011, 0x00000403).rwpacked }, + { unpack(0x00000326, 0x300b7011, 0x00000403).hostdepth }, + { unpack(0x00000326, 0x300b7011, 0x00000403).rwdouble }, + { unpack(0x00000326, 0x300b7011, 0x00000403).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300b7011 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_300b7011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300b7011, 0x00001e03).opcode }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).planes }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).dither }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).logicop }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).compare }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).blend }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).backblend }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).shade }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).stopony }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).length32 }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).lronly }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).ystride }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).yflip }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x300b7011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300b7031 cm=0x00000403 +unsafe extern "C" fn shader_00000326_300b7031_00000403( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300b7031, 0x00000403).opcode }, + { unpack(0x00000326, 0x300b7031, 0x00000403).planes }, + { unpack(0x00000326, 0x300b7031, 0x00000403).drawdepth }, + { unpack(0x00000326, 0x300b7031, 0x00000403).dblsrc }, + { unpack(0x00000326, 0x300b7031, 0x00000403).rgbmode }, + { unpack(0x00000326, 0x300b7031, 0x00000403).dither }, + { unpack(0x00000326, 0x300b7031, 0x00000403).logicop }, + { unpack(0x00000326, 0x300b7031, 0x00000403).compare }, + { unpack(0x00000326, 0x300b7031, 0x00000403).blend }, + { unpack(0x00000326, 0x300b7031, 0x00000403).backblend }, + { unpack(0x00000326, 0x300b7031, 0x00000403).blendalpha }, + { unpack(0x00000326, 0x300b7031, 0x00000403).fastclear }, + { unpack(0x00000326, 0x300b7031, 0x00000403).colorhost }, + { unpack(0x00000326, 0x300b7031, 0x00000403).alphahost }, + { unpack(0x00000326, 0x300b7031, 0x00000403).enzpattern }, + { unpack(0x00000326, 0x300b7031, 0x00000403).enlspattern }, + { unpack(0x00000326, 0x300b7031, 0x00000403).zpopaque }, + { unpack(0x00000326, 0x300b7031, 0x00000403).lsopaque }, + { unpack(0x00000326, 0x300b7031, 0x00000403).cidtest }, + { unpack(0x00000326, 0x300b7031, 0x00000403).shade }, + { unpack(0x00000326, 0x300b7031, 0x00000403).ciclamp }, + { unpack(0x00000326, 0x300b7031, 0x00000403).stoponx }, + { unpack(0x00000326, 0x300b7031, 0x00000403).stopony }, + { unpack(0x00000326, 0x300b7031, 0x00000403).skipfirst }, + { unpack(0x00000326, 0x300b7031, 0x00000403).skiplast }, + { unpack(0x00000326, 0x300b7031, 0x00000403).lsadvlast }, + { unpack(0x00000326, 0x300b7031, 0x00000403).length32 }, + { unpack(0x00000326, 0x300b7031, 0x00000403).lronly }, + { unpack(0x00000326, 0x300b7031, 0x00000403).ystride }, + { unpack(0x00000326, 0x300b7031, 0x00000403).endptfilter }, + { unpack(0x00000326, 0x300b7031, 0x00000403).adrmode }, + { unpack(0x00000326, 0x300b7031, 0x00000403).xyoffset }, + { unpack(0x00000326, 0x300b7031, 0x00000403).yflip }, + { unpack(0x00000326, 0x300b7031, 0x00000403).ensmask }, + { unpack(0x00000326, 0x300b7031, 0x00000403).cid_mask }, + { unpack(0x00000326, 0x300b7031, 0x00000403).sfactor }, + { unpack(0x00000326, 0x300b7031, 0x00000403).dfactor }, + { unpack(0x00000326, 0x300b7031, 0x00000403).rwpacked }, + { unpack(0x00000326, 0x300b7031, 0x00000403).hostdepth }, + { unpack(0x00000326, 0x300b7031, 0x00000403).rwdouble }, + { unpack(0x00000326, 0x300b7031, 0x00000403).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300b7031 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_300b7031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300b7031, 0x00001e03).opcode }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).planes }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).dither }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).logicop }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).compare }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).blend }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).backblend }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).shade }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).stopony }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).length32 }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).lronly }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).ystride }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).yflip }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x300b7031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300bf011 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_300bf011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300bf011, 0x00001e03).opcode }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).planes }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).dither }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).logicop }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).compare }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).blend }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).backblend }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).shade }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).stopony }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).length32 }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).lronly }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).ystride }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).yflip }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x300bf011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300bf019 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_300bf019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300bf019, 0x00001e03).opcode }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).planes }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).dither }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).logicop }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).compare }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).blend }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).backblend }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).shade }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).stopony }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).length32 }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).lronly }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).ystride }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).yflip }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x300bf019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300bf019 cm=0x00001e1f +unsafe extern "C" fn shader_00000326_300bf019_00001e1f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300bf019, 0x00001e1f).opcode }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).planes }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).drawdepth }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).dblsrc }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).rgbmode }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).dither }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).logicop }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).compare }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).blend }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).backblend }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).blendalpha }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).fastclear }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).colorhost }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).alphahost }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).enzpattern }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).enlspattern }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).zpopaque }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).lsopaque }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).cidtest }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).shade }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).ciclamp }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).stoponx }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).stopony }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).skipfirst }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).skiplast }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).lsadvlast }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).length32 }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).lronly }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).ystride }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).endptfilter }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).adrmode }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).xyoffset }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).yflip }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).ensmask }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).cid_mask }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).sfactor }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).dfactor }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).rwpacked }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).hostdepth }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).rwdouble }, + { unpack(0x00000326, 0x300bf019, 0x00001e1f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x300bf031 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_300bf031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x300bf031, 0x00001e03).opcode }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).planes }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).dither }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).logicop }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).compare }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).blend }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).backblend }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).shade }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).stopony }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).length32 }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).lronly }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).ystride }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).yflip }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x300bf031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).planes }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).dither }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).compare }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).blend }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).shade }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).planes }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).dither }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).compare }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).blend }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).shade }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3162f011 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3162f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3162f011, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).planes }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).dither }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).compare }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).blend }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).shade }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3162f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3162f011 cm=0x00001e0f +unsafe extern "C" fn shader_00000326_3162f011_00001e0f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3162f011, 0x00001e0f).opcode }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).planes }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).drawdepth }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).dblsrc }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).rgbmode }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).dither }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).logicop }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).compare }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).blend }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).backblend }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).blendalpha }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).fastclear }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).colorhost }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).alphahost }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).enzpattern }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).enlspattern }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).zpopaque }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).lsopaque }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).cidtest }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).shade }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).ciclamp }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).stoponx }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).stopony }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).skipfirst }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).skiplast }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).lsadvlast }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).length32 }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).lronly }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).ystride }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).endptfilter }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).adrmode }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).xyoffset }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).yflip }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).ensmask }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).cid_mask }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).sfactor }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).dfactor }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).rwpacked }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).hostdepth }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).rwdouble }, + { unpack(0x00000326, 0x3162f011, 0x00001e0f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3162f019 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3162f019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3162f019, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).planes }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).dither }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).compare }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).blend }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).shade }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3162f019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3162f031 cm=0x00000203 +unsafe extern "C" fn shader_00000326_3162f031_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3162f031, 0x00000203).opcode }, + { unpack(0x00000326, 0x3162f031, 0x00000203).planes }, + { unpack(0x00000326, 0x3162f031, 0x00000203).drawdepth }, + { unpack(0x00000326, 0x3162f031, 0x00000203).dblsrc }, + { unpack(0x00000326, 0x3162f031, 0x00000203).rgbmode }, + { unpack(0x00000326, 0x3162f031, 0x00000203).dither }, + { unpack(0x00000326, 0x3162f031, 0x00000203).logicop }, + { unpack(0x00000326, 0x3162f031, 0x00000203).compare }, + { unpack(0x00000326, 0x3162f031, 0x00000203).blend }, + { unpack(0x00000326, 0x3162f031, 0x00000203).backblend }, + { unpack(0x00000326, 0x3162f031, 0x00000203).blendalpha }, + { unpack(0x00000326, 0x3162f031, 0x00000203).fastclear }, + { unpack(0x00000326, 0x3162f031, 0x00000203).colorhost }, + { unpack(0x00000326, 0x3162f031, 0x00000203).alphahost }, + { unpack(0x00000326, 0x3162f031, 0x00000203).enzpattern }, + { unpack(0x00000326, 0x3162f031, 0x00000203).enlspattern }, + { unpack(0x00000326, 0x3162f031, 0x00000203).zpopaque }, + { unpack(0x00000326, 0x3162f031, 0x00000203).lsopaque }, + { unpack(0x00000326, 0x3162f031, 0x00000203).cidtest }, + { unpack(0x00000326, 0x3162f031, 0x00000203).shade }, + { unpack(0x00000326, 0x3162f031, 0x00000203).ciclamp }, + { unpack(0x00000326, 0x3162f031, 0x00000203).stoponx }, + { unpack(0x00000326, 0x3162f031, 0x00000203).stopony }, + { unpack(0x00000326, 0x3162f031, 0x00000203).skipfirst }, + { unpack(0x00000326, 0x3162f031, 0x00000203).skiplast }, + { unpack(0x00000326, 0x3162f031, 0x00000203).lsadvlast }, + { unpack(0x00000326, 0x3162f031, 0x00000203).length32 }, + { unpack(0x00000326, 0x3162f031, 0x00000203).lronly }, + { unpack(0x00000326, 0x3162f031, 0x00000203).ystride }, + { unpack(0x00000326, 0x3162f031, 0x00000203).endptfilter }, + { unpack(0x00000326, 0x3162f031, 0x00000203).adrmode }, + { unpack(0x00000326, 0x3162f031, 0x00000203).xyoffset }, + { unpack(0x00000326, 0x3162f031, 0x00000203).yflip }, + { unpack(0x00000326, 0x3162f031, 0x00000203).ensmask }, + { unpack(0x00000326, 0x3162f031, 0x00000203).cid_mask }, + { unpack(0x00000326, 0x3162f031, 0x00000203).sfactor }, + { unpack(0x00000326, 0x3162f031, 0x00000203).dfactor }, + { unpack(0x00000326, 0x3162f031, 0x00000203).rwpacked }, + { unpack(0x00000326, 0x3162f031, 0x00000203).hostdepth }, + { unpack(0x00000326, 0x3162f031, 0x00000203).rwdouble }, + { unpack(0x00000326, 0x3162f031, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3162f031 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3162f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3162f031, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).planes }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).dither }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).compare }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).blend }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).shade }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3162f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3162f031 cm=0x00001e0f +unsafe extern "C" fn shader_00000326_3162f031_00001e0f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3162f031, 0x00001e0f).opcode }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).planes }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).drawdepth }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).dblsrc }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).rgbmode }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).dither }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).logicop }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).compare }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).blend }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).backblend }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).blendalpha }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).fastclear }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).colorhost }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).alphahost }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).enzpattern }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).enlspattern }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).zpopaque }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).lsopaque }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).cidtest }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).shade }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).ciclamp }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).stoponx }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).stopony }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).skipfirst }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).skiplast }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).lsadvlast }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).length32 }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).lronly }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).ystride }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).endptfilter }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).adrmode }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).xyoffset }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).yflip }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).ensmask }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).cid_mask }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).sfactor }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).dfactor }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).rwpacked }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).hostdepth }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).rwdouble }, + { unpack(0x00000326, 0x3162f031, 0x00001e0f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3163f011 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3163f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3163f011, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).planes }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).dither }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).compare }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).blend }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).shade }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3163f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3163f031 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3163f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3163f031, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).planes }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).dither }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).compare }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).blend }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).shade }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3163f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).planes }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).dither }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).compare }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).blend }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).shade }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_00000326_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).planes }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).dither }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).compare }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).blend }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).shade }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x00000326, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x60007211 cm=0x00001e02 +unsafe extern "C" fn shader_00000326_60007211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x60007211, 0x00001e02).opcode }, + { unpack(0x00000326, 0x60007211, 0x00001e02).planes }, + { unpack(0x00000326, 0x60007211, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x60007211, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x60007211, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x60007211, 0x00001e02).dither }, + { unpack(0x00000326, 0x60007211, 0x00001e02).logicop }, + { unpack(0x00000326, 0x60007211, 0x00001e02).compare }, + { unpack(0x00000326, 0x60007211, 0x00001e02).blend }, + { unpack(0x00000326, 0x60007211, 0x00001e02).backblend }, + { unpack(0x00000326, 0x60007211, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x60007211, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x60007211, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x60007211, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x60007211, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x60007211, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x60007211, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x60007211, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x60007211, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x60007211, 0x00001e02).shade }, + { unpack(0x00000326, 0x60007211, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x60007211, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x60007211, 0x00001e02).stopony }, + { unpack(0x00000326, 0x60007211, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x60007211, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x60007211, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x60007211, 0x00001e02).length32 }, + { unpack(0x00000326, 0x60007211, 0x00001e02).lronly }, + { unpack(0x00000326, 0x60007211, 0x00001e02).ystride }, + { unpack(0x00000326, 0x60007211, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x60007211, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x60007211, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x60007211, 0x00001e02).yflip }, + { unpack(0x00000326, 0x60007211, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x60007211, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x60007211, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x60007211, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x60007211, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x60007211, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x60007211, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x60007211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0x6000f319 cm=0x00001e02 +unsafe extern "C" fn shader_00000326_6000f319_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0x6000f319, 0x00001e02).opcode }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).planes }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).drawdepth }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).dblsrc }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).rgbmode }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).dither }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).logicop }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).compare }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).blend }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).backblend }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).blendalpha }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).fastclear }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).colorhost }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).alphahost }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).enzpattern }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).enlspattern }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).zpopaque }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).lsopaque }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).cidtest }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).shade }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).ciclamp }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).stoponx }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).stopony }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).skipfirst }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).skiplast }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).lsadvlast }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).length32 }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).lronly }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).ystride }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).endptfilter }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).adrmode }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).xyoffset }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).yflip }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).ensmask }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).cid_mask }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).sfactor }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).dfactor }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).rwpacked }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).hostdepth }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).rwdouble }, + { unpack(0x00000326, 0x6000f319, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000326 dm1=0xa000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00000326_a000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000326, 0xa000f319, 0x00001e00).opcode }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).planes }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).drawdepth }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).dblsrc }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).rgbmode }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).dither }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).logicop }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).compare }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).blend }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).backblend }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).blendalpha }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).fastclear }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).colorhost }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).alphahost }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).enzpattern }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).enlspattern }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).zpopaque }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).lsopaque }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).cidtest }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).shade }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).ciclamp }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).stoponx }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).stopony }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).skipfirst }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).skiplast }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).lsadvlast }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).length32 }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).lronly }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).ystride }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).endptfilter }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).adrmode }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).xyoffset }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).yflip }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).ensmask }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).cid_mask }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).sfactor }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).dfactor }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).rwpacked }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).hostdepth }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).rwdouble }, + { unpack(0x00000326, 0xa000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x30007109 cm=0x00001e00 +unsafe extern "C" fn shader_00000327_30007109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x30007109, 0x00001e00).opcode }, + { unpack(0x00000327, 0x30007109, 0x00001e00).planes }, + { unpack(0x00000327, 0x30007109, 0x00001e00).drawdepth }, + { unpack(0x00000327, 0x30007109, 0x00001e00).dblsrc }, + { unpack(0x00000327, 0x30007109, 0x00001e00).rgbmode }, + { unpack(0x00000327, 0x30007109, 0x00001e00).dither }, + { unpack(0x00000327, 0x30007109, 0x00001e00).logicop }, + { unpack(0x00000327, 0x30007109, 0x00001e00).compare }, + { unpack(0x00000327, 0x30007109, 0x00001e00).blend }, + { unpack(0x00000327, 0x30007109, 0x00001e00).backblend }, + { unpack(0x00000327, 0x30007109, 0x00001e00).blendalpha }, + { unpack(0x00000327, 0x30007109, 0x00001e00).fastclear }, + { unpack(0x00000327, 0x30007109, 0x00001e00).colorhost }, + { unpack(0x00000327, 0x30007109, 0x00001e00).alphahost }, + { unpack(0x00000327, 0x30007109, 0x00001e00).enzpattern }, + { unpack(0x00000327, 0x30007109, 0x00001e00).enlspattern }, + { unpack(0x00000327, 0x30007109, 0x00001e00).zpopaque }, + { unpack(0x00000327, 0x30007109, 0x00001e00).lsopaque }, + { unpack(0x00000327, 0x30007109, 0x00001e00).cidtest }, + { unpack(0x00000327, 0x30007109, 0x00001e00).shade }, + { unpack(0x00000327, 0x30007109, 0x00001e00).ciclamp }, + { unpack(0x00000327, 0x30007109, 0x00001e00).stoponx }, + { unpack(0x00000327, 0x30007109, 0x00001e00).stopony }, + { unpack(0x00000327, 0x30007109, 0x00001e00).skipfirst }, + { unpack(0x00000327, 0x30007109, 0x00001e00).skiplast }, + { unpack(0x00000327, 0x30007109, 0x00001e00).lsadvlast }, + { unpack(0x00000327, 0x30007109, 0x00001e00).length32 }, + { unpack(0x00000327, 0x30007109, 0x00001e00).lronly }, + { unpack(0x00000327, 0x30007109, 0x00001e00).ystride }, + { unpack(0x00000327, 0x30007109, 0x00001e00).endptfilter }, + { unpack(0x00000327, 0x30007109, 0x00001e00).adrmode }, + { unpack(0x00000327, 0x30007109, 0x00001e00).xyoffset }, + { unpack(0x00000327, 0x30007109, 0x00001e00).yflip }, + { unpack(0x00000327, 0x30007109, 0x00001e00).ensmask }, + { unpack(0x00000327, 0x30007109, 0x00001e00).cid_mask }, + { unpack(0x00000327, 0x30007109, 0x00001e00).sfactor }, + { unpack(0x00000327, 0x30007109, 0x00001e00).dfactor }, + { unpack(0x00000327, 0x30007109, 0x00001e00).rwpacked }, + { unpack(0x00000327, 0x30007109, 0x00001e00).hostdepth }, + { unpack(0x00000327, 0x30007109, 0x00001e00).rwdouble }, + { unpack(0x00000327, 0x30007109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000710d cm=0x00001e00 +unsafe extern "C" fn shader_00000327_3000710d_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000710d, 0x00001e00).opcode }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).planes }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).drawdepth }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).dblsrc }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).rgbmode }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).dither }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).logicop }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).compare }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).blend }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).backblend }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).blendalpha }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).fastclear }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).colorhost }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).alphahost }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).enzpattern }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).enlspattern }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).zpopaque }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).lsopaque }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).cidtest }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).shade }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).ciclamp }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).stoponx }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).stopony }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).skipfirst }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).skiplast }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).lsadvlast }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).length32 }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).lronly }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).ystride }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).endptfilter }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).adrmode }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).xyoffset }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).yflip }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).ensmask }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).cid_mask }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).sfactor }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).dfactor }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).rwpacked }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).hostdepth }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).rwdouble }, + { unpack(0x00000327, 0x3000710d, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00000000 +unsafe extern "C" fn shader_00000327_3000f019_00000000( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00000000).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00000000).planes }, + { unpack(0x00000327, 0x3000f019, 0x00000000).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000000).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00000000).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00000000).dither }, + { unpack(0x00000327, 0x3000f019, 0x00000000).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00000000).compare }, + { unpack(0x00000327, 0x3000f019, 0x00000000).blend }, + { unpack(0x00000327, 0x3000f019, 0x00000000).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00000000).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00000000).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00000000).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00000000).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00000000).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00000000).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00000000).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000000).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000000).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00000000).shade }, + { unpack(0x00000327, 0x3000f019, 0x00000000).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00000000).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00000000).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00000000).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00000000).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00000000).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00000000).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00000000).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00000000).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00000000).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00000000).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00000000).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00000000).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00000000).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00000000).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00000000).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000000).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000000).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00000000).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000000).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00000000).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00000200 +unsafe extern "C" fn shader_00000327_3000f019_00000200( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00000200).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00000200).planes }, + { unpack(0x00000327, 0x3000f019, 0x00000200).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000200).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00000200).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00000200).dither }, + { unpack(0x00000327, 0x3000f019, 0x00000200).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00000200).compare }, + { unpack(0x00000327, 0x3000f019, 0x00000200).blend }, + { unpack(0x00000327, 0x3000f019, 0x00000200).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00000200).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00000200).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00000200).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00000200).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00000200).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00000200).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00000200).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000200).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000200).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00000200).shade }, + { unpack(0x00000327, 0x3000f019, 0x00000200).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00000200).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00000200).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00000200).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00000200).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00000200).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00000200).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00000200).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00000200).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00000200).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00000200).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00000200).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00000200).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00000200).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00000200).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00000200).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000200).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000200).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00000200).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000200).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00000200).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00000400 +unsafe extern "C" fn shader_00000327_3000f019_00000400( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00000400).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00000400).planes }, + { unpack(0x00000327, 0x3000f019, 0x00000400).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000400).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00000400).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00000400).dither }, + { unpack(0x00000327, 0x3000f019, 0x00000400).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00000400).compare }, + { unpack(0x00000327, 0x3000f019, 0x00000400).blend }, + { unpack(0x00000327, 0x3000f019, 0x00000400).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00000400).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00000400).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00000400).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00000400).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00000400).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00000400).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00000400).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000400).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000400).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00000400).shade }, + { unpack(0x00000327, 0x3000f019, 0x00000400).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00000400).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00000400).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00000400).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00000400).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00000400).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00000400).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00000400).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00000400).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00000400).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00000400).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00000400).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00000400).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00000400).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00000400).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00000400).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000400).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000400).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00000400).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000400).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00000400).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00000600 +unsafe extern "C" fn shader_00000327_3000f019_00000600( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00000600).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00000600).planes }, + { unpack(0x00000327, 0x3000f019, 0x00000600).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000600).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00000600).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00000600).dither }, + { unpack(0x00000327, 0x3000f019, 0x00000600).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00000600).compare }, + { unpack(0x00000327, 0x3000f019, 0x00000600).blend }, + { unpack(0x00000327, 0x3000f019, 0x00000600).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00000600).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00000600).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00000600).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00000600).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00000600).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00000600).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00000600).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000600).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000600).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00000600).shade }, + { unpack(0x00000327, 0x3000f019, 0x00000600).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00000600).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00000600).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00000600).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00000600).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00000600).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00000600).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00000600).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00000600).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00000600).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00000600).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00000600).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00000600).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00000600).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00000600).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00000600).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000600).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000600).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00000600).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000600).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00000600).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00000800 +unsafe extern "C" fn shader_00000327_3000f019_00000800( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00000800).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00000800).planes }, + { unpack(0x00000327, 0x3000f019, 0x00000800).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000800).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00000800).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00000800).dither }, + { unpack(0x00000327, 0x3000f019, 0x00000800).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00000800).compare }, + { unpack(0x00000327, 0x3000f019, 0x00000800).blend }, + { unpack(0x00000327, 0x3000f019, 0x00000800).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00000800).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00000800).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00000800).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00000800).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00000800).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00000800).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00000800).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000800).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000800).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00000800).shade }, + { unpack(0x00000327, 0x3000f019, 0x00000800).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00000800).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00000800).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00000800).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00000800).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00000800).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00000800).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00000800).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00000800).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00000800).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00000800).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00000800).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00000800).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00000800).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00000800).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00000800).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000800).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000800).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00000800).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000800).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00000800).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00000a00 +unsafe extern "C" fn shader_00000327_3000f019_00000a00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00000a00).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).planes }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).dither }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).compare }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).blend }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).shade }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00000a00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00000c00 +unsafe extern "C" fn shader_00000327_3000f019_00000c00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00000c00).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).planes }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).dither }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).compare }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).blend }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).shade }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00000c00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00000e00 +unsafe extern "C" fn shader_00000327_3000f019_00000e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00000e00).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).planes }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).dither }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).compare }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).blend }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).shade }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00000e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00001000 +unsafe extern "C" fn shader_00000327_3000f019_00001000( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00001000).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00001000).planes }, + { unpack(0x00000327, 0x3000f019, 0x00001000).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001000).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00001000).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00001000).dither }, + { unpack(0x00000327, 0x3000f019, 0x00001000).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00001000).compare }, + { unpack(0x00000327, 0x3000f019, 0x00001000).blend }, + { unpack(0x00000327, 0x3000f019, 0x00001000).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00001000).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00001000).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00001000).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00001000).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00001000).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00001000).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00001000).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001000).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001000).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00001000).shade }, + { unpack(0x00000327, 0x3000f019, 0x00001000).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00001000).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00001000).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00001000).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00001000).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00001000).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00001000).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00001000).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00001000).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00001000).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00001000).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00001000).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00001000).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00001000).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00001000).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00001000).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001000).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001000).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00001000).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001000).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00001000).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00001200 +unsafe extern "C" fn shader_00000327_3000f019_00001200( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00001200).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00001200).planes }, + { unpack(0x00000327, 0x3000f019, 0x00001200).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001200).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00001200).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00001200).dither }, + { unpack(0x00000327, 0x3000f019, 0x00001200).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00001200).compare }, + { unpack(0x00000327, 0x3000f019, 0x00001200).blend }, + { unpack(0x00000327, 0x3000f019, 0x00001200).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00001200).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00001200).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00001200).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00001200).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00001200).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00001200).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00001200).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001200).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001200).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00001200).shade }, + { unpack(0x00000327, 0x3000f019, 0x00001200).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00001200).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00001200).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00001200).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00001200).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00001200).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00001200).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00001200).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00001200).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00001200).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00001200).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00001200).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00001200).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00001200).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00001200).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00001200).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001200).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001200).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00001200).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001200).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00001200).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00001400 +unsafe extern "C" fn shader_00000327_3000f019_00001400( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00001400).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00001400).planes }, + { unpack(0x00000327, 0x3000f019, 0x00001400).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001400).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00001400).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00001400).dither }, + { unpack(0x00000327, 0x3000f019, 0x00001400).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00001400).compare }, + { unpack(0x00000327, 0x3000f019, 0x00001400).blend }, + { unpack(0x00000327, 0x3000f019, 0x00001400).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00001400).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00001400).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00001400).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00001400).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00001400).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00001400).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00001400).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001400).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001400).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00001400).shade }, + { unpack(0x00000327, 0x3000f019, 0x00001400).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00001400).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00001400).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00001400).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00001400).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00001400).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00001400).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00001400).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00001400).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00001400).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00001400).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00001400).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00001400).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00001400).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00001400).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00001400).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001400).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001400).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00001400).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001400).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00001400).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00001600 +unsafe extern "C" fn shader_00000327_3000f019_00001600( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00001600).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00001600).planes }, + { unpack(0x00000327, 0x3000f019, 0x00001600).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001600).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00001600).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00001600).dither }, + { unpack(0x00000327, 0x3000f019, 0x00001600).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00001600).compare }, + { unpack(0x00000327, 0x3000f019, 0x00001600).blend }, + { unpack(0x00000327, 0x3000f019, 0x00001600).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00001600).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00001600).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00001600).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00001600).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00001600).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00001600).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00001600).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001600).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001600).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00001600).shade }, + { unpack(0x00000327, 0x3000f019, 0x00001600).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00001600).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00001600).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00001600).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00001600).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00001600).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00001600).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00001600).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00001600).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00001600).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00001600).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00001600).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00001600).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00001600).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00001600).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00001600).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001600).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001600).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00001600).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001600).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00001600).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00001800 +unsafe extern "C" fn shader_00000327_3000f019_00001800( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00001800).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00001800).planes }, + { unpack(0x00000327, 0x3000f019, 0x00001800).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001800).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00001800).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00001800).dither }, + { unpack(0x00000327, 0x3000f019, 0x00001800).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00001800).compare }, + { unpack(0x00000327, 0x3000f019, 0x00001800).blend }, + { unpack(0x00000327, 0x3000f019, 0x00001800).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00001800).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00001800).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00001800).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00001800).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00001800).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00001800).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00001800).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001800).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001800).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00001800).shade }, + { unpack(0x00000327, 0x3000f019, 0x00001800).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00001800).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00001800).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00001800).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00001800).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00001800).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00001800).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00001800).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00001800).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00001800).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00001800).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00001800).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00001800).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00001800).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00001800).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00001800).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001800).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001800).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00001800).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001800).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00001800).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00001a00 +unsafe extern "C" fn shader_00000327_3000f019_00001a00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00001a00).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).planes }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).dither }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).compare }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).blend }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).shade }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00001a00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00001c00 +unsafe extern "C" fn shader_00000327_3000f019_00001c00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00001c00).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).planes }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).dither }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).compare }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).blend }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).shade }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00001c00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f019 cm=0x00001e00 +unsafe extern "C" fn shader_00000327_3000f019_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f019, 0x00001e00).opcode }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).planes }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).drawdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).dblsrc }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).rgbmode }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).dither }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).logicop }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).compare }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).blend }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).backblend }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).blendalpha }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).fastclear }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).colorhost }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).alphahost }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).enzpattern }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).enlspattern }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).zpopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).lsopaque }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).cidtest }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).shade }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).ciclamp }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).stoponx }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).stopony }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).skipfirst }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).skiplast }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).lsadvlast }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).length32 }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).lronly }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).ystride }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).endptfilter }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).adrmode }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).xyoffset }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).yflip }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).ensmask }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).cid_mask }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).sfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).dfactor }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).rwpacked }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).hostdepth }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).rwdouble }, + { unpack(0x00000327, 0x3000f019, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f109 cm=0x00001e00 +unsafe extern "C" fn shader_00000327_3000f109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f109, 0x00001e00).opcode }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).planes }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).drawdepth }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).dblsrc }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).rgbmode }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).dither }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).logicop }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).compare }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).blend }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).backblend }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).blendalpha }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).fastclear }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).colorhost }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).alphahost }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).enzpattern }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).enlspattern }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).zpopaque }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).lsopaque }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).cidtest }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).shade }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).ciclamp }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).stoponx }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).stopony }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).skipfirst }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).skiplast }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).lsadvlast }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).length32 }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).lronly }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).ystride }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).endptfilter }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).adrmode }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).xyoffset }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).yflip }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).ensmask }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).cid_mask }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).sfactor }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).dfactor }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).rwpacked }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).hostdepth }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).rwdouble }, + { unpack(0x00000327, 0x3000f109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f211 cm=0x00001e00 +unsafe extern "C" fn shader_00000327_3000f211_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f211, 0x00001e00).opcode }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).planes }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).drawdepth }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).dblsrc }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).rgbmode }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).dither }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).logicop }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).compare }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).blend }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).backblend }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).blendalpha }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).fastclear }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).colorhost }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).alphahost }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).enzpattern }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).enlspattern }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).zpopaque }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).lsopaque }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).cidtest }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).shade }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).ciclamp }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).stoponx }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).stopony }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).skipfirst }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).skiplast }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).lsadvlast }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).length32 }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).lronly }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).ystride }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).endptfilter }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).adrmode }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).xyoffset }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).yflip }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).ensmask }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).cid_mask }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).sfactor }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).dfactor }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).rwpacked }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).hostdepth }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).rwdouble }, + { unpack(0x00000327, 0x3000f211, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f231 cm=0x00001e00 +unsafe extern "C" fn shader_00000327_3000f231_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f231, 0x00001e00).opcode }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).planes }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).drawdepth }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).dblsrc }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).rgbmode }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).dither }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).logicop }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).compare }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).blend }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).backblend }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).blendalpha }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).fastclear }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).colorhost }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).alphahost }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).enzpattern }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).enlspattern }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).zpopaque }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).lsopaque }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).cidtest }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).shade }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).ciclamp }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).stoponx }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).stopony }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).skipfirst }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).skiplast }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).lsadvlast }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).length32 }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).lronly }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).ystride }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).endptfilter }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).adrmode }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).xyoffset }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).yflip }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).ensmask }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).cid_mask }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).sfactor }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).dfactor }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).rwpacked }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).hostdepth }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).rwdouble }, + { unpack(0x00000327, 0x3000f231, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00000327_3000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3000f319, 0x00001e00).opcode }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).planes }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).drawdepth }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).dblsrc }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).rgbmode }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).dither }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).logicop }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).compare }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).blend }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).backblend }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).blendalpha }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).fastclear }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).colorhost }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).alphahost }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).enzpattern }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).enlspattern }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).zpopaque }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).lsopaque }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).cidtest }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).shade }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).ciclamp }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).stoponx }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).stopony }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).skipfirst }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).skiplast }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).lsadvlast }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).length32 }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).lronly }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).ystride }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).endptfilter }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).adrmode }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).xyoffset }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).yflip }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).ensmask }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).cid_mask }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).sfactor }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).dfactor }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).rwpacked }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).hostdepth }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).rwdouble }, + { unpack(0x00000327, 0x3000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3008f011 cm=0x00001e03 +unsafe extern "C" fn shader_00000327_3008f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3008f011, 0x00001e03).opcode }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).planes }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).drawdepth }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).dblsrc }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).rgbmode }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).dither }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).logicop }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).compare }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).blend }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).backblend }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).blendalpha }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).fastclear }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).colorhost }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).alphahost }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).enzpattern }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).enlspattern }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).zpopaque }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).lsopaque }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).cidtest }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).shade }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).ciclamp }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).stoponx }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).stopony }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).skipfirst }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).skiplast }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).lsadvlast }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).length32 }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).lronly }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).ystride }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).endptfilter }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).adrmode }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).xyoffset }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).yflip }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).ensmask }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).cid_mask }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).sfactor }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).dfactor }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).rwpacked }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).hostdepth }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).rwdouble }, + { unpack(0x00000327, 0x3008f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000327 dm1=0x3008f031 cm=0x00001e03 +unsafe extern "C" fn shader_00000327_3008f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000327, 0x3008f031, 0x00001e03).opcode }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).planes }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).drawdepth }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).dblsrc }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).rgbmode }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).dither }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).logicop }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).compare }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).blend }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).backblend }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).blendalpha }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).fastclear }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).colorhost }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).alphahost }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).enzpattern }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).enlspattern }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).zpopaque }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).lsopaque }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).cidtest }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).shade }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).ciclamp }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).stoponx }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).stopony }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).skipfirst }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).skiplast }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).lsadvlast }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).length32 }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).lronly }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).ystride }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).endptfilter }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).adrmode }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).xyoffset }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).yflip }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).ensmask }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).cid_mask }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).sfactor }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).dfactor }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).rwpacked }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).hostdepth }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).rwdouble }, + { unpack(0x00000327, 0x3008f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x30007109 cm=0x00001e02 +unsafe extern "C" fn shader_0000032a_30007109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x30007109, 0x00001e02).opcode }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).planes }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).drawdepth }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).dblsrc }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).rgbmode }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).dither }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).logicop }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).compare }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).blend }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).backblend }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).blendalpha }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).fastclear }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).colorhost }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).alphahost }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).enzpattern }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).enlspattern }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).zpopaque }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).lsopaque }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).cidtest }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).shade }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).ciclamp }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).stoponx }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).stopony }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).skipfirst }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).skiplast }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).lsadvlast }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).length32 }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).lronly }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).ystride }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).endptfilter }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).adrmode }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).xyoffset }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).yflip }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).ensmask }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).cid_mask }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).sfactor }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).dfactor }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).rwpacked }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).hostdepth }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).rwdouble }, + { unpack(0x0000032a, 0x30007109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x30007109 cm=0x00001e06 +unsafe extern "C" fn shader_0000032a_30007109_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x30007109, 0x00001e06).opcode }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).planes }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).drawdepth }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).dblsrc }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).rgbmode }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).dither }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).logicop }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).compare }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).blend }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).backblend }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).blendalpha }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).fastclear }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).colorhost }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).alphahost }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).enzpattern }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).enlspattern }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).zpopaque }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).lsopaque }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).cidtest }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).shade }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).ciclamp }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).stoponx }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).stopony }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).skipfirst }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).skiplast }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).lsadvlast }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).length32 }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).lronly }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).ystride }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).endptfilter }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).adrmode }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).xyoffset }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).yflip }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).ensmask }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).cid_mask }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).sfactor }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).dfactor }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).rwpacked }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).hostdepth }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).rwdouble }, + { unpack(0x0000032a, 0x30007109, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x30007109 cm=0x00001e0e +unsafe extern "C" fn shader_0000032a_30007109_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x30007109, 0x00001e0e).opcode }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).planes }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).drawdepth }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).dblsrc }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).rgbmode }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).dither }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).logicop }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).compare }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).blend }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).backblend }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).blendalpha }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).fastclear }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).colorhost }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).alphahost }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).enzpattern }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).enlspattern }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).zpopaque }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).lsopaque }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).cidtest }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).shade }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).ciclamp }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).stoponx }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).stopony }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).skipfirst }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).skiplast }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).lsadvlast }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).length32 }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).lronly }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).ystride }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).endptfilter }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).adrmode }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).xyoffset }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).yflip }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).ensmask }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).cid_mask }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).sfactor }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).dfactor }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).rwpacked }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).hostdepth }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).rwdouble }, + { unpack(0x0000032a, 0x30007109, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x30007109 cm=0x00001e1e +unsafe extern "C" fn shader_0000032a_30007109_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x30007109, 0x00001e1e).opcode }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).planes }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).drawdepth }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).dblsrc }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).rgbmode }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).dither }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).logicop }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).compare }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).blend }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).backblend }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).blendalpha }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).fastclear }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).colorhost }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).alphahost }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).enzpattern }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).enlspattern }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).zpopaque }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).lsopaque }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).cidtest }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).shade }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).ciclamp }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).stoponx }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).stopony }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).skipfirst }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).skiplast }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).lsadvlast }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).length32 }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).lronly }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).ystride }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).endptfilter }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).adrmode }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).xyoffset }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).yflip }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).ensmask }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).cid_mask }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).sfactor }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).dfactor }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).rwpacked }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).hostdepth }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).rwdouble }, + { unpack(0x0000032a, 0x30007109, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000710d cm=0x00001e02 +unsafe extern "C" fn shader_0000032a_3000710d_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000710d, 0x00001e02).opcode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).planes }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).drawdepth }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).dblsrc }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).rgbmode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).dither }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).logicop }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).compare }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).blend }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).backblend }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).blendalpha }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).fastclear }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).colorhost }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).alphahost }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).enzpattern }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).enlspattern }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).zpopaque }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).lsopaque }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).cidtest }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).shade }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).ciclamp }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).stoponx }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).stopony }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).skipfirst }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).skiplast }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).lsadvlast }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).length32 }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).lronly }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).ystride }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).endptfilter }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).adrmode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).xyoffset }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).yflip }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).ensmask }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).cid_mask }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).sfactor }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).dfactor }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).rwpacked }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).hostdepth }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).rwdouble }, + { unpack(0x0000032a, 0x3000710d, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000710d cm=0x00001e06 +unsafe extern "C" fn shader_0000032a_3000710d_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000710d, 0x00001e06).opcode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).planes }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).drawdepth }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).dblsrc }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).rgbmode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).dither }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).logicop }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).compare }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).blend }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).backblend }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).blendalpha }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).fastclear }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).colorhost }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).alphahost }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).enzpattern }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).enlspattern }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).zpopaque }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).lsopaque }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).cidtest }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).shade }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).ciclamp }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).stoponx }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).stopony }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).skipfirst }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).skiplast }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).lsadvlast }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).length32 }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).lronly }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).ystride }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).endptfilter }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).adrmode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).xyoffset }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).yflip }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).ensmask }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).cid_mask }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).sfactor }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).dfactor }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).rwpacked }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).hostdepth }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).rwdouble }, + { unpack(0x0000032a, 0x3000710d, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000710d cm=0x00001e0e +unsafe extern "C" fn shader_0000032a_3000710d_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).opcode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).planes }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).drawdepth }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).dblsrc }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).rgbmode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).dither }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).logicop }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).compare }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).blend }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).backblend }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).blendalpha }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).fastclear }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).colorhost }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).alphahost }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).enzpattern }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).enlspattern }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).zpopaque }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).lsopaque }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).cidtest }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).shade }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).ciclamp }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).stoponx }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).stopony }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).skipfirst }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).skiplast }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).lsadvlast }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).length32 }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).lronly }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).ystride }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).endptfilter }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).adrmode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).xyoffset }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).yflip }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).ensmask }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).cid_mask }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).sfactor }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).dfactor }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).rwpacked }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).hostdepth }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).rwdouble }, + { unpack(0x0000032a, 0x3000710d, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000710d cm=0x00001e1e +unsafe extern "C" fn shader_0000032a_3000710d_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).opcode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).planes }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).drawdepth }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).dblsrc }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).rgbmode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).dither }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).logicop }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).compare }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).blend }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).backblend }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).blendalpha }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).fastclear }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).colorhost }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).alphahost }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).enzpattern }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).enlspattern }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).zpopaque }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).lsopaque }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).cidtest }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).shade }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).ciclamp }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).stoponx }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).stopony }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).skipfirst }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).skiplast }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).lsadvlast }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).length32 }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).lronly }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).ystride }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).endptfilter }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).adrmode }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).xyoffset }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).yflip }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).ensmask }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).cid_mask }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).sfactor }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).dfactor }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).rwpacked }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).hostdepth }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).rwdouble }, + { unpack(0x0000032a, 0x3000710d, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x30007211 cm=0x00001e02 +unsafe extern "C" fn shader_0000032a_30007211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x30007211, 0x00001e02).opcode }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).planes }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).drawdepth }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).dblsrc }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).rgbmode }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).dither }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).logicop }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).compare }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).blend }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).backblend }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).blendalpha }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).fastclear }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).colorhost }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).alphahost }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).enzpattern }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).enlspattern }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).zpopaque }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).lsopaque }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).cidtest }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).shade }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).ciclamp }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).stoponx }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).stopony }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).skipfirst }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).skiplast }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).lsadvlast }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).length32 }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).lronly }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).ystride }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).endptfilter }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).adrmode }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).xyoffset }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).yflip }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).ensmask }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).cid_mask }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).sfactor }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).dfactor }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).rwpacked }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).hostdepth }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).rwdouble }, + { unpack(0x0000032a, 0x30007211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x30007211 cm=0x00001e1e +unsafe extern "C" fn shader_0000032a_30007211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x30007211, 0x00001e1e).opcode }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).planes }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).drawdepth }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).dblsrc }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).rgbmode }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).dither }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).logicop }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).compare }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).blend }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).backblend }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).blendalpha }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).fastclear }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).colorhost }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).alphahost }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).enzpattern }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).enlspattern }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).zpopaque }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).lsopaque }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).cidtest }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).shade }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).ciclamp }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).stoponx }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).stopony }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).skipfirst }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).skiplast }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).lsadvlast }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).length32 }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).lronly }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).ystride }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).endptfilter }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).adrmode }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).xyoffset }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).yflip }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).ensmask }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).cid_mask }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).sfactor }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).dfactor }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).rwpacked }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).hostdepth }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).rwdouble }, + { unpack(0x0000032a, 0x30007211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00000000 +unsafe extern "C" fn shader_0000032a_3000f019_00000000( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00000000).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00000000).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00000200 +unsafe extern "C" fn shader_0000032a_3000f019_00000200( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00000200).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00000200).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00000400 +unsafe extern "C" fn shader_0000032a_3000f019_00000400( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00000400).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00000400).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00000600 +unsafe extern "C" fn shader_0000032a_3000f019_00000600( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00000600).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00000600).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00000800 +unsafe extern "C" fn shader_0000032a_3000f019_00000800( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00000800).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00000800).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00000a00 +unsafe extern "C" fn shader_0000032a_3000f019_00000a00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00000a00).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00000a00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00000c00 +unsafe extern "C" fn shader_0000032a_3000f019_00000c00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00000c00).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00000c00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00000e00 +unsafe extern "C" fn shader_0000032a_3000f019_00000e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00000e00).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00000e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00001000 +unsafe extern "C" fn shader_0000032a_3000f019_00001000( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00001000).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00001000).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00001200 +unsafe extern "C" fn shader_0000032a_3000f019_00001200( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00001200).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00001200).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00001400 +unsafe extern "C" fn shader_0000032a_3000f019_00001400( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00001400).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00001400).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00001600 +unsafe extern "C" fn shader_0000032a_3000f019_00001600( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00001600).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00001600).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00001800 +unsafe extern "C" fn shader_0000032a_3000f019_00001800( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00001800).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00001800).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00001a00 +unsafe extern "C" fn shader_0000032a_3000f019_00001a00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00001a00).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00001a00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00001c00 +unsafe extern "C" fn shader_0000032a_3000f019_00001c00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00001c00).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00001c00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f019 cm=0x00001e00 +unsafe extern "C" fn shader_0000032a_3000f019_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f019, 0x00001e00).opcode }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).planes }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).drawdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).dblsrc }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).rgbmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).dither }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).logicop }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).compare }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).blend }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).backblend }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).blendalpha }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).fastclear }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).colorhost }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).alphahost }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).enzpattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).enlspattern }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).zpopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).lsopaque }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).cidtest }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).shade }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).ciclamp }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).stoponx }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).stopony }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).skipfirst }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).skiplast }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).lsadvlast }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).length32 }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).lronly }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).ystride }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).endptfilter }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).adrmode }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).xyoffset }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).yflip }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).ensmask }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).cid_mask }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).sfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).dfactor }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).rwpacked }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).hostdepth }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).rwdouble }, + { unpack(0x0000032a, 0x3000f019, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f109 cm=0x00001e02 +unsafe extern "C" fn shader_0000032a_3000f109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f109, 0x00001e02).opcode }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).planes }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).drawdepth }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).dblsrc }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).rgbmode }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).dither }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).logicop }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).compare }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).blend }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).backblend }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).blendalpha }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).fastclear }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).colorhost }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).alphahost }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).enzpattern }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).enlspattern }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).zpopaque }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).lsopaque }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).cidtest }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).shade }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).ciclamp }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).stoponx }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).stopony }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).skipfirst }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).skiplast }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).lsadvlast }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).length32 }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).lronly }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).ystride }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).endptfilter }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).adrmode }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).xyoffset }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).yflip }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).ensmask }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).cid_mask }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).sfactor }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).dfactor }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).rwpacked }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).hostdepth }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).rwdouble }, + { unpack(0x0000032a, 0x3000f109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f211 cm=0x00001e02 +unsafe extern "C" fn shader_0000032a_3000f211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f211, 0x00001e02).opcode }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).planes }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).drawdepth }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).dblsrc }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).rgbmode }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).dither }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).logicop }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).compare }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).blend }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).backblend }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).blendalpha }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).fastclear }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).colorhost }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).alphahost }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).enzpattern }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).enlspattern }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).zpopaque }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).lsopaque }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).cidtest }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).shade }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).ciclamp }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).stoponx }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).stopony }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).skipfirst }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).skiplast }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).lsadvlast }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).length32 }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).lronly }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).ystride }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).endptfilter }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).adrmode }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).xyoffset }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).yflip }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).ensmask }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).cid_mask }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).sfactor }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).dfactor }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).rwpacked }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).hostdepth }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).rwdouble }, + { unpack(0x0000032a, 0x3000f211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f211 cm=0x00001e0e +unsafe extern "C" fn shader_0000032a_3000f211_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).opcode }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).planes }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).drawdepth }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).dblsrc }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).rgbmode }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).dither }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).logicop }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).compare }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).blend }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).backblend }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).blendalpha }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).fastclear }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).colorhost }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).alphahost }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).enzpattern }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).enlspattern }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).zpopaque }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).lsopaque }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).cidtest }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).shade }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).ciclamp }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).stoponx }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).stopony }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).skipfirst }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).skiplast }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).lsadvlast }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).length32 }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).lronly }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).ystride }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).endptfilter }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).adrmode }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).xyoffset }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).yflip }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).ensmask }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).cid_mask }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).sfactor }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).dfactor }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).rwpacked }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).hostdepth }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).rwdouble }, + { unpack(0x0000032a, 0x3000f211, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f319 cm=0x00001e02 +unsafe extern "C" fn shader_0000032a_3000f319_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f319, 0x00001e02).opcode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).planes }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).drawdepth }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).dblsrc }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).rgbmode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).dither }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).logicop }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).compare }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).blend }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).backblend }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).blendalpha }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).fastclear }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).colorhost }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).alphahost }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).enzpattern }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).enlspattern }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).zpopaque }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).lsopaque }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).cidtest }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).shade }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).ciclamp }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).stoponx }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).stopony }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).skipfirst }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).skiplast }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).lsadvlast }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).length32 }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).lronly }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).ystride }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).endptfilter }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).adrmode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).xyoffset }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).yflip }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).ensmask }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).cid_mask }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).sfactor }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).dfactor }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).rwpacked }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).hostdepth }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).rwdouble }, + { unpack(0x0000032a, 0x3000f319, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f319 cm=0x00001e06 +unsafe extern "C" fn shader_0000032a_3000f319_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f319, 0x00001e06).opcode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).planes }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).drawdepth }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).dblsrc }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).rgbmode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).dither }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).logicop }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).compare }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).blend }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).backblend }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).blendalpha }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).fastclear }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).colorhost }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).alphahost }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).enzpattern }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).enlspattern }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).zpopaque }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).lsopaque }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).cidtest }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).shade }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).ciclamp }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).stoponx }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).stopony }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).skipfirst }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).skiplast }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).lsadvlast }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).length32 }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).lronly }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).ystride }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).endptfilter }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).adrmode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).xyoffset }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).yflip }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).ensmask }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).cid_mask }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).sfactor }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).dfactor }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).rwpacked }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).hostdepth }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).rwdouble }, + { unpack(0x0000032a, 0x3000f319, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f319 cm=0x00001e0e +unsafe extern "C" fn shader_0000032a_3000f319_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).opcode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).planes }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).drawdepth }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).dblsrc }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).rgbmode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).dither }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).logicop }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).compare }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).blend }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).backblend }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).blendalpha }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).fastclear }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).colorhost }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).alphahost }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).enzpattern }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).enlspattern }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).zpopaque }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).lsopaque }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).cidtest }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).shade }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).ciclamp }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).stoponx }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).stopony }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).skipfirst }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).skiplast }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).lsadvlast }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).length32 }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).lronly }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).ystride }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).endptfilter }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).adrmode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).xyoffset }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).yflip }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).ensmask }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).cid_mask }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).sfactor }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).dfactor }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).rwpacked }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).hostdepth }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).rwdouble }, + { unpack(0x0000032a, 0x3000f319, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x3000f319 cm=0x00001e1e +unsafe extern "C" fn shader_0000032a_3000f319_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).opcode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).planes }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).drawdepth }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).dblsrc }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).rgbmode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).dither }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).logicop }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).compare }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).blend }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).backblend }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).blendalpha }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).fastclear }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).colorhost }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).alphahost }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).enzpattern }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).enlspattern }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).zpopaque }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).lsopaque }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).cidtest }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).shade }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).ciclamp }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).stoponx }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).stopony }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).skipfirst }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).skiplast }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).lsadvlast }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).length32 }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).lronly }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).ystride }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).endptfilter }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).adrmode }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).xyoffset }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).yflip }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).ensmask }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).cid_mask }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).sfactor }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).dfactor }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).rwpacked }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).hostdepth }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).rwdouble }, + { unpack(0x0000032a, 0x3000f319, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000032a dm1=0x60007211 cm=0x00001e1e +unsafe extern "C" fn shader_0000032a_60007211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000032a, 0x60007211, 0x00001e1e).opcode }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).planes }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).drawdepth }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).dblsrc }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).rgbmode }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).dither }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).logicop }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).compare }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).blend }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).backblend }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).blendalpha }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).fastclear }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).colorhost }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).alphahost }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).enzpattern }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).enlspattern }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).zpopaque }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).lsopaque }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).cidtest }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).shade }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).ciclamp }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).stoponx }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).stopony }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).skipfirst }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).skiplast }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).lsadvlast }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).length32 }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).lronly }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).ystride }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).endptfilter }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).adrmode }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).xyoffset }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).yflip }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).ensmask }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).cid_mask }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).sfactor }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).dfactor }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).rwpacked }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).hostdepth }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).rwdouble }, + { unpack(0x0000032a, 0x60007211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000003c6 dm1=0x3008f391 cm=0x00001e03 +unsafe extern "C" fn shader_000003c6_3008f391_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000003c6, 0x3008f391, 0x00001e03).opcode }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).planes }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).drawdepth }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).dblsrc }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).rgbmode }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).dither }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).logicop }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).compare }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).blend }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).backblend }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).blendalpha }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).fastclear }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).colorhost }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).alphahost }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).enzpattern }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).enlspattern }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).zpopaque }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).lsopaque }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).cidtest }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).shade }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).ciclamp }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).stoponx }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).stopony }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).skipfirst }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).skiplast }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).lsadvlast }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).length32 }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).lronly }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).ystride }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).endptfilter }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).adrmode }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).xyoffset }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).yflip }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).ensmask }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).cid_mask }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).sfactor }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).dfactor }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).rwpacked }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).hostdepth }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).rwdouble }, + { unpack(0x000003c6, 0x3008f391, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000003c6 dm1=0x3008f3b1 cm=0x00001e03 +unsafe extern "C" fn shader_000003c6_3008f3b1_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).opcode }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).planes }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).drawdepth }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).dblsrc }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).rgbmode }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).dither }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).logicop }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).compare }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).blend }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).backblend }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).blendalpha }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).fastclear }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).colorhost }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).alphahost }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).enzpattern }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).enlspattern }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).zpopaque }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).lsopaque }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).cidtest }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).shade }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).ciclamp }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).stoponx }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).stopony }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).skipfirst }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).skiplast }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).lsadvlast }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).length32 }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).lronly }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).ystride }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).endptfilter }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).adrmode }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).xyoffset }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).yflip }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).ensmask }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).cid_mask }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).sfactor }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).dfactor }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).rwpacked }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).hostdepth }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).rwdouble }, + { unpack(0x000003c6, 0x3008f3b1, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000003c6 dm1=0x3009f391 cm=0x00001e03 +unsafe extern "C" fn shader_000003c6_3009f391_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000003c6, 0x3009f391, 0x00001e03).opcode }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).planes }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).drawdepth }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).dblsrc }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).rgbmode }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).dither }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).logicop }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).compare }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).blend }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).backblend }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).blendalpha }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).fastclear }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).colorhost }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).alphahost }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).enzpattern }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).enlspattern }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).zpopaque }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).lsopaque }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).cidtest }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).shade }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).ciclamp }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).stoponx }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).stopony }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).skipfirst }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).skiplast }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).lsadvlast }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).length32 }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).lronly }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).ystride }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).endptfilter }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).adrmode }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).xyoffset }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).yflip }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).ensmask }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).cid_mask }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).sfactor }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).dfactor }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).rwpacked }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).hostdepth }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).rwdouble }, + { unpack(0x000003c6, 0x3009f391, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000003c6 dm1=0x3009f3b1 cm=0x00001e03 +unsafe extern "C" fn shader_000003c6_3009f3b1_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).opcode }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).planes }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).drawdepth }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).dblsrc }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).rgbmode }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).dither }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).logicop }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).compare }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).blend }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).backblend }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).blendalpha }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).fastclear }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).colorhost }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).alphahost }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).enzpattern }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).enlspattern }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).zpopaque }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).lsopaque }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).cidtest }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).shade }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).ciclamp }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).stoponx }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).stopony }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).skipfirst }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).skiplast }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).lsadvlast }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).length32 }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).lronly }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).ystride }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).endptfilter }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).adrmode }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).xyoffset }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).yflip }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).ensmask }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).cid_mask }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).sfactor }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).dfactor }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).rwpacked }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).hostdepth }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).rwdouble }, + { unpack(0x000003c6, 0x3009f3b1, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x30007109 cm=0x00001e02 +unsafe extern "C" fn shader_00000b2a_30007109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x30007109, 0x00001e02).opcode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).planes }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).drawdepth }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).dblsrc }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).rgbmode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).dither }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).logicop }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).compare }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).blend }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).backblend }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).blendalpha }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).fastclear }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).colorhost }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).alphahost }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).enzpattern }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).enlspattern }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).zpopaque }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).lsopaque }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).cidtest }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).shade }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).ciclamp }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).stoponx }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).stopony }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).skipfirst }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).skiplast }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).lsadvlast }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).length32 }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).lronly }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).ystride }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).endptfilter }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).adrmode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).xyoffset }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).yflip }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).ensmask }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).cid_mask }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).sfactor }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).dfactor }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).rwpacked }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).hostdepth }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).rwdouble }, + { unpack(0x00000b2a, 0x30007109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x30007109 cm=0x00001e06 +unsafe extern "C" fn shader_00000b2a_30007109_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x30007109, 0x00001e06).opcode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).planes }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).drawdepth }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).dblsrc }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).rgbmode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).dither }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).logicop }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).compare }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).blend }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).backblend }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).blendalpha }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).fastclear }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).colorhost }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).alphahost }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).enzpattern }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).enlspattern }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).zpopaque }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).lsopaque }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).cidtest }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).shade }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).ciclamp }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).stoponx }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).stopony }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).skipfirst }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).skiplast }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).lsadvlast }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).length32 }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).lronly }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).ystride }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).endptfilter }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).adrmode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).xyoffset }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).yflip }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).ensmask }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).cid_mask }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).sfactor }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).dfactor }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).rwpacked }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).hostdepth }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).rwdouble }, + { unpack(0x00000b2a, 0x30007109, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x30007109 cm=0x00001e0e +unsafe extern "C" fn shader_00000b2a_30007109_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).opcode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).planes }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).drawdepth }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).dblsrc }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).rgbmode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).dither }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).logicop }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).compare }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).blend }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).backblend }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).blendalpha }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).fastclear }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).colorhost }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).alphahost }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).enzpattern }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).enlspattern }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).zpopaque }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).lsopaque }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).cidtest }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).shade }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).ciclamp }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).stoponx }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).stopony }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).skipfirst }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).skiplast }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).lsadvlast }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).length32 }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).lronly }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).ystride }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).endptfilter }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).adrmode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).xyoffset }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).yflip }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).ensmask }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).cid_mask }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).sfactor }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).dfactor }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).rwpacked }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).hostdepth }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).rwdouble }, + { unpack(0x00000b2a, 0x30007109, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x30007109 cm=0x00001e1e +unsafe extern "C" fn shader_00000b2a_30007109_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).opcode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).planes }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).drawdepth }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).dblsrc }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).rgbmode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).dither }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).logicop }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).compare }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).blend }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).backblend }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).blendalpha }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).fastclear }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).colorhost }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).alphahost }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).enzpattern }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).enlspattern }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).zpopaque }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).lsopaque }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).cidtest }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).shade }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).ciclamp }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).stoponx }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).stopony }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).skipfirst }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).skiplast }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).lsadvlast }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).length32 }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).lronly }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).ystride }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).endptfilter }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).adrmode }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).xyoffset }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).yflip }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).ensmask }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).cid_mask }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).sfactor }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).dfactor }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).rwpacked }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).hostdepth }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).rwdouble }, + { unpack(0x00000b2a, 0x30007109, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000710d cm=0x00001e02 +unsafe extern "C" fn shader_00000b2a_3000710d_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).opcode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).planes }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).drawdepth }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).dblsrc }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).rgbmode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).dither }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).logicop }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).compare }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).blend }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).backblend }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).blendalpha }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).fastclear }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).colorhost }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).alphahost }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).enzpattern }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).enlspattern }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).zpopaque }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).lsopaque }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).cidtest }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).shade }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).ciclamp }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).stoponx }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).stopony }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).skipfirst }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).skiplast }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).lsadvlast }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).length32 }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).lronly }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).ystride }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).endptfilter }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).adrmode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).xyoffset }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).yflip }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).ensmask }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).cid_mask }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).sfactor }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).dfactor }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).rwpacked }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).hostdepth }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).rwdouble }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000710d cm=0x00001e06 +unsafe extern "C" fn shader_00000b2a_3000710d_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).opcode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).planes }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).drawdepth }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).dblsrc }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).rgbmode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).dither }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).logicop }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).compare }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).blend }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).backblend }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).blendalpha }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).fastclear }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).colorhost }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).alphahost }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).enzpattern }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).enlspattern }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).zpopaque }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).lsopaque }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).cidtest }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).shade }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).ciclamp }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).stoponx }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).stopony }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).skipfirst }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).skiplast }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).lsadvlast }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).length32 }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).lronly }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).ystride }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).endptfilter }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).adrmode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).xyoffset }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).yflip }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).ensmask }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).cid_mask }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).sfactor }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).dfactor }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).rwpacked }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).hostdepth }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).rwdouble }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000710d cm=0x00001e0e +unsafe extern "C" fn shader_00000b2a_3000710d_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).opcode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).planes }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).drawdepth }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).dblsrc }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).rgbmode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).dither }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).logicop }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).compare }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).blend }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).backblend }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).blendalpha }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).fastclear }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).colorhost }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).alphahost }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).enzpattern }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).enlspattern }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).zpopaque }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).lsopaque }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).cidtest }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).shade }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).ciclamp }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).stoponx }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).stopony }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).skipfirst }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).skiplast }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).lsadvlast }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).length32 }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).lronly }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).ystride }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).endptfilter }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).adrmode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).xyoffset }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).yflip }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).ensmask }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).cid_mask }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).sfactor }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).dfactor }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).rwpacked }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).hostdepth }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).rwdouble }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000710d cm=0x00001e1e +unsafe extern "C" fn shader_00000b2a_3000710d_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).opcode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).planes }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).drawdepth }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).dblsrc }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).rgbmode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).dither }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).logicop }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).compare }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).blend }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).backblend }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).blendalpha }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).fastclear }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).colorhost }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).alphahost }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).enzpattern }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).enlspattern }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).zpopaque }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).lsopaque }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).cidtest }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).shade }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).ciclamp }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).stoponx }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).stopony }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).skipfirst }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).skiplast }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).lsadvlast }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).length32 }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).lronly }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).ystride }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).endptfilter }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).adrmode }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).xyoffset }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).yflip }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).ensmask }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).cid_mask }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).sfactor }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).dfactor }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).rwpacked }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).hostdepth }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).rwdouble }, + { unpack(0x00000b2a, 0x3000710d, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f109 cm=0x00001e02 +unsafe extern "C" fn shader_00000b2a_3000f109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).opcode }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).planes }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).drawdepth }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).dblsrc }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).rgbmode }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).dither }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).logicop }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).compare }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).blend }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).backblend }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).blendalpha }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).fastclear }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).colorhost }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).alphahost }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).enzpattern }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).enlspattern }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).zpopaque }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).lsopaque }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).cidtest }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).shade }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).ciclamp }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).stoponx }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).stopony }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).skipfirst }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).skiplast }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).lsadvlast }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).length32 }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).lronly }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).ystride }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).endptfilter }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).adrmode }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).xyoffset }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).yflip }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).ensmask }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).cid_mask }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).sfactor }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).dfactor }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).rwpacked }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).hostdepth }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).rwdouble }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f109 cm=0x00001e1e +unsafe extern "C" fn shader_00000b2a_3000f109_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).opcode }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).planes }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).drawdepth }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).dblsrc }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).rgbmode }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).dither }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).logicop }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).compare }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).blend }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).backblend }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).blendalpha }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).fastclear }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).colorhost }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).alphahost }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).enzpattern }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).enlspattern }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).zpopaque }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).lsopaque }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).cidtest }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).shade }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).ciclamp }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).stoponx }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).stopony }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).skipfirst }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).skiplast }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).lsadvlast }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).length32 }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).lronly }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).ystride }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).endptfilter }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).adrmode }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).xyoffset }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).yflip }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).ensmask }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).cid_mask }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).sfactor }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).dfactor }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).rwpacked }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).hostdepth }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).rwdouble }, + { unpack(0x00000b2a, 0x3000f109, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f211 cm=0x00001e02 +unsafe extern "C" fn shader_00000b2a_3000f211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).opcode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).planes }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).drawdepth }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).dblsrc }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).rgbmode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).dither }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).logicop }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).compare }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).blend }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).backblend }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).blendalpha }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).fastclear }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).colorhost }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).alphahost }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).enzpattern }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).enlspattern }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).zpopaque }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).lsopaque }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).cidtest }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).shade }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).ciclamp }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).stoponx }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).stopony }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).skipfirst }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).skiplast }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).lsadvlast }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).length32 }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).lronly }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).ystride }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).endptfilter }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).adrmode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).xyoffset }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).yflip }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).ensmask }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).cid_mask }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).sfactor }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).dfactor }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).rwpacked }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).hostdepth }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).rwdouble }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f211 cm=0x00001e06 +unsafe extern "C" fn shader_00000b2a_3000f211_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).opcode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).planes }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).drawdepth }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).dblsrc }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).rgbmode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).dither }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).logicop }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).compare }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).blend }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).backblend }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).blendalpha }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).fastclear }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).colorhost }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).alphahost }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).enzpattern }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).enlspattern }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).zpopaque }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).lsopaque }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).cidtest }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).shade }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).ciclamp }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).stoponx }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).stopony }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).skipfirst }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).skiplast }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).lsadvlast }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).length32 }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).lronly }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).ystride }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).endptfilter }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).adrmode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).xyoffset }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).yflip }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).ensmask }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).cid_mask }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).sfactor }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).dfactor }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).rwpacked }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).hostdepth }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).rwdouble }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f211 cm=0x00001e0e +unsafe extern "C" fn shader_00000b2a_3000f211_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).opcode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).planes }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).drawdepth }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).dblsrc }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).rgbmode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).dither }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).logicop }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).compare }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).blend }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).backblend }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).blendalpha }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).fastclear }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).colorhost }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).alphahost }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).enzpattern }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).enlspattern }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).zpopaque }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).lsopaque }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).cidtest }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).shade }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).ciclamp }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).stoponx }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).stopony }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).skipfirst }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).skiplast }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).lsadvlast }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).length32 }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).lronly }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).ystride }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).endptfilter }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).adrmode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).xyoffset }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).yflip }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).ensmask }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).cid_mask }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).sfactor }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).dfactor }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).rwpacked }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).hostdepth }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).rwdouble }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f211 cm=0x00001e1e +unsafe extern "C" fn shader_00000b2a_3000f211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).opcode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).planes }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).drawdepth }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).dblsrc }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).rgbmode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).dither }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).logicop }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).compare }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).blend }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).backblend }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).blendalpha }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).fastclear }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).colorhost }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).alphahost }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).enzpattern }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).enlspattern }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).zpopaque }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).lsopaque }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).cidtest }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).shade }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).ciclamp }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).stoponx }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).stopony }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).skipfirst }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).skiplast }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).lsadvlast }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).length32 }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).lronly }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).ystride }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).endptfilter }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).adrmode }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).xyoffset }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).yflip }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).ensmask }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).cid_mask }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).sfactor }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).dfactor }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).rwpacked }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).hostdepth }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).rwdouble }, + { unpack(0x00000b2a, 0x3000f211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f231 cm=0x00001e02 +unsafe extern "C" fn shader_00000b2a_3000f231_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).opcode }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).planes }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).drawdepth }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).dblsrc }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).rgbmode }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).dither }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).logicop }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).compare }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).blend }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).backblend }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).blendalpha }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).fastclear }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).colorhost }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).alphahost }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).enzpattern }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).enlspattern }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).zpopaque }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).lsopaque }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).cidtest }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).shade }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).ciclamp }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).stoponx }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).stopony }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).skipfirst }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).skiplast }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).lsadvlast }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).length32 }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).lronly }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).ystride }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).endptfilter }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).adrmode }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).xyoffset }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).yflip }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).ensmask }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).cid_mask }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).sfactor }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).dfactor }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).rwpacked }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).hostdepth }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).rwdouble }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f231 cm=0x00001e06 +unsafe extern "C" fn shader_00000b2a_3000f231_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).opcode }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).planes }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).drawdepth }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).dblsrc }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).rgbmode }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).dither }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).logicop }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).compare }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).blend }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).backblend }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).blendalpha }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).fastclear }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).colorhost }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).alphahost }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).enzpattern }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).enlspattern }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).zpopaque }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).lsopaque }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).cidtest }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).shade }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).ciclamp }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).stoponx }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).stopony }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).skipfirst }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).skiplast }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).lsadvlast }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).length32 }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).lronly }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).ystride }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).endptfilter }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).adrmode }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).xyoffset }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).yflip }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).ensmask }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).cid_mask }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).sfactor }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).dfactor }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).rwpacked }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).hostdepth }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).rwdouble }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f231 cm=0x00001e1e +unsafe extern "C" fn shader_00000b2a_3000f231_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).opcode }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).planes }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).drawdepth }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).dblsrc }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).rgbmode }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).dither }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).logicop }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).compare }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).blend }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).backblend }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).blendalpha }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).fastclear }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).colorhost }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).alphahost }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).enzpattern }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).enlspattern }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).zpopaque }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).lsopaque }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).cidtest }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).shade }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).ciclamp }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).stoponx }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).stopony }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).skipfirst }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).skiplast }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).lsadvlast }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).length32 }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).lronly }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).ystride }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).endptfilter }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).adrmode }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).xyoffset }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).yflip }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).ensmask }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).cid_mask }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).sfactor }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).dfactor }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).rwpacked }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).hostdepth }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).rwdouble }, + { unpack(0x00000b2a, 0x3000f231, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f319 cm=0x00001e02 +unsafe extern "C" fn shader_00000b2a_3000f319_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).opcode }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).planes }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).drawdepth }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).dblsrc }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).rgbmode }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).dither }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).logicop }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).compare }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).blend }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).backblend }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).blendalpha }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).fastclear }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).colorhost }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).alphahost }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).enzpattern }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).enlspattern }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).zpopaque }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).lsopaque }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).cidtest }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).shade }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).ciclamp }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).stoponx }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).stopony }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).skipfirst }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).skiplast }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).lsadvlast }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).length32 }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).lronly }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).ystride }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).endptfilter }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).adrmode }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).xyoffset }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).yflip }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).ensmask }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).cid_mask }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).sfactor }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).dfactor }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).rwpacked }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).hostdepth }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).rwdouble }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f319 cm=0x00001e06 +unsafe extern "C" fn shader_00000b2a_3000f319_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).opcode }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).planes }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).drawdepth }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).dblsrc }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).rgbmode }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).dither }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).logicop }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).compare }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).blend }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).backblend }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).blendalpha }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).fastclear }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).colorhost }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).alphahost }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).enzpattern }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).enlspattern }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).zpopaque }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).lsopaque }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).cidtest }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).shade }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).ciclamp }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).stoponx }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).stopony }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).skipfirst }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).skiplast }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).lsadvlast }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).length32 }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).lronly }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).ystride }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).endptfilter }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).adrmode }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).xyoffset }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).yflip }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).ensmask }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).cid_mask }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).sfactor }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).dfactor }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).rwpacked }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).hostdepth }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).rwdouble }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x3000f319 cm=0x00001e1e +unsafe extern "C" fn shader_00000b2a_3000f319_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).opcode }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).planes }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).drawdepth }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).dblsrc }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).rgbmode }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).dither }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).logicop }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).compare }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).blend }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).backblend }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).blendalpha }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).fastclear }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).colorhost }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).alphahost }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).enzpattern }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).enlspattern }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).zpopaque }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).lsopaque }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).cidtest }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).shade }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).ciclamp }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).stoponx }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).stopony }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).skipfirst }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).skiplast }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).lsadvlast }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).length32 }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).lronly }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).ystride }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).endptfilter }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).adrmode }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).xyoffset }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).yflip }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).ensmask }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).cid_mask }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).sfactor }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).dfactor }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).rwpacked }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).hostdepth }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).rwdouble }, + { unpack(0x00000b2a, 0x3000f319, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x6000710d cm=0x00001e02 +unsafe extern "C" fn shader_00000b2a_6000710d_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).opcode }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).planes }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).drawdepth }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).dblsrc }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).rgbmode }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).dither }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).logicop }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).compare }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).blend }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).backblend }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).blendalpha }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).fastclear }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).colorhost }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).alphahost }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).enzpattern }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).enlspattern }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).zpopaque }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).lsopaque }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).cidtest }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).shade }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).ciclamp }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).stoponx }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).stopony }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).skipfirst }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).skiplast }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).lsadvlast }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).length32 }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).lronly }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).ystride }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).endptfilter }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).adrmode }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).xyoffset }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).yflip }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).ensmask }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).cid_mask }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).sfactor }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).dfactor }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).rwpacked }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).hostdepth }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).rwdouble }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x6000710d cm=0x00001e0e +unsafe extern "C" fn shader_00000b2a_6000710d_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).opcode }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).planes }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).drawdepth }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).dblsrc }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).rgbmode }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).dither }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).logicop }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).compare }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).blend }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).backblend }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).blendalpha }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).fastclear }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).colorhost }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).alphahost }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).enzpattern }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).enlspattern }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).zpopaque }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).lsopaque }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).cidtest }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).shade }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).ciclamp }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).stoponx }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).stopony }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).skipfirst }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).skiplast }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).lsadvlast }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).length32 }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).lronly }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).ystride }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).endptfilter }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).adrmode }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).xyoffset }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).yflip }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).ensmask }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).cid_mask }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).sfactor }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).dfactor }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).rwpacked }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).hostdepth }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).rwdouble }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00000b2a dm1=0x6000710d cm=0x00001e1e +unsafe extern "C" fn shader_00000b2a_6000710d_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).opcode }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).planes }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).drawdepth }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).dblsrc }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).rgbmode }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).dither }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).logicop }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).compare }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).blend }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).backblend }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).blendalpha }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).fastclear }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).colorhost }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).alphahost }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).enzpattern }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).enlspattern }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).zpopaque }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).lsopaque }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).cidtest }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).shade }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).ciclamp }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).stoponx }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).stopony }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).skipfirst }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).skiplast }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).lsadvlast }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).length32 }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).lronly }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).ystride }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).endptfilter }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).adrmode }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).xyoffset }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).yflip }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).ensmask }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).cid_mask }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).sfactor }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).dfactor }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).rwpacked }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).hostdepth }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).rwdouble }, + { unpack(0x00000b2a, 0x6000710d, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3009700c cm=0x00001e03 +unsafe extern "C" fn shader_00001106_3009700c_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3009700c, 0x00001e03).opcode }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).planes }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).dither }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).logicop }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).compare }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).blend }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).backblend }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).shade }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).stopony }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).length32 }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).lronly }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).ystride }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).yflip }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x3009700c, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3009700d cm=0x00001e03 +unsafe extern "C" fn shader_00001106_3009700d_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3009700d, 0x00001e03).opcode }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).planes }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).dither }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).logicop }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).compare }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).blend }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).backblend }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).shade }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).stopony }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).length32 }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).lronly }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).ystride }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).yflip }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x3009700d, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x30097011 cm=0x00000403 +unsafe extern "C" fn shader_00001106_30097011_00000403( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x30097011, 0x00000403).opcode }, + { unpack(0x00001106, 0x30097011, 0x00000403).planes }, + { unpack(0x00001106, 0x30097011, 0x00000403).drawdepth }, + { unpack(0x00001106, 0x30097011, 0x00000403).dblsrc }, + { unpack(0x00001106, 0x30097011, 0x00000403).rgbmode }, + { unpack(0x00001106, 0x30097011, 0x00000403).dither }, + { unpack(0x00001106, 0x30097011, 0x00000403).logicop }, + { unpack(0x00001106, 0x30097011, 0x00000403).compare }, + { unpack(0x00001106, 0x30097011, 0x00000403).blend }, + { unpack(0x00001106, 0x30097011, 0x00000403).backblend }, + { unpack(0x00001106, 0x30097011, 0x00000403).blendalpha }, + { unpack(0x00001106, 0x30097011, 0x00000403).fastclear }, + { unpack(0x00001106, 0x30097011, 0x00000403).colorhost }, + { unpack(0x00001106, 0x30097011, 0x00000403).alphahost }, + { unpack(0x00001106, 0x30097011, 0x00000403).enzpattern }, + { unpack(0x00001106, 0x30097011, 0x00000403).enlspattern }, + { unpack(0x00001106, 0x30097011, 0x00000403).zpopaque }, + { unpack(0x00001106, 0x30097011, 0x00000403).lsopaque }, + { unpack(0x00001106, 0x30097011, 0x00000403).cidtest }, + { unpack(0x00001106, 0x30097011, 0x00000403).shade }, + { unpack(0x00001106, 0x30097011, 0x00000403).ciclamp }, + { unpack(0x00001106, 0x30097011, 0x00000403).stoponx }, + { unpack(0x00001106, 0x30097011, 0x00000403).stopony }, + { unpack(0x00001106, 0x30097011, 0x00000403).skipfirst }, + { unpack(0x00001106, 0x30097011, 0x00000403).skiplast }, + { unpack(0x00001106, 0x30097011, 0x00000403).lsadvlast }, + { unpack(0x00001106, 0x30097011, 0x00000403).length32 }, + { unpack(0x00001106, 0x30097011, 0x00000403).lronly }, + { unpack(0x00001106, 0x30097011, 0x00000403).ystride }, + { unpack(0x00001106, 0x30097011, 0x00000403).endptfilter }, + { unpack(0x00001106, 0x30097011, 0x00000403).adrmode }, + { unpack(0x00001106, 0x30097011, 0x00000403).xyoffset }, + { unpack(0x00001106, 0x30097011, 0x00000403).yflip }, + { unpack(0x00001106, 0x30097011, 0x00000403).ensmask }, + { unpack(0x00001106, 0x30097011, 0x00000403).cid_mask }, + { unpack(0x00001106, 0x30097011, 0x00000403).sfactor }, + { unpack(0x00001106, 0x30097011, 0x00000403).dfactor }, + { unpack(0x00001106, 0x30097011, 0x00000403).rwpacked }, + { unpack(0x00001106, 0x30097011, 0x00000403).hostdepth }, + { unpack(0x00001106, 0x30097011, 0x00000403).rwdouble }, + { unpack(0x00001106, 0x30097011, 0x00000403).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x30097011 cm=0x00001e03 +unsafe extern "C" fn shader_00001106_30097011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x30097011, 0x00001e03).opcode }, + { unpack(0x00001106, 0x30097011, 0x00001e03).planes }, + { unpack(0x00001106, 0x30097011, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x30097011, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x30097011, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x30097011, 0x00001e03).dither }, + { unpack(0x00001106, 0x30097011, 0x00001e03).logicop }, + { unpack(0x00001106, 0x30097011, 0x00001e03).compare }, + { unpack(0x00001106, 0x30097011, 0x00001e03).blend }, + { unpack(0x00001106, 0x30097011, 0x00001e03).backblend }, + { unpack(0x00001106, 0x30097011, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x30097011, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x30097011, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x30097011, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x30097011, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x30097011, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x30097011, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x30097011, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x30097011, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x30097011, 0x00001e03).shade }, + { unpack(0x00001106, 0x30097011, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x30097011, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x30097011, 0x00001e03).stopony }, + { unpack(0x00001106, 0x30097011, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x30097011, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x30097011, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x30097011, 0x00001e03).length32 }, + { unpack(0x00001106, 0x30097011, 0x00001e03).lronly }, + { unpack(0x00001106, 0x30097011, 0x00001e03).ystride }, + { unpack(0x00001106, 0x30097011, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x30097011, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x30097011, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x30097011, 0x00001e03).yflip }, + { unpack(0x00001106, 0x30097011, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x30097011, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x30097011, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x30097011, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x30097011, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x30097011, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x30097011, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x30097011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x30097031 cm=0x00000403 +unsafe extern "C" fn shader_00001106_30097031_00000403( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x30097031, 0x00000403).opcode }, + { unpack(0x00001106, 0x30097031, 0x00000403).planes }, + { unpack(0x00001106, 0x30097031, 0x00000403).drawdepth }, + { unpack(0x00001106, 0x30097031, 0x00000403).dblsrc }, + { unpack(0x00001106, 0x30097031, 0x00000403).rgbmode }, + { unpack(0x00001106, 0x30097031, 0x00000403).dither }, + { unpack(0x00001106, 0x30097031, 0x00000403).logicop }, + { unpack(0x00001106, 0x30097031, 0x00000403).compare }, + { unpack(0x00001106, 0x30097031, 0x00000403).blend }, + { unpack(0x00001106, 0x30097031, 0x00000403).backblend }, + { unpack(0x00001106, 0x30097031, 0x00000403).blendalpha }, + { unpack(0x00001106, 0x30097031, 0x00000403).fastclear }, + { unpack(0x00001106, 0x30097031, 0x00000403).colorhost }, + { unpack(0x00001106, 0x30097031, 0x00000403).alphahost }, + { unpack(0x00001106, 0x30097031, 0x00000403).enzpattern }, + { unpack(0x00001106, 0x30097031, 0x00000403).enlspattern }, + { unpack(0x00001106, 0x30097031, 0x00000403).zpopaque }, + { unpack(0x00001106, 0x30097031, 0x00000403).lsopaque }, + { unpack(0x00001106, 0x30097031, 0x00000403).cidtest }, + { unpack(0x00001106, 0x30097031, 0x00000403).shade }, + { unpack(0x00001106, 0x30097031, 0x00000403).ciclamp }, + { unpack(0x00001106, 0x30097031, 0x00000403).stoponx }, + { unpack(0x00001106, 0x30097031, 0x00000403).stopony }, + { unpack(0x00001106, 0x30097031, 0x00000403).skipfirst }, + { unpack(0x00001106, 0x30097031, 0x00000403).skiplast }, + { unpack(0x00001106, 0x30097031, 0x00000403).lsadvlast }, + { unpack(0x00001106, 0x30097031, 0x00000403).length32 }, + { unpack(0x00001106, 0x30097031, 0x00000403).lronly }, + { unpack(0x00001106, 0x30097031, 0x00000403).ystride }, + { unpack(0x00001106, 0x30097031, 0x00000403).endptfilter }, + { unpack(0x00001106, 0x30097031, 0x00000403).adrmode }, + { unpack(0x00001106, 0x30097031, 0x00000403).xyoffset }, + { unpack(0x00001106, 0x30097031, 0x00000403).yflip }, + { unpack(0x00001106, 0x30097031, 0x00000403).ensmask }, + { unpack(0x00001106, 0x30097031, 0x00000403).cid_mask }, + { unpack(0x00001106, 0x30097031, 0x00000403).sfactor }, + { unpack(0x00001106, 0x30097031, 0x00000403).dfactor }, + { unpack(0x00001106, 0x30097031, 0x00000403).rwpacked }, + { unpack(0x00001106, 0x30097031, 0x00000403).hostdepth }, + { unpack(0x00001106, 0x30097031, 0x00000403).rwdouble }, + { unpack(0x00001106, 0x30097031, 0x00000403).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x30097031 cm=0x00001e03 +unsafe extern "C" fn shader_00001106_30097031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x30097031, 0x00001e03).opcode }, + { unpack(0x00001106, 0x30097031, 0x00001e03).planes }, + { unpack(0x00001106, 0x30097031, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x30097031, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x30097031, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x30097031, 0x00001e03).dither }, + { unpack(0x00001106, 0x30097031, 0x00001e03).logicop }, + { unpack(0x00001106, 0x30097031, 0x00001e03).compare }, + { unpack(0x00001106, 0x30097031, 0x00001e03).blend }, + { unpack(0x00001106, 0x30097031, 0x00001e03).backblend }, + { unpack(0x00001106, 0x30097031, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x30097031, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x30097031, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x30097031, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x30097031, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x30097031, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x30097031, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x30097031, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x30097031, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x30097031, 0x00001e03).shade }, + { unpack(0x00001106, 0x30097031, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x30097031, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x30097031, 0x00001e03).stopony }, + { unpack(0x00001106, 0x30097031, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x30097031, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x30097031, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x30097031, 0x00001e03).length32 }, + { unpack(0x00001106, 0x30097031, 0x00001e03).lronly }, + { unpack(0x00001106, 0x30097031, 0x00001e03).ystride }, + { unpack(0x00001106, 0x30097031, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x30097031, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x30097031, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x30097031, 0x00001e03).yflip }, + { unpack(0x00001106, 0x30097031, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x30097031, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x30097031, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x30097031, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x30097031, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x30097031, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x30097031, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x30097031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00001106_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3009f019 cm=0x00001e03 +unsafe extern "C" fn shader_00001106_3009f019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3009f019, 0x00001e03).opcode }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).planes }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).dither }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).logicop }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).compare }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).blend }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).backblend }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).shade }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).stopony }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).length32 }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).lronly }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).ystride }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).yflip }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x3009f019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3009f019 cm=0x00001e1f +unsafe extern "C" fn shader_00001106_3009f019_00001e1f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3009f019, 0x00001e1f).opcode }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).planes }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).drawdepth }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).dblsrc }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).rgbmode }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).dither }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).logicop }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).compare }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).blend }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).backblend }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).blendalpha }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).fastclear }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).colorhost }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).alphahost }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).enzpattern }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).enlspattern }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).zpopaque }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).lsopaque }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).cidtest }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).shade }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).ciclamp }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).stoponx }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).stopony }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).skipfirst }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).skiplast }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).lsadvlast }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).length32 }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).lronly }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).ystride }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).endptfilter }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).adrmode }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).xyoffset }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).yflip }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).ensmask }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).cid_mask }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).sfactor }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).dfactor }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).rwpacked }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).hostdepth }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).rwdouble }, + { unpack(0x00001106, 0x3009f019, 0x00001e1f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00001106_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_00001106_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).planes }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).dither }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).compare }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).blend }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).shade }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_00001106_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).planes }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).dither }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).compare }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).blend }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).shade }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_00001106_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).planes }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).dither }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).compare }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).blend }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).shade }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001106 dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_00001106_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001106, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).planes }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).dither }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).compare }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).blend }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).shade }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x00001106, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001126 dm1=0x3009700d cm=0x00001e03 +unsafe extern "C" fn shader_00001126_3009700d_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001126, 0x3009700d, 0x00001e03).opcode }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).planes }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).drawdepth }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).dblsrc }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).rgbmode }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).dither }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).logicop }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).compare }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).blend }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).backblend }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).blendalpha }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).fastclear }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).colorhost }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).alphahost }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).enzpattern }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).enlspattern }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).zpopaque }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).lsopaque }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).cidtest }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).shade }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).ciclamp }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).stoponx }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).stopony }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).skipfirst }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).skiplast }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).lsadvlast }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).length32 }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).lronly }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).ystride }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).endptfilter }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).adrmode }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).xyoffset }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).yflip }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).ensmask }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).cid_mask }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).sfactor }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).dfactor }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).rwpacked }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).hostdepth }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).rwdouble }, + { unpack(0x00001126, 0x3009700d, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00001126 dm1=0x30097011 cm=0x00001e03 +unsafe extern "C" fn shader_00001126_30097011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00001126, 0x30097011, 0x00001e03).opcode }, + { unpack(0x00001126, 0x30097011, 0x00001e03).planes }, + { unpack(0x00001126, 0x30097011, 0x00001e03).drawdepth }, + { unpack(0x00001126, 0x30097011, 0x00001e03).dblsrc }, + { unpack(0x00001126, 0x30097011, 0x00001e03).rgbmode }, + { unpack(0x00001126, 0x30097011, 0x00001e03).dither }, + { unpack(0x00001126, 0x30097011, 0x00001e03).logicop }, + { unpack(0x00001126, 0x30097011, 0x00001e03).compare }, + { unpack(0x00001126, 0x30097011, 0x00001e03).blend }, + { unpack(0x00001126, 0x30097011, 0x00001e03).backblend }, + { unpack(0x00001126, 0x30097011, 0x00001e03).blendalpha }, + { unpack(0x00001126, 0x30097011, 0x00001e03).fastclear }, + { unpack(0x00001126, 0x30097011, 0x00001e03).colorhost }, + { unpack(0x00001126, 0x30097011, 0x00001e03).alphahost }, + { unpack(0x00001126, 0x30097011, 0x00001e03).enzpattern }, + { unpack(0x00001126, 0x30097011, 0x00001e03).enlspattern }, + { unpack(0x00001126, 0x30097011, 0x00001e03).zpopaque }, + { unpack(0x00001126, 0x30097011, 0x00001e03).lsopaque }, + { unpack(0x00001126, 0x30097011, 0x00001e03).cidtest }, + { unpack(0x00001126, 0x30097011, 0x00001e03).shade }, + { unpack(0x00001126, 0x30097011, 0x00001e03).ciclamp }, + { unpack(0x00001126, 0x30097011, 0x00001e03).stoponx }, + { unpack(0x00001126, 0x30097011, 0x00001e03).stopony }, + { unpack(0x00001126, 0x30097011, 0x00001e03).skipfirst }, + { unpack(0x00001126, 0x30097011, 0x00001e03).skiplast }, + { unpack(0x00001126, 0x30097011, 0x00001e03).lsadvlast }, + { unpack(0x00001126, 0x30097011, 0x00001e03).length32 }, + { unpack(0x00001126, 0x30097011, 0x00001e03).lronly }, + { unpack(0x00001126, 0x30097011, 0x00001e03).ystride }, + { unpack(0x00001126, 0x30097011, 0x00001e03).endptfilter }, + { unpack(0x00001126, 0x30097011, 0x00001e03).adrmode }, + { unpack(0x00001126, 0x30097011, 0x00001e03).xyoffset }, + { unpack(0x00001126, 0x30097011, 0x00001e03).yflip }, + { unpack(0x00001126, 0x30097011, 0x00001e03).ensmask }, + { unpack(0x00001126, 0x30097011, 0x00001e03).cid_mask }, + { unpack(0x00001126, 0x30097011, 0x00001e03).sfactor }, + { unpack(0x00001126, 0x30097011, 0x00001e03).dfactor }, + { unpack(0x00001126, 0x30097011, 0x00001e03).rwpacked }, + { unpack(0x00001126, 0x30097011, 0x00001e03).hostdepth }, + { unpack(0x00001126, 0x30097011, 0x00001e03).rwdouble }, + { unpack(0x00001126, 0x30097011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00002102 dm1=0x3000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00002102_3000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00002102, 0x3000f319, 0x00001e00).opcode }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).planes }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).drawdepth }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).dblsrc }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).rgbmode }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).dither }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).logicop }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).compare }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).blend }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).backblend }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).blendalpha }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).fastclear }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).colorhost }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).alphahost }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).enzpattern }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).enlspattern }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).zpopaque }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).lsopaque }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).cidtest }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).shade }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).ciclamp }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).stoponx }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).stopony }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).skipfirst }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).skiplast }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).lsadvlast }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).length32 }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).lronly }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).ystride }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).endptfilter }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).adrmode }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).xyoffset }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).yflip }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).ensmask }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).cid_mask }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).sfactor }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).dfactor }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).rwpacked }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).hostdepth }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).rwdouble }, + { unpack(0x00002102, 0x3000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00002102 dm1=0x6000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00002102_6000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00002102, 0x6000f319, 0x00001e00).opcode }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).planes }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).drawdepth }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).dblsrc }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).rgbmode }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).dither }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).logicop }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).compare }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).blend }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).backblend }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).blendalpha }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).fastclear }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).colorhost }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).alphahost }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).enzpattern }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).enlspattern }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).zpopaque }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).lsopaque }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).cidtest }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).shade }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).ciclamp }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).stoponx }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).stopony }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).skipfirst }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).skiplast }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).lsadvlast }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).length32 }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).lronly }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).ystride }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).endptfilter }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).adrmode }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).xyoffset }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).yflip }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).ensmask }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).cid_mask }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).sfactor }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).dfactor }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).rwpacked }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).hostdepth }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).rwdouble }, + { unpack(0x00002102, 0x6000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00002106 dm1=0x30007109 cm=0x00001e00 +unsafe extern "C" fn shader_00002106_30007109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00002106, 0x30007109, 0x00001e00).opcode }, + { unpack(0x00002106, 0x30007109, 0x00001e00).planes }, + { unpack(0x00002106, 0x30007109, 0x00001e00).drawdepth }, + { unpack(0x00002106, 0x30007109, 0x00001e00).dblsrc }, + { unpack(0x00002106, 0x30007109, 0x00001e00).rgbmode }, + { unpack(0x00002106, 0x30007109, 0x00001e00).dither }, + { unpack(0x00002106, 0x30007109, 0x00001e00).logicop }, + { unpack(0x00002106, 0x30007109, 0x00001e00).compare }, + { unpack(0x00002106, 0x30007109, 0x00001e00).blend }, + { unpack(0x00002106, 0x30007109, 0x00001e00).backblend }, + { unpack(0x00002106, 0x30007109, 0x00001e00).blendalpha }, + { unpack(0x00002106, 0x30007109, 0x00001e00).fastclear }, + { unpack(0x00002106, 0x30007109, 0x00001e00).colorhost }, + { unpack(0x00002106, 0x30007109, 0x00001e00).alphahost }, + { unpack(0x00002106, 0x30007109, 0x00001e00).enzpattern }, + { unpack(0x00002106, 0x30007109, 0x00001e00).enlspattern }, + { unpack(0x00002106, 0x30007109, 0x00001e00).zpopaque }, + { unpack(0x00002106, 0x30007109, 0x00001e00).lsopaque }, + { unpack(0x00002106, 0x30007109, 0x00001e00).cidtest }, + { unpack(0x00002106, 0x30007109, 0x00001e00).shade }, + { unpack(0x00002106, 0x30007109, 0x00001e00).ciclamp }, + { unpack(0x00002106, 0x30007109, 0x00001e00).stoponx }, + { unpack(0x00002106, 0x30007109, 0x00001e00).stopony }, + { unpack(0x00002106, 0x30007109, 0x00001e00).skipfirst }, + { unpack(0x00002106, 0x30007109, 0x00001e00).skiplast }, + { unpack(0x00002106, 0x30007109, 0x00001e00).lsadvlast }, + { unpack(0x00002106, 0x30007109, 0x00001e00).length32 }, + { unpack(0x00002106, 0x30007109, 0x00001e00).lronly }, + { unpack(0x00002106, 0x30007109, 0x00001e00).ystride }, + { unpack(0x00002106, 0x30007109, 0x00001e00).endptfilter }, + { unpack(0x00002106, 0x30007109, 0x00001e00).adrmode }, + { unpack(0x00002106, 0x30007109, 0x00001e00).xyoffset }, + { unpack(0x00002106, 0x30007109, 0x00001e00).yflip }, + { unpack(0x00002106, 0x30007109, 0x00001e00).ensmask }, + { unpack(0x00002106, 0x30007109, 0x00001e00).cid_mask }, + { unpack(0x00002106, 0x30007109, 0x00001e00).sfactor }, + { unpack(0x00002106, 0x30007109, 0x00001e00).dfactor }, + { unpack(0x00002106, 0x30007109, 0x00001e00).rwpacked }, + { unpack(0x00002106, 0x30007109, 0x00001e00).hostdepth }, + { unpack(0x00002106, 0x30007109, 0x00001e00).rwdouble }, + { unpack(0x00002106, 0x30007109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00002106 dm1=0x3000710d cm=0x00001e00 +unsafe extern "C" fn shader_00002106_3000710d_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00002106, 0x3000710d, 0x00001e00).opcode }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).planes }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).drawdepth }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).dblsrc }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).rgbmode }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).dither }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).logicop }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).compare }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).blend }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).backblend }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).blendalpha }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).fastclear }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).colorhost }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).alphahost }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).enzpattern }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).enlspattern }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).zpopaque }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).lsopaque }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).cidtest }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).shade }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).ciclamp }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).stoponx }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).stopony }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).skipfirst }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).skiplast }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).lsadvlast }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).length32 }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).lronly }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).ystride }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).endptfilter }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).adrmode }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).xyoffset }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).yflip }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).ensmask }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).cid_mask }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).sfactor }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).dfactor }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).rwpacked }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).hostdepth }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).rwdouble }, + { unpack(0x00002106, 0x3000710d, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00002106 dm1=0x3000f109 cm=0x00001e00 +unsafe extern "C" fn shader_00002106_3000f109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00002106, 0x3000f109, 0x00001e00).opcode }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).planes }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).drawdepth }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).dblsrc }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).rgbmode }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).dither }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).logicop }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).compare }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).blend }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).backblend }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).blendalpha }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).fastclear }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).colorhost }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).alphahost }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).enzpattern }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).enlspattern }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).zpopaque }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).lsopaque }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).cidtest }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).shade }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).ciclamp }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).stoponx }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).stopony }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).skipfirst }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).skiplast }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).lsadvlast }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).length32 }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).lronly }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).ystride }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).endptfilter }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).adrmode }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).xyoffset }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).yflip }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).ensmask }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).cid_mask }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).sfactor }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).dfactor }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).rwpacked }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).hostdepth }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).rwdouble }, + { unpack(0x00002106, 0x3000f109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00002106 dm1=0x3000f211 cm=0x00001e00 +unsafe extern "C" fn shader_00002106_3000f211_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00002106, 0x3000f211, 0x00001e00).opcode }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).planes }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).drawdepth }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).dblsrc }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).rgbmode }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).dither }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).logicop }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).compare }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).blend }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).backblend }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).blendalpha }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).fastclear }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).colorhost }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).alphahost }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).enzpattern }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).enlspattern }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).zpopaque }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).lsopaque }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).cidtest }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).shade }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).ciclamp }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).stoponx }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).stopony }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).skipfirst }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).skiplast }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).lsadvlast }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).length32 }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).lronly }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).ystride }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).endptfilter }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).adrmode }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).xyoffset }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).yflip }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).ensmask }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).cid_mask }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).sfactor }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).dfactor }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).rwpacked }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).hostdepth }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).rwdouble }, + { unpack(0x00002106, 0x3000f211, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00002106 dm1=0x3000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00002106_3000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00002106, 0x3000f319, 0x00001e00).opcode }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).planes }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).drawdepth }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).dblsrc }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).rgbmode }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).dither }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).logicop }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).compare }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).blend }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).backblend }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).blendalpha }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).fastclear }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).colorhost }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).alphahost }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).enzpattern }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).enlspattern }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).zpopaque }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).lsopaque }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).cidtest }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).shade }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).ciclamp }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).stoponx }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).stopony }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).skipfirst }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).skiplast }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).lsadvlast }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).length32 }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).lronly }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).ystride }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).endptfilter }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).adrmode }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).xyoffset }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).yflip }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).ensmask }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).cid_mask }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).sfactor }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).dfactor }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).rwpacked }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).hostdepth }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).rwdouble }, + { unpack(0x00002106, 0x3000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00002106 dm1=0x6000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00002106_6000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00002106, 0x6000f319, 0x00001e00).opcode }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).planes }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).drawdepth }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).dblsrc }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).rgbmode }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).dither }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).logicop }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).compare }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).blend }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).backblend }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).blendalpha }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).fastclear }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).colorhost }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).alphahost }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).enzpattern }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).enlspattern }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).zpopaque }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).lsopaque }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).cidtest }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).shade }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).ciclamp }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).stoponx }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).stopony }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).skipfirst }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).skiplast }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).lsadvlast }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).length32 }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).lronly }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).ystride }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).endptfilter }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).adrmode }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).xyoffset }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).yflip }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).ensmask }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).cid_mask }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).sfactor }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).dfactor }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).rwpacked }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).hostdepth }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).rwdouble }, + { unpack(0x00002106, 0x6000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000232e dm1=0x3008f011 cm=0x00001e03 +unsafe extern "C" fn shader_0000232e_3008f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000232e, 0x3008f011, 0x00001e03).opcode }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).planes }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).drawdepth }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).dblsrc }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).rgbmode }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).dither }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).logicop }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).compare }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).blend }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).backblend }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).blendalpha }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).fastclear }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).colorhost }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).alphahost }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).enzpattern }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).enlspattern }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).zpopaque }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).lsopaque }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).cidtest }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).shade }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).ciclamp }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).stoponx }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).stopony }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).skipfirst }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).skiplast }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).lsadvlast }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).length32 }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).lronly }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).ystride }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).endptfilter }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).adrmode }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).xyoffset }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).yflip }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).ensmask }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).cid_mask }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).sfactor }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).dfactor }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).rwpacked }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).hostdepth }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).rwdouble }, + { unpack(0x0000232e, 0x3008f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000232e dm1=0x3008f031 cm=0x00001e03 +unsafe extern "C" fn shader_0000232e_3008f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000232e, 0x3008f031, 0x00001e03).opcode }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).planes }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).drawdepth }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).dblsrc }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).rgbmode }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).dither }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).logicop }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).compare }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).blend }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).backblend }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).blendalpha }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).fastclear }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).colorhost }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).alphahost }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).enzpattern }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).enlspattern }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).zpopaque }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).lsopaque }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).cidtest }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).shade }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).ciclamp }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).stoponx }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).stopony }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).skipfirst }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).skiplast }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).lsadvlast }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).length32 }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).lronly }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).ystride }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).endptfilter }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).adrmode }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).xyoffset }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).yflip }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).ensmask }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).cid_mask }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).sfactor }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).dfactor }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).rwpacked }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).hostdepth }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).rwdouble }, + { unpack(0x0000232e, 0x3008f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000232e dm1=0x3009700d cm=0x00001e03 +unsafe extern "C" fn shader_0000232e_3009700d_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000232e, 0x3009700d, 0x00001e03).opcode }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).planes }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).drawdepth }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).dblsrc }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).rgbmode }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).dither }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).logicop }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).compare }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).blend }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).backblend }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).blendalpha }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).fastclear }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).colorhost }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).alphahost }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).enzpattern }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).enlspattern }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).zpopaque }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).lsopaque }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).cidtest }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).shade }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).ciclamp }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).stoponx }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).stopony }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).skipfirst }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).skiplast }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).lsadvlast }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).length32 }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).lronly }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).ystride }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).endptfilter }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).adrmode }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).xyoffset }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).yflip }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).ensmask }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).cid_mask }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).sfactor }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).dfactor }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).rwpacked }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).hostdepth }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).rwdouble }, + { unpack(0x0000232e, 0x3009700d, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000232e dm1=0x30097011 cm=0x00001e03 +unsafe extern "C" fn shader_0000232e_30097011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000232e, 0x30097011, 0x00001e03).opcode }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).planes }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).drawdepth }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).dblsrc }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).rgbmode }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).dither }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).logicop }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).compare }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).blend }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).backblend }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).blendalpha }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).fastclear }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).colorhost }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).alphahost }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).enzpattern }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).enlspattern }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).zpopaque }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).lsopaque }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).cidtest }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).shade }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).ciclamp }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).stoponx }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).stopony }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).skipfirst }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).skiplast }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).lsadvlast }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).length32 }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).lronly }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).ystride }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).endptfilter }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).adrmode }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).xyoffset }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).yflip }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).ensmask }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).cid_mask }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).sfactor }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).dfactor }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).rwpacked }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).hostdepth }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).rwdouble }, + { unpack(0x0000232e, 0x30097011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000232e dm1=0x30097031 cm=0x00001e03 +unsafe extern "C" fn shader_0000232e_30097031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000232e, 0x30097031, 0x00001e03).opcode }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).planes }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).drawdepth }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).dblsrc }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).rgbmode }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).dither }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).logicop }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).compare }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).blend }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).backblend }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).blendalpha }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).fastclear }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).colorhost }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).alphahost }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).enzpattern }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).enlspattern }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).zpopaque }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).lsopaque }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).cidtest }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).shade }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).ciclamp }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).stoponx }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).stopony }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).skipfirst }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).skiplast }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).lsadvlast }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).length32 }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).lronly }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).ystride }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).endptfilter }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).adrmode }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).xyoffset }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).yflip }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).ensmask }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).cid_mask }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).sfactor }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).dfactor }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).rwpacked }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).hostdepth }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).rwdouble }, + { unpack(0x0000232e, 0x30097031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000232e dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_0000232e_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000232e, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).planes }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).dither }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).compare }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).blend }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).shade }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x0000232e, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000232e dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_0000232e_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000232e, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).planes }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).dither }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).compare }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).blend }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).shade }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x0000232e, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000232e dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_0000232e_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000232e, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).planes }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).dither }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).compare }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).blend }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).shade }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x0000232e, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0000232e dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_0000232e_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0000232e, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).planes }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).dither }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).compare }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).blend }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).shade }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x0000232e, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x30007109 cm=0x00001e00 +unsafe extern "C" fn shader_00009106_30007109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x30007109, 0x00001e00).opcode }, + { unpack(0x00009106, 0x30007109, 0x00001e00).planes }, + { unpack(0x00009106, 0x30007109, 0x00001e00).drawdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e00).dblsrc }, + { unpack(0x00009106, 0x30007109, 0x00001e00).rgbmode }, + { unpack(0x00009106, 0x30007109, 0x00001e00).dither }, + { unpack(0x00009106, 0x30007109, 0x00001e00).logicop }, + { unpack(0x00009106, 0x30007109, 0x00001e00).compare }, + { unpack(0x00009106, 0x30007109, 0x00001e00).blend }, + { unpack(0x00009106, 0x30007109, 0x00001e00).backblend }, + { unpack(0x00009106, 0x30007109, 0x00001e00).blendalpha }, + { unpack(0x00009106, 0x30007109, 0x00001e00).fastclear }, + { unpack(0x00009106, 0x30007109, 0x00001e00).colorhost }, + { unpack(0x00009106, 0x30007109, 0x00001e00).alphahost }, + { unpack(0x00009106, 0x30007109, 0x00001e00).enzpattern }, + { unpack(0x00009106, 0x30007109, 0x00001e00).enlspattern }, + { unpack(0x00009106, 0x30007109, 0x00001e00).zpopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e00).lsopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e00).cidtest }, + { unpack(0x00009106, 0x30007109, 0x00001e00).shade }, + { unpack(0x00009106, 0x30007109, 0x00001e00).ciclamp }, + { unpack(0x00009106, 0x30007109, 0x00001e00).stoponx }, + { unpack(0x00009106, 0x30007109, 0x00001e00).stopony }, + { unpack(0x00009106, 0x30007109, 0x00001e00).skipfirst }, + { unpack(0x00009106, 0x30007109, 0x00001e00).skiplast }, + { unpack(0x00009106, 0x30007109, 0x00001e00).lsadvlast }, + { unpack(0x00009106, 0x30007109, 0x00001e00).length32 }, + { unpack(0x00009106, 0x30007109, 0x00001e00).lronly }, + { unpack(0x00009106, 0x30007109, 0x00001e00).ystride }, + { unpack(0x00009106, 0x30007109, 0x00001e00).endptfilter }, + { unpack(0x00009106, 0x30007109, 0x00001e00).adrmode }, + { unpack(0x00009106, 0x30007109, 0x00001e00).xyoffset }, + { unpack(0x00009106, 0x30007109, 0x00001e00).yflip }, + { unpack(0x00009106, 0x30007109, 0x00001e00).ensmask }, + { unpack(0x00009106, 0x30007109, 0x00001e00).cid_mask }, + { unpack(0x00009106, 0x30007109, 0x00001e00).sfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e00).dfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e00).rwpacked }, + { unpack(0x00009106, 0x30007109, 0x00001e00).hostdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e00).rwdouble }, + { unpack(0x00009106, 0x30007109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x30007109 cm=0x00001e02 +unsafe extern "C" fn shader_00009106_30007109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x30007109, 0x00001e02).opcode }, + { unpack(0x00009106, 0x30007109, 0x00001e02).planes }, + { unpack(0x00009106, 0x30007109, 0x00001e02).drawdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e02).dblsrc }, + { unpack(0x00009106, 0x30007109, 0x00001e02).rgbmode }, + { unpack(0x00009106, 0x30007109, 0x00001e02).dither }, + { unpack(0x00009106, 0x30007109, 0x00001e02).logicop }, + { unpack(0x00009106, 0x30007109, 0x00001e02).compare }, + { unpack(0x00009106, 0x30007109, 0x00001e02).blend }, + { unpack(0x00009106, 0x30007109, 0x00001e02).backblend }, + { unpack(0x00009106, 0x30007109, 0x00001e02).blendalpha }, + { unpack(0x00009106, 0x30007109, 0x00001e02).fastclear }, + { unpack(0x00009106, 0x30007109, 0x00001e02).colorhost }, + { unpack(0x00009106, 0x30007109, 0x00001e02).alphahost }, + { unpack(0x00009106, 0x30007109, 0x00001e02).enzpattern }, + { unpack(0x00009106, 0x30007109, 0x00001e02).enlspattern }, + { unpack(0x00009106, 0x30007109, 0x00001e02).zpopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e02).lsopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e02).cidtest }, + { unpack(0x00009106, 0x30007109, 0x00001e02).shade }, + { unpack(0x00009106, 0x30007109, 0x00001e02).ciclamp }, + { unpack(0x00009106, 0x30007109, 0x00001e02).stoponx }, + { unpack(0x00009106, 0x30007109, 0x00001e02).stopony }, + { unpack(0x00009106, 0x30007109, 0x00001e02).skipfirst }, + { unpack(0x00009106, 0x30007109, 0x00001e02).skiplast }, + { unpack(0x00009106, 0x30007109, 0x00001e02).lsadvlast }, + { unpack(0x00009106, 0x30007109, 0x00001e02).length32 }, + { unpack(0x00009106, 0x30007109, 0x00001e02).lronly }, + { unpack(0x00009106, 0x30007109, 0x00001e02).ystride }, + { unpack(0x00009106, 0x30007109, 0x00001e02).endptfilter }, + { unpack(0x00009106, 0x30007109, 0x00001e02).adrmode }, + { unpack(0x00009106, 0x30007109, 0x00001e02).xyoffset }, + { unpack(0x00009106, 0x30007109, 0x00001e02).yflip }, + { unpack(0x00009106, 0x30007109, 0x00001e02).ensmask }, + { unpack(0x00009106, 0x30007109, 0x00001e02).cid_mask }, + { unpack(0x00009106, 0x30007109, 0x00001e02).sfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e02).dfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e02).rwpacked }, + { unpack(0x00009106, 0x30007109, 0x00001e02).hostdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e02).rwdouble }, + { unpack(0x00009106, 0x30007109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x30007109 cm=0x00001e06 +unsafe extern "C" fn shader_00009106_30007109_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x30007109, 0x00001e06).opcode }, + { unpack(0x00009106, 0x30007109, 0x00001e06).planes }, + { unpack(0x00009106, 0x30007109, 0x00001e06).drawdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e06).dblsrc }, + { unpack(0x00009106, 0x30007109, 0x00001e06).rgbmode }, + { unpack(0x00009106, 0x30007109, 0x00001e06).dither }, + { unpack(0x00009106, 0x30007109, 0x00001e06).logicop }, + { unpack(0x00009106, 0x30007109, 0x00001e06).compare }, + { unpack(0x00009106, 0x30007109, 0x00001e06).blend }, + { unpack(0x00009106, 0x30007109, 0x00001e06).backblend }, + { unpack(0x00009106, 0x30007109, 0x00001e06).blendalpha }, + { unpack(0x00009106, 0x30007109, 0x00001e06).fastclear }, + { unpack(0x00009106, 0x30007109, 0x00001e06).colorhost }, + { unpack(0x00009106, 0x30007109, 0x00001e06).alphahost }, + { unpack(0x00009106, 0x30007109, 0x00001e06).enzpattern }, + { unpack(0x00009106, 0x30007109, 0x00001e06).enlspattern }, + { unpack(0x00009106, 0x30007109, 0x00001e06).zpopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e06).lsopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e06).cidtest }, + { unpack(0x00009106, 0x30007109, 0x00001e06).shade }, + { unpack(0x00009106, 0x30007109, 0x00001e06).ciclamp }, + { unpack(0x00009106, 0x30007109, 0x00001e06).stoponx }, + { unpack(0x00009106, 0x30007109, 0x00001e06).stopony }, + { unpack(0x00009106, 0x30007109, 0x00001e06).skipfirst }, + { unpack(0x00009106, 0x30007109, 0x00001e06).skiplast }, + { unpack(0x00009106, 0x30007109, 0x00001e06).lsadvlast }, + { unpack(0x00009106, 0x30007109, 0x00001e06).length32 }, + { unpack(0x00009106, 0x30007109, 0x00001e06).lronly }, + { unpack(0x00009106, 0x30007109, 0x00001e06).ystride }, + { unpack(0x00009106, 0x30007109, 0x00001e06).endptfilter }, + { unpack(0x00009106, 0x30007109, 0x00001e06).adrmode }, + { unpack(0x00009106, 0x30007109, 0x00001e06).xyoffset }, + { unpack(0x00009106, 0x30007109, 0x00001e06).yflip }, + { unpack(0x00009106, 0x30007109, 0x00001e06).ensmask }, + { unpack(0x00009106, 0x30007109, 0x00001e06).cid_mask }, + { unpack(0x00009106, 0x30007109, 0x00001e06).sfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e06).dfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e06).rwpacked }, + { unpack(0x00009106, 0x30007109, 0x00001e06).hostdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e06).rwdouble }, + { unpack(0x00009106, 0x30007109, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x30007109 cm=0x00001e0e +unsafe extern "C" fn shader_00009106_30007109_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x30007109, 0x00001e0e).opcode }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).planes }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).drawdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).dblsrc }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).rgbmode }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).dither }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).logicop }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).compare }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).blend }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).backblend }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).blendalpha }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).fastclear }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).colorhost }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).alphahost }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).enzpattern }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).enlspattern }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).zpopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).lsopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).cidtest }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).shade }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).ciclamp }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).stoponx }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).stopony }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).skipfirst }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).skiplast }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).lsadvlast }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).length32 }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).lronly }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).ystride }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).endptfilter }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).adrmode }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).xyoffset }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).yflip }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).ensmask }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).cid_mask }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).sfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).dfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).rwpacked }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).hostdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).rwdouble }, + { unpack(0x00009106, 0x30007109, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x30007109 cm=0x00001e1e +unsafe extern "C" fn shader_00009106_30007109_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x30007109, 0x00001e1e).opcode }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).planes }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).drawdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).dblsrc }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).rgbmode }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).dither }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).logicop }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).compare }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).blend }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).backblend }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).blendalpha }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).fastclear }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).colorhost }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).alphahost }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).enzpattern }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).enlspattern }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).zpopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).lsopaque }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).cidtest }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).shade }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).ciclamp }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).stoponx }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).stopony }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).skipfirst }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).skiplast }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).lsadvlast }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).length32 }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).lronly }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).ystride }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).endptfilter }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).adrmode }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).xyoffset }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).yflip }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).ensmask }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).cid_mask }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).sfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).dfactor }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).rwpacked }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).hostdepth }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).rwdouble }, + { unpack(0x00009106, 0x30007109, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000710d cm=0x00001e02 +unsafe extern "C" fn shader_00009106_3000710d_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000710d, 0x00001e02).opcode }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).planes }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).drawdepth }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).dblsrc }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).rgbmode }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).dither }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).logicop }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).compare }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).blend }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).backblend }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).blendalpha }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).fastclear }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).colorhost }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).alphahost }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).enzpattern }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).enlspattern }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).zpopaque }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).lsopaque }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).cidtest }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).shade }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).ciclamp }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).stoponx }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).stopony }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).skipfirst }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).skiplast }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).lsadvlast }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).length32 }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).lronly }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).ystride }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).endptfilter }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).adrmode }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).xyoffset }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).yflip }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).ensmask }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).cid_mask }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).sfactor }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).dfactor }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).rwpacked }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).hostdepth }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).rwdouble }, + { unpack(0x00009106, 0x3000710d, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000710d cm=0x00001e06 +unsafe extern "C" fn shader_00009106_3000710d_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000710d, 0x00001e06).opcode }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).planes }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).drawdepth }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).dblsrc }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).rgbmode }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).dither }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).logicop }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).compare }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).blend }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).backblend }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).blendalpha }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).fastclear }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).colorhost }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).alphahost }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).enzpattern }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).enlspattern }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).zpopaque }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).lsopaque }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).cidtest }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).shade }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).ciclamp }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).stoponx }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).stopony }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).skipfirst }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).skiplast }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).lsadvlast }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).length32 }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).lronly }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).ystride }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).endptfilter }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).adrmode }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).xyoffset }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).yflip }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).ensmask }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).cid_mask }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).sfactor }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).dfactor }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).rwpacked }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).hostdepth }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).rwdouble }, + { unpack(0x00009106, 0x3000710d, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000710d cm=0x00001e0e +unsafe extern "C" fn shader_00009106_3000710d_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000710d, 0x00001e0e).opcode }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).planes }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).drawdepth }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).dblsrc }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).rgbmode }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).dither }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).logicop }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).compare }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).blend }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).backblend }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).blendalpha }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).fastclear }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).colorhost }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).alphahost }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).enzpattern }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).enlspattern }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).zpopaque }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).lsopaque }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).cidtest }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).shade }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).ciclamp }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).stoponx }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).stopony }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).skipfirst }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).skiplast }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).lsadvlast }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).length32 }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).lronly }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).ystride }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).endptfilter }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).adrmode }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).xyoffset }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).yflip }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).ensmask }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).cid_mask }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).sfactor }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).dfactor }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).rwpacked }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).hostdepth }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).rwdouble }, + { unpack(0x00009106, 0x3000710d, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000710d cm=0x00001e1e +unsafe extern "C" fn shader_00009106_3000710d_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000710d, 0x00001e1e).opcode }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).planes }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).drawdepth }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).dblsrc }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).rgbmode }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).dither }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).logicop }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).compare }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).blend }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).backblend }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).blendalpha }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).fastclear }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).colorhost }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).alphahost }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).enzpattern }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).enlspattern }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).zpopaque }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).lsopaque }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).cidtest }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).shade }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).ciclamp }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).stoponx }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).stopony }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).skipfirst }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).skiplast }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).lsadvlast }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).length32 }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).lronly }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).ystride }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).endptfilter }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).adrmode }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).xyoffset }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).yflip }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).ensmask }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).cid_mask }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).sfactor }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).dfactor }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).rwpacked }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).hostdepth }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).rwdouble }, + { unpack(0x00009106, 0x3000710d, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x30007211 cm=0x00001e02 +unsafe extern "C" fn shader_00009106_30007211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x30007211, 0x00001e02).opcode }, + { unpack(0x00009106, 0x30007211, 0x00001e02).planes }, + { unpack(0x00009106, 0x30007211, 0x00001e02).drawdepth }, + { unpack(0x00009106, 0x30007211, 0x00001e02).dblsrc }, + { unpack(0x00009106, 0x30007211, 0x00001e02).rgbmode }, + { unpack(0x00009106, 0x30007211, 0x00001e02).dither }, + { unpack(0x00009106, 0x30007211, 0x00001e02).logicop }, + { unpack(0x00009106, 0x30007211, 0x00001e02).compare }, + { unpack(0x00009106, 0x30007211, 0x00001e02).blend }, + { unpack(0x00009106, 0x30007211, 0x00001e02).backblend }, + { unpack(0x00009106, 0x30007211, 0x00001e02).blendalpha }, + { unpack(0x00009106, 0x30007211, 0x00001e02).fastclear }, + { unpack(0x00009106, 0x30007211, 0x00001e02).colorhost }, + { unpack(0x00009106, 0x30007211, 0x00001e02).alphahost }, + { unpack(0x00009106, 0x30007211, 0x00001e02).enzpattern }, + { unpack(0x00009106, 0x30007211, 0x00001e02).enlspattern }, + { unpack(0x00009106, 0x30007211, 0x00001e02).zpopaque }, + { unpack(0x00009106, 0x30007211, 0x00001e02).lsopaque }, + { unpack(0x00009106, 0x30007211, 0x00001e02).cidtest }, + { unpack(0x00009106, 0x30007211, 0x00001e02).shade }, + { unpack(0x00009106, 0x30007211, 0x00001e02).ciclamp }, + { unpack(0x00009106, 0x30007211, 0x00001e02).stoponx }, + { unpack(0x00009106, 0x30007211, 0x00001e02).stopony }, + { unpack(0x00009106, 0x30007211, 0x00001e02).skipfirst }, + { unpack(0x00009106, 0x30007211, 0x00001e02).skiplast }, + { unpack(0x00009106, 0x30007211, 0x00001e02).lsadvlast }, + { unpack(0x00009106, 0x30007211, 0x00001e02).length32 }, + { unpack(0x00009106, 0x30007211, 0x00001e02).lronly }, + { unpack(0x00009106, 0x30007211, 0x00001e02).ystride }, + { unpack(0x00009106, 0x30007211, 0x00001e02).endptfilter }, + { unpack(0x00009106, 0x30007211, 0x00001e02).adrmode }, + { unpack(0x00009106, 0x30007211, 0x00001e02).xyoffset }, + { unpack(0x00009106, 0x30007211, 0x00001e02).yflip }, + { unpack(0x00009106, 0x30007211, 0x00001e02).ensmask }, + { unpack(0x00009106, 0x30007211, 0x00001e02).cid_mask }, + { unpack(0x00009106, 0x30007211, 0x00001e02).sfactor }, + { unpack(0x00009106, 0x30007211, 0x00001e02).dfactor }, + { unpack(0x00009106, 0x30007211, 0x00001e02).rwpacked }, + { unpack(0x00009106, 0x30007211, 0x00001e02).hostdepth }, + { unpack(0x00009106, 0x30007211, 0x00001e02).rwdouble }, + { unpack(0x00009106, 0x30007211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x30007211 cm=0x00001e1e +unsafe extern "C" fn shader_00009106_30007211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x30007211, 0x00001e1e).opcode }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).planes }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).drawdepth }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).dblsrc }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).rgbmode }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).dither }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).logicop }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).compare }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).blend }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).backblend }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).blendalpha }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).fastclear }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).colorhost }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).alphahost }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).enzpattern }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).enlspattern }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).zpopaque }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).lsopaque }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).cidtest }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).shade }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).ciclamp }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).stoponx }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).stopony }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).skipfirst }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).skiplast }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).lsadvlast }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).length32 }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).lronly }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).ystride }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).endptfilter }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).adrmode }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).xyoffset }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).yflip }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).ensmask }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).cid_mask }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).sfactor }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).dfactor }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).rwpacked }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).hostdepth }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).rwdouble }, + { unpack(0x00009106, 0x30007211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f109 cm=0x00001e02 +unsafe extern "C" fn shader_00009106_3000f109_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f109, 0x00001e02).opcode }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).planes }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).drawdepth }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).dblsrc }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).rgbmode }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).dither }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).logicop }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).compare }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).blend }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).backblend }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).blendalpha }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).fastclear }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).colorhost }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).alphahost }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).enzpattern }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).enlspattern }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).zpopaque }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).lsopaque }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).cidtest }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).shade }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).ciclamp }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).stoponx }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).stopony }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).skipfirst }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).skiplast }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).lsadvlast }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).length32 }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).lronly }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).ystride }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).endptfilter }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).adrmode }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).xyoffset }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).yflip }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).ensmask }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).cid_mask }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).sfactor }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).dfactor }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).rwpacked }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).hostdepth }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).rwdouble }, + { unpack(0x00009106, 0x3000f109, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f211 cm=0x00001e02 +unsafe extern "C" fn shader_00009106_3000f211_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f211, 0x00001e02).opcode }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).planes }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).drawdepth }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).dblsrc }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).rgbmode }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).dither }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).logicop }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).compare }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).blend }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).backblend }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).blendalpha }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).fastclear }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).colorhost }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).alphahost }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).enzpattern }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).enlspattern }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).zpopaque }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).lsopaque }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).cidtest }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).shade }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).ciclamp }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).stoponx }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).stopony }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).skipfirst }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).skiplast }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).lsadvlast }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).length32 }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).lronly }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).ystride }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).endptfilter }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).adrmode }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).xyoffset }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).yflip }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).ensmask }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).cid_mask }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).sfactor }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).dfactor }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).rwpacked }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).hostdepth }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).rwdouble }, + { unpack(0x00009106, 0x3000f211, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f211 cm=0x00001e06 +unsafe extern "C" fn shader_00009106_3000f211_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f211, 0x00001e06).opcode }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).planes }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).drawdepth }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).dblsrc }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).rgbmode }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).dither }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).logicop }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).compare }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).blend }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).backblend }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).blendalpha }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).fastclear }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).colorhost }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).alphahost }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).enzpattern }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).enlspattern }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).zpopaque }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).lsopaque }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).cidtest }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).shade }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).ciclamp }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).stoponx }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).stopony }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).skipfirst }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).skiplast }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).lsadvlast }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).length32 }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).lronly }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).ystride }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).endptfilter }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).adrmode }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).xyoffset }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).yflip }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).ensmask }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).cid_mask }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).sfactor }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).dfactor }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).rwpacked }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).hostdepth }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).rwdouble }, + { unpack(0x00009106, 0x3000f211, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f211 cm=0x00001e0e +unsafe extern "C" fn shader_00009106_3000f211_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f211, 0x00001e0e).opcode }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).planes }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).drawdepth }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).dblsrc }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).rgbmode }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).dither }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).logicop }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).compare }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).blend }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).backblend }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).blendalpha }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).fastclear }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).colorhost }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).alphahost }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).enzpattern }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).enlspattern }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).zpopaque }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).lsopaque }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).cidtest }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).shade }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).ciclamp }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).stoponx }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).stopony }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).skipfirst }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).skiplast }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).lsadvlast }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).length32 }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).lronly }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).ystride }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).endptfilter }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).adrmode }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).xyoffset }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).yflip }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).ensmask }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).cid_mask }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).sfactor }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).dfactor }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).rwpacked }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).hostdepth }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).rwdouble }, + { unpack(0x00009106, 0x3000f211, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f211 cm=0x00001e1e +unsafe extern "C" fn shader_00009106_3000f211_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f211, 0x00001e1e).opcode }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).planes }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).drawdepth }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).dblsrc }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).rgbmode }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).dither }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).logicop }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).compare }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).blend }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).backblend }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).blendalpha }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).fastclear }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).colorhost }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).alphahost }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).enzpattern }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).enlspattern }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).zpopaque }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).lsopaque }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).cidtest }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).shade }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).ciclamp }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).stoponx }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).stopony }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).skipfirst }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).skiplast }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).lsadvlast }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).length32 }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).lronly }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).ystride }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).endptfilter }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).adrmode }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).xyoffset }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).yflip }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).ensmask }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).cid_mask }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).sfactor }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).dfactor }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).rwpacked }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).hostdepth }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).rwdouble }, + { unpack(0x00009106, 0x3000f211, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f231 cm=0x00001e02 +unsafe extern "C" fn shader_00009106_3000f231_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f231, 0x00001e02).opcode }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).planes }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).drawdepth }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).dblsrc }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).rgbmode }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).dither }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).logicop }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).compare }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).blend }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).backblend }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).blendalpha }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).fastclear }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).colorhost }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).alphahost }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).enzpattern }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).enlspattern }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).zpopaque }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).lsopaque }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).cidtest }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).shade }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).ciclamp }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).stoponx }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).stopony }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).skipfirst }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).skiplast }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).lsadvlast }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).length32 }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).lronly }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).ystride }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).endptfilter }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).adrmode }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).xyoffset }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).yflip }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).ensmask }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).cid_mask }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).sfactor }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).dfactor }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).rwpacked }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).hostdepth }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).rwdouble }, + { unpack(0x00009106, 0x3000f231, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f231 cm=0x00001e06 +unsafe extern "C" fn shader_00009106_3000f231_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f231, 0x00001e06).opcode }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).planes }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).drawdepth }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).dblsrc }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).rgbmode }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).dither }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).logicop }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).compare }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).blend }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).backblend }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).blendalpha }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).fastclear }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).colorhost }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).alphahost }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).enzpattern }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).enlspattern }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).zpopaque }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).lsopaque }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).cidtest }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).shade }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).ciclamp }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).stoponx }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).stopony }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).skipfirst }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).skiplast }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).lsadvlast }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).length32 }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).lronly }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).ystride }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).endptfilter }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).adrmode }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).xyoffset }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).yflip }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).ensmask }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).cid_mask }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).sfactor }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).dfactor }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).rwpacked }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).hostdepth }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).rwdouble }, + { unpack(0x00009106, 0x3000f231, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f231 cm=0x00001e1e +unsafe extern "C" fn shader_00009106_3000f231_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f231, 0x00001e1e).opcode }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).planes }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).drawdepth }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).dblsrc }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).rgbmode }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).dither }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).logicop }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).compare }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).blend }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).backblend }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).blendalpha }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).fastclear }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).colorhost }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).alphahost }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).enzpattern }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).enlspattern }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).zpopaque }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).lsopaque }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).cidtest }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).shade }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).ciclamp }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).stoponx }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).stopony }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).skipfirst }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).skiplast }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).lsadvlast }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).length32 }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).lronly }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).ystride }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).endptfilter }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).adrmode }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).xyoffset }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).yflip }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).ensmask }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).cid_mask }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).sfactor }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).dfactor }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).rwpacked }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).hostdepth }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).rwdouble }, + { unpack(0x00009106, 0x3000f231, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00009106_3000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f319, 0x00001e00).opcode }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).planes }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).drawdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).dblsrc }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).rgbmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).dither }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).logicop }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).compare }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).blend }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).backblend }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).blendalpha }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).fastclear }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).colorhost }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).alphahost }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).enzpattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).enlspattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).zpopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).lsopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).cidtest }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).shade }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).ciclamp }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).stoponx }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).stopony }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).skipfirst }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).skiplast }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).lsadvlast }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).length32 }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).lronly }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).ystride }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).endptfilter }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).adrmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).xyoffset }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).yflip }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).ensmask }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).cid_mask }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).sfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).dfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).rwpacked }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).hostdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).rwdouble }, + { unpack(0x00009106, 0x3000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f319 cm=0x00001e02 +unsafe extern "C" fn shader_00009106_3000f319_00001e02( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f319, 0x00001e02).opcode }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).planes }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).drawdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).dblsrc }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).rgbmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).dither }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).logicop }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).compare }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).blend }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).backblend }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).blendalpha }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).fastclear }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).colorhost }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).alphahost }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).enzpattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).enlspattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).zpopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).lsopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).cidtest }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).shade }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).ciclamp }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).stoponx }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).stopony }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).skipfirst }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).skiplast }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).lsadvlast }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).length32 }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).lronly }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).ystride }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).endptfilter }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).adrmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).xyoffset }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).yflip }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).ensmask }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).cid_mask }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).sfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).dfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).rwpacked }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).hostdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).rwdouble }, + { unpack(0x00009106, 0x3000f319, 0x00001e02).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f319 cm=0x00001e06 +unsafe extern "C" fn shader_00009106_3000f319_00001e06( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f319, 0x00001e06).opcode }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).planes }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).drawdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).dblsrc }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).rgbmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).dither }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).logicop }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).compare }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).blend }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).backblend }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).blendalpha }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).fastclear }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).colorhost }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).alphahost }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).enzpattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).enlspattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).zpopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).lsopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).cidtest }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).shade }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).ciclamp }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).stoponx }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).stopony }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).skipfirst }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).skiplast }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).lsadvlast }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).length32 }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).lronly }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).ystride }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).endptfilter }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).adrmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).xyoffset }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).yflip }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).ensmask }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).cid_mask }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).sfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).dfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).rwpacked }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).hostdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).rwdouble }, + { unpack(0x00009106, 0x3000f319, 0x00001e06).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f319 cm=0x00001e0e +unsafe extern "C" fn shader_00009106_3000f319_00001e0e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f319, 0x00001e0e).opcode }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).planes }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).drawdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).dblsrc }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).rgbmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).dither }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).logicop }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).compare }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).blend }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).backblend }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).blendalpha }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).fastclear }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).colorhost }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).alphahost }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).enzpattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).enlspattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).zpopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).lsopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).cidtest }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).shade }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).ciclamp }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).stoponx }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).stopony }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).skipfirst }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).skiplast }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).lsadvlast }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).length32 }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).lronly }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).ystride }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).endptfilter }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).adrmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).xyoffset }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).yflip }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).ensmask }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).cid_mask }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).sfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).dfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).rwpacked }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).hostdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).rwdouble }, + { unpack(0x00009106, 0x3000f319, 0x00001e0e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3000f319 cm=0x00001e1e +unsafe extern "C" fn shader_00009106_3000f319_00001e1e( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3000f319, 0x00001e1e).opcode }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).planes }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).drawdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).dblsrc }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).rgbmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).dither }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).logicop }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).compare }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).blend }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).backblend }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).blendalpha }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).fastclear }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).colorhost }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).alphahost }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).enzpattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).enlspattern }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).zpopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).lsopaque }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).cidtest }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).shade }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).ciclamp }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).stoponx }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).stopony }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).skipfirst }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).skiplast }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).lsadvlast }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).length32 }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).lronly }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).ystride }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).endptfilter }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).adrmode }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).xyoffset }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).yflip }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).ensmask }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).cid_mask }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).sfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).dfactor }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).rwpacked }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).hostdepth }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).rwdouble }, + { unpack(0x00009106, 0x3000f319, 0x00001e1e).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x30017009 cm=0x00001e03 +unsafe extern "C" fn shader_00009106_30017009_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x30017009, 0x00001e03).opcode }, + { unpack(0x00009106, 0x30017009, 0x00001e03).planes }, + { unpack(0x00009106, 0x30017009, 0x00001e03).drawdepth }, + { unpack(0x00009106, 0x30017009, 0x00001e03).dblsrc }, + { unpack(0x00009106, 0x30017009, 0x00001e03).rgbmode }, + { unpack(0x00009106, 0x30017009, 0x00001e03).dither }, + { unpack(0x00009106, 0x30017009, 0x00001e03).logicop }, + { unpack(0x00009106, 0x30017009, 0x00001e03).compare }, + { unpack(0x00009106, 0x30017009, 0x00001e03).blend }, + { unpack(0x00009106, 0x30017009, 0x00001e03).backblend }, + { unpack(0x00009106, 0x30017009, 0x00001e03).blendalpha }, + { unpack(0x00009106, 0x30017009, 0x00001e03).fastclear }, + { unpack(0x00009106, 0x30017009, 0x00001e03).colorhost }, + { unpack(0x00009106, 0x30017009, 0x00001e03).alphahost }, + { unpack(0x00009106, 0x30017009, 0x00001e03).enzpattern }, + { unpack(0x00009106, 0x30017009, 0x00001e03).enlspattern }, + { unpack(0x00009106, 0x30017009, 0x00001e03).zpopaque }, + { unpack(0x00009106, 0x30017009, 0x00001e03).lsopaque }, + { unpack(0x00009106, 0x30017009, 0x00001e03).cidtest }, + { unpack(0x00009106, 0x30017009, 0x00001e03).shade }, + { unpack(0x00009106, 0x30017009, 0x00001e03).ciclamp }, + { unpack(0x00009106, 0x30017009, 0x00001e03).stoponx }, + { unpack(0x00009106, 0x30017009, 0x00001e03).stopony }, + { unpack(0x00009106, 0x30017009, 0x00001e03).skipfirst }, + { unpack(0x00009106, 0x30017009, 0x00001e03).skiplast }, + { unpack(0x00009106, 0x30017009, 0x00001e03).lsadvlast }, + { unpack(0x00009106, 0x30017009, 0x00001e03).length32 }, + { unpack(0x00009106, 0x30017009, 0x00001e03).lronly }, + { unpack(0x00009106, 0x30017009, 0x00001e03).ystride }, + { unpack(0x00009106, 0x30017009, 0x00001e03).endptfilter }, + { unpack(0x00009106, 0x30017009, 0x00001e03).adrmode }, + { unpack(0x00009106, 0x30017009, 0x00001e03).xyoffset }, + { unpack(0x00009106, 0x30017009, 0x00001e03).yflip }, + { unpack(0x00009106, 0x30017009, 0x00001e03).ensmask }, + { unpack(0x00009106, 0x30017009, 0x00001e03).cid_mask }, + { unpack(0x00009106, 0x30017009, 0x00001e03).sfactor }, + { unpack(0x00009106, 0x30017009, 0x00001e03).dfactor }, + { unpack(0x00009106, 0x30017009, 0x00001e03).rwpacked }, + { unpack(0x00009106, 0x30017009, 0x00001e03).hostdepth }, + { unpack(0x00009106, 0x30017009, 0x00001e03).rwdouble }, + { unpack(0x00009106, 0x30017009, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00009106_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00009106, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3009f019 cm=0x00001e03 +unsafe extern "C" fn shader_00009106_3009f019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3009f019, 0x00001e03).opcode }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).planes }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).drawdepth }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).dblsrc }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).rgbmode }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).dither }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).logicop }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).compare }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).blend }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).backblend }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).blendalpha }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).fastclear }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).colorhost }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).alphahost }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).enzpattern }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).enlspattern }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).zpopaque }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).lsopaque }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).cidtest }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).shade }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).ciclamp }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).stoponx }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).stopony }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).skipfirst }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).skiplast }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).lsadvlast }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).length32 }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).lronly }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).ystride }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).endptfilter }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).adrmode }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).xyoffset }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).yflip }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).ensmask }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).cid_mask }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).sfactor }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).dfactor }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).rwpacked }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).hostdepth }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).rwdouble }, + { unpack(0x00009106, 0x3009f019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00009106_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00009106, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_00009106_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).planes }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).dither }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).compare }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).blend }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).shade }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x00009106, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_00009106_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).planes }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).dither }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).compare }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).blend }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).shade }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x00009106, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_00009106_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).planes }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).dither }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).compare }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).blend }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).shade }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x00009106, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00009106 dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_00009106_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00009106, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).planes }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).dither }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).compare }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).blend }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).shade }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x00009106, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00019106 dm1=0x30007109 cm=0x00001e00 +unsafe extern "C" fn shader_00019106_30007109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00019106, 0x30007109, 0x00001e00).opcode }, + { unpack(0x00019106, 0x30007109, 0x00001e00).planes }, + { unpack(0x00019106, 0x30007109, 0x00001e00).drawdepth }, + { unpack(0x00019106, 0x30007109, 0x00001e00).dblsrc }, + { unpack(0x00019106, 0x30007109, 0x00001e00).rgbmode }, + { unpack(0x00019106, 0x30007109, 0x00001e00).dither }, + { unpack(0x00019106, 0x30007109, 0x00001e00).logicop }, + { unpack(0x00019106, 0x30007109, 0x00001e00).compare }, + { unpack(0x00019106, 0x30007109, 0x00001e00).blend }, + { unpack(0x00019106, 0x30007109, 0x00001e00).backblend }, + { unpack(0x00019106, 0x30007109, 0x00001e00).blendalpha }, + { unpack(0x00019106, 0x30007109, 0x00001e00).fastclear }, + { unpack(0x00019106, 0x30007109, 0x00001e00).colorhost }, + { unpack(0x00019106, 0x30007109, 0x00001e00).alphahost }, + { unpack(0x00019106, 0x30007109, 0x00001e00).enzpattern }, + { unpack(0x00019106, 0x30007109, 0x00001e00).enlspattern }, + { unpack(0x00019106, 0x30007109, 0x00001e00).zpopaque }, + { unpack(0x00019106, 0x30007109, 0x00001e00).lsopaque }, + { unpack(0x00019106, 0x30007109, 0x00001e00).cidtest }, + { unpack(0x00019106, 0x30007109, 0x00001e00).shade }, + { unpack(0x00019106, 0x30007109, 0x00001e00).ciclamp }, + { unpack(0x00019106, 0x30007109, 0x00001e00).stoponx }, + { unpack(0x00019106, 0x30007109, 0x00001e00).stopony }, + { unpack(0x00019106, 0x30007109, 0x00001e00).skipfirst }, + { unpack(0x00019106, 0x30007109, 0x00001e00).skiplast }, + { unpack(0x00019106, 0x30007109, 0x00001e00).lsadvlast }, + { unpack(0x00019106, 0x30007109, 0x00001e00).length32 }, + { unpack(0x00019106, 0x30007109, 0x00001e00).lronly }, + { unpack(0x00019106, 0x30007109, 0x00001e00).ystride }, + { unpack(0x00019106, 0x30007109, 0x00001e00).endptfilter }, + { unpack(0x00019106, 0x30007109, 0x00001e00).adrmode }, + { unpack(0x00019106, 0x30007109, 0x00001e00).xyoffset }, + { unpack(0x00019106, 0x30007109, 0x00001e00).yflip }, + { unpack(0x00019106, 0x30007109, 0x00001e00).ensmask }, + { unpack(0x00019106, 0x30007109, 0x00001e00).cid_mask }, + { unpack(0x00019106, 0x30007109, 0x00001e00).sfactor }, + { unpack(0x00019106, 0x30007109, 0x00001e00).dfactor }, + { unpack(0x00019106, 0x30007109, 0x00001e00).rwpacked }, + { unpack(0x00019106, 0x30007109, 0x00001e00).hostdepth }, + { unpack(0x00019106, 0x30007109, 0x00001e00).rwdouble }, + { unpack(0x00019106, 0x30007109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00019106 dm1=0x3000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00019106_3000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00019106, 0x3000f319, 0x00001e00).opcode }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).planes }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).drawdepth }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).dblsrc }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).rgbmode }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).dither }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).logicop }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).compare }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).blend }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).backblend }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).blendalpha }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).fastclear }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).colorhost }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).alphahost }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).enzpattern }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).enlspattern }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).zpopaque }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).lsopaque }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).cidtest }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).shade }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).ciclamp }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).stoponx }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).stopony }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).skipfirst }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).skiplast }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).lsadvlast }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).length32 }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).lronly }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).ystride }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).endptfilter }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).adrmode }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).xyoffset }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).yflip }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).ensmask }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).cid_mask }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).sfactor }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).dfactor }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).rwpacked }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).hostdepth }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).rwdouble }, + { unpack(0x00019106, 0x3000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00022102 dm1=0x30007109 cm=0x00001e00 +unsafe extern "C" fn shader_00022102_30007109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00022102, 0x30007109, 0x00001e00).opcode }, + { unpack(0x00022102, 0x30007109, 0x00001e00).planes }, + { unpack(0x00022102, 0x30007109, 0x00001e00).drawdepth }, + { unpack(0x00022102, 0x30007109, 0x00001e00).dblsrc }, + { unpack(0x00022102, 0x30007109, 0x00001e00).rgbmode }, + { unpack(0x00022102, 0x30007109, 0x00001e00).dither }, + { unpack(0x00022102, 0x30007109, 0x00001e00).logicop }, + { unpack(0x00022102, 0x30007109, 0x00001e00).compare }, + { unpack(0x00022102, 0x30007109, 0x00001e00).blend }, + { unpack(0x00022102, 0x30007109, 0x00001e00).backblend }, + { unpack(0x00022102, 0x30007109, 0x00001e00).blendalpha }, + { unpack(0x00022102, 0x30007109, 0x00001e00).fastclear }, + { unpack(0x00022102, 0x30007109, 0x00001e00).colorhost }, + { unpack(0x00022102, 0x30007109, 0x00001e00).alphahost }, + { unpack(0x00022102, 0x30007109, 0x00001e00).enzpattern }, + { unpack(0x00022102, 0x30007109, 0x00001e00).enlspattern }, + { unpack(0x00022102, 0x30007109, 0x00001e00).zpopaque }, + { unpack(0x00022102, 0x30007109, 0x00001e00).lsopaque }, + { unpack(0x00022102, 0x30007109, 0x00001e00).cidtest }, + { unpack(0x00022102, 0x30007109, 0x00001e00).shade }, + { unpack(0x00022102, 0x30007109, 0x00001e00).ciclamp }, + { unpack(0x00022102, 0x30007109, 0x00001e00).stoponx }, + { unpack(0x00022102, 0x30007109, 0x00001e00).stopony }, + { unpack(0x00022102, 0x30007109, 0x00001e00).skipfirst }, + { unpack(0x00022102, 0x30007109, 0x00001e00).skiplast }, + { unpack(0x00022102, 0x30007109, 0x00001e00).lsadvlast }, + { unpack(0x00022102, 0x30007109, 0x00001e00).length32 }, + { unpack(0x00022102, 0x30007109, 0x00001e00).lronly }, + { unpack(0x00022102, 0x30007109, 0x00001e00).ystride }, + { unpack(0x00022102, 0x30007109, 0x00001e00).endptfilter }, + { unpack(0x00022102, 0x30007109, 0x00001e00).adrmode }, + { unpack(0x00022102, 0x30007109, 0x00001e00).xyoffset }, + { unpack(0x00022102, 0x30007109, 0x00001e00).yflip }, + { unpack(0x00022102, 0x30007109, 0x00001e00).ensmask }, + { unpack(0x00022102, 0x30007109, 0x00001e00).cid_mask }, + { unpack(0x00022102, 0x30007109, 0x00001e00).sfactor }, + { unpack(0x00022102, 0x30007109, 0x00001e00).dfactor }, + { unpack(0x00022102, 0x30007109, 0x00001e00).rwpacked }, + { unpack(0x00022102, 0x30007109, 0x00001e00).hostdepth }, + { unpack(0x00022102, 0x30007109, 0x00001e00).rwdouble }, + { unpack(0x00022102, 0x30007109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00022102 dm1=0x3000710d cm=0x00001e00 +unsafe extern "C" fn shader_00022102_3000710d_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00022102, 0x3000710d, 0x00001e00).opcode }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).planes }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).drawdepth }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).dblsrc }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).rgbmode }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).dither }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).logicop }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).compare }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).blend }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).backblend }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).blendalpha }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).fastclear }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).colorhost }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).alphahost }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).enzpattern }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).enlspattern }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).zpopaque }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).lsopaque }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).cidtest }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).shade }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).ciclamp }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).stoponx }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).stopony }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).skipfirst }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).skiplast }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).lsadvlast }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).length32 }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).lronly }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).ystride }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).endptfilter }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).adrmode }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).xyoffset }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).yflip }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).ensmask }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).cid_mask }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).sfactor }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).dfactor }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).rwpacked }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).hostdepth }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).rwdouble }, + { unpack(0x00022102, 0x3000710d, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00022102 dm1=0x3000f109 cm=0x00001e00 +unsafe extern "C" fn shader_00022102_3000f109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00022102, 0x3000f109, 0x00001e00).opcode }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).planes }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).drawdepth }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).dblsrc }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).rgbmode }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).dither }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).logicop }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).compare }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).blend }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).backblend }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).blendalpha }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).fastclear }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).colorhost }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).alphahost }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).enzpattern }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).enlspattern }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).zpopaque }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).lsopaque }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).cidtest }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).shade }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).ciclamp }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).stoponx }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).stopony }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).skipfirst }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).skiplast }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).lsadvlast }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).length32 }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).lronly }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).ystride }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).endptfilter }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).adrmode }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).xyoffset }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).yflip }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).ensmask }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).cid_mask }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).sfactor }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).dfactor }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).rwpacked }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).hostdepth }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).rwdouble }, + { unpack(0x00022102, 0x3000f109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00022102 dm1=0x3000f211 cm=0x00001e00 +unsafe extern "C" fn shader_00022102_3000f211_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00022102, 0x3000f211, 0x00001e00).opcode }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).planes }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).drawdepth }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).dblsrc }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).rgbmode }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).dither }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).logicop }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).compare }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).blend }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).backblend }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).blendalpha }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).fastclear }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).colorhost }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).alphahost }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).enzpattern }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).enlspattern }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).zpopaque }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).lsopaque }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).cidtest }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).shade }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).ciclamp }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).stoponx }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).stopony }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).skipfirst }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).skiplast }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).lsadvlast }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).length32 }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).lronly }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).ystride }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).endptfilter }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).adrmode }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).xyoffset }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).yflip }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).ensmask }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).cid_mask }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).sfactor }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).dfactor }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).rwpacked }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).hostdepth }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).rwdouble }, + { unpack(0x00022102, 0x3000f211, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00022102 dm1=0x3000f231 cm=0x00001e00 +unsafe extern "C" fn shader_00022102_3000f231_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00022102, 0x3000f231, 0x00001e00).opcode }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).planes }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).drawdepth }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).dblsrc }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).rgbmode }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).dither }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).logicop }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).compare }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).blend }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).backblend }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).blendalpha }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).fastclear }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).colorhost }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).alphahost }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).enzpattern }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).enlspattern }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).zpopaque }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).lsopaque }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).cidtest }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).shade }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).ciclamp }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).stoponx }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).stopony }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).skipfirst }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).skiplast }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).lsadvlast }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).length32 }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).lronly }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).ystride }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).endptfilter }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).adrmode }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).xyoffset }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).yflip }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).ensmask }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).cid_mask }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).sfactor }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).dfactor }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).rwpacked }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).hostdepth }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).rwdouble }, + { unpack(0x00022102, 0x3000f231, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00022102 dm1=0x3000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00022102_3000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00022102, 0x3000f319, 0x00001e00).opcode }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).planes }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).drawdepth }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).dblsrc }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).rgbmode }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).dither }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).logicop }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).compare }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).blend }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).backblend }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).blendalpha }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).fastclear }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).colorhost }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).alphahost }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).enzpattern }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).enlspattern }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).zpopaque }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).lsopaque }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).cidtest }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).shade }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).ciclamp }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).stoponx }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).stopony }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).skipfirst }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).skiplast }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).lsadvlast }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).length32 }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).lronly }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).ystride }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).endptfilter }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).adrmode }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).xyoffset }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).yflip }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).ensmask }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).cid_mask }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).sfactor }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).dfactor }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).rwpacked }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).hostdepth }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).rwdouble }, + { unpack(0x00022102, 0x3000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00022106 dm1=0x30007109 cm=0x00001e00 +unsafe extern "C" fn shader_00022106_30007109_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00022106, 0x30007109, 0x00001e00).opcode }, + { unpack(0x00022106, 0x30007109, 0x00001e00).planes }, + { unpack(0x00022106, 0x30007109, 0x00001e00).drawdepth }, + { unpack(0x00022106, 0x30007109, 0x00001e00).dblsrc }, + { unpack(0x00022106, 0x30007109, 0x00001e00).rgbmode }, + { unpack(0x00022106, 0x30007109, 0x00001e00).dither }, + { unpack(0x00022106, 0x30007109, 0x00001e00).logicop }, + { unpack(0x00022106, 0x30007109, 0x00001e00).compare }, + { unpack(0x00022106, 0x30007109, 0x00001e00).blend }, + { unpack(0x00022106, 0x30007109, 0x00001e00).backblend }, + { unpack(0x00022106, 0x30007109, 0x00001e00).blendalpha }, + { unpack(0x00022106, 0x30007109, 0x00001e00).fastclear }, + { unpack(0x00022106, 0x30007109, 0x00001e00).colorhost }, + { unpack(0x00022106, 0x30007109, 0x00001e00).alphahost }, + { unpack(0x00022106, 0x30007109, 0x00001e00).enzpattern }, + { unpack(0x00022106, 0x30007109, 0x00001e00).enlspattern }, + { unpack(0x00022106, 0x30007109, 0x00001e00).zpopaque }, + { unpack(0x00022106, 0x30007109, 0x00001e00).lsopaque }, + { unpack(0x00022106, 0x30007109, 0x00001e00).cidtest }, + { unpack(0x00022106, 0x30007109, 0x00001e00).shade }, + { unpack(0x00022106, 0x30007109, 0x00001e00).ciclamp }, + { unpack(0x00022106, 0x30007109, 0x00001e00).stoponx }, + { unpack(0x00022106, 0x30007109, 0x00001e00).stopony }, + { unpack(0x00022106, 0x30007109, 0x00001e00).skipfirst }, + { unpack(0x00022106, 0x30007109, 0x00001e00).skiplast }, + { unpack(0x00022106, 0x30007109, 0x00001e00).lsadvlast }, + { unpack(0x00022106, 0x30007109, 0x00001e00).length32 }, + { unpack(0x00022106, 0x30007109, 0x00001e00).lronly }, + { unpack(0x00022106, 0x30007109, 0x00001e00).ystride }, + { unpack(0x00022106, 0x30007109, 0x00001e00).endptfilter }, + { unpack(0x00022106, 0x30007109, 0x00001e00).adrmode }, + { unpack(0x00022106, 0x30007109, 0x00001e00).xyoffset }, + { unpack(0x00022106, 0x30007109, 0x00001e00).yflip }, + { unpack(0x00022106, 0x30007109, 0x00001e00).ensmask }, + { unpack(0x00022106, 0x30007109, 0x00001e00).cid_mask }, + { unpack(0x00022106, 0x30007109, 0x00001e00).sfactor }, + { unpack(0x00022106, 0x30007109, 0x00001e00).dfactor }, + { unpack(0x00022106, 0x30007109, 0x00001e00).rwpacked }, + { unpack(0x00022106, 0x30007109, 0x00001e00).hostdepth }, + { unpack(0x00022106, 0x30007109, 0x00001e00).rwdouble }, + { unpack(0x00022106, 0x30007109, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00022106 dm1=0x3000f319 cm=0x00001e00 +unsafe extern "C" fn shader_00022106_3000f319_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00022106, 0x3000f319, 0x00001e00).opcode }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).planes }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).drawdepth }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).dblsrc }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).rgbmode }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).dither }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).logicop }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).compare }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).blend }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).backblend }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).blendalpha }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).fastclear }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).colorhost }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).alphahost }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).enzpattern }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).enlspattern }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).zpopaque }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).lsopaque }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).cidtest }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).shade }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).ciclamp }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).stoponx }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).stopony }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).skipfirst }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).skiplast }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).lsadvlast }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).length32 }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).lronly }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).ystride }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).endptfilter }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).adrmode }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).xyoffset }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).yflip }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).ensmask }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).cid_mask }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).sfactor }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).dfactor }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).rwpacked }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).hostdepth }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).rwdouble }, + { unpack(0x00022106, 0x3000f319, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040022 dm1=0x3009d011 cm=0x00001e03 +unsafe extern "C" fn shader_00040022_3009d011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040022, 0x3009d011, 0x00001e03).opcode }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).planes }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).drawdepth }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).dblsrc }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).rgbmode }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).dither }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).logicop }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).compare }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).blend }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).backblend }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).blendalpha }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).fastclear }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).colorhost }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).alphahost }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).enzpattern }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).enlspattern }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).zpopaque }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).lsopaque }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).cidtest }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).shade }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).ciclamp }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).stoponx }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).stopony }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).skipfirst }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).skiplast }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).lsadvlast }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).length32 }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).lronly }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).ystride }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).endptfilter }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).adrmode }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).xyoffset }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).yflip }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).ensmask }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).cid_mask }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).sfactor }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).dfactor }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).rwpacked }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).hostdepth }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).rwdouble }, + { unpack(0x00040022, 0x3009d011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040022 dm1=0x3009d031 cm=0x00001e03 +unsafe extern "C" fn shader_00040022_3009d031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040022, 0x3009d031, 0x00001e03).opcode }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).planes }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).drawdepth }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).dblsrc }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).rgbmode }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).dither }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).logicop }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).compare }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).blend }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).backblend }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).blendalpha }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).fastclear }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).colorhost }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).alphahost }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).enzpattern }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).enlspattern }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).zpopaque }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).lsopaque }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).cidtest }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).shade }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).ciclamp }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).stoponx }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).stopony }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).skipfirst }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).skiplast }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).lsadvlast }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).length32 }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).lronly }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).ystride }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).endptfilter }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).adrmode }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).xyoffset }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).yflip }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).ensmask }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).cid_mask }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).sfactor }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).dfactor }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).rwpacked }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).hostdepth }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).rwdouble }, + { unpack(0x00040022, 0x3009d031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040022 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00040022_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040022, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00040022, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040022 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00040022_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040022, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00040022, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040022 dm1=0x3165d011 cm=0x00001e03 +unsafe extern "C" fn shader_00040022_3165d011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040022, 0x3165d011, 0x00001e03).opcode }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).planes }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).drawdepth }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).dblsrc }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).rgbmode }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).dither }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).logicop }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).compare }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).blend }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).backblend }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).blendalpha }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).fastclear }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).colorhost }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).alphahost }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).enzpattern }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).enlspattern }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).zpopaque }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).lsopaque }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).cidtest }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).shade }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).ciclamp }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).stoponx }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).stopony }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).skipfirst }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).skiplast }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).lsadvlast }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).length32 }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).lronly }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).ystride }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).endptfilter }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).adrmode }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).xyoffset }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).yflip }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).ensmask }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).cid_mask }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).sfactor }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).dfactor }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).rwpacked }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).hostdepth }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).rwdouble }, + { unpack(0x00040022, 0x3165d011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040022 dm1=0x3165d031 cm=0x00001e03 +unsafe extern "C" fn shader_00040022_3165d031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040022, 0x3165d031, 0x00001e03).opcode }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).planes }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).drawdepth }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).dblsrc }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).rgbmode }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).dither }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).logicop }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).compare }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).blend }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).backblend }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).blendalpha }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).fastclear }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).colorhost }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).alphahost }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).enzpattern }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).enlspattern }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).zpopaque }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).lsopaque }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).cidtest }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).shade }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).ciclamp }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).stoponx }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).stopony }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).skipfirst }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).skiplast }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).lsadvlast }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).length32 }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).lronly }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).ystride }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).endptfilter }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).adrmode }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).xyoffset }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).yflip }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).ensmask }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).cid_mask }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).sfactor }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).dfactor }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).rwpacked }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).hostdepth }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).rwdouble }, + { unpack(0x00040022, 0x3165d031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040102 dm1=0x3000f019 cm=0x00001e00 +unsafe extern "C" fn shader_00040102_3000f019_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040102, 0x3000f019, 0x00001e00).opcode }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).planes }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).drawdepth }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).dblsrc }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).rgbmode }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).dither }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).logicop }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).compare }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).blend }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).backblend }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).blendalpha }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).fastclear }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).colorhost }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).alphahost }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).enzpattern }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).enlspattern }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).zpopaque }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).lsopaque }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).cidtest }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).shade }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).ciclamp }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).stoponx }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).stopony }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).skipfirst }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).skiplast }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).lsadvlast }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).length32 }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).lronly }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).ystride }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).endptfilter }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).adrmode }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).xyoffset }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).yflip }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).ensmask }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).cid_mask }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).sfactor }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).dfactor }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).rwpacked }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).hostdepth }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).rwdouble }, + { unpack(0x00040102, 0x3000f019, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040122 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00040122_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040122, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00040122, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040122 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_00040122_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040122, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).planes }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).dither }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).compare }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).blend }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).shade }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x00040122, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040122 dm1=0x3165f011 cm=0x00001e0f +unsafe extern "C" fn shader_00040122_3165f011_00001e0f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040122, 0x3165f011, 0x00001e0f).opcode }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).planes }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).drawdepth }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).dblsrc }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).rgbmode }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).dither }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).logicop }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).compare }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).blend }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).backblend }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).blendalpha }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).fastclear }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).colorhost }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).alphahost }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).enzpattern }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).enlspattern }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).zpopaque }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).lsopaque }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).cidtest }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).shade }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).ciclamp }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).stoponx }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).stopony }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).skipfirst }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).skiplast }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).lsadvlast }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).length32 }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).lronly }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).ystride }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).endptfilter }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).adrmode }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).xyoffset }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).yflip }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).ensmask }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).cid_mask }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).sfactor }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).dfactor }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).rwpacked }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).hostdepth }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).rwdouble }, + { unpack(0x00040122, 0x3165f011, 0x00001e0f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040122 dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_00040122_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040122, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).planes }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).dither }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).compare }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).blend }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).shade }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x00040122, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00040122 dm1=0x3165f031 cm=0x00001e0f +unsafe extern "C" fn shader_00040122_3165f031_00001e0f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00040122, 0x3165f031, 0x00001e0f).opcode }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).planes }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).drawdepth }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).dblsrc }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).rgbmode }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).dither }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).logicop }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).compare }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).blend }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).backblend }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).blendalpha }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).fastclear }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).colorhost }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).alphahost }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).enzpattern }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).enlspattern }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).zpopaque }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).lsopaque }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).cidtest }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).shade }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).ciclamp }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).stoponx }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).stopony }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).skipfirst }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).skiplast }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).lsadvlast }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).length32 }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).lronly }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).ystride }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).endptfilter }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).adrmode }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).xyoffset }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).yflip }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).ensmask }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).cid_mask }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).sfactor }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).dfactor }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).rwpacked }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).hostdepth }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).rwdouble }, + { unpack(0x00040122, 0x3165f031, 0x00001e0f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004212e dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_0004212e_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004212e, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).planes }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).dither }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).compare }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).blend }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).shade }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x0004212e, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004212e dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_0004212e_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004212e, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).planes }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).dither }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).compare }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).blend }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).shade }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x0004212e, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004222e dm1=0x30097011 cm=0x00001e03 +unsafe extern "C" fn shader_0004222e_30097011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004222e, 0x30097011, 0x00001e03).opcode }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).planes }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).drawdepth }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).dblsrc }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).rgbmode }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).dither }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).logicop }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).compare }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).blend }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).backblend }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).blendalpha }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).fastclear }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).colorhost }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).alphahost }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).enzpattern }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).enlspattern }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).zpopaque }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).lsopaque }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).cidtest }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).shade }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).ciclamp }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).stoponx }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).stopony }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).skipfirst }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).skiplast }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).lsadvlast }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).length32 }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).lronly }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).ystride }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).endptfilter }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).adrmode }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).xyoffset }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).yflip }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).ensmask }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).cid_mask }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).sfactor }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).dfactor }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).rwpacked }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).hostdepth }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).rwdouble }, + { unpack(0x0004222e, 0x30097011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004222e dm1=0x30097031 cm=0x00001e03 +unsafe extern "C" fn shader_0004222e_30097031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004222e, 0x30097031, 0x00001e03).opcode }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).planes }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).drawdepth }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).dblsrc }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).rgbmode }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).dither }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).logicop }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).compare }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).blend }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).backblend }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).blendalpha }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).fastclear }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).colorhost }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).alphahost }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).enzpattern }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).enlspattern }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).zpopaque }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).lsopaque }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).cidtest }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).shade }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).ciclamp }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).stoponx }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).stopony }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).skipfirst }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).skiplast }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).lsadvlast }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).length32 }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).lronly }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).ystride }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).endptfilter }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).adrmode }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).xyoffset }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).yflip }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).ensmask }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).cid_mask }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).sfactor }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).dfactor }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).rwpacked }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).hostdepth }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).rwdouble }, + { unpack(0x0004222e, 0x30097031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004222e dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_0004222e_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004222e, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).planes }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).dither }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).compare }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).blend }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).shade }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x0004222e, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004222e dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_0004222e_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004222e, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).planes }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).dither }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).compare }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).blend }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).shade }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x0004222e, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x3009700c cm=0x00001e03 +unsafe extern "C" fn shader_0004232e_3009700c_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x3009700c, 0x00001e03).opcode }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).planes }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).drawdepth }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).dblsrc }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).rgbmode }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).dither }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).logicop }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).compare }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).blend }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).backblend }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).blendalpha }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).fastclear }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).colorhost }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).alphahost }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).enzpattern }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).enlspattern }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).zpopaque }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).lsopaque }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).cidtest }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).shade }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).ciclamp }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).stoponx }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).stopony }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).skipfirst }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).skiplast }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).lsadvlast }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).length32 }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).lronly }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).ystride }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).endptfilter }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).adrmode }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).xyoffset }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).yflip }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).ensmask }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).cid_mask }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).sfactor }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).dfactor }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).rwpacked }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).hostdepth }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).rwdouble }, + { unpack(0x0004232e, 0x3009700c, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x3009700d cm=0x00001e03 +unsafe extern "C" fn shader_0004232e_3009700d_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x3009700d, 0x00001e03).opcode }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).planes }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).drawdepth }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).dblsrc }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).rgbmode }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).dither }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).logicop }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).compare }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).blend }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).backblend }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).blendalpha }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).fastclear }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).colorhost }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).alphahost }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).enzpattern }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).enlspattern }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).zpopaque }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).lsopaque }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).cidtest }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).shade }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).ciclamp }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).stoponx }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).stopony }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).skipfirst }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).skiplast }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).lsadvlast }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).length32 }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).lronly }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).ystride }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).endptfilter }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).adrmode }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).xyoffset }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).yflip }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).ensmask }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).cid_mask }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).sfactor }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).dfactor }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).rwpacked }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).hostdepth }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).rwdouble }, + { unpack(0x0004232e, 0x3009700d, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x30097011 cm=0x00000403 +unsafe extern "C" fn shader_0004232e_30097011_00000403( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x30097011, 0x00000403).opcode }, + { unpack(0x0004232e, 0x30097011, 0x00000403).planes }, + { unpack(0x0004232e, 0x30097011, 0x00000403).drawdepth }, + { unpack(0x0004232e, 0x30097011, 0x00000403).dblsrc }, + { unpack(0x0004232e, 0x30097011, 0x00000403).rgbmode }, + { unpack(0x0004232e, 0x30097011, 0x00000403).dither }, + { unpack(0x0004232e, 0x30097011, 0x00000403).logicop }, + { unpack(0x0004232e, 0x30097011, 0x00000403).compare }, + { unpack(0x0004232e, 0x30097011, 0x00000403).blend }, + { unpack(0x0004232e, 0x30097011, 0x00000403).backblend }, + { unpack(0x0004232e, 0x30097011, 0x00000403).blendalpha }, + { unpack(0x0004232e, 0x30097011, 0x00000403).fastclear }, + { unpack(0x0004232e, 0x30097011, 0x00000403).colorhost }, + { unpack(0x0004232e, 0x30097011, 0x00000403).alphahost }, + { unpack(0x0004232e, 0x30097011, 0x00000403).enzpattern }, + { unpack(0x0004232e, 0x30097011, 0x00000403).enlspattern }, + { unpack(0x0004232e, 0x30097011, 0x00000403).zpopaque }, + { unpack(0x0004232e, 0x30097011, 0x00000403).lsopaque }, + { unpack(0x0004232e, 0x30097011, 0x00000403).cidtest }, + { unpack(0x0004232e, 0x30097011, 0x00000403).shade }, + { unpack(0x0004232e, 0x30097011, 0x00000403).ciclamp }, + { unpack(0x0004232e, 0x30097011, 0x00000403).stoponx }, + { unpack(0x0004232e, 0x30097011, 0x00000403).stopony }, + { unpack(0x0004232e, 0x30097011, 0x00000403).skipfirst }, + { unpack(0x0004232e, 0x30097011, 0x00000403).skiplast }, + { unpack(0x0004232e, 0x30097011, 0x00000403).lsadvlast }, + { unpack(0x0004232e, 0x30097011, 0x00000403).length32 }, + { unpack(0x0004232e, 0x30097011, 0x00000403).lronly }, + { unpack(0x0004232e, 0x30097011, 0x00000403).ystride }, + { unpack(0x0004232e, 0x30097011, 0x00000403).endptfilter }, + { unpack(0x0004232e, 0x30097011, 0x00000403).adrmode }, + { unpack(0x0004232e, 0x30097011, 0x00000403).xyoffset }, + { unpack(0x0004232e, 0x30097011, 0x00000403).yflip }, + { unpack(0x0004232e, 0x30097011, 0x00000403).ensmask }, + { unpack(0x0004232e, 0x30097011, 0x00000403).cid_mask }, + { unpack(0x0004232e, 0x30097011, 0x00000403).sfactor }, + { unpack(0x0004232e, 0x30097011, 0x00000403).dfactor }, + { unpack(0x0004232e, 0x30097011, 0x00000403).rwpacked }, + { unpack(0x0004232e, 0x30097011, 0x00000403).hostdepth }, + { unpack(0x0004232e, 0x30097011, 0x00000403).rwdouble }, + { unpack(0x0004232e, 0x30097011, 0x00000403).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x30097011 cm=0x00001e03 +unsafe extern "C" fn shader_0004232e_30097011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x30097011, 0x00001e03).opcode }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).planes }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).drawdepth }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).dblsrc }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).rgbmode }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).dither }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).logicop }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).compare }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).blend }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).backblend }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).blendalpha }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).fastclear }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).colorhost }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).alphahost }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).enzpattern }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).enlspattern }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).zpopaque }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).lsopaque }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).cidtest }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).shade }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).ciclamp }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).stoponx }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).stopony }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).skipfirst }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).skiplast }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).lsadvlast }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).length32 }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).lronly }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).ystride }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).endptfilter }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).adrmode }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).xyoffset }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).yflip }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).ensmask }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).cid_mask }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).sfactor }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).dfactor }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).rwpacked }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).hostdepth }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).rwdouble }, + { unpack(0x0004232e, 0x30097011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x30097031 cm=0x00000403 +unsafe extern "C" fn shader_0004232e_30097031_00000403( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x30097031, 0x00000403).opcode }, + { unpack(0x0004232e, 0x30097031, 0x00000403).planes }, + { unpack(0x0004232e, 0x30097031, 0x00000403).drawdepth }, + { unpack(0x0004232e, 0x30097031, 0x00000403).dblsrc }, + { unpack(0x0004232e, 0x30097031, 0x00000403).rgbmode }, + { unpack(0x0004232e, 0x30097031, 0x00000403).dither }, + { unpack(0x0004232e, 0x30097031, 0x00000403).logicop }, + { unpack(0x0004232e, 0x30097031, 0x00000403).compare }, + { unpack(0x0004232e, 0x30097031, 0x00000403).blend }, + { unpack(0x0004232e, 0x30097031, 0x00000403).backblend }, + { unpack(0x0004232e, 0x30097031, 0x00000403).blendalpha }, + { unpack(0x0004232e, 0x30097031, 0x00000403).fastclear }, + { unpack(0x0004232e, 0x30097031, 0x00000403).colorhost }, + { unpack(0x0004232e, 0x30097031, 0x00000403).alphahost }, + { unpack(0x0004232e, 0x30097031, 0x00000403).enzpattern }, + { unpack(0x0004232e, 0x30097031, 0x00000403).enlspattern }, + { unpack(0x0004232e, 0x30097031, 0x00000403).zpopaque }, + { unpack(0x0004232e, 0x30097031, 0x00000403).lsopaque }, + { unpack(0x0004232e, 0x30097031, 0x00000403).cidtest }, + { unpack(0x0004232e, 0x30097031, 0x00000403).shade }, + { unpack(0x0004232e, 0x30097031, 0x00000403).ciclamp }, + { unpack(0x0004232e, 0x30097031, 0x00000403).stoponx }, + { unpack(0x0004232e, 0x30097031, 0x00000403).stopony }, + { unpack(0x0004232e, 0x30097031, 0x00000403).skipfirst }, + { unpack(0x0004232e, 0x30097031, 0x00000403).skiplast }, + { unpack(0x0004232e, 0x30097031, 0x00000403).lsadvlast }, + { unpack(0x0004232e, 0x30097031, 0x00000403).length32 }, + { unpack(0x0004232e, 0x30097031, 0x00000403).lronly }, + { unpack(0x0004232e, 0x30097031, 0x00000403).ystride }, + { unpack(0x0004232e, 0x30097031, 0x00000403).endptfilter }, + { unpack(0x0004232e, 0x30097031, 0x00000403).adrmode }, + { unpack(0x0004232e, 0x30097031, 0x00000403).xyoffset }, + { unpack(0x0004232e, 0x30097031, 0x00000403).yflip }, + { unpack(0x0004232e, 0x30097031, 0x00000403).ensmask }, + { unpack(0x0004232e, 0x30097031, 0x00000403).cid_mask }, + { unpack(0x0004232e, 0x30097031, 0x00000403).sfactor }, + { unpack(0x0004232e, 0x30097031, 0x00000403).dfactor }, + { unpack(0x0004232e, 0x30097031, 0x00000403).rwpacked }, + { unpack(0x0004232e, 0x30097031, 0x00000403).hostdepth }, + { unpack(0x0004232e, 0x30097031, 0x00000403).rwdouble }, + { unpack(0x0004232e, 0x30097031, 0x00000403).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x30097031 cm=0x00001e03 +unsafe extern "C" fn shader_0004232e_30097031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x30097031, 0x00001e03).opcode }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).planes }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).drawdepth }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).dblsrc }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).rgbmode }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).dither }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).logicop }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).compare }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).blend }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).backblend }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).blendalpha }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).fastclear }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).colorhost }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).alphahost }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).enzpattern }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).enlspattern }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).zpopaque }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).lsopaque }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).cidtest }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).shade }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).ciclamp }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).stoponx }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).stopony }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).skipfirst }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).skiplast }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).lsadvlast }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).length32 }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).lronly }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).ystride }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).endptfilter }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).adrmode }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).xyoffset }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).yflip }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).ensmask }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).cid_mask }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).sfactor }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).dfactor }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).rwpacked }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).hostdepth }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).rwdouble }, + { unpack(0x0004232e, 0x30097031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_0004232e_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).planes }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).dither }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).compare }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).blend }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).shade }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x0004232e, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x3009f019 cm=0x00001e03 +unsafe extern "C" fn shader_0004232e_3009f019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x3009f019, 0x00001e03).opcode }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).planes }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).drawdepth }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).dblsrc }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).rgbmode }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).dither }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).logicop }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).compare }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).blend }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).backblend }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).blendalpha }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).fastclear }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).colorhost }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).alphahost }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).enzpattern }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).enlspattern }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).zpopaque }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).lsopaque }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).cidtest }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).shade }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).ciclamp }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).stoponx }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).stopony }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).skipfirst }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).skiplast }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).lsadvlast }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).length32 }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).lronly }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).ystride }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).endptfilter }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).adrmode }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).xyoffset }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).yflip }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).ensmask }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).cid_mask }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).sfactor }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).dfactor }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).rwpacked }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).hostdepth }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).rwdouble }, + { unpack(0x0004232e, 0x3009f019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_0004232e_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).planes }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).dither }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).compare }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).blend }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).shade }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x0004232e, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004232e dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_0004232e_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004232e, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).planes }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).dither }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).compare }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).blend }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).shade }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x0004232e, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00042332 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00042332_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00042332, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00042332, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00042332 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00042332_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00042332, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00042332, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00042332 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_00042332_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00042332, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).planes }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).dither }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).compare }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).blend }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).shade }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x00042332, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00049102 dm1=0x3000f019 cm=0x00001e00 +unsafe extern "C" fn shader_00049102_3000f019_00001e00( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00049102, 0x3000f019, 0x00001e00).opcode }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).planes }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).drawdepth }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).dblsrc }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).rgbmode }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).dither }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).logicop }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).compare }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).blend }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).backblend }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).blendalpha }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).fastclear }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).colorhost }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).alphahost }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).enzpattern }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).enlspattern }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).zpopaque }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).lsopaque }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).cidtest }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).shade }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).ciclamp }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).stoponx }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).stopony }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).skipfirst }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).skiplast }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).lsadvlast }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).length32 }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).lronly }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).ystride }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).endptfilter }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).adrmode }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).xyoffset }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).yflip }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).ensmask }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).cid_mask }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).sfactor }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).dfactor }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).rwpacked }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).hostdepth }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).rwdouble }, + { unpack(0x00049102, 0x3000f019, 0x00001e00).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00049122 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00049122_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00049122, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00049122, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00049122 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00049122_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00049122, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00049122, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00049122 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_00049122_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00049122, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).planes }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).dither }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).compare }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).blend }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).shade }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x00049122, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00049122 dm1=0x3165f011 cm=0x00001e0f +unsafe extern "C" fn shader_00049122_3165f011_00001e0f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00049122, 0x3165f011, 0x00001e0f).opcode }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).planes }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).drawdepth }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).dblsrc }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).rgbmode }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).dither }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).logicop }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).compare }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).blend }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).backblend }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).blendalpha }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).fastclear }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).colorhost }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).alphahost }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).enzpattern }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).enlspattern }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).zpopaque }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).lsopaque }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).cidtest }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).shade }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).ciclamp }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).stoponx }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).stopony }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).skipfirst }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).skiplast }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).lsadvlast }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).length32 }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).lronly }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).ystride }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).endptfilter }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).adrmode }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).xyoffset }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).yflip }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).ensmask }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).cid_mask }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).sfactor }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).dfactor }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).rwpacked }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).hostdepth }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).rwdouble }, + { unpack(0x00049122, 0x3165f011, 0x00001e0f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00049122 dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_00049122_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00049122, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).planes }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).dither }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).compare }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).blend }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).shade }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x00049122, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00049122 dm1=0x3165f031 cm=0x00001e0f +unsafe extern "C" fn shader_00049122_3165f031_00001e0f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00049122, 0x3165f031, 0x00001e0f).opcode }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).planes }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).drawdepth }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).dblsrc }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).rgbmode }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).dither }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).logicop }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).compare }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).blend }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).backblend }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).blendalpha }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).fastclear }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).colorhost }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).alphahost }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).enzpattern }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).enlspattern }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).zpopaque }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).lsopaque }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).cidtest }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).shade }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).ciclamp }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).stoponx }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).stopony }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).skipfirst }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).skiplast }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).lsadvlast }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).length32 }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).lronly }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).ystride }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).endptfilter }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).adrmode }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).xyoffset }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).yflip }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).ensmask }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).cid_mask }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).sfactor }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).dfactor }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).rwpacked }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).hostdepth }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).rwdouble }, + { unpack(0x00049122, 0x3165f031, 0x00001e0f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004930e dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_0004930e_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004930e, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).planes }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).dither }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).compare }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).blend }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).shade }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x0004930e, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004930e dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_0004930e_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004930e, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).planes }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).dither }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).compare }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).blend }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).shade }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x0004930e, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004930e dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_0004930e_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004930e, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).planes }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).dither }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).compare }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).blend }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).shade }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x0004930e, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004930e dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_0004930e_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004930e, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).planes }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).dither }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).compare }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).blend }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).shade }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x0004930e, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004b312 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_0004b312_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004b312, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).planes }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).dither }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).compare }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).blend }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).shade }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x0004b312, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0004b312 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_0004b312_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0004b312, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).planes }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).dither }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).compare }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).blend }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).shade }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x0004b312, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x3008f011 cm=0x00001e03 +unsafe extern "C" fn shader_00080122_3008f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x3008f011, 0x00001e03).opcode }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).planes }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).dither }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).logicop }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).compare }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).blend }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).backblend }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).shade }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).stopony }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).length32 }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).lronly }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).ystride }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).yflip }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x3008f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x3008f031 cm=0x00001e03 +unsafe extern "C" fn shader_00080122_3008f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x3008f031, 0x00001e03).opcode }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).planes }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).dither }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).logicop }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).compare }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).blend }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).backblend }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).shade }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).stopony }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).length32 }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).lronly }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).ystride }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).yflip }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x3008f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x3009700c cm=0x00001e03 +unsafe extern "C" fn shader_00080122_3009700c_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x3009700c, 0x00001e03).opcode }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).planes }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).dither }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).logicop }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).compare }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).blend }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).backblend }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).shade }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).stopony }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).length32 }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).lronly }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).ystride }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).yflip }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x3009700c, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x3009700d cm=0x00001e03 +unsafe extern "C" fn shader_00080122_3009700d_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x3009700d, 0x00001e03).opcode }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).planes }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).dither }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).logicop }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).compare }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).blend }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).backblend }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).shade }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).stopony }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).length32 }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).lronly }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).ystride }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).yflip }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x3009700d, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x30097011 cm=0x00001e03 +unsafe extern "C" fn shader_00080122_30097011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x30097011, 0x00001e03).opcode }, + { unpack(0x00080122, 0x30097011, 0x00001e03).planes }, + { unpack(0x00080122, 0x30097011, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x30097011, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x30097011, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x30097011, 0x00001e03).dither }, + { unpack(0x00080122, 0x30097011, 0x00001e03).logicop }, + { unpack(0x00080122, 0x30097011, 0x00001e03).compare }, + { unpack(0x00080122, 0x30097011, 0x00001e03).blend }, + { unpack(0x00080122, 0x30097011, 0x00001e03).backblend }, + { unpack(0x00080122, 0x30097011, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x30097011, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x30097011, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x30097011, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x30097011, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x30097011, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x30097011, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x30097011, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x30097011, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x30097011, 0x00001e03).shade }, + { unpack(0x00080122, 0x30097011, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x30097011, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x30097011, 0x00001e03).stopony }, + { unpack(0x00080122, 0x30097011, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x30097011, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x30097011, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x30097011, 0x00001e03).length32 }, + { unpack(0x00080122, 0x30097011, 0x00001e03).lronly }, + { unpack(0x00080122, 0x30097011, 0x00001e03).ystride }, + { unpack(0x00080122, 0x30097011, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x30097011, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x30097011, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x30097011, 0x00001e03).yflip }, + { unpack(0x00080122, 0x30097011, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x30097011, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x30097011, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x30097011, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x30097011, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x30097011, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x30097011, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x30097011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x30097031 cm=0x00001e03 +unsafe extern "C" fn shader_00080122_30097031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x30097031, 0x00001e03).opcode }, + { unpack(0x00080122, 0x30097031, 0x00001e03).planes }, + { unpack(0x00080122, 0x30097031, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x30097031, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x30097031, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x30097031, 0x00001e03).dither }, + { unpack(0x00080122, 0x30097031, 0x00001e03).logicop }, + { unpack(0x00080122, 0x30097031, 0x00001e03).compare }, + { unpack(0x00080122, 0x30097031, 0x00001e03).blend }, + { unpack(0x00080122, 0x30097031, 0x00001e03).backblend }, + { unpack(0x00080122, 0x30097031, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x30097031, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x30097031, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x30097031, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x30097031, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x30097031, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x30097031, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x30097031, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x30097031, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x30097031, 0x00001e03).shade }, + { unpack(0x00080122, 0x30097031, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x30097031, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x30097031, 0x00001e03).stopony }, + { unpack(0x00080122, 0x30097031, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x30097031, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x30097031, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x30097031, 0x00001e03).length32 }, + { unpack(0x00080122, 0x30097031, 0x00001e03).lronly }, + { unpack(0x00080122, 0x30097031, 0x00001e03).ystride }, + { unpack(0x00080122, 0x30097031, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x30097031, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x30097031, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x30097031, 0x00001e03).yflip }, + { unpack(0x00080122, 0x30097031, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x30097031, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x30097031, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x30097031, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x30097031, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x30097031, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x30097031, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x30097031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00080122_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00080122_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_00080122_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).planes }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).dither }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).compare }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).blend }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).shade }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00080122 dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_00080122_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00080122, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).planes }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).dither }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).compare }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).blend }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).shade }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x00080122, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00081102 dm1=0x30097011 cm=0x00001e03 +unsafe extern "C" fn shader_00081102_30097011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00081102, 0x30097011, 0x00001e03).opcode }, + { unpack(0x00081102, 0x30097011, 0x00001e03).planes }, + { unpack(0x00081102, 0x30097011, 0x00001e03).drawdepth }, + { unpack(0x00081102, 0x30097011, 0x00001e03).dblsrc }, + { unpack(0x00081102, 0x30097011, 0x00001e03).rgbmode }, + { unpack(0x00081102, 0x30097011, 0x00001e03).dither }, + { unpack(0x00081102, 0x30097011, 0x00001e03).logicop }, + { unpack(0x00081102, 0x30097011, 0x00001e03).compare }, + { unpack(0x00081102, 0x30097011, 0x00001e03).blend }, + { unpack(0x00081102, 0x30097011, 0x00001e03).backblend }, + { unpack(0x00081102, 0x30097011, 0x00001e03).blendalpha }, + { unpack(0x00081102, 0x30097011, 0x00001e03).fastclear }, + { unpack(0x00081102, 0x30097011, 0x00001e03).colorhost }, + { unpack(0x00081102, 0x30097011, 0x00001e03).alphahost }, + { unpack(0x00081102, 0x30097011, 0x00001e03).enzpattern }, + { unpack(0x00081102, 0x30097011, 0x00001e03).enlspattern }, + { unpack(0x00081102, 0x30097011, 0x00001e03).zpopaque }, + { unpack(0x00081102, 0x30097011, 0x00001e03).lsopaque }, + { unpack(0x00081102, 0x30097011, 0x00001e03).cidtest }, + { unpack(0x00081102, 0x30097011, 0x00001e03).shade }, + { unpack(0x00081102, 0x30097011, 0x00001e03).ciclamp }, + { unpack(0x00081102, 0x30097011, 0x00001e03).stoponx }, + { unpack(0x00081102, 0x30097011, 0x00001e03).stopony }, + { unpack(0x00081102, 0x30097011, 0x00001e03).skipfirst }, + { unpack(0x00081102, 0x30097011, 0x00001e03).skiplast }, + { unpack(0x00081102, 0x30097011, 0x00001e03).lsadvlast }, + { unpack(0x00081102, 0x30097011, 0x00001e03).length32 }, + { unpack(0x00081102, 0x30097011, 0x00001e03).lronly }, + { unpack(0x00081102, 0x30097011, 0x00001e03).ystride }, + { unpack(0x00081102, 0x30097011, 0x00001e03).endptfilter }, + { unpack(0x00081102, 0x30097011, 0x00001e03).adrmode }, + { unpack(0x00081102, 0x30097011, 0x00001e03).xyoffset }, + { unpack(0x00081102, 0x30097011, 0x00001e03).yflip }, + { unpack(0x00081102, 0x30097011, 0x00001e03).ensmask }, + { unpack(0x00081102, 0x30097011, 0x00001e03).cid_mask }, + { unpack(0x00081102, 0x30097011, 0x00001e03).sfactor }, + { unpack(0x00081102, 0x30097011, 0x00001e03).dfactor }, + { unpack(0x00081102, 0x30097011, 0x00001e03).rwpacked }, + { unpack(0x00081102, 0x30097011, 0x00001e03).hostdepth }, + { unpack(0x00081102, 0x30097011, 0x00001e03).rwdouble }, + { unpack(0x00081102, 0x30097011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c0122 dm1=0x3009700d cm=0x00001e03 +unsafe extern "C" fn shader_000c0122_3009700d_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c0122, 0x3009700d, 0x00001e03).opcode }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).planes }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).drawdepth }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).dblsrc }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).rgbmode }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).dither }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).logicop }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).compare }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).blend }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).backblend }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).blendalpha }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).fastclear }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).colorhost }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).alphahost }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).enzpattern }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).enlspattern }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).zpopaque }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).lsopaque }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).cidtest }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).shade }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).ciclamp }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).stoponx }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).stopony }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).skipfirst }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).skiplast }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).lsadvlast }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).length32 }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).lronly }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).ystride }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).endptfilter }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).adrmode }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).xyoffset }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).yflip }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).ensmask }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).cid_mask }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).sfactor }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).dfactor }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).rwpacked }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).hostdepth }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).rwdouble }, + { unpack(0x000c0122, 0x3009700d, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c0122 dm1=0x30097011 cm=0x00001e03 +unsafe extern "C" fn shader_000c0122_30097011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c0122, 0x30097011, 0x00001e03).opcode }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).planes }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).drawdepth }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).dblsrc }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).rgbmode }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).dither }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).logicop }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).compare }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).blend }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).backblend }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).blendalpha }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).fastclear }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).colorhost }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).alphahost }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).enzpattern }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).enlspattern }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).zpopaque }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).lsopaque }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).cidtest }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).shade }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).ciclamp }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).stoponx }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).stopony }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).skipfirst }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).skiplast }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).lsadvlast }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).length32 }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).lronly }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).ystride }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).endptfilter }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).adrmode }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).xyoffset }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).yflip }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).ensmask }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).cid_mask }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).sfactor }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).dfactor }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).rwpacked }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).hostdepth }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).rwdouble }, + { unpack(0x000c0122, 0x30097011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c0122 dm1=0x30097031 cm=0x00001e03 +unsafe extern "C" fn shader_000c0122_30097031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c0122, 0x30097031, 0x00001e03).opcode }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).planes }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).drawdepth }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).dblsrc }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).rgbmode }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).dither }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).logicop }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).compare }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).blend }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).backblend }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).blendalpha }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).fastclear }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).colorhost }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).alphahost }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).enzpattern }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).enlspattern }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).zpopaque }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).lsopaque }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).cidtest }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).shade }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).ciclamp }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).stoponx }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).stopony }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).skipfirst }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).skiplast }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).lsadvlast }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).length32 }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).lronly }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).ystride }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).endptfilter }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).adrmode }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).xyoffset }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).yflip }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).ensmask }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).cid_mask }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).sfactor }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).dfactor }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).rwpacked }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).hostdepth }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).rwdouble }, + { unpack(0x000c0122, 0x30097031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c0122 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_000c0122_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c0122, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).planes }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).dither }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).compare }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).blend }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).shade }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x000c0122, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c0122 dm1=0x3009f019 cm=0x00001e03 +unsafe extern "C" fn shader_000c0122_3009f019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c0122, 0x3009f019, 0x00001e03).opcode }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).planes }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).drawdepth }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).dblsrc }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).rgbmode }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).dither }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).logicop }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).compare }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).blend }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).backblend }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).blendalpha }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).fastclear }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).colorhost }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).alphahost }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).enzpattern }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).enlspattern }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).zpopaque }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).lsopaque }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).cidtest }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).shade }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).ciclamp }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).stoponx }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).stopony }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).skipfirst }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).skiplast }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).lsadvlast }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).length32 }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).lronly }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).ystride }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).endptfilter }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).adrmode }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).xyoffset }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).yflip }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).ensmask }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).cid_mask }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).sfactor }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).dfactor }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).rwpacked }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).hostdepth }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).rwdouble }, + { unpack(0x000c0122, 0x3009f019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c0122 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_000c0122_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c0122, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).planes }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).dither }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).compare }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).blend }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).shade }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x000c0122, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c1122 dm1=0x3009700d cm=0x00001e03 +unsafe extern "C" fn shader_000c1122_3009700d_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c1122, 0x3009700d, 0x00001e03).opcode }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).planes }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).drawdepth }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).dblsrc }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).rgbmode }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).dither }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).logicop }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).compare }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).blend }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).backblend }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).blendalpha }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).fastclear }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).colorhost }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).alphahost }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).enzpattern }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).enlspattern }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).zpopaque }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).lsopaque }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).cidtest }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).shade }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).ciclamp }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).stoponx }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).stopony }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).skipfirst }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).skiplast }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).lsadvlast }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).length32 }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).lronly }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).ystride }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).endptfilter }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).adrmode }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).xyoffset }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).yflip }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).ensmask }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).cid_mask }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).sfactor }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).dfactor }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).rwpacked }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).hostdepth }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).rwdouble }, + { unpack(0x000c1122, 0x3009700d, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c9102 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_000c9102_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c9102, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).planes }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).dither }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).compare }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).blend }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).shade }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x000c9102, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c9102 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_000c9102_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c9102, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).planes }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).dither }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).compare }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).blend }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).shade }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x000c9102, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c9102 dm1=0x3065f011 cm=0x00001e03 +unsafe extern "C" fn shader_000c9102_3065f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c9102, 0x3065f011, 0x00001e03).opcode }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).planes }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).drawdepth }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).dblsrc }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).rgbmode }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).dither }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).logicop }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).compare }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).blend }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).backblend }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).blendalpha }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).fastclear }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).colorhost }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).alphahost }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).enzpattern }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).enlspattern }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).zpopaque }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).lsopaque }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).cidtest }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).shade }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).ciclamp }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).stoponx }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).stopony }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).skipfirst }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).skiplast }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).lsadvlast }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).length32 }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).lronly }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).ystride }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).endptfilter }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).adrmode }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).xyoffset }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).yflip }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).ensmask }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).cid_mask }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).sfactor }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).dfactor }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).rwpacked }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).hostdepth }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).rwdouble }, + { unpack(0x000c9102, 0x3065f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x000c9102 dm1=0x3065f031 cm=0x00001e03 +unsafe extern "C" fn shader_000c9102_3065f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x000c9102, 0x3065f031, 0x00001e03).opcode }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).planes }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).drawdepth }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).dblsrc }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).rgbmode }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).dither }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).logicop }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).compare }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).blend }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).backblend }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).blendalpha }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).fastclear }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).colorhost }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).alphahost }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).enzpattern }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).enlspattern }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).zpopaque }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).lsopaque }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).cidtest }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).shade }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).ciclamp }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).stoponx }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).stopony }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).skipfirst }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).skiplast }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).lsadvlast }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).length32 }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).lronly }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).ystride }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).endptfilter }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).adrmode }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).xyoffset }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).yflip }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).ensmask }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).cid_mask }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).sfactor }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).dfactor }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).rwpacked }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).hostdepth }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).rwdouble }, + { unpack(0x000c9102, 0x3065f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00200b2e dm1=0x30017009 cm=0x00001e03 +unsafe extern "C" fn shader_00200b2e_30017009_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00200b2e, 0x30017009, 0x00001e03).opcode }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).planes }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).drawdepth }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).dblsrc }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).rgbmode }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).dither }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).logicop }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).compare }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).blend }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).backblend }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).blendalpha }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).fastclear }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).colorhost }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).alphahost }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).enzpattern }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).enlspattern }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).zpopaque }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).lsopaque }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).cidtest }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).shade }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).ciclamp }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).stoponx }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).stopony }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).skipfirst }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).skiplast }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).lsadvlast }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).length32 }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).lronly }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).ystride }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).endptfilter }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).adrmode }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).xyoffset }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).yflip }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).ensmask }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).cid_mask }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).sfactor }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).dfactor }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).rwpacked }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).hostdepth }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).rwdouble }, + { unpack(0x00200b2e, 0x30017009, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00200b2e dm1=0x3009f011 cm=0x00000203 +unsafe extern "C" fn shader_00200b2e_3009f011_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00200b2e, 0x3009f011, 0x00000203).opcode }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).planes }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).drawdepth }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).dblsrc }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).rgbmode }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).dither }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).logicop }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).compare }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).blend }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).backblend }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).blendalpha }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).fastclear }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).colorhost }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).alphahost }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).enzpattern }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).enlspattern }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).zpopaque }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).lsopaque }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).cidtest }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).shade }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).ciclamp }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).stoponx }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).stopony }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).skipfirst }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).skiplast }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).lsadvlast }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).length32 }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).lronly }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).ystride }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).endptfilter }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).adrmode }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).xyoffset }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).yflip }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).ensmask }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).cid_mask }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).sfactor }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).dfactor }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).rwpacked }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).hostdepth }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).rwdouble }, + { unpack(0x00200b2e, 0x3009f011, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00200b2e dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00200b2e_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00200b2e, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00200b2e dm1=0x3009f031 cm=0x00000203 +unsafe extern "C" fn shader_00200b2e_3009f031_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00200b2e, 0x3009f031, 0x00000203).opcode }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).planes }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).drawdepth }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).dblsrc }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).rgbmode }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).dither }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).logicop }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).compare }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).blend }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).backblend }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).blendalpha }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).fastclear }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).colorhost }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).alphahost }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).enzpattern }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).enlspattern }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).zpopaque }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).lsopaque }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).cidtest }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).shade }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).ciclamp }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).stoponx }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).stopony }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).skipfirst }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).skiplast }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).lsadvlast }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).length32 }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).lronly }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).ystride }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).endptfilter }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).adrmode }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).xyoffset }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).yflip }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).ensmask }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).cid_mask }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).sfactor }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).dfactor }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).rwpacked }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).hostdepth }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).rwdouble }, + { unpack(0x00200b2e, 0x3009f031, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00200b2e dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00200b2e_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00200b2e, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00200b2e dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_00200b2e_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).planes }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).dither }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).compare }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).blend }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).shade }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x00200b2e, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00200b2e dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_00200b2e_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).planes }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).dither }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).compare }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).blend }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).shade }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x00200b2e, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00240b2e dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00240b2e_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00240b2e, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00240b2e dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00240b2e_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00240b2e, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00249b0e dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_00249b0e_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).planes }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).dither }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).compare }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).blend }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).shade }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x00249b0e, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00249b0e dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_00249b0e_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).planes }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).dither }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).compare }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).blend }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).shade }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x00249b0e, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x30017009 cm=0x00001e03 +unsafe extern "C" fn shader_00280126_30017009_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x30017009, 0x00001e03).opcode }, + { unpack(0x00280126, 0x30017009, 0x00001e03).planes }, + { unpack(0x00280126, 0x30017009, 0x00001e03).drawdepth }, + { unpack(0x00280126, 0x30017009, 0x00001e03).dblsrc }, + { unpack(0x00280126, 0x30017009, 0x00001e03).rgbmode }, + { unpack(0x00280126, 0x30017009, 0x00001e03).dither }, + { unpack(0x00280126, 0x30017009, 0x00001e03).logicop }, + { unpack(0x00280126, 0x30017009, 0x00001e03).compare }, + { unpack(0x00280126, 0x30017009, 0x00001e03).blend }, + { unpack(0x00280126, 0x30017009, 0x00001e03).backblend }, + { unpack(0x00280126, 0x30017009, 0x00001e03).blendalpha }, + { unpack(0x00280126, 0x30017009, 0x00001e03).fastclear }, + { unpack(0x00280126, 0x30017009, 0x00001e03).colorhost }, + { unpack(0x00280126, 0x30017009, 0x00001e03).alphahost }, + { unpack(0x00280126, 0x30017009, 0x00001e03).enzpattern }, + { unpack(0x00280126, 0x30017009, 0x00001e03).enlspattern }, + { unpack(0x00280126, 0x30017009, 0x00001e03).zpopaque }, + { unpack(0x00280126, 0x30017009, 0x00001e03).lsopaque }, + { unpack(0x00280126, 0x30017009, 0x00001e03).cidtest }, + { unpack(0x00280126, 0x30017009, 0x00001e03).shade }, + { unpack(0x00280126, 0x30017009, 0x00001e03).ciclamp }, + { unpack(0x00280126, 0x30017009, 0x00001e03).stoponx }, + { unpack(0x00280126, 0x30017009, 0x00001e03).stopony }, + { unpack(0x00280126, 0x30017009, 0x00001e03).skipfirst }, + { unpack(0x00280126, 0x30017009, 0x00001e03).skiplast }, + { unpack(0x00280126, 0x30017009, 0x00001e03).lsadvlast }, + { unpack(0x00280126, 0x30017009, 0x00001e03).length32 }, + { unpack(0x00280126, 0x30017009, 0x00001e03).lronly }, + { unpack(0x00280126, 0x30017009, 0x00001e03).ystride }, + { unpack(0x00280126, 0x30017009, 0x00001e03).endptfilter }, + { unpack(0x00280126, 0x30017009, 0x00001e03).adrmode }, + { unpack(0x00280126, 0x30017009, 0x00001e03).xyoffset }, + { unpack(0x00280126, 0x30017009, 0x00001e03).yflip }, + { unpack(0x00280126, 0x30017009, 0x00001e03).ensmask }, + { unpack(0x00280126, 0x30017009, 0x00001e03).cid_mask }, + { unpack(0x00280126, 0x30017009, 0x00001e03).sfactor }, + { unpack(0x00280126, 0x30017009, 0x00001e03).dfactor }, + { unpack(0x00280126, 0x30017009, 0x00001e03).rwpacked }, + { unpack(0x00280126, 0x30017009, 0x00001e03).hostdepth }, + { unpack(0x00280126, 0x30017009, 0x00001e03).rwdouble }, + { unpack(0x00280126, 0x30017009, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3009f011 cm=0x00000203 +unsafe extern "C" fn shader_00280126_3009f011_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3009f011, 0x00000203).opcode }, + { unpack(0x00280126, 0x3009f011, 0x00000203).planes }, + { unpack(0x00280126, 0x3009f011, 0x00000203).drawdepth }, + { unpack(0x00280126, 0x3009f011, 0x00000203).dblsrc }, + { unpack(0x00280126, 0x3009f011, 0x00000203).rgbmode }, + { unpack(0x00280126, 0x3009f011, 0x00000203).dither }, + { unpack(0x00280126, 0x3009f011, 0x00000203).logicop }, + { unpack(0x00280126, 0x3009f011, 0x00000203).compare }, + { unpack(0x00280126, 0x3009f011, 0x00000203).blend }, + { unpack(0x00280126, 0x3009f011, 0x00000203).backblend }, + { unpack(0x00280126, 0x3009f011, 0x00000203).blendalpha }, + { unpack(0x00280126, 0x3009f011, 0x00000203).fastclear }, + { unpack(0x00280126, 0x3009f011, 0x00000203).colorhost }, + { unpack(0x00280126, 0x3009f011, 0x00000203).alphahost }, + { unpack(0x00280126, 0x3009f011, 0x00000203).enzpattern }, + { unpack(0x00280126, 0x3009f011, 0x00000203).enlspattern }, + { unpack(0x00280126, 0x3009f011, 0x00000203).zpopaque }, + { unpack(0x00280126, 0x3009f011, 0x00000203).lsopaque }, + { unpack(0x00280126, 0x3009f011, 0x00000203).cidtest }, + { unpack(0x00280126, 0x3009f011, 0x00000203).shade }, + { unpack(0x00280126, 0x3009f011, 0x00000203).ciclamp }, + { unpack(0x00280126, 0x3009f011, 0x00000203).stoponx }, + { unpack(0x00280126, 0x3009f011, 0x00000203).stopony }, + { unpack(0x00280126, 0x3009f011, 0x00000203).skipfirst }, + { unpack(0x00280126, 0x3009f011, 0x00000203).skiplast }, + { unpack(0x00280126, 0x3009f011, 0x00000203).lsadvlast }, + { unpack(0x00280126, 0x3009f011, 0x00000203).length32 }, + { unpack(0x00280126, 0x3009f011, 0x00000203).lronly }, + { unpack(0x00280126, 0x3009f011, 0x00000203).ystride }, + { unpack(0x00280126, 0x3009f011, 0x00000203).endptfilter }, + { unpack(0x00280126, 0x3009f011, 0x00000203).adrmode }, + { unpack(0x00280126, 0x3009f011, 0x00000203).xyoffset }, + { unpack(0x00280126, 0x3009f011, 0x00000203).yflip }, + { unpack(0x00280126, 0x3009f011, 0x00000203).ensmask }, + { unpack(0x00280126, 0x3009f011, 0x00000203).cid_mask }, + { unpack(0x00280126, 0x3009f011, 0x00000203).sfactor }, + { unpack(0x00280126, 0x3009f011, 0x00000203).dfactor }, + { unpack(0x00280126, 0x3009f011, 0x00000203).rwpacked }, + { unpack(0x00280126, 0x3009f011, 0x00000203).hostdepth }, + { unpack(0x00280126, 0x3009f011, 0x00000203).rwdouble }, + { unpack(0x00280126, 0x3009f011, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_00280126_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).planes }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).dither }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).compare }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).blend }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).shade }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x00280126, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3009f019 cm=0x00000003 +unsafe extern "C" fn shader_00280126_3009f019_00000003( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3009f019, 0x00000003).opcode }, + { unpack(0x00280126, 0x3009f019, 0x00000003).planes }, + { unpack(0x00280126, 0x3009f019, 0x00000003).drawdepth }, + { unpack(0x00280126, 0x3009f019, 0x00000003).dblsrc }, + { unpack(0x00280126, 0x3009f019, 0x00000003).rgbmode }, + { unpack(0x00280126, 0x3009f019, 0x00000003).dither }, + { unpack(0x00280126, 0x3009f019, 0x00000003).logicop }, + { unpack(0x00280126, 0x3009f019, 0x00000003).compare }, + { unpack(0x00280126, 0x3009f019, 0x00000003).blend }, + { unpack(0x00280126, 0x3009f019, 0x00000003).backblend }, + { unpack(0x00280126, 0x3009f019, 0x00000003).blendalpha }, + { unpack(0x00280126, 0x3009f019, 0x00000003).fastclear }, + { unpack(0x00280126, 0x3009f019, 0x00000003).colorhost }, + { unpack(0x00280126, 0x3009f019, 0x00000003).alphahost }, + { unpack(0x00280126, 0x3009f019, 0x00000003).enzpattern }, + { unpack(0x00280126, 0x3009f019, 0x00000003).enlspattern }, + { unpack(0x00280126, 0x3009f019, 0x00000003).zpopaque }, + { unpack(0x00280126, 0x3009f019, 0x00000003).lsopaque }, + { unpack(0x00280126, 0x3009f019, 0x00000003).cidtest }, + { unpack(0x00280126, 0x3009f019, 0x00000003).shade }, + { unpack(0x00280126, 0x3009f019, 0x00000003).ciclamp }, + { unpack(0x00280126, 0x3009f019, 0x00000003).stoponx }, + { unpack(0x00280126, 0x3009f019, 0x00000003).stopony }, + { unpack(0x00280126, 0x3009f019, 0x00000003).skipfirst }, + { unpack(0x00280126, 0x3009f019, 0x00000003).skiplast }, + { unpack(0x00280126, 0x3009f019, 0x00000003).lsadvlast }, + { unpack(0x00280126, 0x3009f019, 0x00000003).length32 }, + { unpack(0x00280126, 0x3009f019, 0x00000003).lronly }, + { unpack(0x00280126, 0x3009f019, 0x00000003).ystride }, + { unpack(0x00280126, 0x3009f019, 0x00000003).endptfilter }, + { unpack(0x00280126, 0x3009f019, 0x00000003).adrmode }, + { unpack(0x00280126, 0x3009f019, 0x00000003).xyoffset }, + { unpack(0x00280126, 0x3009f019, 0x00000003).yflip }, + { unpack(0x00280126, 0x3009f019, 0x00000003).ensmask }, + { unpack(0x00280126, 0x3009f019, 0x00000003).cid_mask }, + { unpack(0x00280126, 0x3009f019, 0x00000003).sfactor }, + { unpack(0x00280126, 0x3009f019, 0x00000003).dfactor }, + { unpack(0x00280126, 0x3009f019, 0x00000003).rwpacked }, + { unpack(0x00280126, 0x3009f019, 0x00000003).hostdepth }, + { unpack(0x00280126, 0x3009f019, 0x00000003).rwdouble }, + { unpack(0x00280126, 0x3009f019, 0x00000003).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3009f019 cm=0x00001e03 +unsafe extern "C" fn shader_00280126_3009f019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3009f019, 0x00001e03).opcode }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).planes }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).drawdepth }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).dblsrc }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).rgbmode }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).dither }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).logicop }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).compare }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).blend }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).backblend }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).blendalpha }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).fastclear }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).colorhost }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).alphahost }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).enzpattern }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).enlspattern }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).zpopaque }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).lsopaque }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).cidtest }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).shade }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).ciclamp }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).stoponx }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).stopony }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).skipfirst }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).skiplast }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).lsadvlast }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).length32 }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).lronly }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).ystride }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).endptfilter }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).adrmode }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).xyoffset }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).yflip }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).ensmask }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).cid_mask }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).sfactor }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).dfactor }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).rwpacked }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).hostdepth }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).rwdouble }, + { unpack(0x00280126, 0x3009f019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3009f031 cm=0x00000203 +unsafe extern "C" fn shader_00280126_3009f031_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3009f031, 0x00000203).opcode }, + { unpack(0x00280126, 0x3009f031, 0x00000203).planes }, + { unpack(0x00280126, 0x3009f031, 0x00000203).drawdepth }, + { unpack(0x00280126, 0x3009f031, 0x00000203).dblsrc }, + { unpack(0x00280126, 0x3009f031, 0x00000203).rgbmode }, + { unpack(0x00280126, 0x3009f031, 0x00000203).dither }, + { unpack(0x00280126, 0x3009f031, 0x00000203).logicop }, + { unpack(0x00280126, 0x3009f031, 0x00000203).compare }, + { unpack(0x00280126, 0x3009f031, 0x00000203).blend }, + { unpack(0x00280126, 0x3009f031, 0x00000203).backblend }, + { unpack(0x00280126, 0x3009f031, 0x00000203).blendalpha }, + { unpack(0x00280126, 0x3009f031, 0x00000203).fastclear }, + { unpack(0x00280126, 0x3009f031, 0x00000203).colorhost }, + { unpack(0x00280126, 0x3009f031, 0x00000203).alphahost }, + { unpack(0x00280126, 0x3009f031, 0x00000203).enzpattern }, + { unpack(0x00280126, 0x3009f031, 0x00000203).enlspattern }, + { unpack(0x00280126, 0x3009f031, 0x00000203).zpopaque }, + { unpack(0x00280126, 0x3009f031, 0x00000203).lsopaque }, + { unpack(0x00280126, 0x3009f031, 0x00000203).cidtest }, + { unpack(0x00280126, 0x3009f031, 0x00000203).shade }, + { unpack(0x00280126, 0x3009f031, 0x00000203).ciclamp }, + { unpack(0x00280126, 0x3009f031, 0x00000203).stoponx }, + { unpack(0x00280126, 0x3009f031, 0x00000203).stopony }, + { unpack(0x00280126, 0x3009f031, 0x00000203).skipfirst }, + { unpack(0x00280126, 0x3009f031, 0x00000203).skiplast }, + { unpack(0x00280126, 0x3009f031, 0x00000203).lsadvlast }, + { unpack(0x00280126, 0x3009f031, 0x00000203).length32 }, + { unpack(0x00280126, 0x3009f031, 0x00000203).lronly }, + { unpack(0x00280126, 0x3009f031, 0x00000203).ystride }, + { unpack(0x00280126, 0x3009f031, 0x00000203).endptfilter }, + { unpack(0x00280126, 0x3009f031, 0x00000203).adrmode }, + { unpack(0x00280126, 0x3009f031, 0x00000203).xyoffset }, + { unpack(0x00280126, 0x3009f031, 0x00000203).yflip }, + { unpack(0x00280126, 0x3009f031, 0x00000203).ensmask }, + { unpack(0x00280126, 0x3009f031, 0x00000203).cid_mask }, + { unpack(0x00280126, 0x3009f031, 0x00000203).sfactor }, + { unpack(0x00280126, 0x3009f031, 0x00000203).dfactor }, + { unpack(0x00280126, 0x3009f031, 0x00000203).rwpacked }, + { unpack(0x00280126, 0x3009f031, 0x00000203).hostdepth }, + { unpack(0x00280126, 0x3009f031, 0x00000203).rwdouble }, + { unpack(0x00280126, 0x3009f031, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_00280126_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).planes }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).dither }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).compare }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).blend }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).shade }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x00280126, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_00280126_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).planes }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).dither }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).compare }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).blend }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).shade }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x00280126, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3161f031 cm=0x00000203 +unsafe extern "C" fn shader_00280126_3161f031_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3161f031, 0x00000203).opcode }, + { unpack(0x00280126, 0x3161f031, 0x00000203).planes }, + { unpack(0x00280126, 0x3161f031, 0x00000203).drawdepth }, + { unpack(0x00280126, 0x3161f031, 0x00000203).dblsrc }, + { unpack(0x00280126, 0x3161f031, 0x00000203).rgbmode }, + { unpack(0x00280126, 0x3161f031, 0x00000203).dither }, + { unpack(0x00280126, 0x3161f031, 0x00000203).logicop }, + { unpack(0x00280126, 0x3161f031, 0x00000203).compare }, + { unpack(0x00280126, 0x3161f031, 0x00000203).blend }, + { unpack(0x00280126, 0x3161f031, 0x00000203).backblend }, + { unpack(0x00280126, 0x3161f031, 0x00000203).blendalpha }, + { unpack(0x00280126, 0x3161f031, 0x00000203).fastclear }, + { unpack(0x00280126, 0x3161f031, 0x00000203).colorhost }, + { unpack(0x00280126, 0x3161f031, 0x00000203).alphahost }, + { unpack(0x00280126, 0x3161f031, 0x00000203).enzpattern }, + { unpack(0x00280126, 0x3161f031, 0x00000203).enlspattern }, + { unpack(0x00280126, 0x3161f031, 0x00000203).zpopaque }, + { unpack(0x00280126, 0x3161f031, 0x00000203).lsopaque }, + { unpack(0x00280126, 0x3161f031, 0x00000203).cidtest }, + { unpack(0x00280126, 0x3161f031, 0x00000203).shade }, + { unpack(0x00280126, 0x3161f031, 0x00000203).ciclamp }, + { unpack(0x00280126, 0x3161f031, 0x00000203).stoponx }, + { unpack(0x00280126, 0x3161f031, 0x00000203).stopony }, + { unpack(0x00280126, 0x3161f031, 0x00000203).skipfirst }, + { unpack(0x00280126, 0x3161f031, 0x00000203).skiplast }, + { unpack(0x00280126, 0x3161f031, 0x00000203).lsadvlast }, + { unpack(0x00280126, 0x3161f031, 0x00000203).length32 }, + { unpack(0x00280126, 0x3161f031, 0x00000203).lronly }, + { unpack(0x00280126, 0x3161f031, 0x00000203).ystride }, + { unpack(0x00280126, 0x3161f031, 0x00000203).endptfilter }, + { unpack(0x00280126, 0x3161f031, 0x00000203).adrmode }, + { unpack(0x00280126, 0x3161f031, 0x00000203).xyoffset }, + { unpack(0x00280126, 0x3161f031, 0x00000203).yflip }, + { unpack(0x00280126, 0x3161f031, 0x00000203).ensmask }, + { unpack(0x00280126, 0x3161f031, 0x00000203).cid_mask }, + { unpack(0x00280126, 0x3161f031, 0x00000203).sfactor }, + { unpack(0x00280126, 0x3161f031, 0x00000203).dfactor }, + { unpack(0x00280126, 0x3161f031, 0x00000203).rwpacked }, + { unpack(0x00280126, 0x3161f031, 0x00000203).hostdepth }, + { unpack(0x00280126, 0x3161f031, 0x00000203).rwdouble }, + { unpack(0x00280126, 0x3161f031, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_00280126_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).planes }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).dither }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).compare }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).blend }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).shade }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x00280126, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_00280126_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).planes }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).dither }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).compare }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).blend }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).shade }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x00280126, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3165f019 cm=0x00000203 +unsafe extern "C" fn shader_00280126_3165f019_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3165f019, 0x00000203).opcode }, + { unpack(0x00280126, 0x3165f019, 0x00000203).planes }, + { unpack(0x00280126, 0x3165f019, 0x00000203).drawdepth }, + { unpack(0x00280126, 0x3165f019, 0x00000203).dblsrc }, + { unpack(0x00280126, 0x3165f019, 0x00000203).rgbmode }, + { unpack(0x00280126, 0x3165f019, 0x00000203).dither }, + { unpack(0x00280126, 0x3165f019, 0x00000203).logicop }, + { unpack(0x00280126, 0x3165f019, 0x00000203).compare }, + { unpack(0x00280126, 0x3165f019, 0x00000203).blend }, + { unpack(0x00280126, 0x3165f019, 0x00000203).backblend }, + { unpack(0x00280126, 0x3165f019, 0x00000203).blendalpha }, + { unpack(0x00280126, 0x3165f019, 0x00000203).fastclear }, + { unpack(0x00280126, 0x3165f019, 0x00000203).colorhost }, + { unpack(0x00280126, 0x3165f019, 0x00000203).alphahost }, + { unpack(0x00280126, 0x3165f019, 0x00000203).enzpattern }, + { unpack(0x00280126, 0x3165f019, 0x00000203).enlspattern }, + { unpack(0x00280126, 0x3165f019, 0x00000203).zpopaque }, + { unpack(0x00280126, 0x3165f019, 0x00000203).lsopaque }, + { unpack(0x00280126, 0x3165f019, 0x00000203).cidtest }, + { unpack(0x00280126, 0x3165f019, 0x00000203).shade }, + { unpack(0x00280126, 0x3165f019, 0x00000203).ciclamp }, + { unpack(0x00280126, 0x3165f019, 0x00000203).stoponx }, + { unpack(0x00280126, 0x3165f019, 0x00000203).stopony }, + { unpack(0x00280126, 0x3165f019, 0x00000203).skipfirst }, + { unpack(0x00280126, 0x3165f019, 0x00000203).skiplast }, + { unpack(0x00280126, 0x3165f019, 0x00000203).lsadvlast }, + { unpack(0x00280126, 0x3165f019, 0x00000203).length32 }, + { unpack(0x00280126, 0x3165f019, 0x00000203).lronly }, + { unpack(0x00280126, 0x3165f019, 0x00000203).ystride }, + { unpack(0x00280126, 0x3165f019, 0x00000203).endptfilter }, + { unpack(0x00280126, 0x3165f019, 0x00000203).adrmode }, + { unpack(0x00280126, 0x3165f019, 0x00000203).xyoffset }, + { unpack(0x00280126, 0x3165f019, 0x00000203).yflip }, + { unpack(0x00280126, 0x3165f019, 0x00000203).ensmask }, + { unpack(0x00280126, 0x3165f019, 0x00000203).cid_mask }, + { unpack(0x00280126, 0x3165f019, 0x00000203).sfactor }, + { unpack(0x00280126, 0x3165f019, 0x00000203).dfactor }, + { unpack(0x00280126, 0x3165f019, 0x00000203).rwpacked }, + { unpack(0x00280126, 0x3165f019, 0x00000203).hostdepth }, + { unpack(0x00280126, 0x3165f019, 0x00000203).rwdouble }, + { unpack(0x00280126, 0x3165f019, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3165f019 cm=0x00001e03 +unsafe extern "C" fn shader_00280126_3165f019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3165f019, 0x00001e03).opcode }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).planes }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).drawdepth }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).dblsrc }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).rgbmode }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).dither }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).logicop }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).compare }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).blend }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).backblend }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).blendalpha }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).fastclear }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).colorhost }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).alphahost }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).enzpattern }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).enlspattern }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).zpopaque }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).lsopaque }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).cidtest }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).shade }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).ciclamp }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).stoponx }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).stopony }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).skipfirst }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).skiplast }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).lsadvlast }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).length32 }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).lronly }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).ystride }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).endptfilter }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).adrmode }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).xyoffset }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).yflip }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).ensmask }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).cid_mask }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).sfactor }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).dfactor }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).rwpacked }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).hostdepth }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).rwdouble }, + { unpack(0x00280126, 0x3165f019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00280126 dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_00280126_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00280126, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).planes }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).dither }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).compare }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).blend }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).shade }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x00280126, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c0126 dm1=0x3009f009 cm=0x00000203 +unsafe extern "C" fn shader_002c0126_3009f009_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c0126, 0x3009f009, 0x00000203).opcode }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).planes }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).drawdepth }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).dblsrc }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).rgbmode }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).dither }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).logicop }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).compare }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).blend }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).backblend }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).blendalpha }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).fastclear }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).colorhost }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).alphahost }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).enzpattern }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).enlspattern }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).zpopaque }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).lsopaque }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).cidtest }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).shade }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).ciclamp }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).stoponx }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).stopony }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).skipfirst }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).skiplast }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).lsadvlast }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).length32 }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).lronly }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).ystride }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).endptfilter }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).adrmode }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).xyoffset }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).yflip }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).ensmask }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).cid_mask }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).sfactor }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).dfactor }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).rwpacked }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).hostdepth }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).rwdouble }, + { unpack(0x002c0126, 0x3009f009, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c0126 dm1=0x3009f009 cm=0x00001e03 +unsafe extern "C" fn shader_002c0126_3009f009_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c0126, 0x3009f009, 0x00001e03).opcode }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).planes }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).drawdepth }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).dblsrc }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).rgbmode }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).dither }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).logicop }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).compare }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).blend }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).backblend }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).blendalpha }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).fastclear }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).colorhost }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).alphahost }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).enzpattern }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).enlspattern }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).zpopaque }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).lsopaque }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).cidtest }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).shade }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).ciclamp }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).stoponx }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).stopony }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).skipfirst }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).skiplast }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).lsadvlast }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).length32 }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).lronly }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).ystride }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).endptfilter }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).adrmode }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).xyoffset }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).yflip }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).ensmask }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).cid_mask }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).sfactor }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).dfactor }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).rwpacked }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).hostdepth }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).rwdouble }, + { unpack(0x002c0126, 0x3009f009, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c0126 dm1=0x3009f011 cm=0x00000203 +unsafe extern "C" fn shader_002c0126_3009f011_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c0126, 0x3009f011, 0x00000203).opcode }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).planes }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).drawdepth }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).dblsrc }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).rgbmode }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).dither }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).logicop }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).compare }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).blend }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).backblend }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).blendalpha }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).fastclear }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).colorhost }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).alphahost }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).enzpattern }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).enlspattern }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).zpopaque }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).lsopaque }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).cidtest }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).shade }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).ciclamp }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).stoponx }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).stopony }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).skipfirst }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).skiplast }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).lsadvlast }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).length32 }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).lronly }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).ystride }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).endptfilter }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).adrmode }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).xyoffset }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).yflip }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).ensmask }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).cid_mask }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).sfactor }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).dfactor }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).rwpacked }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).hostdepth }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).rwdouble }, + { unpack(0x002c0126, 0x3009f011, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c0126 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_002c0126_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c0126, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).planes }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).dither }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).compare }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).blend }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).shade }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x002c0126, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c0126 dm1=0x3009f031 cm=0x00000203 +unsafe extern "C" fn shader_002c0126_3009f031_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c0126, 0x3009f031, 0x00000203).opcode }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).planes }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).drawdepth }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).dblsrc }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).rgbmode }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).dither }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).logicop }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).compare }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).blend }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).backblend }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).blendalpha }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).fastclear }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).colorhost }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).alphahost }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).enzpattern }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).enlspattern }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).zpopaque }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).lsopaque }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).cidtest }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).shade }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).ciclamp }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).stoponx }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).stopony }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).skipfirst }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).skiplast }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).lsadvlast }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).length32 }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).lronly }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).ystride }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).endptfilter }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).adrmode }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).xyoffset }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).yflip }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).ensmask }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).cid_mask }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).sfactor }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).dfactor }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).rwpacked }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).hostdepth }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).rwdouble }, + { unpack(0x002c0126, 0x3009f031, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c0126 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_002c0126_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c0126, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).planes }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).dither }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).compare }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).blend }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).shade }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x002c0126, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c0126 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_002c0126_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c0126, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).planes }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).dither }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).compare }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).blend }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).shade }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x002c0126, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c0126 dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_002c0126_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c0126, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).planes }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).dither }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).compare }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).blend }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).shade }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x002c0126, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3009f009 cm=0x00001e03 +unsafe extern "C" fn shader_002c9126_3009f009_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3009f009, 0x00001e03).opcode }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).planes }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).drawdepth }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).dblsrc }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).rgbmode }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).dither }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).logicop }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).compare }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).blend }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).backblend }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).blendalpha }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).fastclear }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).colorhost }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).alphahost }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).enzpattern }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).enlspattern }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).zpopaque }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).lsopaque }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).cidtest }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).shade }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).ciclamp }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).stoponx }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).stopony }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).skipfirst }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).skiplast }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).lsadvlast }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).length32 }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).lronly }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).ystride }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).endptfilter }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).adrmode }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).xyoffset }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).yflip }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).ensmask }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).cid_mask }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).sfactor }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).dfactor }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).rwpacked }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).hostdepth }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).rwdouble }, + { unpack(0x002c9126, 0x3009f009, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3009f009 cm=0x00001e07 +unsafe extern "C" fn shader_002c9126_3009f009_00001e07( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3009f009, 0x00001e07).opcode }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).planes }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).drawdepth }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).dblsrc }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).rgbmode }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).dither }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).logicop }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).compare }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).blend }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).backblend }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).blendalpha }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).fastclear }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).colorhost }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).alphahost }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).enzpattern }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).enlspattern }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).zpopaque }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).lsopaque }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).cidtest }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).shade }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).ciclamp }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).stoponx }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).stopony }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).skipfirst }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).skiplast }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).lsadvlast }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).length32 }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).lronly }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).ystride }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).endptfilter }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).adrmode }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).xyoffset }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).yflip }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).ensmask }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).cid_mask }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).sfactor }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).dfactor }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).rwpacked }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).hostdepth }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).rwdouble }, + { unpack(0x002c9126, 0x3009f009, 0x00001e07).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3009f011 cm=0x00001e03 +unsafe extern "C" fn shader_002c9126_3009f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3009f011, 0x00001e03).opcode }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).planes }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).drawdepth }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).dblsrc }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).rgbmode }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).dither }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).logicop }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).compare }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).blend }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).backblend }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).blendalpha }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).fastclear }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).colorhost }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).alphahost }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).enzpattern }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).enlspattern }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).zpopaque }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).lsopaque }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).cidtest }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).shade }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).ciclamp }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).stoponx }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).stopony }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).skipfirst }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).skiplast }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).lsadvlast }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).length32 }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).lronly }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).ystride }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).endptfilter }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).adrmode }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).xyoffset }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).yflip }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).ensmask }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).cid_mask }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).sfactor }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).dfactor }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).rwpacked }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).hostdepth }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).rwdouble }, + { unpack(0x002c9126, 0x3009f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3009f031 cm=0x00001e03 +unsafe extern "C" fn shader_002c9126_3009f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3009f031, 0x00001e03).opcode }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).planes }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).drawdepth }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).dblsrc }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).rgbmode }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).dither }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).logicop }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).compare }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).blend }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).backblend }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).blendalpha }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).fastclear }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).colorhost }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).alphahost }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).enzpattern }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).enlspattern }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).zpopaque }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).lsopaque }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).cidtest }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).shade }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).ciclamp }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).stoponx }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).stopony }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).skipfirst }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).skiplast }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).lsadvlast }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).length32 }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).lronly }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).ystride }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).endptfilter }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).adrmode }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).xyoffset }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).yflip }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).ensmask }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).cid_mask }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).sfactor }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).dfactor }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).rwpacked }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).hostdepth }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).rwdouble }, + { unpack(0x002c9126, 0x3009f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3061f011 cm=0x00001e03 +unsafe extern "C" fn shader_002c9126_3061f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3061f011, 0x00001e03).opcode }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).planes }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).drawdepth }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).dblsrc }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).rgbmode }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).dither }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).logicop }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).compare }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).blend }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).backblend }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).blendalpha }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).fastclear }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).colorhost }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).alphahost }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).enzpattern }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).enlspattern }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).zpopaque }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).lsopaque }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).cidtest }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).shade }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).ciclamp }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).stoponx }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).stopony }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).skipfirst }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).skiplast }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).lsadvlast }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).length32 }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).lronly }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).ystride }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).endptfilter }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).adrmode }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).xyoffset }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).yflip }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).ensmask }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).cid_mask }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).sfactor }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).dfactor }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).rwpacked }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).hostdepth }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).rwdouble }, + { unpack(0x002c9126, 0x3061f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3061f031 cm=0x00001e03 +unsafe extern "C" fn shader_002c9126_3061f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3061f031, 0x00001e03).opcode }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).planes }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).drawdepth }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).dblsrc }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).rgbmode }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).dither }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).logicop }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).compare }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).blend }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).backblend }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).blendalpha }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).fastclear }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).colorhost }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).alphahost }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).enzpattern }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).enlspattern }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).zpopaque }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).lsopaque }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).cidtest }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).shade }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).ciclamp }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).stoponx }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).stopony }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).skipfirst }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).skiplast }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).lsadvlast }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).length32 }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).lronly }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).ystride }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).endptfilter }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).adrmode }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).xyoffset }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).yflip }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).ensmask }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).cid_mask }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).sfactor }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).dfactor }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).rwpacked }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).hostdepth }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).rwdouble }, + { unpack(0x002c9126, 0x3061f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3161f011 cm=0x00001e03 +unsafe extern "C" fn shader_002c9126_3161f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3161f011, 0x00001e03).opcode }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).planes }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).drawdepth }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).dblsrc }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).rgbmode }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).dither }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).logicop }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).compare }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).blend }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).backblend }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).blendalpha }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).fastclear }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).colorhost }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).alphahost }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).enzpattern }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).enlspattern }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).zpopaque }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).lsopaque }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).cidtest }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).shade }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).ciclamp }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).stoponx }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).stopony }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).skipfirst }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).skiplast }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).lsadvlast }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).length32 }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).lronly }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).ystride }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).endptfilter }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).adrmode }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).xyoffset }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).yflip }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).ensmask }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).cid_mask }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).sfactor }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).dfactor }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).rwpacked }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).hostdepth }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).rwdouble }, + { unpack(0x002c9126, 0x3161f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3161f011 cm=0x00001e0f +unsafe extern "C" fn shader_002c9126_3161f011_00001e0f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).opcode }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).planes }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).drawdepth }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).dblsrc }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).rgbmode }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).dither }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).logicop }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).compare }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).blend }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).backblend }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).blendalpha }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).fastclear }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).colorhost }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).alphahost }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).enzpattern }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).enlspattern }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).zpopaque }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).lsopaque }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).cidtest }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).shade }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).ciclamp }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).stoponx }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).stopony }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).skipfirst }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).skiplast }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).lsadvlast }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).length32 }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).lronly }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).ystride }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).endptfilter }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).adrmode }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).xyoffset }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).yflip }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).ensmask }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).cid_mask }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).sfactor }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).dfactor }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).rwpacked }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).hostdepth }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).rwdouble }, + { unpack(0x002c9126, 0x3161f011, 0x00001e0f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3161f031 cm=0x00000203 +unsafe extern "C" fn shader_002c9126_3161f031_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3161f031, 0x00000203).opcode }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).planes }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).drawdepth }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).dblsrc }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).rgbmode }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).dither }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).logicop }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).compare }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).blend }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).backblend }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).blendalpha }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).fastclear }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).colorhost }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).alphahost }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).enzpattern }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).enlspattern }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).zpopaque }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).lsopaque }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).cidtest }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).shade }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).ciclamp }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).stoponx }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).stopony }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).skipfirst }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).skiplast }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).lsadvlast }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).length32 }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).lronly }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).ystride }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).endptfilter }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).adrmode }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).xyoffset }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).yflip }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).ensmask }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).cid_mask }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).sfactor }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).dfactor }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).rwpacked }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).hostdepth }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).rwdouble }, + { unpack(0x002c9126, 0x3161f031, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3161f031 cm=0x00001e03 +unsafe extern "C" fn shader_002c9126_3161f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3161f031, 0x00001e03).opcode }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).planes }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).drawdepth }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).dblsrc }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).rgbmode }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).dither }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).logicop }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).compare }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).blend }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).backblend }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).blendalpha }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).fastclear }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).colorhost }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).alphahost }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).enzpattern }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).enlspattern }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).zpopaque }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).lsopaque }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).cidtest }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).shade }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).ciclamp }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).stoponx }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).stopony }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).skipfirst }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).skiplast }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).lsadvlast }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).length32 }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).lronly }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).ystride }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).endptfilter }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).adrmode }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).xyoffset }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).yflip }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).ensmask }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).cid_mask }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).sfactor }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).dfactor }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).rwpacked }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).hostdepth }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).rwdouble }, + { unpack(0x002c9126, 0x3161f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3161f031 cm=0x00001e0f +unsafe extern "C" fn shader_002c9126_3161f031_00001e0f( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).opcode }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).planes }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).drawdepth }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).dblsrc }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).rgbmode }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).dither }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).logicop }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).compare }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).blend }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).backblend }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).blendalpha }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).fastclear }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).colorhost }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).alphahost }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).enzpattern }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).enlspattern }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).zpopaque }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).lsopaque }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).cidtest }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).shade }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).ciclamp }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).stoponx }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).stopony }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).skipfirst }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).skiplast }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).lsadvlast }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).length32 }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).lronly }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).ystride }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).endptfilter }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).adrmode }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).xyoffset }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).yflip }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).ensmask }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).cid_mask }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).sfactor }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).dfactor }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).rwpacked }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).hostdepth }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).rwdouble }, + { unpack(0x002c9126, 0x3161f031, 0x00001e0f).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_002c9126_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).planes }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).dither }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).compare }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).blend }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).shade }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x002c9126, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x002c9126 dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_002c9126_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x002c9126, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).planes }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).dither }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).compare }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).blend }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).shade }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x002c9126, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00400b32 dm1=0x3165f019 cm=0x00000203 +unsafe extern "C" fn shader_00400b32_3165f019_00000203( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00400b32, 0x3165f019, 0x00000203).opcode }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).planes }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).drawdepth }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).dblsrc }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).rgbmode }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).dither }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).logicop }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).compare }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).blend }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).backblend }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).blendalpha }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).fastclear }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).colorhost }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).alphahost }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).enzpattern }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).enlspattern }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).zpopaque }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).lsopaque }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).cidtest }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).shade }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).ciclamp }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).stoponx }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).stopony }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).skipfirst }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).skiplast }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).lsadvlast }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).length32 }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).lronly }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).ystride }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).endptfilter }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).adrmode }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).xyoffset }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).yflip }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).ensmask }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).cid_mask }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).sfactor }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).dfactor }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).rwpacked }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).hostdepth }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).rwdouble }, + { unpack(0x00400b32, 0x3165f019, 0x00000203).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00400b32 dm1=0x3165f019 cm=0x00001e03 +unsafe extern "C" fn shader_00400b32_3165f019_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00400b32, 0x3165f019, 0x00001e03).opcode }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).planes }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).drawdepth }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).dblsrc }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).rgbmode }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).dither }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).logicop }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).compare }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).blend }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).backblend }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).blendalpha }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).fastclear }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).colorhost }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).alphahost }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).enzpattern }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).enlspattern }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).zpopaque }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).lsopaque }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).cidtest }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).shade }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).ciclamp }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).stoponx }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).stopony }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).skipfirst }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).skiplast }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).lsadvlast }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).length32 }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).lronly }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).ystride }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).endptfilter }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).adrmode }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).xyoffset }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).yflip }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).ensmask }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).cid_mask }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).sfactor }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).dfactor }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).rwpacked }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).hostdepth }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).rwdouble }, + { unpack(0x00400b32, 0x3165f019, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00440b32 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_00440b32_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00440b32, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).planes }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).dither }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).compare }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).blend }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).shade }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x00440b32, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00440b32 dm1=0x3165f031 cm=0x00001e03 +unsafe extern "C" fn shader_00440b32_3165f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00440b32, 0x3165f031, 0x00001e03).opcode }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).planes }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).drawdepth }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).dblsrc }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).rgbmode }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).dither }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).logicop }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).compare }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).blend }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).backblend }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).blendalpha }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).fastclear }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).colorhost }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).alphahost }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).enzpattern }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).enlspattern }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).zpopaque }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).lsopaque }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).cidtest }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).shade }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).ciclamp }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).stoponx }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).stopony }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).skipfirst }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).skiplast }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).lsadvlast }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).length32 }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).lronly }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).ystride }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).endptfilter }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).adrmode }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).xyoffset }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).yflip }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).ensmask }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).cid_mask }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).sfactor }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).dfactor }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).rwpacked }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).hostdepth }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).rwdouble }, + { unpack(0x00440b32, 0x3165f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x00442332 dm1=0x3165f011 cm=0x00001e03 +unsafe extern "C" fn shader_00442332_3165f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x00442332, 0x3165f011, 0x00001e03).opcode }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).planes }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).drawdepth }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).dblsrc }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).rgbmode }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).dither }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).logicop }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).compare }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).blend }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).backblend }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).blendalpha }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).fastclear }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).colorhost }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).alphahost }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).enzpattern }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).enlspattern }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).zpopaque }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).lsopaque }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).cidtest }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).shade }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).ciclamp }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).stoponx }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).stopony }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).skipfirst }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).skiplast }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).lsadvlast }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).length32 }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).lronly }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).ystride }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).endptfilter }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).adrmode }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).xyoffset }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).yflip }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).ensmask }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).cid_mask }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).sfactor }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).dfactor }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).rwpacked }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).hostdepth }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).rwdouble }, + { unpack(0x00442332, 0x3165f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0044b312 dm1=0x3065f011 cm=0x00001e03 +unsafe extern "C" fn shader_0044b312_3065f011_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0044b312, 0x3065f011, 0x00001e03).opcode }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).planes }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).drawdepth }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).dblsrc }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).rgbmode }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).dither }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).logicop }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).compare }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).blend }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).backblend }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).blendalpha }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).fastclear }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).colorhost }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).alphahost }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).enzpattern }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).enlspattern }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).zpopaque }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).lsopaque }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).cidtest }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).shade }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).ciclamp }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).stoponx }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).stopony }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).skipfirst }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).skiplast }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).lsadvlast }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).length32 }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).lronly }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).ystride }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).endptfilter }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).adrmode }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).xyoffset }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).yflip }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).ensmask }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).cid_mask }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).sfactor }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).dfactor }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).rwpacked }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).hostdepth }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).rwdouble }, + { unpack(0x0044b312, 0x3065f011, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// dm0=0x0044b312 dm1=0x3065f031 cm=0x00001e03 +unsafe extern "C" fn shader_0044b312_3065f031_00001e03( + ctx: *mut Rex3Context, + fb_rgb: *mut u32, + fb_aux: *mut u32, +) { + let m: ConstMode< + { unpack(0x0044b312, 0x3065f031, 0x00001e03).opcode }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).planes }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).drawdepth }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).dblsrc }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).rgbmode }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).dither }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).logicop }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).compare }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).blend }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).backblend }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).blendalpha }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).fastclear }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).colorhost }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).alphahost }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).enzpattern }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).enlspattern }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).zpopaque }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).lsopaque }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).cidtest }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).shade }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).ciclamp }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).stoponx }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).stopony }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).skipfirst }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).skiplast }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).lsadvlast }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).length32 }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).lronly }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).ystride }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).endptfilter }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).adrmode }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).xyoffset }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).yflip }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).ensmask }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).cid_mask }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).sfactor }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).dfactor }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).rwpacked }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).hostdepth }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).rwdouble }, + { unpack(0x0044b312, 0x3065f031, 0x00001e03).swapendian }, + > = ConstMode; + let fb = Framebuffers { rgb: fb_rgb, aux: fb_aux }; + draw_with_fb(unsafe { &mut *ctx }, &fb, &m); +} + +/// Sorted by key, so the lookup can binary-search. +/// +/// Key is the raw `(dm0, dm1, clipmode & CLIPMODE_JIT_KEY_MASK)` triple — +/// the same key the Cranelift shader cache uses, so both stores answer the +/// same question and a table hit can pre-empt a JIT compile. +pub static SHADERS: &[((u32, u32, u32), ShaderFn)] = &[ + ((0x00000002, 0x3009d011, 0x00001e03), shader_00000002_3009d011_00001e03), + ((0x00000002, 0x3009d031, 0x00001e03), shader_00000002_3009d031_00001e03), + ((0x00000002, 0x3009f011, 0x00001e03), shader_00000002_3009f011_00001e03), + ((0x00000002, 0x3009f031, 0x00001e03), shader_00000002_3009f031_00001e03), + ((0x00000002, 0x3165d011, 0x00001e03), shader_00000002_3165d011_00001e03), + ((0x00000002, 0x3165d031, 0x00001e03), shader_00000002_3165d031_00001e03), + ((0x0000000a, 0x30007109, 0x00001e02), shader_0000000a_30007109_00001e02), + ((0x0000000a, 0x30007109, 0x00001e06), shader_0000000a_30007109_00001e06), + ((0x0000000a, 0x30007109, 0x00001e0e), shader_0000000a_30007109_00001e0e), + ((0x0000000a, 0x30007109, 0x00001e1e), shader_0000000a_30007109_00001e1e), + ((0x0000000a, 0x3000710d, 0x00001e02), shader_0000000a_3000710d_00001e02), + ((0x0000000a, 0x3000710d, 0x00001e1e), shader_0000000a_3000710d_00001e1e), + ((0x0000000a, 0x30007211, 0x00001e02), shader_0000000a_30007211_00001e02), + ((0x0000000a, 0x30007211, 0x00001e1e), shader_0000000a_30007211_00001e1e), + ((0x0000000a, 0x3000f109, 0x00001e02), shader_0000000a_3000f109_00001e02), + ((0x0000000a, 0x3000f109, 0x00001e1e), shader_0000000a_3000f109_00001e1e), + ((0x0000000a, 0x3000f211, 0x00001e02), shader_0000000a_3000f211_00001e02), + ((0x0000000a, 0x3000f211, 0x00001e06), shader_0000000a_3000f211_00001e06), + ((0x0000000a, 0x3000f211, 0x00001e0e), shader_0000000a_3000f211_00001e0e), + ((0x0000000a, 0x3000f211, 0x00001e1e), shader_0000000a_3000f211_00001e1e), + ((0x0000000a, 0x3000f231, 0x00001e02), shader_0000000a_3000f231_00001e02), + ((0x0000000a, 0x3000f231, 0x00001e06), shader_0000000a_3000f231_00001e06), + ((0x0000000a, 0x3000f231, 0x00001e1e), shader_0000000a_3000f231_00001e1e), + ((0x0000000a, 0x3000f319, 0x00001e02), shader_0000000a_3000f319_00001e02), + ((0x0000000a, 0x3000f319, 0x00001e0e), shader_0000000a_3000f319_00001e0e), + ((0x0000000a, 0x3009f011, 0x00001e03), shader_0000000a_3009f011_00001e03), + ((0x0000000a, 0x3009f031, 0x00001e03), shader_0000000a_3009f031_00001e03), + ((0x0000000a, 0x3161f011, 0x00001e03), shader_0000000a_3161f011_00001e03), + ((0x0000000a, 0x3161f031, 0x00000203), shader_0000000a_3161f031_00000203), + ((0x0000000a, 0x3161f031, 0x00001e03), shader_0000000a_3161f031_00001e03), + ((0x0000000a, 0x3165f011, 0x00001e03), shader_0000000a_3165f011_00001e03), + ((0x0000000a, 0x3165f031, 0x00001e03), shader_0000000a_3165f031_00001e03), + ((0x00000022, 0x3065f011, 0x00001e03), shader_00000022_3065f011_00001e03), + ((0x00000022, 0x3065f031, 0x00001e03), shader_00000022_3065f031_00001e03), + ((0x00000022, 0x3161f011, 0x00001e03), shader_00000022_3161f011_00001e03), + ((0x00000045, 0x04007189, 0x00001e00), shader_00000045_04007189_00001e00), + ((0x00000045, 0x0400718d, 0x00001e00), shader_00000045_0400718d_00001e00), + ((0x00000045, 0x0400f189, 0x00001e00), shader_00000045_0400f189_00001e00), + ((0x00000045, 0x0400f291, 0x00001e00), shader_00000045_0400f291_00001e00), + ((0x00000045, 0x0400f399, 0x00001e00), shader_00000045_0400f399_00001e00), + ((0x00000045, 0x34007291, 0x00001e00), shader_00000045_34007291_00001e00), + ((0x00000046, 0x30007189, 0x00001e00), shader_00000046_30007189_00001e00), + ((0x00000046, 0x3000718d, 0x00001e00), shader_00000046_3000718d_00001e00), + ((0x00000046, 0x30007589, 0x00001e00), shader_00000046_30007589_00001e00), + ((0x00000046, 0x30007691, 0x00001e00), shader_00000046_30007691_00001e00), + ((0x00000046, 0x3000f189, 0x00001e00), shader_00000046_3000f189_00001e00), + ((0x00000046, 0x3000f291, 0x00001e00), shader_00000046_3000f291_00001e00), + ((0x00000046, 0x3000f399, 0x00001e00), shader_00000046_3000f399_00001e00), + ((0x00000046, 0x3000f799, 0x00001e00), shader_00000046_3000f799_00001e00), + ((0x00000046, 0x34007291, 0x00001e00), shader_00000046_34007291_00001e00), + ((0x00000065, 0x34007291, 0x00000000), shader_00000065_34007291_00000000), + ((0x00000065, 0x34007291, 0x00001e00), shader_00000065_34007291_00001e00), + ((0x00000066, 0x34007291, 0x00000000), shader_00000066_34007291_00000000), + ((0x00000066, 0x34007291, 0x00001e00), shader_00000066_34007291_00001e00), + ((0x0000008a, 0x3165f011, 0x00001e03), shader_0000008a_3165f011_00001e03), + ((0x0000008a, 0x3165f031, 0x00001e03), shader_0000008a_3165f031_00001e03), + ((0x000000c5, 0x3409f391, 0x00001e03), shader_000000c5_3409f391_00001e03), + ((0x000000c5, 0x3409f3b1, 0x00001e03), shader_000000c5_3409f3b1_00001e03), + ((0x000000c6, 0x30097291, 0x00001e03), shader_000000c6_30097291_00001e03), + ((0x000000c6, 0x3009f391, 0x00001e03), shader_000000c6_3009f391_00001e03), + ((0x000000c6, 0x3009f399, 0x00001e03), shader_000000c6_3009f399_00001e03), + ((0x000000c6, 0x3009f3b1, 0x00001e03), shader_000000c6_3009f3b1_00001e03), + ((0x000000c6, 0x3009f799, 0x00001e03), shader_000000c6_3009f799_00001e03), + ((0x000000c6, 0x3165f7b1, 0x00001e03), shader_000000c6_3165f7b1_00001e03), + ((0x00000102, 0x3000710c, 0x00001e02), shader_00000102_3000710c_00001e02), + ((0x00000102, 0x3000710d, 0x00001e00), shader_00000102_3000710d_00001e00), + ((0x00000102, 0x3000710d, 0x00001e1e), shader_00000102_3000710d_00001e1e), + ((0x00000102, 0x3000f019, 0x00001e00), shader_00000102_3000f019_00001e00), + ((0x00000102, 0x30027109, 0x00001e00), shader_00000102_30027109_00001e00), + ((0x00000102, 0x30027109, 0x00001e02), shader_00000102_30027109_00001e02), + ((0x00000102, 0x3002f109, 0x00001e00), shader_00000102_3002f109_00001e00), + ((0x00000102, 0x3002f109, 0x00001e02), shader_00000102_3002f109_00001e02), + ((0x00000102, 0x3002f109, 0x00001e1e), shader_00000102_3002f109_00001e1e), + ((0x00000102, 0x3002f211, 0x00001e00), shader_00000102_3002f211_00001e00), + ((0x00000102, 0x3002f211, 0x00001e02), shader_00000102_3002f211_00001e02), + ((0x00000102, 0x3002f211, 0x00001e06), shader_00000102_3002f211_00001e06), + ((0x00000102, 0x3002f211, 0x00001e0e), shader_00000102_3002f211_00001e0e), + ((0x00000102, 0x3002f211, 0x00001e1e), shader_00000102_3002f211_00001e1e), + ((0x00000102, 0x3002f231, 0x00001e00), shader_00000102_3002f231_00001e00), + ((0x00000102, 0x3002f231, 0x00001e02), shader_00000102_3002f231_00001e02), + ((0x00000102, 0x3002f231, 0x00001e06), shader_00000102_3002f231_00001e06), + ((0x00000102, 0x3002f231, 0x00001e1e), shader_00000102_3002f231_00001e1e), + ((0x00000102, 0x3002f319, 0x00001e00), shader_00000102_3002f319_00001e00), + ((0x00000102, 0x3002f319, 0x00001e02), shader_00000102_3002f319_00001e02), + ((0x00000102, 0x3002f319, 0x00001e06), shader_00000102_3002f319_00001e06), + ((0x00000102, 0x3002f319, 0x00001e1e), shader_00000102_3002f319_00001e1e), + ((0x00000122, 0x30007109, 0x00001e00), shader_00000122_30007109_00001e00), + ((0x00000122, 0x3000710d, 0x00001e00), shader_00000122_3000710d_00001e00), + ((0x00000122, 0x3000f109, 0x00001e00), shader_00000122_3000f109_00001e00), + ((0x00000122, 0x3000f211, 0x00001e00), shader_00000122_3000f211_00001e00), + ((0x00000122, 0x3000f231, 0x00001e00), shader_00000122_3000f231_00001e00), + ((0x00000122, 0x3000f319, 0x00001e00), shader_00000122_3000f319_00001e00), + ((0x00000145, 0x00007589, 0x00001e00), shader_00000145_00007589_00001e00), + ((0x00000145, 0x0000f799, 0x00001e00), shader_00000145_0000f799_00001e00), + ((0x000001c5, 0x3009f7b1, 0x00001e03), shader_000001c5_3009f7b1_00001e03), + ((0x00000306, 0x3000f019, 0x00000000), shader_00000306_3000f019_00000000), + ((0x00000306, 0x3000f019, 0x00000200), shader_00000306_3000f019_00000200), + ((0x00000306, 0x3000f019, 0x00000400), shader_00000306_3000f019_00000400), + ((0x00000306, 0x3000f019, 0x00000600), shader_00000306_3000f019_00000600), + ((0x00000306, 0x3000f019, 0x00000800), shader_00000306_3000f019_00000800), + ((0x00000306, 0x3000f019, 0x00000a00), shader_00000306_3000f019_00000a00), + ((0x00000306, 0x3000f019, 0x00000c00), shader_00000306_3000f019_00000c00), + ((0x00000306, 0x3000f019, 0x00000e00), shader_00000306_3000f019_00000e00), + ((0x00000306, 0x3000f019, 0x00001000), shader_00000306_3000f019_00001000), + ((0x00000306, 0x3000f019, 0x00001200), shader_00000306_3000f019_00001200), + ((0x00000306, 0x3000f019, 0x00001400), shader_00000306_3000f019_00001400), + ((0x00000306, 0x3000f019, 0x00001600), shader_00000306_3000f019_00001600), + ((0x00000306, 0x3000f019, 0x00001800), shader_00000306_3000f019_00001800), + ((0x00000306, 0x3000f019, 0x00001a00), shader_00000306_3000f019_00001a00), + ((0x00000306, 0x3000f019, 0x00001c00), shader_00000306_3000f019_00001c00), + ((0x00000306, 0x3000f019, 0x00001e00), shader_00000306_3000f019_00001e00), + ((0x00000326, 0x30007109, 0x00001e00), shader_00000326_30007109_00001e00), + ((0x00000326, 0x3000710c, 0x00001e00), shader_00000326_3000710c_00001e00), + ((0x00000326, 0x3000710c, 0x00001e02), shader_00000326_3000710c_00001e02), + ((0x00000326, 0x3000710d, 0x00001e00), shader_00000326_3000710d_00001e00), + ((0x00000326, 0x3000710d, 0x00001e02), shader_00000326_3000710d_00001e02), + ((0x00000326, 0x3000710d, 0x00001e1e), shader_00000326_3000710d_00001e1e), + ((0x00000326, 0x3000710e, 0x00001e00), shader_00000326_3000710e_00001e00), + ((0x00000326, 0x30007319, 0x00001e00), shader_00000326_30007319_00001e00), + ((0x00000326, 0x3000f319, 0x00001e00), shader_00000326_3000f319_00001e00), + ((0x00000326, 0x30017009, 0x00001e03), shader_00000326_30017009_00001e03), + ((0x00000326, 0x3001700c, 0x00001e03), shader_00000326_3001700c_00001e03), + ((0x00000326, 0x30027009, 0x00001e03), shader_00000326_30027009_00001e03), + ((0x00000326, 0x30027109, 0x00001e00), shader_00000326_30027109_00001e00), + ((0x00000326, 0x30027109, 0x00001e02), shader_00000326_30027109_00001e02), + ((0x00000326, 0x30027109, 0x00001e06), shader_00000326_30027109_00001e06), + ((0x00000326, 0x30027109, 0x00001e0e), shader_00000326_30027109_00001e0e), + ((0x00000326, 0x30027109, 0x00001e1e), shader_00000326_30027109_00001e1e), + ((0x00000326, 0x30027211, 0x00001e02), shader_00000326_30027211_00001e02), + ((0x00000326, 0x30027211, 0x00001e1e), shader_00000326_30027211_00001e1e), + ((0x00000326, 0x3002f109, 0x00001e00), shader_00000326_3002f109_00001e00), + ((0x00000326, 0x3002f109, 0x00001e02), shader_00000326_3002f109_00001e02), + ((0x00000326, 0x3002f211, 0x00001e00), shader_00000326_3002f211_00001e00), + ((0x00000326, 0x3002f211, 0x00001e02), shader_00000326_3002f211_00001e02), + ((0x00000326, 0x3002f211, 0x00001e06), shader_00000326_3002f211_00001e06), + ((0x00000326, 0x3002f211, 0x00001e0e), shader_00000326_3002f211_00001e0e), + ((0x00000326, 0x3002f211, 0x00001e1e), shader_00000326_3002f211_00001e1e), + ((0x00000326, 0x3002f231, 0x00001e02), shader_00000326_3002f231_00001e02), + ((0x00000326, 0x3002f231, 0x00001e06), shader_00000326_3002f231_00001e06), + ((0x00000326, 0x3002f231, 0x00001e1e), shader_00000326_3002f231_00001e1e), + ((0x00000326, 0x3002f319, 0x00001e00), shader_00000326_3002f319_00001e00), + ((0x00000326, 0x3002f319, 0x00001e02), shader_00000326_3002f319_00001e02), + ((0x00000326, 0x3002f319, 0x00001e06), shader_00000326_3002f319_00001e06), + ((0x00000326, 0x3002f319, 0x00001e0e), shader_00000326_3002f319_00001e0e), + ((0x00000326, 0x3002f319, 0x00001e1e), shader_00000326_3002f319_00001e1e), + ((0x00000326, 0x3002f399, 0x00001e00), shader_00000326_3002f399_00001e00), + ((0x00000326, 0x3009700c, 0x00001e03), shader_00000326_3009700c_00001e03), + ((0x00000326, 0x3009700d, 0x00001e03), shader_00000326_3009700d_00001e03), + ((0x00000326, 0x3009f011, 0x00001e03), shader_00000326_3009f011_00001e03), + ((0x00000326, 0x3009f031, 0x00001e03), shader_00000326_3009f031_00001e03), + ((0x00000326, 0x3009f391, 0x00001e03), shader_00000326_3009f391_00001e03), + ((0x00000326, 0x3009f3b1, 0x00001e03), shader_00000326_3009f3b1_00001e03), + ((0x00000326, 0x300af009, 0x00000203), shader_00000326_300af009_00000203), + ((0x00000326, 0x300af009, 0x00001e03), shader_00000326_300af009_00001e03), + ((0x00000326, 0x300af011, 0x00000203), shader_00000326_300af011_00000203), + ((0x00000326, 0x300af011, 0x00001e03), shader_00000326_300af011_00001e03), + ((0x00000326, 0x300af019, 0x00000203), shader_00000326_300af019_00000203), + ((0x00000326, 0x300af019, 0x00001e03), shader_00000326_300af019_00001e03), + ((0x00000326, 0x300af031, 0x00000203), shader_00000326_300af031_00000203), + ((0x00000326, 0x300af031, 0x00001e03), shader_00000326_300af031_00001e03), + ((0x00000326, 0x300b7011, 0x00000403), shader_00000326_300b7011_00000403), + ((0x00000326, 0x300b7011, 0x00001e03), shader_00000326_300b7011_00001e03), + ((0x00000326, 0x300b7031, 0x00000403), shader_00000326_300b7031_00000403), + ((0x00000326, 0x300b7031, 0x00001e03), shader_00000326_300b7031_00001e03), + ((0x00000326, 0x300bf011, 0x00001e03), shader_00000326_300bf011_00001e03), + ((0x00000326, 0x300bf019, 0x00001e03), shader_00000326_300bf019_00001e03), + ((0x00000326, 0x300bf019, 0x00001e1f), shader_00000326_300bf019_00001e1f), + ((0x00000326, 0x300bf031, 0x00001e03), shader_00000326_300bf031_00001e03), + ((0x00000326, 0x3161f011, 0x00001e03), shader_00000326_3161f011_00001e03), + ((0x00000326, 0x3161f031, 0x00001e03), shader_00000326_3161f031_00001e03), + ((0x00000326, 0x3162f011, 0x00001e03), shader_00000326_3162f011_00001e03), + ((0x00000326, 0x3162f011, 0x00001e0f), shader_00000326_3162f011_00001e0f), + ((0x00000326, 0x3162f019, 0x00001e03), shader_00000326_3162f019_00001e03), + ((0x00000326, 0x3162f031, 0x00000203), shader_00000326_3162f031_00000203), + ((0x00000326, 0x3162f031, 0x00001e03), shader_00000326_3162f031_00001e03), + ((0x00000326, 0x3162f031, 0x00001e0f), shader_00000326_3162f031_00001e0f), + ((0x00000326, 0x3163f011, 0x00001e03), shader_00000326_3163f011_00001e03), + ((0x00000326, 0x3163f031, 0x00001e03), shader_00000326_3163f031_00001e03), + ((0x00000326, 0x3165f011, 0x00001e03), shader_00000326_3165f011_00001e03), + ((0x00000326, 0x3165f031, 0x00001e03), shader_00000326_3165f031_00001e03), + ((0x00000326, 0x60007211, 0x00001e02), shader_00000326_60007211_00001e02), + ((0x00000326, 0x6000f319, 0x00001e02), shader_00000326_6000f319_00001e02), + ((0x00000326, 0xa000f319, 0x00001e00), shader_00000326_a000f319_00001e00), + ((0x00000327, 0x30007109, 0x00001e00), shader_00000327_30007109_00001e00), + ((0x00000327, 0x3000710d, 0x00001e00), shader_00000327_3000710d_00001e00), + ((0x00000327, 0x3000f019, 0x00000000), shader_00000327_3000f019_00000000), + ((0x00000327, 0x3000f019, 0x00000200), shader_00000327_3000f019_00000200), + ((0x00000327, 0x3000f019, 0x00000400), shader_00000327_3000f019_00000400), + ((0x00000327, 0x3000f019, 0x00000600), shader_00000327_3000f019_00000600), + ((0x00000327, 0x3000f019, 0x00000800), shader_00000327_3000f019_00000800), + ((0x00000327, 0x3000f019, 0x00000a00), shader_00000327_3000f019_00000a00), + ((0x00000327, 0x3000f019, 0x00000c00), shader_00000327_3000f019_00000c00), + ((0x00000327, 0x3000f019, 0x00000e00), shader_00000327_3000f019_00000e00), + ((0x00000327, 0x3000f019, 0x00001000), shader_00000327_3000f019_00001000), + ((0x00000327, 0x3000f019, 0x00001200), shader_00000327_3000f019_00001200), + ((0x00000327, 0x3000f019, 0x00001400), shader_00000327_3000f019_00001400), + ((0x00000327, 0x3000f019, 0x00001600), shader_00000327_3000f019_00001600), + ((0x00000327, 0x3000f019, 0x00001800), shader_00000327_3000f019_00001800), + ((0x00000327, 0x3000f019, 0x00001a00), shader_00000327_3000f019_00001a00), + ((0x00000327, 0x3000f019, 0x00001c00), shader_00000327_3000f019_00001c00), + ((0x00000327, 0x3000f019, 0x00001e00), shader_00000327_3000f019_00001e00), + ((0x00000327, 0x3000f109, 0x00001e00), shader_00000327_3000f109_00001e00), + ((0x00000327, 0x3000f211, 0x00001e00), shader_00000327_3000f211_00001e00), + ((0x00000327, 0x3000f231, 0x00001e00), shader_00000327_3000f231_00001e00), + ((0x00000327, 0x3000f319, 0x00001e00), shader_00000327_3000f319_00001e00), + ((0x00000327, 0x3008f011, 0x00001e03), shader_00000327_3008f011_00001e03), + ((0x00000327, 0x3008f031, 0x00001e03), shader_00000327_3008f031_00001e03), + ((0x0000032a, 0x30007109, 0x00001e02), shader_0000032a_30007109_00001e02), + ((0x0000032a, 0x30007109, 0x00001e06), shader_0000032a_30007109_00001e06), + ((0x0000032a, 0x30007109, 0x00001e0e), shader_0000032a_30007109_00001e0e), + ((0x0000032a, 0x30007109, 0x00001e1e), shader_0000032a_30007109_00001e1e), + ((0x0000032a, 0x3000710d, 0x00001e02), shader_0000032a_3000710d_00001e02), + ((0x0000032a, 0x3000710d, 0x00001e06), shader_0000032a_3000710d_00001e06), + ((0x0000032a, 0x3000710d, 0x00001e0e), shader_0000032a_3000710d_00001e0e), + ((0x0000032a, 0x3000710d, 0x00001e1e), shader_0000032a_3000710d_00001e1e), + ((0x0000032a, 0x30007211, 0x00001e02), shader_0000032a_30007211_00001e02), + ((0x0000032a, 0x30007211, 0x00001e1e), shader_0000032a_30007211_00001e1e), + ((0x0000032a, 0x3000f019, 0x00000000), shader_0000032a_3000f019_00000000), + ((0x0000032a, 0x3000f019, 0x00000200), shader_0000032a_3000f019_00000200), + ((0x0000032a, 0x3000f019, 0x00000400), shader_0000032a_3000f019_00000400), + ((0x0000032a, 0x3000f019, 0x00000600), shader_0000032a_3000f019_00000600), + ((0x0000032a, 0x3000f019, 0x00000800), shader_0000032a_3000f019_00000800), + ((0x0000032a, 0x3000f019, 0x00000a00), shader_0000032a_3000f019_00000a00), + ((0x0000032a, 0x3000f019, 0x00000c00), shader_0000032a_3000f019_00000c00), + ((0x0000032a, 0x3000f019, 0x00000e00), shader_0000032a_3000f019_00000e00), + ((0x0000032a, 0x3000f019, 0x00001000), shader_0000032a_3000f019_00001000), + ((0x0000032a, 0x3000f019, 0x00001200), shader_0000032a_3000f019_00001200), + ((0x0000032a, 0x3000f019, 0x00001400), shader_0000032a_3000f019_00001400), + ((0x0000032a, 0x3000f019, 0x00001600), shader_0000032a_3000f019_00001600), + ((0x0000032a, 0x3000f019, 0x00001800), shader_0000032a_3000f019_00001800), + ((0x0000032a, 0x3000f019, 0x00001a00), shader_0000032a_3000f019_00001a00), + ((0x0000032a, 0x3000f019, 0x00001c00), shader_0000032a_3000f019_00001c00), + ((0x0000032a, 0x3000f019, 0x00001e00), shader_0000032a_3000f019_00001e00), + ((0x0000032a, 0x3000f109, 0x00001e02), shader_0000032a_3000f109_00001e02), + ((0x0000032a, 0x3000f211, 0x00001e02), shader_0000032a_3000f211_00001e02), + ((0x0000032a, 0x3000f211, 0x00001e0e), shader_0000032a_3000f211_00001e0e), + ((0x0000032a, 0x3000f319, 0x00001e02), shader_0000032a_3000f319_00001e02), + ((0x0000032a, 0x3000f319, 0x00001e06), shader_0000032a_3000f319_00001e06), + ((0x0000032a, 0x3000f319, 0x00001e0e), shader_0000032a_3000f319_00001e0e), + ((0x0000032a, 0x3000f319, 0x00001e1e), shader_0000032a_3000f319_00001e1e), + ((0x0000032a, 0x60007211, 0x00001e1e), shader_0000032a_60007211_00001e1e), + ((0x000003c6, 0x3008f391, 0x00001e03), shader_000003c6_3008f391_00001e03), + ((0x000003c6, 0x3008f3b1, 0x00001e03), shader_000003c6_3008f3b1_00001e03), + ((0x000003c6, 0x3009f391, 0x00001e03), shader_000003c6_3009f391_00001e03), + ((0x000003c6, 0x3009f3b1, 0x00001e03), shader_000003c6_3009f3b1_00001e03), + ((0x00000b2a, 0x30007109, 0x00001e02), shader_00000b2a_30007109_00001e02), + ((0x00000b2a, 0x30007109, 0x00001e06), shader_00000b2a_30007109_00001e06), + ((0x00000b2a, 0x30007109, 0x00001e0e), shader_00000b2a_30007109_00001e0e), + ((0x00000b2a, 0x30007109, 0x00001e1e), shader_00000b2a_30007109_00001e1e), + ((0x00000b2a, 0x3000710d, 0x00001e02), shader_00000b2a_3000710d_00001e02), + ((0x00000b2a, 0x3000710d, 0x00001e06), shader_00000b2a_3000710d_00001e06), + ((0x00000b2a, 0x3000710d, 0x00001e0e), shader_00000b2a_3000710d_00001e0e), + ((0x00000b2a, 0x3000710d, 0x00001e1e), shader_00000b2a_3000710d_00001e1e), + ((0x00000b2a, 0x3000f109, 0x00001e02), shader_00000b2a_3000f109_00001e02), + ((0x00000b2a, 0x3000f109, 0x00001e1e), shader_00000b2a_3000f109_00001e1e), + ((0x00000b2a, 0x3000f211, 0x00001e02), shader_00000b2a_3000f211_00001e02), + ((0x00000b2a, 0x3000f211, 0x00001e06), shader_00000b2a_3000f211_00001e06), + ((0x00000b2a, 0x3000f211, 0x00001e0e), shader_00000b2a_3000f211_00001e0e), + ((0x00000b2a, 0x3000f211, 0x00001e1e), shader_00000b2a_3000f211_00001e1e), + ((0x00000b2a, 0x3000f231, 0x00001e02), shader_00000b2a_3000f231_00001e02), + ((0x00000b2a, 0x3000f231, 0x00001e06), shader_00000b2a_3000f231_00001e06), + ((0x00000b2a, 0x3000f231, 0x00001e1e), shader_00000b2a_3000f231_00001e1e), + ((0x00000b2a, 0x3000f319, 0x00001e02), shader_00000b2a_3000f319_00001e02), + ((0x00000b2a, 0x3000f319, 0x00001e06), shader_00000b2a_3000f319_00001e06), + ((0x00000b2a, 0x3000f319, 0x00001e1e), shader_00000b2a_3000f319_00001e1e), + ((0x00000b2a, 0x6000710d, 0x00001e02), shader_00000b2a_6000710d_00001e02), + ((0x00000b2a, 0x6000710d, 0x00001e0e), shader_00000b2a_6000710d_00001e0e), + ((0x00000b2a, 0x6000710d, 0x00001e1e), shader_00000b2a_6000710d_00001e1e), + ((0x00001106, 0x3009700c, 0x00001e03), shader_00001106_3009700c_00001e03), + ((0x00001106, 0x3009700d, 0x00001e03), shader_00001106_3009700d_00001e03), + ((0x00001106, 0x30097011, 0x00000403), shader_00001106_30097011_00000403), + ((0x00001106, 0x30097011, 0x00001e03), shader_00001106_30097011_00001e03), + ((0x00001106, 0x30097031, 0x00000403), shader_00001106_30097031_00000403), + ((0x00001106, 0x30097031, 0x00001e03), shader_00001106_30097031_00001e03), + ((0x00001106, 0x3009f011, 0x00001e03), shader_00001106_3009f011_00001e03), + ((0x00001106, 0x3009f019, 0x00001e03), shader_00001106_3009f019_00001e03), + ((0x00001106, 0x3009f019, 0x00001e1f), shader_00001106_3009f019_00001e1f), + ((0x00001106, 0x3009f031, 0x00001e03), shader_00001106_3009f031_00001e03), + ((0x00001106, 0x3161f011, 0x00001e03), shader_00001106_3161f011_00001e03), + ((0x00001106, 0x3161f031, 0x00001e03), shader_00001106_3161f031_00001e03), + ((0x00001106, 0x3165f011, 0x00001e03), shader_00001106_3165f011_00001e03), + ((0x00001106, 0x3165f031, 0x00001e03), shader_00001106_3165f031_00001e03), + ((0x00001126, 0x3009700d, 0x00001e03), shader_00001126_3009700d_00001e03), + ((0x00001126, 0x30097011, 0x00001e03), shader_00001126_30097011_00001e03), + ((0x00002102, 0x3000f319, 0x00001e00), shader_00002102_3000f319_00001e00), + ((0x00002102, 0x6000f319, 0x00001e00), shader_00002102_6000f319_00001e00), + ((0x00002106, 0x30007109, 0x00001e00), shader_00002106_30007109_00001e00), + ((0x00002106, 0x3000710d, 0x00001e00), shader_00002106_3000710d_00001e00), + ((0x00002106, 0x3000f109, 0x00001e00), shader_00002106_3000f109_00001e00), + ((0x00002106, 0x3000f211, 0x00001e00), shader_00002106_3000f211_00001e00), + ((0x00002106, 0x3000f319, 0x00001e00), shader_00002106_3000f319_00001e00), + ((0x00002106, 0x6000f319, 0x00001e00), shader_00002106_6000f319_00001e00), + ((0x0000232e, 0x3008f011, 0x00001e03), shader_0000232e_3008f011_00001e03), + ((0x0000232e, 0x3008f031, 0x00001e03), shader_0000232e_3008f031_00001e03), + ((0x0000232e, 0x3009700d, 0x00001e03), shader_0000232e_3009700d_00001e03), + ((0x0000232e, 0x30097011, 0x00001e03), shader_0000232e_30097011_00001e03), + ((0x0000232e, 0x30097031, 0x00001e03), shader_0000232e_30097031_00001e03), + ((0x0000232e, 0x3009f011, 0x00001e03), shader_0000232e_3009f011_00001e03), + ((0x0000232e, 0x3009f031, 0x00001e03), shader_0000232e_3009f031_00001e03), + ((0x0000232e, 0x3161f011, 0x00001e03), shader_0000232e_3161f011_00001e03), + ((0x0000232e, 0x3161f031, 0x00001e03), shader_0000232e_3161f031_00001e03), + ((0x00009106, 0x30007109, 0x00001e00), shader_00009106_30007109_00001e00), + ((0x00009106, 0x30007109, 0x00001e02), shader_00009106_30007109_00001e02), + ((0x00009106, 0x30007109, 0x00001e06), shader_00009106_30007109_00001e06), + ((0x00009106, 0x30007109, 0x00001e0e), shader_00009106_30007109_00001e0e), + ((0x00009106, 0x30007109, 0x00001e1e), shader_00009106_30007109_00001e1e), + ((0x00009106, 0x3000710d, 0x00001e02), shader_00009106_3000710d_00001e02), + ((0x00009106, 0x3000710d, 0x00001e06), shader_00009106_3000710d_00001e06), + ((0x00009106, 0x3000710d, 0x00001e0e), shader_00009106_3000710d_00001e0e), + ((0x00009106, 0x3000710d, 0x00001e1e), shader_00009106_3000710d_00001e1e), + ((0x00009106, 0x30007211, 0x00001e02), shader_00009106_30007211_00001e02), + ((0x00009106, 0x30007211, 0x00001e1e), shader_00009106_30007211_00001e1e), + ((0x00009106, 0x3000f109, 0x00001e02), shader_00009106_3000f109_00001e02), + ((0x00009106, 0x3000f211, 0x00001e02), shader_00009106_3000f211_00001e02), + ((0x00009106, 0x3000f211, 0x00001e06), shader_00009106_3000f211_00001e06), + ((0x00009106, 0x3000f211, 0x00001e0e), shader_00009106_3000f211_00001e0e), + ((0x00009106, 0x3000f211, 0x00001e1e), shader_00009106_3000f211_00001e1e), + ((0x00009106, 0x3000f231, 0x00001e02), shader_00009106_3000f231_00001e02), + ((0x00009106, 0x3000f231, 0x00001e06), shader_00009106_3000f231_00001e06), + ((0x00009106, 0x3000f231, 0x00001e1e), shader_00009106_3000f231_00001e1e), + ((0x00009106, 0x3000f319, 0x00001e00), shader_00009106_3000f319_00001e00), + ((0x00009106, 0x3000f319, 0x00001e02), shader_00009106_3000f319_00001e02), + ((0x00009106, 0x3000f319, 0x00001e06), shader_00009106_3000f319_00001e06), + ((0x00009106, 0x3000f319, 0x00001e0e), shader_00009106_3000f319_00001e0e), + ((0x00009106, 0x3000f319, 0x00001e1e), shader_00009106_3000f319_00001e1e), + ((0x00009106, 0x30017009, 0x00001e03), shader_00009106_30017009_00001e03), + ((0x00009106, 0x3009f011, 0x00001e03), shader_00009106_3009f011_00001e03), + ((0x00009106, 0x3009f019, 0x00001e03), shader_00009106_3009f019_00001e03), + ((0x00009106, 0x3009f031, 0x00001e03), shader_00009106_3009f031_00001e03), + ((0x00009106, 0x3161f011, 0x00001e03), shader_00009106_3161f011_00001e03), + ((0x00009106, 0x3161f031, 0x00001e03), shader_00009106_3161f031_00001e03), + ((0x00009106, 0x3165f011, 0x00001e03), shader_00009106_3165f011_00001e03), + ((0x00009106, 0x3165f031, 0x00001e03), shader_00009106_3165f031_00001e03), + ((0x00019106, 0x30007109, 0x00001e00), shader_00019106_30007109_00001e00), + ((0x00019106, 0x3000f319, 0x00001e00), shader_00019106_3000f319_00001e00), + ((0x00022102, 0x30007109, 0x00001e00), shader_00022102_30007109_00001e00), + ((0x00022102, 0x3000710d, 0x00001e00), shader_00022102_3000710d_00001e00), + ((0x00022102, 0x3000f109, 0x00001e00), shader_00022102_3000f109_00001e00), + ((0x00022102, 0x3000f211, 0x00001e00), shader_00022102_3000f211_00001e00), + ((0x00022102, 0x3000f231, 0x00001e00), shader_00022102_3000f231_00001e00), + ((0x00022102, 0x3000f319, 0x00001e00), shader_00022102_3000f319_00001e00), + ((0x00022106, 0x30007109, 0x00001e00), shader_00022106_30007109_00001e00), + ((0x00022106, 0x3000f319, 0x00001e00), shader_00022106_3000f319_00001e00), + ((0x00040022, 0x3009d011, 0x00001e03), shader_00040022_3009d011_00001e03), + ((0x00040022, 0x3009d031, 0x00001e03), shader_00040022_3009d031_00001e03), + ((0x00040022, 0x3009f011, 0x00001e03), shader_00040022_3009f011_00001e03), + ((0x00040022, 0x3009f031, 0x00001e03), shader_00040022_3009f031_00001e03), + ((0x00040022, 0x3165d011, 0x00001e03), shader_00040022_3165d011_00001e03), + ((0x00040022, 0x3165d031, 0x00001e03), shader_00040022_3165d031_00001e03), + ((0x00040102, 0x3000f019, 0x00001e00), shader_00040102_3000f019_00001e00), + ((0x00040122, 0x3009f011, 0x00001e03), shader_00040122_3009f011_00001e03), + ((0x00040122, 0x3165f011, 0x00001e03), shader_00040122_3165f011_00001e03), + ((0x00040122, 0x3165f011, 0x00001e0f), shader_00040122_3165f011_00001e0f), + ((0x00040122, 0x3165f031, 0x00001e03), shader_00040122_3165f031_00001e03), + ((0x00040122, 0x3165f031, 0x00001e0f), shader_00040122_3165f031_00001e0f), + ((0x0004212e, 0x3009f011, 0x00001e03), shader_0004212e_3009f011_00001e03), + ((0x0004212e, 0x3009f031, 0x00001e03), shader_0004212e_3009f031_00001e03), + ((0x0004222e, 0x30097011, 0x00001e03), shader_0004222e_30097011_00001e03), + ((0x0004222e, 0x30097031, 0x00001e03), shader_0004222e_30097031_00001e03), + ((0x0004222e, 0x3009f011, 0x00001e03), shader_0004222e_3009f011_00001e03), + ((0x0004222e, 0x3009f031, 0x00001e03), shader_0004222e_3009f031_00001e03), + ((0x0004232e, 0x3009700c, 0x00001e03), shader_0004232e_3009700c_00001e03), + ((0x0004232e, 0x3009700d, 0x00001e03), shader_0004232e_3009700d_00001e03), + ((0x0004232e, 0x30097011, 0x00000403), shader_0004232e_30097011_00000403), + ((0x0004232e, 0x30097011, 0x00001e03), shader_0004232e_30097011_00001e03), + ((0x0004232e, 0x30097031, 0x00000403), shader_0004232e_30097031_00000403), + ((0x0004232e, 0x30097031, 0x00001e03), shader_0004232e_30097031_00001e03), + ((0x0004232e, 0x3009f011, 0x00001e03), shader_0004232e_3009f011_00001e03), + ((0x0004232e, 0x3009f019, 0x00001e03), shader_0004232e_3009f019_00001e03), + ((0x0004232e, 0x3009f031, 0x00001e03), shader_0004232e_3009f031_00001e03), + ((0x0004232e, 0x3165f031, 0x00001e03), shader_0004232e_3165f031_00001e03), + ((0x00042332, 0x3009f011, 0x00001e03), shader_00042332_3009f011_00001e03), + ((0x00042332, 0x3009f031, 0x00001e03), shader_00042332_3009f031_00001e03), + ((0x00042332, 0x3165f011, 0x00001e03), shader_00042332_3165f011_00001e03), + ((0x00049102, 0x3000f019, 0x00001e00), shader_00049102_3000f019_00001e00), + ((0x00049122, 0x3009f011, 0x00001e03), shader_00049122_3009f011_00001e03), + ((0x00049122, 0x3009f031, 0x00001e03), shader_00049122_3009f031_00001e03), + ((0x00049122, 0x3165f011, 0x00001e03), shader_00049122_3165f011_00001e03), + ((0x00049122, 0x3165f011, 0x00001e0f), shader_00049122_3165f011_00001e0f), + ((0x00049122, 0x3165f031, 0x00001e03), shader_00049122_3165f031_00001e03), + ((0x00049122, 0x3165f031, 0x00001e0f), shader_00049122_3165f031_00001e0f), + ((0x0004930e, 0x3009f011, 0x00001e03), shader_0004930e_3009f011_00001e03), + ((0x0004930e, 0x3009f031, 0x00001e03), shader_0004930e_3009f031_00001e03), + ((0x0004930e, 0x3165f011, 0x00001e03), shader_0004930e_3165f011_00001e03), + ((0x0004930e, 0x3165f031, 0x00001e03), shader_0004930e_3165f031_00001e03), + ((0x0004b312, 0x3009f011, 0x00001e03), shader_0004b312_3009f011_00001e03), + ((0x0004b312, 0x3009f031, 0x00001e03), shader_0004b312_3009f031_00001e03), + ((0x00080122, 0x3008f011, 0x00001e03), shader_00080122_3008f011_00001e03), + ((0x00080122, 0x3008f031, 0x00001e03), shader_00080122_3008f031_00001e03), + ((0x00080122, 0x3009700c, 0x00001e03), shader_00080122_3009700c_00001e03), + ((0x00080122, 0x3009700d, 0x00001e03), shader_00080122_3009700d_00001e03), + ((0x00080122, 0x30097011, 0x00001e03), shader_00080122_30097011_00001e03), + ((0x00080122, 0x30097031, 0x00001e03), shader_00080122_30097031_00001e03), + ((0x00080122, 0x3009f011, 0x00001e03), shader_00080122_3009f011_00001e03), + ((0x00080122, 0x3009f031, 0x00001e03), shader_00080122_3009f031_00001e03), + ((0x00080122, 0x3161f011, 0x00001e03), shader_00080122_3161f011_00001e03), + ((0x00080122, 0x3161f031, 0x00001e03), shader_00080122_3161f031_00001e03), + ((0x00081102, 0x30097011, 0x00001e03), shader_00081102_30097011_00001e03), + ((0x000c0122, 0x3009700d, 0x00001e03), shader_000c0122_3009700d_00001e03), + ((0x000c0122, 0x30097011, 0x00001e03), shader_000c0122_30097011_00001e03), + ((0x000c0122, 0x30097031, 0x00001e03), shader_000c0122_30097031_00001e03), + ((0x000c0122, 0x3009f011, 0x00001e03), shader_000c0122_3009f011_00001e03), + ((0x000c0122, 0x3009f019, 0x00001e03), shader_000c0122_3009f019_00001e03), + ((0x000c0122, 0x3009f031, 0x00001e03), shader_000c0122_3009f031_00001e03), + ((0x000c1122, 0x3009700d, 0x00001e03), shader_000c1122_3009700d_00001e03), + ((0x000c9102, 0x3009f011, 0x00001e03), shader_000c9102_3009f011_00001e03), + ((0x000c9102, 0x3009f031, 0x00001e03), shader_000c9102_3009f031_00001e03), + ((0x000c9102, 0x3065f011, 0x00001e03), shader_000c9102_3065f011_00001e03), + ((0x000c9102, 0x3065f031, 0x00001e03), shader_000c9102_3065f031_00001e03), + ((0x00200b2e, 0x30017009, 0x00001e03), shader_00200b2e_30017009_00001e03), + ((0x00200b2e, 0x3009f011, 0x00000203), shader_00200b2e_3009f011_00000203), + ((0x00200b2e, 0x3009f011, 0x00001e03), shader_00200b2e_3009f011_00001e03), + ((0x00200b2e, 0x3009f031, 0x00000203), shader_00200b2e_3009f031_00000203), + ((0x00200b2e, 0x3009f031, 0x00001e03), shader_00200b2e_3009f031_00001e03), + ((0x00200b2e, 0x3161f011, 0x00001e03), shader_00200b2e_3161f011_00001e03), + ((0x00200b2e, 0x3161f031, 0x00001e03), shader_00200b2e_3161f031_00001e03), + ((0x00240b2e, 0x3009f011, 0x00001e03), shader_00240b2e_3009f011_00001e03), + ((0x00240b2e, 0x3009f031, 0x00001e03), shader_00240b2e_3009f031_00001e03), + ((0x00249b0e, 0x3161f011, 0x00001e03), shader_00249b0e_3161f011_00001e03), + ((0x00249b0e, 0x3161f031, 0x00001e03), shader_00249b0e_3161f031_00001e03), + ((0x00280126, 0x30017009, 0x00001e03), shader_00280126_30017009_00001e03), + ((0x00280126, 0x3009f011, 0x00000203), shader_00280126_3009f011_00000203), + ((0x00280126, 0x3009f011, 0x00001e03), shader_00280126_3009f011_00001e03), + ((0x00280126, 0x3009f019, 0x00000003), shader_00280126_3009f019_00000003), + ((0x00280126, 0x3009f019, 0x00001e03), shader_00280126_3009f019_00001e03), + ((0x00280126, 0x3009f031, 0x00000203), shader_00280126_3009f031_00000203), + ((0x00280126, 0x3009f031, 0x00001e03), shader_00280126_3009f031_00001e03), + ((0x00280126, 0x3161f011, 0x00001e03), shader_00280126_3161f011_00001e03), + ((0x00280126, 0x3161f031, 0x00000203), shader_00280126_3161f031_00000203), + ((0x00280126, 0x3161f031, 0x00001e03), shader_00280126_3161f031_00001e03), + ((0x00280126, 0x3165f011, 0x00001e03), shader_00280126_3165f011_00001e03), + ((0x00280126, 0x3165f019, 0x00000203), shader_00280126_3165f019_00000203), + ((0x00280126, 0x3165f019, 0x00001e03), shader_00280126_3165f019_00001e03), + ((0x00280126, 0x3165f031, 0x00001e03), shader_00280126_3165f031_00001e03), + ((0x002c0126, 0x3009f009, 0x00000203), shader_002c0126_3009f009_00000203), + ((0x002c0126, 0x3009f009, 0x00001e03), shader_002c0126_3009f009_00001e03), + ((0x002c0126, 0x3009f011, 0x00000203), shader_002c0126_3009f011_00000203), + ((0x002c0126, 0x3009f011, 0x00001e03), shader_002c0126_3009f011_00001e03), + ((0x002c0126, 0x3009f031, 0x00000203), shader_002c0126_3009f031_00000203), + ((0x002c0126, 0x3009f031, 0x00001e03), shader_002c0126_3009f031_00001e03), + ((0x002c0126, 0x3165f011, 0x00001e03), shader_002c0126_3165f011_00001e03), + ((0x002c0126, 0x3165f031, 0x00001e03), shader_002c0126_3165f031_00001e03), + ((0x002c9126, 0x3009f009, 0x00001e03), shader_002c9126_3009f009_00001e03), + ((0x002c9126, 0x3009f009, 0x00001e07), shader_002c9126_3009f009_00001e07), + ((0x002c9126, 0x3009f011, 0x00001e03), shader_002c9126_3009f011_00001e03), + ((0x002c9126, 0x3009f031, 0x00001e03), shader_002c9126_3009f031_00001e03), + ((0x002c9126, 0x3061f011, 0x00001e03), shader_002c9126_3061f011_00001e03), + ((0x002c9126, 0x3061f031, 0x00001e03), shader_002c9126_3061f031_00001e03), + ((0x002c9126, 0x3161f011, 0x00001e03), shader_002c9126_3161f011_00001e03), + ((0x002c9126, 0x3161f011, 0x00001e0f), shader_002c9126_3161f011_00001e0f), + ((0x002c9126, 0x3161f031, 0x00000203), shader_002c9126_3161f031_00000203), + ((0x002c9126, 0x3161f031, 0x00001e03), shader_002c9126_3161f031_00001e03), + ((0x002c9126, 0x3161f031, 0x00001e0f), shader_002c9126_3161f031_00001e0f), + ((0x002c9126, 0x3165f011, 0x00001e03), shader_002c9126_3165f011_00001e03), + ((0x002c9126, 0x3165f031, 0x00001e03), shader_002c9126_3165f031_00001e03), + ((0x00400b32, 0x3165f019, 0x00000203), shader_00400b32_3165f019_00000203), + ((0x00400b32, 0x3165f019, 0x00001e03), shader_00400b32_3165f019_00001e03), + ((0x00440b32, 0x3165f011, 0x00001e03), shader_00440b32_3165f011_00001e03), + ((0x00440b32, 0x3165f031, 0x00001e03), shader_00440b32_3165f031_00001e03), + ((0x00442332, 0x3165f011, 0x00001e03), shader_00442332_3165f011_00001e03), + ((0x0044b312, 0x3065f011, 0x00001e03), shader_0044b312_3065f011_00001e03), + ((0x0044b312, 0x3065f031, 0x00001e03), shader_0044b312_3065f031_00001e03), +]; + +/// Look up a specialised shader for this draw mode. +#[inline] +pub fn lookup(dm0: u32, dm1: u32, cm: u32) -> Option { + SHADERS + .binary_search_by_key(&(dm0, dm1, cm), |&(k, _)| k) + .ok() + .map(|i| SHADERS[i].1) +} diff --git a/src/rex3_shape.rs b/src/rex3_shape.rs new file mode 100644 index 00000000..e5408b43 --- /dev/null +++ b/src/rex3_shape.rs @@ -0,0 +1,567 @@ +//! Canonical decoding of the REX3 draw-mode registers. +//! +//! One place that answers "what shape of draw is this?", so the interpreter, the +//! Cranelift JIT and (later) the generated monomorphised draw table all agree by +//! construction instead of by three hand-kept copies. +//! +//! Today this holds only `normalize_dm1`. The field extractors and the +//! `unpack()` that feeds the const-generic draw path land in the next stage. + +use crate::rex3::{ + CLIPMODE_CIDMATCH_SHIFT, CLIPMODE_ENSMASK_MASK, DRAWMODE0_OPCODE_DRAW, + DRAWMODE0_OPCODE_READ, DRAWMODE0_OPCODE_SCR2SCR, +}; + +/// DRAWMODE1 bit 16 — DITHER. +const DM1_DITHER: u32 = 1 << 16; +/// DRAWMODE1 bit 17 — FASTCLEAR. +const DM1_FASTCLEAR: u32 = 1 << 17; +/// DRAWMODE1 bit 18 — BLEND. +const DM1_BLEND: u32 = 1 << 18; + +// ── DRAWMODE0 field extractors ─────────────────────────────────────────────── +// Bit positions mirror the `DrawMode0` bitfield in rex3.rs. These are `const fn` +// so they work in const contexts, in the JIT's runtime code, and as the source +// of the constants baked into the generated draw table. + +#[inline(always)] pub const fn dm0_opcode(v: u32) -> u32 { v & 0x3 } +#[inline(always)] pub const fn dm0_adrmode(v: u32) -> u32 { (v >> 2) & 0x7 } +#[inline(always)] pub const fn dm0_dosetup(v: u32) -> u32 { (v >> 5) & 1 } +#[inline(always)] pub const fn dm0_colorhost(v: u32) -> u32 { (v >> 6) & 1 } +#[inline(always)] pub const fn dm0_alphahost(v: u32) -> u32 { (v >> 7) & 1 } +#[inline(always)] pub const fn dm0_stoponx(v: u32) -> u32 { (v >> 8) & 1 } +#[inline(always)] pub const fn dm0_stopony(v: u32) -> u32 { (v >> 9) & 1 } +#[inline(always)] pub const fn dm0_skipfirst(v: u32) -> u32 { (v >> 10) & 1 } +#[inline(always)] pub const fn dm0_skiplast(v: u32) -> u32 { (v >> 11) & 1 } +#[inline(always)] pub const fn dm0_enzpattern(v: u32) -> u32 { (v >> 12) & 1 } +#[inline(always)] pub const fn dm0_enlspattern(v: u32) -> u32 { (v >> 13) & 1 } +#[inline(always)] pub const fn dm0_lsadvlast(v: u32) -> u32 { (v >> 14) & 1 } +#[inline(always)] pub const fn dm0_length32(v: u32) -> u32 { (v >> 15) & 1 } +#[inline(always)] pub const fn dm0_zpopaque(v: u32) -> u32 { (v >> 16) & 1 } +#[inline(always)] pub const fn dm0_lsopaque(v: u32) -> u32 { (v >> 17) & 1 } +#[inline(always)] pub const fn dm0_shade(v: u32) -> u32 { (v >> 18) & 1 } +#[inline(always)] pub const fn dm0_lronly(v: u32) -> u32 { (v >> 19) & 1 } +#[inline(always)] pub const fn dm0_xyoffset(v: u32) -> u32 { (v >> 20) & 1 } +#[inline(always)] pub const fn dm0_ciclamp(v: u32) -> u32 { (v >> 21) & 1 } +#[inline(always)] pub const fn dm0_endptfilter(v: u32) -> u32 { (v >> 22) & 1 } +#[inline(always)] pub const fn dm0_ystride(v: u32) -> u32 { (v >> 23) & 1 } + +// ── DRAWMODE1 field extractors ─────────────────────────────────────────────── + +#[inline(always)] pub const fn dm1_planes(v: u32) -> u32 { v & 0x7 } +#[inline(always)] pub const fn dm1_drawdepth(v: u32) -> u32 { (v >> 3) & 0x3 } +#[inline(always)] pub const fn dm1_dblsrc(v: u32) -> u32 { (v >> 5) & 1 } +#[inline(always)] pub const fn dm1_yflip(v: u32) -> u32 { (v >> 6) & 1 } +#[inline(always)] pub const fn dm1_rwpacked(v: u32) -> u32 { (v >> 7) & 1 } +#[inline(always)] pub const fn dm1_hostdepth(v: u32) -> u32 { (v >> 8) & 0x3 } +#[inline(always)] pub const fn dm1_rwdouble(v: u32) -> u32 { (v >> 10) & 1 } +#[inline(always)] pub const fn dm1_swapendian(v: u32) -> u32 { (v >> 11) & 1 } +#[inline(always)] pub const fn dm1_compare(v: u32) -> u32 { (v >> 12) & 0x7 } +#[inline(always)] pub const fn dm1_rgbmode(v: u32) -> u32 { (v >> 15) & 1 } +#[inline(always)] pub const fn dm1_dither(v: u32) -> u32 { (v >> 16) & 1 } +#[inline(always)] pub const fn dm1_fastclear(v: u32) -> u32 { (v >> 17) & 1 } +#[inline(always)] pub const fn dm1_blend(v: u32) -> u32 { (v >> 18) & 1 } +#[inline(always)] pub const fn dm1_sfactor(v: u32) -> u32 { (v >> 19) & 0x7 } +#[inline(always)] pub const fn dm1_dfactor(v: u32) -> u32 { (v >> 22) & 0x7 } +#[inline(always)] pub const fn dm1_backblend(v: u32) -> u32 { (v >> 25) & 1 } +#[inline(always)] pub const fn dm1_prefetch(v: u32) -> u32 { (v >> 26) & 1 } +#[inline(always)] pub const fn dm1_blendalpha(v: u32) -> u32 { (v >> 27) & 1 } +#[inline(always)] pub const fn dm1_logicop(v: u32) -> u32 { (v >> 28) & 0xF } + +/// Host pixels per 64-bit host word. Lifted from `Rex3::host_setup`, which the +/// JIT's `Dm1::host_count` used to duplicate by hand. +#[inline(always)] +pub const fn host_count(dm1: u32) -> u32 { + if dm1_rwpacked(dm1) == 0 { + return 1; + } + let depth = dm1_hostdepth(dm1); + if dm1_rwdouble(dm1) != 0 { + match depth { 0 | 1 => 8, 2 => 4, 3 => 2, _ => 1 } + } else { + match depth { 0 | 1 => 4, 2 => 2, 3 => 1, _ => 1 } + } +} + +/// Bits per host pixel slot. Lifted from `Rex3::host_setup`. +#[inline(always)] +pub const fn host_shift(dm1: u32) -> u32 { + if dm1_rwpacked(dm1) == 0 { + return 0; + } + match dm1_hostdepth(dm1) { 0 | 1 => 8, 2 => 16, 3 => 32, _ => 0 } +} + +/// Canonical DRAWMODE1 for keying and specialization. +/// +/// Folds out fields that are redundant with other state, so a draw that behaves +/// identically always produces the same key — whichever engine asks: +/// +/// - **FASTCLEAR clears BLEND.** Hardware ignores blending when fastclear is set. +/// - **SCR2SCR clears DITHER.** A screen-to-screen copy moves already-quantized +/// pixels; dithering them again would corrupt the copy. +/// +/// The two are ordered, not combined: fastclear wins, matching the JIT's +/// `compile_shader` and the dispatch key it has to agree with. +/// +/// **Scope note.** FASTCLEAR kills much more than BLEND. Per `rex3.pdf` §3.5.5: +/// "No support for any per pixel operations, such as shade, stipple, dither, +/// blend. Flat fill only, via value previously written by host into the +/// COLORVRAM register." Restricted to OPCODE=draw with ADRMODE=block or span, +/// left-to-right spans only. +/// +/// IRIS matches: `process_pixel_fastclear` is address-then-write, with the +/// colour from `ctx.colorvram` (see `fastclear_color`) — no destination read, +/// logic op, afunction, host fetch, shade DDA or dither. The JIT agrees and adds +/// that `colorhost` beats fastclear (`dm1.fastclear() && !is_hostw`) and that +/// fastclear forces `compare = 7`. +/// +/// MAME (`newport.cpp` ~3392) does **not** match the spec here: it uses the +/// fastclear bit only to suppress the shade/rgb colour path, falls back to +/// COLORI rather than COLORVRAM, and still evaluates stipple and the opaque +/// path. Not a usable reference for this mode. +/// +/// Only the BLEND fold lives here, because this function is currently the key +/// for `planes_setup`, whose other inputs (logicop, dither, compare, drawdepth, +/// rgbmode) still have to be honoured for non-fastclear draws sharing the cache +/// slot. The rest of the fastclear folding belongs in `unpack()`, where it can +/// zero LOGICOP/COMPARE/DITHER/SFACTOR/DFACTOR/host fields for the +/// monomorphisation key and collapse every fastclear variant onto one body. +#[inline] +pub const fn normalize_dm1(dm1: u32, opcode: u32) -> u32 { + if dm1 & DM1_FASTCLEAR != 0 { + dm1 & !DM1_BLEND + } else if opcode == DRAWMODE0_OPCODE_SCR2SCR { + dm1 & !DM1_DITHER + } else { + dm1 + } +} + +/// Decode `(dm0, dm1, clipmode)` into the canonical shape. +/// +/// Canonicalisation — folding dead fields to a fixed value — is what keeps the +/// table small. Without it, drawmodes that generate byte-identical code become +/// distinct monomorphisations, because drivers leave stale bits in fields the +/// current mode ignores. +pub const fn unpack(dm0: u32, dm1: u32, clipmode: u32) -> crate::rex3_generic::DynMode { + let opcode = dm0_opcode(dm0); + let dm1 = normalize_dm1(dm1, opcode); + + let colorhost = dm0_colorhost(dm0); + let alphahost = dm0_alphahost(dm0); + let is_host = colorhost != 0 || alphahost != 0 || opcode == DRAWMODE0_OPCODE_READ; + + let cidtest = if (clipmode >> CLIPMODE_CIDMATCH_SHIFT) & 0xF == 0xF { 0 } else { 1 }; + + // FASTCLEAR collapses the whole pixel pipeline (rex3.pdf §3.5.5: "No support + // for any per pixel operation ... Flat fill only, via COLORVRAM"), but only + // where hardware actually honours it: DRAW + block/span, CID checking off, + // and not overridden by colorhost. Outside that it is an ordinary draw and + // every field below stays live. + let fastclear_active = dm1_fastclear(dm1) != 0 + && opcode == DRAWMODE0_OPCODE_DRAW + && cidtest == 0 + && colorhost == 0; + + // Blend inputs are dead unless blending; logicop is dead when blending, + // since the blended value is written directly. + let blend = if fastclear_active { 0 } else { dm1_blend(dm1) }; + let blending = blend != 0; + + crate::rex3_generic::DynMode { + opcode, + planes: dm1_planes(dm1), + drawdepth: dm1_drawdepth(dm1), + dblsrc: dm1_dblsrc(dm1), + rgbmode: dm1_rgbmode(dm1), + dither: if fastclear_active { 0 } else { dm1_dither(dm1) }, + fastclear: if fastclear_active { 1 } else { 0 }, + blend, + backblend: if blending { dm1_backblend(dm1) } else { 0 }, + blendalpha: if blending { dm1_blendalpha(dm1) } else { 0 }, + // Fastclear writes COLORVRAM unconditionally; blending bypasses the + // logic op. Either way the selector stops selecting anything. + logicop: if fastclear_active || blending { 0 } else { dm1_logicop(dm1) }, + // Fastclear bypasses afunction (the JIT forces compare=7 for it). + // 7 is "always pass", i.e. the disabled encoding. + compare: if fastclear_active { 7 } else { dm1_compare(dm1) }, + colorhost, + alphahost, + enzpattern: if fastclear_active { 0 } else { dm0_enzpattern(dm0) }, + enlspattern: if fastclear_active { 0 } else { dm0_enlspattern(dm0) }, + zpopaque: if fastclear_active { 0 } else { dm0_zpopaque(dm0) }, + lsopaque: if fastclear_active { 0 } else { dm0_lsopaque(dm0) }, + shade: if fastclear_active { 0 } else { dm0_shade(dm0) }, + // CICLAMP only governs the CI shade paths. + ciclamp: if dm0_shade(dm0) != 0 && !fastclear_active { dm0_ciclamp(dm0) } else { 0 }, + ystride: dm0_ystride(dm0), + lronly: dm0_lronly(dm0), + length32: dm0_length32(dm0), + stoponx: dm0_stoponx(dm0), + stopony: dm0_stopony(dm0), + skipfirst: dm0_skipfirst(dm0), + skiplast: dm0_skiplast(dm0), + // Stipple-advance and endpoint filtering only mean anything on lines. + lsadvlast: if dm0_enlspattern(dm0) != 0 && !fastclear_active { dm0_lsadvlast(dm0) } else { 0 }, + endptfilter: dm0_endptfilter(dm0), + adrmode: dm0_adrmode(dm0), + xyoffset: dm0_xyoffset(dm0), + yflip: dm1_yflip(dm1), + ensmask: clipmode & CLIPMODE_ENSMASK_MASK, + cid_mask: (clipmode >> CLIPMODE_CIDMATCH_SHIFT) & 0xF, + sfactor: if blending { dm1_sfactor(dm1) } else { 0 }, + dfactor: if blending { dm1_dfactor(dm1) } else { 0 }, + rwpacked: if is_host { dm1_rwpacked(dm1) } else { 0 }, + hostdepth: if is_host { dm1_hostdepth(dm1) } else { 0 }, + rwdouble: if is_host { dm1_rwdouble(dm1) } else { 0 }, + swapendian: if is_host { dm1_swapendian(dm1) } else { 0 }, + // Host transfer shape is dead when no host pixels move. + cidtest, + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::rex3::{DrawMode0, DrawMode1, CLIPMODE_CIDMATCH_MASK}; + + /// The expression `execute_go` and `compile_shader` each spelled out inline + /// before this module existed. Kept verbatim as the oracle so the shared + /// function is pinned to the behaviour the JIT key already depended on. + fn legacy_jit_norm(dm1: u32, opcode: u32) -> u32 { + if dm1 & (1 << 17) != 0 { + dm1 & !(1 << 18) + } else if opcode == DRAWMODE0_OPCODE_SCR2SCR { + dm1 & !(1 << 16) + } else { + dm1 + } + } + + #[test] + fn matches_legacy_jit_normalization() { + // Walk the three bits that matter against every opcode, plus a spread of + // unrelated bit patterns to prove nothing else is disturbed. + for extra in [0x0000_0000, 0xFFFF_FFFF, 0x3000_F019, 0x5A5A_5A5A, 0x0007_0000] { + for bits in 0..8u32 { + let dm1 = extra + | if bits & 1 != 0 { DM1_DITHER } else { 0 } + | if bits & 2 != 0 { DM1_FASTCLEAR } else { 0 } + | if bits & 4 != 0 { DM1_BLEND } else { 0 }; + for opcode in [ + DRAWMODE0_OPCODE_DRAW, + DRAWMODE0_OPCODE_SCR2SCR, + DRAWMODE0_OPCODE_READ, + ] { + assert_eq!( + normalize_dm1(dm1, opcode), + legacy_jit_norm(dm1, opcode), + "dm1={dm1:#010x} opcode={opcode}" + ); + } + } + } + } + + #[test] + fn fastclear_beats_scr2scr() { + // Both conditions true: fastclear must win, so BLEND clears and DITHER + // survives. Getting this order wrong is invisible until a fastclear + // scr2scr draw keys differently in two engines. + let dm1 = DM1_FASTCLEAR | DM1_BLEND | DM1_DITHER; + let got = normalize_dm1(dm1, DRAWMODE0_OPCODE_SCR2SCR); + assert_eq!(got & DM1_BLEND, 0, "fastclear must clear blend"); + assert_eq!(got & DM1_DITHER, DM1_DITHER, "dither must survive fastclear"); + } + + #[test] + fn leaves_unrelated_modes_alone() { + let dm1 = 0x3000_F019; + assert_eq!(normalize_dm1(dm1, DRAWMODE0_OPCODE_DRAW), dm1); + } + + /// Sample values that exercise every bit position: all-clear, all-set, each + /// single bit alone, and a few real drawmodes from the saved corpus. + fn samples() -> Vec { + let mut v = vec![0x0000_0000, 0xFFFF_FFFF, 0x3000_F019, 0x0306, 0x0327, 0x032A]; + for bit in 0..32 { + v.push(1 << bit); + v.push(!(1u32 << bit)); + } + v + } + + /// The extractors must agree with the `bitfield!` accessors they are going to + /// replace. This is the entire correctness basis for the migration: if a + /// shift or mask is off by one, the generated table bakes the wrong constant + /// into every shader and the failure is silent. + #[test] + fn extractors_match_bitfield_accessors() { + for v in samples() { + let d0 = DrawMode0(v); + assert_eq!(dm0_opcode(v), d0.opcode(), "opcode {v:#010x}"); + assert_eq!(dm0_adrmode(v), d0.adrmode(), "adrmode {v:#010x}"); + assert_eq!(dm0_dosetup(v), d0.dosetup() as u32, "dosetup {v:#010x}"); + assert_eq!(dm0_colorhost(v), d0.colorhost() as u32, "colorhost {v:#010x}"); + assert_eq!(dm0_alphahost(v), d0.alphahost() as u32, "alphahost {v:#010x}"); + assert_eq!(dm0_stoponx(v), d0.stoponx() as u32, "stoponx {v:#010x}"); + assert_eq!(dm0_stopony(v), d0.stopony() as u32, "stopony {v:#010x}"); + assert_eq!(dm0_skipfirst(v), d0.skipfirst() as u32, "skipfirst {v:#010x}"); + assert_eq!(dm0_skiplast(v), d0.skiplast() as u32, "skiplast {v:#010x}"); + assert_eq!(dm0_enzpattern(v), d0.enzpattern() as u32, "enzpattern {v:#010x}"); + assert_eq!(dm0_enlspattern(v), d0.enlspattern() as u32, "enlspattern {v:#010x}"); + assert_eq!(dm0_lsadvlast(v), d0.lsadvlast() as u32, "lsadvlast {v:#010x}"); + assert_eq!(dm0_length32(v), d0.length32() as u32, "length32 {v:#010x}"); + assert_eq!(dm0_zpopaque(v), d0.zpopaque() as u32, "zpopaque {v:#010x}"); + assert_eq!(dm0_lsopaque(v), d0.lsopaque() as u32, "lsopaque {v:#010x}"); + assert_eq!(dm0_shade(v), d0.shade() as u32, "shade {v:#010x}"); + assert_eq!(dm0_lronly(v), d0.lronly() as u32, "lronly {v:#010x}"); + assert_eq!(dm0_xyoffset(v), d0.xyoffset() as u32, "xyoffset {v:#010x}"); + assert_eq!(dm0_ciclamp(v), d0.ciclamp() as u32, "ciclamp {v:#010x}"); + assert_eq!(dm0_endptfilter(v), d0.endptfilter() as u32, "endptfilter {v:#010x}"); + assert_eq!(dm0_ystride(v), d0.ystride() as u32, "ystride {v:#010x}"); + + let d1 = DrawMode1(v); + assert_eq!(dm1_planes(v), d1.planes(), "planes {v:#010x}"); + assert_eq!(dm1_drawdepth(v), d1.drawdepth(), "drawdepth {v:#010x}"); + assert_eq!(dm1_dblsrc(v), d1.dblsrc() as u32, "dblsrc {v:#010x}"); + assert_eq!(dm1_yflip(v), d1.yflip() as u32, "yflip {v:#010x}"); + assert_eq!(dm1_rwpacked(v), d1.rwpacked() as u32, "rwpacked {v:#010x}"); + assert_eq!(dm1_hostdepth(v), d1.hostdepth(), "hostdepth {v:#010x}"); + assert_eq!(dm1_rwdouble(v), d1.rwdouble() as u32, "rwdouble {v:#010x}"); + assert_eq!(dm1_swapendian(v), d1.swapendian() as u32, "swapendian {v:#010x}"); + assert_eq!(dm1_compare(v), d1.compare(), "compare {v:#010x}"); + assert_eq!(dm1_rgbmode(v), d1.rgbmode() as u32, "rgbmode {v:#010x}"); + assert_eq!(dm1_dither(v), d1.dither() as u32, "dither {v:#010x}"); + assert_eq!(dm1_fastclear(v), d1.fastclear() as u32, "fastclear {v:#010x}"); + assert_eq!(dm1_blend(v), d1.blend() as u32, "blend {v:#010x}"); + assert_eq!(dm1_sfactor(v), d1.sfactor(), "sfactor {v:#010x}"); + assert_eq!(dm1_dfactor(v), d1.dfactor(), "dfactor {v:#010x}"); + assert_eq!(dm1_backblend(v), d1.backblend() as u32, "backblend {v:#010x}"); + assert_eq!(dm1_prefetch(v), d1.prefetch() as u32, "prefetch {v:#010x}"); + assert_eq!(dm1_blendalpha(v), d1.blendalpha() as u32, "blendalpha {v:#010x}"); + assert_eq!(dm1_logicop(v), d1.logicop(), "logicop {v:#010x}"); + } + } + + const CID_OFF: u32 = 0xF << CLIPMODE_CIDMATCH_SHIFT; + + /// Dead blend inputs fold to zero, so drawmodes differing only in stale + /// sfactor/dfactor bits share one monomorphisation. + #[test] + fn blend_inputs_fold_when_not_blending() { + let dm1_a = 0 << 19; // sfactor 0 + let dm1_b = 5 << 19; // sfactor 5, blend still off + let a = unpack(DRAWMODE0_OPCODE_DRAW, dm1_a, CID_OFF); + let b = unpack(DRAWMODE0_OPCODE_DRAW, dm1_b, CID_OFF); + assert_eq!(a, b, "stale sfactor must not create a second shape"); + assert_eq!(a.sfactor, 0); + } + + /// Per rex3.pdf §3.5.5 fastclear supports no per-pixel operation, so every + /// variant collapses onto one shape regardless of the stale bits around it. + #[test] + fn fastclear_collapses_the_pipeline() { + let plain = DM1_FASTCLEAR; + let noisy = DM1_FASTCLEAR + | DM1_BLEND + | DM1_DITHER + | (0x6 << 28) // logicop XOR + | (0x3 << 12) // compare LE + | (5 << 19) | (2 << 22); // sfactor/dfactor + let dm0_noisy = DRAWMODE0_OPCODE_DRAW + | (1 << 12) // enzpattern + | (1 << 18); // shade + + let a = unpack(DRAWMODE0_OPCODE_DRAW, plain, CID_OFF); + let b = unpack(dm0_noisy, noisy, CID_OFF); + assert_eq!(a, b, "fastclear variants must share one shape"); + assert_eq!(a.fastclear, 1); + assert_eq!(a.blend, 0); + assert_eq!(a.dither, 0); + assert_eq!(a.logicop, 0); + assert_eq!(a.shade, 0); + assert_eq!(a.enzpattern, 0); + assert_eq!(a.compare, 7, "fastclear bypasses afunction"); + } + + /// Hardware disables FASTCLEAR when CID checking is on (rex3.pdf bit 17, + /// §3.5.5, and the programming notes), so the fold must not apply there — + /// the draw is an ordinary one and its fields stay live. + /// See rules/rex3/fastclear-cid-divergence.md. + #[test] + fn fastclear_does_not_fold_when_cid_checking_enabled() { + let dm1 = DM1_FASTCLEAR | (0x6 << 28); // logicop XOR left live + let cid_on = 0x7 << CLIPMODE_CIDMATCH_SHIFT; // != 0xF + let f = unpack(DRAWMODE0_OPCODE_DRAW, dm1, cid_on); + assert_eq!(f.fastclear, 0, "CID checking disables fastclear"); + assert_eq!(f.logicop, 0x6, "ordinary draw keeps its logic op"); + assert_eq!(f.cidtest, 1); + } + + /// colorhost beats fastclear, matching the JIT's `!is_hostw` guard. + #[test] + fn colorhost_beats_fastclear() { + let dm0 = DRAWMODE0_OPCODE_DRAW | (1 << 6); // colorhost + let f = unpack(dm0, DM1_FASTCLEAR, CID_OFF); + assert_eq!(f.fastclear, 0); + assert_eq!(f.colorhost, 1); + } + + /// Host-transfer shape is dead when no host pixels move. + #[test] + fn host_fields_fold_for_non_host_draws() { + let dm1 = (1 << 7) | (0x2 << 8) | (1 << 10); // rwpacked, hostdepth, rwdouble + let f = unpack(DRAWMODE0_OPCODE_DRAW, dm1, CID_OFF); + assert_eq!((f.rwpacked, f.hostdepth, f.rwdouble), (0, 0, 0)); + // …but a READ moves host pixels, so they stay live. + let r = unpack(DRAWMODE0_OPCODE_READ, dm1, CID_OFF); + assert_eq!((r.rwpacked, r.hostdepth, r.rwdouble), (1, 2, 1)); + } + + #[test] + fn cidtest_is_on_off_not_the_nibble() { + let off = unpack(DRAWMODE0_OPCODE_DRAW, 0, CID_OFF); + assert_eq!(off.cidtest, 0, "0xF permits every CID — no test"); + // Every other nibble, including 0x0 (permit nothing), emits the test. + for nib in 0..0xFu32 { + let f = unpack(DRAWMODE0_OPCODE_DRAW, 0, nib << CLIPMODE_CIDMATCH_SHIFT); + assert_eq!(f.cidtest, 1, "nibble {nib:#x} must emit the test"); + } + } + + /// host_count/host_shift must match the Rex3::host_setup logic they were + /// lifted from — the JIT had its own hand-copy of this. + #[test] + fn host_count_shift_cover_all_depths() { + // Unpacked: always one pixel, no shift. + assert_eq!((host_count(0), host_shift(0)), (1, 0)); + for depth in 0..4u32 { + let packed = (1 << 7) | (depth << 8); + let dbl = packed | (1 << 10); + let expect_count = match depth { 0 | 1 => 4, 2 => 2, _ => 1 }; + let expect_dbl = match depth { 0 | 1 => 8, 2 => 4, _ => 2 }; + let expect_shift = match depth { 0 | 1 => 8, 2 => 16, _ => 32 }; + assert_eq!(host_count(packed), expect_count, "depth {depth}"); + assert_eq!(host_count(dbl), expect_dbl, "depth {depth} rwdouble"); + assert_eq!(host_shift(packed), expect_shift, "depth {depth}"); + } + } +} + +#[cfg(test)] +mod corpus_check { + use super::*; + + /// Decode the developer's saved JIT profile (if present) and report how far + /// canonicalisation collapses it. Prints rather than asserts — no particular + /// machine's profile is a correctness property — but the number is what + /// table sizing rests on, so it is worth being able to see. + /// Run with: cargo test --features rex-jit --lib corpus_check -- --nocapture + #[test] + fn report_corpus_collapse() { + let path = match std::env::var_os("HOME") { + Some(h) => std::path::PathBuf::from(h).join(".iris/rex-jit-profile.bin"), + None => return, + }; + let data = match std::fs::read(&path) { Ok(d) => d, Err(_) => return }; + if data.len() < 9 || &data[0..4] != b"IRXP" || data[4] != 2 { + return; + } + let count = u32::from_le_bytes(data[5..9].try_into().unwrap()) as usize; + + let mut raw = std::collections::HashSet::new(); + let mut shapes = std::collections::HashSet::new(); + for i in 0..count { + let o = 9 + i * 12; + if o + 12 > data.len() { break; } + let dm0 = u32::from_le_bytes(data[o..o + 4].try_into().unwrap()); + let dm1 = u32::from_le_bytes(data[o + 4..o + 8].try_into().unwrap()); + let cm = u32::from_le_bytes(data[o + 8..o + 12].try_into().unwrap()); + raw.insert((dm0, dm1, cm)); + shapes.insert(unpack(dm0, dm1, cm)); + } + println!( + "corpus: {} raw triples -> {} canonical shapes", + raw.len(), + shapes.len() + ); + } +} + +// ── Shape-key hashing ──────────────────────────────────────────────────────── + +/// A fast hash for `(dm0, dm1, cm)` shape keys. +/// +/// The default `HashMap` hasher is SipHash, which is ~27 ns for this 12-byte key +/// — measured, and the dominant cost of a dispatch lookup. SipHash buys DoS +/// resistance against adversarial keys; these keys come from a guest's draw-mode +/// registers, are bounded by the reachable draw-mode space, and land in a map the +/// guest cannot enumerate. That protection has nothing to defend here. +/// +/// This is the FxHash construction (rustc's own): multiply by a constant with +/// good bit-mixing and rotate, folding each word in turn. No allocation, no +/// finalisation, a handful of instructions. +#[derive(Default, Clone, Copy)] +pub struct ShapeHasher(u64); + +impl ShapeHasher { + const SEED: u64 = 0x51_7c_c1_b7_27_22_0a_95; + + #[inline(always)] + fn add(&mut self, w: u64) { + self.0 = (self.0.rotate_left(5) ^ w).wrapping_mul(Self::SEED); + } +} + +impl std::hash::Hasher for ShapeHasher { + #[inline(always)] + fn finish(&self) -> u64 { + self.0 + } + + #[inline(always)] + fn write(&mut self, bytes: &[u8]) { + // Shape keys are written as u32s; this path exists only to satisfy the + // trait and is not on the hot path. + for chunk in bytes.chunks(8) { + let mut buf = [0u8; 8]; + buf[..chunk.len()].copy_from_slice(chunk); + self.add(u64::from_le_bytes(buf)); + } + } + + #[inline(always)] + fn write_u32(&mut self, v: u32) { + self.add(v as u64); + } + + #[inline(always)] + fn write_u64(&mut self, v: u64) { + self.add(v); + } + + #[inline(always)] + fn write_usize(&mut self, v: usize) { + self.add(v as u64); + } +} + +/// `BuildHasher` for [`ShapeHasher`]. +#[derive(Default, Clone, Copy)] +pub struct ShapeHashBuilder; + +impl std::hash::BuildHasher for ShapeHashBuilder { + type Hasher = ShapeHasher; + #[inline(always)] + fn build_hasher(&self) -> ShapeHasher { + ShapeHasher(0) + } +} + +/// A `HashMap` keyed by shape triples. +pub type ShapeMap = std::collections::HashMap<(u32, u32, u32), V, ShapeHashBuilder>; + +/// A `HashSet` of shape triples. +pub type ShapeSet = std::collections::HashSet<(u32, u32, u32), ShapeHashBuilder>; diff --git a/src/rex3_simd.rs b/src/rex3_simd.rs deleted file mode 100644 index f7921654..00000000 --- a/src/rex3_simd.rs +++ /dev/null @@ -1,170 +0,0 @@ -//! SIMD-friendly fast paths for common REX3 interpreter draws (pre rex-jit). - -use crate::rex3::{Rex3, Rex3Context}; - -// ctx.xstart/ystart/xend/yend (>>11) are WINDOW-RELATIVE coordinates — -// calculate_fb_address adds XYWIN's offset (plus xymove, when applicable) -// and only THEN subtracts REX3_COORD_BIAS to get the physical framebuffer -// position (see calculate_fb_address in rex3.rs: `x_abs = x_curr + x_off` -// then `x_phys = x_abs - REX3_COORD_BIAS`). There is deliberately no -// pre-loop bounding-box clamp here — any clamp applied directly to -// xstart/xend before XYWIN is added would reject legitimate coordinates -// for windows not positioned at the absolute screen origin (confirmed: -// an earlier attempt to clamp to a fixed biased screen range broke solid -// fills for most on-screen windows). calculate_fb_address already performs -// the real, XYWIN-aware bounds check per pixel — same as the interpreter's -// unclamped draw_block/draw_span fallback loop — so no pre-clamp is needed; -// xstart/xend/ystart/yend are bounded 16-bit register fields regardless, -// so the loop range can't run away even without one. - -/// Try to fast-fill a fastclear BLOCK without per-pixel interpreter overhead. -/// Returns true when the entire primitive was handled. -pub fn try_fastclear_block(rex: &Rex3, ctx: &Rex3Context) -> bool { - if !ctx.drawmode1.fastclear() { - return false; - } - if ctx.drawmode0.enzpattern() || ctx.drawmode0.enlspattern() { - return false; - } - if ctx.drawmode0.colorhost() || ctx.drawmode0.alphahost() { - return false; - } - if ctx.drawmode0.adrmode() != 1 { - return false; // BLOCK only - } - - let x0 = ctx.xstart >> 11; - let x1 = ctx.xend >> 11; - let y0 = ctx.ystart >> 11; - let y1 = ctx.yend >> 11; - let (x_lo, x_hi) = if x0 <= x1 { (x0, x1) } else { (x1, x0) }; - let (y_lo, y_hi) = if y0 <= y1 { (y0, y1) } else { (y1, y0) }; - - let color = Rex3::fastclear_color(ctx); - let wr_fn = unsafe { *rex.px_wr.get() }; - let mut rows = 0u64; - - for y in y_lo..=y_hi { - for x in x_lo..=x_hi { - if let Some(addr) = rex.calculate_fb_address(x, y, ctx, true) { - wr_fn(rex, addr, color); - } - } - rows += 1; - } - - rex.simd_fill_rows.fetch_add(rows, std::sync::atomic::Ordering::Relaxed); - true -} - -/// Fast SRC logicop horizontal span (solid RGB, no blend/pattern/host). -pub fn try_src_span_rgb(rex: &Rex3, ctx: &Rex3Context) -> bool { - use crate::rex3::{DRAWMODE0_ADRMODE_SPAN, DRAWMODE1_LOGICOP_SRC}; - if ctx.drawmode0.adrmode() << 2 != DRAWMODE0_ADRMODE_SPAN { - return false; - } - if ctx.drawmode1.logicop() != DRAWMODE1_LOGICOP_SRC >> 28 { - return false; - } - if ctx.drawmode0.enzpattern() || ctx.drawmode0.enlspattern() { - return false; - } - if ctx.drawmode0.colorhost() || ctx.drawmode0.alphahost() || ctx.drawmode0.shade() { - return false; - } - if ctx.drawmode1.planes() != 0 { - return false; // RGB/RGBA planes only - } - // Blending and the alpha-vs-ALPHAREF compare are both per-pixel decisions this - // path cannot make: it precomputes one solid colour and stores it unconditionally, - // which would bypass the blend entirely and write pixels the alpha test should - // have killed. COMPARE == 0x7 means the test is disabled (always pass). - if ctx.drawmode1.blend() || ctx.drawmode1.compare() != 0x7 { - return false; - } - // Dithering needs a per-pixel bayer(x,y) threshold — not representable as a - // single precomputed fill color, so fall back to the interpreter for that case. - if ctx.drawmode1.dither() { - return false; - } - - let x0 = ctx.xstart >> 11; - let x1 = ctx.xend >> 11; - let y = ctx.ystart >> 11; - let (x_lo, x_hi) = if x0 <= x1 { (x0, x1) } else { (x1, x0) }; - - // Match process_pixel_noblend's src formatting: compress raw 24-bit BGR - // (get_colori()) down to the framebuffer's plane depth, then amplify for - // dblsrc packing (replicates into both packed-pixel slots so whichever - // slot wrmask selects gets the right bits) — without this, a raw - // get_colori() write is only correct for drawdepth==3 (24bpp)/no-dblsrc, - // and lands unpacked/misaligned bits for every other depth. - let compress_fn = unsafe { *rex.px_compress.get() }; - let amp_fn = unsafe { *rex.px_amp.get() }; - let color = amp_fn(compress_fn(ctx.get_colori())); - let wr_fn = unsafe { *rex.px_wr.get() }; - for x in x_lo..=x_hi { - if let Some(addr) = rex.calculate_fb_address(x, y, ctx, true) { - wr_fn(rex, addr, color); - } - } - rex.simd_fill_rows.fetch_add(1, std::sync::atomic::Ordering::Relaxed); - true -} - -/// Fast SRC logicop axis-aligned BLOCK fill (solid RGB, no blend/pattern/host). -pub fn try_src_block_rgb(rex: &Rex3, ctx: &Rex3Context) -> bool { - use crate::rex3::{DRAWMODE1_LOGICOP_SRC}; - if ctx.drawmode0.adrmode() != 1 { - return false; - } - if ctx.drawmode1.logicop() != DRAWMODE1_LOGICOP_SRC >> 28 { - return false; - } - if ctx.drawmode0.enzpattern() || ctx.drawmode0.enlspattern() { - return false; - } - if ctx.drawmode0.colorhost() || ctx.drawmode0.alphahost() || ctx.drawmode0.shade() { - return false; - } - if ctx.drawmode1.planes() != 0 || ctx.drawmode1.fastclear() { - return false; - } - // See try_src_span_rgb: blend and the alpha compare are per-pixel decisions - // this precomputed-colour path cannot honour. - if ctx.drawmode1.blend() || ctx.drawmode1.compare() != 0x7 { - return false; - } - // See try_src_span_rgb: dithering needs a per-pixel bayer(x,y) threshold, - // not representable as a single precomputed fill color. - if ctx.drawmode1.dither() { - return false; - } - - let x0 = ctx.xstart >> 11; - let x1 = ctx.xend >> 11; - let y0 = ctx.ystart >> 11; - let y1 = ctx.yend >> 11; - let (x_lo, x_hi) = if x0 <= x1 { (x0, x1) } else { (x1, x0) }; - let (y_lo, y_hi) = if y0 <= y1 { (y0, y1) } else { (y1, y0) }; - - // See try_src_span_rgb: compress to plane depth + amplify for dblsrc - // packing, matching process_pixel_noblend's src formatting. - let compress_fn = unsafe { *rex.px_compress.get() }; - let amp_fn = unsafe { *rex.px_amp.get() }; - let color = amp_fn(compress_fn(ctx.get_colori())); - let wr_fn = unsafe { *rex.px_wr.get() }; - let mut rows = 0u64; - - for y in y_lo..=y_hi { - for x in x_lo..=x_hi { - if let Some(addr) = rex.calculate_fb_address(x, y, ctx, true) { - wr_fn(rex, addr, color); - } - } - rows += 1; - } - - rex.simd_fill_rows.fetch_add(rows, std::sync::atomic::Ordering::Relaxed); - true -} diff --git a/src/rex3_tests.rs b/src/rex3_tests.rs index f5889f78..25f984ba 100644 --- a/src/rex3_tests.rs +++ b/src/rex3_tests.rs @@ -54,15 +54,34 @@ fn set_addr(offset: u32) -> u32 { REX3_BASE | offset } // Compute the GO address (bit 11 set) for a register offset. fn go_addr(offset: u32) -> u32 { REX3_BASE | 0x0800 | offset } +/// Bus write that retries on `BUS_BUSY`, the way the CPU re-executes a store +/// on `EXEC_RETRY`. `Rex3::write32` returns `BUS_BUSY` when the GFIFO is +/// full; discarding that status silently drops the entry, which turned the +/// throughput benchmarks below into a measurement of how fast a host thread +/// can *attempt* pushes (a flat ~18M spans/s at every span length, i.e. +/// "22 Gpx/s" for 1280-pixel Gouraud spans). +fn w32(rex: &Rex3, addr: u32, value: u32) { + while rex.write32(addr, value) == crate::traits::BUS_BUSY { + std::hint::spin_loop(); + } +} + +/// 64-bit counterpart of `w32`. +fn w64(rex: &Rex3, addr: u32, value: u64) { + while rex.write64(addr, value) == crate::traits::BUS_BUSY { + std::hint::spin_loop(); + } +} + /// Write a register to the SET space (no draw trigger). fn reg(rex: &Rex3, offset: u32, value: u32) { - rex.write32(set_addr(offset), value); + w32(rex, set_addr(offset), value); } /// Write a register to the GO space (triggers a draw), then wait for idle. /// Equivalent to writing to go.reg + REX3WAIT(REX) in SGI diagnostics. fn reg_go(rex: &Rex3, offset: u32, value: u32) { - rex.write32(go_addr(offset), value); + w32(rex, go_addr(offset), value); rex.wait_idle(); } @@ -73,9 +92,21 @@ fn wait(rex: &Rex3) { /// Read a 32-bit context register. Blocks until the GFIFO is idle first. fn read_reg(rex: &Rex3, offset: u32) -> u32 { + // Retry on busy, don't panic. 67 registers are gated behind `busy_or_val!`, + // which returns busy whenever gfxbusy is set or the GFIFO is non-empty — so + // `wait_idle()` first is necessary but not sufficient: nothing stops the + // queue refilling between the wait and the read. Retrying matches what + // read_hostrw32 and friends already do; panicking here would surface a + // transient queue state as a bogus "bad status" failure. rex.wait_idle(); - let r: BusRead32 = rex.read32(set_addr(offset)); - if r.is_ok() { r.data } else { panic!("read_reg: bad status for offset {offset:#x}") } + loop { + let r: BusRead32 = rex.read32(set_addr(offset)); + if r.is_ok() { return r.data; } + if r.status != crate::traits::BUS_BUSY { + panic!("read_reg: bad status {:#x} for offset {offset:#x}", r.status); + } + std::hint::spin_loop(); + } } /// Read from HOSTRW0 GO space: returns current word, then triggers next batch. @@ -118,12 +149,12 @@ fn read_hostrw64_last(rex: &Rex3) -> u64 { /// Write a 32-bit word to HOSTRW0 (CPU→REX draw path). fn write_hostrw32(rex: &Rex3, val: u32) { - rex.write32(go_addr(REX3_HOSTRW0), val); + w32(rex, go_addr(REX3_HOSTRW0), val); } /// Write a 64-bit double to HOSTRW0 (CPU→REX draw path, 64-bit GIO bus). fn write_hostrw64(rex: &Rex3, val: u64) { - rex.write64(go_addr(REX3_HOSTRW0), val); + w64(rex, go_addr(REX3_HOSTRW0), val); } /// Read fb_rgb pixel at screen (x, y) — direct framebuffer access for verification. @@ -187,8 +218,8 @@ fn write_yendf(rex: &Rex3, screen_y: i32, frac4: i32) { // DRAWMODE1 combinations. COMPARE is included at its disabled value (0x7) — real // drawmode1 words always carry it explicitly; omitting it would leave COMPARE=0 // (afunction always-kill) since DrawMode1's bitfield default zero-inits. -const DM1_CI8_SRC: u32 = DRAWMODE1_PLANES_RGB | (1 << 3) | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC; -const DM1_RGB24_SRC: u32 = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC; +const DM1_CI8_SRC: u32 = DRAWMODE1_PLANES_RGB | (1 << 3) | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH; +const DM1_RGB24_SRC: u32 = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH; // DRAWMODE1 host-depth fields (bits [4:3] = hostdepth, bit 16 = rwpacked, bit 17 = rwdouble) // hostdepth: 0=4bpp, 1=8bpp, 2=12bpp, 3=32bpp @@ -204,13 +235,13 @@ const DM0_STOPONXY: u32 = DM0_STOPONX | DM0_STOPONY; const DM0_DOSETUP: u32 = 1 << 5; const DM0_COLORHOST: u32 = 1 << 6; // pixel data comes from / goes to host FIFO (bit 6) -const DM0_DRAW_BLOCK: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_BLOCK | DM0_STOPONXY; -const DM0_DRAW_SPAN: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_SPAN | DM0_STOPONX; -const DM0_SCR2SCR: u32 = DRAWMODE0_OPCODE_SCR2SCR | DRAWMODE0_ADRMODE_BLOCK | DM0_DOSETUP | DM0_STOPONXY; +const DM0_DRAW_BLOCK: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_BLOCK_SH | DM0_STOPONXY; +const DM0_DRAW_SPAN: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_SPAN_SH | DM0_STOPONX; +const DM0_SCR2SCR: u32 = DRAWMODE0_OPCODE_SCR2SCR | DRAWMODE0_ADRMODE_BLOCK_SH | DM0_DOSETUP | DM0_STOPONXY; // DRAW with COLORHOST: pixels come from host write FIFO -const DM0_HOSTW_BLOCK: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_BLOCK | DM0_STOPONXY | DM0_COLORHOST; +const DM0_HOSTW_BLOCK: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_BLOCK_SH | DM0_STOPONXY | DM0_COLORHOST; // READ with COLORHOST: reads fb → host read FIFO -const DM0_READ_BLOCK: u32 = DRAWMODE0_OPCODE_READ | DRAWMODE0_ADRMODE_BLOCK | DM0_STOPONXY | DM0_COLORHOST | DM0_DOSETUP; +const DM0_READ_BLOCK: u32 = DRAWMODE0_OPCODE_READ | DRAWMODE0_ADRMODE_BLOCK_SH | DM0_STOPONXY | DM0_COLORHOST | DM0_DOSETUP; /// Initialise REX3 to a known baseline — matches rex3init() from rex3.c. /// XYWIN is left at 0 (no hardware xbias correction needed in emulation). @@ -259,7 +290,7 @@ fn check_cid_write_masks(rex: &Rex3, compiled: bool) { let jit_before = rex.jit_go_count.load(std::sync::atomic::Ordering::Relaxed); let src = 10 * 2048 + 10; let dst = 20 * 2048 + 10; - for dm0 in [DM0_DRAW_BLOCK, DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE | DM0_DOSETUP | DM0_STOPONXY, DM0_SCR2SCR] { + for dm0 in [DM0_DRAW_BLOCK, DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE_SH | DM0_DOSETUP | DM0_STOPONXY, DM0_SCR2SCR] { for mask in 0..16_u32 { let cm = mask << CLIPMODE_CIDMATCH_SHIFT; #[cfg(feature = "rex-jit")] @@ -720,7 +751,7 @@ fn test_logicop_zero_clears() { assert_ne!(read_pixel(&rex, 4, 4) & 0xFF, 0); // Clear with ZERO logicop - let dm1_zero = DRAWMODE1_PLANES_RGB | (1 << 3) | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_ZERO; + let dm1_zero = DRAWMODE1_PLANES_RGB | (1 << 3) | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_ZERO_SH; reg(&rex, REX3_DRAWMODE1, dm1_zero); reg(&rex, REX3_COLORI, 0xFF); reg(&rex, REX3_XYENDI, xy(4, 4)); @@ -734,7 +765,7 @@ fn test_logicop_zero_clears() { fn test_logicop_xor_roundtrip() { let rex = make_rex3(); rex3init(&rex); - let dm1_xor = DRAWMODE1_PLANES_RGB | (1 << 3) | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_XOR; + let dm1_xor = DRAWMODE1_PLANES_RGB | (1 << 3) | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_XOR_SH; reg(&rex, REX3_DRAWMODE1, dm1_xor); reg(&rex, REX3_WRMASK, 0xFF); @@ -790,7 +821,7 @@ fn test_noop_opcode_draws_nothing() { reg(&rex, REX3_COLORI, 0xFF); reg(&rex, REX3_XYENDI, xy(5, 5)); reg(&rex, REX3_XYSTARTI, xy(0, 0)); - let dm0_noop = DRAWMODE0_OPCODE_NOOP | DRAWMODE0_ADRMODE_BLOCK | DM0_STOPONXY; + let dm0_noop = DRAWMODE0_OPCODE_NOOP | DRAWMODE0_ADRMODE_BLOCK_SH | DM0_STOPONXY; reg_go(&rex, REX3_DRAWMODE0, dm0_noop); for y in 0..=5 { for x in 0..=5 { @@ -1088,12 +1119,12 @@ fn test_patterns_gouraud_shade_span() { // DM1 values with host-depth and packed/double flags // CI8: hostdepth=1 (8bpp), rwpacked (bit 7), same draw-plane config as DM1_CI8_SRC const DM1_CI8_HOSTRW: u32 = - DRAWMODE1_PLANES_RGB | (1 << 3) | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC | (1 << 8) | (1 << 7); + DRAWMODE1_PLANES_RGB | (1 << 3) | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH | (1 << 8) | (1 << 7); // CI8 64-bit: same as CI8 + rwdouble (bit 10) → 8 CI8 pixels per 64-bit word const DM1_CI8_HOSTRW64: u32 = DM1_CI8_HOSTRW | (1 << 10); // RGB24: hostdepth=3 (32bpp), rwpacked (bit 7), same draw-plane as DM1_RGB24_SRC const DM1_RGB24_HOSTRW: u32 = - DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC | (3 << 8) | (1 << 7); + DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH | (3 << 8) | (1 << 7); // RGB24 64-bit: same as above + rwdouble (bit 10) const DM1_RGB24_HOSTRW64: u32 = DM1_RGB24_HOSTRW | (1 << 10); @@ -1111,7 +1142,7 @@ fn test_hostrw_gio_bus_walking_ones_32bit() { for b in 0..32u32 { let w = 1u32 << b; - rex.write32(set_addr(REX3_HOSTRW0), w); + w32(rex, set_addr(REX3_HOSTRW0), w); // SET read: wait for GFIFO to drain, then return hostrw register. let got = loop { let r: BusRead32 = rex.read32(set_addr(REX3_HOSTRW0)); @@ -1130,7 +1161,7 @@ fn test_hostrw_gio_bus_walking_ones_hostrw1() { for b in 0..32u32 { let w = 1u32 << b; - rex.write32(set_addr(REX3_HOSTRW1), w); + w32(rex, set_addr(REX3_HOSTRW1), w); let got = loop { let r: BusRead32 = rex.read32(set_addr(REX3_HOSTRW1)); if r.is_ok() { break r.data; } @@ -1717,16 +1748,16 @@ fn test_hostw_rgb24_multiline_64bit_unpacked() { // ============================================================================ // DM0 for a full I_LINE draw (stoponx+stopony so the whole line runs in one GO). -const DM0_DRAW_ILINE: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE | DM0_DOSETUP | DM0_STOPONXY; +const DM0_DRAW_ILINE: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE_SH | DM0_DOSETUP | DM0_STOPONXY; // DM0 for I_LINE single-step mode (no stoponx/stopony — one pixel per GO). -const DM0_DRAW_ILINE_STEP: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE | DM0_DOSETUP; +const DM0_DRAW_ILINE_STEP: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE_SH | DM0_DOSETUP; // DM0 for a full F_LINE draw — fractional-endpoint Bresenham correction. -const DM0_DRAW_FLINE: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_F_LINE | DM0_DOSETUP | DM0_STOPONXY; +const DM0_DRAW_FLINE: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_F_LINE_SH | DM0_DOSETUP | DM0_STOPONXY; // DM0 for a full A_LINE draw — F_LINE plus AWEIGHT-LUT endpoint suppression (needs ENDPTFILTER, bit 22, set separately). // A_LINE tests are out of scope for this pass (see rules/testing/rex3-fline-fractional-bresenham.md) — // kept for a future session, not yet exercised by any test. #[allow(dead_code)] -const DM0_DRAW_ALINE: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_A_LINE | DM0_DOSETUP | DM0_STOPONXY; +const DM0_DRAW_ALINE: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_A_LINE_SH | DM0_DOSETUP | DM0_STOPONXY; #[allow(dead_code)] const DM0_ENDPTFILTER: u32 = 1 << 22; @@ -1789,7 +1820,7 @@ fn draw_iline_step(rex: &Rex3, x0: i32, y0: i32, x1: i32, y1: i32, color: u8) -> reg_go(rex, REX3_DRAWMODE0, DM0_DRAW_ILINE_STEP); // Subsequent GOs without DOSETUP — each draws one more pixel. - let dm0_cont = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE; + let dm0_cont = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE_SH; for _ in 1..pixel_count { reg_go(rex, REX3_DRAWMODE0, dm0_cont); } @@ -2239,7 +2270,7 @@ fn test_iline_all_octants_step() { reg_go(&rex, REX3_DRAWMODE0, DM0_DRAW_ILINE_STEP); // Subsequent GOs — one pixel each. - let dm0_cont = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE; + let dm0_cont = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE_SH; for _ in 1..pixel_count { reg_go(&rex, REX3_DRAWMODE0, dm0_cont); } @@ -2410,7 +2441,7 @@ fn test_iline_line_loop_rect() { rex3init(&rex); // DM0: DRAW | I_LINE | DOSETUP | STOPONXY | SKIPLAST - let dm0_loop: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE + let dm0_loop: u32 = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE_SH | DM0_DOSETUP | DM0_STOPONXY | (1 << 11); // bit11 = skiplast reg(&rex, REX3_DRAWMODE1, DM1_CI8_SRC); @@ -2514,6 +2545,28 @@ mod jit_tests { } /// Build a Rex3 with JIT enabled. + /// A Rex3 with the generated LLVM shaders loaded. + /// + /// `Rex3::new` deliberately does not seed them under `cfg(test)` — the + /// JIT-vs-generic comparison tests need Cranelift to actually run — so a + /// benchmark that wants to measure the precompiled path has to load them + /// explicitly. + fn make_rex3_precompiled() -> &'static Rex3 { + let rex = make_rex3(); + { + let mut map = rex.shaders.write(); + for (k, f) in crate::rex3_shaders::SHADERS { + map.insert(*k, *f); + } + } + // make_rex3 turns dispatch off so ordinary tests exercise the generic + // path; this fixture exists to measure the precompiled one, so turn it + // back on. + #[cfg(feature = "rex-jit")] + rex.jit_enabled.store(true, std::sync::atomic::Ordering::Relaxed); + rex + } + fn make_rex3_jit() -> &'static Rex3 { std::thread::Builder::new() .stack_size(8 * 1024 * 1024) @@ -2530,7 +2583,11 @@ mod jit_tests { (*rex.fb_rgb.get()).fill(0); (*rex.fb_aux.get()).fill(0); } - rex.rex_jit = Some(std::sync::Arc::new(RexJit::new())); + // Share the dispatch map so compiled shaders land where execute_go + // looks for them. + rex.rex_jit = Some(std::sync::Arc::new(RexJit::new( + std::sync::Arc::clone(&rex.shaders), + ))); rex.start(); rex }) @@ -2578,6 +2635,26 @@ mod jit_tests { x0: i32, y0: i32, x1: i32, y1: i32, setup: impl Fn(&Rex3), dm0: u32, dm1: u32, + ) { + compare_jit_interp_inner(x0, y0, x1, y1, setup, dm0, dm1, false) + } + + /// `compare_jit_interp` for cases where drawing nothing IS the expected + /// result (LRONLY aborting the primitive, for example), so the + /// "interpreter drew nothing" guard must not fire. + fn compare_jit_interp_expect_blank( + x0: i32, y0: i32, x1: i32, y1: i32, + setup: impl Fn(&Rex3), + dm0: u32, dm1: u32, + ) { + compare_jit_interp_inner(x0, y0, x1, y1, setup, dm0, dm1, true) + } + + fn compare_jit_interp_inner( + x0: i32, y0: i32, x1: i32, y1: i32, + setup: impl Fn(&Rex3), + dm0: u32, dm1: u32, + expect_blank: bool, ) { // Interpreter run with JIT dispatch disabled. let rex_interp = make_rex3(); @@ -2597,9 +2674,12 @@ mod jit_tests { let ctx = unsafe { &*rex_jit.context.get() }; ctx.clipmode & CLIPMODE_JIT_KEY_MASK }; - // First GO: triggers compile + interpreter fallback + // First GO: triggers compile + generic fallback. reg_go(rex_jit, REX3_DRAWMODE0, dm0); - // Wait for JIT compile + + // Test builds do not seed the generated LLVM shaders (see Rex3::new), so + // this shape reaches Cranelift and the comparison below really is + // JIT-vs-generic rather than generic-vs-itself. let compiled = if let Some(ref jit) = rex_jit.rex_jit { jit.wait_compiled(dm0, dm1, cm) } else { false }; @@ -2630,6 +2710,17 @@ mod jit_tests { reg_go(rex_jit, REX3_DRAWMODE0, dm0); let fb_jit = dump_region(rex_jit, x0, y0, x1, y1); + // A comparison of two blank regions passes whatever the shader does. + // jit_zpattern_block sat in exactly that state (packed RGB written to + // an o12.11 colour register drew black on black), so an inverted + // pattern test in the JIT went undetected. Require that something was + // actually drawn before trusting the match. + assert!(expect_blank || fb_interp.iter().any(|&p| p != 0), + "compare_jit_interp: interpreter drew nothing for dm0={dm0:#010x} \ + dm1={dm1:#010x} — the comparison below would pass vacuously. If a \ + blank result is genuinely expected, use \ + compare_jit_interp_expect_blank."); + assert_eq!(fb_interp, fb_jit, "JIT/interp mismatch: dm0={dm0:#010x} dm1={dm1:#010x}"); } @@ -2671,13 +2762,25 @@ mod jit_tests { /// RGB24 XOR logic op block. #[test] fn jit_logicop_xor_rgb24() { - let dm1 = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) | DRAWMODE1_LOGICOP_XOR; + // COMPARE must be 0x7 (disabled). Without DRAWMODE1_COMPARE_DISABLE_SH the + // compare field reads 0, which is an alpha-function test that passes + // nothing, so every write was inhibited and this test compared two + // untouched regions -- passing for any shader behaviour. Every working + // test gets this via DM1_RGB24_SRC; this one open-coded dm1 and lost it. + let dm1 = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) + | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_XOR_SH; let dm0 = DM0_DRAW_BLOCK; compare_jit_interp(0, 0, 15, 15, |rex| { reg(rex, REX3_DRAWMODE1, dm1); reg(rex, REX3_WRMASK, 0xFFFFFF); - reg(rex, REX3_COLORRED, 0x00_FF_00_FFu32); + // o12.11 components, not a packed RGB24 word (see + // jit_zpattern_block): a packed value shifts down to near-zero + // and XOR against a cleared framebuffer left the region blank, + // so this compared two empty regions and passed regardless. + reg(rex, REX3_COLORRED, 200u32 << 11); + reg(rex, REX3_COLORGRN, 150u32 << 11); + reg(rex, REX3_COLORBLUE, 100u32 << 11); reg(rex, REX3_XYENDI, xy(15, 15)); reg(rex, REX3_XYSTARTI, xy(0, 0)); }, @@ -2689,7 +2792,7 @@ mod jit_tests { #[test] fn jit_fastclear_rgb24() { // fastclear = DM1 bit 17; cidmatch must be 0xF for fastclear to activate in interpreter - let dm1 = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) | DRAWMODE1_LOGICOP_SRC | (1 << 17); + let dm1 = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) | DRAWMODE1_LOGICOP_SRC_SH | (1 << 17); let dm0 = DM0_DRAW_BLOCK; compare_jit_interp(0, 0, 31, 31, |rex| { @@ -2819,7 +2922,14 @@ mod jit_tests { |rex| { reg(rex, REX3_DRAWMODE1, dm1); reg(rex, REX3_WRMASK, 0xFFFFFF); - reg(rex, REX3_COLORRED, 0x00_FF_80_40u32); + // o12.11 fixed-point components, NOT a packed RGB24 word: the + // shader takes colorred >> 11, so a packed value like + // 0x00FF8040 shifts down to 0 and the whole region draws black + // on black. This test compared two all-zero regions and passed + // for any shader behaviour until that was fixed. + reg(rex, REX3_COLORRED, 200u32 << 11); + reg(rex, REX3_COLORGRN, 150u32 << 11); + reg(rex, REX3_COLORBLUE, 100u32 << 11); reg(rex, REX3_ZPATTERN, 0xAAAA_AAAA); // alternating bits reg(rex, REX3_XYENDI, xy(7, 7)); reg(rex, REX3_XYSTARTI, xy(0, 0)); @@ -3022,7 +3132,9 @@ mod jit_tests { // x_dec=1: xstart > xend, octant has XDEC set by dosetup // Use dosetup so octant is derived from coordinates let dm0 = dm0 | (1 << 5); // dosetup - compare_jit_interp(0, 0, 15, 7, + // LRONLY aborts the primitive when xstart > xend, so an empty region is + // the expected result here, not a broken test. + compare_jit_interp_expect_blank(0, 0, 15, 7, |rex| { reg(rex, REX3_DRAWMODE1, dm1); reg(rex, REX3_WRMASK, 0xFFFFFF); @@ -3102,7 +3214,7 @@ mod jit_tests { reg(rex, REX3_COLORBLUE, b0 << 11); reg(rex, REX3_XYENDI, xy(W, y)); // XYSTARTI+GO in one write — triggers the draw - rex.write32(go_addr(REX3_XYSTARTI), xy(0, y)); + w32(rex, go_addr(REX3_XYSTARTI), xy(0, y)); } // Drain after each full frame so we measure throughput not queue depth rex.wait_idle(); @@ -3160,6 +3272,250 @@ mod jit_tests { ); } + /// ZPATTERN transparent-miss semantics, checked against explicit expected + /// pixels rather than an engine-to-engine comparison. + /// + /// Written because `jit_zpattern_block` could not catch an inverted pattern + /// test: it wrote a packed RGB24 word into COLORRED (an o12.11 component + /// register, so it shifted down to ~0) and compared two all-black regions, + /// passing for any shader behaviour. This asserts which pixels must change + /// and which must not, so an inverted or missing test fails loudly. + /// + /// ZPATTERN walks MSB-first from bit 31 (see advance_zpat). With pattern + /// 0xAAAA_AAAA that yields a strict alternation; the phase is taken from the + /// interpreter (the reference) rather than derived here, since the cursor's + /// starting position depends on DOSETUP/row-start handling in execute_go. + /// What this test pins down is the *transparent-miss* contract: missed + /// pixels must be left completely untouched, drawn pixels must carry the + /// colour, and the two engines must agree pixel for pixel. + #[test] + fn jit_zpattern_transparent_miss_exact() { + const Y: i32 = 400; + const N: usize = 32; + const SENTINEL: u32 = 0x0012_3456; + let dm0 = DM0_DRAW_SPAN | (1 << 12); // + ENZPATTERN, transparent (no ZPOPAQUE) + let dm1 = DM1_RGB24_SRC; + + let run = |rex: &Rex3| -> Vec { + // zpat_bit has no register mapping and only resets on DOSETUP, + // which DM0_DRAW_SPAN does not set. Without forcing it here the two + // engines start the pattern from whatever the previous GO left + // behind -- the interpreter ran once and began at 0, the JIT's + // compile-triggering GO left it at 31, and every pixel disagreed. + // Same harness hazard compare_jit_interp documents. + unsafe { (*rex.context.get()).zpat_bit = 31; } + // Fill with a sentinel so an untouched pixel is distinguishable + // from a pixel drawn black — the flaw that made the old test inert. + { + let fb = unsafe { &mut *rex.fb_rgb.get() }; + for x in 0..N { fb[Y as usize * 2048 + x] = SENTINEL; } + } + reg(rex, REX3_DRAWMODE0, dm0); + reg(rex, REX3_DRAWMODE1, dm1); + reg(rex, REX3_WRMASK, 0xFFFFFF); + reg(rex, REX3_ZPATTERN, 0xAAAA_AAAA); + reg(rex, REX3_COLORRED, 200u32 << 11); + reg(rex, REX3_COLORGRN, 150u32 << 11); + reg(rex, REX3_COLORBLUE, 100u32 << 11); + reg(rex, REX3_XYENDI, xy(N as i32 - 1, Y)); + reg_go(rex, REX3_XYSTARTI, xy(0, Y)); + rex.wait_idle(); + let fb = unsafe { &*rex.fb_rgb.get() }; + (0..N).map(|x| fb[Y as usize * 2048 + x]).collect() + }; + + let check = |got: &[u32], who: &str| { + // Strict alternation, and exactly half the span drawn: a shader that + // drew everything, drew nothing, or inverted the test all fail here. + let drawn_count = (0..N).filter(|&x| got[x] != SENTINEL).count(); + assert_eq!(drawn_count, N / 2, + "{who}: {drawn_count} of {N} pixels drawn, expected exactly half \ + (0xAAAA_AAAA alternates)"); + // Absolute phase, not derived from the output. Both fixtures enter + // the draw with zpat_bit = 31 (set explicitly below), and bit 31 of + // 0xAAAA_AAAA is set, so pixel 0 MUST be drawn. Deriving the phase + // from got[0] instead made the test blind to an inverted pattern + // test: inverting it shifts the alternation by one, both engines + // shift together, and every self-calibrating check still passes. + for x in 0..N { + let drawn = got[x] != SENTINEL; + let expect_drawn = x % 2 == 0; + assert_eq!(drawn, expect_drawn, + "{who}: pixel {x} {} but should {} (value {:#010x}) — \ + alternation broken", + if drawn { "was drawn" } else { "was NOT drawn" }, + if expect_drawn { "be drawn" } else { "be left alone" }, + got[x]); + } + // Missed pixels must be untouched, not drawn black: that distinction + // is what the sentinel fill exists for. + let missed = (0..N).find(|&x| got[x] == SENTINEL).expect("some pixel missed"); + assert_eq!(got[missed], SENTINEL, + "{who}: missed pixel {missed} was modified"); + // And the drawn pixels must carry the colour, not black. + let first_drawn = (0..N).find(|&x| got[x] != SENTINEL).unwrap(); + assert_ne!(got[first_drawn] & 0xFFFFFF, 0, + "{who}: drawn pixels are black — the colour registers were not \ + interpreted as o12.11 components and this check is vacuous"); + }; + + let rex_i = make_rex3(); + rex3init(rex_i); + unsafe { + let ctx = &mut *rex_i.context.get(); + ctx.zpat_bit = 31; + ctx.pat_bit = 31; + } + let interp = run(rex_i); + check(&interp, "interpreter"); + + let rex_j = make_rex3_jit(); + rex3init(rex_j); + let _ = run(rex_j); // request compile + { + let cm = unsafe { (*rex_j.context.get()).clipmode } & CLIPMODE_JIT_KEY_MASK; + if let Some(ref jit) = rex_j.rex_jit { + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30); + while !jit.compiled_pairs().iter().any(|&(a, _, c)| a == dm0 && c == cm) { + assert!(std::time::Instant::now() < deadline, + "JIT compile timed out for dm0={dm0:#010x} cm={cm:#x}"); + std::thread::sleep(std::time::Duration::from_millis(5)); + } + } + } + // Reset the pattern cursor before the measured run. zpat_bit/pat_bit are + // internal state with no register mapping, and they only reset on + // DOSETUP — which DM0_DRAW_SPAN does not set. The JIT fixture draws + // twice (once to request the compile), so without this it enters the + // measured draw one bit further along than the interpreter's single + // draw, and every pixel mismatches. compare_jit_interp carries the same + // fixup for the same reason. + unsafe { + let ctx = &mut *rex_j.context.get(); + ctx.zpat_bit = 31; + ctx.pat_bit = 31; + } + rex_j.jit_go_count.store(0, Ordering::Relaxed); + let jit = run(rex_j); + assert!(rex_j.jit_go_count.load(Ordering::Relaxed) > 0, + "no GO dispatched through the JIT — this would compare interpreter to itself"); + check(&jit, "jit"); + assert_eq!(interp, jit, "JIT and interpreter disagree on ZPATTERN span"); + } + + /// Scissor (SMASK0) clipping must agree between interpreter and JIT. + /// + /// Written because the JIT's smask loads are now gated on `ensmask_key` + /// (the compile-time clipmode bits), so a wrong gate would silently stop + /// clipping — and nothing else in this suite draws with clipping enabled: + /// SMASK0X appeared only in `rex3init` and a register read/write check, so + /// the whole suite passed either way. + /// + /// Draws a span wider than the scissor rect and requires both engines to + /// clip it identically, then repeats with ensmask off to confirm the same + /// span is *not* clipped (otherwise a shader that always clips would also + /// pass). + #[test] + fn jit_smask_clip_matches_interpreter() { + const Y: i32 = 200; + const X0: i32 = 0; + const X1: i32 = 120; + const CLIP_LO: i32 = 30; + const CLIP_HI: i32 = 80; + const WIDTH: usize = 140; + + let draw = |rex: &Rex3, clip: bool| -> Vec { + { + let fb = unsafe { &mut *rex.fb_rgb.get() }; + for x in 0..WIDTH { fb[Y as usize * 2048 + x] = 0; } + } + // SMASK0X/Y pack (min << 16) | max. The comparison in + // calculate_fb_address is against x_curr/y_curr, which are the + // COORD_BIAS-shifted coordinates (xy() biases them), so the bounds + // must be biased too — unbiased values clip everything away. + let lo = (CLIP_LO + REX3_COORD_BIAS) as u32 & 0xFFFF; + let hi = (CLIP_HI + REX3_COORD_BIAS) as u32 & 0xFFFF; + reg(rex, REX3_SMASK0X, (lo << 16) | hi); + let ylo = (0 + REX3_COORD_BIAS) as u32 & 0xFFFF; + let yhi = (1023 + REX3_COORD_BIAS) as u32 & 0xFFFF; + reg(rex, REX3_SMASK0Y, (ylo << 16) | yhi); + // Keep cidmatch = 0xF (disabled) as rex3init sets it — writing a + // bare 0/1 here zeroes cidmatch, and cidmatch=0 rejects every + // pixel, so nothing draws at all and the test looks like it is + // clipping when it is really drawing nothing. + let cidm = 0xFu32 << CLIPMODE_CIDMATCH_SHIFT; + reg(rex, REX3_CLIPMODE, cidm | if clip { 1 } else { 0 }); + reg(rex, REX3_DRAWMODE0, DM0_DRAW_SPAN); + reg(rex, REX3_DRAWMODE1, DM1_RGB24_SRC); + reg(rex, REX3_WRMASK, 0xFFFFFF); + reg(rex, REX3_COLORRED, 255u32 << 11); + reg(rex, REX3_COLORGRN, 255u32 << 11); + reg(rex, REX3_COLORBLUE, 255u32 << 11); + reg(rex, REX3_XYENDI, xy(X1, Y)); + reg_go(rex, REX3_XYSTARTI, xy(X0, Y)); + rex.wait_idle(); + let fb = unsafe { &*rex.fb_rgb.get() }; + (0..WIDTH).map(|x| fb[Y as usize * 2048 + x] & 0xFFFFFF).collect() + }; + + for clip in [true, false] { + let rex_i = make_rex3(); + rex3init(rex_i); + let interp = draw(rex_i, clip); + + let rex_j = make_rex3_jit(); + rex3init(rex_j); + let _ = draw(rex_j, clip); // request compile + { + let cm = unsafe { (*rex_j.context.get()).clipmode } & CLIPMODE_JIT_KEY_MASK; + if let Some(ref jit) = rex_j.rex_jit { + let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30); + while !jit.compiled_pairs().iter() + .any(|&(a, _, c)| a == DM0_DRAW_SPAN && c == cm) + { + assert!(std::time::Instant::now() < deadline, + "JIT compile timed out for clip={clip} cm={cm:#x}"); + std::thread::sleep(std::time::Duration::from_millis(5)); + } + } + } + rex_j.jit_go_count.store(0, Ordering::Relaxed); + let jit = draw(rex_j, clip); + + assert!(rex_j.jit_go_count.load(Ordering::Relaxed) > 0, + "clip={clip}: no GO dispatched through the JIT"); + + let lit = |v: &Vec| (0..WIDTH).filter(|&x| v[x] != 0).count(); + if clip { + // Both engines must clip to the scissor rect, not draw the full span. + assert!(lit(&interp) > 0 && lit(&interp) < (X1 - X0) as usize, + "interpreter did not clip: {} px lit of {}", lit(&interp), X1 - X0); + for x in 0..WIDTH { + let inside = (x as i32) >= CLIP_LO && (x as i32) <= CLIP_HI; + if !inside { + assert_eq!(interp[x], 0, "interpreter drew outside scissor at x={x}"); + } + } + } else { + assert!(lit(&interp) >= (X1 - X0) as usize, + "ensmask off should not clip: only {} px lit", lit(&interp)); + } + assert_eq!(interp, jit, + "clip={clip}: JIT scissor result differs from interpreter\n \ + interp lit {} px, jit lit {} px", lit(&interp), lit(&jit)); + } + } + + // NOTE: no LSADVLAST interpreter-vs-JIT test here on purpose. The JIT was + // advancing the line stipple on the last pixel unconditionally where the + // interpreter gates on LSADVLAST (fixed in rex3_jit/compiler.rs), but two + // attempts to build a test that observes the difference both passed with + // the bug reinstated: DOSETUP-per-segment resets pat_bit, and the + // LSSAVE/LSRESTORE bracketing used for connected stipples round-trips + // lsrcount. A test that passes either way is worse than none. Deferred + // until a real XL Indy is available to say which behaviour is correct -- + // see the UNVERIFIED note in compiler.rs's line-shader pattern advance. + /// GFIFO pressure sweep: how much can we draw per second, as primitives shrink? /// /// `jit_timing_shade_scanlines_fullscreen` already goes through the GFIFO @@ -3209,6 +3565,11 @@ mod jit_tests { let dm1 = DM1_RGB24_SRC; let dm0_plain = DM0_DRAW_SPAN | (1 << 18); // shade + stoponx + // Flat fill: same span, no SHADE. The primitive colour is then constant + // for the whole draw, which is the case the entry-block colour hoist in + // rex3_jit/compiler.rs targets -- and the common one in real content + // (solid rectangles, window fills), which the Gouraud rows never cover. + let dm0_flat = DM0_DRAW_SPAN; // Depth mode as the GL driver actually drives it: ENZPATTERN (bit 12) // for the coverage mask AND LENGTH32 (bit 15), which hard-caps the draw // at 32 pixels (see execute_go's `length32 && pixel_count > 32`). That @@ -3219,8 +3580,11 @@ mod jit_tests { // Draw spans of `len` pixels for BUDGET, through the GFIFO. // Returns (pixels drawn, queue entries pushed, elapsed nanos). - let run = |rex: &Rex3, len: i32, zpat: bool| -> (u64, u64, u64) { - reg(rex, REX3_DRAWMODE0, if zpat { dm0_zpat } else { dm0_plain }); + let run = |rex: &Rex3, len: i32, zpat: bool, shade: bool| -> (u64, u64, u64) { + let dm0_sel = if zpat { dm0_zpat } + else if shade { dm0_plain } + else { dm0_flat }; + reg(rex, REX3_DRAWMODE0, dm0_sel); reg(rex, REX3_DRAWMODE1, dm1); reg(rex, REX3_WRMASK, 0xFFFFFF); reg(rex, REX3_SLOPERED, 2u32 << 11); @@ -3245,13 +3609,13 @@ mod jit_tests { // a constant) keeps the per-pixel test honest and stops // the value being hoisted; the alternating-ish patterns // reject roughly half the pixels. - reg(rex, REX3_ZPATTERN, (0xAAAA_AAAAu32 ^ (i as u32).wrapping_mul(2654435761))); + reg(rex, REX3_ZPATTERN, 0xAAAA_AAAAu32 ^ (i as u32).wrapping_mul(2654435761)); } reg(rex, REX3_COLORRED, ((i * 7 % 200) as u32) << 11); reg(rex, REX3_COLORGRN, ((i * 3 % 180) as u32) << 11); reg(rex, REX3_COLORBLUE, ((i * 5 % 160) as u32) << 11); reg(rex, REX3_XYENDI, xy(x0 + len - 1, y)); - rex.write32(go_addr(REX3_XYSTARTI), xy(x0, y)); + w32(rex, go_addr(REX3_XYSTARTI), xy(x0, y)); spans += 1; } if start.elapsed() >= BUDGET { break; } @@ -3266,11 +3630,15 @@ mod jit_tests { let rex_interp = make_rex3(); rex3init(rex_interp); + // Same device, but with the generated LLVM shaders loaded — the path a + // shipping build actually takes for a covered shape. + let rex_pre = make_rex3_precompiled(); + rex3init(rex_pre); let rex_jit = make_rex3_jit(); rex3init(rex_jit); // Force both shader variants compiled before timing. - for dm0 in [dm0_plain, dm0_zpat] { + for dm0 in [dm0_flat, dm0_plain, dm0_zpat] { reg(rex_jit, REX3_DRAWMODE0, dm0); reg(rex_jit, REX3_DRAWMODE1, dm1); reg(rex_jit, REX3_XYENDI, xy(63, 0)); @@ -3287,13 +3655,13 @@ mod jit_tests { } // Median of `SAMPLES` runs, plus the observed min/max, in Mpx/s. - let sample = |rex: &Rex3, len: i32, zpat: bool| -> (u64, u64, u64, u64, u64, u64) { + let sample = |rex: &Rex3, len: i32, zpat: bool, shade: bool| -> (u64, u64, u64, u64, u64, u64) { let mut rates = Vec::with_capacity(SAMPLES); let mut entries = 0u64; let mut last_ms = 0u64; let mut last_spans = 0u64; for _ in 0..SAMPLES { - let (px, e, ns) = run(rex, len, zpat); + let (px, e, ns) = run(rex, len, zpat, shade); entries = e; last_ms = ns / 1_000_000; last_spans = px / if zpat { len.min(32) } else { len } as u64; @@ -3309,7 +3677,19 @@ mod jit_tests { // than no number: it looks like a fast configuration. Likewise a "JIT" // column that is really the interpreter. Check both before reporting, // on both engines and both modes, rather than trusting the setup. - for (rex, engine) in [(rex_interp, "interp"), (rex_jit, "jit")] { + // Report the exact keys this benchmark draws, so the generated table + // can be built for them: the corpus comes from real IRIX drawing and + // does not otherwise contain these synthetic shapes. + { + let cm = unsafe { (*rex_interp.context.get()).clipmode } & CLIPMODE_JIT_KEY_MASK; + for (name, d0) in [("flat", dm0_flat), ("plain", dm0_plain), ("zpat", dm0_zpat)] { + let nd1 = crate::rex3_shape::normalize_dm1(dm1, DRAWMODE0_OPCODE_DRAW); + println!(" bench shape {name:<5}: dm0={d0:#010x} dm1={nd1:#010x} cm={cm:#010x} \ + precompiled={}", crate::rex3_shaders::lookup(d0, nd1, cm).is_some()); + } + } + + for (rex, engine) in [(rex_interp, "generic"), (rex_pre, "precomp"), (rex_jit, "jit")] { for (zpat, mode) in [(false, "plain"), (true, "zpat")] { // Clear a known region, draw one span into it, confirm it moved. let probe_y = 700; @@ -3342,28 +3722,42 @@ mod jit_tests { let jit_gos = rex.jit_go_count.load(Ordering::Relaxed) - go_before; let int_gos = rex.interp_go_count.load(Ordering::Relaxed) - int_before; + let counters_live = cfg!(feature = "rexdiag"); println!(" validate {engine:>6}/{mode:<5}: {changed:>2}/32 px written, \ - GOs jit={jit_gos} interp={int_gos}"); + GOs jit={jit_gos} interp={int_gos}{}", + if counters_live { "" } else { " (counters disabled: rexdiag off)" }); + // The dispatch counters live behind `rexdiag`, which `lightning` + // turns off (they are lock-prefixed RMWs on the per-GO path). + // Under lightning both read 0 because they are compiled out, not + // because dispatch failed, so this check would make the sweep + // unrunnable on exactly the build it most needs to measure. + #[cfg(feature = "rexdiag")] if engine == "jit" { assert!(jit_gos > 0, "{engine}/{mode}: no GO dispatched through the JIT (jit={jit_gos} \ interp={int_gos}) — the 'jit' column would just be the interpreter"); } + #[cfg(not(feature = "rexdiag"))] + let _ = (jit_gos, int_gos); } } - for (label, zpat) in [("plain Gouraud", false), ("ZPATTERN-masked (LENGTH32: 32px draws)", true)] { + for (label, zpat) in [("flat (no SHADE)", false), ("plain Gouraud", false), ("ZPATTERN-masked (LENGTH32: 32px draws)", true)] { println!("\n=== GFIFO pressure sweep: {label} ({} ms per cell) ===", BUDGET.as_millis()); - println!(" {:>6} {:>10} {:>21} {:>21} {:>8} {:>11} {:>17}", - "span", "entries/px", "interp Mpx/s [min-max]", "jit Mpx/s [min-max]", - "jit x", "ms i/j", "spans i/j"); + println!(" {:>6} {:>10} {:>7} {:>7} {:>7} {:>9} {:>9}", + "span", "entries/px", "generic", "precomp", "jit", + "precomp x", "jit x"); + println!(" {:>6} {:>10} {:>7} {:>7} {:>7}", + "", "", "Mpx/s", "Mpx/s", "Mpx/s"); // ZPATTERN draws are capped at 32 pixels, so sweeping span length // past that measures nothing new -- one row is the whole story. let lens: &[i32] = if zpat { &[32, 16, 8] } else { &SPAN_LENS }; for &len in lens { - let (i_mpx, i_lo, i_hi, entries, i_ms, i_spans) = sample(rex_interp, len, zpat); - let (j_mpx, j_lo, j_hi, _, j_ms, j_spans) = sample(rex_jit, len, zpat); + let shade = label != "flat (no SHADE)"; + let (i_mpx, i_lo, i_hi, entries, i_ms, i_spans) = sample(rex_interp, len, zpat, shade); + let (p_mpx, _p_lo, _p_hi, _, _p_ms, _p_spans) = sample(rex_pre, len, zpat, shade); + let (j_mpx, j_lo, j_hi, _, j_ms, j_spans) = sample(rex_jit, len, zpat, shade); let drawn = if zpat { len.min(32) } else { len } as u64; // entries/px uses pixels actually rasterized (LENGTH32 caps // ZPATTERN draws at 32), not the span length requested. @@ -3375,12 +3769,12 @@ mod jit_tests { // ~1.00 by construction and says nothing. (It printed a // reassuring "1.00x" next to cells where the JIT was doing // half the interpreter's work.) - println!(" {:>6} {:>10.3} {:>6}[{:>5}-{:>6}] {:>6}[{:>5}-{:>6}] {:>7.2}x {:>5}/{:<5} {:>8}/{:<8}", + println!(" {:>6} {:>10.3} {:>7} {:>7} {:>7} {:>8.2}x {:>8.2}x", len, per_px, - i_mpx, i_lo, i_hi, - j_mpx, j_lo, j_hi, - j_mpx as f64 / i_mpx.max(1) as f64, - i_ms, j_ms, i_spans, j_spans); + i_mpx, p_mpx, j_mpx, + p_mpx as f64 / i_mpx.max(1) as f64, + j_mpx as f64 / i_mpx.max(1) as f64); + let _ = (i_lo, i_hi, j_lo, j_hi, i_ms, j_ms, i_spans, j_spans); } } println!("\n For comparison: guest-side gltest --bench ~44 Mpx/s,\n \x20 --bench --depth ~20 Mpx/s.\n"); @@ -3600,7 +3994,7 @@ mod jit_tests { fn jit_iline_step_mode() { let dm1 = DM1_CI8_SRC; // step mode dm0: same adrmode but no stoponx/stopony/dosetup - let dm0_cont = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE; + let dm0_cont = DRAWMODE0_OPCODE_DRAW | DRAWMODE0_ADRMODE_I_LINE_SH; // We compare a single continuation step (after DOSETUP already set up Bresenham state). // Setup: issue the DOSETUP GO first (interpreter-only, not JIT), then compare one step. compare_jit_interp(0, 0, 14, 8, @@ -3870,7 +4264,7 @@ mod jit_tests { #[test] fn jit_hostr_ci8_block_32bit() { // DM0 for READ - let dm0_read = DRAWMODE0_OPCODE_READ | DRAWMODE0_ADRMODE_BLOCK | DM0_STOPONXY; + let dm0_read = DRAWMODE0_OPCODE_READ | DRAWMODE0_ADRMODE_BLOCK_SH | DM0_STOPONXY; let dm1 = DM1_CI8_HOSTRW; // Fill 4 pixels with known CI8 values using interpreter @@ -3928,7 +4322,7 @@ mod jit_tests { /// Mirrors test_hostr_rgb24_read_block_32bit. #[test] fn jit_hostr_rgb24_block_32bit() { - let dm0_read = DRAWMODE0_OPCODE_READ | DRAWMODE0_ADRMODE_BLOCK | DM0_STOPONXY; + let dm0_read = DRAWMODE0_OPCODE_READ | DRAWMODE0_ADRMODE_BLOCK_SH | DM0_STOPONXY; let dm1 = DM1_RGB24_HOSTRW; let pixels_in: &[u32] = &[0x112233, 0x445566, 0x778899, 0xAABBCC]; let width = pixels_in.len() as i32; @@ -4003,7 +4397,7 @@ mod jit_tests { /// no-STOPONY shape — the gap that let this bug ship. #[test] fn jit_hostr_ci8_block_multirow_no_stopony() { - let dm0_read = DRAWMODE0_OPCODE_READ | DRAWMODE0_ADRMODE_BLOCK | DM0_COLORHOST; + let dm0_read = DRAWMODE0_OPCODE_READ | DRAWMODE0_ADRMODE_BLOCK_SH | DM0_COLORHOST; let dm1 = DM1_CI8_HOSTRW; // 8bpp packed, 4 pixels/word let width = 6i32; // 2 words/row (ceil(6/4)) let height = 3i32; @@ -4305,11 +4699,11 @@ mod jit_tests { fn jit_blend_blendalpha_matches_interp() { for blendalpha in [false, true] { let dm1 = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) - | DRAWMODE1_COMPARE_DISABLE | (1 << 18) + | DRAWMODE1_COMPARE_DISABLE_SH | (1 << 18) | (DRAWMODE1_BF_SA << 19) | (DRAWMODE1_BF_MSA << 22) - | ((blendalpha as u32) << 27) | DRAWMODE1_LOGICOP_SRC; + | ((blendalpha as u32) << 27) | DRAWMODE1_LOGICOP_SRC_SH; let dm1_src = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) - | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC; + | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH; let dm0 = DM0_DRAW_BLOCK; let alphas: [u32; 5] = [0, 8, 64, 128, 255]; @@ -4367,6 +4761,52 @@ mod jit_tests { } } + + /// FASTCLEAR with CID checking ENABLED must draw as an ordinary draw. + /// + /// rex3.pdf says so three times — DRAWMODE1 bit 17 ("when CID checking + /// disabled (CLIPMODE CIDMATCH = 0xF)"), §3.5.5 ("CID checking is not + /// allowed for this drawing mode"), and the programming notes ("REX3 will + /// disable FASTCLEAR mode if CID checking is enabled ... host must setup + /// fast clear operation by writing COLORVRAM and also setting up DRAWMODE + /// and COLORI"). The COLORI advice is the tell: COLORI is what gets used + /// when the window system turns CID checking on behind GL's back. + /// + /// jit_fastclear_rgb24 cannot catch this — it pins cidmatch to 0xF, where + /// the question does not arise. This was invisible for another reason too: + /// rex3_simd::try_fastclear_block intercepted BLOCK draws before + /// execute_go's processor selection and never checked CID, so BOTH engines + /// wrote COLORVRAM and agreed. Removing that path exposed the real + /// divergence. See rules/rex3/fastclear-cid-divergence.md. + /// + /// Colour registers are o12.11 DDA values (get_colori shifts right by 11), + /// so they are written as `component << 11`, not as packed RGB24 — writing + /// packed bytes here clamps to black and makes the test vacuous. + #[test] + fn jit_fastclear_with_cid_checking_matches_interp() { + let dm1 = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) + | DRAWMODE1_LOGICOP_SRC_SH | (1 << 17) | DRAWMODE1_COMPARE_DISABLE_SH; + let dm0 = DM0_DRAW_BLOCK; + compare_jit_interp(0, 0, 7, 7, + |rex| { + reg(rex, REX3_DRAWMODE1, dm1); + // Distinct from the COLORI-derived colour so the two colour + // sources cannot be confused. + reg(rex, REX3_COLORVRAM, 0xABCDEF); + reg(rex, REX3_COLORRED, 0x40u32 << 11); + reg(rex, REX3_COLORGRN, 0x50u32 << 11); + reg(rex, REX3_COLORBLUE, 0x60u32 << 11); + reg(rex, REX3_WRMASK, 0xFFFFFF); + // CID checking ON, permitting CID 0. make_rex3 zeroes fb_aux, so + // every pixel has CID 0 and passes — isolating the colour-source + // question from write suppression. + reg(rex, REX3_CLIPMODE, 0x1 << 9); + reg(rex, REX3_XYENDI, xy(7, 7)); + reg(rex, REX3_XYSTARTI, xy(0, 0)); + }, + dm0, dm1, + ); + } } // --------------------------------------------------------------------------- @@ -4490,11 +4930,11 @@ mod gfifo_tests { const DM1_RGB12_BLEND: u32 = DRAWMODE1_PLANES_RGB | (2 << 3) | (1 << 15) - | DRAWMODE1_COMPARE_DISABLE + | DRAWMODE1_COMPARE_DISABLE_SH | (1 << 18) | (4 << 19) | (5 << 22) - | DRAWMODE1_LOGICOP_SRC; + | DRAWMODE1_LOGICOP_SRC_SH; /// Write an opaque blended pixel into the HIGH 12-bit slot and read it back. /// Before the fix the high slot received 0 while the low slot kept whatever was @@ -4552,7 +4992,7 @@ fn test_blend_opaque_matches_logicop_src() { let rex = make_rex3(); rex3init(&rex); let dm1_src = DRAWMODE1_PLANES_RGB | (2 << 3) | (1 << 15) - | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC; + | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH; for (x, dm1) in [(20, dm1_src), (21, DM1_RGB12_BLEND)] { reg(&rex, REX3_DRAWMODE1, dm1); @@ -4582,7 +5022,7 @@ fn test_blend_alpha_test_discards_zero_alpha() { let rex = make_rex3(); rex3init(&rex); // compare = 0b101 (!=) instead of the disable pattern. - let dm1 = (DM1_RGB12_BLEND & !DRAWMODE1_COMPARE_DISABLE) | (0b101 << 12); + let dm1 = (DM1_RGB12_BLEND & !DRAWMODE1_COMPARE_DISABLE_SH) | (0b101 << 12); reg(&rex, REX3_DRAWMODE1, dm1); reg(&rex, REX3_WRMASK, 0xffffff); reg(&rex, REX3_ALPHAREF, 0); @@ -4613,9 +5053,9 @@ fn test_blend_alpha_test_discards_zero_alpha() { /// Build a 24bpp RGB blend DRAWMODE1 with the given factors and BLENDALPHA. fn dm1_blend24(sfactor: u32, dfactor: u32, blendalpha: bool) -> u32 { - DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) | DRAWMODE1_COMPARE_DISABLE + DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) | DRAWMODE1_COMPARE_DISABLE_SH | (1 << 18) | (sfactor << 19) | (dfactor << 22) - | ((blendalpha as u32) << 27) | DRAWMODE1_LOGICOP_SRC + | ((blendalpha as u32) << 27) | DRAWMODE1_LOGICOP_SRC_SH } /// Paint a single pixel with the given mode/colour and return what landed. @@ -4653,7 +5093,7 @@ fn test_blendalpha0_sa_one_is_additive() { rex3init(&rex); // Lay down a destination first, with blending off. let dm1_src = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) - | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC; + | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH; blend_one(&rex, 32, 40, dm1_src, 255, 0x202020); // Now blend additively over it. let px = blend_one(&rex, 32, 40, @@ -4671,7 +5111,7 @@ fn test_blendalpha0_substitutes_sfactor_only() { let rex = make_rex3(); rex3init(&rex); let dm1_src = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) - | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC; + | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH; // Destination 0x404040, source 0x101010 at alpha 8. blend_one(&rex, 50, 50, dm1_src, 255, 0x404040); let px = blend_one(&rex, 50, 50, @@ -4690,7 +5130,7 @@ fn test_blendalpha1_uses_alpha_in_both_factors() { let rex = make_rex3(); rex3init(&rex); let dm1_src = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) - | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC; + | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH; blend_one(&rex, 51, 50, dm1_src, 255, 0x404040); let px = blend_one(&rex, 51, 50, dm1_blend24(DRAWMODE1_BF_SA, DRAWMODE1_BF_MSA, true), 8, 0x101010); @@ -4710,7 +5150,7 @@ fn test_afunction_uses_real_alpha_not_blendalpha() { let rex = make_rex3(); rex3init(&rex); let dm1_src = DRAWMODE1_PLANES_RGB | (3 << 3) | (1 << 15) - | DRAWMODE1_COMPARE_DISABLE | DRAWMODE1_LOGICOP_SRC; + | DRAWMODE1_COMPARE_DISABLE_SH | DRAWMODE1_LOGICOP_SRC_SH; for (i, blendalpha) in [false, true].iter().enumerate() { let x = 60 + i as i32; @@ -4718,7 +5158,7 @@ fn test_afunction_uses_real_alpha_not_blendalpha() { blend_one(&rex, x, 55, dm1_src, 255, 0x123456); // COMPARE = 0b101 ("!="), ALPHAREF = 0, source alpha = 0 -> must be killed. let dm1 = (dm1_blend24(DRAWMODE1_BF_SA, DRAWMODE1_BF_MSA, *blendalpha) - & !DRAWMODE1_COMPARE_DISABLE) | (0b101 << 12); + & !DRAWMODE1_COMPARE_DISABLE_SH) | (0b101 << 12); let px = blend_one(&rex, x, 55, dm1, 0, 0xFFFFFF); assert_eq!( px, 0x123456, @@ -4727,3 +5167,363 @@ fn test_afunction_uses_real_alpha_not_blendalpha() { ); } } + +// --------------------------------------------------------------------------- +// Plane access: data form must match the function-pointer form +// --------------------------------------------------------------------------- + +/// `plane_read_shift_mask` is the single source for how a plane read slices a +/// framebuffer word. Pin every `(planes, drawdepth, dblsrc)` combination against +/// the shift and mask it is required to produce, so a wrong bit offset is a test +/// failure rather than silently wrong pixels in every specialised read. +/// +/// The expected values are written out literally on purpose: checking the table +/// against a second implementation of the same table only proves the two copies +/// agree, not that either is right. +#[test] +fn plane_read_shift_mask_is_correct() { + // (planes, drawdepth, dblsrc) -> (shift, mask) + let cases: &[(u32, u32, bool, u32, u32)] = &[ + // RGB/RGBA: dblsrc selects the high half of the packed pair. + (DRAWMODE1_PLANES_RGB, 0, false, 0, 0xF), + (DRAWMODE1_PLANES_RGB, 0, true, 4, 0xF), + (DRAWMODE1_PLANES_RGB, 1, false, 0, 0xFF), + (DRAWMODE1_PLANES_RGB, 1, true, 8, 0xFF), + (DRAWMODE1_PLANES_RGB, 2, false, 0, 0xFFF), + (DRAWMODE1_PLANES_RGB, 2, true, 12, 0xFFF), + // 24bpp fills the word, so there is no second slot to select. + (DRAWMODE1_PLANES_RGB, 3, false, 0, 0xFFFFFF), + (DRAWMODE1_PLANES_RGB, 3, true, 0, 0xFFFFFF), + (DRAWMODE1_PLANES_RGBA, 1, false, 0, 0xFF), + // Aux planes live at fixed offsets in the aux word, depth-independent. + (DRAWMODE1_PLANES_OLAY, 0, false, 8, 0xFF), + (DRAWMODE1_PLANES_OLAY, 0, true, 16, 0xFF), + (DRAWMODE1_PLANES_PUP, 0, false, 2, 0x3), + (DRAWMODE1_PLANES_PUP, 0, true, 6, 0x3), + (DRAWMODE1_PLANES_CID, 0, false, 0, 0x3), + (DRAWMODE1_PLANES_CID, 0, true, 4, 0x3), + ]; + + for &(planes, depth, dblsrc, want_shift, want_mask) in cases { + let got = Rex3::plane_read_shift_mask(planes, depth, dblsrc); + assert_eq!( + got, + Some((want_shift, want_mask)), + "planes={planes} depth={depth} dblsrc={dblsrc}: \ + expected (>>{want_shift} & {want_mask:#x}), got {got:?}" + ); + } +} + +/// The aux/rgb split must agree with which framebuffer a plane actually lives +/// in — getting this backwards is the "JIT scr2scr aux plane" bug class. +#[test] +fn plane_is_aux_matches_framebuffer() { + for planes in [DRAWMODE1_PLANES_OLAY, DRAWMODE1_PLANES_PUP, DRAWMODE1_PLANES_CID] { + assert!(Rex3::plane_is_aux(planes), "planes={planes} should be aux"); + } + for planes in [DRAWMODE1_PLANES_RGB, DRAWMODE1_PLANES_RGBA] { + assert!(!Rex3::plane_is_aux(planes), "planes={planes} should be rgb"); + } +} + +/// `write_masked` is now the single implementation behind all seven writers; +/// confirm the mask semantics it centralises (untouched bits preserved). +#[test] +fn write_masked_preserves_unmasked_bits() { + let mut fb = vec![0xAAAA_AAAAu32; 4]; + Rex3::write_masked(&mut fb, 2, 0x5555_5555, 0x0000_FFFF); + assert_eq!(fb[2], 0xAAAA_5555, "masked bits replaced, others preserved"); + assert_eq!(fb[1], 0xAAAA_AAAA, "neighbours untouched"); + Rex3::write_masked(&mut fb, 2, 0xFFFF_FFFF, 0); + assert_eq!(fb[2], 0xAAAA_5555, "zero mask writes nothing"); +} + +/// The draw-shape corpus must be recorded in every build, not only when +/// Cranelift is compiled in. +/// +/// This was broken until the corpus moved from `RexJit` to `Rex3`: without +/// `rex-jit` there is no `RexJit`, so nothing recorded and nothing saved — the +/// generated shader table could never learn about new shapes from ordinary +/// runs, which is precisely the build most users have. +#[test] +fn corpus_records_shapes_without_jit() { + let rex = make_rex3(); + rex3init(rex); + + reg(rex, REX3_DRAWMODE1, DM1_RGB24_SRC); + reg(rex, REX3_WRMASK, 0xFFFFFF); + reg(rex, REX3_COLORRED, 0x40u32 << 11); + reg(rex, REX3_XYENDI, xy(4, 4)); + reg(rex, REX3_XYSTARTI, xy(0, 0)); + reg_go(rex, REX3_DRAWMODE0, DM0_DRAW_BLOCK); + wait(rex); + + let seen = rex.seen_shapes.lock(); + assert!( + !seen.is_empty(), + "no draw shapes recorded — the corpus cannot grow in this build" + ); + + // The recorded key must be the canonical one the table is keyed on, or a + // regenerated shader would be filed under something the dispatch never asks + // for. + let dm1 = crate::rex3_shape::normalize_dm1(DM1_RGB24_SRC, DRAWMODE0_OPCODE_DRAW); + // cm carries the clipmode key, which rex3init leaves at CIDMATCH=0xF + // (checking disabled) — read it back rather than assuming zero. + let cm = unsafe { (*rex.context.get()).clipmode } & CLIPMODE_JIT_KEY_MASK; + let expect = (DM0_DRAW_BLOCK, dm1, cm); + assert!( + seen.contains(&expect), + "expected {expect:?} in the corpus, got {:?}", + seen.iter().collect::>() + ); +} + +/// What does a single GFIFO register write cost? +/// +/// The draw backend is now fast enough that the sweep's small-span rows are +/// dominated by queue traffic rather than rasterisation: flat fill runs at +/// 645 Mpx/s across 1280-pixel spans (0.005 entries/px) and 49 Mpx/s across +/// 8-pixel spans (0.75 entries/px) — same pixels, 13x slower, purely entry +/// density. This isolates the push itself so that cost has a number. +/// +/// Measures the real bus entry point (`write32`), which is what the CPU store +/// path actually calls, including the register match and the BUS_BUSY retry. +/// The consumer runs concurrently, as it does in practice. +#[test] +#[ignore = "benchmark: runs for several seconds of wall clock"] +fn gfifo_push_cost() { + use std::time::{Duration, Instant}; + + let rex = make_rex3(); + rex3init(rex); + + const BUDGET: Duration = Duration::from_millis(500); + + // A register that is pure queue traffic: no CPU-thread side effect, so the + // write32 default arm runs and the entry lands in the fifo. + let push_one = |r: &Rex3| { + // Retry on BUS_BUSY exactly as the CPU does. + while r.write32(REX3_COLORRED, 0x40 << 11) == crate::traits::BUS_BUSY { + std::hint::spin_loop(); + } + }; + + // Warm up: let the consumer thread reach steady state. + for _ in 0..10_000 { push_one(rex); } + wait(rex); + + let start = Instant::now(); + let mut pushes: u64 = 0; + while start.elapsed() < BUDGET { + for _ in 0..1_000 { push_one(rex); } + pushes += 1_000; + } + let elapsed = start.elapsed(); + wait(rex); + + let ns_per = elapsed.as_nanos() as f64 / pushes as f64; + println!("\n=== GFIFO push cost ==="); + println!(" {pushes} pushes in {:?}", elapsed); + println!(" {:.1} ns/entry ({:.1} M entries/s)", ns_per, 1000.0 / ns_per); + println!(); + println!(" For scale: a GL triangle of ~32px costs tens of entries, so at"); + println!(" this rate the queue alone caps small-primitive throughput."); + assert!(pushes > 0); +} + +/// A 64-bit store is two register writes. Does pushing them as one atomic pair +/// beat two separate pushes? +/// +/// IRIX/GL issues 64-bit stores constantly (coordinate pairs, colour pairs, +/// Bresenham terms), so this is the common case, not a corner. +#[test] +#[ignore = "benchmark: runs for several seconds of wall clock"] +fn gfifo_push64_cost() { + use std::time::{Duration, Instant}; + + let rex = make_rex3(); + rex3init(rex); + const BUDGET: Duration = Duration::from_millis(500); + + // COLORRED/COLORGRN are adjacent and neither has a CPU-thread side effect, + // so a 64-bit store to the pair takes the queue path. + let push64 = |r: &Rex3| { + while r.write64(REX3_COLORRED, 0x0000_0040_0000_0050) == crate::traits::BUS_BUSY { + std::hint::spin_loop(); + } + }; + let push32x2 = |r: &Rex3| { + while r.write32(REX3_COLORRED, 0x40) == crate::traits::BUS_BUSY { + std::hint::spin_loop(); + } + while r.write32(REX3_COLORRED + 4, 0x50) == crate::traits::BUS_BUSY { + std::hint::spin_loop(); + } + }; + + for _ in 0..10_000 { push64(rex); } + wait(rex); + + let run = |f: &dyn Fn(&Rex3)| -> f64 { + let start = Instant::now(); + let mut n: u64 = 0; + while start.elapsed() < BUDGET { + for _ in 0..1_000 { f(rex); } + n += 1_000; + } + let e = start.elapsed(); + wait(rex); + // Nanoseconds per *entry pair*, so the two are directly comparable. + e.as_nanos() as f64 / n as f64 + }; + + let ns_pair = run(&push64); + let ns_two = run(&push32x2); + + println!("\n=== GFIFO 64-bit store: paired vs two separate pushes ==="); + println!(" write64 (one try_push2): {:>6.1} ns/pair", ns_pair); + println!(" two write32 calls: {:>6.1} ns/pair", ns_two); + println!(" speedup: {:>6.2}x", ns_two / ns_pair.max(0.001)); + println!(); + println!(" Three atomics per pair instead of six, and one trip through the"); + println!(" write32 register match instead of two."); + assert!(ns_pair > 0.0); +} + +/// What does the consumer-side dispatch lookup cost? +/// +/// With the backend at ~169 Mpx/s for Gouraud, a small-span GO spends far more +/// time in queue traffic and dispatch than in rasterisation. This isolates the +/// per-GO lookup: SipHash over a 12-byte key plus an RwLock read acquire, both +/// on the hot path, against the memo that is supposed to hide them. +#[test] +#[ignore = "benchmark"] +fn dispatch_lookup_cost() { + use std::time::{Duration, Instant}; + use std::collections::HashMap; + + const N: usize = 4096; + let keys: Vec<(u32, u32, u32)> = + (0..N).map(|i| (0x306 + i as u32, 0x3000_f019, (i as u32 % 16) << 9)).collect(); + + let map: HashMap<(u32, u32, u32), u32> = + keys.iter().enumerate().map(|(i, k)| (*k, i as u32)).collect(); + let locked = parking_lot::RwLock::new(map.clone()); + + const BUDGET: Duration = Duration::from_millis(300); + let bench = |name: &str, mut f: Box u32>| { + let start = Instant::now(); + let mut n = 0usize; + let mut acc = 0u32; + while start.elapsed() < BUDGET { + for _ in 0..1000 { acc = acc.wrapping_add(f(n % N)); n += 1; } + } + let ns = start.elapsed().as_nanos() as f64 / n as f64; + println!(" {name:<38} {ns:>6.1} ns (acc {acc})"); + ns + }; + + println!("\n=== dispatch lookup cost ==="); + let m = map.clone(); + let ks = keys.clone(); + let hash_only = bench("std HashMap (SipHash), no lock", Box::new(move |i| *m.get(&ks[i]).unwrap())); + let ks2 = keys.clone(); + let locked_ref = &locked; + let with_lock = bench("RwLock read + lookup", Box::new(move |i| *locked_ref.read().get(&ks2[i]).unwrap())); + let fxmap: crate::rex3_shape::ShapeMap = + keys.iter().enumerate().map(|(i, k)| (*k, i as u32)).collect(); + let ks_fx = keys.clone(); + let fx = bench("ShapeMap (FxHash), no lock", Box::new(move |i| *fxmap.get(&ks_fx[i]).unwrap())); + let fxlocked = parking_lot::RwLock::new({ + let m: crate::rex3_shape::ShapeMap = + keys.iter().enumerate().map(|(i, k)| (*k, i as u32)).collect(); + m + }); + let ks_fxl = keys.clone(); + let fxl_ref = &fxlocked; + let fxl = bench("RwLock read + lookup", Box::new(move |i| *fxl_ref.read().get(&ks_fxl[i]).unwrap())); + let _ = (fx, fxl); + let ks3 = keys.clone(); + let sorted: Vec<((u32, u32, u32), u32)> = { + let mut v: Vec<_> = keys.iter().enumerate().map(|(i, k)| (*k, i as u32)).collect(); + v.sort_unstable_by_key(|(k, _)| *k); + v + }; + let bsearch = bench("sorted slice binary_search", Box::new(move |i| { + let k = ks3[i]; + sorted.binary_search_by_key(&k, |(kk, _)| *kk).map(|j| sorted[j].1).unwrap() + })); + println!(); + println!(" lock overhead: {:.1} ns", with_lock - hash_only); + println!(" binary search vs hashmap+lock: {:.2}x", with_lock / bsearch.max(0.001)); + assert!(hash_only > 0.0); +} + +/// Where do the 73 ns of a GFIFO push actually go? +/// +/// Three atomics on an uncontended cache line should be ~15-20 ns. Measuring +/// 73 means something else dominates — most likely producer/consumer contention +/// on the ring's head/tail lines, which no amount of instruction-shaving fixes. +/// This separates the cases. +#[test] +#[ignore = "benchmark"] +fn gfifo_push_breakdown() { + use std::time::{Duration, Instant}; + const BUDGET: Duration = Duration::from_millis(400); + + let bench = |name: &str, f: &dyn Fn()| { + let start = Instant::now(); + let mut n: u64 = 0; + while start.elapsed() < BUDGET { + for _ in 0..1000 { f(); } + n += 1000; + } + let ns = start.elapsed().as_nanos() as f64 / n as f64; + println!(" {name:<44} {ns:>6.1} ns"); + ns + }; + + println!("\n=== GFIFO push breakdown ==="); + + // 1. The ring alone, no consumer running at all. + let quiet = crate::rex3::GFifo::new(); + let a = bench("try_push, NO consumer thread", &|| { + // Drain by hand so the ring never fills. + if !quiet.try_push(0x100, 0) { + while quiet.peek().is_some() { quiet.consume(); } + } + }); + + // 2. Same ring, but a consumer thread spinning on it — the real topology. + let live: &'static crate::rex3::GFifo = Box::leak(Box::new(crate::rex3::GFifo::new())); + let stop = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)); + let stop2 = stop.clone(); + let h = std::thread::spawn(move || { + while !stop2.load(Ordering::Relaxed) { + while live.peek().is_some() { live.consume(); } + std::hint::spin_loop(); + } + }); + let b = bench("try_push, consumer thread draining", &|| { + while !live.try_push(0x100, 0) { std::hint::spin_loop(); } + }); + stop.store(true, Ordering::Relaxed); + let _ = h.join(); + + // 3. Through the real bus entry point, for reference. + let rex = make_rex3(); + rex3init(rex); + let c = bench("write32 (full bus path + consumer)", &|| { + while rex.write32(REX3_COLORRED, 0x40 << 11) == crate::traits::BUS_BUSY { + std::hint::spin_loop(); + } + }); + + println!(); + println!(" ring alone: {:>6.1} ns", a); + println!(" + concurrent consumer: {:>6.1} ns (+{:.1} contention)", b, b - a); + println!(" + bus/register dispatch: {:>6.1} ns (+{:.1} overhead)", c, c - b); + assert!(a > 0.0); +} diff --git a/tools/gen_rex3_shaders.py b/tools/gen_rex3_shaders.py new file mode 100755 index 00000000..399ce732 --- /dev/null +++ b/tools/gen_rex3_shaders.py @@ -0,0 +1,215 @@ +#!/usr/bin/env python3 +"""Generate monomorphised REX3 draw shaders from the saved rex-jit corpus. + +Reads the `IRXP` profile the emulator writes on exit (default +`$HOME/.iris/rex-jit-profile.bin`) and emits a Rust source file containing one +wrapper per distinct draw mode, plus a sorted key -> function-pointer table that +`Rex3` loads into its shader map at startup. + +Each wrapper instantiates the *existing* generic draw pipeline with `ConstMode`, +so every mode field becomes a compile-time literal and LLVM folds the branches +away — the same specialisation Cranelift performs, done ahead of time. + +**This script deliberately does not decode the drawmode bits itself.** The +canonical form (the FASTCLEAR fold, dead blend inputs, host fields) lives in one +place, `rex3_shape::unpack`, which is a `const fn`; the generated code calls it +in const position so the constants are derived by the same code the runtime +uses. A Python reimplementation would be a second decoder free to drift, and the +whole point of the refactor is that there is only one. + +Usage: + tools/gen_rex3_shaders.py [profile ...] -o src/rex3_shaders.rs + +With no profile argument it reads $IRIS_REX_JIT_PROFILE, else +$HOME/.iris/rex-jit-profile.bin. Multiple profiles are merged and de-duplicated, +so corpora collected from different workloads can be combined. +""" + +import argparse +import os +import struct +import sys +from pathlib import Path + +MAGIC = b"IRXP" +VERSION = 2 +HEADER_LEN = 9 # magic(4) + version(1) + count(4) +ENTRY_LEN = 12 # dm0, dm1, cm — all u32 LE + + +def default_profile() -> Path: + env = os.environ.get("IRIS_REX_JIT_PROFILE") + if env: + return Path(env) + home = os.environ.get("HOME") + if home: + return Path(home) / ".iris" / "rex-jit-profile.bin" + return Path("rex-jit-profile.bin") + + +def read_profile(path: Path) -> list[tuple[int, int, int]]: + """Parse one IRXP v2 profile into (dm0, dm1, cm) triples.""" + try: + data = path.read_bytes() + except OSError as e: + print(f"warning: cannot read {path}: {e}", file=sys.stderr) + return [] + + if len(data) < HEADER_LEN or data[:4] != MAGIC: + print(f"warning: {path} is not an IRXP profile, skipping", file=sys.stderr) + return [] + if data[4] != VERSION: + print( + f"warning: {path} is IRXP v{data[4]}, expected v{VERSION}, skipping", + file=sys.stderr, + ) + return [] + + count = struct.unpack_from(" len(data): + print( + f"warning: {path} truncated after {i} of {count} entries", + file=sys.stderr, + ) + break + entries.append(struct.unpack_from(" str: + out: list[str] = [] + w = out.append + + w("// @generated by tools/gen_rex3_shaders.py — do not edit.") + w(f"// Source: {source}") + w("//") + w("// One wrapper per draw mode seen in the corpus, each instantiating the") + w("// generic pipeline with every mode field as a compile-time constant.") + w("// The constants are derived by calling `rex3_shape::unpack` in const") + w("// position, so this file cannot disagree with the runtime decoder.") + w("//") + w("// Regenerate after collecting a fatter corpus:") + w("// tools/gen_rex3_shaders.py -o src/rex3_shaders.rs") + w("") + w("use crate::rex3::Rex3Context;") + w("use crate::rex3_generic::{draw_with_fb, ConstMode, Framebuffers};") + w("use crate::rex3_shape::unpack;") + w("") + w("/// A specialised draw entry point.") + w("///") + w("/// **Identical to the Cranelift shader ABI** (`CompiledShader::entry`), so") + w("/// an LLVM-compiled shader and a Cranelift one are interchangeable at the") + w("/// dispatch site: `(ctx, fb_rgb, fb_aux)`, `extern \"C\"`.") + w("pub type ShaderFn = unsafe extern \"C\" fn(*mut Rex3Context, *mut u32, *mut u32);") + w("") + + # De-duplicate by the canonical mode, not the raw triple: two register + # combinations that fold to the same mode need only one instantiation. We + # cannot compute the fold here (that is unpack's job, in Rust), so we + # de-duplicate on the raw triple and let identical instantiations collapse + # at link time via ICF. + seen = sorted(set(entries)) + + for dm0, dm1, cm in seen: + name = f"shader_{dm0:08x}_{dm1:08x}_{cm:08x}" + args = ",\n ".join( + f"{{ unpack({dm0:#010x}, {dm1:#010x}, {cm:#010x}).{f} }}" for f in FIELDS + ) + w(f"/// dm0={dm0:#010x} dm1={dm1:#010x} cm={cm:#010x}") + w(f"unsafe extern \"C\" fn {name}(") + w(f" ctx: *mut Rex3Context,") + w(f" fb_rgb: *mut u32,") + w(f" fb_aux: *mut u32,") + w(f") {{") + w(f" let m: ConstMode<") + w(f" {args},") + w(f" > = ConstMode;") + w(f" let fb = Framebuffers {{ rgb: fb_rgb, aux: fb_aux }};") + w(f" draw_with_fb(unsafe {{ &mut *ctx }}, &fb, &m);") + w("}") + w("") + + w("/// Sorted by key, so the lookup can binary-search.") + w("///") + w("/// Key is the raw `(dm0, dm1, clipmode & CLIPMODE_JIT_KEY_MASK)` triple —") + w("/// the same key the Cranelift shader cache uses, so both stores answer the") + w("/// same question and a table hit can pre-empt a JIT compile.") + w(f"pub static SHADERS: &[((u32, u32, u32), ShaderFn)] = &[") + for dm0, dm1, cm in seen: + name = f"shader_{dm0:08x}_{dm1:08x}_{cm:08x}" + w(f" (({dm0:#010x}, {dm1:#010x}, {cm:#010x}), {name}),") + w("];") + w("") + w("/// Look up a specialised shader for this draw mode.") + w("#[inline]") + w("pub fn lookup(dm0: u32, dm1: u32, cm: u32) -> Option {") + w(" SHADERS") + w(" .binary_search_by_key(&(dm0, dm1, cm), |&(k, _)| k)") + w(" .ok()") + w(" .map(|i| SHADERS[i].1)") + w("}") + + return "\n".join(out) + "\n" + + +def main() -> int: + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("profiles", nargs="*", type=Path, help="IRXP profile(s) to read") + ap.add_argument("-o", "--output", type=Path, required=True, help="Rust file to write") + args = ap.parse_args() + + paths = args.profiles or [default_profile()] + entries: list[tuple[int, int, int]] = list(SEED_SHAPES) + print(f"seed: {len(SEED_SHAPES)} always-emitted shapes", file=sys.stderr) + for p in paths: + got = read_profile(p) + print(f"{p}: {len(got)} entries", file=sys.stderr) + entries.extend(got) + + unique = sorted(set(entries)) + print( + f"{len(entries)} entries -> {len(unique)} unique triples", + file=sys.stderr, + ) + + source = ", ".join(str(p) for p in paths) + args.output.write_text(emit(entries, source)) + print(f"wrote {args.output} ({len(unique)} shaders)", file=sys.stderr) + return 0 + + +if __name__ == "__main__": + sys.exit(main())