Skip to main content
The Client.Graphics namespace contains the game’s rendering engine, scene management, and visual effects systems.

​
Kernel

​
Device

Core graphics device (DirectX 11). Struct Layout: 
// Client::Graphics::Kernel::Device
[StructLayout(LayoutKind.Explicit, Size = 0xE0AC8)]
public unsafe partial struct Device {
    [FieldOffset(0x8)] public void* ContextArray;
    [FieldOffset(0x10)] public void* RenderThread;
    [FieldOffset(0x40)] public CallbackManager* OnResizeDestroy;
    [FieldOffset(0x48)] public CallbackManager* OnResizeCreate;
    [FieldOffset(0x70)] public SwapChain* SwapChain;
    
    // Display settings
    [FieldOffset(0x8C)] public uint Width;
    [FieldOffset(0x90)] public uint Height;
    [FieldOffset(0x94)] public float AspectRatio;
    [FieldOffset(0x98)] public float GammaCorrection;
    [FieldOffset(0x9C)] public int ColorFilter;
    
    // Frame rate
    [FieldOffset(0xA8)] public bool IsFrameRateLimited;
    [FieldOffset(0xAE)] public short FrameRateLimit;
    
    // Rendering
    [FieldOffset(0x908)] internal RenderCommandBufferGroup* RenderCommandBuffer;
    [FieldOffset(0x910)] public uint RenderCommandBufferCount;
    
    // DirectX 11
    [FieldOffset(0xE0A90)] public int D3DFeatureLevel;
    [FieldOffset(0xE0A98)] public void* DXGIFactory;        // IDXGIFactory1
    [FieldOffset(0xE0AA0)] public void* DXGIOutput;         // IDXGIOutput6
    [FieldOffset(0xE0AA8)] public void* D3D11Forwarder;     // ID3D11Device
    [FieldOffset(0xE0AB0)] public void* D3D11DeviceContext; // ID3D11DeviceContext5
    [FieldOffset(0xE0AC0)] public ImmediateContext* ImmediateContext;
}
Singleton Access: 
var device = Device.Instance();
Key Methods:
  • CreateConstantBuffer(int, uint, uint) - Create constant buffer
  • CreateTexture2D(int*, byte, TextureFormat, TextureFlags, uint) - Create texture
Usage Example: 
var device = Device.Instance();
if (device != null) {
    var width = device->Width;
    var height = device->Height;
    var aspectRatio = device->AspectRatio;
    
    Console.WriteLine($"Display: {width}x{height} (AR: {aspectRatio:F2})");
    Console.WriteLine($"FPS Limit: {device->FrameRateLimit}");
    Console.WriteLine($"Gamma: {device->GammaCorrection:F2}");
}

​
CallbackManager

Manages graphics callbacks (e.g., on resize). 
// Device::CallbackManager
[StructLayout(LayoutKind.Explicit, Size = 0x40)]
public unsafe partial struct CallbackManager {
    [FieldOffset(0x30)] public Entry* Entries;
    [FieldOffset(0x38)] public uint Capacity;
    [FieldOffset(0x3C)] public uint Count;
}
Methods:
  • AddCallback(delegate* unmanaged<void*, bool>, void*) - Add callback
  • RemoveCallback(int) - Remove callback
  • ExecuteCallbacks() - Execute all callbacks
Usage: 
var device = Device.Instance();
var resizeCallbacks = device->OnResizeCreate;

if (resizeCallbacks != null) {
    // Add callback
    var index = resizeCallbacks->AddCallback(&MyResizeCallback, myContext);
    
    // Later, remove it
    resizeCallbacks->RemoveCallback(index);
}

​
Scene

​
World

Main scene graph root. Struct Layout: 
// Client::Graphics::Scene::World
[Inherits<Object>]
[StructLayout(LayoutKind.Explicit, Size = 0x160)]
public unsafe partial struct World {
    // Scene management
}
Singleton Access: 
var world = World.Instance();
Usage: 
var world = World.Instance();
if (world != null) {
    // Access scene graph
}

​
DrawObject

Base class for renderable objects. 
// Client::Graphics::Scene::DrawObject
public unsafe partial struct DrawObject {
    // Rendering properties
}
Used by GameObject: 
var gameObject = /* get from ObjectTable */;
var drawObject = gameObject->DrawObject;
if (drawObject != null) {
    // Object has visual representation
}

​
CharacterBase

Drawable character representation. 
var character = /* get character */;
var charBase = character->GameObject.GetCharacterBase();
if (charBase != null) {
    // Access character rendering
}

​
Render

​
Manager

