apple.metal.protocol

Interface MTLRenderCommandEncoder

All Superinterfaces:

MTLCommandEncoder

public interface MTLRenderCommandEncoder
extends MTLCommandEncoder

[@protocol] MTLRenderCommandEncoder

MTLRenderCommandEncoder is a container for graphics rendering state and the code to translate the state into a command format that the device can execute.

Method Summary

Modifier and Type	Method and Description
void	dispatchThreadsPerTile(MTLSize threadsPerTile) dispatchThreadsPerTile:
void	drawIndexedPatchesPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetIndirectBufferIndirectBufferOffset(long numberOfPatchControlPoints, MTLBuffer patchIndexBuffer, long patchIndexBufferOffset, MTLBuffer controlPointIndexBuffer, long controlPointIndexBufferOffset, MTLBuffer indirectBuffer, long indirectBufferOffset)
void	drawIndexedPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetInstanceCountBaseInstance(long numberOfPatchControlPoints, long patchStart, long patchCount, MTLBuffer patchIndexBuffer, long patchIndexBufferOffset, MTLBuffer controlPointIndexBuffer, long controlPointIndexBufferOffset, long instanceCount, long baseInstance)
void	drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffset(long primitiveType, long indexCount, long indexType, MTLBuffer indexBuffer, long indexBufferOffset) drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:
void	drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCount(long primitiveType, long indexCount, long indexType, MTLBuffer indexBuffer, long indexBufferOffset, long instanceCount) drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:
void	drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCountBaseVertexBaseInstance(long primitiveType, long indexCount, long indexType, MTLBuffer indexBuffer, long indexBufferOffset, long instanceCount, long baseVertex, long baseInstance) drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:
void	drawIndexedPrimitivesIndexTypeIndexBufferIndexBufferOffsetIndirectBufferIndirectBufferOffset(long primitiveType, long indexType, MTLBuffer indexBuffer, long indexBufferOffset, MTLBuffer indirectBuffer, long indirectBufferOffset) drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:
void	drawPatchesPatchIndexBufferPatchIndexBufferOffsetIndirectBufferIndirectBufferOffset(long numberOfPatchControlPoints, MTLBuffer patchIndexBuffer, long patchIndexBufferOffset, MTLBuffer indirectBuffer, long indirectBufferOffset)
void	drawPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetInstanceCountBaseInstance(long numberOfPatchControlPoints, long patchStart, long patchCount, MTLBuffer patchIndexBuffer, long patchIndexBufferOffset, long instanceCount, long baseInstance)
void	drawPrimitivesIndirectBufferIndirectBufferOffset(long primitiveType, MTLBuffer indirectBuffer, long indirectBufferOffset) drawPrimitives:indirectBuffer:indirectBufferOffset:
void	drawPrimitivesVertexStartVertexCount(long primitiveType, long vertexStart, long vertexCount) drawPrimitives:vertexStart:vertexCount:
void	drawPrimitivesVertexStartVertexCountInstanceCount(long primitiveType, long vertexStart, long vertexCount, long instanceCount) drawPrimitives:vertexStart:vertexCount:instanceCount:
void	drawPrimitivesVertexStartVertexCountInstanceCountBaseInstance(long primitiveType, long vertexStart, long vertexCount, long instanceCount, long baseInstance) drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:
void	executeCommandsInBufferIndirectBufferIndirectBufferOffset(MTLIndirectCommandBuffer indirectCommandbuffer, MTLBuffer indirectRangeBuffer, long indirectBufferOffset) executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:
void	executeCommandsInBufferWithRange(MTLIndirectCommandBuffer indirectCommandBuffer, NSRange executionRange) executeCommandsInBuffer:withRange:
void	sampleCountersInBufferAtSampleIndexWithBarrier(MTLCounterSampleBuffer sampleBuffer, long sampleIndex, boolean barrier) sampleCountersInBuffer:atSampleIndex:withBarrier:
void	setBlendColorRedGreenBlueAlpha(float red, float green, float blue, float alpha) Constant Blend Color
void	setColorStoreActionAtIndex(long storeAction, long colorAttachmentIndex) setColorStoreAction:atIndex:
void	setColorStoreActionOptionsAtIndex(long storeActionOptions, long colorAttachmentIndex) setColorStoreActionOptions:atIndex:
void	setCullMode(long cullMode) setCullMode:
void	setDepthBiasSlopeScaleClamp(float depthBias, float slopeScale, float clamp) setDepthBias:slopeScale:clamp:
void	setDepthClipMode(long depthClipMode) setDepthClipMode:
void	setDepthStencilState(MTLDepthStencilState depthStencilState) setDepthStencilState:
void	setDepthStoreAction(long storeAction) setDepthStoreAction:
void	setDepthStoreActionOptions(long storeActionOptions) setDepthStoreActionOptions:
void	setFragmentAccelerationStructureAtBufferIndex(MTLAccelerationStructure accelerationStructure, long bufferIndex) setFragmentAccelerationStructure:atBufferIndex:
void	setFragmentBufferOffsetAtIndex(long offset, long index) setFragmentBufferOffset:atIndex:
void	setFragmentBufferOffsetAtIndex(MTLBuffer buffer, long offset, long index) setFragmentBuffer:offset:atIndex:
void	setFragmentBuffersOffsetsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, org.moe.natj.general.ptr.ConstNUIntPtr offsets, NSRange range) setFragmentBuffers:offsets:withRange:
void	setFragmentBytesLengthAtIndex(org.moe.natj.general.ptr.ConstVoidPtr bytes, long length, long index) setFragmentBytes:length:atIndex:
void	setFragmentIntersectionFunctionTableAtBufferIndex(MTLIntersectionFunctionTable intersectionFunctionTable, long bufferIndex) setFragmentIntersectionFunctionTable:atBufferIndex:
void	setFragmentIntersectionFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTable, NSRange range) setFragmentIntersectionFunctionTables:withBufferRange:
void	setFragmentSamplerStateAtIndex(MTLSamplerState sampler, long index) setFragmentSamplerState:atIndex:
void	setFragmentSamplerStateLodMinClampLodMaxClampAtIndex(MTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, long index) setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:
void	setFragmentSamplerStatesLodMinClampsLodMaxClampsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps, org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps, NSRange range) setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:
void	setFragmentSamplerStatesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, NSRange range) setFragmentSamplerStates:withRange:
void	setFragmentTextureAtIndex(MTLTexture texture, long index) setFragmentTexture:atIndex:
void	setFragmentTexturesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures, NSRange range) setFragmentTextures:withRange:
void	setFragmentVisibleFunctionTableAtBufferIndex(MTLVisibleFunctionTable functionTable, long bufferIndex) setFragmentVisibleFunctionTable:atBufferIndex:
void	setFragmentVisibleFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> functionTables, NSRange range) setFragmentVisibleFunctionTables:withBufferRange:
void	setFrontFacingWinding(long frontFacingWinding) setFrontFacingWinding:
void	setRenderPipelineState(MTLRenderPipelineState pipelineState) setRenderPipelineState
void	setScissorRect(MTLScissorRect rect) setScissorRect:
void	setScissorRectsCount(MTLScissorRect scissorRects, long count) setScissorRects:
void	setStencilFrontReferenceValueBackReferenceValue(int frontReferenceValue, int backReferenceValue) setStencilFrontReferenceValue:backReferenceValue:
void	setStencilReferenceValue(int referenceValue) setStencilReferenceValue:
void	setStencilStoreAction(long storeAction) setStencilStoreAction:
void	setStencilStoreActionOptions(long storeActionOptions) setStencilStoreActionOptions:
void	setTessellationFactorBufferOffsetInstanceStride(MTLBuffer buffer, long offset, long instanceStride)
void	setTessellationFactorScale(float scale)
void	setThreadgroupMemoryLengthOffsetAtIndex(long length, long offset, long index) setThreadgroupMemoryLength:offset:atIndex:
void	setTileAccelerationStructureAtBufferIndex(MTLAccelerationStructure accelerationStructure, long bufferIndex) setTileAccelerationStructure:atBufferIndex:
void	setTileBufferOffsetAtIndex(long offset, long index) setTileBufferOffset:atIndex:
void	setTileBufferOffsetAtIndex(MTLBuffer buffer, long offset, long index) setTileBuffer:offset:atIndex:
void	setTileBuffersOffsetsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, org.moe.natj.general.ptr.ConstNUIntPtr offsets, NSRange range) setTileBuffers:offsets:withRange:
void	setTileBytesLengthAtIndex(org.moe.natj.general.ptr.ConstVoidPtr bytes, long length, long index) setTileBytes:length:atIndex:
void	setTileIntersectionFunctionTableAtBufferIndex(MTLIntersectionFunctionTable intersectionFunctionTable, long bufferIndex) setTileIntersectionFunctionTable:atBufferIndex:
void	setTileIntersectionFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTable, NSRange range) setTileIntersectionFunctionTables:withBufferRange:
void	setTileSamplerStateAtIndex(MTLSamplerState sampler, long index) setTileSamplerState:atIndex:
void	setTileSamplerStateLodMinClampLodMaxClampAtIndex(MTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, long index) setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:
void	setTileSamplerStatesLodMinClampsLodMaxClampsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps, org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps, NSRange range) setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:
void	setTileSamplerStatesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, NSRange range) setTileSamplerStates:withRange:
void	setTileTextureAtIndex(MTLTexture texture, long index) setTileTexture:atIndex:
void	setTileTexturesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures, NSRange range) setTileTextures:withRange:
void	setTileVisibleFunctionTableAtBufferIndex(MTLVisibleFunctionTable functionTable, long bufferIndex) setTileVisibleFunctionTable:atBufferIndex:
void	setTileVisibleFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> functionTables, NSRange range) setTileVisibleFunctionTables:withBufferRange:
void	setTriangleFillMode(long fillMode) setTriangleFillMode:
void	setVertexAccelerationStructureAtBufferIndex(MTLAccelerationStructure accelerationStructure, long bufferIndex) setVertexAccelerationStructure:atBufferIndex:
void	setVertexAmplificationCountViewMappings(long count, MTLVertexAmplificationViewMapping viewMappings) setVertexAmplificationCount:
void	setVertexBufferOffsetAtIndex(long offset, long index) setVertexBufferOffset:atIndex:
void	setVertexBufferOffsetAtIndex(MTLBuffer buffer, long offset, long index) setVertexBuffer:offset:atIndex:
void	setVertexBuffersOffsetsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, org.moe.natj.general.ptr.ConstNUIntPtr offsets, NSRange range) setVertexBuffers:offsets:withRange:
void	setVertexBytesLengthAtIndex(org.moe.natj.general.ptr.ConstVoidPtr bytes, long length, long index) setVertexBytes:length:atIndex:
void	setVertexIntersectionFunctionTableAtBufferIndex(MTLIntersectionFunctionTable intersectionFunctionTable, long bufferIndex) setVertexIntersectionFunctionTable:atBufferIndex:
void	setVertexIntersectionFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTable, NSRange range) setVertexIntersectionFunctionTables:withBufferRange:
void	setVertexSamplerStateAtIndex(MTLSamplerState sampler, long index) setVertexSamplerState:atIndex:
void	setVertexSamplerStateLodMinClampLodMaxClampAtIndex(MTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, long index) setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:
void	setVertexSamplerStatesLodMinClampsLodMaxClampsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps, org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps, NSRange range) setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:
void	setVertexSamplerStatesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, NSRange range) setVertexSamplerStates:withRange:
void	setVertexTextureAtIndex(MTLTexture texture, long index) setVertexTexture:atIndex:
void	setVertexTexturesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures, NSRange range) setVertexTextures:withRange:
void	setVertexVisibleFunctionTableAtBufferIndex(MTLVisibleFunctionTable functionTable, long bufferIndex) setVertexVisibleFunctionTable:atBufferIndex:
void	setVertexVisibleFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> functionTables, NSRange range) setVertexVisibleFunctionTables:withBufferRange:
void	setViewport(MTLViewport viewport) setViewport:
void	setViewportsCount(MTLViewport viewports, long count) setViewports:
void	setVisibilityResultModeOffset(long mode, long offset) setVisibilityResultMode:offset:
long	tileHeight() [@property] tileHeight:
long	tileWidth() [@property] tileWidth:
void	updateFenceAfterStages(MTLFence fence, long stages) updateFence:afterStages:
void	useHeap(MTLHeap heap) useHeap:
void	useHeapsCount(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> heaps, long count) useHeaps:count:
void	useHeapsCountStages(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> heaps, long count, long stages) useHeaps:count:stages
void	useHeapStages(MTLHeap heap, long stages) useHeap:stages
void	useResourcesCountUsage(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources, long count, long usage) * @method useResources:count:usage: * @abstract Declare that an array of resources may be accessed through an argument buffer by the render pass * @discussion This method does not protect against data hazards; these hazards must be addressed using an MTLFence.
void	useResourcesCountUsageStages(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources, long count, long usage, long stages) * @method useResources:count:usage:stages * @abstract Declare that an array of resources may be accessed through an argument buffer by the render pass * @discussion For hazard tracked resources, this method protects against data hazards.
void	useResourceUsage(MTLResource resource, long usage) * @method useResource:usage: * @abstract Declare that a resource may be accessed by the render pass through an argument buffer * @discussion This method does not protect against data hazards; these hazards must be addressed using an MTLFence.
void	useResourceUsageStages(MTLResource resource, long usage, long stages) * @method useResources:usage:stage * @abstract Declare that a resource may be accessed by the render pass through an argument buffer * @For hazard tracked resources, this method protects against data hazards.
void	waitForFenceBeforeStages(MTLFence fence, long stages) waitForFence:beforeStages:

