RenderingDevice

public void Barrier(RenderingDevice.BarrierMask from = RenderingDevice.BarrierMask.AllBarriers, RenderingDevice.BarrierMask to = RenderingDevice.BarrierMask.AllBarriers);

This method does nothing.

public Error BlasBuild(Rid blas);

Builds the blas.

public Rid BlasCreate(Reckfell.Collections.Array<RDAccelerationStructureGeometry> geometries, RenderingDevice.AccelerationStructureFlagBits flags);

Creates a new Bottom-Level Acceleration Structure (BLAS). It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method.

public Error BufferClear(Rid buffer, uint offset, uint sizeBytes);

Clears the contents of the buffer, clearing size_bytes bytes, starting at offset. Prints an error if:

• the size isn't a multiple of four
• the region specified by offset + size_bytes exceeds the buffer
• a draw list is currently active (created by RenderingDevice.DrawListBegin)
• a compute list is currently active (created by RenderingDevice.ComputeListBegin)

public Error BufferClear(Rid buffer, uint offset, uint sizeBytes, RenderingDevice.BarrierMask postBarrier);

Clears the contents of the buffer, clearing size_bytes bytes, starting at offset. Prints an error if:

• the size isn't a multiple of four
• the region specified by offset + size_bytes exceeds the buffer
• a draw list is currently active (created by RenderingDevice.DrawListBegin)
• a compute list is currently active (created by RenderingDevice.ComputeListBegin)

public Error BufferCopy(Rid srcBuffer, Rid dstBuffer, uint srcOffset, uint dstOffset, uint size);

Copies size bytes from the src_buffer at src_offset into dst_buffer at dst_offset. Prints an error if:

• size exceeds the size of either src_buffer or dst_buffer at their corresponding offsets
• a draw list is currently active (created by RenderingDevice.DrawListBegin)
• a compute list is currently active (created by RenderingDevice.ComputeListBegin)

public byte[] BufferGetData(Rid buffer, uint offsetBytes = 0, uint sizeBytes = 0);

Blocking buffer read into a new byte[] that waits for device work. Offset and size are bytes; sizeBytes=0 selects the full buffer size, not the remainder after an arbitrary offset. Specify the size explicitly for partial reads.

public Error BufferGetDataAsync(Rid buffer, Callable callback, uint offsetBytes = 0, uint sizeBytes = 0);

Asynchronous version of RenderingDevice.BufferGetData. RenderingDevice will call callback in a certain amount of frames with the data the buffer had at the time of the request. Note: At the moment, the delay corresponds to the amount of frames specified by ProjectSettings.rendering/rendering_device/vsync/frame_queue_size. Note: Downloading large buffers can have a prohibitive cost for real-time even when using the asynchronous method due to hardware bandwidth limitations. When dealing with large resources, you can adjust settings such as ProjectSettings.rendering/rendering_device/staging_buffer/block_size_kb to improve the transfer speed at the cost of extra memory.

public ulong BufferGetDeviceAddress(Rid buffer);

Returns the address of the given buffer which can be passed to shaders in any way to access underlying data. Buffer must have been created with this feature enabled. Note: You must check that the GPU supports this functionality by calling RenderingDevice.HasFeature with RenderingDevice.Features.BufferDeviceAddress as a parameter.

public Error BufferUpdate(Rid buffer, uint offset, uint sizeBytes, byte[] data);

Writes sizeBytes bytes into the buffer at offset. Call outside an active compute/draw/raytracing list, provide enough source bytes and stay within the allocated buffer. These are not element counts.

public Error BufferUpdate(Rid buffer, uint offset, uint sizeBytes, byte[] data, RenderingDevice.BarrierMask postBarrier);

Updates a region of size_bytes bytes, starting at offset, in the buffer, with the specified data. Prints an error if:

• the region specified by offset + size_bytes exceeds the buffer
• a draw list is currently active (created by RenderingDevice.DrawListBegin)
• a compute list is currently active (created by RenderingDevice.ComputeListBegin)

public Error BufferUpdate(Rid buffer, uint offset, uint sizeBytes, ReadOnlySpan<byte> data);

Updates a region of size_bytes bytes, starting at offset, in the buffer, with the specified data. Prints an error if:

• the region specified by offset + size_bytes exceeds the buffer
• a draw list is currently active (created by RenderingDevice.DrawListBegin)
• a compute list is currently active (created by RenderingDevice.ComputeListBegin)

public Error BufferUpdate(Rid buffer, uint offset, uint sizeBytes, ReadOnlySpan<byte> data, RenderingDevice.BarrierMask postBarrier);

Updates a region of size_bytes bytes, starting at offset, in the buffer, with the specified data. Prints an error if:

• the region specified by offset + size_bytes exceeds the buffer
• a draw list is currently active (created by RenderingDevice.DrawListBegin)
• a compute list is currently active (created by RenderingDevice.ComputeListBegin)

public void CaptureTimestamp(string name);

Creates a timestamp marker with the specified name. This is used for performance reporting with the RenderingDevice.GetCapturedTimestampCpuTime, RenderingDevice.GetCapturedTimestampGpuTime and RenderingDevice.GetCapturedTimestampName methods.

