renoir::RendererCaps Struct Reference

Tells the Renoir Core, what is supported in this backend. It's important to correctly fill the structure in order to achieve maximum performance. More...

#include <Coherent/renoir/include/RenoirBackend/RendererBackend.h>

Public Attributes
bool	SupportsMSAATextures
	Tells if MSAA is supported.
bool	RequiresMSAAResolve
	Tells if an explicit resolve step is required for MSAA. Some mobile devices do the resolve implicitly.
bool	RequiresDrawFences
	Tells if the API requires explicit draw fences (unused and reserved)
bool	RequiresShaderTypeInShader
	The user could implement the shaders either as a Uber shader or as individual shaders. On more powerful devices/APIs it's preferable to use a Uber shader. This argument will make the Core set the Shader Type in a uniform. If you don't use Uber shaders - set this to false.
bool	RequiresYFlipForLayers
	Renoir works with a coords system where the texture origin is the top-left pixel. OpenGL uses bottom-left, this flag will flip the Y coordinate of images so that they work correctly.
bool	SupportsNPOTTextureOps
	Tells if the backend supports linear sampling on NPOT textures.
bool	ShaderChangeRequiresResourcesRebind
	If "true" the Renoir Core will re-bind all shader resources whenever a shader changes. This is important for PS4.
bool	RequiresRBSwapForImages
	If "true" the Renoir Core library will swap the red and blue channels in all image data.
bool	SupportsA8RenderTarget
	If "true" the Renoir Core will use A8 render targets whenever possible instead of RGBA.
bool	SupportsOnly16bitIndices
	Some backends (like GLES2 renderers) might only support 16 bit indices.
bool	PreferCPUWorkload
	Some systems benefit from doing work on the CPU instead of the driver/GPU. This is mostly relevant for mobile platforms. PC/Console targets perform better when the GPU is utilized. When this capability is set, attempts to minimize draw call count will be made at the expense of CPU time.
bool	ShouldUseRenderPasses
	When this capability is set, Renoir will issue BeginRenderPass and EndRenderPass commands and will not issue the SetRenderTarget and ResolveRenderTarget commands. The BeginRenderPass command provides additional information about whether the render targets should be cleared on render pass load and if they should be resolved on store. This is done so that the backend API is compliant with the modern graphics APIs like Metal and Vulkan.
bool	ShouldClearRTWithClearQuad
	When this capability is set, Renoir will issue fullscreen clear quad instead of calling ClearRenderTarget. This is done so that we don't need to create a new render pass to clear a render target in graphics APIs like Metal, which do not provide an easier way to do it.
bool	CanOutputDepthInPixelShader
	If "true" the backend supports depth output in the pixel shader.
bool	SupportsTwoSidedStencilOperations
	If "true" the backend supports two-sided stencil operations.
int	ConstantBufferRingSize
	Size of the internal ring buffer, which is used to manage Renoir's constant buffers. For low-level graphics APIs like Dx12, Metal and Vulkan it is recommended to set this size to 4. The motivation for this particular size is that the maximum count of buffered frames in a standard pipeline is three and in order to surely avoid overlap of constant buffers, they should be managed by a circular buffer with size 4. If you have a pipeline with higher maximum count of buffered frames, then this value should be changed accordingly. For most high-level graphics APIs ring buffer size should be set to 1, because the drivers for them handle constant buffer overlap internally and therefore a greater value for the ring buffer size is unnecessary.
ShaderType	ShaderMapping [ST_Count]
	A mapping between logical shaders and actual ones. The user can implement many logical shaders in one Uber shader. This mapping will avoid redundant shader change commands.
int	ConstantBufferBlockAlignment
	The alignment required of an element in a constant buffer block.
int	ConstantBufferBlocksCount
	The count of aligned constant buffer blocks for each constant buffer type. Renoir will issue a CreateConstantBuffer call with size equal to (constant buffer blocks count) * (aligned specific constant buffer size) for each constant buffer type. If the blocks count value is greater than 1, then if the regular constant buffer becomes full, Renoir will make sure that a new auxiliary constant buffer is allocated. If the blocks count value is equal to 1, then Renoir won't create any auxiliary constant buffers. Auxiliary constant buffers are allocated per frame, thus being allocated before ExecuteRendering is called and deallocated immediately after that. Setting constant buffer ring size and blocks count value to greater than 1 usually goes hand in hand, because both provide functionality that otherwise should be explicitly implemented in the backend for low-level graphics APIs like Dx12, Metal and Vulkan.
unsigned	MaxTextureWidth
	The maximum possible texture width supported by this device. Currently used to cap the size of temporary textures created by the SDK. Use 8192 as a default if it's not possible to determine.
unsigned	MaxTextureHeight
	The maximum possible texture width supported by this device. Currently used to cap the size of temporary textures created by the SDK. Use 8192 as a default if it's not possible to determine.

Detailed Description

Tells the Renoir Core, what is supported in this backend. It's important to correctly fill the structure in order to achieve maximum performance.