Methods inherited from interface apple.metal.protocol.MTLCommandEncoder

device, endEncoding, insertDebugSignpost, label, popDebugGroup, pushDebugGroup, setLabel

Method Detail

drawIndexedPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetInstanceCountBaseInstance

void drawIndexedPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetInstanceCountBaseInstance(long numberOfPatchControlPoints,
                                                                                                                                                               long patchStart,
                                                                                                                                                               long patchCount,
                                                                                                                                                               MTLBuffer patchIndexBuffer,
                                                                                                                                                               long patchIndexBufferOffset,
                                                                                                                                                               MTLBuffer controlPointIndexBuffer,
                                                                                                                                                               long controlPointIndexBufferOffset,
                                                                                                                                                               long instanceCount,
                                                                                                                                                               long baseInstance)

drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffset

void drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffset(long primitiveType,
                                                                          long indexCount,
                                                                          long indexType,
                                                                          MTLBuffer indexBuffer,
                                                                          long indexBufferOffset)

drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:

Draw primitives with an index list.

Parameters:

primitiveType - The type of primitives that elements are assembled into.

indexCount - The number of indexes to read from the index buffer for each instance.

indexType - The type if indexes, either 16 bit integer or 32 bit integer.

indexBuffer - A buffer object that the device will read indexes from.