public void ComputeListAddBarrier(long computeList);

Raises a Vulkan compute barrier in the specified compute_list.

public long ComputeListBegin();

Begins recording a compute list on the device thread. Only one compute list can be active; after binding the pipeline and resources, finish recording with ComputeListEnd.

public long ComputeListBegin(bool allowDrawOverlap);

Starts a list of compute commands created with the compute_* methods. The returned value should be passed to other compute_list_* functions. Multiple compute lists cannot be created at the same time; you must finish the previous compute list first using RenderingDevice.ComputeListEnd. A simple compute operation might look like this (code is not a complete example):

public void ComputeListBindComputePipeline(long computeList, Rid computePipeline);

Binds a same-device compute pipeline to the active list. Before dispatch also provide compatible resource sets and any parameters required by the shader.

public void ComputeListBindUniformSet(long computeList, Rid uniformSet, uint setIndex);

Binds a uniform set at the active compute pipeline set index. setIndex corresponds to GLSL set, not RDUniform.Binding; the layout must match the pipeline shader.

public void ComputeListDispatch(long computeList, uint xGroups, uint yGroups, uint zGroups);

Records dispatch of the specified workgroup counts, not individual threads. Counts must be positive and within device limits; guard indices in the shader for a partial final group.

public void ComputeListDispatchIndirect(long computeList, Rid buffer, uint offset);

Submits the compute list for processing on the GPU with the given group counts stored in the buffer at offset. Buffer must have been created with RenderingDevice.StorageBufferUsage.Indirect flag.

public void ComputeListEnd();

Ends recording of the active compute list. This does not wait for GPU completion: a local device needs Submit and appropriate synchronization before CPU result use.

public void ComputeListEnd(RenderingDevice.BarrierMask postBarrier);

Finishes a list of compute commands created with the compute_* methods.

public void ComputeListSetPushConstant(long computeList, byte[] buffer, uint sizeBytes);

Sets the push constant data to buffer for the specified compute_list. The shader determines how this binary data is used. The buffer's size in bytes must also be specified in size_bytes (this can be obtained by calling the PackedByteArray.size method on the passed buffer).

public void ComputeListSetPushConstant(long computeList, ReadOnlySpan<byte> buffer, uint sizeBytes);

Sets the push constant data to buffer for the specified compute_list. The shader determines how this binary data is used. The buffer's size in bytes must also be specified in size_bytes (this can be obtained by calling the PackedByteArray.size method on the passed buffer).

public Rid ComputePipelineCreate(Rid shader, Reckfell.Collections.Array<RDPipelineSpecializationConstant> specializationConstants = null);

Creates a compute pipeline from a compute shader on the same device. A regular graphics shader is not suitable. The pipeline can be reused with compatible resource sets.

public bool ComputePipelineIsValid(Rid computePipeline);

Returns true if the compute pipeline specified by the compute_pipeline RID is valid, false otherwise.

public RenderingDevice CreateLocalDevice();

Create a new local RenderingDevice. This is most useful for performing compute operations on the GPU independently from the rest of the engine.

public void DrawCommandBeginLabel(string name, Color color);

