What CNA offers

Game Loop

The Game base class provides the full Initialize(), LoadContent(), Update(), Draw(), UnloadContent() lifecycle. GameTime, GameComponent, DrawableGameComponent, GameComponentCollection, GameWindow, and FrameworkDispatcher are all implemented.

SpriteBatch

Full 2D rendering abstraction. Supports all SpriteSortMode values, transform matrix, custom Effect, blend and sampler states. DrawString with SpriteFont included. Renderer-agnostic across every renderer that supports 2D.

Texture2D

Full texture lifecycle: load from disk, GetData/SetData for all mip levels, SaveAsPng/SaveAsJpeg, pixel cache. RenderTarget2D is a proper subclass with FBO + depth renderbuffer (EasyGL) or off-screen Vulkan images.

Known gap: public format support is renderer-qualified. SKIA promotes a broad packed/float/normalized/DXT/BC7 set and IGL promotes verified Rg32 and Single; other families defer to the framework's SurfaceFormat::Color-only Texture2D rule. Texture3D and TextureCube still take the framework-only path. An internal native-format table does not by itself make that format constructible through the public API.

GraphicsDevice

Full render state API: BlendState, DepthStencilState, RasterizerState, SamplerState, scissor rect, viewport, render targets. DrawPrimitives, DrawIndexedPrimitives, DrawUserIndexedPrimitives, DrawInstancedPrimitives (hardware-accelerated on the renderers that support instancing), GetBackBufferData<Color> all implemented. GraphicsDevice exposes all 6 XNA events and all 5 Draw* families.

Cross-renderer caveat: SupportsCapability() fails open for most entries. The base explicitly opts out of multi-stream input and compiled effects and delegates stencil, but otherwise returns true; DIRECTX9, DIRECTX11, DIRECTX12 and SDL_GPU never override it at all. Treat a true as "not contradicted", not as evidence.

Math Types

Complete math library: Vector2/3/4, Matrix, Quaternion, Color, Rectangle, Point, BoundingBox, BoundingSphere, BoundingFrustum, Plane, Ray, MathHelper, Curve, CurveKey. All operators, static factories, and interpolation methods. Matrix has all 30 statics including Decompose, billboards, shadow and reflection; Curve::Evaluate handles all 5 loop types; Color carries all 141 named constants. The one known gap in the core Framework namespace is BoundingFrustum::Intersects(Ray), which throws.

PackedVector Types

All 17 XNA 4.0 PackedVector types implemented in the Microsoft::Xna::Framework::Graphics::PackedVector namespace: Byte4, HalfSingle, HalfVector2/4, NormalizedByte2/4, NormalizedShort2/4, Rg32, Rgba1010102, Rgba64, Short2/4, Vector2/4. A correct IEEE 754 half-float codec is implemented from scratch, handling subnormals, infinities and NaN in both directions. Known gap: ToString() and GetHashCode() are missing on all 17.

Input

The Input namespace has zero stubs. Keyboard exposes all ~145 Keys members; Mouse covers position, buttons and wheel; GamePad is a real SDL3 bridge with rumble, trigger rumble, LED control, hot-plug and per-device capability probing. TouchPanel genuinely detects all 10 XNA gesture types via a 474-line state machine with exponentially-smoothed flick velocity.

Known bug: TouchCollection reports IsReadOnly == true, but its mutators mutate instead of throwing.

Devices & Sensors

The Microsoft::Devices namespace talks to real hardware. Accelerometer and Gyroscope use the SDL sensor path on Android, iOS and desktop with m/s²-to-g conversion and concurrency handling. VibrateController uses haptics and deliberately excludes gamepads. Compass and Motion are Android-only and report NotSupported elsewhere.

Build and evidence: the CNA_DEVICES CMake option defaults to OFF. The path-filtered devices-tests.yml workflow turns it on and runs the Microsoft::Devices and CNA::Devices suites with UBSan on desktop Linux; hardware-dependent checks self-skip when no physical sensor is present.

Audio

