Namespace Organization Guide

This guide documents the complete namespace structure of FFXIVClientStructs, explaining the purpose and organization of each namespace and its sub-namespaces.

​

Complete Namespace Hierarchy

​

FFXIV Namespace

The primary namespace containing all FFXIV-specific game structures.

​

FFXIV.Application

Purpose: Application-level systems and networking

• FFXIV.Application.Network - Network protocol and packet handling

Key Classes: Network packet structures, protocol handlers

​

FFXIV.Client

Purpose: Core game client implementation The Client namespace is the largest and most frequently used, containing the main game systems:

FFXIV.Client.Game

Purpose: Core gameplay logic, character data, and game state Key Classes:

• ActionManager - Action execution and validation
• InventoryManager - Inventory and item management
• Character.Character - Player and NPC character data
• Object.GameObject - Base game object structure
• Camera - Camera control and positioning
• Balloon - Speech bubble system
• BGMSystem - Background music control

Subdirectories:

• Character - Character-specific structures
• Event - Event and cutscene systems
• Fate - FATE system
• Housing - Housing and furniture
• InstanceContent - Dungeon/raid instances
• Object - Game object base classes
• Status - Status effects and buffs
• UI - Game-related UI data

FFXIV.Client.Graphics

Purpose: Rendering, animation, and visual effects Key Classes:

• Scene.Camera - Scene camera systems
• Scene.Object - Renderable objects
• Render.Skeleton - Skeletal animation
• Kernel.Device - Graphics device management
• Vfx.VfxData - Visual effect data

Subdirectories:

• Animation - Animation systems
• Environment - Weather, time of day, environment
• Kernel - Core graphics systems
• Physics - Client-side physics
• Render - Rendering pipeline
• Scene - Scene management
• Vfx - Visual effects

FFXIV.Client.Network

Purpose: Client-side network handling Key Classes: Network session management, packet handlers

FFXIV.Client.Sound

Purpose: Audio playback and sound effects Key Classes: Sound management, audio routing

FFXIV.Client.System

Purpose: Core client systems and infrastructure Key Classes:

• Framework.Framework - Main application framework
• Memory.MemoryManager - Memory allocation
• Resource.ResourceManager - Resource loading
• String.Utf8String - UTF-8 string handling

Subdirectories:

• Configuration - Client configuration
• File - File I/O
• Framework - Application framework
• Input - Input handling
• Memory - Memory management
• Resource - Resource loading
• Scheduler - Task scheduling
• String - String utilities
• Threading - Thread management
• Timer - Timing systems

FFXIV.Client.UI

Purpose: User interface windows and addons Key Classes:

• AddonActionBar - Action bar hotbars
• AddonInventory - Inventory windows
• AddonCharacter - Character sheet
• AddonNamePlate - Player nameplates
• UIModule - Main UI system manager
• RaptureAtkModule - UI rendering module

Pattern: Most classes are named Addon[WindowName] and inherit from AtkUnitBase. Common Addons:

• Character sheets and equipment
• Inventory and item management
• Party and duty finder
• Social features (friends, FC, linkshells)
• HUD elements (hotbars, gauges, minimap)
• System menus and settings

FFXIV.Client.LayoutEngine

Purpose: UI layout and positioning Key Classes: Layout calculation and positioning systems

FFXIV.Client.SupportDesk

Purpose: GM support and reporting tools

​

FFXIV.Component

Purpose: Reusable component systems used throughout the client

FFXIV.Component.GUI

Purpose: UI toolkit and widget system Key Classes:

• AtkUnitBase - Base class for all UI windows
• AtkComponentButton - Button widget
• AtkComponentCheckBox - Checkbox widget
• AtkComponentList - List widget
• AtkTextNode - Text rendering node
• AtkImageNode - Image rendering node
• AtkResNode - Base resource node

Pattern: Classes prefixed with Atk (Adobe/Scaleform toolkit) Component Types:

• Nodes: AtkTextNode, AtkImageNode, AtkNineGridNode
• Components: AtkComponentButton, AtkComponentList, AtkComponentIcon
• Base: AtkUnitBase, AtkEventListener, AtkComponentBase

FFXIV.Component.Excel

Purpose: Game data sheet access (Excel files) Key Classes:

• ExcelModule - Excel data loading
• ExcelSheet - Data sheet access

Usage: Access to game databases (items, actions, quests, etc.)

FFXIV.Component.Exd

Purpose: Binary Excel data handling

FFXIV.Component.Text

Purpose: Text processing and macro expansion Key Classes:

• TextModule - Text processing
• Macro and placeholder expansion

FFXIV.Component.Completion

Purpose: Text completion and autocomplete

FFXIV.Component.Log

Purpose: Chat log and message handling

FFXIV.Component.Shell

Purpose: Command shell and text commands

FFXIV.Component.SteamApi

Purpose: Steam integration

​

FFXIV.Common

Purpose: Shared utilities used across namespaces Key Classes:

