Namespace Stride.Graphics

Classes

AdapterDriverInfo: GPU / driver / API identification. Populated per-backend.

BatchBase<TDrawInfo>: Base class to batch a group of draw calls into one.

BatchBase<TDrawInfo>.DeviceResourceContext: Use a ResourceContext per GraphicsDevice (DeviceContext)

BatchBase<TDrawInfo>.QueueComparer<TInfo>

BatchBase<TDrawInfo>.ResourceBufferInfo: A class containing information on how to build the batch vertex and index buffer.

BatchBase<TDrawInfo>.StaticQuadBufferInfo: A class containing the information required to build a vertex and index buffer for simple quad based batching.

BatchBase<TDrawInfo>.TextureIdComparer

BlendStates: Defines a set of built-in BlendStateDescriptions for common blending configurations.

Buffer: All-in-one GPU Buffer that is able to represent many types of Buffers (shader Constant Buffers, Structured Buffers, Raw Buffers, Argument Buffers, etc.).

Buffer.Argument: Helper methods for creating Argument Buffers.

Buffer.Constant: Helper methods for creating Constant Buffers.

Buffer.Index: Helper methods for creating Index Buffers.

Buffer.Raw: Helper methods for creating Raw Buffers.

Buffer.Structured: Helper methods for creating Structured Buffers.

Buffer.StructuredAppend: Helper methods for creating Structured Append Buffers.

Buffer.StructuredCounter: Helper methods for creating Structured Counter Buffers.

Buffer.Typed: Helper methods for creating Typed Buffers.

Buffer.Vertex: Helper methods for creating Vertex Buffers.

BufferPool

Buffer<T>: All-in-one GPU buffer that is able to represent many types of Buffers (shader Constant Buffers, Structured Buffers, Raw Buffers, Argument Buffers, etc.), but with typed information.

CommandList: Represents a list of graphics commands for playback, which can include resource binding, primitive-based rendering, etc.

DepthStencilStates: Defines a set of built-in DepthStencilStateDescriptions for common Depth and Stencil testing configurations.

DescriptorPool: A pool where the application can allocate Descriptors that are grouped together in DescriptorSets.

DescriptorSetLayout: Defines the Graphics Resources (Descriptors) that need to be bound together, their layout, types, and other associated metadata.
This description is used to allocate a DescriptorSet.

DescriptorSetLayoutBuilder: Helper class to build a DescriptorSetLayout.

Effect

EffectDescriptorSetReflection: A reflection object that describes the Descriptor Sets and their layouts for an Effect / Shader based on reflection data extracted from its bytecode.
This includes the bindings for Graphics Resources such as Textures, Buffers, and Sampler States.

FastTextRenderer: Renders text with a fixed size font.

GeometricMeshData<T>: A geometric data.

GraphicsAdapter: Represents a display subsystem (including one or more GPUs, DACs and video memory). A display subsystem is often referred to as a video card, however, on some machines the display subsystem is part of the motherboard.

GraphicsAdapterFactory: Static factory for obtaining the available GraphicsAdapters in the system.

GraphicsContext: A graphics command context. You should usually stick to one per rendering thread.

GraphicsDevice: A virtual adapter that can be used for creating GPU resources (buffers, textures, states, shaders, etc), and to manipulate CommandLists.

GraphicsDeviceException: An exception that is thrown when a Graphics Device operation fails.

GraphicsDeviceExtensions: Defines a set of extension methods for the GraphicsDevice class.

GraphicsDeviceServiceLocal: A default simple implementation of IGraphicsDeviceService that is used by some systems that only need quick access to the GraphicsDevice.

GraphicsException: An exception that is thrown when a graphics operation fails.

GraphicsMarshal: An unsafe class that provides a set of methods to access the underlying native DXGI and Direct3D devices and resources from its Stride counterparts.

GraphicsOutput: Represents an output (such as a monitor) attached to a GraphicsAdapter.

GraphicsPresenter: Represents an abstraction over a Swap-Chain.

GraphicsResource: Represents an abstract resource that depends on a GraphicsDevice.

GraphicsResourceAllocator: A GraphicsResource allocator tracking usage references and allowing to recycle unused resources based on a recycle policy.

GraphicsResourceAllocator.ResourceCache<TResourceDesc>: Internal type for a cache of Graphics Resources associated with their description.

