Namespace Stride.Graphics
Classes
- BatchBase<TDrawInfo>
Base class to batch a group of draw calls into one.
- BatchBase<TDrawInfo>.DeviceResourceContext
Use a ResourceContext per GraphicsDevice (DeviceContext)
- 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.
- 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.
- 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.
- ColorExtensions
Extension class for Color
- 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.
- 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.
- Image
Provides method to instantiate an image 1D/2D/3D supporting TextureArray and mipmaps on the CPU or to load/save an image from the disk.
- IndexBufferBinding
Binding structure that specifies an Index Buffer for a Graphics Device.
- 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 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.
- PixelBuffer
An unmanaged buffer of pixels.
- PixelBufferArray
Used by Image to provide a selector to a PixelBuffer.
- PixelFormatExtensions
Provides extensions for PixelFormat to help in conversions between formats, querying format information, calculating sizes, pitches, etc.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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>.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.
- DataBox
Defines a region of data organized in 3D.
- DataRectangle
Provides a pointer to 2D data.
- 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 PixelFormat.
- GraphicsResourceAllocator.QueryPoolDescription
A description of a GPU queries pool.
- ImageDescription
A description for Image.
- 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).
- MipMapCount
Describes the number of mipmap levels of a Texture.
- MipMapDescription
Describes a mipmap image.
- 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.
- 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.
- SamplerStateDescription
Describes a Sampler State object, which determines how to sample Texture data.
- TextureDescription
A structure providing a common description for all kinds of Textures.
- TextureViewDescription
Describes a View for a Texture.
- 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.
- 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.
Enums
- 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.
- ColorSpace
Defines the color space used for Textures, Materials, lighting calculations, etc.
- ColorSpaceType
Specifies the type of color space a Graphics Presenter has to output.
- ColorWriteChannels
Identifies which components of each pixel of a Render Target can be written to during blending.
- CompareFunction
Identifies comparison functions that can be used to determine how the runtime compares source (new) data against destination (existing) data before storing the new data.
- 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.
- DisplayOrientation
Describes the orientation of the display.
- 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 PixelFormat for a GraphicsDevice.
- GraphicsDeviceStatus
Describes the current status of a GraphicsDevice.
- GraphicsPlatform
The graphics platform.
- GraphicsProfile
Identifies the base set of capabilities a Graphics Device supports.
- 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.
- ImageFileType
Image file format used by Save(Stream, ImageFileType)
- 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.
- PixelFormat
Defines various types of pixel formats.
- 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.
- SpriteEffects
Defines sprite mirroring options.
- 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.
- TextureAddressMode
Identifies a technique for resolving Texture coordinates that are outside of the boundaries of a Texture (outside the [0, 1] range).
- TextureDimension
Identifies the type of Texture resource being used.
- TextureFilter
Identifies the filtering mode to use during Texture sampling.
- 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
TResourcebased on the specified description and pixel format.
- GraphicsResourceAllocator.GetDescriptionDelegate<TResource, TDescription>
Represents a method that retrieves a description of a Graphics Resource.
- GraphicsResourceRecyclePolicyDelegate
A recycle policy to check whether a Graphics Resource tracked by a GraphicsResourceAllocator must be disposed / recycled.