Implemented (SDL3_mixer): SoundEffect, SoundEffectInstance (volume, pitch, pan, looping), DynamicSoundEffectInstance, MediaPlayer/Song.
XACT is a real parser and player, not a facade: a binary parser for XGS/XWB/XSB behind AudioEngine, SoundBank, WaveBank and Cue, using FACT volume and RPC behavior. The default output path is SDL3_mixer; audio-platform selection is independent.

Known gaps: only the first PlayWave per track is honoured; XMA and WMA wave-bank entries are not decoded — they log a diagnostic and yield a null sound rather than throwing, so the effect is silently missing; and reverb is a deliberate no-op because SDL3_mixer has no aux-send bus. .m4a/.aac are unplayable for the same reason.

Content System & .xnb Pipeline

Extensible ContentManager with the ContentTypeReader<T> pattern, loading loose files directly: Texture2D (PNG/BMP/etc.), SoundEffect (WAV), Song, Video, plus SpriteFont, Model and Effect from CNA's single .cnj JSON descriptor format.

A real read-side .xnb loader exists. It offers 50 built-in readers with FFmpeg and 49 without video, including typed external references and a renderer-qualified compiled-effect reader. LZX decompression, shared resources and malformed-input checks are implemented. Register the built-ins explicitly before loading; CNA does not author XNB files.

You must call CNA::Internal::Xnb::RegisterAllBuiltInXnbReaders() once at startup — a deliberate, documented design decision, but it does mean the registry is empty by default.

Known boundaries: CNA cannot discover arbitrary game types through .NET reflection, but a game can register an explicit ContentTypeReader<T> factory. VideoReader follows FFmpeg availability, typed external references are implemented, and the real EffectReader requires an active renderer with CompiledEffects. Closed generic readers still need explicit registration.

Networking

The Net namespace is real: genuine ENet over UDP, LAN discovery via broadcast with measured RTT for QoS, and loopback tests. Real transport is gated to SystemLink; PlayerMatch and Ranked no-op because they require Xbox Live, and voice chat is a no-op by design.

GamerServices & Avatar

All 52 GamerServices types are present with complete member signatures. There is no online service behind them — no Steam, no Xbox Live, no HTTP — but, unlike FNA's no-op shim, CNA backs them with a real local implementation that genuinely persists to disk. Achievements and leaderboard entries are written as JSON under SDL_GetPrefPath() using an atomic temp-file-and-rename, and they reload correctly in a later process.

Concretely: LeaderboardWriter and LeaderboardReader are real, with rating-descending sort, 1-based ranks, pivot centring and paging. Guide::BeginShowMessageBox/EndShowMessageBox and BeginShowKeyboardInput/EndShowKeyboardInput are complete CNA-original implementations, including SpriteBatch overlay rendering, password masking and real mouse hit-testing. What genuinely does nothing: fifteen Guide::Show* entry points (gamer card, marketplace, party, players, sign-in, messages and friends UI) are documented no-ops, and AvatarRenderer::Draw() validates its bones and then deliberately does nothing — faithful to the XNA reference assembly. The working avatar renderer sits behind the CNAEXT DrawRealEXT(), which does real GPU skinning of a 19-bone rig and is covered by pixel-readback tests.

What is genuinely present: enums, exceptions, event arguments and collection types are real data structures with .NET-shaped exception semantics; local achievement and leaderboard persistence is implemented.

3D Rendering

Four shader variants by vertex stride, depth test/write, blend, cull mode, matrix upload. Tested with the House 3D demo — procedural walls, roof, windows, door, floor with player movement and gravity. Also runs via WebGL 2 in the browser.

Effects System

All six XNA stock effects — BasicEffect, AlphaTestEffect, DualTextureEffect, EnvironmentMapEffect, SkinnedEffect, SpriteEffect — implemented natively in C++ rather than translated from bytecode. All IEffectMatrices, IEffectFog and IEffectLights interfaces, and EffectParameter with all Get/Set overloads.

Compiled effects: already-compiled XNA/FNA D3D9 Effect Framework binaries load on FNA3D and on opt-in EasyGL, SDL_GPU and Vulkan builds, including through XNB EffectReader. CNA does not compile HLSL .fx source or accept MGFX. CNAEXT ShaderEffect remains the renderer-oriented GLSL/SPIR-V path.

