Appendix C Glossary of XNA and CNA Terms

A removed public renderer identity. Its reusable quantization and glyph-atlas logic now lives in the renderer-neutral CNA::Graphics::AsciiPostProcessEffect extension under modules/graphics-ext; the former renderer’s architecture is retained as history in Chapter 31.

One of CNA’s 50 public renderer identities; a third-party rendering library integrated directly via its native API. See Chapter 24.

CNA’s Emscripten-only, HTML <canvas>-based 2D graphics renderer. See Chapter 31.

The project this book is about: a native XNA 4.0 reimplementation compiled with a C++23 toolchain floor and written in a disciplined C++17/20 idiom, built on SDL3 with a pluggable graphics-renderer layer.

The central XNA class resolving an asset name to loaded content. A same- named .xnb is checked first; otherwise the registered loose reader can prefer a .cnj sidecar before its declared native formats. See Chapter 33.

DIRECTX9 is CNA’s public selector for its Direct3D 9 renderer, and Direct3D 9 is the API this book’s own zero-tolerance oracle methodology (see Oracle (D3D9) below) is built around, since a genuine XNA 4.0 runtime itself targets Direct3D 9. See Chapter 28.

DIRECTX11 selects CNA’s Direct3D 11 renderer, sharing a common D3DCommon foundation with D3D12 but implementing mip-chain generation via one native, whole-resource GenerateMips() call where D3D12 cannot. See Chapter 28.

DIRECTX12 selects CNA’s Direct3D 12 renderer; unlike D3D11 it has no native convenience call for mipmap generation and instead implements it as an explicit, face-scoped CPU readback/downsample/upload loop. See Chapter 28.

A Direct3D 12-owned table of resource-view descriptions rather than the resources themselves. CNA’s D3D12 renderer keeps separate RTV, DSV, CBV/SRV/UAV, and sampler heaps, currently using fixed-capacity bump allocation with no slot reclamation during a device lifetime; exhaustion is therefore a CNA implementation limit, not a Direct3D 12 resource-memory limit. See Chapter 28.

CNA’s graphics renderer fronting the sibling free-direct project; a 2D-only renderer in the same spirit as SDL_RENDERER. The former DX3 selector was renamed; current DIRECTX3 denotes a different, genuine DirectX 3 implementation. See Chapter 26.

OPENGLES2, OPENGLES3, OPENGL33, WEBGL1, and WEBGL2 are distinct public identities sharing CNA’s internal EasyGL factory and the sibling easy-gl project. EASYGL is not an accepted selector. See Chapter 22.

The XNA base class for a shader program bound to a GraphicsDevice. CNA ships five stock effects and renderer-specific runtime-compiled custom ShaderEffect path — see the shader/.fx gap chapter, Chapter 17.

The third-party UDP networking library backing CNA’s real Networking namespace implementation, wrapped by an internal ENetBackend. The same library free-direct’s own optional DirectPlay transport is built on. See Chapter 51.

A visible naming convention used by many non-XNA methods and types, such as MinimizeEXT() / RestoreEXT() on GameWindow. It is not the enforcement mechanism: the empty CNAEXT declaration macro supplies that marker, and an extension can use either naming style only as the source declares it. See Chapter 3.

An open-source C# reimplementation of the XNA 4.0 API, maintained independently of CNA. FNA is CNA’s primary behavioral reference and the subject of CNA’s own differential-testing infrastructure — not the same thing as the real Microsoft XNA 4.0 specification, a distinction this book returns to repeatedly (most sharply in the Media chapter’s Song finding, Chapter 46).

A GPU-completion counter used to tell when submitted Direct3D 12 command work has finished. CNA records one previous fence value for each of its two command-allocator slots and waits before reusing that slot, rather than waiting for the newly submitted frame itself; its simpler off-screen draw helpers intentionally wait synchronously for deterministic readback. See Chapter 28.

The XNA namespace covering Xbox-Live-era player profile, achievement, leaderboard, and system-UI concepts. CNA implements it with real local persistence where FNA does not implement it at all. See Chapter 49.

A captured frame compared with a retained reference image under an explicit tolerance and environment. CNA has renderer-specific golden tests; the reference’s provenance and the fact that the capture reached real pixels remain part of the claim. See Chapters 70 and 72.

A CNA graphics renderer that never rasterizes a real pixel at all — it only tracks and reports the last Clear() color and similar logic-only state. Used for fast unit testing and unable to produce a real screenshot for that reason. See Chapter 12.

The small enum GraphicsDevice::SupportsCapability takes, letting game code ask whether the active renderer supports a feature (3D rendering, occlusion queries, and so on) before attempting it, rather than attempting it and catching the resulting exception. Not every value is yet wired to answer honestly on every renderer: MRT and occlusion-query false positives are confirmed, and several device-dependent limits cannot be represented by one Boolean. See Chapter 19 and Appendix B for the qualified matrices.

The central class every rendering operation in CNA passes through; covered in Chapter 12.