GraphicsResourceAllocatorExtensions: Extensions for the GraphicsResourceAllocator.

GraphicsResourceBase: Base class for a Graphics Resource.

GraphicsResourceFactoryBase: Base class for all Graphics Resource factories.

GraphicsResourceLink: An object linking a Graphics Resource allocated by a GraphicsResourceAllocator and providing allocation information.

IndexBufferBinding: Binding structure that specifies an Index Buffer for a Graphics Device.

MeshExtension

MutablePipelineState: A convenience class that allows to compose a Pipeline State by modifying its configuration (as PipelineState objects are immutable once compiled), and only compile it into a Pipeline State object when needed.

ParameterCollectionLayoutExtensions: Provides extension methods for updating Stride.Rendering.ParameterCollectionLayout instances.

PipelineState

A Pipeline State object encapsulates the complete pipeline configuration, including Shaders, input layout, Render States, and output settings. It represents an atomic, immutable collection of states that can be efficiently bound and unbound as a single unit during rendering operations.

An instance of this class can represent either the state of the graphics pipeline, or the state of the compute pipeline (in the platforms that support compute).

PipelineStateDescription: Describes the configuration of the graphics pipeline that will be encapsulated by a PipelineState object. This includes Shaders, input layout, Render States, and output settings.

PresentationParameters: Describes how a GraphicsDevice will display to the screen.

PrimitiveQuad: A primitive triangle that can be used to draw a Texture or an Effect, commonly used to draw full-screen. This is directly accessible from the DrawQuad(GraphicsContext, EffectInstance) method.

PrimitiveTypeExtensions: Defines extensions and helpers for PrimitiveType.

QueryPool: A pool holding asynchronous GPU Queries of a specific type.

RasterizerStates: Defines a set of built-in RasterizerStateDescriptions for common rasterizer configurations.

RenderTargetGraphicsPresenter: A simple GraphicsPresenter wrapping a Render-Target Texture where drawing will occur but no actual presentation will happen.

RenderingSettings

ResourceGroup: Groups bound Graphics Resources and a Constant Buffer, that usually change at a given frequency.

ResourceGroupAllocator: Allocator for resource groups.

ResourceGroupLayout: Represents the layout of the Graphics Resources and parameter values which form a resource group.

ResumeManager

RootSignature: Represents a Root Signature, used to specify how Graphics Resources, such as Textures and Buffers, are bound to the graphics pipeline (i.e. how DescriptorSet will be bound together).

SamplerState: A graphics object that describes a Sampler State, which determines how to sample Texture data.

SamplerStateFactory: A factory for creating SamplerState instances. Contains pre-created Sampler States for commonly used configurations.

SamplerStateSerializer: Serializer for SamplerState.

Sprite: A sprite.

Sprite3DBatch: A batcher for sprite in the 3D world.

SpriteBatch: Renders a group of sprites.

SpriteEffect

SpriteExtensions: A sprite represents a series frames in an atlas forming an animation.

SpriteFont: SpriteFont to use with SpriteBatch. See SpriteFont to learn how to use it.

SpriteFrame: A sprite frame represents a single frame a sprite animation. It contains the region of the texture representing the frame and the time it is supposed to be displayed.

SpriteSheet: A sheet (group) of sprites.

SwapChainGraphicsPresenter: A GraphicsPresenter wrapping a DirectX Swap-Chain (Silk.NET.DXGI.IDXGISwapChain).

Texture: All-in-one GPU Texture that is able to represent many types of textures (1D, 2D, 3D, Depth-Stencil Buffers, Render Targets, etc), as well as Texture Views over a parent Texture.

TextureExtensions

UIBatch: A utility class to batch and draw UI images.

VertexBufferBindingExtensions: Provides extension methods that facilitate the conversion of Vertex Declarations and Vertex Buffer bindings into InputElementDescription structures, which are used to define the input layout for Shaders in the graphics pipeline.

VertexDeclaration: Defines the layout of the vertices in a Vertex Buffer by specifying its component VertexElements.

VertexElementUsage

VertexHelper: An helper class for manipulating vertex buffers on CPU (Generate new vertex attributes...etc.)

WindowHandle: Encapsulates a platform-specific window handle.

Structs

BatchBase<TDrawInfo>.DrawTextures