PBR & Skeletal Animation

Beyond the XNA stock set, CNA ships non-XNA effects and types: PbrEffect and SkinnedPbrEffect for physically based rendering, and a full skeletal-animation stack in SkinnedModelEXT with AnimationPlayer, AnimationClipEXT, BoneTrackEXT and KeyframeEXT. MorphTargetEXT adds blend shapes, alongside tangent and skinned vertex types and sRGB/BC7 surface formats. Render-pipeline settings (PbrMaterial, TonemappingMode, ShadowQuality) live in the CNA:: namespace.

Build boundary: the CNA_CNAEXT CMake option defaults to OFF, so these extensions are absent from an ordinary default build. Alpha.1 has no dedicated CNAEXT workflow; verify the exact extension and renderer configuration you ship.

Vertex & Index Buffers

VertexBuffer, DynamicVertexBuffer, IndexBuffer (16/32-bit), DynamicIndexBuffer. All four VertexPosition* types: VertexPositionColor, VertexPositionTexture, VertexPositionColorTexture, VertexPositionNormalTexture.

Model System

Model::Draw with bone transforms, IEffectMatrices binding, and a full mesh/part rendering pipeline. Models load from .cnj descriptors, from .gltf/.glb directly, or from .xnb via ContentManager. CNA's actual model content path is gltf_to_cnj, an offline glTF 2.0 → .cnj Model/AnimationClip converter that is built unconditionally.

SpriteFont

Full glyph data model, MeasureString, and SpriteBatch::DrawString with three overloads. Fonts loaded from .cnj descriptors naming a pre-rendered glyph atlas.

Media & Video Playback

Real: MediaPlayer genuinely plays songs through SDL3_mixer and exposes a real FFT spectrum and waveform via GetVisualizationData, captured from the live post-mix callback. VideoPlayer genuinely decodes video through FFmpeg (real libavcodec/libavformat/libswresample with PTS-driven pacing), plays the video's own audio track, and supports multi-track selection. The MediaLibrary catalogue is also real: it resolves your actual Music and Pictures folders through SDL_GetUserFolder, scans them recursively, parses ID3v2, Vorbis-comment, Opus and FLAC tags, probes durations, discovers album art, reads playlists and saves pictures to disk.

Known gaps: the three video translation units are excluded from the build entirely on Windows, Emscripten and Android — the headers still exist, so code calling Video or VideoPlayer compiles and then fails to link. Video playback is therefore native Linux/macOS only today. Note also that FFmpeg is a hard requirement on Linux and macOS, not an optional codec extra: CMake configuration fails without the libavcodec, libavformat, libavutil and libswresample development packages. Unrecognised video pixel formats render magenta rather than raising an error.

Storage

All 3 Storage types use real std::filesystem IO, a hand-written glob matcher, and <root>/<displayName>/Player{N} namespacing. The async Begin*/End* pairs execute synchronously. Caveat: alpha.1 has only one Storage test source with five statically discoverable test definitions, so applications should verify their target filesystem behavior.

Multisample Anti-Aliasing

Enabled via GraphicsDeviceManager: set PreferMultiSampling = true and MultiSampleCount on PresentationParameters before device creation. Real MSAA resolve is implemented on the Vulkan and SDL_GPU renderers. The WebGPU and Software renderers have no MSAA at all, and the 2D-only renderers do not apply.

OcclusionQuery

Hardware occlusion queries are implemented on EasyGL, which is the renderer to use for GPU-driven visibility culling. They are not available on WebGPU, and the 13 2D-only renderers (SDL_Renderer, Direct2D, Canvas, HTML_DOM, Skia, Blend2D, FreeDirect, DirectX1, GDI, SVG_DOM, OpenVG, NanoVG and PixiJS) have no GPU query API at all.

Context-Loss Recovery

GraphicsDevice exposes DeviceLost and DeviceReset events following the XNA pattern. EasyGL implements real GL context-loss recovery (relevant on Android and some desktop compositors), and DIRECTX9 implements full device-lost and D3DPOOL_DEFAULT recovery. Other renderers do not.