Central rendering manager. Struct Layout: 
// Client::Graphics::Render::Manager
[StructLayout(LayoutKind.Explicit, Size = 0x40380)]
public unsafe partial struct Manager {
    [FieldOffset(0x8)] internal FixedSizeArray87<View> _views;
    [FieldOffset(0x87F8)] public JobSystem ManagerJobSystem;
    [FieldOffset(0x10908)] public ShaderManager ShaderManager;
    [FieldOffset(0x10AE0)] public ModelRenderer ModelRenderer;
    [FieldOffset(0x10F30)] public BGInstancingRenderer BGInstancingRenderer;
    [FieldOffset(0x31D90)] public TerrainRenderer TerrainRenderer;
    [FieldOffset(0x363F0)] public WaterRenderer WaterRenderer;
    [FieldOffset(0x36960)] public VerticalFogRenderer VerticalFogRenderer;
}
Singleton Access: 
var renderManager = Manager.Instance();
Render Views: 
public enum RenderViews : uint {
    OmniShadow0 = 0,
    // ... OmniShadow1-23
    Environment = 24,
    View25 = 25,
    OffscreenRenderer0 = 26,
    OffscreenRenderer1 = 27,
    OffscreenRenderer2 = 28,
    OffscreenRenderer3 = 29,
    Main = 30,
    Unused = 31
}
Usage Example: 
var renderMgr = Manager.Instance();
if (renderMgr != null) {
    var views = renderMgr->Views;
    var mainView = views[(int)RenderViews.Main];
    
    // Access renderers
    var modelRenderer = &renderMgr->ModelRenderer;
    var terrainRenderer = &renderMgr->TerrainRenderer;
}

​
View

Represents a rendering view/viewport. 
var renderMgr = Manager.Instance();
var mainView = renderMgr->Views[(int)RenderViews.Main];

// Configure view

​
VFX (Visual Effects)

​
VfxContainer

Contains visual effects for a character. 
var character = /* get character */;
var vfx = &character->Vfx;

// Access character's VFX

​
VfxData

Represents a single VFX instance. 
// Used in ActionManager for area targeting
var actionMgr = ActionManager.Instance();
var vfx1 = actionMgr->AreaTargetingVfx1;
var vfx2 = actionMgr->AreaTargetingVfx2;

​
Animation

​
Timeline

Character animation timeline. 
var character = /* get character */;
var timeline = &character->Timeline;

if (timeline->IsWeaponDrawn) {
    Console.WriteLine("Weapon is drawn");
}

​
Environment

​
EnvironmentManager

Manages lighting and environment. 
var framework = Framework.Instance();
var envMgr = framework->EnvironmentManager;

if (envMgr != null) {
    // Control environment settings
}

​
Common Patterns

​
Getting Display Settings

var device = Device.Instance();

if (device != null) {
    var settings = new {
        Width = device->Width,
        Height = device->Height,
        AspectRatio = device->AspectRatio,
        FpsLimit = device->FrameRateLimit,
        IsLimited = device->IsFrameRateLimited,
        Gamma = device->GammaCorrection,
        ColorFilter = device->ColorFilter
    };
    
    Console.WriteLine($"Resolution: {settings.Width}x{settings.Height}");
    Console.WriteLine($"FPS: {(settings.IsLimited ? settings.FpsLimit.ToString() : "Unlimited")}");
}

​
Accessing DirectX Device

var device = Device.Instance();

if (device != null) {
    var d3dDevice = device->D3D11Forwarder;       // ID3D11Device
    var d3dContext = device->D3D11DeviceContext;  // ID3D11DeviceContext
    var dxgiFactory = device->DXGIFactory;         // IDXGIFactory
    
    // Cast to COM interfaces and use
    // var d3d11Device = (ID3D11Device*)d3dDevice;
}

​
Working with Scene Objects

var objectTable = ObjectTable.Instance();
for (int i = 0; i < objectTable->Length; i++) {
    var obj = objectTable->GetObjectByIndex(i);
    if (obj != null) {
        var drawObj = obj->DrawObject;
        if (drawObj != null) {
            // Object is being rendered
            Console.WriteLine($"{obj->Name} is visible");
        }
    }
}

​
Character Rendering

var character = /* get character */;

// Check if character is rendered
var charBase = character->GameObject.GetCharacterBase();
if (charBase != null) {
    // Character has 3D model loaded
    
    // Access draw data
    var drawData = &character->DrawData;
    
    // Check animation state
    var timeline = &character->Timeline;
    var isWeaponDrawn = timeline->IsWeaponDrawn;
}

​
Monitoring Rendering

var device = Device.Instance();
var renderMgr = Manager.Instance();

if (device != null && renderMgr != null) {
    // Get render command buffer info
    var cmdBufferCount = device->RenderCommandBufferCount;
    
    // Access shader manager
    var shaderMgr = &renderMgr->ShaderManager;
    
    // Access model renderer
    var modelRenderer = &renderMgr->ModelRenderer;
}

​
Performance Considerations

​
Frame Rate Limiting

var device = Device.Instance();

// Check current limit
if (device->IsFrameRateLimited) {
    Console.WriteLine($"FPS limited to {device->FrameRateLimit}");
} else {
    Console.WriteLine("FPS unlimited");
}

// Note: Modifying these values directly is not recommended
// Use game settings instead

​
Render Callbacks

var device = Device.Instance();

// Monitor resize events
var onResize = device->OnResizeCreate;
if (onResize != null) {
    Console.WriteLine($"Resize callbacks: {onResize->Count}");
}

​
See Also

Build docs developers (and LLMs) love

Get started for freeTalk to us