CNA’s own JSON-based content envelope. For a registered loose reader it is considered after the same-name .xnb route and before that reader’s direct native formats. It is a typed envelope with per-loader payload rules, not one universal object schema. See Chapter 36.

Real XNA’s compiled binary content-pipeline output format. CNA has a substantial, explicit reader registry for XNB containers and object graphs; a same-named XNB is checked before loose CNJ/native routes. Reader coverage is finite and unsupported reader names or versions must remain explicit. See Chapters 34 and 35, and this book’s migration guide, Chapter 74.

A translator used by the FNA/FNA3D stack for compiled Direct3D 9 effect bytecode. CNA’s FNA3D family uses it for the bounded XNA/FNA Effect Framework route reached by the public byte-buffer constructor and XNB EffectReader; SDL_GPU, EasyGL and Vulkan expose explicit experimental opt-ins. It is not an .fx source, DXBC or MGFX loader. See Chapters 17 and 25.

sharp-runtime’s in-memory IO::Stream implementation, used where a real file path is unavailable (for example content loaded from Android assets). Closing it makes I/O operations throw ObjectDisposedException, but deliberately preserves the bytes for post-close ToArray() / GetBuffer() extraction. Its raw-buffer constructor is a known divergence: it creates a read-only stream where real .NET defaults to writable. See Chapter 56.

An empty declaration marker for non-XNA surface inside the XNA namespace tree. In strict harnesses it becomes a deprecation attribute and deliberate use fails under warnings-as-errors. The CNA_CNAEXT CMake option instead enables selected extension products; CNA::CnaExt is a link umbrella. These three mechanisms share a name fragment but are not interchangeable. See Chapter 3.

The pixel-for-pixel verification methodology comparing CNA’s DIRECTX9 renderer against a genuinely running XNA 4.0 runtime under Wine, at zero tolerance. See Chapter 28, and this book’s Windows/Wine chapter, Chapter 62.

A CNAEXT glTF 2.0-style metallic-roughness material effect with no real-XNA counterpart. Several implementation families carry PBR routes with different evidence; WebGPU is one of them and lacks the skinned sibling. See Chapters 15, 39, and 23.

Real .NET’s reflection-based automatic content-reader generation mechanism. CNA has no equivalent by permanent, explicit scope decision: only manually registered, explicit C++ ContentTypeReaders are supported, so content originally built against an implicit ReflectiveReader<T> needs an explicit ContentTypeWriter/reader pair rebuilt and registered before it will load. See Chapter 33.

The cross-platform windowing/input/audio library CNA is built on. Not itself a graphics renderer — SDL_RENDERER is built on SDL3’s own 2D renderer specifically.

A CNA graphics renderer built directly on SDL3’s own SDL_GPU API, using a fixed HLSL-style resource-binding order and a runtime GLSL-to-SPIR-V compile via libshaderc. See Chapter 23.28.

CNA’s default renderer outside Linux and Emscripten, selected by cmake/RendererSelection.cmake; a thin, 2D-only wrapper over SDL3’s own 2D renderer. See Chapter 30.

The sibling C++ reimplementation of a subset of the .NET base class library that CNA depends on for its non-XNA-specific vocabulary (System::Object, TimeSpan, EventHandler<T>, and more). Covered in full in Part VIII.

The CNA-original, CNAEXT real-rendering extension for the Avatar system, structurally separate from the faithful, inert base Avatar API. See Chapter 52.

A real CPU triangle rasterizer (edge functions, perspective-correct interpolation, per-pixel depth test) that never touches SDL video/X11/a GPU at all, making it a renderer that can produce a genuine screenshot in a headless, display-less environment. See Chapter 12.

The primary 2D rendering API in XNA and CNA alike. See Chapter 13.

The five built-in XNA shader effects — BasicEffect, AlphaTestEffect, DualTextureEffect, EnvironmentMapEffect, SkinnedEffect. See Chapter 15.

The Microsoft::Xna::Framework::Storage namespace — a real, if small, XNA namespace for user-data persistence (StorageDevice, StorageContainer), backed by a straightforward local-filesystem implementation underneath a faithfully-preserved fake-async API shape. See Chapter 50.

The renderer-independent description of a vertex layout: a stride plus VertexElement records naming offsets, formats, and usages. It is pure data and can be constructed on CNA’s 2D-only SDL renderer; an actual 3D draw that uses it is where that renderer correctly throws. See Chapters 7, 15, and 17.

A CNA graphics renderer targeting the Vulkan API directly. See Chapter 23.

CNA’s experimental graphics renderer targeting native wgpu-native. See Chapter 23.18.

Microsoft’s Cross-platform Audio Creation Tool format/engine, the format CNA’s own Audio namespace parses and plays back through SDL3_mixer rather than a FAudio-equivalent engine. See Chapter 45.

A sibling repository containing 544 indexed, machine-readable XML type files converted from XNA 4.0 documentation across 19 documented namespaces. CNA does not reference it in source or CI at the pin, and converted rows contain defects; use it as searchable inventory with normalization and independent oracles, not as a live or infallible ground truth. See Chapter 76.