• Math.* - Mathematical utilities (vectors specific to FFXIV)
• TimePoint - Time representation
• Component.* - Shared component utilities
• Configuration.* - Configuration structures
• Lua.* - Lua scripting integration

Subdirectories:

• Component - Shared component patterns
• Configuration - Configuration structures
• Lua - Lua integration
• Math - Mathematical types

​

FFXIV.Shader

Purpose: Shader parameters and rendering data Key Classes:

• SceneParameter - Scene-wide shader parameters

​

STD Namespace

Purpose: C++ Standard Library container interop Provides managed wrappers for native C++ STL containers used throughout the game.

​

Core Containers

• StdVector<T> - Dynamic array (std::vector)
• StdList<T> - Doubly-linked list (std::list)
• StdDeque<T> - Double-ended queue (std::deque)
• StdMap<K, V> - Sorted map (std::map)
• StdSet<T> - Sorted set (std::set)
• StdPair<T1, T2> - Pair type (std::pair)

​

String Types

• StdString - std::string
• StdWString - std::wstring
• StdBasicString<T> - Base string template

​

Helpers

• STD.Helper.* - Container operation helpers
• STD.ContainerInterface.* - Container interface definitions

Usage: Interact with game’s native C++ containers safely from C#.

​

Havok Namespace

Purpose: Havok Physics and Animation engine structures

​

Havok.Animation

Purpose: Character animation and skeletal rigging Key Classes:

• hkaAnimation - Animation data
• hkaSkeleton - Skeletal structure
• hkaPose - Animation pose
• hkaAnimationControl - Animation playback control
• hkaAnimatedSkeleton - Animated skeleton instance

Subdirectories:

• Animation - Core animation data
• Deform/Skinning - Mesh skinning
• Mapper - Skeleton mapping/retargeting
• Motion - Motion data
• Playback - Animation playback
• Rig - Rigging structures

​

Havok.Common.Base

Purpose: Core Havok types and mathematics Key Classes:

• hkVector4f - 4D vector (SIMD)
• hkQuaternionf - Quaternion rotation
• hkMatrix3f, hkMatrix4f - Matrices
• hkTransformf - Transformation
• hkQsTransformf - Quaternion-scale-translation transform
• hkAabb - Axis-aligned bounding box

Subdirectories:

• Container - Havok containers (hkArray, etc.)
• Math - Math types
• Object - Base object system
• Reflection - Type reflection
• System/IO - I/O streams
• Thread - Threading primitives
• Types - Core types

​

Havok.Common.Serialize

Purpose: Havok data serialization Key Classes:

• hkLoader - Resource loading
• hkRootLevelContainer - Container for loaded data

​

Havok.Common.SceneData

Purpose: Scene and mesh data Key Classes:

• hkxMesh - Mesh data

​

SQEX Namespace

Purpose: Square Enix proprietary engine components

​

SQEX.CDev.Engine.Sd

Purpose: Sound engine (CDev = Crystal Development) Key Classes:

• SdMemoryAllocator - Sound memory allocation
• Driver.SoundController - Sound playback control

Note: Currently limited scope; may expand with future reverse engineering.

​

Interop Namespace

Purpose: Interoperability utilities for safe native memory access Key Classes:

• Pointer<T> - Type-safe pointer wrapper with bounds checking
• SpanExtensions - Extension methods for memory spans

Usage: Provides safe abstractions when working with raw pointers and memory.

​

Namespace to Game System Mapping

This table maps common game features to their corresponding namespaces:

​

Naming Conventions

Understanding naming patterns helps locate classes quickly:

​

UI Classes

• Addon[Name] - UI windows (e.g., AddonInventory, AddonActionBar)
• Atk[Type] - UI toolkit components (e.g., AtkUnitBase, AtkTextNode)
• RaptureAtk[Type] - UI rendering modules (e.g., RaptureAtkModule)

​

Manager Classes

• [System]Manager - Singleton managers (e.g., ActionManager, InventoryManager)
• Often accessible via Instance() static method

​

Data Structures

• [Type]Array - Fixed or dynamic arrays
• [Type]Container - Container structures
• [Type]Data - Data-only structures

​

Havok Classes

• hk[Type] - Havok types (e.g., hkVector4f, hkaSkeleton)
• hka[Type] - Havok Animation (e.g., hkaAnimation)
• hkx[Type] - Havok scene/export data (e.g., hkxMesh)

​

STD Classes

• Std[Type] - C++ STL containers (e.g., StdVector, StdMap)

​

Navigation Tips

1. Start with the game feature - Use the mapping table above
2. Check related namespaces - UI often involves both Client.UI and Component.GUI
3. Follow inheritance - Many classes inherit from common bases (e.g., AtkUnitBase, GameObject)
4. Use naming patterns - If you know the feature name, try Addon[Name] or [Name]Manager
5. Search by prefix - Filter by Addon, Atk, or Manager to narrow results

​

See Also

• API Reference Overview - Introduction to the API
• Memory Layout - Understanding struct layouts
• Common Patterns - Usage examples
• UI System Guide - Working with UI structures