indexBufferOffset - Byte offset within @a indexBuffer to start reading indexes from. @a indexBufferOffset must be a multiple of the index size.

drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCount

void drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCount(long primitiveType,
                                                                                       long indexCount,
                                                                                       long indexType,
                                                                                       MTLBuffer indexBuffer,
                                                                                       long indexBufferOffset,
                                                                                       long instanceCount)

drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:

Draw primitives with an index list.

Parameters:

primitiveType - The type of primitives that elements are assembled into.

indexCount - The number of indexes to read from the index buffer for each instance.

indexType - The type if indexes, either 16 bit integer or 32 bit integer.

indexBuffer - A buffer object that the device will read indexes from.

indexBufferOffset - Byte offset within @a indexBuffer to start reading indexes from. @a indexBufferOffset must be a multiple of the index size.

instanceCount - The number of instances drawn.

drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCountBaseVertexBaseInstance

void drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCountBaseVertexBaseInstance(long primitiveType,
                                                                                                             long indexCount,
                                                                                                             long indexType,
                                                                                                             MTLBuffer indexBuffer,
                                                                                                             long indexBufferOffset,
                                                                                                             long instanceCount,
                                                                                                             long baseVertex,
                                                                                                             long baseInstance)

drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:

Draw primitives with an index list.

Parameters:

primitiveType - The type of primitives that elements are assembled into.

indexCount - The number of indexes to read from the index buffer for each instance.

indexType - The type if indexes, either 16 bit integer or 32 bit integer.

indexBuffer - A buffer object that the device will read indexes from.

indexBufferOffset - Byte offset within @a indexBuffer to start reading indexes from. @a indexBufferOffset must be a multiple of the index size.

instanceCount - The number of instances drawn.

baseVertex - Offset for vertex_id. NOTE: this can be negative

baseInstance - Offset for instance_id.

drawIndexedPrimitivesIndexTypeIndexBufferIndexBufferOffsetIndirectBufferIndirectBufferOffset

void drawIndexedPrimitivesIndexTypeIndexBufferIndexBufferOffsetIndirectBufferIndirectBufferOffset(long primitiveType,
                                                                                                  long indexType,
                                                                                                  MTLBuffer indexBuffer,
                                                                                                  long indexBufferOffset,
                                                                                                  MTLBuffer indirectBuffer,
                                                                                                  long indirectBufferOffset)

drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:

Draw primitives with an index list using an indirect buffer see MTLDrawIndexedPrimitivesIndirectArguments.

Parameters:

primitiveType - The type of primitives that elements are assembled into.

indexType - The type if indexes, either 16 bit integer or 32 bit integer.

indexBuffer - A buffer object that the device will read indexes from.

indexBufferOffset - Byte offset within @a indexBuffer to start reading indexes from. @a indexBufferOffset must be a multiple of the index size.

indirectBuffer - A buffer object that the device will read drawIndexedPrimitives arguments from, see MTLDrawIndexedPrimitivesIndirectArguments.

indirectBufferOffset - Byte offset within @a indirectBuffer to start reading indexes from. @a indirectBufferOffset must be a multiple of 4.

drawPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetInstanceCountBaseInstance

void drawPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetInstanceCountBaseInstance(long numberOfPatchControlPoints,
                                                                                                    long patchStart,
                                                                                                    long patchCount,
                                                                                                    MTLBuffer patchIndexBuffer,
                                                                                                    long patchIndexBufferOffset,
                                                                                                    long instanceCount,
                                                                                                    long baseInstance)

drawPrimitivesIndirectBufferIndirectBufferOffset

void drawPrimitivesIndirectBufferIndirectBufferOffset(long primitiveType,
                                                      MTLBuffer indirectBuffer,
                                                      long indirectBufferOffset)

drawPrimitives:indirectBuffer:indirectBufferOffset:

Draw primitives without an index list using an indirect buffer see MTLDrawPrimitivesIndirectArguments.

Parameters:

primitiveType - The type of primitives that elements are assembled into.

indirectBuffer - A buffer object that the device will read drawPrimitives arguments from, see MTLDrawPrimitivesIndirectArguments.

indirectBufferOffset - Byte offset within @a indirectBuffer to start reading indexes from. @a indirectBufferOffset must be a multiple of 4.

drawPrimitivesVertexStartVertexCount

void drawPrimitivesVertexStartVertexCount(long primitiveType,
                                          long vertexStart,
                                          long vertexCount)

drawPrimitives:vertexStart:vertexCount:

Draw primitives without an index list.

Parameters:

primitiveType - The type of primitives that elements are assembled into.

vertexStart - For each instance, the first index to draw

vertexCount - For each instance, the number of indexes to draw

drawPrimitivesVertexStartVertexCountInstanceCount

void drawPrimitivesVertexStartVertexCountInstanceCount(long primitiveType,
                                                       long vertexStart,
                                                       long vertexCount,
                                                       long instanceCount)

drawPrimitives:vertexStart:vertexCount:instanceCount:

Draw primitives without an index list.

Parameters:

primitiveType - The type of primitives that elements are assembled into.

vertexStart - For each instance, the first index to draw

vertexCount - For each instance, the number of indexes to draw

instanceCount - The number of instances drawn.

drawPrimitivesVertexStartVertexCountInstanceCountBaseInstance

void drawPrimitivesVertexStartVertexCountInstanceCountBaseInstance(long primitiveType,
                                                                   long vertexStart,
                                                                   long vertexCount,
                                                                   long instanceCount,
                                                                   long baseInstance)

drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:

Draw primitives without an index list.

Parameters:

primitiveType - The type of primitives that elements are assembled into.

vertexStart - For each instance, the first index to draw

vertexCount - For each instance, the number of indexes to draw

instanceCount - The number of instances drawn.

baseInstance - Offset for instance_id.

setBlendColorRedGreenBlueAlpha

void setBlendColorRedGreenBlueAlpha(float red,
                                    float green,
                                    float blue,
                                    float alpha)

Constant Blend Color

setBlendColorRed:green:blue:alpha:

Set the constant blend color used across all blending on all render targets

setColorStoreActionAtIndex

void setColorStoreActionAtIndex(long storeAction,
                                long colorAttachmentIndex)

setColorStoreAction:atIndex:

If the the store action for a given color attachment was set to MTLStoreActionUnknown when the render command encoder was created, setColorStoreAction:atIndex: must be used to finalize the store action before endEncoding is called.

Parameters:

storeAction - The desired store action for the given color attachment. This may be set to any value other than MTLStoreActionUnknown.

colorAttachmentIndex - The index of the color attachment

setCullMode

void setCullMode(long cullMode)

setCullMode:

Controls if primitives are culled when front facing, back facing, or not culled at all.

setDepthBiasSlopeScaleClamp

void setDepthBiasSlopeScaleClamp(float depthBias,
                                 float slopeScale,
                                 float clamp)

setDepthBias:slopeScale:clamp:

Depth Bias.

setDepthStencilState

void setDepthStencilState(MTLDepthStencilState depthStencilState)

setDepthStencilState:

Set the DepthStencil state object.

setDepthStoreAction

void setDepthStoreAction(long storeAction)

setDepthStoreAction:

If the the store action for the depth attachment was set to MTLStoreActionUnknown when the render command encoder was created, setDepthStoreAction: must be used to finalize the store action before endEncoding is called.

setFragmentBufferOffsetAtIndex

void setFragmentBufferOffsetAtIndex(MTLBuffer buffer,
                                    long offset,
                                    long index)

setFragmentBuffer:offset:atIndex:

Set a global buffer for all fragment shaders at the given bind point index.

setFragmentBufferOffsetAtIndex

void setFragmentBufferOffsetAtIndex(long offset,
                                    long index)

setFragmentBufferOffset:atIndex:

Set the offset within the current global buffer for all fragment shaders at the given bind point index.

setFragmentBuffersOffsetsWithRange

void setFragmentBuffersOffsetsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers,
                                        org.moe.natj.general.ptr.ConstNUIntPtr offsets,
                                        NSRange range)

setFragmentBuffers:offsets:withRange:

Set an array of global buffers for all fragment shaders with the given bind point range.

setFragmentBytesLengthAtIndex

void setFragmentBytesLengthAtIndex(org.moe.natj.general.ptr.ConstVoidPtr bytes,
                                   long length,
                                   long index)

setFragmentBytes:length:atIndex:

Set the data (by copy) for a given fragment buffer binding point. This will remove any existing MTLBuffer from the binding point.

setFragmentSamplerStateAtIndex

void setFragmentSamplerStateAtIndex(MTLSamplerState sampler,
                                    long index)

setFragmentSamplerState:atIndex:

Set a global sampler for all fragment shaders at the given bind point index.

setFragmentSamplerStateLodMinClampLodMaxClampAtIndex

void setFragmentSamplerStateLodMinClampLodMaxClampAtIndex(MTLSamplerState sampler,
                                                          float lodMinClamp,
                                                          float lodMaxClamp,
                                                          long index)

setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:

Set a global sampler for all fragment shaders at the given bind point index.

setFragmentSamplerStatesLodMinClampsLodMaxClampsWithRange

void setFragmentSamplerStatesLodMinClampsLodMaxClampsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                                               org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps,
                                                               org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps,
                                                               NSRange range)

setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:

Set an array of global samplers for all fragment shaders with the given bind point range.

setFragmentSamplerStatesWithRange

void setFragmentSamplerStatesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                       NSRange range)

setFragmentSamplerStates:withRange:

Set an array of global samplers for all fragment shaders with the given bind point range.

setFragmentTextureAtIndex

void setFragmentTextureAtIndex(MTLTexture texture,
                               long index)

setFragmentTexture:atIndex:

Set a global texture for all fragment shaders at the given bind point index.

setFragmentTexturesWithRange

void setFragmentTexturesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures,
                                  NSRange range)

setFragmentTextures:withRange:

Set an array of global textures for all fragment shaders with the given bind point range.

setFrontFacingWinding

void setFrontFacingWinding(long frontFacingWinding)

setFrontFacingWinding:

The winding order of front-facing primitives.

setRenderPipelineState

void setRenderPipelineState(MTLRenderPipelineState pipelineState)

setRenderPipelineState

Sets the current render pipeline state object.

setScissorRect

void setScissorRect(MTLScissorRect rect)

setScissorRect:

Specifies a rectangle for a fragment scissor test. All fragments outside of this rectangle are discarded.

setStencilFrontReferenceValueBackReferenceValue

void setStencilFrontReferenceValueBackReferenceValue(int frontReferenceValue,
                                                     int backReferenceValue)

setStencilFrontReferenceValue:backReferenceValue:

Set the stencil reference value for the back and front stencil buffers independently.

setStencilReferenceValue

void setStencilReferenceValue(int referenceValue)

setStencilReferenceValue:

Set the stencil reference value for both the back and front stencil buffers.

setStencilStoreAction

void setStencilStoreAction(long storeAction)

setStencilStoreAction:

If the the store action for the stencil attachment was set to MTLStoreActionUnknown when the render command encoder was created, setStencilStoreAction: must be used to finalize the store action before endEncoding is called.

setTessellationFactorBufferOffsetInstanceStride

void setTessellationFactorBufferOffsetInstanceStride(MTLBuffer buffer,
                                                     long offset,
                                                     long instanceStride)

setTessellationFactorScale

void setTessellationFactorScale(float scale)

setTriangleFillMode

void setTriangleFillMode(long fillMode)

setTriangleFillMode:

Set how to rasterize triangle and triangle strip primitives.

setVertexBufferOffsetAtIndex

void setVertexBufferOffsetAtIndex(MTLBuffer buffer,
                                  long offset,
                                  long index)

setVertexBuffer:offset:atIndex:

Set a global buffer for all vertex shaders at the given bind point index.

setVertexBufferOffsetAtIndex

void setVertexBufferOffsetAtIndex(long offset,
                                  long index)

setVertexBufferOffset:atIndex:

Set the offset within the current global buffer for all vertex shaders at the given bind point index.

setVertexBuffersOffsetsWithRange

void setVertexBuffersOffsetsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers,
                                      org.moe.natj.general.ptr.ConstNUIntPtr offsets,
                                      NSRange range)

setVertexBuffers:offsets:withRange:

Set an array of global buffers for all vertex shaders with the given bind point range.

setVertexBytesLengthAtIndex

void setVertexBytesLengthAtIndex(org.moe.natj.general.ptr.ConstVoidPtr bytes,
                                 long length,
                                 long index)

setVertexBytes:length:atIndex:

Set the data (by copy) for a given vertex buffer binding point. This will remove any existing MTLBuffer from the binding point.

setVertexSamplerStateAtIndex

void setVertexSamplerStateAtIndex(MTLSamplerState sampler,
                                  long index)

setVertexSamplerState:atIndex:

Set a global sampler for all vertex shaders at the given bind point index.

setVertexSamplerStateLodMinClampLodMaxClampAtIndex

void setVertexSamplerStateLodMinClampLodMaxClampAtIndex(MTLSamplerState sampler,
                                                        float lodMinClamp,
                                                        float lodMaxClamp,
                                                        long index)

setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:

Set a global sampler for all vertex shaders at the given bind point index.

setVertexSamplerStatesLodMinClampsLodMaxClampsWithRange

void setVertexSamplerStatesLodMinClampsLodMaxClampsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                                             org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps,
                                                             org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps,
                                                             NSRange range)

setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:

Set an array of global samplers for all vertex shaders with the given bind point range.

setVertexSamplerStatesWithRange

void setVertexSamplerStatesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                     NSRange range)

setVertexSamplerStates:withRange:

Set an array of global samplers for all vertex shaders with the given bind point range.

setVertexTextureAtIndex

void setVertexTextureAtIndex(MTLTexture texture,
                             long index)

setVertexTexture:atIndex:

Set a global texture for all vertex shaders at the given bind point index.

setVertexTexturesWithRange

void setVertexTexturesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures,
                                NSRange range)

setVertexTextures:withRange:

Set an array of global textures for all vertex shaders with the given bind point range.

setViewport

void setViewport(MTLViewport viewport)

setViewport:

Set the viewport, which is used to transform vertexes from normalized device coordinates to window coordinates. Fragments that lie outside of the viewport are clipped, and optionally clamped for fragments outside of znear/zfar.

setVisibilityResultModeOffset

void setVisibilityResultModeOffset(long mode,
                                   long offset)

setVisibilityResultMode:offset:

Monitor if samples pass the depth and stencil tests.

Parameters:

mode - Controls if the counter is disabled or moniters passing samples.

offset - The offset relative to the occlusion query buffer provided when the command encoder was created. offset must be a multiple of 8.

updateFenceAfterStages

void updateFenceAfterStages(MTLFence fence,
                            long stages)

updateFence:afterStages:

Update the fence to capture all GPU work so far enqueued by this encoder for the given stages.

Unlike updateFence:, this method will update the fence when the given stage(s) complete, allowing for commands to overlap in execution. On iOS, render command encoder fence updates are always delayed until the end of the encoder.

waitForFenceBeforeStages

void waitForFenceBeforeStages(MTLFence fence,
                              long stages)

waitForFence:beforeStages:

Prevent further GPU work until the fence is reached for the given stages.