Windowing & Events

The default SDL3 platform manages windows and events. The IPlatform layer also has real SDL2, Headless and POSIX Terminal implementations selected with CNA_PLATFORM.

Selectable audio integration

CNA_AUDIO_PLATFORM independently selects SDL3, SDL2 or Null device code. Only SDL3 defines SOUND_ENABLED and links the SDL3_mixer engine used by SoundEffect, MediaPlayer, XACT and decoding. SDL2/Null compile the low-level device contract without providing equivalent alpha.1 XNA playback.

SDL3_image Loading

SDL3_image is used for loading PNG, JPG, and other texture formats into Texture2D. Vendored alongside SDL3.

SDL_Renderer Renderer

The most portable 2D renderer, built on SDL3's own hardware-accelerated renderer. 3D calls throw by design rather than quietly drawing nothing, and its capability reporting is written to match what it can actually do. Selected with -DCNA_GRAPHICS_RENDERER=SDL_RENDERER.

EasyGL (OpenGL) Renderer

The shared family behind five public profiles, including Linux's OPENGLES3 and Emscripten's WEBGL2 defaults. It provides shader-driven 2D/3D rendering and profile-specific capability boundaries. Selected with -DCNA_GRAPHICS_RENDERER=OPENGLES3.

bgfx Renderer

Integration with the bgfx cross-platform graphics library, pulled in through CMake FetchContent. Its shader and driver boundaries differ from CNA's native families; consult the renderer reference before shipping. Selected with -DCNA_GRAPHICS_RENDERER=BGFX.

Known gaps: shaders are built for GL/GLES/Vulkan/WebGPU only — no D3D or Metal, so 3D silently draws nothing on bgfx's default Windows and macOS renderers. DrawUserIndexedPrimitives corrupts geometry: the renderer never overrides CreateIndexBuffer32, so 32-bit indices are uploaded into a 16-bit buffer (every other 3D renderer implements this). Draw offsets are also ignored outside the wireframe path. Note too that bgfx.cmake is fetched at GIT_TAG master — the only unpinned dependency in the project.

Vulkan Renderer

A native Vulkan family with SPIR-V ShaderEffect, render-target and readback paths. XNA/FNA compiled Effect Framework bytecode is separately opt-in with CNA_VULKAN_COMPILED_EFFECTS. Selected with -DCNA_GRAPHICS_RENDERER=VULKAN.

Known gaps: see the Roadmap.

Direct3D 11 Renderer

Windows-only, hard-gated at CMake configure time, with state-object caches, MRT, instancing and runtime HLSL compilation for ShaderEffect. Native MSVC coverage is manual-dispatch. Selected with -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/mingw-w64.cmake -DCNA_GRAPHICS_RENDERER=DIRECTX11.

Verify capability boundaries: do not infer correct draw offsets or device support from the family's presence alone.

Direct3D 12 Renderer

A Windows-only Direct3D 12 family with PSO/root-signature caches and barrier tracking. Native MSVC coverage is manual-dispatch and remaining state-path boundaries are documented in the renderer reference. Selected with -DCMAKE_TOOLCHAIN_FILE=cmake/toolchains/mingw-w64.cmake -DCNA_GRAPHICS_RENDERER=DIRECTX12.

Known gaps: no scissor, no viewport, no stencil and no blend factor; MRT clears but never draws. SupportsCapability() is never overridden, and verification remains especially narrow.

WebGPU Renderer

An experimental renderer using native wgpu-native, with a working 2D baseline and early 3D path. Its capability boundary is narrower than the WebGPU API itself. Selected with -DCNA_GRAPHICS_RENDERER=WEBGPU.

Known gaps: it is a backbuffer-only forward renderer — no render targets at all, no MSAA, no cube or 3D textures, no queries, no instancing, and non-functional stencil. It also claims 5 capabilities through SupportsCapability() that it does not actually have.

Headless Renderer

Renders nothing by design: no window, GPU or graphics API calls. It provides argument validation, resource-lifecycle tracking and draw counters for game-logic CI. Selected with -DCNA_GRAPHICS_RENDERER=HEADLESS.