BatchBase<TDrawInfo>.ElementInfo: The structure containing all the information required to batch one element.

BlendStateDescription: A description of a Blend State, which defines how colors are blended when rendering to one or multiple Render Targets.

BlendStateDescription.RenderTargetBlendStates: A structure that contains an inline array of BlendStateRenderTargetDescription for up to eight render targets.

BlendStateRenderTargetDescription: A description of a Blend State for a Render Target, which defines how colors are blended when rendering.

BufferDescription: Describes a GPU Buffer.

BufferPoolAllocationResult

CompiledCommandList

DefaultCommandListLock: Used to prevent concurrent uses of CommandList against the main one.

DepthStencilStateDescription: A description of a Depth-Stencil State, which defines how depth and stencil testing are performed during rasterization.

DepthStencilStencilOpDescription: Describes the stencil operations and comparison function used during stencil testing for a given face orientation (front or back).

DescriptorSet: Represents a set of Descriptors (such as Textures or Buffers) that can be bound together to a graphics pipeline.

DescriptorTypeCount: Describes how many Descriptor of a specific type will need to be allocated in a DescriptorPool.

DisplayMode: Describes a display mode.

GraphicsDeviceFeatures: Contains information about the general features supported by a GraphicsDevice, as well as supported features specific to a particular pixel format or data format.

GraphicsDeviceFeatures.FeaturesPerFormat: Contains information about the features a GraphicsDevice supports for a particular Stride.Graphics.PixelFormat.

GraphicsResourceAllocator.QueryPoolDescription: A description of a GPU queries pool.

IndexBufferHelper

InputElementDescription: Describes a single input element for the definition of a vertex format layout.

MappedResource: A GPU resource mapped for CPU access. This is returned by using MapSubResource(GraphicsResource, int, MapMode, bool, int, int).

RasterizerStateDescription: A description of a Rasterizer State, which defines how primitives are rasterized to the Render Targets.

Rational: Represents a rational number.

RenderOutputDescription: Describes the output formats of the Render Targets and the Depth-Stencil Buffer.

ResourceBarrierDescription: Describes a resource barrier transition for GPU synchronization. This is a cross-platform abstraction over D3D12 Enhanced Barriers and Vulkan pipeline barriers.

ResourceGroupBufferUploader: Describes how a Descriptor Set maps to real resource bindings.

ResourceGroupDescription: Represents a description of a resource group, including the layout of its Graphics Resources and Constant Buffers.

ResourceRegion: Defines a 3D box with integer coordinates, represented as the coordinates of its minimum (left, top, front) and maximum (right, bottom, back) corners.

Sprite3DBatch.Sprite3DDrawInfo

SpriteBatch.SpriteDrawInfo

SpriteFont.GlyphPosition

TextureDescription: A structure providing a common description for all kinds of Textures.

TextureViewDescription: Describes a View for a Texture.

UIBatch.UIImageDrawInfo

Vertex2DPositionTexture: Describes a custom vertex format structure that contains position and UV information.

VertexBufferBinding: Binding structure that specifies a Vertex Buffer and other per-vertex parameters (such as offset and instancing) for a Graphics Device.

VertexBufferHelper

VertexBufferHelper.CopyAsTriangleList

VertexElement: A description of a single element for the input-assembler stage. This structure is related to SharpDX.Direct3D11.InputElement.

VertexElementWithOffset: Represents a VertexElement with additional metadata, including its offset and size.

VertexHelper.VertexTransformResult: Result of a vertex buffer transform.

VertexPosition2: Describes a custom vertex format structure that contains position as a Vector2.

VertexPositionColorTexture: Describes a custom vertex format structure that contains position and color information.

VertexPositionColorTextureSwizzle: Describes a custom vertex format structure that contains position, color, texture and swizzle information.

VertexPositionNormalColor: Describes a custom vertex format structure that contains position, normal and color information.

VertexPositionNormalTexture: Describes a custom vertex format structure that contains position, normal and texture information.

VertexPositionTexture: Describes a custom vertex format structure that contains position and color information.

Viewport: Defines the viewport dimensions of a render-target surface onto which a 3D volume projects.

Interfaces

IGraphicsDeviceService: Service providing access to the GraphicsDevice and events that can be subscribed to be notified of when the device is created, reset, or disposed.