Create a command buffer debug label region that can be displayed in third-party tools such as RenderDoc(https://renderdoc.org/). All regions must be ended with a RenderingDevice.DrawCommandEndLabel call. When viewed from the linear series of submissions to a single queue, calls to RenderingDevice.DrawCommandBeginLabel and RenderingDevice.DrawCommandEndLabel must be matched and balanced. The VK_EXT_DEBUG_UTILS_EXTENSION_NAME Vulkan extension must be available and enabled for command buffer debug label region to work. See also RenderingDevice.DrawCommandEndLabel.

public void DrawCommandEndLabel();

Ends the command buffer debug label region started by a RenderingDevice.DrawCommandBeginLabel call.

public void DrawCommandInsertLabel(string name, Color color);

This method does nothing.

public long DrawListBegin(Rid framebuffer, RenderingDevice.DrawFlags drawFlags = RenderingDevice.DrawFlags.DefaultAll, Color[] clearColorValues = null, float clearDepthValue = 1f, uint clearStencilValue = 0, Rect2? region = default, uint breadcrumb = 0);

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions. Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using RenderingDevice.DrawListEnd. A simple drawing operation might look like this (code is not a complete example):

The draw_flags indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See RDTextureFormat or RenderingDevice.TextureSetDiscardable. The breadcrumb parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Reckfell is built in dev or debug mode; when the GPU crashes Reckfell will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to. It does not affect rendering behavior and can be set to 0. It is recommended to use RenderingDevice.BreadcrumbMarker enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

public long DrawListBegin(Rid framebuffer, RenderingDevice.DrawFlags drawFlags, ReadOnlySpan<Color> clearColorValues, float clearDepthValue, uint clearStencilValue, Rect2? region, uint breadcrumb);

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions. Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using RenderingDevice.DrawListEnd. A simple drawing operation might look like this (code is not a complete example):

The draw_flags indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See RDTextureFormat or RenderingDevice.TextureSetDiscardable. The breadcrumb parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Reckfell is built in dev or debug mode; when the GPU crashes Reckfell will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to. It does not affect rendering behavior and can be set to 0. It is recommended to use RenderingDevice.BreadcrumbMarker enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

public long DrawListBegin(Rid framebuffer, RenderingDevice.InitialAction initialColorAction, RenderingDevice.FinalAction finalColorAction, RenderingDevice.InitialAction initialDepthAction, RenderingDevice.FinalAction finalDepthAction, Color[] clearColorValues, float clearDepth, uint clearStencil, Rect2? region);

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions. Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using RenderingDevice.DrawListEnd. A simple drawing operation might look like this (code is not a complete example):

The draw_flags indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See RDTextureFormat or RenderingDevice.TextureSetDiscardable. The breadcrumb parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Reckfell is built in dev or debug mode; when the GPU crashes Reckfell will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to. It does not affect rendering behavior and can be set to 0. It is recommended to use RenderingDevice.BreadcrumbMarker enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

public long DrawListBegin(Rid framebuffer, RenderingDevice.InitialAction initialColorAction, RenderingDevice.FinalAction finalColorAction, RenderingDevice.InitialAction initialDepthAction, RenderingDevice.FinalAction finalDepthAction, Color[] clearColorValues, float clearDepth, uint clearStencil, Rect2? region, Reckfell.Collections.Array storageTextures);

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions. Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using RenderingDevice.DrawListEnd. A simple drawing operation might look like this (code is not a complete example):

The draw_flags indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See RDTextureFormat or RenderingDevice.TextureSetDiscardable. The breadcrumb parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Reckfell is built in dev or debug mode; when the GPU crashes Reckfell will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to. It does not affect rendering behavior and can be set to 0. It is recommended to use RenderingDevice.BreadcrumbMarker enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

public long DrawListBegin(Rid framebuffer, RenderingDevice.InitialAction initialColorAction, RenderingDevice.FinalAction finalColorAction, RenderingDevice.InitialAction initialDepthAction, RenderingDevice.FinalAction finalDepthAction, Color[] clearColorValues, float clearDepth, uint clearStencil, Rect2? region, Reckfell.Collections.Array<Rid> storageTextures);

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions. Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using RenderingDevice.DrawListEnd. A simple drawing operation might look like this (code is not a complete example):

The draw_flags indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See RDTextureFormat or RenderingDevice.TextureSetDiscardable. The breadcrumb parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Reckfell is built in dev or debug mode; when the GPU crashes Reckfell will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to. It does not affect rendering behavior and can be set to 0. It is recommended to use RenderingDevice.BreadcrumbMarker enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

public long DrawListBegin(Rid framebuffer, RenderingDevice.InitialAction initialColorAction, RenderingDevice.FinalAction finalColorAction, RenderingDevice.InitialAction initialDepthAction, RenderingDevice.FinalAction finalDepthAction, Color[] clearColorValues, float clearDepth, uint clearStencil, Rect2? region, uint breadcrumb);

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions. Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using RenderingDevice.DrawListEnd. A simple drawing operation might look like this (code is not a complete example):

The draw_flags indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See RDTextureFormat or RenderingDevice.TextureSetDiscardable. The breadcrumb parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Reckfell is built in dev or debug mode; when the GPU crashes Reckfell will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to. It does not affect rendering behavior and can be set to 0. It is recommended to use RenderingDevice.BreadcrumbMarker enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

public long DrawListBegin(Rid framebuffer, RenderingDevice.InitialAction initialColorAction, RenderingDevice.FinalAction finalColorAction, RenderingDevice.InitialAction initialDepthAction, RenderingDevice.FinalAction finalDepthAction, ReadOnlySpan<Color> clearColorValues, float clearDepth, uint clearStencil, Rect2? region);

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions. Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using RenderingDevice.DrawListEnd. A simple drawing operation might look like this (code is not a complete example):

The draw_flags indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See RDTextureFormat or RenderingDevice.TextureSetDiscardable. The breadcrumb parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Reckfell is built in dev or debug mode; when the GPU crashes Reckfell will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to. It does not affect rendering behavior and can be set to 0. It is recommended to use RenderingDevice.BreadcrumbMarker enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

public long DrawListBegin(Rid framebuffer, RenderingDevice.InitialAction initialColorAction, RenderingDevice.FinalAction finalColorAction, RenderingDevice.InitialAction initialDepthAction, RenderingDevice.FinalAction finalDepthAction, ReadOnlySpan<Color> clearColorValues, float clearDepth, uint clearStencil, Rect2? region, Reckfell.Collections.Array<Rid> storageTextures);

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions. Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using RenderingDevice.DrawListEnd. A simple drawing operation might look like this (code is not a complete example):

The draw_flags indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See RDTextureFormat or RenderingDevice.TextureSetDiscardable. The breadcrumb parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Reckfell is built in dev or debug mode; when the GPU crashes Reckfell will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to. It does not affect rendering behavior and can be set to 0. It is recommended to use RenderingDevice.BreadcrumbMarker enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

public long DrawListBegin(Rid framebuffer, RenderingDevice.InitialAction initialColorAction, RenderingDevice.FinalAction finalColorAction, RenderingDevice.InitialAction initialDepthAction, RenderingDevice.FinalAction finalDepthAction, ReadOnlySpan<Color> clearColorValues, float clearDepth, uint clearStencil, Rect2? region, uint breadcrumb);

Starts a list of raster drawing commands created with the draw_* methods. The returned value should be passed to other draw_list_* functions. Multiple draw lists cannot be created at the same time; you must finish the previous draw list first using RenderingDevice.DrawListEnd. A simple drawing operation might look like this (code is not a complete example):

The draw_flags indicates if the texture attachments of the framebuffer should be cleared or ignored. Only one of the two flags can be used for each individual attachment. Ignoring an attachment means that any contents that existed before the draw list will be completely discarded, reducing the memory bandwidth used by the render pass but producing garbage results if the pixels aren't replaced. The default behavior allows the engine to figure out the right operation to use if the texture is discardable, which can result in increased performance. See RDTextureFormat or RenderingDevice.TextureSetDiscardable. The breadcrumb parameter can be an arbitrary 32-bit integer that is useful to diagnose GPU crashes. If Reckfell is built in dev or debug mode; when the GPU crashes Reckfell will dump all shaders that were being executed at the time of the crash and the breadcrumb is useful to diagnose what passes did those shaders belong to. It does not affect rendering behavior and can be set to 0. It is recommended to use RenderingDevice.BreadcrumbMarker enumerations for consistency but it's not required. It is also possible to use bitwise operations to add extra data. e.g.

rd.draw_list_begin(fb[i], RenderingDevice.CLEAR_COLOR_ALL, clear_colors, true, 1.0f, true, 0, Rect2(), RenderingDevice.OPAQUE_PASS | 5)

public long DrawListBeginForScreen(int screen = 0, Color? clearColor = default);

High-level variant of RenderingDevice.DrawListBegin, with the parameters automatically being adjusted for drawing onto the window specified by the screen ID. Note: Cannot be used with local RenderingDevices, as these don't have a screen. If called on a local RenderingDevice, RenderingDevice.DrawListBeginForScreen returns RenderingDevice.InvalidId.

public long[] DrawListBeginSplit(Rid framebuffer, uint splits, RenderingDevice.InitialAction initialColorAction, RenderingDevice.FinalAction finalColorAction, RenderingDevice.InitialAction initialDepthAction, RenderingDevice.FinalAction finalDepthAction, Color[] clearColorValues = null, float clearDepth = 1f, uint clearStencil = 0, Rect2? region = default, Reckfell.Collections.Array<Rid> storageTextures = null);

This method does nothing and always returns an empty long[].

public long[] DrawListBeginSplit(Rid framebuffer, uint splits, RenderingDevice.InitialAction initialColorAction, RenderingDevice.FinalAction finalColorAction, RenderingDevice.InitialAction initialDepthAction, RenderingDevice.FinalAction finalDepthAction, ReadOnlySpan<Color> clearColorValues, float clearDepth, uint clearStencil, Rect2? region, Reckfell.Collections.Array<Rid> storageTextures);

This method does nothing and always returns an empty long[].

public void DrawListBindIndexArray(long drawList, Rid indexArray);

Binds index_array to the specified draw_list.

public void DrawListBindRenderPipeline(long drawList, Rid renderPipeline);

Binds render_pipeline to the specified draw_list.

public void DrawListBindUniformSet(long drawList, Rid uniformSet, uint setIndex);

Binds uniform_set to the specified draw_list. A set_index must also be specified, which is an identifier starting from 0 that must match the one expected by the draw list.

public void DrawListBindVertexArray(long drawList, Rid vertexArray);

Binds vertex_array to the specified draw_list.

public void DrawListBindVertexBuffersFormat(long drawList, long vertexFormat, uint vertexCount, Reckfell.Collections.Array<Rid> vertexBuffers, long[] offsets = null);

Binds a set of vertex_buffers directly to the specified draw_list using vertex_format without creating a vertex array RID. Provide the number of vertices in vertex_count; optional per-buffer byte offsets may also be supplied.

public void DrawListBindVertexBuffersFormat(long drawList, long vertexFormat, uint vertexCount, Reckfell.Collections.Array<Rid> vertexBuffers, ReadOnlySpan<long> offsets);

Binds a set of vertex_buffers directly to the specified draw_list using vertex_format without creating a vertex array RID. Provide the number of vertices in vertex_count; optional per-buffer byte offsets may also be supplied.

public void DrawListDisableScissor(long drawList);

Removes and disables the scissor rectangle for the specified draw_list. See also RenderingDevice.DrawListEnableScissor.

public void DrawListDraw(long drawList, bool useIndices, uint instances, uint proceduralVertexCount = 0);

Submits draw_list for rendering on the GPU. This is the raster equivalent to RenderingDevice.ComputeListDispatch.

public void DrawListDrawIndirect(long drawList, bool useIndices, Rid buffer, uint offset = 0, uint drawCount = 1, uint stride = 0);

Submits draw_list for rendering on the GPU with the given parameters stored in the buffer at offset. Parameters being integers: vertex count, instance count, first vertex, first instance. And when using indices: index count, instance count, first index, vertex offset, first instance. Buffer must have been created with RenderingDevice.StorageBufferUsage.Indirect flag.

public void DrawListEnableScissor(long drawList, Rect2? rect = default);

Creates a scissor rectangle and enables it for the specified draw_list. Scissor rectangles are used for clipping by discarding fragments that fall outside a specified rectangular portion of the screen. See also RenderingDevice.DrawListDisableScissor. Note: The specified rect is automatically intersected with the screen's dimensions, which means it cannot exceed the screen's dimensions.

public void DrawListEnd();

Finishes a list of raster drawing commands created with the draw_* methods.

public void DrawListEnd(RenderingDevice.BarrierMask postBarrier);

Finishes a list of raster drawing commands created with the draw_* methods.

public void DrawListSetBlendConstants(long drawList, Color color);

Sets blend constants for the specified draw_list to color. Blend constants are used only if the graphics pipeline is created with RenderingDevice.PipelineDynamicStateFlags.BlendConstants flag set.

public void DrawListSetPushConstant(long drawList, byte[] buffer, uint sizeBytes);

Sets the push constant data to buffer for the specified draw_list. The shader determines how this binary data is used. The buffer's size in bytes must also be specified in size_bytes (this can be obtained by calling the PackedByteArray.size method on the passed buffer).

public void DrawListSetPushConstant(long drawList, ReadOnlySpan<byte> buffer, uint sizeBytes);

Sets the push constant data to buffer for the specified draw_list. The shader determines how this binary data is used. The buffer's size in bytes must also be specified in size_bytes (this can be obtained by calling the PackedByteArray.size method on the passed buffer).

public long DrawListSwitchToNextPass();

Switches to the next draw pass.

public long[] DrawListSwitchToNextPassSplit(uint splits);

This method does nothing and always returns an empty long[].

public Rid FramebufferCreate(Reckfell.Collections.Array<Rid> textures, long validateWithFormat = -1, uint viewCount = 1);

Creates a new framebuffer. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method. This will be freed automatically when any of the textures is freed.

public Rid FramebufferCreateEmpty(Vector2I size, RenderingDevice.TextureSamples samples = RenderingDevice.TextureSamples.Samples1, long validateWithFormat = -1);

Creates a new empty framebuffer. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method.

public Rid FramebufferCreateMultipass(Reckfell.Collections.Array<Rid> textures, Reckfell.Collections.Array<RDFramebufferPass> passes, long validateWithFormat = -1, uint viewCount = 1);

Creates a new multipass framebuffer. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method. This will be freed automatically when any of the textures is freed.

public long FramebufferFormatCreate(Reckfell.Collections.Array<RDAttachmentFormat> attachments, uint viewCount = 1);

Creates a new framebuffer format with the specified attachments and view_count. Returns the new framebuffer's unique framebuffer format ID. If view_count is greater than or equal to 2, enables multiview which is used for VR rendering. This requires support for the Vulkan multiview extension.

public long FramebufferFormatCreateEmpty(RenderingDevice.TextureSamples samples = RenderingDevice.TextureSamples.Samples1);

Creates a new empty framebuffer format with the specified number of samples and returns its ID.

public long FramebufferFormatCreateMultipass(Reckfell.Collections.Array<RDAttachmentFormat> attachments, Reckfell.Collections.Array<RDFramebufferPass> passes, uint viewCount = 1);

Creates a multipass framebuffer format with the specified attachments, passes and view_count and returns its ID. If view_count is greater than or equal to 2, enables multiview which is used for VR rendering. This requires support for the Vulkan multiview extension.

public RenderingDevice.TextureSamples FramebufferFormatGetTextureSamples(long format, uint renderPass = 0);

Returns the number of texture samples used for the given framebuffer format ID (returned by RenderingDevice.FramebufferGetFormat).

public long FramebufferGetFormat(Rid framebuffer);

Returns the format ID of the framebuffer specified by the framebuffer RID. This ID is guaranteed to be unique for the same formats and does not need to be freed.

public bool FramebufferIsValid(Rid framebuffer);

Returns true if the framebuffer specified by the framebuffer RID is valid, false otherwise.

public void FreeRid(Rid rid);

Frees a resource owned by this RenderingDevice. Respect dependencies and work completion; do not reuse the freed RID. A nonzero Rid.IsValid alone does not prove the resource still exists.

public void FullBarrier();

This method does nothing.

public ulong GetCapturedTimestampCpuTime(uint index);

Returns the timestamp in CPU time for the rendering step specified by index (in microseconds since the engine started). See also RenderingDevice.GetCapturedTimestampGpuTime and RenderingDevice.CaptureTimestamp.

public ulong GetCapturedTimestampGpuTime(uint index);

Returns the timestamp in GPU time for the rendering step specified by index (in nanoseconds since the engine started). See also RenderingDevice.GetCapturedTimestampCpuTime and RenderingDevice.CaptureTimestamp.

public string GetCapturedTimestampName(uint index);

Returns the timestamp's name for the rendering step specified by index. See also RenderingDevice.CaptureTimestamp.

public uint GetCapturedTimestampsCount();

Returns the total number of timestamps (rendering steps) available for profiling.

public ulong GetCapturedTimestampsFrame();

Returns the index of the last frame rendered that has rendering timestamps available for querying.

public ulong GetDeviceAllocationCount();

Returns how many allocations the GPU has performed for internal driver structures. This is only used by Vulkan in debug builds and can return 0 when this information is not tracked or unknown.

public ulong GetDeviceAllocsByObjectType(uint type);

Same as RenderingDevice.GetDeviceAllocationCount but filtered for a given object type. The type argument must be in range [RenderingDevice.GetTrackedObjectTypeCount`](/en/docs/api/renderingdevice#member-gettrackedobjecttypecount-6ea83230eb) is 0, then type argument is ignored and always returns 0. This is only used by Vulkan in debug builds and can return 0 when this information is not tracked or unknown.

public ulong GetDeviceMemoryByObjectType(uint type);

Same as RenderingDevice.GetDeviceTotalMemory but filtered for a given object type. The type argument must be in range [RenderingDevice.GetTrackedObjectTypeCount`](/en/docs/api/renderingdevice#member-gettrackedobjecttypecount-6ea83230eb) is 0, then type argument is ignored and always returns 0. This is only used by Vulkan in debug builds and can return 0 when this information is not tracked or unknown.

public string GetDeviceName();

Returns the name of the video adapter (e.g. "GeForce GTX 1080/PCIe/SSE2"). Equivalent to RenderingServer.GetVideoAdapterName. See also RenderingDevice.GetDeviceVendorName.

public string GetDevicePipelineCacheUuid();

Returns the universally unique identifier for the pipeline cache. This is used to cache shader files on disk, which avoids shader recompilations on subsequent engine runs. This UUID varies depending on the graphics card model, but also the driver version. Therefore, updating graphics drivers will invalidate the shader cache.

public ulong GetDeviceTotalMemory();

Returns how much bytes the GPU is using. This is only used by Vulkan in debug builds and can return 0 when this information is not tracked or unknown.

public string GetDeviceVendorName();

Returns the vendor of the video adapter (e.g. "NVIDIA Corporation"). Equivalent to RenderingServer.GetVideoAdapterVendor. See also RenderingDevice.GetDeviceName.

public ulong GetDriverAllocationCount();

Returns how many allocations the GPU driver has performed for internal driver structures. This is only used by Vulkan in debug builds and can return 0 when this information is not tracked or unknown.

public ulong GetDriverAllocsByObjectType(uint type);

Same as RenderingDevice.GetDriverAllocationCount but filtered for a given object type. The type argument must be in range [RenderingDevice.GetTrackedObjectTypeCount`](/en/docs/api/renderingdevice#member-gettrackedobjecttypecount-6ea83230eb) is 0, then type argument is ignored and always returns 0. This is only used by Vulkan in debug builds and can return 0 when this information is not tracked or unknown.

public string GetDriverAndDeviceMemoryReport();

Returns string report in CSV format using the following methods:

• RenderingDevice.GetTrackedObjectName
• RenderingDevice.GetTrackedObjectTypeCount
• RenderingDevice.GetDriverTotalMemory
• RenderingDevice.GetDriverAllocationCount
• RenderingDevice.GetDriverMemoryByObjectType
• RenderingDevice.GetDriverAllocsByObjectType
• RenderingDevice.GetDeviceTotalMemory
• RenderingDevice.GetDeviceAllocationCount
• RenderingDevice.GetDeviceMemoryByObjectType
• RenderingDevice.GetDeviceAllocsByObjectType This is only used by Vulkan in debug builds. Reckfell must also be started with the --extra-gpu-memory-tracking command line argument.

public ulong GetDriverMemoryByObjectType(uint type);

Same as RenderingDevice.GetDriverTotalMemory but filtered for a given object type. The type argument must be in range [RenderingDevice.GetTrackedObjectTypeCount`](/en/docs/api/renderingdevice#member-gettrackedobjecttypecount-6ea83230eb) is 0, then type argument is ignored and always returns 0. This is only used by Vulkan in debug builds and can return 0 when this information is not tracked or unknown.

public ulong GetDriverResource(RenderingDevice.DriverResource resource, Rid rid, ulong index);

Returns the unique identifier of the driver resource for the specified rid. Some driver resource types ignore the specified rid. index is always ignored but must be specified anyway.

public ulong GetDriverTotalMemory();

Returns how much bytes the GPU driver is using for internal driver structures. This is only used by Vulkan in debug builds and can return 0 when this information is not tracked or unknown.

public uint GetFrameDelay();

Returns the frame count kept by the graphics API. Higher values result in higher input lag, but with more consistent throughput. For the main RenderingDevice, frames are cycled (usually 3 with triple-buffered V-Sync enabled). However, local RenderingDevices only have 1 frame.

public ulong GetMemoryUsage(RenderingDevice.MemoryType type);

Returns the memory usage in bytes corresponding to the given type. When using Vulkan, these statistics are calculated by Vulkan Memory Allocator.

public string GetPerfReport();

Returns a string with a performance report from the past frame. Updates every frame.

public string GetTrackedObjectName(uint typeIndex);

Returns the name of the type of object for the given type_index. This value must be in range [RenderingDevice.GetTrackedObjectTypeCount](/en/docs/api/renderingdevice#member-gettrackedobjecttypecount-6ea83230eb) is 0, then type argument is ignored and always returns the same string. The return value is important because it gives meaning to the types passed to [RenderingDevice.GetDriverMemoryByObjectType](/en/docs/api/renderingdevice#member-getdrivermemorybyobjecttype-f8ed5453a7), [RenderingDevice.GetDriverAllocsByObjectType](/en/docs/api/renderingdevice#member-getdriverallocsbyobjecttype-0caddbe283), [RenderingDevice.GetDeviceMemoryByObjectType](/en/docs/api/renderingdevice#member-getdevicememorybyobjecttype-3861f5f55f), and [RenderingDevice.GetDeviceAllocsByObjectType`](/en/docs/api/renderingdevice#member-getdeviceallocsbyobjecttype-341591375f). Examples of strings it can return (not exhaustive):

• DEVICE_MEMORY
• PIPELINE_CACHE
• SWAPCHAIN_KHR
• COMMAND_POOL Thus if e.g. get_tracked_object_name(5) returns "COMMAND_POOL", then get_device_memory_by_object_type(5) returns the bytes used by the GPU for command pools. This is only used by Vulkan in debug builds. Reckfell must also be started with the --extra-gpu-memory-tracking command line argument.

public ulong GetTrackedObjectTypeCount();

Returns how many types of trackable objects there are. This is only used by Vulkan in debug builds. Reckfell must also be started with the --extra-gpu-memory-tracking command line argument.

public bool HasFeature(RenderingDevice.Features feature);

Returns true if the feature is supported by the GPU.

public Rid HitSbtCreate(Rid raytracingPipeline, uint initialHitGroupCapacity);

Creates a new hit shader binding table (SBT). It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method. This will be freed automatically when the raytracing_pipeline is freed. The hit SBT resizes itself as needed. initial_hit_group_capacity is used to allocate the initial backing memory.

public long HitSbtRangeAlloc(Rid hitSbt, uint hitGroupCount);

Allocates a contiguous range of SBT entries from hit_sbt. The returned value should be assigned to RDAccelerationStructureInstance.HitSbtRange. During ray traversal, hit group index is computed as: (geometry index in RDAccelerationStructureInstance.Blas) × (SBT stride used in traceRayEXT)

• (SBT offset used in traceRayEXT)
• (range offset) hit_group_count must be large enough to cover all SBT entries that may be indexed by this equation. This typically corresponds to: (geometry count in RDAccelerationStructureInstance.Blas) × (SBT stride used in traceRayEXT) The allocated range is uninitialized and must be filled using RenderingDevice.HitSbtRangeUpdate.

public Error HitSbtRangeFree(Rid hitSbt, long range);

Frees a hit SBT range previously allocated with RenderingDevice.HitSbtRangeAlloc. The range must not be in use by any acceleration structure after being freed.

public Error HitSbtRangeUpdate(Rid hitSbt, long range, uint offset, int[] hitGroupIndices);

Updates the contents of a hit SBT range. hit_group_indices specifies indices into the hit group array provided in RenderingDevice.RaytracingPipelineCreate. The offset parameter specifies where within the allocated range the writing begins. This allows partial updates of a range. However, the complete range must be fully initialized before it is used in a raytracing dispatch.

public Error HitSbtRangeUpdate(Rid hitSbt, long range, uint offset, ReadOnlySpan<int> hitGroupIndices);

Updates the contents of a hit SBT range. hit_group_indices specifies indices into the hit group array provided in RenderingDevice.RaytracingPipelineCreate. The offset parameter specifies where within the allocated range the writing begins. This allows partial updates of a range. However, the complete range must be fully initialized before it is used in a raytracing dispatch.

public Error HitSbtSetPipeline(Rid hitSbt, Rid raytracingPipeline);

Sets a new raytracing_pipeline for hit_sbt. The new pipeline must be a superset of the previous one. Existing hit groups must keep the same order and new hit groups should be appended to the end. This preserves existing SBT entries. The previous pipeline must remain valid during the call.

public Rid IndexArrayCreate(Rid indexBuffer, uint indexOffset, uint indexCount);

Creates a new index array. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method. This will be freed automatically when the index_buffer is freed.

public Rid IndexBufferCreate(uint sizeIndices, RenderingDevice.IndexBufferFormat format, byte[] data, bool useRestartIndices);

Creates a new index buffer. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method.

public Rid IndexBufferCreate(uint sizeIndices, RenderingDevice.IndexBufferFormat format, byte[] data = null, bool useRestartIndices = false, RenderingDevice.BufferCreationBits creationBits = (RenderingDevice.BufferCreationBits)0);

Creates a new index buffer. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method.

public Rid IndexBufferCreate(uint sizeIndices, RenderingDevice.IndexBufferFormat format, ReadOnlySpan<byte> data, bool useRestartIndices);

Creates a new index buffer. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method.

public Rid IndexBufferCreate(uint sizeIndices, RenderingDevice.IndexBufferFormat format, ReadOnlySpan<byte> data, bool useRestartIndices, RenderingDevice.BufferCreationBits creationBits);

Creates a new index buffer. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method.

public ulong LimitGet(RenderingDevice.Limit limit);

Queries a hardware limit of this device. For example, MaxTextureSize2D bounds a 2D texture dimension but does not guarantee a successful allocation at that size. Values depend on the device and driver; they are not remaining memory or one universal limit for all texture types.

public long RaytracingListBegin();

Starts a list of raytracing commands. The returned value should be passed to other raytracing_list_* functions. Multiple raytracing lists cannot be created at the same time; you must finish the previous raytracing list first using RenderingDevice.RaytracingListEnd. A simple raytracing operation might look like this (code is not a complete example):

public void RaytracingListBindRaytracingPipeline(long raytracingList, Rid raytracingPipeline);

Binds raytracing_pipeline to the specified raytracing_list.

public void RaytracingListBindUniformSet(long raytracingList, Rid uniformSet, uint setIndex);

Binds the uniform_set to this raytracing_list.

public void RaytracingListEnd();

Finishes a list of raytracing commands created with the raytracing_* methods.

public void RaytracingListSetPushConstant(long raytracingList, byte[] buffer, uint sizeBytes);

Sets the push constant data to buffer for the specified raytracing_list. The shader determines how this binary data is used. The buffer's size in bytes must also be specified in size_bytes (this can be obtained by calling the PackedByteArray.size method on the passed buffer).

public void RaytracingListSetPushConstant(long raytracingList, ReadOnlySpan<byte> buffer, uint sizeBytes);

Sets the push constant data to buffer for the specified raytracing_list. The shader determines how this binary data is used. The buffer's size in bytes must also be specified in size_bytes (this can be obtained by calling the PackedByteArray.size method on the passed buffer).

public void RaytracingListTraceRays(long raytracingList, uint raygenShaderIndex, Rid hitSbt, uint width, uint height, uint depth);

Initializes a raytracing dispatch for raytracing_list, launching width × height × depth rays. raygen_shader_index selects the ray generation shader from the pipeline bound with RenderingDevice.RaytracingListBindRaytracingPipeline. hit_sbt must use the same pipeline bound to raytracing_list.

public Rid RaytracingPipelineCreate(Reckfell.Collections.Array<RDPipelineShader> raygenShaders, Reckfell.Collections.Array<RDPipelineShader> missShaders, Reckfell.Collections.Array<RDHitGroup> hitGroups, uint maxTraceRecursionDepth);

Creates a new raytracing pipeline. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method. Each shader must provide the required stage. All stages must use compatible pipeline layouts. The pipeline selects the required stage from each shader. Input order defines stable indices used by the API:

• raygen_shaders is indexed in RenderingDevice.RaytracingListTraceRays.
• miss_shaders is indexed in traceRayEXT.
• hit_groups is indexed in RenderingDevice.HitSbtRangeUpdate.

public bool RaytracingPipelineIsValid(Rid raytracingPipeline);

Returns true if the raytracing pipeline specified by the raytracing_pipeline RID is valid, false otherwise.

public Rid RenderPipelineCreate(Rid shader, long framebufferFormat, long vertexFormat, RenderingDevice.RenderPrimitive primitive, RDPipelineRasterizationState rasterizationState, RDPipelineMultisampleState multisampleState, RDPipelineDepthStencilState stencilState, RDPipelineColorBlendState colorBlendState, RenderingDevice.PipelineDynamicStateFlags dynamicStateFlags = (RenderingDevice.PipelineDynamicStateFlags)0, uint forRenderPass = 0, Reckfell.Collections.Array<RDPipelineSpecializationConstant> specializationConstants = null);

Creates a new render pipeline. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method. This will be freed automatically when the shader is freed.

public bool RenderPipelineIsValid(Rid renderPipeline);

Returns true if the render pipeline specified by the render_pipeline RID is valid, false otherwise.

public Rid SamplerCreate(RDSamplerState state);

Creates a new sampler. It can be accessed with the RID that is returned. Once finished with your RID, you will want to free the RID using the RenderingDevice's RenderingDevice.FreeRid method.

public bool SamplerIsFormatSupportedForFilter(RenderingDevice.DataFormat format, RenderingDevice.SamplerFilter samplerFilter);

Returns true if implementation supports using a texture of format with the given sampler_filter.

public long ScreenGetFramebufferFormat();

Returns the framebuffer format of the given screen. Note: Only the main RenderingDevice returned by RenderingServer.GetRenderingDevice has a format. If called on a local RenderingDevice, this method prints an error and returns RenderingDevice.InvalidId.

public long ScreenGetFramebufferFormat(int screen = 0);

Returns the framebuffer format of the given screen. Note: Only the main RenderingDevice returned by RenderingServer.GetRenderingDevice has a format. If called on a local RenderingDevice, this method prints an error and returns RenderingDevice.InvalidId.

public int ScreenGetHeight(int screen = 0);

Returns the window height matching the graphics API context for the given window ID (in pixels). Despite the parameter being named screen, this returns the window size. See also RenderingDevice.ScreenGetWidth. Note: Only the main RenderingDevice returned by RenderingServer.GetRenderingDevice has a height. If called on a local RenderingDevice, this method prints an error and returns RenderingDevice.InvalidId.