Be aware: ReadBackbuffer simply returns the last clear colour and discards the x/y coordinates. It is not a pixel oracle.

Software Renderer

A genuine CPU rasterizer with edge functions, a Z-buffer and perspective-correct interpolation into a CPU-owned framebuffer. Useful for GPU-free pixel tests. Selected with -DCNA_GRAPHICS_RENDERER=SOFTWARE.

Known gaps: TriangleList primitives only, no MSAA, and it claims 6 capabilities through SupportsCapability() that it does not have. Not a real-time renderer by design.

Direct3D 9 Renderer

Windows-only and the renderer used for the 39-scene XNA oracle comparison at zero tolerance. It includes shader, device-lost recovery and MRT paths; the oracle result is specific to DIRECTX9. Selected with -DCNA_GRAPHICS_RENDERER=DIRECTX9.

Note: created 2026-07-14 — one of the newest renderers. SupportsCapability() is not overridden.

SDL_GPU Renderer

Built on SDL3's GPU API with deferred/retained rendering, stencil and MSAA paths. Compiled XNA/FNA effects are separately opt-in with CNA_SDL_GPU_COMPILED_EFFECTS. Selected with -DCNA_GRAPHICS_RENDERER=SDL_GPU.

Known gaps: it drives a Vulkan device only today, despite SDL_GPU's broader potential. SupportsCapability() is not overridden. Created 2026-07-15.

FreeDirect (DirectDraw) Renderer

A DirectDraw-shaped 2D renderer fronting the sibling free-direct library. Despite the name it is cross-platform and uses a CPU compositor. Selected with -DCNA_GRAPHICS_RENDERER=FREEDIRECT.

Scope: 2D only. Created 2026-07-15.

ASCII post-process effect

Quantizes any Texture2D or RenderTarget2D into a glyph and colour grid. This used to be a renderer; it is now a CNAEXT post-process effect, CNA::Graphics::AsciiPostProcessEffect, which is a strictly better arrangement: because it works through the public Texture2D::GetData() and SpriteBatch API rather than a renderer-internal type, it now runs on any renderer, including 3D-rendered sources. The old renderer could only quantize its own 2D SDL frame.

Note: it is deliberately not an XNA Effect subclass — it performs its own multi-step CPU readback and re-upload, so it costs a GPU→CPU readback per draw. Requires -DCNA_CNAEXT=ON. It is not a terminal/TTY renderer; no such renderer exists.

Canvas Renderer

An Emscripten-only 2D renderer driving the browser's HTML canvas through EM_JS. Selected with -DCNA_GRAPHICS_RENDERER=CANVAS.

Evidence boundary: the module has 17 statically discoverable GoogleTest-family definitions, but that source count is not a browser pixel pass result.

Linux (x86_64)

The primary development platform, with OPENGLES3 as the default renderer and the broadest CI coverage. macOS also has an automatic CI job of its own for the METAL renderer. FFmpeg video decoding is available on Linux and macOS, but not on Windows, Emscripten or Android.

Windows (x86_64)

Reached through a MinGW-w64 cross-toolchain as well as native MSVC. Windows-gated DirectX/GDI paths have focused evidence, while the native D3D/GDI workflows remain manual-dispatch rather than automatic merge gates.

Android

Genuinely wired through CMake and the Android NDK — sensors link against android, and Compass/Motion use a real NDK fusion of 5 sensors. Caveats: there is no Android CI and no CMake preset, and FFmpeg video is unavailable on this target.

Emscripten / Web

A real path with six identities: WEBGL1/2, Canvas, HTML DOM, SVG DOM and PixiJS. Alpha.1 includes Emscripten multi-renderer build/link CI and selected browser runtime gates. FFmpeg video remains excluded and save persistence requires an explicit browser-storage path.

macOS / iOS

macOS/Metal has automatic CI. iOS is experimental and restricted to SDL_RENDERER: alpha.1 final-links a device app and launches a one-frame simulator smoke path, without a physical-device or pixel-correctness claim. tvOS is unsupported.