Unlike waitForFence:, this method will only block commands assoicated with the given stage(s), allowing for commands to overlap in execution. On iOS, render command encoder fence waits always occur the beginning of the encoder.

dispatchThreadsPerTile

void dispatchThreadsPerTile(MTLSize threadsPerTile)

dispatchThreadsPerTile:

dispatch threads to perform a mid-render compute operation.

setColorStoreActionOptionsAtIndex

void setColorStoreActionOptionsAtIndex(long storeActionOptions,
                                       long colorAttachmentIndex)

setColorStoreActionOptions:atIndex:

If the the store action for a given color attachment was set to MTLStoreActionUnknown when the render command encoder was created, setColorStoreActionOptions:atIndex: may be used to finalize the store action options before endEncoding is called.

Parameters:

storeActionOptions - The desired store action options for the given color attachment.

colorAttachmentIndex - The index of the color attachment

setDepthClipMode

void setDepthClipMode(long depthClipMode)

setDepthClipMode:

Controls what is done with fragments outside of the near or far planes.

setDepthStoreActionOptions

void setDepthStoreActionOptions(long storeActionOptions)

setDepthStoreActionOptions:

If the the store action for the depth attachment was set to MTLStoreActionUnknown when the render command encoder was created, setDepthStoreActionOptions: may be used to finalize the store action options before endEncoding is called.

setStencilStoreActionOptions

void setStencilStoreActionOptions(long storeActionOptions)

setStencilStoreActionOptions:

If the the store action for the stencil attachment was set to MTLStoreActionUnknown when the render command encoder was created, setStencilStoreActionOptions: may be used to finalize the store action options before endEncoding is called.

setThreadgroupMemoryLengthOffsetAtIndex

void setThreadgroupMemoryLengthOffsetAtIndex(long length,
                                             long offset,
                                             long index)

setThreadgroupMemoryLength:offset:atIndex:

Set the size of the threadgroup memory argument at the given bind point index and offset.

setTileBufferOffsetAtIndex

void setTileBufferOffsetAtIndex(MTLBuffer buffer,
                                long offset,
                                long index)

setTileBuffer:offset:atIndex:

Set a global buffer for all tile shaders at the given bind point index.

setTileBufferOffsetAtIndex

void setTileBufferOffsetAtIndex(long offset,
                                long index)

setTileBufferOffset:atIndex:

Set the offset within the current global buffer for all tile shaders at the given bind point index.

setTileBuffersOffsetsWithRange

void setTileBuffersOffsetsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers,
                                    org.moe.natj.general.ptr.ConstNUIntPtr offsets,
                                    NSRange range)

setTileBuffers:offsets:withRange:

Set an array of global buffers for all tile shaders with the given bind point range.

setTileBytesLengthAtIndex

void setTileBytesLengthAtIndex(org.moe.natj.general.ptr.ConstVoidPtr bytes,
                               long length,
                               long index)

setTileBytes:length:atIndex:

Set the data (by copy) for a given tile buffer binding point. This will remove any existing MTLBuffer from the binding point.

setTileSamplerStateAtIndex

void setTileSamplerStateAtIndex(MTLSamplerState sampler,
                                long index)

setTileSamplerState:atIndex:

Set a global sampler for all tile shaders at the given bind point index.

setTileSamplerStateLodMinClampLodMaxClampAtIndex

void setTileSamplerStateLodMinClampLodMaxClampAtIndex(MTLSamplerState sampler,
                                                      float lodMinClamp,
                                                      float lodMaxClamp,
                                                      long index)

setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:

Set a global sampler for all tile shaders at the given bind point index.

setTileSamplerStatesLodMinClampsLodMaxClampsWithRange

void setTileSamplerStatesLodMinClampsLodMaxClampsWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                                           org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps,
                                                           org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps,
                                                           NSRange range)

setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:

Set an array of global samplers for all tile shaders with the given bind point range.

setTileSamplerStatesWithRange

void setTileSamplerStatesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                   NSRange range)

setTileSamplerStates:withRange:

Set an array of global samplers for all fragment shaders with the given bind point range.

setTileTextureAtIndex

void setTileTextureAtIndex(MTLTexture texture,
                           long index)

setTileTexture:atIndex:

Set a global texture for all tile shaders at the given bind point index.

setTileTexturesWithRange

void setTileTexturesWithRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures,
                              NSRange range)

setTileTextures:withRange:

Set an array of global textures for all tile shaders with the given bind point range.

tileHeight

long tileHeight()

[@property] tileHeight:

The height of the tile for this render pass.

tileWidth

long tileWidth()

[@property] tileWidth:

The width of the tile for this render pass.

useHeap

void useHeap(MTLHeap heap)

useHeap:

Declare that the resources allocated from a heap may be accessed by the render pass through an argument buffer

This method does not protect against data hazards; these hazards must be addressed using an MTLFence. This method must be called before encoding any draw commands which may access the resources allocated from the heap through an argument buffer. This method may cause all of the color attachments allocated from the heap to become decompressed. Therefore, it is recommended that the useResource:usage: or useResources:count:usage: methods be used for color attachments instead, with a minimal (i.e. read-only) usage.

useHeapsCount

void useHeapsCount(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> heaps,
                   long count)

useHeaps:count:

Declare that the resources allocated from an array of heaps may be accessed by the render pass through an argument buffer

This method does not protect against data hazards; these hazards must be addressed using an MTLFence. This method must be called before encoding any draw commands which may access the resources allocated from the heaps through an argument buffer. This method may cause all of the color attachments allocated from the heaps to become decompressed. Therefore, it is recommended that the useResource:usage: or useResources:count:usage: methods be used for color attachments instead, with a minimal (i.e. read-only) usage.

useResourceUsage

void useResourceUsage(MTLResource resource,
                      long usage)

* @method useResource:usage: * @abstract Declare that a resource may be accessed by the render pass through an argument buffer * @discussion This method does not protect against data hazards; these hazards must be addressed using an MTLFence. This method must be called before encoding any draw commands which may access the resource through an argument buffer. However, this method may cause color attachments to become decompressed. Therefore, this method should be called until as late as possible within a render command encoder. Declaring a minimal usage (i.e. read-only) may prevent color attachments from becoming decompressed on some devices.

