Skip to content

Namespace Apogee.Graphics

Namespaces

Apogee.Graphics.Metal

Apogee.Graphics.Shaders

Apogee.Graphics.Vulkan

Classes

BindlessHeap

The one set of resources every pipeline sees: arrays of sampled images, samplers and storage images that shaders index with integers, plus the push constants. Slot 0 of the images and samplers is a white texel and a linear repeat sampler, so an unset index still reads something sane; slot 0 of the storage images is never handed out (0 means "none").

CommandRecorder

A command buffer being recorded, with the operations the engine needs on it. Everything here is on the one queue family the device uses.

Frame

One frame in flight: its command buffer, the window's image, per-frame upload memory, and deferred destruction.

FrameLoop

Keeps frames in flight (two by default): each has its own command buffer, upload arena and timer queries, and waits only for the frame that used its slot two frames ago. Without a swapchain it runs headless: the same frames with no window image, for screenshots, tests and servers. Made by .

GpuBuffer

A buffer in GPU memory. Every buffer has a device address, so shaders reach it through a pointer in push constants.

GpuImage

An image with a view of the whole of it (the aspect a shader samples).

GpuInfo

A GPU a backend found, and whether the engine can use it.

GpuSampler

GraphicsDevice

The logical device of one graphics API and everything created with it. The renderer talks to this class and the abstract classes it hands out (buffers, images, pipelines, a command recorder, a swapchain and frame loop); Apogee.Graphics.Vulkan has the Vulkan implementation, and a Metal one follows. The engine's baseline is the same on every API: dynamic rendering, explicit barriers, buffer device addresses and bindless textures; a GPU without them is rejected with the reason.

GraphicsDeviceOptions

GraphicsException

A graphics call failed or the machine cannot do what the engine needs (no usable GPU, a missing feature); the message says which. Each backend has its own subclass.

GraphicsPipelineDescription

Everything that makes a graphics pipeline (front faces are counter-clockwise by default, as in glTF). Geometry is pulled from buffers by the vertex shader (no vertex input state), depth is reverse-Z (the near plane is 1, so is greater-or-equal), and the pipelines render with dynamic rendering into attachments of these formats.

ImageView

A view of (part of) an image, as the API of a backend sees it. Opaque: the backend that made it knows what is in it.

ImmediateContext

Records a command buffer, submits it and waits for it: for loading and tools, where stalling is fine. A frame never uses this. Safe to call from several threads (the calls are serialized).

Pipeline

A compiled pipeline; bind it with .

ResourceStates

Which states write a resource.

Swapchain

The images of a window, which the frame loop acquires, renders to and presents. Made by .

Structs

Backbuffer

The image of the window the frame renders to. It starts in and must end in .

BufferBarrier

ColorTarget

A color attachment to render into: its view (the image is in ), cleared or loaded, and kept or discarded.

DebugLabelScope

Closes a debug label group when disposed.

DepthTarget

The depth attachment. The engine uses reverse-Z, so the usual clear value is 0 (the far plane).

DispatchIndirectCommand

The arguments of one indirect dispatch, as reads them from a buffer (a compute shader can write them). Twelve bytes.

DrawIndexedIndirectCommand

The arguments of one indexed indirect draw, as reads them from a buffer (a compute shader can write them). Twenty bytes, the same layout in Vulkan and Metal.

FrameAllocation

Space in a frame's upload arena: an address for shaders and memory for the CPU to fill.

FrameScope

A debug label with a GPU timer; dispose it to end the section.

GpuTiming

How long a named part of a frame took on the GPU.

ImageBarrier

One image transition: from the state it was last used in to the state the next use needs.

ImageDescription

What an image is: format, size, mip chain, layers and what it will be used for.

ImageRegion

Where in a staging buffer the bytes of one image subresource are.

SamplerDescription

What a sampler does. other than the average needs and is not combined with .

ShaderCode

One shader stage: the compiled code for the device's (SPIR-V for Vulkan, Metal shading language source for Metal) and the entry point in it to run. A compute shader also says its size.

ThreadGroupSize

The size of a compute shader's thread group, [numthreads(x, y, z)]. Vulkan pipelines have it inside; a Metal dispatch has to be told.

Enums

AddressMode

BlendMode

BufferState

How a buffer is being used.

BufferUsage

What a buffer will be used for. Every buffer can also be copied from and to, and is reachable by address.

CompareOp

CullMode

Filter

FrontFace

GpuKind

GraphicsBackend

The graphics API a device runs on.

ImageState

How an image is being used; each state means one layout and one set of pipeline stages and accesses (in a backend that has them).

ImageUsage

What an image will be used for. Every image can also be copied from and to.

IndexFormat

MemoryKind

Where a buffer's memory lives.

MipmapMode

PrimitiveTopology

SampleCount

SamplerReduction

How a sampler combines the texels of its filter footprint. Minimum and maximum (Hi-Z depth pyramids, clamping) need .