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. API-Since: 8.0

Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
Modifier and Type	Method	Description
`void`	`dispatchThreadsPerTile(MTLSize threadsPerTile)`	dispatchThreadsPerTile: dispatch threads to perform a mid-render compute operation.
`void`	`drawIndexedPatchesPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetIndirectBufferIndirectBufferOffset(long numberOfPatchControlPoints, @Nullable MTLBuffer patchIndexBuffer, long patchIndexBufferOffset, @NotNull MTLBuffer controlPointIndexBuffer, long controlPointIndexBufferOffset, @NotNull MTLBuffer indirectBuffer, long indirectBufferOffset)`	API-Since: 12.0
`void`	`drawIndexedPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetInstanceCountBaseInstance(long numberOfPatchControlPoints, long patchStart, long patchCount, @Nullable MTLBuffer patchIndexBuffer, long patchIndexBufferOffset, @NotNull MTLBuffer controlPointIndexBuffer, long controlPointIndexBufferOffset, long instanceCount, long baseInstance)`	API-Since: 10.0
`void`	`drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffset(long primitiveType, long indexCount, long indexType, @NotNull MTLBuffer indexBuffer, long indexBufferOffset)`	drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset: Draw primitives with an index list.
`void`	`drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCount(long primitiveType, long indexCount, long indexType, @NotNull MTLBuffer indexBuffer, long indexBufferOffset, long instanceCount)`	drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount: Draw primitives with an index list.
`void`	`drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCountBaseVertexBaseInstance(long primitiveType, long indexCount, long indexType, @NotNull MTLBuffer indexBuffer, long indexBufferOffset, long instanceCount, long baseVertex, long baseInstance)`	drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance: Draw primitives with an index list.
`void`	`drawIndexedPrimitivesIndexTypeIndexBufferIndexBufferOffsetIndirectBufferIndirectBufferOffset(long primitiveType, long indexType, @NotNull MTLBuffer indexBuffer, long indexBufferOffset, @NotNull MTLBuffer indirectBuffer, long indirectBufferOffset)`	drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset: Draw primitives with an index list using an indirect buffer see MTLDrawIndexedPrimitivesIndirectArguments.
`void`	`drawMeshThreadgroupsThreadsPerObjectThreadgroupThreadsPerMeshThreadgroup(MTLSize threadgroupsPerGrid, MTLSize threadsPerObjectThreadgroup, MTLSize threadsPerMeshThreadgroup)`	drawMeshThreadgroups:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup: Enqueue a grid of object (if present) or mesh shader threadgroups.
`void`	`drawMeshThreadgroupsWithIndirectBufferIndirectBufferOffsetThreadsPerObjectThreadgroupThreadsPerMeshThreadgroup(@NotNull MTLBuffer indirectBuffer, long indirectBufferOffset, MTLSize threadsPerObjectThreadgroup, MTLSize threadsPerMeshThreadgroup)`	drawMeshThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup: Enqueue a grid of object (if present) or mesh shader threadgroups.
`void`	`drawMeshThreadsThreadsPerObjectThreadgroupThreadsPerMeshThreadgroup(MTLSize threadsPerGrid, MTLSize threadsPerObjectThreadgroup, MTLSize threadsPerMeshThreadgroup)`	drawMeshThreads:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup: Enqueue a grid of object (if present) of mesh shader threadgroups.
`void`	`drawPatchesPatchIndexBufferPatchIndexBufferOffsetIndirectBufferIndirectBufferOffset(long numberOfPatchControlPoints, @Nullable MTLBuffer patchIndexBuffer, long patchIndexBufferOffset, @NotNull MTLBuffer indirectBuffer, long indirectBufferOffset)`	API-Since: 12.0
`void`	`drawPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetInstanceCountBaseInstance(long numberOfPatchControlPoints, long patchStart, long patchCount, @Nullable MTLBuffer patchIndexBuffer, long patchIndexBufferOffset, long instanceCount, long baseInstance)`	API-Since: 10.0
`void`	`drawPrimitivesIndirectBufferIndirectBufferOffset(long primitiveType, @NotNull MTLBuffer indirectBuffer, long indirectBufferOffset)`	drawPrimitives:indirectBuffer:indirectBufferOffset: Draw primitives without an index list using an indirect buffer see MTLDrawPrimitivesIndirectArguments.
`void`	`drawPrimitivesVertexStartVertexCount(long primitiveType, long vertexStart, long vertexCount)`	drawPrimitives:vertexStart:vertexCount: Draw primitives without an index list.
`void`	`drawPrimitivesVertexStartVertexCountInstanceCount(long primitiveType, long vertexStart, long vertexCount, long instanceCount)`	drawPrimitives:vertexStart:vertexCount:instanceCount: Draw primitives without an index list.
`void`	`drawPrimitivesVertexStartVertexCountInstanceCountBaseInstance(long primitiveType, long vertexStart, long vertexCount, long instanceCount, long baseInstance)`	drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance: Draw primitives without an index list.
`void`	`executeCommandsInBufferIndirectBufferIndirectBufferOffset(@NotNull MTLIndirectCommandBuffer indirectCommandbuffer, @NotNull MTLBuffer indirectRangeBuffer, long indirectBufferOffset)`	executeCommandsInBuffer:indirectBuffer:indirectBufferOffset: Execute commands in the buffer within the range specified by the indirect range buffer.
`void`	`executeCommandsInBufferWithRange(@NotNull MTLIndirectCommandBuffer indirectCommandBuffer, NSRange executionRange)`	executeCommandsInBuffer:withRange: Execute commands in the buffer within the range specified.
`void`	`memoryBarrierWithResourcesCountAfterStagesBeforeStages(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources, long count, long after, long before)`	memoryBarrierWithResources:count:afterStages:beforeStages: Make stores to memory encoded before the barrier coherent with loads from memory encoded after the barrier.
`void`	`memoryBarrierWithScopeAfterStagesBeforeStages(long scope, long after, long before)`	memoryBarrierWithScope:afterStages:beforeStages: Make stores to memory encoded before the barrier coherent with loads from memory encoded after the barrier.
`void`	`sampleCountersInBufferAtSampleIndexWithBarrier(@NotNull 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.
`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
`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.
`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.
`void`	`setCullMode(long cullMode)`	setCullMode: Controls if primitives are culled when front facing, back facing, or not culled at all.
`void`	`setDepthBiasSlopeScaleClamp(float depthBias, float slopeScale, float clamp)`	setDepthBias:slopeScale:clamp: Depth Bias.
`void`	`setDepthClipMode(long depthClipMode)`	setDepthClipMode: Controls what is done with fragments outside of the near or far planes.
`void`	`setDepthStencilState(@Nullable MTLDepthStencilState depthStencilState)`	setDepthStencilState: Set the DepthStencil state object.
`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.
`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.
`void`	`setFragmentAccelerationStructureAtBufferIndex(@Nullable MTLAccelerationStructure accelerationStructure, long bufferIndex)`	setFragmentAccelerationStructure:atBufferIndex: Set a global acceleration structure for all fragment shaders at the given buffer bind point index.
`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.
`void`	`setFragmentBufferOffsetAtIndex(@Nullable MTLBuffer buffer, long offset, long index)`	setFragmentBuffer:offset:atIndex: Set a global buffer for all fragment shaders at the given bind point index.
`void`	`setFragmentBuffersOffsetsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, @NotNull 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.
`void`	`setFragmentBytesLengthAtIndex(@NotNull 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.
`void`	`setFragmentIntersectionFunctionTableAtBufferIndex(@Nullable MTLIntersectionFunctionTable intersectionFunctionTable, long bufferIndex)`	setFragmentIntersectionFunctionTable:atBufferIndex: Set a global intersection function table for all fragment shaders at the given buffer bind point index.
`void`	`setFragmentIntersectionFunctionTablesWithBufferRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTables, NSRange range)`	setFragmentIntersectionFunctionTables:withBufferRange: Set an array of global intersection function tables for all fragment shaders with the given buffer bind point range.
`void`	`setFragmentSamplerStateAtIndex(@Nullable MTLSamplerState sampler, long index)`	setFragmentSamplerState:atIndex: Set a global sampler for all fragment shaders at the given bind point index.
`void`	`setFragmentSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable 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.
`void`	`setFragmentSamplerStatesLodMinClampsLodMaxClampsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps, @NotNull 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.
`void`	`setFragmentSamplerStatesWithRange(@NotNull 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.
`void`	`setFragmentTextureAtIndex(@Nullable MTLTexture texture, long index)`	setFragmentTexture:atIndex: Set a global texture for all fragment shaders at the given bind point index.
`void`	`setFragmentTexturesWithRange(@NotNull 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.
`void`	`setFragmentVisibleFunctionTableAtBufferIndex(@Nullable MTLVisibleFunctionTable functionTable, long bufferIndex)`	setFragmentVisibleFunctionTable:atBufferIndex: Set a global visible function table for all fragment shaders at the given buffer bind point index.
`void`	`setFragmentVisibleFunctionTablesWithBufferRange(@NotNull 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.
`void`	`setFrontFacingWinding(long frontFacingWinding)`	setFrontFacingWinding: The winding order of front-facing primitives.
`void`	`setMeshBufferOffsetAtIndex(long offset, long index)`	setMeshBufferOffset:atIndex: Set the offset within the current global buffer for all mesh shaders at the given bind point index.
`void`	`setMeshBufferOffsetAtIndex(@Nullable MTLBuffer buffer, long offset, long index)`	setMeshBuffer:offset:atIndex: Set a global buffer for all mesh shaders at the given bind point index.
`void`	`setMeshBuffersOffsetsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, @NotNull org.moe.natj.general.ptr.ConstNUIntPtr offsets, NSRange range)`	setMeshBuffers:offsets:withRange: Set an array of global buffers for all mesh shaders with the given bind point range.
`void`	`setMeshBytesLengthAtIndex(@NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes, long length, long index)`	setMeshBytes:length:atIndex: Set the data (by copy) for a given mesh shader buffer binding point.
`void`	`setMeshSamplerStateAtIndex(@Nullable MTLSamplerState sampler, long index)`	setMeshSamplerState:atIndex: Set a global sampler for all mesh shaders at the given bind point index.
`void`	`setMeshSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable MTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, long index)`	setMeshSamplerState:lodMinClamp:lodMaxClamp:atIndex: Set a global sampler for all mesh shaders at the given bind point index.
`void`	`setMeshSamplerStatesLodMinClampsLodMaxClampsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps, @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps, NSRange range)`	setMeshSamplerStates:lodMinClamps:lodMaxClamps:withRange: Set an array of global samplers for all mesh shaders with the given bind point range.
`void`	`setMeshSamplerStatesWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, NSRange range)`	setMeshSamplerStates:withRange: Set an array of global samplers for all mesh shaders with the given bind point range.
`void`	`setMeshTextureAtIndex(@Nullable MTLTexture texture, long index)`	setMeshTexture:atIndex: Set a global texture for all mesh shaders at the given bind point index.
`void`	`setMeshTexturesWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures, NSRange range)`	setMeshTextures:withRange: Set an array of global textures for all mesh shaders with the given bind point range.
`void`	`setObjectBufferOffsetAtIndex(long offset, long index)`	setObjectBufferOffset:atIndex: Set the offset within the current global buffer for all object shaders at the given bind point index.
`void`	`setObjectBufferOffsetAtIndex(@Nullable MTLBuffer buffer, long offset, long index)`	setObjectBuffer:offset:atIndex: Set a global buffer for all object shaders at the given bind point index.
`void`	`setObjectBuffersOffsetsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, @NotNull org.moe.natj.general.ptr.ConstNUIntPtr offsets, NSRange range)`	setObjectBuffers:offsets:withRange: Set an array of global buffers for all object shaders with the given bind point range.
`void`	`setObjectBytesLengthAtIndex(@NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes, long length, long index)`	setObjectBytes:length:atIndex: Set the data (by copy) for a given object shader buffer binding point.
`void`	`setObjectSamplerStateAtIndex(@Nullable MTLSamplerState sampler, long index)`	setObjectSamplerState:atIndex: Set a global sampler for all object shaders at the given bind point index.
`void`	`setObjectSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable MTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, long index)`	setObjectSamplerState:lodMinClamp:lodMaxClamp:atIndex: Set a global sampler for all object shaders at the given bind point index.
`void`	`setObjectSamplerStatesLodMinClampsLodMaxClampsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps, @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps, NSRange range)`	setObjectSamplerStates:lodMinClamps:lodMaxClamps:withRange: Set an array of global samplers for all object shaders with the given bind point range.
`void`	`setObjectSamplerStatesWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, NSRange range)`	setObjectSamplerStates:withRange: Set an array of global samplers for all object shaders with the given bind point range.
`void`	`setObjectTextureAtIndex(@Nullable MTLTexture texture, long index)`	setObjectTexture:atIndex: Set a global texture for all object shaders at the given bind point index.
`void`	`setObjectTexturesWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures, NSRange range)`	setObjectTextures:withRange: Set an array of global textures for all object shaders with the given bind point range.
`void`	`setObjectThreadgroupMemoryLengthAtIndex(long length, long index)`	setObjectThreadgroupMemoryLength:atIndex: Set the threadgroup memory byte length at the binding point specified by the index for all object shaders.
`void`	`setRenderPipelineState(@NotNull MTLRenderPipelineState pipelineState)`	setRenderPipelineState Sets the current render pipeline state object.
`void`	`setScissorRect(MTLScissorRect rect)`	setScissorRect: Specifies a rectangle for a fragment scissor test.
`void`	`setScissorRectsCount(@NotNull MTLScissorRect scissorRects, long count)`	setScissorRects: Specifies an array of rectangles for a fragment scissor test.
`void`	`setStencilFrontReferenceValueBackReferenceValue(int frontReferenceValue, int backReferenceValue)`	setStencilFrontReferenceValue:backReferenceValue: Set the stencil reference value for the back and front stencil buffers independently.
`void`	`setStencilReferenceValue(int referenceValue)`	setStencilReferenceValue: Set the stencil reference value for both the back and front stencil buffers.
`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.
`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.
`void`	`setTessellationFactorBufferOffsetInstanceStride(@Nullable MTLBuffer buffer, long offset, long instanceStride)`	API-Since: 10.0
`void`	`setTessellationFactorScale(float scale)`	API-Since: 10.0
`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.
`void`	`setTileAccelerationStructureAtBufferIndex(@Nullable MTLAccelerationStructure accelerationStructure, long bufferIndex)`	setTileAccelerationStructure:atBufferIndex: Set a global acceleration structure for all tile shaders at the given buffer bind point index.
`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.
`void`	`setTileBufferOffsetAtIndex(@Nullable MTLBuffer buffer, long offset, long index)`	setTileBuffer:offset:atIndex: Set a global buffer for all tile shaders at the given bind point index.
`void`	`setTileBuffersOffsetsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, @NotNull 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.
`void`	`setTileBytesLengthAtIndex(@NotNull 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.
`void`	`setTileIntersectionFunctionTableAtBufferIndex(@Nullable MTLIntersectionFunctionTable intersectionFunctionTable, long bufferIndex)`	setTileIntersectionFunctionTable:atBufferIndex: Set a global intersection function table for all tile shaders at the given buffer bind point index.
`void`	`setTileIntersectionFunctionTablesWithBufferRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTables, NSRange range)`	setTileIntersectionFunctionTables:withBufferRange: Set an array of global intersection function tables for all tile shaders with the given buffer bind point range.
`void`	`setTileSamplerStateAtIndex(@Nullable MTLSamplerState sampler, long index)`	setTileSamplerState:atIndex: Set a global sampler for all tile shaders at the given bind point index.
`void`	`setTileSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable 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.
`void`	`setTileSamplerStatesLodMinClampsLodMaxClampsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps, @NotNull 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.
`void`	`setTileSamplerStatesWithRange(@NotNull 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.
`void`	`setTileTextureAtIndex(@Nullable MTLTexture texture, long index)`	setTileTexture:atIndex: Set a global texture for all tile shaders at the given bind point index.
`void`	`setTileTexturesWithRange(@NotNull 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.
`void`	`setTileVisibleFunctionTableAtBufferIndex(@Nullable MTLVisibleFunctionTable functionTable, long bufferIndex)`	setTileVisibleFunctionTable:atBufferIndex: Set a global visible function table for all tile shaders at the given buffer bind point index.
`void`	`setTileVisibleFunctionTablesWithBufferRange(@NotNull 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.
`void`	`setTriangleFillMode(long fillMode)`	setTriangleFillMode: Set how to rasterize triangle and triangle strip primitives.
`void`	`setVertexAccelerationStructureAtBufferIndex(@Nullable MTLAccelerationStructure accelerationStructure, long bufferIndex)`	setVertexAccelerationStructure:atBufferIndex: Set a global acceleration structure for all vertex shaders at the given buffer bind point index.
`void`	`setVertexAmplificationCountViewMappings(long count, @Nullable MTLVertexAmplificationViewMapping viewMappings)`	setVertexAmplificationCount: Specifies the vertex amplification count and associated view mappings for each amplification ID.
`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.
`void`	`setVertexBufferOffsetAtIndex(@Nullable MTLBuffer buffer, long offset, long index)`	setVertexBuffer:offset:atIndex: Set a global buffer for all vertex shaders at the given bind point index.
`void`	`setVertexBufferOffsetAttributeStrideAtIndex(long offset, long stride, long index)`	only call this when the buffer-index is part of the vertexDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0
`void`	`setVertexBufferOffsetAttributeStrideAtIndex(@Nullable MTLBuffer buffer, long offset, long stride, long index)`	sets vertex buffer at specified index with provided offset and stride.
`void`	`setVertexBuffersOffsetsAttributeStridesWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, @NotNull org.moe.natj.general.ptr.ConstNUIntPtr offsets, @NotNull org.moe.natj.general.ptr.ConstNUIntPtr strides, NSRange range)`	sets an array of vertex buffers with provided offsets and strides with the given bind point range.
`void`	`setVertexBuffersOffsetsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, @NotNull 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.
`void`	`setVertexBytesLengthAtIndex(@NotNull 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.
`void`	`setVertexBytesLengthAttributeStrideAtIndex(@NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes, long length, long stride, long index)`	only call this when the buffer-index is part of the vertexDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0
`void`	`setVertexIntersectionFunctionTableAtBufferIndex(@Nullable MTLIntersectionFunctionTable intersectionFunctionTable, long bufferIndex)`	setVertexIntersectionFunctionTable:atBufferIndex: Set a global intersection function table for all vertex shaders at the given buffer bind point index.
`void`	`setVertexIntersectionFunctionTablesWithBufferRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTables, NSRange range)`	setVertexIntersectionFunctionTables:withBufferRange: Set an array of global intersection function tables for all vertex shaders with the given buffer bind point range.
`void`	`setVertexSamplerStateAtIndex(@Nullable MTLSamplerState sampler, long index)`	setVertexSamplerState:atIndex: Set a global sampler for all vertex shaders at the given bind point index.
`void`	`setVertexSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable 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.
`void`	`setVertexSamplerStatesLodMinClampsLodMaxClampsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps, @NotNull 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.
`void`	`setVertexSamplerStatesWithRange(@NotNull 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.
`void`	`setVertexTextureAtIndex(@Nullable MTLTexture texture, long index)`	setVertexTexture:atIndex: Set a global texture for all vertex shaders at the given bind point index.
`void`	`setVertexTexturesWithRange(@NotNull 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.
`void`	`setVertexVisibleFunctionTableAtBufferIndex(@Nullable MTLVisibleFunctionTable functionTable, long bufferIndex)`	setVertexVisibleFunctionTable:atBufferIndex: Set a global visible function table for all vertex shaders at the given buffer bind point index.
`void`	`setVertexVisibleFunctionTablesWithBufferRange(@NotNull 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.
`void`	`setViewport(MTLViewport viewport)`	setViewport: Set the viewport, which is used to transform vertexes from normalized device coordinates to window coordinates.
`void`	`setViewportsCount(@NotNull 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.
`void`	`setVisibilityResultModeOffset(long mode, long offset)`	setVisibilityResultMode:offset: Monitor if samples pass the depth and stencil tests.
`long`	`tileHeight()`	[@property] tileHeight: The height of the tile for this render pass.
`long`	`tileWidth()`	[@property] tileWidth: The width of the tile for this render pass.
`void`	`updateFenceAfterStages(@NotNull MTLFence fence, long stages)`	updateFence:afterStages: Update the fence to capture all GPU work so far enqueued by this encoder for the given stages.
`void`	`useHeap(@NotNull MTLHeap heap)`	Deprecated.
`void`	`useHeapsCount(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> heaps, long count)`	Deprecated.
`void`	`useHeapsCountStages(@NotNull 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.
`void`	`useHeapStages(@NotNull 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.
`void`	`useResourcesCountUsage(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources, long count, long usage)`	Deprecated.
`void`	`useResourcesCountUsageStages(@NotNull 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(@NotNull MTLResource resource, long usage)`	Deprecated.
`void`	`useResourceUsageStages(@NotNull 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 * @discussion For hazard tracked resources, this method protects against data hazards.
`void`	`waitForFenceBeforeStages(@NotNull MTLFence fence, long stages)`	waitForFence:beforeStages: Prevent further GPU work until the fence is reached for the given stages.

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,
                                                                                                                                                               @Nullable
                                                                                                                                                               @Nullable MTLBuffer patchIndexBuffer,
                                                                                                                                                               long patchIndexBufferOffset,
                                                                                                                                                               @NotNull
                                                                                                                                                               @NotNull MTLBuffer controlPointIndexBuffer,
                                                                                                                                                               long controlPointIndexBufferOffset,
                                                                                                                                                               long instanceCount,
                                                                                                                                                               long baseInstance)

API-Since: 10.0

drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffset
```
void drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffset(long primitiveType,
                                                                          long indexCount,
                                                                          long indexType,
                                                                          @NotNull
                                                                          @NotNull 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,
                                                                                       @NotNull
                                                                                       @NotNull 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,
                                                                                                             @NotNull
                                                                                                             @NotNull 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. API-Since: 9.0

drawIndexedPrimitivesIndexTypeIndexBufferIndexBufferOffsetIndirectBufferIndirectBufferOffset
```
void drawIndexedPrimitivesIndexTypeIndexBufferIndexBufferOffsetIndirectBufferIndirectBufferOffset(long primitiveType,
                                                                                                  long indexType,
                                                                                                  @NotNull
                                                                                                  @NotNull MTLBuffer indexBuffer,
                                                                                                  long indexBufferOffset,
                                                                                                  @NotNull
                                                                                                  @NotNull 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. API-Since: 9.0

drawPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetInstanceCountBaseInstance

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

API-Since: 10.0

drawPrimitivesIndirectBufferIndirectBufferOffset
```
void drawPrimitivesIndirectBufferIndirectBufferOffset(long primitiveType,
                                                      @NotNull
                                                      @NotNull 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. API-Since: 9.0

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. API-Since: 9.0

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 API-Since: 10.0

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(@Nullable
                          @Nullable 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. API-Since: 10.0

setFragmentBufferOffsetAtIndex

void setFragmentBufferOffsetAtIndex(@Nullable
                                    @Nullable 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. API-Since: 8.3

setFragmentBuffersOffsetsWithRange

void setFragmentBuffersOffsetsWithRange(@NotNull
                                        @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers,
                                        @NotNull
                                        @NotNull 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(@NotNull
                                   @NotNull 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. API-Since: 8.3

setFragmentSamplerStateAtIndex

void setFragmentSamplerStateAtIndex(@Nullable
                                    @Nullable MTLSamplerState sampler,
                                    long index)

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

setFragmentSamplerStateLodMinClampLodMaxClampAtIndex

void setFragmentSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable
                                                          @Nullable 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(@NotNull
                                                               @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                                               @NotNull
                                                               @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps,
                                                               @NotNull
                                                               @NotNull 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(@NotNull
                                       @NotNull 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(@Nullable
                               @Nullable MTLTexture texture,
                               long index)

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

setFragmentTexturesWithRange

void setFragmentTexturesWithRange(@NotNull
                                  @NotNull 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(@NotNull
                            @NotNull 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. API-Since: 9.0

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. API-Since: 10.0

setTessellationFactorBufferOffsetInstanceStride

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

API-Since: 10.0

setTessellationFactorScale

void setTessellationFactorScale(float scale)

API-Since: 10.0

setTriangleFillMode
```
void setTriangleFillMode(long fillMode)
```
setTriangleFillMode: Set how to rasterize triangle and triangle strip primitives.

setVertexBufferOffsetAtIndex

void setVertexBufferOffsetAtIndex(@Nullable
                                  @Nullable 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. API-Since: 8.3

setVertexBuffersOffsetsWithRange

void setVertexBuffersOffsetsWithRange(@NotNull
                                      @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers,
                                      @NotNull
                                      @NotNull 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(@NotNull
                                 @NotNull 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. API-Since: 8.3

setVertexSamplerStateAtIndex

void setVertexSamplerStateAtIndex(@Nullable
                                  @Nullable MTLSamplerState sampler,
                                  long index)

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

setVertexSamplerStateLodMinClampLodMaxClampAtIndex

void setVertexSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable
                                                        @Nullable 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(@NotNull
                                                             @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                                             @NotNull
                                                             @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps,
                                                             @NotNull
                                                             @NotNull 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(@NotNull
                                     @NotNull 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(@Nullable
                             @Nullable MTLTexture texture,
                             long index)

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

setVertexTexturesWithRange

void setVertexTexturesWithRange(@NotNull
                                @NotNull 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(@NotNull
                            @NotNull 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. API-Since: 10.0

waitForFenceBeforeStages
```
void waitForFenceBeforeStages(@NotNull
                              @NotNull 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. API-Since: 10.0

dispatchThreadsPerTile
```
void dispatchThreadsPerTile(MTLSize threadsPerTile)
```
dispatchThreadsPerTile: dispatch threads to perform a mid-render compute operation. API-Since: 11.0

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 API-Since: 11.0

setDepthClipMode
```
void setDepthClipMode(long depthClipMode)
```
setDepthClipMode: Controls what is done with fragments outside of the near or far planes. API-Since: 11.0

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. API-Since: 11.0

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. API-Since: 11.0

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. API-Since: 11.0

setTileBufferOffsetAtIndex

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

setTileBuffer:offset:atIndex: Set a global buffer for all tile shaders at the given bind point index. API-Since: 11.0

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. API-Since: 11.0

setTileBuffersOffsetsWithRange

void setTileBuffersOffsetsWithRange(@NotNull
                                    @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers,
                                    @NotNull
                                    @NotNull 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. API-Since: 11.0

setTileBytesLengthAtIndex

void setTileBytesLengthAtIndex(@NotNull
                               @NotNull 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. API-Since: 11.0

setTileSamplerStateAtIndex

void setTileSamplerStateAtIndex(@Nullable
                                @Nullable MTLSamplerState sampler,
                                long index)

setTileSamplerState:atIndex: Set a global sampler for all tile shaders at the given bind point index. API-Since: 11.0

setTileSamplerStateLodMinClampLodMaxClampAtIndex

void setTileSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable
                                                      @Nullable 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. API-Since: 11.0

setTileSamplerStatesLodMinClampsLodMaxClampsWithRange

void setTileSamplerStatesLodMinClampsLodMaxClampsWithRange(@NotNull
                                                           @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                                           @NotNull
                                                           @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps,
                                                           @NotNull
                                                           @NotNull 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. API-Since: 11.0

setTileSamplerStatesWithRange

void setTileSamplerStatesWithRange(@NotNull
                                   @NotNull 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. API-Since: 11.0

setTileTextureAtIndex

void setTileTextureAtIndex(@Nullable
                           @Nullable MTLTexture texture,
                           long index)

setTileTexture:atIndex: Set a global texture for all tile shaders at the given bind point index. API-Since: 11.0

setTileTexturesWithRange

void setTileTexturesWithRange(@NotNull
                              @NotNull 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. API-Since: 11.0

tileHeight
```
long tileHeight()
```
[@property] tileHeight: The height of the tile for this render pass. API-Since: 11.0

tileWidth
```
long tileWidth()
```
[@property] tileWidth: The width of the tile for this render pass. API-Since: 11.0

useHeap
```
@Deprecated
void useHeap(@NotNull
             @NotNull MTLHeap heap)
```
Deprecated.

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. API-Since: 11.0 Deprecated-Since: 16.0

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

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. API-Since: 11.0 Deprecated-Since: 16.0

useResourceUsage
```
@Deprecated
void useResourceUsage(@NotNull
                      @NotNull MTLResource resource,
                      long usage)
```
Deprecated.

* @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. API-Since: 11.0 Deprecated-Since: 16.0

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

* @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. API-Since: 11.0 Deprecated-Since: 16.0

drawIndexedPatchesPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetIndirectBufferIndirectBufferOffset

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

API-Since: 12.0

drawPatchesPatchIndexBufferPatchIndexBufferOffsetIndirectBufferIndirectBufferOffset

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

API-Since: 12.0

executeCommandsInBufferIndirectBufferIndirectBufferOffset
```
void executeCommandsInBufferIndirectBufferIndirectBufferOffset(@NotNull
                                                               @NotNull MTLIndirectCommandBuffer indirectCommandbuffer,
                                                               @NotNull
                                                               @NotNull 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. API-Since: 13.0

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(@NotNull
                                      @NotNull 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. API-Since: 12.0

setScissorRectsCount
```
void setScissorRectsCount(@NotNull
                          @NotNull 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. API-Since: 12.0

setVertexAmplificationCountViewMappings
```
void setVertexAmplificationCountViewMappings(long count,
                                             @Nullable
                                             @Nullable 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. API-Since: 13.0

Parameters:

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

viewMappings - an array of mapping elements.

setViewportsCount
```
void setViewportsCount(@NotNull
                       @NotNull 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. API-Since: 12.0

useHeapStages
```
void useHeapStages(@NotNull
                   @NotNull 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. API-Since: 13.0

useHeapsCountStages
```
void useHeapsCountStages(@NotNull
                         @NotNull 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. API-Since: 13.0

useResourceUsageStages
```
void useResourceUsageStages(@NotNull
                            @NotNull 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 * @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 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. API-Since: 13.0

useResourcesCountUsageStages
```
void useResourcesCountUsageStages(@NotNull
                                  @NotNull 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. API-Since: 13.0

sampleCountersInBufferAtSampleIndexWithBarrier
```
void sampleCountersInBufferAtSampleIndexWithBarrier(@NotNull
                                                    @NotNull 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. API-Since: 14.0

setFragmentAccelerationStructureAtBufferIndex

void setFragmentAccelerationStructureAtBufferIndex(@Nullable
                                                   @Nullable MTLAccelerationStructure accelerationStructure,
                                                   long bufferIndex)

setFragmentAccelerationStructure:atBufferIndex: Set a global acceleration structure for all fragment shaders at the given buffer bind point index. API-Since: 15.0

setFragmentIntersectionFunctionTableAtBufferIndex

void setFragmentIntersectionFunctionTableAtBufferIndex(@Nullable
                                                       @Nullable MTLIntersectionFunctionTable intersectionFunctionTable,
                                                       long bufferIndex)

setFragmentIntersectionFunctionTable:atBufferIndex: Set a global intersection function table for all fragment shaders at the given buffer bind point index. API-Since: 15.0

setFragmentIntersectionFunctionTablesWithBufferRange

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

setFragmentIntersectionFunctionTables:withBufferRange: Set an array of global intersection function tables for all fragment shaders with the given buffer bind point range. API-Since: 15.0

setFragmentVisibleFunctionTableAtBufferIndex

void setFragmentVisibleFunctionTableAtBufferIndex(@Nullable
                                                  @Nullable MTLVisibleFunctionTable functionTable,
                                                  long bufferIndex)

setFragmentVisibleFunctionTable:atBufferIndex: Set a global visible function table for all fragment shaders at the given buffer bind point index. API-Since: 15.0

setFragmentVisibleFunctionTablesWithBufferRange

void setFragmentVisibleFunctionTablesWithBufferRange(@NotNull
                                                     @NotNull 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. API-Since: 15.0

setTileAccelerationStructureAtBufferIndex

void setTileAccelerationStructureAtBufferIndex(@Nullable
                                               @Nullable MTLAccelerationStructure accelerationStructure,
                                               long bufferIndex)

setTileAccelerationStructure:atBufferIndex: Set a global acceleration structure for all tile shaders at the given buffer bind point index. API-Since: 15.0

setTileIntersectionFunctionTableAtBufferIndex

void setTileIntersectionFunctionTableAtBufferIndex(@Nullable
                                                   @Nullable MTLIntersectionFunctionTable intersectionFunctionTable,
                                                   long bufferIndex)

setTileIntersectionFunctionTable:atBufferIndex: Set a global intersection function table for all tile shaders at the given buffer bind point index. API-Since: 15.0

setTileIntersectionFunctionTablesWithBufferRange

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

setTileIntersectionFunctionTables:withBufferRange: Set an array of global intersection function tables for all tile shaders with the given buffer bind point range. API-Since: 15.0

setTileVisibleFunctionTableAtBufferIndex

void setTileVisibleFunctionTableAtBufferIndex(@Nullable
                                              @Nullable MTLVisibleFunctionTable functionTable,
                                              long bufferIndex)

setTileVisibleFunctionTable:atBufferIndex: Set a global visible function table for all tile shaders at the given buffer bind point index. API-Since: 15.0

setTileVisibleFunctionTablesWithBufferRange

void setTileVisibleFunctionTablesWithBufferRange(@NotNull
                                                 @NotNull 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. API-Since: 15.0

setVertexAccelerationStructureAtBufferIndex

void setVertexAccelerationStructureAtBufferIndex(@Nullable
                                                 @Nullable MTLAccelerationStructure accelerationStructure,
                                                 long bufferIndex)

setVertexAccelerationStructure:atBufferIndex: Set a global acceleration structure for all vertex shaders at the given buffer bind point index. API-Since: 15.0

setVertexIntersectionFunctionTableAtBufferIndex

void setVertexIntersectionFunctionTableAtBufferIndex(@Nullable
                                                     @Nullable MTLIntersectionFunctionTable intersectionFunctionTable,
                                                     long bufferIndex)

setVertexIntersectionFunctionTable:atBufferIndex: Set a global intersection function table for all vertex shaders at the given buffer bind point index. API-Since: 15.0

setVertexIntersectionFunctionTablesWithBufferRange

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

setVertexIntersectionFunctionTables:withBufferRange: Set an array of global intersection function tables for all vertex shaders with the given buffer bind point range. API-Since: 15.0

setVertexVisibleFunctionTableAtBufferIndex

void setVertexVisibleFunctionTableAtBufferIndex(@Nullable
                                                @Nullable MTLVisibleFunctionTable functionTable,
                                                long bufferIndex)

setVertexVisibleFunctionTable:atBufferIndex: Set a global visible function table for all vertex shaders at the given buffer bind point index. API-Since: 15.0

setVertexVisibleFunctionTablesWithBufferRange

void setVertexVisibleFunctionTablesWithBufferRange(@NotNull
                                                   @NotNull 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. API-Since: 15.0

drawMeshThreadgroupsThreadsPerObjectThreadgroupThreadsPerMeshThreadgroup
```
void drawMeshThreadgroupsThreadsPerObjectThreadgroupThreadsPerMeshThreadgroup(MTLSize threadgroupsPerGrid,
                                                                              MTLSize threadsPerObjectThreadgroup,
                                                                              MTLSize threadsPerMeshThreadgroup)
```
drawMeshThreadgroups:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup: Enqueue a grid of object (if present) or mesh shader threadgroups. The dimensions of the threadgroups and the grid are specified directly.

Parameters:

threadgroupsPerGrid - The number of threadgroups in the object (if present) or mesh shader grid.

threadsPerObjectThreadgroup - The number of threads in one object shader threadgroup. Ignored if object shader is not present.

threadsPerMeshThreadgroup - The number of threads in one mesh shader threadgroup. API-Since: 16.0

drawMeshThreadgroupsWithIndirectBufferIndirectBufferOffsetThreadsPerObjectThreadgroupThreadsPerMeshThreadgroup
```
void drawMeshThreadgroupsWithIndirectBufferIndirectBufferOffsetThreadsPerObjectThreadgroupThreadsPerMeshThreadgroup(@NotNull
                                                                                                                    @NotNull MTLBuffer indirectBuffer,
                                                                                                                    long indirectBufferOffset,
                                                                                                                    MTLSize threadsPerObjectThreadgroup,
                                                                                                                    MTLSize threadsPerMeshThreadgroup)
```
drawMeshThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup: Enqueue a grid of object (if present) or mesh shader threadgroups. The dimensions of the threadgroups are specified directly, the dimensions of the grid, in threadgroups, are read from a buffer by the GPU.

Parameters:

indirectBuffer - A buffer object that the device will read the grid size from, see MTLDispatchThreadgroupsIndirectArguments.

indirectBufferOffset - Byte offset within @a indirectBuffer to read arguments from. @a indirectBufferOffset must be a multiple of 4.

threadsPerObjectThreadgroup - The number of threads in one object shader threadgroup. Ignored if object shader is not present.

threadsPerMeshThreadgroup - The number of threads in one mesh shader threadgroup. API-Since: 16.0

drawMeshThreadsThreadsPerObjectThreadgroupThreadsPerMeshThreadgroup
```
void drawMeshThreadsThreadsPerObjectThreadgroupThreadsPerMeshThreadgroup(MTLSize threadsPerGrid,
                                                                         MTLSize threadsPerObjectThreadgroup,
                                                                         MTLSize threadsPerMeshThreadgroup)
```
drawMeshThreads:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup: Enqueue a grid of object (if present) of mesh shader threadgroups. The dimensions of the threadgroups and the grid are specified directly. The dimensions of threadsPerGrid does not have to be a multiple of threadsPerThreadgroup for object shaders. For mesh shaders, threadsPerGrid is rounded down to the neareset multiple of threadsPerMeshThreadgroup (in each dimension).

Parameters:

threadsPerGrid - The number of threads in the object (if present) or mesh shader grid

threadsPerObjectThreadgroup - The number of threads in one object shader threadgroup. Ignored if object shader is not present.

threadsPerMeshThreadgroup - The number of threads in one mesh shader threadgroup. API-Since: 16.0

memoryBarrierWithResourcesCountAfterStagesBeforeStages
```
void memoryBarrierWithResourcesCountAfterStagesBeforeStages(@NotNull
                                                            @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources,
                                                            long count,
                                                            long after,
                                                            long before)
```
memoryBarrierWithResources:count:afterStages:beforeStages: Make stores to memory encoded before the barrier coherent with loads from memory encoded after the barrier. The barrier makes stores coherent that 1) are to resources in given array, and 2) happen at (or before) the stage given by afterStages. Only affects loads that happen at (or after) the stage give by beforeStages. API-Since: 16.0

memoryBarrierWithScopeAfterStagesBeforeStages
```
void memoryBarrierWithScopeAfterStagesBeforeStages(long scope,
                                                   long after,
                                                   long before)
```
memoryBarrierWithScope:afterStages:beforeStages: Make stores to memory encoded before the barrier coherent with loads from memory encoded after the barrier. The barrier makes stores coherent that 1) are to a resource with a type in the given scope, and 2) happen at (or before) the stage given by afterStages. Only affects loads that happen at (or after) the stage given by beforeStages. API-Since: 16.0

setMeshBufferOffsetAtIndex

void setMeshBufferOffsetAtIndex(@Nullable
                                @Nullable MTLBuffer buffer,
                                long offset,
                                long index)

setMeshBuffer:offset:atIndex: Set a global buffer for all mesh shaders at the given bind point index. API-Since: 16.0

setMeshBufferOffsetAtIndex
```
void setMeshBufferOffsetAtIndex(long offset,
                                long index)
```
setMeshBufferOffset:atIndex: Set the offset within the current global buffer for all mesh shaders at the given bind point index. API-Since: 16.0

setMeshBuffersOffsetsWithRange

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

setMeshBuffers:offsets:withRange: Set an array of global buffers for all mesh shaders with the given bind point range. API-Since: 16.0

setMeshBytesLengthAtIndex

void setMeshBytesLengthAtIndex(@NotNull
                               @NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes,
                               long length,
                               long index)

setMeshBytes:length:atIndex: Set the data (by copy) for a given mesh shader buffer binding point. This will remove any existing MTLBuffer from the binding point. API-Since: 16.0

setMeshSamplerStateAtIndex

void setMeshSamplerStateAtIndex(@Nullable
                                @Nullable MTLSamplerState sampler,
                                long index)

setMeshSamplerState:atIndex: Set a global sampler for all mesh shaders at the given bind point index. API-Since: 16.0

setMeshSamplerStateLodMinClampLodMaxClampAtIndex

void setMeshSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable
                                                      @Nullable MTLSamplerState sampler,
                                                      float lodMinClamp,
                                                      float lodMaxClamp,
                                                      long index)

setMeshSamplerState:lodMinClamp:lodMaxClamp:atIndex: Set a global sampler for all mesh shaders at the given bind point index. API-Since: 16.0

setMeshSamplerStatesLodMinClampsLodMaxClampsWithRange

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

setMeshSamplerStates:lodMinClamps:lodMaxClamps:withRange: Set an array of global samplers for all mesh shaders with the given bind point range. API-Since: 16.0

setMeshSamplerStatesWithRange

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

setMeshSamplerStates:withRange: Set an array of global samplers for all mesh shaders with the given bind point range. API-Since: 16.0

setMeshTextureAtIndex

void setMeshTextureAtIndex(@Nullable
                           @Nullable MTLTexture texture,
                           long index)

setMeshTexture:atIndex: Set a global texture for all mesh shaders at the given bind point index. API-Since: 16.0

setMeshTexturesWithRange

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

setMeshTextures:withRange: Set an array of global textures for all mesh shaders with the given bind point range. API-Since: 16.0

setObjectBufferOffsetAtIndex

void setObjectBufferOffsetAtIndex(@Nullable
                                  @Nullable MTLBuffer buffer,
                                  long offset,
                                  long index)

setObjectBuffer:offset:atIndex: Set a global buffer for all object shaders at the given bind point index. API-Since: 16.0

setObjectBufferOffsetAtIndex
```
void setObjectBufferOffsetAtIndex(long offset,
                                  long index)
```
setObjectBufferOffset:atIndex: Set the offset within the current global buffer for all object shaders at the given bind point index. API-Since: 16.0

setObjectBuffersOffsetsWithRange

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

setObjectBuffers:offsets:withRange: Set an array of global buffers for all object shaders with the given bind point range. API-Since: 16.0

setObjectBytesLengthAtIndex

void setObjectBytesLengthAtIndex(@NotNull
                                 @NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes,
                                 long length,
                                 long index)

setObjectBytes:length:atIndex: Set the data (by copy) for a given object shader buffer binding point. This will remove any existing MTLBuffer from the binding point. API-Since: 16.0

setObjectSamplerStateAtIndex

void setObjectSamplerStateAtIndex(@Nullable
                                  @Nullable MTLSamplerState sampler,
                                  long index)

setObjectSamplerState:atIndex: Set a global sampler for all object shaders at the given bind point index. API-Since: 16.0

setObjectSamplerStateLodMinClampLodMaxClampAtIndex

void setObjectSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable
                                                        @Nullable MTLSamplerState sampler,
                                                        float lodMinClamp,
                                                        float lodMaxClamp,
                                                        long index)

setObjectSamplerState:lodMinClamp:lodMaxClamp:atIndex: Set a global sampler for all object shaders at the given bind point index. API-Since: 16.0

setObjectSamplerStatesLodMinClampsLodMaxClampsWithRange

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

setObjectSamplerStates:lodMinClamps:lodMaxClamps:withRange: Set an array of global samplers for all object shaders with the given bind point range. API-Since: 16.0

setObjectSamplerStatesWithRange

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

setObjectSamplerStates:withRange: Set an array of global samplers for all object shaders with the given bind point range. API-Since: 16.0

setObjectTextureAtIndex

void setObjectTextureAtIndex(@Nullable
                             @Nullable MTLTexture texture,
                             long index)

setObjectTexture:atIndex: Set a global texture for all object shaders at the given bind point index. API-Since: 16.0

setObjectTexturesWithRange

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

setObjectTextures:withRange: Set an array of global textures for all object shaders with the given bind point range. API-Since: 16.0

setObjectThreadgroupMemoryLengthAtIndex
```
void setObjectThreadgroupMemoryLengthAtIndex(long length,
                                             long index)
```
setObjectThreadgroupMemoryLength:atIndex: Set the threadgroup memory byte length at the binding point specified by the index for all object shaders. API-Since: 16.0

setVertexBufferOffsetAttributeStrideAtIndex

void setVertexBufferOffsetAttributeStrideAtIndex(@Nullable
                                                 @Nullable MTLBuffer buffer,
                                                 long offset,
                                                 long stride,
                                                 long index)

sets vertex buffer at specified index with provided offset and stride. Only call this when the buffer-index is part of the vertexDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0

setVertexBufferOffsetAttributeStrideAtIndex

void setVertexBufferOffsetAttributeStrideAtIndex(long offset,
                                                 long stride,
                                                 long index)

only call this when the buffer-index is part of the vertexDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0

setVertexBuffersOffsetsAttributeStridesWithRange

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

sets an array of vertex buffers with provided offsets and strides with the given bind point range. only call this when at least one buffer is part of the vertexDescriptor, other buffers must set their value relative to the `attributeStrides` array to `MTLAttributeStrideStatic` API-Since: 17.0

setVertexBytesLengthAttributeStrideAtIndex

void setVertexBytesLengthAttributeStrideAtIndex(@NotNull
                                                @NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes,
                                                long length,
                                                long stride,
                                                long index)

only call this when the buffer-index is part of the vertexDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0

Interface MTLRenderCommandEncoder

Method Summary

Methods inherited from interface apple.metal.protocol.MTLCommandEncoder

Method Detail

drawIndexedPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetInstanceCountBaseInstance

drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffset

drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCount

drawIndexedPrimitivesIndexCountIndexTypeIndexBufferIndexBufferOffsetInstanceCountBaseVertexBaseInstance

drawIndexedPrimitivesIndexTypeIndexBufferIndexBufferOffsetIndirectBufferIndirectBufferOffset

drawPatchesPatchStartPatchCountPatchIndexBufferPatchIndexBufferOffsetInstanceCountBaseInstance

drawPrimitivesIndirectBufferIndirectBufferOffset

drawPrimitivesVertexStartVertexCount

drawPrimitivesVertexStartVertexCountInstanceCount

drawPrimitivesVertexStartVertexCountInstanceCountBaseInstance

setBlendColorRedGreenBlueAlpha

setColorStoreActionAtIndex

setCullMode

setDepthBiasSlopeScaleClamp

setDepthStencilState

setDepthStoreAction

setFragmentBufferOffsetAtIndex

setFragmentBufferOffsetAtIndex

setFragmentBuffersOffsetsWithRange

setFragmentBytesLengthAtIndex

setFragmentSamplerStateAtIndex

setFragmentSamplerStateLodMinClampLodMaxClampAtIndex

setFragmentSamplerStatesLodMinClampsLodMaxClampsWithRange

setFragmentSamplerStatesWithRange

setFragmentTextureAtIndex

setFragmentTexturesWithRange

setFrontFacingWinding

setRenderPipelineState

setScissorRect

setStencilFrontReferenceValueBackReferenceValue

setStencilReferenceValue

setStencilStoreAction

setTessellationFactorBufferOffsetInstanceStride

setTessellationFactorScale

setTriangleFillMode

setVertexBufferOffsetAtIndex

setVertexBufferOffsetAtIndex

setVertexBuffersOffsetsWithRange

setVertexBytesLengthAtIndex

setVertexSamplerStateAtIndex

setVertexSamplerStateLodMinClampLodMaxClampAtIndex

setVertexSamplerStatesLodMinClampsLodMaxClampsWithRange

setVertexSamplerStatesWithRange

setVertexTextureAtIndex

setVertexTexturesWithRange

setViewport

setVisibilityResultModeOffset

updateFenceAfterStages

waitForFenceBeforeStages

dispatchThreadsPerTile

setColorStoreActionOptionsAtIndex

setDepthClipMode

setDepthStoreActionOptions

setStencilStoreActionOptions

setThreadgroupMemoryLengthOffsetAtIndex

setTileBufferOffsetAtIndex

setTileBufferOffsetAtIndex

setTileBuffersOffsetsWithRange

setTileBytesLengthAtIndex

setTileSamplerStateAtIndex

setTileSamplerStateLodMinClampLodMaxClampAtIndex

setTileSamplerStatesLodMinClampsLodMaxClampsWithRange

setTileSamplerStatesWithRange

setTileTextureAtIndex

setTileTexturesWithRange

tileHeight

tileWidth

useHeap

useHeapsCount

useResourceUsage

useResourcesCountUsage

drawIndexedPatchesPatchIndexBufferPatchIndexBufferOffsetControlPointIndexBufferControlPointIndexBufferOffsetIndirectBufferIndirectBufferOffset

drawPatchesPatchIndexBufferPatchIndexBufferOffsetIndirectBufferIndirectBufferOffset

executeCommandsInBufferIndirectBufferIndirectBufferOffset

executeCommandsInBufferWithRange

setScissorRectsCount