Note that calling useResource does not retain the resource. It is the responsiblity of the user to retain the resource until the command buffer has been executed.

useResourcesCountUsage

void useResourcesCountUsage(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources,
                            long count,
                            long usage)

* @method useResources:count:usage: * @abstract Declare that an array of resources may be accessed through an argument buffer by the render pass * @discussion This method does not protect against data hazards; these hazards must be addressed using an MTLFence. This method must be called before encoding any draw commands which may access the resources through an argument buffer. However, this method may cause color attachments to become decompressed. Therefore, this method should be called until as late as possible within a render command encoder. Declaring a minimal usage (i.e. read-only) may prevent color attachments from becoming decompressed on some devices.

Note that calling useResources does not retain the resources. It is the responsiblity of the user to retain the resources until the command buffer has been executed.

drawIndexedPatchesPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetIndirectBufferIndirectBufferOffset

void drawIndexedPatchesPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetIndirectBufferIndirectBufferOffset(long numberOfPatchControlPoints,
                                                                                                                                                    MTLBuffer patchIndexBuffer,
                                                                                                                                                    long patchIndexBufferOffset,
                                                                                                                                                    MTLBuffer controlPointIndexBuffer,
                                                                                                                                                    long controlPointIndexBufferOffset,
                                                                                                                                                    MTLBuffer indirectBuffer,
                                                                                                                                                    long indirectBufferOffset)

drawPatchesPatchIndexBufferPatchIndexBufferOffsetIndirectBufferIndirectBufferOffset

void drawPatchesPatchIndexBufferPatchIndexBufferOffsetIndirectBufferIndirectBufferOffset(long numberOfPatchControlPoints,
                                                                                         MTLBuffer patchIndexBuffer,
                                                                                         long patchIndexBufferOffset,
                                                                                         MTLBuffer indirectBuffer,
                                                                                         long indirectBufferOffset)

executeCommandsInBufferIndirectBufferIndirectBufferOffset

void executeCommandsInBufferIndirectBufferIndirectBufferOffset(MTLIndirectCommandBuffer indirectCommandbuffer,
                                                               MTLBuffer indirectRangeBuffer,
                                                               long indirectBufferOffset)

executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:

Execute commands in the buffer within the range specified by the indirect range buffer.

The same indirect command buffer may be executed any number of times within the same encoder.

Parameters:

indirectRangeBuffer - An indirect buffer from which the device reads the execution range parameter, as laid out in the MTLIndirectCommandBufferExecutionRange structure.

indirectBufferOffset - The byte offset within indirectBuffer where the execution range parameter is located. Must be a multiple of 4 bytes.

executeCommandsInBufferWithRange

void executeCommandsInBufferWithRange(MTLIndirectCommandBuffer indirectCommandBuffer,
                                      NSRange executionRange)

executeCommandsInBuffer:withRange:

Execute commands in the buffer within the range specified.

The same indirect command buffer may be executed any number of times within the same encoder.

setScissorRectsCount

void setScissorRectsCount(MTLScissorRect scissorRects,
                          long count)

setScissorRects:

Specifies an array of rectangles for a fragment scissor test. The specific rectangle used is based on the [[ viewport_array_index ]] value output by the vertex shader. Fragments that lie outside the scissor rectangle are discarded.

setVertexAmplificationCountViewMappings

void setVertexAmplificationCountViewMappings(long count,
                                             MTLVertexAmplificationViewMapping viewMappings)

setVertexAmplificationCount:

Specifies the vertex amplification count and associated view mappings for each amplification ID.

Each mapping element describes how to route the corresponding amplification ID to a specific viewport and render target array index by using offsets from the base array index provided by the [[render_target_array_index]] and/or [[viewport_array_index]] output attributes in the vertex shader. This allows a modicum of programmability for each amplified vertex to be routed to a different [[render_target_array_index]] and [[viewport_array_index]] even though these attribytes cannot be amplified themselves.

Parameters:

count - the amplification count. The maximum value is currently 2.

viewMappings - an array of mapping elements.

setViewportsCount

void setViewportsCount(MTLViewport viewports,
                       long count)

setViewports:

Specifies an array of viewports, which are used to transform vertices from normalized device coordinates to window coordinates based on [[ viewport_array_index ]] value specified in the vertex shader.

useHeapStages

void useHeapStages(MTLHeap heap,
                   long stages)

useHeap:stages

Declare that the resources allocated from a heap may be accessed by the render pass through an argument buffer

If the heap is tracked, this method protects against hazard tracking; these hazards must be addressed using an MTLFence. This method must be called before encoding any draw commands which may access the resources allocated from the heap through an argument buffer. This method may cause all of the color attachments allocated from the heap to become decompressed. Therefore, it is recommended that the useResource:usage: or useResources:count:usage: methods be used for color attachments instead, with a minimal (i.e. read-only) usage.

useHeapsCountStages

void useHeapsCountStages(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> heaps,
                         long count,
                         long stages)

useHeaps:count:stages

Declare that the resources allocated from an array of heaps may be accessed by the render pass through an argument buffer

This method does not protect against data hazards; these hazards must be addressed using an MTLFence. This method must be called before encoding any draw commands which may access the resources allocated from the heaps through an argument buffer. This method may cause all of the color attachments allocated from the heaps to become decompressed. Therefore, it is recommended that the useResource:usage: or useResources:count:usage: methods be used for color attachments instead, with a minimal (i.e. read-only) usage.

useResourceUsageStages

void useResourceUsageStages(MTLResource resource,
                            long usage,
                            long stages)

* @method useResources:usage:stage * @abstract Declare that a resource may be accessed by the render pass through an argument buffer * @For hazard tracked resources, this method protects against data hazards. This method must be called before encoding any draw commands which may access the resource through an argument buffer. However, this method may cause color attachments to become decompressed. Therefore, this method should be called until as late as possible within a render command encoder. Declaring a minimal usage (i.e. read-only) may prevent color attachments from becoming decompressed on some devices.

Note that calling useResource does not retain the resource. It is the responsiblity of the user to retain the resource until the command buffer has been executed.

useResourcesCountUsageStages