IVertex: The base interface for all the vertex data structure.

VertexBufferHelper.IReader<TDest>

VertexBufferHelper.IWriter<TDest>

Enums

BarrierAccess: Defines flags for the type of access a GPU operation performs on a graphics resource. This is a cross-platform abstraction over D3D12 Enhanced Barrier access flags and Vulkan access flags.

BarrierLayout: Defines the memory layout of a graphics resource for barrier transitions. This is a cross-platform abstraction over D3D12 Enhanced Barrier layouts and Vulkan image layouts.

BarrierSync: Defines flags for GPU pipeline synchronization points used in barrier transitions. This is a cross-platform abstraction over D3D12 Enhanced Barrier sync flags and Vulkan pipeline stage flags.

Blend: A Blend Option identifying the data source and an optional pre-blend operation, which help define how Pixel Shader output is mixed with the destination color in rendering operations.

BlendFunction: Defines a function for color blending.

BufferFlags: Identifies the intended use of a graphics Buffer when rendering.

BufferPoolAllocationType

ColorWriteChannels: Identifies which components of each pixel of a Render Target can be written to during blending.

ComputeShaderFormatSupport: Flags specifying which resources and features are supported when using compute shaders for a given pixel format for a graphics device.

CubeMapFace: Defines the faces of a cube map for Cube Texture.

CullMode: Indicates the facing direction of triangles that will be culled (not drawn).

DepthStencilClearOptions: Flags that specify what parts of a Depth-Stencil Buffer to clear when calling Clear(Texture, DepthStencilClearOptions, float, byte).

DeviceCreationFlags: Flags describing the parameters that are used to create a Graphics Device.

DisplayRotation: Defines the rotation of a display, indicating how the Back-Buffers should be rotated to fit the physical rotation of a monitor.

FillMode: Determines the fill mode to use when rendering triangles.

FormatSupport: Flags specifying which resources and features are supported for a given Stride.Graphics.PixelFormat for a GraphicsDevice.

GraphicsDeviceStatus: Describes the current status of a GraphicsDevice.

GraphicsResourceLifetimeState: Describes the lifetime state of a graphics resource.

GraphicsResourceState: Defines constants that specify the state of a Graphics Resource regarding how the resource is being used.

GraphicsResourceUsage: Identifies the intended use of a resource during rendering. The usage directly reflects whether a resource is accessible by the CPU and/or the GPU.

ImageOrientation: Defines the possible rotations to apply on image regions.

IndexElementSize: Specifies the size of indices in an Index Buffer.

InputClassification: Specifies whether the data of a Input Element is per-vertex or per-instance.

MapMode: Describes how the CPU is accessing a GraphicsResource with the MapSubResource(GraphicsResource, int, MapMode, bool, int, int) method.

MultisampleCount: Defines the level of multisampling.

PreferredGraphicsPlatform

PresentInterval: Defines the relationship between the GraphicsOutput's refresh rate and the rate at which Present operations are completed.

PrimitiveType: Values that indicate how the graphics pipeline interprets input vertex data.

QueryType: Defines the types of a GPU query.

RequiredDisplayOrientation

SpriteEffects: Defines sprite mirroring options.

SpriteFontType

SpriteSortMode: Defines sprite sort-rendering options.

StencilOperation: Specifies the operation to perform on the stencil part of the Depth-Stencil Buffer when rasterizing primitives.

SwizzleMode: Specify how to swizzle a vector.

TextAlignment: Specify the available text alignment when rendering text.

TextureFlags: Flags describing how a Texture can be bound to the graphics pipeline.

TextureOptions: Flags describing resource options for a Texture.

UIBatch.PrimitiveType: The primitive type to draw for an element.

ViewType: Defines what sub-resources (mip-levels, array elements) from a GraphicsResource are selected by a View.

Delegates

GraphicsDevice.CreateSharedData<T>: A delegate called to create shareable data.

GraphicsDevice.GraphicsDeviceInfoMessageHandler: Represents a method that handles messages related to Graphics Device information.

GraphicsResourceAllocator.CreateResourceDelegate<TResource, TDescription>: Represents a method that creates a Graphics Resource of type TResource based on the specified description and pixel format.

GraphicsResourceAllocator.GetDescriptionDelegate<TResource, TDescription>: Represents a method that retrieves a description of a Graphics Resource.