void useResourcesCountUsageStages(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources,
                                  long count,
                                  long usage,
                                  long stages)

* @method useResources:count:usage:stages * @abstract Declare that an array of resources may be accessed through an argument buffer by the render pass * @discussion For hazard tracked resources, this method protects against data hazards. This method must be called before encoding any draw commands which may access the resources through an argument buffer. However, this method may cause color attachments to become decompressed. Therefore, this method should be called until as late as possible within a render command encoder. Declaring a minimal usage (i.e. read-only) may prevent color attachments from becoming decompressed on some devices.

Note that calling useResources does not retain the resources. It is the responsiblity of the user to retain the resources until the command buffer has been executed.

sampleCountersInBufferAtSampleIndexWithBarrier

void sampleCountersInBufferAtSampleIndexWithBarrier(MTLCounterSampleBuffer sampleBuffer,
                                                    long sampleIndex,
                                                    boolean barrier)

sampleCountersInBuffer:atSampleIndex:withBarrier:

Sample hardware counters at this point in the render encoder and store the counter sample into the sample buffer at the specified index.

Parameters:

sampleBuffer - The sample buffer to sample into

sampleIndex - The index into the counter buffer to write the sample.

barrier - Insert a barrier before taking the sample. Passing YES will ensure that all work encoded before this operation in the encoder is complete but does not isolate the work with respect to other encoders. Passing NO will allow the sample to be taken concurrently with other operations in this encoder. In general, passing YES will lead to more repeatable counter results but may negatively impact performance. Passing NO will generally be higher performance but counter results may not be repeatable.

setFragmentAccelerationStructureAtBufferIndex

void setFragmentAccelerationStructureAtBufferIndex(MTLAccelerationStructure accelerationStructure,
                                                   long bufferIndex)

setFragmentAccelerationStructure:atBufferIndex:

Set a global acceleration structure for all fragment shaders at the given buffer bind point index.

setFragmentIntersectionFunctionTableAtBufferIndex

void setFragmentIntersectionFunctionTableAtBufferIndex(MTLIntersectionFunctionTable intersectionFunctionTable,
                                                       long bufferIndex)

setFragmentIntersectionFunctionTable:atBufferIndex:

Set a global intersection function table for all fragment shaders at the given buffer bind point index.

setFragmentIntersectionFunctionTablesWithBufferRange

void setFragmentIntersectionFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTable,
                                                          NSRange range)

setFragmentIntersectionFunctionTables:withBufferRange:

Set an array of global intersection function tables for all fragment shaders with the given buffer bind point range.

setFragmentVisibleFunctionTableAtBufferIndex

void setFragmentVisibleFunctionTableAtBufferIndex(MTLVisibleFunctionTable functionTable,
                                                  long bufferIndex)

setFragmentVisibleFunctionTable:atBufferIndex:

Set a global visible function table for all fragment shaders at the given buffer bind point index.

setFragmentVisibleFunctionTablesWithBufferRange

void setFragmentVisibleFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> functionTables,
                                                     NSRange range)

setFragmentVisibleFunctionTables:withBufferRange:

Set an array of global visible function tables for all fragment shaders with the given buffer bind point range.

setTileAccelerationStructureAtBufferIndex

void setTileAccelerationStructureAtBufferIndex(MTLAccelerationStructure accelerationStructure,
                                               long bufferIndex)

setTileAccelerationStructure:atBufferIndex:

Set a global acceleration structure for all tile shaders at the given buffer bind point index.

setTileIntersectionFunctionTableAtBufferIndex

void setTileIntersectionFunctionTableAtBufferIndex(MTLIntersectionFunctionTable intersectionFunctionTable,
                                                   long bufferIndex)

setTileIntersectionFunctionTable:atBufferIndex:

Set a global intersection function table for all tile shaders at the given buffer bind point index.

setTileIntersectionFunctionTablesWithBufferRange

void setTileIntersectionFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTable,
                                                      NSRange range)

setTileIntersectionFunctionTables:withBufferRange:

Set an array of global intersection function tables for all tile shaders with the given buffer bind point range.

setTileVisibleFunctionTableAtBufferIndex

void setTileVisibleFunctionTableAtBufferIndex(MTLVisibleFunctionTable functionTable,
                                              long bufferIndex)

setTileVisibleFunctionTable:atBufferIndex:

Set a global visible function table for all tile shaders at the given buffer bind point index.

setTileVisibleFunctionTablesWithBufferRange

void setTileVisibleFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> functionTables,
                                                 NSRange range)

setTileVisibleFunctionTables:withBufferRange:

Set an array of global visible function tables for all tile shaders with the given buffer bind point range.

setVertexAccelerationStructureAtBufferIndex

void setVertexAccelerationStructureAtBufferIndex(MTLAccelerationStructure accelerationStructure,
                                                 long bufferIndex)

setVertexAccelerationStructure:atBufferIndex:

Set a global acceleration structure for all vertex shaders at the given buffer bind point index.

setVertexIntersectionFunctionTableAtBufferIndex

void setVertexIntersectionFunctionTableAtBufferIndex(MTLIntersectionFunctionTable intersectionFunctionTable,
                                                     long bufferIndex)

setVertexIntersectionFunctionTable:atBufferIndex:

Set a global intersection function table for all vertex shaders at the given buffer bind point index.

setVertexIntersectionFunctionTablesWithBufferRange

void setVertexIntersectionFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTable,
                                                        NSRange range)

setVertexIntersectionFunctionTables:withBufferRange:

Set an array of global intersection function tables for all vertex shaders with the given buffer bind point range.

setVertexVisibleFunctionTableAtBufferIndex

void setVertexVisibleFunctionTableAtBufferIndex(MTLVisibleFunctionTable functionTable,
                                                long bufferIndex)

setVertexVisibleFunctionTable:atBufferIndex:

Set a global visible function table for all vertex shaders at the given buffer bind point index.

setVertexVisibleFunctionTablesWithBufferRange

void setVertexVisibleFunctionTablesWithBufferRange(org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> functionTables,
                                                   NSRange range)

setVertexVisibleFunctionTables:withBufferRange:

Set an array of global visible function tables for all vertex shaders with the given buffer bind point range.