Bindings for [[ Metal ; https://developer.apple.com/documentation/metal ]].

Collection Info

View Source
Collection
vendor
Path
darwin/Metal
Entries
1952
Constants 6
Jump to Constants
ColorWriteMaskAll ResourceCPUCacheModeDefaultCache ResourceHazardTrackingModeDefault ResourceOptionCPUCacheModeDefault ResourceStorageModeMemoryless ResourceStorageModeShared
Types 303
Jump to Types
AccelerationStructure AccelerationStructureBoundingBoxGeometryDescriptor AccelerationStructureCommandEncoder AccelerationStructureDescriptor AccelerationStructureGeometryDescriptor AccelerationStructureInstanceDescriptor AccelerationStructureInstanceDescriptorType AccelerationStructureInstanceOption AccelerationStructureInstanceOptions AccelerationStructureMotionBoundingBoxGeometryDescriptor AccelerationStructureMotionTriangleGeometryDescriptor AccelerationStructurePassDescriptor AccelerationStructurePassSampleBufferAttachmentDescriptor AccelerationStructurePassSampleBufferAttachmentDescriptorArray AccelerationStructureRefitOption AccelerationStructureRefitOptions +287 more
Procedures 1608
Jump to Procedures
AccelerationStructure_gpuResourceID AccelerationStructure_size AccelerationStructureBoundingBoxGeometryDescriptor_alloc AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride AccelerationStructureBoundingBoxGeometryDescriptor_descriptor AccelerationStructureBoundingBoxGeometryDescriptor_init AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride AccelerationStructureCommandEncoder_buildAccelerationStructure AccelerationStructureCommandEncoder_copyAccelerationStructure AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure +1592 more
Procedure Groups 12
Jump to Procedure Groups
CaptureManager_newCaptureScope Device_newBuffer Device_newComputePipelineState Device_newLibrary Device_newRenderPipelineState Device_newSharedTexture Device_newTexture Heap_newAccelerationStructure Heap_newBuffer Heap_newTexture Library_newFunction Texture_newTextureView
Variables 23
Jump to Variables
CommandBufferEncoderInfoErrorKey CommonCounterClipperInvocations CommonCounterClipperPrimitivesOut CommonCounterComputeKernelInvocations CommonCounterFragmentCycles CommonCounterFragmentInvocations CommonCounterFragmentsPassed CommonCounterPostTessellationVertexCycles CommonCounterPostTessellationVertexInvocations CommonCounterRenderTargetWriteCycles CommonCounterSetStageUtilization CommonCounterSetStatistic CommonCounterSetTimestamp CommonCounterTessellationCycles CommonCounterTessellationInputPatches CommonCounterTimestamp +7 more

Source Files

Constants

6

ColorWriteMaskAll #

Source 
ColorWriteMaskAll :: ColorWriteMask{.Alpha, .Blue, .Green, .Red}

ResourceCPUCacheModeDefaultCache #

Source 
ResourceCPUCacheModeDefaultCache :: ResourceOptions{}

ResourceHazardTrackingModeDefault #

Source 
ResourceHazardTrackingModeDefault :: ResourceOptions{}

ResourceOptionCPUCacheModeDefault #

Source 
ResourceOptionCPUCacheModeDefault :: ResourceOptions{}

ResourceStorageModeMemoryless #

Source 
ResourceStorageModeMemoryless :: ResourceOptions{.StorageModeManaged, .StorageModePrivate}

ResourceStorageModeShared #

Source 
ResourceStorageModeShared :: ResourceOptions{}

Types

303

NewComputePipelineStateCompletionHandler #

Source 
NewComputePipelineStateCompletionHandler :: ^Block

NewComputePipelineStateWithReflectionCompletionHandler #

Source 
NewComputePipelineStateWithReflectionCompletionHandler :: ^Block

NewRenderPipelineStateCompletionHandler #

Source 
NewRenderPipelineStateCompletionHandler :: ^Block

NewRenderPipelineStateWithReflectionCompletionHandler #

Source 
NewRenderPipelineStateWithReflectionCompletionHandler :: ^Block

Procedures

1608

AccelerationStructureBoundingBoxGeometryDescriptor_descriptor #

Source 
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor)
@(objc_name="descriptor")
@(objc_is_class_method=true)
AccelerationStructureBoundingBoxGeometryDescriptor_descriptor :: proc "c" () -> ^AccelerationStructureBoundingBoxGeometryDescriptor {…}

AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer #

Source 
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor)
@(objc_name="setBoundingBoxBuffer")
AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBuffer: ^Buffer) {…}

AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset #

Source 
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor)
@(objc_name="setBoundingBoxBufferOffset")
AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: UInteger) {…}

AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride #

Source 
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor)
@(objc_name="setBoundingBoxStride")
AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: proc "c" (self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: UInteger) {…}

AccelerationStructureCommandEncoder_copyAccelerationStructure #

Source 
@(objc_type=AccelerationStructureCommandEncoder)
@(objc_name="copyAccelerationStructure")
AccelerationStructureCommandEncoder_copyAccelerationStructure :: proc "c" (self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) {…}

AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure #

Source 
@(objc_type=AccelerationStructureCommandEncoder)
@(objc_name="copyAndCompactAccelerationStructure")
AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: proc "c" (self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure, destinationAccelerationStructure: ^AccelerationStructure) {…}

AccelerationStructureCommandEncoder_refitAccelerationStructure #

Source 
@(objc_type=AccelerationStructureCommandEncoder)
@(objc_name="refitAccelerationStructure")
AccelerationStructureCommandEncoder_refitAccelerationStructure :: proc "c" (
	self:                             ^AccelerationStructureCommandEncoder, 
	sourceAccelerationStructure:      ^AccelerationStructure, 
	descriptor:                       ^AccelerationStructureDescriptor, 
	destinationAccelerationStructure: ^AccelerationStructure, 
	scratchBuffer:                    ^Buffer, 
	scratchBufferOffset:              UInteger, 
) {…}

AccelerationStructureCommandEncoder_refitAccelerationStructureWithOptions #

Source 
@(objc_type=AccelerationStructureCommandEncoder)
@(objc_name="refitAccelerationStructureWithOptions")
AccelerationStructureCommandEncoder_refitAccelerationStructureWithOptions :: proc "c" (
	self:                             ^AccelerationStructureCommandEncoder, 
	sourceAccelerationStructure:      ^AccelerationStructure, 
	descriptor:                       ^AccelerationStructureDescriptor, 
	destinationAccelerationStructure: ^AccelerationStructure, 
	scratchBuffer:                    ^Buffer, 
	scratchBufferOffset:              UInteger, 
	options:                          AccelerationStructureRefitOptions, 
) {…}

AccelerationStructureCommandEncoder_sampleCountersInBuffer #

Source 
@(objc_type=AccelerationStructureCommandEncoder)
@(objc_name="sampleCountersInBuffer")
AccelerationStructureCommandEncoder_sampleCountersInBuffer :: proc "c" (self: ^AccelerationStructureCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: UInteger, barrier: bool) {…}

AccelerationStructureDescriptor_alloc #

Source 
@(objc_type=AccelerationStructureDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
AccelerationStructureDescriptor_alloc :: proc "c" () -> ^AccelerationStructureDescriptor {…}

AccelerationStructureGeometryDescriptor_alloc #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
AccelerationStructureGeometryDescriptor_alloc :: proc "c" () -> ^AccelerationStructureGeometryDescriptor {…}

AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="allowDuplicateIntersectionFunctionInvocation")
AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation :: proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> bool {…}

AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="intersectionFunctionTableOffset")
AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> UInteger {…}

AccelerationStructureGeometryDescriptor_primitiveDataBuffer #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="primitiveDataBuffer")
AccelerationStructureGeometryDescriptor_primitiveDataBuffer :: proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> ^Buffer {…}

AccelerationStructureGeometryDescriptor_primitiveDataBufferOffset #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="primitiveDataBufferOffset")
AccelerationStructureGeometryDescriptor_primitiveDataBufferOffset :: proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> UInteger {…}

AccelerationStructureGeometryDescriptor_primitiveDataElementSize #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="primitiveDataElementSize")
AccelerationStructureGeometryDescriptor_primitiveDataElementSize :: proc "c" (self: ^AccelerationStructureGeometryDescriptor) -> UInteger {…}

AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="setAllowDuplicateIntersectionFunctionInvocation")
AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation :: proc "c" (self: ^AccelerationStructureGeometryDescriptor, allowDuplicateIntersectionFunctionInvocation: bool) {…}

AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="setIntersectionFunctionTableOffset")
AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: proc "c" (self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: UInteger) {…}

AccelerationStructureGeometryDescriptor_setPrimitiveDataBuffer #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="setPrimitiveDataBuffer")
AccelerationStructureGeometryDescriptor_setPrimitiveDataBuffer :: proc "c" (self: ^AccelerationStructureGeometryDescriptor, primitiveDataBuffer: ^Buffer) {…}

AccelerationStructureGeometryDescriptor_setPrimitiveDataBufferOffset #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="setPrimitiveDataBufferOffset")
AccelerationStructureGeometryDescriptor_setPrimitiveDataBufferOffset :: proc "c" (self: ^AccelerationStructureGeometryDescriptor, offset: UInteger) {…}

AccelerationStructureGeometryDescriptor_setPrimitiveDataElementSize #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="setPrimitiveDataElementSize")
AccelerationStructureGeometryDescriptor_setPrimitiveDataElementSize :: proc "c" (self: ^AccelerationStructureGeometryDescriptor, elementSize: UInteger) {…}

AccelerationStructureGeometryDescriptor_setPrimitiveDataStride #

Source 
@(objc_type=AccelerationStructureGeometryDescriptor)
@(objc_name="setPrimitiveDataStride")
AccelerationStructureGeometryDescriptor_setPrimitiveDataStride :: proc "c" (self: ^AccelerationStructureGeometryDescriptor, stride: UInteger) {…}

AccelerationStructureMotionBoundingBoxGeometryDescriptor_descriptor #

Source 
@(objc_type=AccelerationStructureMotionBoundingBoxGeometryDescriptor)
@(objc_name="descriptor")
@(objc_is_class_method=true)
AccelerationStructureMotionBoundingBoxGeometryDescriptor_descriptor :: proc "c" () -> ^AccelerationStructureMotionBoundingBoxGeometryDescriptor {…}

AccelerationStructureMotionTriangleGeometryDescriptor_setTransformationMatrixBuffer #

Source 
@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor)
@(objc_name="setTransformationMatrixBuffer")
AccelerationStructureMotionTriangleGeometryDescriptor_setTransformationMatrixBuffer :: proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, transformationMatrixBuffer: ^Buffer) {…}

AccelerationStructureMotionTriangleGeometryDescriptor_setTransformationMatrixBufferOffset #

Source 
@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor)
@(objc_name="setTransformationMatrixBufferOffset")
AccelerationStructureMotionTriangleGeometryDescriptor_setTransformationMatrixBufferOffset :: proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor, transformationMatrixBufferOffset: UInteger) {…}

AccelerationStructureMotionTriangleGeometryDescriptor_transformationMatrixBuffer #

Source 
@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor)
@(objc_name="transformationMatrixBuffer")
AccelerationStructureMotionTriangleGeometryDescriptor_transformationMatrixBuffer :: proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> ^Buffer {…}

AccelerationStructureMotionTriangleGeometryDescriptor_transformationMatrixBufferOffset #

Source 
@(objc_type=AccelerationStructureMotionTriangleGeometryDescriptor)
@(objc_name="transformationMatrixBufferOffset")
AccelerationStructureMotionTriangleGeometryDescriptor_transformationMatrixBufferOffset :: proc "c" (self: ^AccelerationStructureMotionTriangleGeometryDescriptor) -> UInteger {…}

AccelerationStructurePassDescriptor_accelerationStructurePassDescriptor #

Source 
@(objc_type=AccelerationStructurePassDescriptor)
@(objc_name="accelerationStructurePassDescriptor")
@(objc_is_class_method=true)
AccelerationStructurePassDescriptor_accelerationStructurePassDescriptor :: proc "c" () -> ^AccelerationStructurePassDescriptor {…}

AccelerationStructurePassDescriptor_alloc #

Source 
@(objc_type=AccelerationStructurePassDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
AccelerationStructurePassDescriptor_alloc :: proc "c" () -> ^AccelerationStructurePassDescriptor {…}

AccelerationStructurePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex #

Source 
@(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor)
@(objc_name="setEndOfEncoderSampleIndex")
AccelerationStructurePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: UInteger) {…}

AccelerationStructurePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex #

Source 
@(objc_type=AccelerationStructurePassSampleBufferAttachmentDescriptor)
@(objc_name="setStartOfEncoderSampleIndex")
AccelerationStructurePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc "c" (self: ^AccelerationStructurePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: UInteger) {…}

AccelerationStructureTriangleGeometryDescriptor_descriptor #

Source 
@(objc_type=AccelerationStructureTriangleGeometryDescriptor)
@(objc_name="descriptor")
@(objc_is_class_method=true)
AccelerationStructureTriangleGeometryDescriptor_descriptor :: proc "c" () -> ^AccelerationStructureTriangleGeometryDescriptor {…}

AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset #

Source 
@(objc_type=AccelerationStructureTriangleGeometryDescriptor)
@(objc_name="setIndexBufferOffset")
AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: UInteger) {…}

AccelerationStructureTriangleGeometryDescriptor_setTransformationMatrixBuffer #

Source 
@(objc_type=AccelerationStructureTriangleGeometryDescriptor)
@(objc_name="setTransformationMatrixBuffer")
AccelerationStructureTriangleGeometryDescriptor_setTransformationMatrixBuffer :: proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, transformationMatrixBuffer: ^Buffer) {…}

AccelerationStructureTriangleGeometryDescriptor_setTransformationMatrixBufferOffset #

Source 
@(objc_type=AccelerationStructureTriangleGeometryDescriptor)
@(objc_name="setTransformationMatrixBufferOffset")
AccelerationStructureTriangleGeometryDescriptor_setTransformationMatrixBufferOffset :: proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, transformationMatrixBufferOffset: UInteger) {…}

AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset #

Source 
@(objc_type=AccelerationStructureTriangleGeometryDescriptor)
@(objc_name="setVertexBufferOffset")
AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: UInteger) {…}

AccelerationStructureTriangleGeometryDescriptor_transformationMatrixBuffer #

Source 
@(objc_type=AccelerationStructureTriangleGeometryDescriptor)
@(objc_name="transformationMatrixBuffer")
AccelerationStructureTriangleGeometryDescriptor_transformationMatrixBuffer :: proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^Buffer {…}

AccelerationStructureTriangleGeometryDescriptor_transformationMatrixBufferOffset #

Source 
@(objc_type=AccelerationStructureTriangleGeometryDescriptor)
@(objc_name="transformationMatrixBufferOffset")
AccelerationStructureTriangleGeometryDescriptor_transformationMatrixBufferOffset :: proc "c" (self: ^AccelerationStructureTriangleGeometryDescriptor) -> UInteger {…}

Argument_alloc #

Source 
@(objc_type=Argument)
@(objc_name="alloc")
@(objc_is_class_method=true)
Argument_alloc :: proc "c" () -> ^Argument {…}

Argument_bufferAlignment #

Source 
@(objc_type=Argument)
@(objc_name="bufferAlignment")
Argument_bufferAlignment :: proc "c" (self: ^Argument) -> UInteger {…}

Argument_bufferDataSize #

Source 
@(objc_type=Argument)
@(objc_name="bufferDataSize")
Argument_bufferDataSize :: proc "c" (self: ^Argument) -> UInteger {…}

Argument_bufferDataType #

Source 
@(objc_type=Argument)
@(objc_name="bufferDataType")
Argument_bufferDataType :: proc "c" (self: ^Argument) -> DataType {…}

Argument_bufferPointerType #

Source 
@(objc_type=Argument)
@(objc_name="bufferPointerType")
Argument_bufferPointerType :: proc "c" (self: ^Argument) -> ^PointerType {…}

Argument_bufferStructType #

Source 
@(objc_type=Argument)
@(objc_name="bufferStructType")
Argument_bufferStructType :: proc "c" (self: ^Argument) -> ^StructType {…}

Argument_isActive #

Source 
@(objc_type=Argument)
@(objc_name="isActive")
Argument_isActive :: proc "c" (self: ^Argument) -> bool {…}

Argument_isDepthTexture #

Source 
@(objc_type=Argument)
@(objc_name="isDepthTexture")
Argument_isDepthTexture :: proc "c" (self: ^Argument) -> bool {…}

Argument_textureDataType #

Source 
@(objc_type=Argument)
@(objc_name="textureDataType")
Argument_textureDataType :: proc "c" (self: ^Argument) -> DataType {…}

Argument_threadgroupMemoryAlignment #

Source 
@(objc_type=Argument)
@(objc_name="threadgroupMemoryAlignment")
Argument_threadgroupMemoryAlignment :: proc "c" (self: ^Argument) -> UInteger {…}

Argument_threadgroupMemoryDataSize #

Source 
@(objc_type=Argument)
@(objc_name="threadgroupMemoryDataSize")
Argument_threadgroupMemoryDataSize :: proc "c" (self: ^Argument) -> UInteger {…}

ArgumentDescriptor_alloc #

Source 
@(objc_type=ArgumentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
ArgumentDescriptor_alloc :: proc "c" () -> ^ArgumentDescriptor {…}

ArgumentDescriptor_argumentDescriptor #

Source 
@(objc_type=ArgumentDescriptor)
@(objc_name="argumentDescriptor")
@(objc_is_class_method=true)
ArgumentDescriptor_argumentDescriptor :: proc "c" () -> ^ArgumentDescriptor {…}

ArgumentDescriptor_constantBlockAlignment #

Source 
@(objc_type=ArgumentDescriptor)
@(objc_name="constantBlockAlignment")
ArgumentDescriptor_constantBlockAlignment :: proc "c" (self: ^ArgumentDescriptor) -> UInteger {…}

ArgumentDescriptor_setArrayLength #

Source 
@(objc_type=ArgumentDescriptor)
@(objc_name="setArrayLength")
ArgumentDescriptor_setArrayLength :: proc "c" (self: ^ArgumentDescriptor, arrayLength: UInteger) {…}

ArgumentDescriptor_setConstantBlockAlignment #

Source 
@(objc_type=ArgumentDescriptor)
@(objc_name="setConstantBlockAlignment")
ArgumentDescriptor_setConstantBlockAlignment :: proc "c" (self: ^ArgumentDescriptor, constantBlockAlignment: UInteger) {…}

ArgumentEncoder_setArgumentBuffer_startOffsetWithStartOffset #

Source 
@(objc_type=ArgumentEncoder)
@(objc_name="setArgumentBufferWithStartOffset")
ArgumentEncoder_setArgumentBuffer_startOffsetWithStartOffset :: proc "c" (self: ^ArgumentEncoder, argumentBuffer: ^Buffer, startOffset: UInteger, arrayElement: UInteger) {…}

ArgumentEncoder_setArgumentBufferWithOffset #

Source 
@(objc_type=ArgumentEncoder)
@(objc_name="setArgumentBufferWithOffset")
ArgumentEncoder_setArgumentBufferWithOffset :: proc "c" (self: ^ArgumentEncoder, argumentBuffer: ^Buffer, offset: UInteger) {…}

ArrayType_alloc #

Source 
@(objc_type=ArrayType)
@(objc_name="alloc")
@(objc_is_class_method=true)
ArrayType_alloc :: proc "c" () -> ^ArrayType {…}

ArrayType_argumentIndexStride #

Source 
@(objc_type=ArrayType)
@(objc_name="argumentIndexStride")
ArrayType_argumentIndexStride :: proc "c" (self: ^ArrayType) -> UInteger {…}

ArrayType_elementArrayType #

Source 
@(objc_type=ArrayType)
@(objc_name="elementArrayType")
ArrayType_elementArrayType :: proc "c" (self: ^ArrayType) -> ^ArrayType {…}

ArrayType_elementPointerType #

Source 
@(objc_type=ArrayType)
@(objc_name="elementPointerType")
ArrayType_elementPointerType :: proc "c" (self: ^ArrayType) -> ^PointerType {…}

ArrayType_elementStructType #

Source 
@(objc_type=ArrayType)
@(objc_name="elementStructType")
ArrayType_elementStructType :: proc "c" (self: ^ArrayType) -> ^StructType {…}

Attribute_alloc #

Source 
@(objc_type=Attribute)
@(objc_name="alloc")
@(objc_is_class_method=true)
Attribute_alloc :: proc "c" () -> ^Attribute {…}

Attribute_attributeIndex #

Source 
@(objc_type=Attribute)
@(objc_name="attributeIndex")
Attribute_attributeIndex :: proc "c" (self: ^Attribute) -> UInteger {…}

Attribute_attributeType #

Source 
@(objc_type=Attribute)
@(objc_name="attributeType")
Attribute_attributeType :: proc "c" (self: ^Attribute) -> DataType {…}

Attribute_isActive #

Source 
@(objc_type=Attribute)
@(objc_name="isActive")
Attribute_isActive :: proc "c" (self: ^Attribute) -> bool {…}

Attribute_isPatchControlPointData #

Source 
@(objc_type=Attribute)
@(objc_name="isPatchControlPointData")
Attribute_isPatchControlPointData :: proc "c" (self: ^Attribute) -> bool {…}

Attribute_isPatchData #

Source 
@(objc_type=Attribute)
@(objc_name="isPatchData")
Attribute_isPatchData :: proc "c" (self: ^Attribute) -> bool {…}

AttributeDescriptor_alloc #

Source 
@(objc_type=AttributeDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
AttributeDescriptor_alloc :: proc "c" () -> ^AttributeDescriptor {…}

AttributeDescriptor_setBufferIndex #

Source 
@(objc_type=AttributeDescriptor)
@(objc_name="setBufferIndex")
AttributeDescriptor_setBufferIndex :: proc "c" (self: ^AttributeDescriptor, bufferIndex: UInteger) {…}

AttributeDescriptorArray_alloc #

Source 
@(objc_type=AttributeDescriptorArray)
@(objc_name="alloc")
@(objc_is_class_method=true)
AttributeDescriptorArray_alloc :: proc "c" () -> ^AttributeDescriptorArray {…}

BinaryArchive_serializeToURL #

Source 
@(objc_type=BinaryArchive)
@(objc_name="serializeToURL")
BinaryArchive_serializeToURL :: proc "contextless" (self: ^BinaryArchive, url: ^URL) -> (ok: bool, error: ^Error) {…}

BinaryArchiveDescriptor_alloc #

Source 
@(objc_type=BinaryArchiveDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
BinaryArchiveDescriptor_alloc :: proc "c" () -> ^BinaryArchiveDescriptor {…}

Binding_isArgument #

Source 
@(objc_type=Binding)
@(objc_name="isArgument")
Binding_isArgument :: proc "c" (self: ^Binding) -> bool {…}

Binding_isUsed #

Source 
@(objc_type=Binding)
@(objc_name="isUsed")
Binding_isUsed :: proc "c" (self: ^Binding) -> bool {…}

BlitCommandEncoder_copyFromTexture #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="copyFromTexture")
BlitCommandEncoder_copyFromTexture :: proc "c" (self: ^BlitCommandEncoder, sourceTexture: ^Texture, destinationTexture: ^Texture) {…}

BlitCommandEncoder_copyFromTextureWithDestinationOrigin #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="copyFromTextureWithDestinationOrigin")
BlitCommandEncoder_copyFromTextureWithDestinationOrigin :: proc "c" (
	self:               ^BlitCommandEncoder, 
	sourceTexture:      ^Texture, 
	sourceSlice:        UInteger, 
	sourceLevel:        UInteger, 
	sourceOrigin:       Origin, 
	sourceSize:         Size, 
	destinationTexture: ^Texture, 
	destinationSlice:   UInteger, 
	destinationLevel:   UInteger, 
	destinationOrigin:  Origin, 
) {…}

BlitCommandEncoder_generateMipmapsForTexture #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="generateMipmapsForTexture")
BlitCommandEncoder_generateMipmapsForTexture :: proc "c" (self: ^BlitCommandEncoder, texture: ^Texture) {…}

BlitCommandEncoder_optimizeContentsForCPUAccess #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="optimizeContentsForCPUAccess")
BlitCommandEncoder_optimizeContentsForCPUAccess :: proc "c" (self: ^BlitCommandEncoder, texture: ^Texture) {…}

BlitCommandEncoder_optimizeContentsForCPUAccessWithSliceAndLevel #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="optimizeContentsForCPUAccessWithSliceAndLevel")
BlitCommandEncoder_optimizeContentsForCPUAccessWithSliceAndLevel :: proc "c" (self: ^BlitCommandEncoder, texture: ^Texture, slice: UInteger, level: UInteger) {…}

BlitCommandEncoder_optimizeContentsForGPUAccess #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="optimizeContentsForGPUAccess")
BlitCommandEncoder_optimizeContentsForGPUAccess :: proc "c" (self: ^BlitCommandEncoder, texture: ^Texture) {…}

BlitCommandEncoder_optimizeContentsForGPUAccessWithSliceAndLevel #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="optimizeContentsForGPUAccessWithSliceAndLevel")
BlitCommandEncoder_optimizeContentsForGPUAccessWithSliceAndLevel :: proc "c" (self: ^BlitCommandEncoder, texture: ^Texture, slice: UInteger, level: UInteger) {…}

BlitCommandEncoder_optimizeIndirectCommandBuffer #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="optimizeIndirectCommandBuffer")
BlitCommandEncoder_optimizeIndirectCommandBuffer :: proc "c" (self: ^BlitCommandEncoder, indirectCommandBuffer: ^Buffer, range: Range) {…}

BlitCommandEncoder_resetCommandsInBuffer #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="resetCommandsInBuffer")
BlitCommandEncoder_resetCommandsInBuffer :: proc "c" (self: ^BlitCommandEncoder, buffer: ^Buffer, range: Range) {…}

BlitCommandEncoder_sampleCountersInBuffer #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="sampleCountersInBuffer")
BlitCommandEncoder_sampleCountersInBuffer :: proc "c" (self: ^BlitCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: UInteger, barrier: bool) {…}

BlitCommandEncoder_synchronizeResource #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="synchronizeResource")
BlitCommandEncoder_synchronizeResource :: proc "c" (self: ^BlitCommandEncoder, resource: ^Resource) {…}

BlitCommandEncoder_updateFence #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="updateFence")
BlitCommandEncoder_updateFence :: proc "c" (self: ^BlitCommandEncoder, fence: ^Fence) {…}

BlitCommandEncoder_waitForFence #

Source 
@(objc_type=BlitCommandEncoder)
@(objc_name="waitForFence")
BlitCommandEncoder_waitForFence :: proc "c" (self: ^BlitCommandEncoder, fence: ^Fence) {…}

BlitPassDescriptor_alloc #

Source 
@(objc_type=BlitPassDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
BlitPassDescriptor_alloc :: proc "c" () -> ^BlitPassDescriptor {…}

BlitPassDescriptor_blitPassDescriptor #

Source 
@(objc_type=BlitPassDescriptor)
@(objc_name="blitPassDescriptor")
@(objc_is_class_method=true)
BlitPassDescriptor_blitPassDescriptor :: proc "c" () -> ^BlitPassDescriptor {…}

BlitPassSampleBufferAttachmentDescriptor_alloc #

Source 
@(objc_type=BlitPassSampleBufferAttachmentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
BlitPassSampleBufferAttachmentDescriptor_alloc :: proc "c" () -> ^BlitPassSampleBufferAttachmentDescriptor {…}

BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex #

Source 
@(objc_type=BlitPassSampleBufferAttachmentDescriptor)
@(objc_name="endOfEncoderSampleIndex")
BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor) -> UInteger {…}

BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex #

Source 
@(objc_type=BlitPassSampleBufferAttachmentDescriptor)
@(objc_name="setEndOfEncoderSampleIndex")
BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: UInteger) {…}

BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex #

Source 
@(objc_type=BlitPassSampleBufferAttachmentDescriptor)
@(objc_name="setStartOfEncoderSampleIndex")
BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: UInteger) {…}

BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex #

Source 
@(objc_type=BlitPassSampleBufferAttachmentDescriptor)
@(objc_name="startOfEncoderSampleIndex")
BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc "c" (self: ^BlitPassSampleBufferAttachmentDescriptor) -> UInteger {…}

Buffer_addDebugMarker #

Source 
@(objc_type=Buffer)
@(objc_name="addDebugMarker")
Buffer_addDebugMarker :: proc "c" (self: ^Buffer, marker: ^String, range: Range) {…}

Buffer_contents #

Source 
@(objc_type=Buffer)
@(objc_name="contents")
Buffer_contents :: proc "c" (self: ^Buffer) -> []u8 {…}

Buffer_contentsAsSlice #

Source 
@(objc_type=Buffer)
@(objc_name="contentsAsSlice")
Buffer_contentsAsSlice :: proc "c" (self: ^Buffer, $T: typeid/[]$E) -> $$deferred_return {…}

Buffer_contentsPointer #

Source 
@(objc_type=Buffer)
@(objc_name="contentsPointer")
Buffer_contentsPointer :: proc "c" (self: ^Buffer) -> rawptr {…}

Buffer_didModifyRange #

Source 
@(objc_type=Buffer)
@(objc_name="didModifyRange")
Buffer_didModifyRange :: proc "c" (self: ^Buffer, range: Range) {…}

Buffer_gpuAddress #

Source 
@(objc_type=Buffer)
@(objc_name="gpuAddress")
Buffer_gpuAddress :: proc "c" (self: ^Buffer) -> u64 {…}

Buffer_newRemoteBufferViewForDevice #

Source 
@(objc_type=Buffer)
@(objc_name="newRemoteBufferViewForDevice")
Buffer_newRemoteBufferViewForDevice :: proc "c" (self: ^Buffer, device: ^Device) -> ^Buffer {…}

Buffer_newRemoveBufferViewForDevice #

Source 
@(objc_type=Buffer)
@(objc_name="newRemoveBufferViewForDevice")
Buffer_newRemoveBufferViewForDevice :: proc "c" (self: ^Buffer, device: ^Device) -> ^Buffer {…}

Buffer_remoteStorageBuffer #

Source 
@(objc_type=Buffer)
@(objc_name="remoteStorageBuffer")
Buffer_remoteStorageBuffer :: proc "c" (self: ^Buffer) -> ^Buffer {…}

Buffer_removeAllDebugMarkers #

Source 
@(objc_type=Buffer)
@(objc_name="removeAllDebugMarkers")
Buffer_removeAllDebugMarkers :: proc "c" (self: ^Buffer) {…}

BufferBinding_bufferAlignment #

Source 
@(objc_type=BufferBinding)
@(objc_name="bufferAlignment")
BufferBinding_bufferAlignment :: proc "c" (self: ^BufferBinding) -> UInteger {…}

BufferBinding_bufferDataSize #

Source 
@(objc_type=BufferBinding)
@(objc_name="bufferDataSize")
BufferBinding_bufferDataSize :: proc "c" (self: ^BufferBinding) -> UInteger {…}

BufferBinding_bufferDataType #

Source 
@(objc_type=BufferBinding)
@(objc_name="bufferDataType")
BufferBinding_bufferDataType :: proc "c" (self: ^BufferBinding) -> DataType {…}

BufferBinding_bufferPointerType #

Source 
@(objc_type=BufferBinding)
@(objc_name="bufferPointerType")
BufferBinding_bufferPointerType :: proc "c" (self: ^BufferBinding) -> ^PointerType {…}

BufferBinding_bufferStructType #

Source 
@(objc_type=BufferBinding)
@(objc_name="bufferStructType")
BufferBinding_bufferStructType :: proc "c" (self: ^BufferBinding) -> ^StructType {…}

BufferLayoutDescriptor_alloc #

Source 
@(objc_type=BufferLayoutDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
BufferLayoutDescriptor_alloc :: proc "c" () -> ^BufferLayoutDescriptor {…}

BufferLayoutDescriptorArray_alloc #

Source 
@(objc_type=BufferLayoutDescriptorArray)
@(objc_name="alloc")
@(objc_is_class_method=true)
BufferLayoutDescriptorArray_alloc :: proc "c" () -> ^BufferLayoutDescriptorArray {…}

CaptureDescriptor_alloc #

Source 
@(objc_type=CaptureDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
CaptureDescriptor_alloc :: proc "c" () -> ^CaptureDescriptor {…}

CaptureDescriptor_captureObject #

Source 
@(objc_type=CaptureDescriptor)
@(objc_name="captureObject")
CaptureDescriptor_captureObject :: proc "c" (self: ^CaptureDescriptor) -> ^Object {…}

CaptureDescriptor_outputURL #

Source 
@(objc_type=CaptureDescriptor)
@(objc_name="outputURL")
CaptureDescriptor_outputURL :: proc "c" (self: ^CaptureDescriptor) -> ^URL {…}

CaptureDescriptor_setCaptureObject #

Source 
@(objc_type=CaptureDescriptor)
@(objc_name="setCaptureObject")
CaptureDescriptor_setCaptureObject :: proc "c" (self: ^CaptureDescriptor, captureObject: ^Object) {…}

CaptureDescriptor_setOutputURL #

Source 
@(objc_type=CaptureDescriptor)
@(objc_name="setOutputURL")
CaptureDescriptor_setOutputURL :: proc "c" (self: ^CaptureDescriptor, outputURL: ^URL) {…}

CaptureManager_alloc #

Source 
@(objc_type=CaptureManager)
@(objc_name="alloc")
@(objc_is_class_method=true)
CaptureManager_alloc :: proc "c" () -> ^CaptureManager {…}

CaptureManager_isCapturing #

Source 
@(objc_type=CaptureManager)
@(objc_name="isCapturing")
CaptureManager_isCapturing :: proc "c" (self: ^CaptureManager) -> bool {…}

CaptureManager_newCaptureScopeWithCommandQueue #

Source 
@(objc_type=CaptureManager)
@(objc_name="newCaptureScopeWithCommandQueue")
CaptureManager_newCaptureScopeWithCommandQueue :: proc "c" (self: ^CaptureManager, commandQueue: ^CommandQueue) -> ^CaptureScope {…}

CaptureManager_newCaptureScopeWithDevice #

Source 
@(objc_type=CaptureManager)
@(objc_name="newCaptureScopeWithDevice")
CaptureManager_newCaptureScopeWithDevice :: proc "c" (self: ^CaptureManager, device: ^Device) -> ^CaptureScope {…}

CaptureManager_setDefaultCaptureScope #

Source 
@(objc_type=CaptureManager)
@(objc_name="setDefaultCaptureScope")
CaptureManager_setDefaultCaptureScope :: proc "c" (self: ^CaptureManager, defaultCaptureScope: ^CaptureScope) {…}

CaptureManager_sharedCaptureManager #

Source 
@(objc_type=CaptureManager)
@(objc_name="sharedCaptureManager")
@(objc_is_class_method=true)
CaptureManager_sharedCaptureManager :: proc "c" () -> ^CaptureManager {…}

CaptureManager_startCaptureWithCommandQueue #

Source 
@(objc_type=CaptureManager)
@(objc_name="startCaptureWithCommandQueue")
CaptureManager_startCaptureWithCommandQueue :: proc "c" (self: ^CaptureManager, commandQueue: ^CommandQueue) {…}

CaptureManager_startCaptureWithDescriptor #

Source 
@(objc_type=CaptureManager)
@(objc_name="startCaptureWithDescriptor")
CaptureManager_startCaptureWithDescriptor :: proc "contextless" (self: ^CaptureManager, descriptor: ^CaptureDescriptor) -> (ok: bool, error: ^Error) {…}

CaptureManager_startCaptureWithDevice #

Source 
@(objc_type=CaptureManager)
@(objc_name="startCaptureWithDevice")
CaptureManager_startCaptureWithDevice :: proc "c" (self: ^CaptureManager, device: ^Device) {…}

CaptureManager_startCaptureWithScope #

Source 
@(objc_type=CaptureManager)
@(objc_name="startCaptureWithScope")
CaptureManager_startCaptureWithScope :: proc "c" (self: ^CaptureManager, captureScope: ^CaptureScope) {…}

CaptureManager_stopCapture #

Source 
@(objc_type=CaptureManager)
@(objc_name="stopCapture")
CaptureManager_stopCapture :: proc "c" (self: ^CaptureManager) {…}

CaptureScope_beginScope #

Source 
@(objc_type=CaptureScope)
@(objc_name="beginScope")
CaptureScope_beginScope :: proc "c" (self: ^CaptureScope) {…}

CaptureScope_endScope #

Source 
@(objc_type=CaptureScope)
@(objc_name="endScope")
CaptureScope_endScope :: proc "c" (self: ^CaptureScope) {…}

CommandBuffer_commit #

Source 
@(objc_type=CommandBuffer)
@(objc_name="commit")
CommandBuffer_commit :: proc "c" (self: ^CommandBuffer) {…}

CommandBuffer_encodeSignalEvent #

Source 
@(objc_type=CommandBuffer)
@(objc_name="encodeSignalEvent")
CommandBuffer_encodeSignalEvent :: proc "c" (self: ^CommandBuffer, event: ^Event, value: u64) {…}

CommandBuffer_encodeWaitForEvent #

Source 
@(objc_type=CommandBuffer)
@(objc_name="encodeWaitForEvent")
CommandBuffer_encodeWaitForEvent :: proc "c" (self: ^CommandBuffer, event: ^Event, value: u64) {…}

CommandBuffer_enqueue #

Source 
@(objc_type=CommandBuffer)
@(objc_name="enqueue")
CommandBuffer_enqueue :: proc "c" (self: ^CommandBuffer) {…}

CommandBuffer_popDebugGroup #

Source 
@(objc_type=CommandBuffer)
@(objc_name="popDebugGroup")
CommandBuffer_popDebugGroup :: proc "c" (self: ^CommandBuffer) {…}

CommandBuffer_presentDrawable #

Source 
@(objc_type=CommandBuffer)
@(objc_name="presentDrawable")
CommandBuffer_presentDrawable :: proc "c" (self: ^CommandBuffer, drawable: ^Drawable) {…}

CommandBuffer_presentDrawableAfterMinimumDuration #

Source 
@(objc_type=CommandBuffer)
@(objc_name="presentDrawableAfterMinimumDuration")
CommandBuffer_presentDrawableAfterMinimumDuration :: proc "c" (self: ^CommandBuffer, drawable: ^Drawable, duration: TimeInterval) {…}

CommandBuffer_presentDrawableAtTime #

Source 
@(objc_type=CommandBuffer)
@(objc_name="presentDrawableAtTime")
CommandBuffer_presentDrawableAtTime :: proc "c" (self: ^CommandBuffer, drawable: ^Drawable, presentationTime: TimeInterval) {…}

CommandBuffer_pushDebugGroup #

Source 
@(objc_type=CommandBuffer)
@(objc_name="pushDebugGroup")
CommandBuffer_pushDebugGroup :: proc "c" (self: ^CommandBuffer, string: ^String) {…}

CommandBuffer_resourceStateCommandEncoder #

Source 
@(objc_type=CommandBuffer)
@(objc_name="resourceStateCommandEncoder")
CommandBuffer_resourceStateCommandEncoder :: proc "c" (self: ^CommandBuffer) -> ^CommandBuffer {…}

CommandBuffer_retainedReferences #

Source 
@(objc_type=CommandBuffer)
@(objc_name="retainedReferences")
CommandBuffer_retainedReferences :: proc "c" (self: ^CommandBuffer) -> bool {…}

CommandBuffer_waitUntilCompleted #

Source 
@(objc_type=CommandBuffer)
@(objc_name="waitUntilCompleted")
CommandBuffer_waitUntilCompleted :: proc "c" (self: ^CommandBuffer) {…}

CommandBuffer_waitUntilScheduled #

Source 
@(objc_type=CommandBuffer)
@(objc_name="waitUntilScheduled")
CommandBuffer_waitUntilScheduled :: proc "c" (self: ^CommandBuffer) {…}

CommandBufferDescriptor_alloc #

Source 
@(objc_type=CommandBufferDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
CommandBufferDescriptor_alloc :: proc "c" () -> ^CommandBufferDescriptor {…}

CommandBufferDescriptor_retainedReferences #

Source 
@(objc_type=CommandBufferDescriptor)
@(objc_name="retainedReferences")
CommandBufferDescriptor_retainedReferences :: proc "c" (self: ^CommandBufferDescriptor) -> bool {…}

CommandBufferDescriptor_setRetainedReferences #

Source 
@(objc_type=CommandBufferDescriptor)
@(objc_name="setRetainedReferences")
CommandBufferDescriptor_setRetainedReferences :: proc "c" (self: ^CommandBufferDescriptor, retainedReferences: bool) {…}

CommandBufferEncoderInfo_debugSignposts #

Source 
@(objc_type=CommandBufferEncoderInfo)
@(objc_name="debugSignposts")
CommandBufferEncoderInfo_debugSignposts :: proc "c" (self: ^CommandBufferEncoderInfo) -> ^Array {…}

CommandEncoder_endEncoding #

Source 
@(objc_type=CommandEncoder)
@(objc_name="endEncoding")
CommandEncoder_endEncoding :: proc "c" (self: ^CommandEncoder) {…}

CommandEncoder_insertDebugSignpost #

Source 
@(objc_type=CommandEncoder)
@(objc_name="insertDebugSignpost")
CommandEncoder_insertDebugSignpost :: proc "c" (self: ^CommandEncoder, string: ^String) {…}

CommandEncoder_popDebugGroup #

Source 
@(objc_type=CommandEncoder)
@(objc_name="popDebugGroup")
CommandEncoder_popDebugGroup :: proc "c" (self: ^CommandEncoder) {…}

CommandEncoder_pushDebugGroup #

Source 
@(objc_type=CommandEncoder)
@(objc_name="pushDebugGroup")
CommandEncoder_pushDebugGroup :: proc "c" (self: ^CommandEncoder, string: ^String) {…}

CommandQueue_commandBufferWithUnretainedReferences #

Source 
@(objc_type=CommandQueue)
@(objc_name="commandBufferWithUnretainedReferences")
CommandQueue_commandBufferWithUnretainedReferences :: proc "c" (self: ^CommandQueue) -> ^CommandBuffer {…}

CommandQueue_insertDebugCaptureBoundary #

Source 
@(objc_type=CommandQueue)
@(objc_name="insertDebugCaptureBoundary")
CommandQueue_insertDebugCaptureBoundary :: proc "c" (self: ^CommandQueue) {…}

CompileOptions_alloc #

Source 
@(objc_type=CompileOptions)
@(objc_name="alloc")
@(objc_is_class_method=true)
CompileOptions_alloc :: proc "c" () -> ^CompileOptions {…}

CompileOptions_fastMathEnabled #

Source 
@(objc_type=CompileOptions)
@(objc_name="fastMathEnabled")
CompileOptions_fastMathEnabled :: proc "c" (self: ^CompileOptions) -> bool {…}

CompileOptions_installName #

Source 
@(objc_type=CompileOptions)
@(objc_name="installName")
CompileOptions_installName :: proc "c" (self: ^CompileOptions) -> ^String {…}

CompileOptions_preprocessorMacros #

Source 
@(objc_type=CompileOptions)
@(objc_name="preprocessorMacros")
CompileOptions_preprocessorMacros :: proc "c" (self: ^CompileOptions) -> ^Dictionary {…}

CompileOptions_preserveInvariance #

Source 
@(objc_type=CompileOptions)
@(objc_name="preserveInvariance")
CompileOptions_preserveInvariance :: proc "c" (self: ^CompileOptions) -> bool {…}

CompileOptions_setFastMathEnabled #

Source 
@(objc_type=CompileOptions)
@(objc_name="setFastMathEnabled")
CompileOptions_setFastMathEnabled :: proc "c" (self: ^CompileOptions, fastMathEnabled: bool) {…}

CompileOptions_setInstallName #

Source 
@(objc_type=CompileOptions)
@(objc_name="setInstallName")
CompileOptions_setInstallName :: proc "c" (self: ^CompileOptions, installName: ^String) {…}

CompileOptions_setLanguageVersion #

Source 
@(objc_type=CompileOptions)
@(objc_name="setLanguageVersion")
CompileOptions_setLanguageVersion :: proc "c" (self: ^CompileOptions, languageVersion: LanguageVersion) {…}

CompileOptions_setLibraries #

Source 
@(objc_type=CompileOptions)
@(objc_name="setLibraries")
CompileOptions_setLibraries :: proc "c" (self: ^CompileOptions, libraries: ^Array) {…}

CompileOptions_setLibraryType #

Source 
@(objc_type=CompileOptions)
@(objc_name="setLibraryType")
CompileOptions_setLibraryType :: proc "c" (self: ^CompileOptions, libraryType: LibraryType) {…}

CompileOptions_setPreprocessorMacros #

Source 
@(objc_type=CompileOptions)
@(objc_name="setPreprocessorMacros")
CompileOptions_setPreprocessorMacros :: proc "c" (self: ^CompileOptions, preprocessorMacros: ^Dictionary) {…}

CompileOptions_setPreserveInvariance #

Source 
@(objc_type=CompileOptions)
@(objc_name="setPreserveInvariance")
CompileOptions_setPreserveInvariance :: proc "c" (self: ^CompileOptions, preserveInvariance: bool) {…}

ComputeCommandEncoder_dispatchThreadgroups #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="dispatchThreadgroups")
ComputeCommandEncoder_dispatchThreadgroups :: proc "c" (self: ^ComputeCommandEncoder, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) {…}

ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="dispatchThreadgroupsWithIndirectBuffer")
ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer :: proc "c" (self: ^ComputeCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset: UInteger, threadsPerThreadgroup: Size) {…}

ComputeCommandEncoder_dispatchThreads #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="dispatchThreads")
ComputeCommandEncoder_dispatchThreads :: proc "c" (self: ^ComputeCommandEncoder, threadsPerGrid: Size, threadsPerThreadgroup: Size) {…}

ComputeCommandEncoder_executeCommandsInBuffer #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="executeCommandsInBuffer")
ComputeCommandEncoder_executeCommandsInBuffer :: proc "c" (self: ^ComputeCommandEncoder, indirectCommandbuffer: ^Buffer, indirectRangeBuffer: ^Buffer, indirectBufferOffset: UInteger) {…}

ComputeCommandEncoder_executeCommandsInBufferWithRange #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="executeCommandsInBufferWithRange")
ComputeCommandEncoder_executeCommandsInBufferWithRange :: proc "c" (self: ^ComputeCommandEncoder, indirectCommandBuffer: ^Buffer, executionRange: Range) {…}

ComputeCommandEncoder_memoryBarrierWithResources #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="memoryBarrierWithResources")
ComputeCommandEncoder_memoryBarrierWithResources :: proc "c" (self: ^ComputeCommandEncoder, resources: []^Resource) {…}

ComputeCommandEncoder_memoryBarrierWithScope #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="memoryBarrierWithScope")
ComputeCommandEncoder_memoryBarrierWithScope :: proc "c" (self: ^ComputeCommandEncoder, scope: BarrierScope) {…}

ComputeCommandEncoder_sampleCountersInBuffer #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="sampleCountersInBuffer")
ComputeCommandEncoder_sampleCountersInBuffer :: proc "c" (self: ^ComputeCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: UInteger, barrier: bool) {…}

ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="setSamplerStateWithLod")
ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp :: proc "c" (self: ^ComputeCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: UInteger) {…}

ComputeCommandEncoder_setSamplerStatesWithLod #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="setSamplerStatesWithLod")
ComputeCommandEncoder_setSamplerStatesWithLod :: proc "c" (self: ^ComputeCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: Range) {…}

ComputeCommandEncoder_setSamplerStatesWithRange #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="setSamplerStatesWithRange")
ComputeCommandEncoder_setSamplerStatesWithRange :: proc "c" (self: ^ComputeCommandEncoder, samplers: []^SamplerState, range: Range) {…}

ComputeCommandEncoder_setStageInRegion #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="setStageInRegion")
ComputeCommandEncoder_setStageInRegion :: proc "c" (self: ^ComputeCommandEncoder, region: Region) {…}

ComputeCommandEncoder_setStageInRegionWithIndirectBuffer #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="setStageInRegionWithIndirectBuffer")
ComputeCommandEncoder_setStageInRegionWithIndirectBuffer :: proc "c" (self: ^ComputeCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset: UInteger) {…}

ComputeCommandEncoder_setThreadgroupMemoryLength #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="setThreadgroupMemoryLength")
ComputeCommandEncoder_setThreadgroupMemoryLength :: proc "c" (self: ^ComputeCommandEncoder, length: UInteger, index: UInteger) {…}

ComputeCommandEncoder_updateFence #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="updateFence")
ComputeCommandEncoder_updateFence :: proc "c" (self: ^ComputeCommandEncoder, fence: ^Fence) {…}

ComputeCommandEncoder_useHeaps #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="useHeaps")
ComputeCommandEncoder_useHeaps :: proc "c" (self: ^ComputeCommandEncoder, heaps: []^Heap) {…}

ComputeCommandEncoder_waitForFence #

Source 
@(objc_type=ComputeCommandEncoder)
@(objc_name="waitForFence")
ComputeCommandEncoder_waitForFence :: proc "c" (self: ^ComputeCommandEncoder, fence: ^Fence) {…}

ComputePassDescriptor_alloc #

Source 
@(objc_type=ComputePassDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
ComputePassDescriptor_alloc :: proc "c" () -> ^ComputePassDescriptor {…}

ComputePassDescriptor_computePassDescriptor #

Source 
@(objc_type=ComputePassDescriptor)
@(objc_name="computePassDescriptor")
@(objc_is_class_method=true)
ComputePassDescriptor_computePassDescriptor :: proc "c" () -> ^ComputePassDescriptor {…}

ComputePassSampleBufferAttachmentDescriptor_alloc #

Source 
@(objc_type=ComputePassSampleBufferAttachmentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
ComputePassSampleBufferAttachmentDescriptor_alloc :: proc "c" () -> ^ComputePassSampleBufferAttachmentDescriptor {…}

ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex #

Source 
@(objc_type=ComputePassSampleBufferAttachmentDescriptor)
@(objc_name="setEndOfEncoderSampleIndex")
ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: UInteger) {…}

ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex #

Source 
@(objc_type=ComputePassSampleBufferAttachmentDescriptor)
@(objc_name="setStartOfEncoderSampleIndex")
ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: UInteger) {…}

ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex #

Source 
@(objc_type=ComputePassSampleBufferAttachmentDescriptor)
@(objc_name="startOfEncoderSampleIndex")
ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc "c" (self: ^ComputePassSampleBufferAttachmentDescriptor) -> UInteger {…}

ComputePipelineDescriptor_alloc #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
ComputePipelineDescriptor_alloc :: proc "c" () -> ^ComputePipelineDescriptor {…}

ComputePipelineDescriptor_binaryArchives #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="binaryArchives")
ComputePipelineDescriptor_binaryArchives :: proc "c" (self: ^ComputePipelineDescriptor) -> ^Array {…}

ComputePipelineDescriptor_insertLibraries #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="insertLibraries")
ComputePipelineDescriptor_insertLibraries :: proc "c" (self: ^ComputePipelineDescriptor) -> ^Array {…}

ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="maxTotalThreadsPerThreadgroup")
ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup :: proc "c" (self: ^ComputePipelineDescriptor) -> UInteger {…}

ComputePipelineDescriptor_setBinaryArchives #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="setBinaryArchives")
ComputePipelineDescriptor_setBinaryArchives :: proc "c" (self: ^ComputePipelineDescriptor, binaryArchives: ^Array) {…}

ComputePipelineDescriptor_setComputeFunction #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="setComputeFunction")
ComputePipelineDescriptor_setComputeFunction :: proc "c" (self: ^ComputePipelineDescriptor, computeFunction: ^Function) {…}

ComputePipelineDescriptor_setInsertLibraries #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="setInsertLibraries")
ComputePipelineDescriptor_setInsertLibraries :: proc "c" (self: ^ComputePipelineDescriptor, insertLibraries: ^Array) {…}

ComputePipelineDescriptor_setMaxCallStackDepth #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="setMaxCallStackDepth")
ComputePipelineDescriptor_setMaxCallStackDepth :: proc "c" (self: ^ComputePipelineDescriptor, maxCallStackDepth: UInteger) {…}

ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="setMaxTotalThreadsPerThreadgroup")
ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: proc "c" (self: ^ComputePipelineDescriptor, maxTotalThreadsPerThreadgroup: UInteger) {…}

ComputePipelineDescriptor_setSupportAddingBinaryFunctions #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="setSupportAddingBinaryFunctions")
ComputePipelineDescriptor_setSupportAddingBinaryFunctions :: proc "c" (self: ^ComputePipelineDescriptor, supportAddingBinaryFunctions: bool) {…}

ComputePipelineDescriptor_setSupportIndirectCommandBuffers #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="setSupportIndirectCommandBuffers")
ComputePipelineDescriptor_setSupportIndirectCommandBuffers :: proc "c" (self: ^ComputePipelineDescriptor, supportIndirectCommandBuffers: bool) {…}

ComputePipelineDescriptor_setThreadGroupSizeIsMultipleOfThreadExecutionWidth #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="setThreadGroupSizeIsMultipleOfThreadExecutionWidth")
ComputePipelineDescriptor_setThreadGroupSizeIsMultipleOfThreadExecutionWidth :: proc "c" (self: ^ComputePipelineDescriptor, threadGroupSizeIsMultipleOfThreadExecutionWidth: bool) {…}

ComputePipelineDescriptor_supportAddingBinaryFunctions #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="supportAddingBinaryFunctions")
ComputePipelineDescriptor_supportAddingBinaryFunctions :: proc "c" (self: ^ComputePipelineDescriptor) -> bool {…}

ComputePipelineDescriptor_supportIndirectCommandBuffers #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="supportIndirectCommandBuffers")
ComputePipelineDescriptor_supportIndirectCommandBuffers :: proc "c" (self: ^ComputePipelineDescriptor) -> bool {…}

ComputePipelineDescriptor_threadGroupSizeIsMultipleOfThreadExecutionWidth #

Source 
@(objc_type=ComputePipelineDescriptor)
@(objc_name="threadGroupSizeIsMultipleOfThreadExecutionWidth")
ComputePipelineDescriptor_threadGroupSizeIsMultipleOfThreadExecutionWidth :: proc "c" (self: ^ComputePipelineDescriptor) -> bool {…}

ComputePipelineReflection_alloc #

Source 
@(objc_type=ComputePipelineReflection)
@(objc_name="alloc")
@(objc_is_class_method=true)
ComputePipelineReflection_alloc :: proc "c" () -> ^ComputePipelineReflection {…}

ComputePipelineState_imageblockMemoryLengthForDimensions #

Source 
@(objc_type=ComputePipelineState)
@(objc_name="imageblockMemoryLengthForDimensions")
ComputePipelineState_imageblockMemoryLengthForDimensions :: proc "c" (self: ^ComputePipelineState, imageblockDimensions: Size) -> ^ComputePipelineState {…}

ComputePipelineState_maxTotalThreadsPerThreadgroup #

Source 
@(objc_type=ComputePipelineState)
@(objc_name="maxTotalThreadsPerThreadgroup")
ComputePipelineState_maxTotalThreadsPerThreadgroup :: proc "c" (self: ^ComputePipelineState) -> UInteger {…}

ComputePipelineState_staticThreadgroupMemoryLength #

Source 
@(objc_type=ComputePipelineState)
@(objc_name="staticThreadgroupMemoryLength")
ComputePipelineState_staticThreadgroupMemoryLength :: proc "c" (self: ^ComputePipelineState) -> UInteger {…}

ComputePipelineState_supportIndirectCommandBuffers #

Source 
@(objc_type=ComputePipelineState)
@(objc_name="supportIndirectCommandBuffers")
ComputePipelineState_supportIndirectCommandBuffers :: proc "c" (self: ^ComputePipelineState) -> bool {…}

ComputePipelineState_threadExecutionWidth #

Source 
@(objc_type=ComputePipelineState)
@(objc_name="threadExecutionWidth")
ComputePipelineState_threadExecutionWidth :: proc "c" (self: ^ComputePipelineState) -> UInteger {…}

CounterSampleBuffer_resolveCounterRange #

Source 
@(objc_type=CounterSampleBuffer)
@(objc_name="resolveCounterRange")
CounterSampleBuffer_resolveCounterRange :: proc "c" (self: ^CounterSampleBuffer, range: Range) -> ^Data {…}

CounterSampleBufferDescriptor_alloc #

Source 
@(objc_type=CounterSampleBufferDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
CounterSampleBufferDescriptor_alloc :: proc "c" () -> ^CounterSampleBufferDescriptor {…}

CounterSet_counters #

Source 
@(objc_type=CounterSet)
@(objc_name="counters")
CounterSet_counters :: proc "c" (self: ^CounterSet) -> ^Array {…}

DepthStencilDescriptor_alloc #

Source 
@(objc_type=DepthStencilDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
DepthStencilDescriptor_alloc :: proc "c" () -> ^DepthStencilDescriptor {…}

DepthStencilDescriptor_isDepthWriteEnabled #

Source 
@(objc_type=DepthStencilDescriptor)
@(objc_name="isDepthWriteEnabled")
DepthStencilDescriptor_isDepthWriteEnabled :: proc "c" (self: ^DepthStencilDescriptor) -> bool {…}

DepthStencilDescriptor_setDepthCompareFunction #

Source 
@(objc_type=DepthStencilDescriptor)
@(objc_name="setDepthCompareFunction")
DepthStencilDescriptor_setDepthCompareFunction :: proc "c" (self: ^DepthStencilDescriptor, depthCompareFunction: CompareFunction) {…}

DepthStencilDescriptor_setDepthWriteEnabled #

Source 
@(objc_type=DepthStencilDescriptor)
@(objc_name="setDepthWriteEnabled")
DepthStencilDescriptor_setDepthWriteEnabled :: proc "c" (self: ^DepthStencilDescriptor, depthWriteEnabled: bool) {…}

Device_areBarycentricCoordsSupported #

Source 
@(objc_type=Device)
@(objc_name="areBarycentricCoordsSupported")
Device_areBarycentricCoordsSupported :: proc "c" (self: ^Device) -> bool {…}

Device_areProgrammableSamplePositionsSupported #

Source 
@(objc_type=Device)
@(objc_name="areProgrammableSamplePositionsSupported")
Device_areProgrammableSamplePositionsSupported :: proc "c" (self: ^Device) -> bool {…}

Device_areRasterOrderGroupsSupported #

Source 
@(objc_type=Device)
@(objc_name="areRasterOrderGroupsSupported")
Device_areRasterOrderGroupsSupported :: proc "c" (self: ^Device) -> bool {…}

Device_convertSparseTileRegions #

Source 
@(objc_type=Device)
@(objc_name="convertSparseTileRegions")
Device_convertSparseTileRegions :: proc "c" (self: ^Device, tileRegions, pixelRegions: ^Region, tileSize: Size, numRegions: UInteger) {…}

Device_counterSets #

Source 
@(objc_type=Device)
@(objc_name="counterSets")
Device_counterSets :: proc "c" (self: ^Device) -> ^Array {…}

Device_currentAllocatedSize #

Source 
@(objc_type=Device)
@(objc_name="currentAllocatedSize")
Device_currentAllocatedSize :: proc "c" (self: ^Device) -> UInteger {…}

Device_getDefaultSamplePositions #

Source 
@(objc_type=Device)
@(objc_name="getDefaultSamplePositions")
Device_getDefaultSamplePositions :: proc "c" (self: ^Device, positions: []SamplePosition) {…}

Device_hasUnifiedMemory #

Source 
@(objc_type=Device)
@(objc_name="hasUnifiedMemory")
Device_hasUnifiedMemory :: proc "c" (self: ^Device) -> bool {…}

Device_heapBufferSizeAndAlignWithLength #

Source 
@(objc_type=Device)
@(objc_name="heapBufferSizeAndAlignWithLength")
Device_heapBufferSizeAndAlignWithLength :: proc "c" (self: ^Device, length: UInteger, options: ResourceOptions) -> (size, align: UInteger) {…}

Device_heapTextureSizeAndAlignWithDescriptor #

Source 
@(objc_type=Device)
@(objc_name="heapTextureSizeAndAlignWithDescriptor")
Device_heapTextureSizeAndAlignWithDescriptor :: proc "c" (self: ^Device, desc: ^TextureDescriptor) -> (size, align: UInteger) {…}

Device_isDepth24Stencil8PixelFormatSupported #

Source 
@(objc_type=Device)
@(objc_name="isDepth24Stencil8PixelFormatSupported")
Device_isDepth24Stencil8PixelFormatSupported :: proc "c" (self: ^Device) -> bool {…}

Device_isHeadless #

Source 
@(objc_type=Device)
@(objc_name="isHeadless")
Device_isHeadless :: proc "c" (self: ^Device) -> bool {…}

Device_isLowPower #

Source 
@(objc_type=Device)
@(objc_name="isLowPower")
Device_isLowPower :: proc "c" (self: ^Device) -> bool {…}

Device_isRemovable #

Source 
@(objc_type=Device)
@(objc_name="isRemovable")
Device_isRemovable :: proc "c" (self: ^Device) -> bool {…}

Device_locationNumber #

Source 
@(objc_type=Device)
@(objc_name="locationNumber")
Device_locationNumber :: proc "c" (self: ^Device) -> UInteger {…}

Device_maxArgumentBufferSamplerCount #

Source 
@(objc_type=Device)
@(objc_name="maxArgumentBufferSamplerCount")
Device_maxArgumentBufferSamplerCount :: proc "c" (self: ^Device) -> UInteger {…}

Device_maxBufferLength #

Source 
@(objc_type=Device)
@(objc_name="maxBufferLength")
Device_maxBufferLength :: proc "c" (self: ^Device) -> UInteger {…}

Device_maxThreadgroupMemoryLength #

Source 
@(objc_type=Device)
@(objc_name="maxThreadgroupMemoryLength")
Device_maxThreadgroupMemoryLength :: proc "c" (self: ^Device) -> UInteger {…}

Device_maxThreadsPerThreadgroup #

Source 
@(objc_type=Device)
@(objc_name="maxThreadsPerThreadgroup")
Device_maxThreadsPerThreadgroup :: proc "c" (self: ^Device) -> Size {…}

Device_maxTransferRate #

Source 
@(objc_type=Device)
@(objc_name="maxTransferRate")
Device_maxTransferRate :: proc "c" (self: ^Device) -> u64 {…}

Device_minimumLinearTextureAlignmentForPixelFormat #

Source 
@(objc_type=Device)
@(objc_name="minimumLinearTextureAlignmentForPixelFormat")
Device_minimumLinearTextureAlignmentForPixelFormat :: proc "c" (self: ^Device, format: PixelFormat) -> UInteger {…}

Device_minimumTextureBufferAlignmentForPixelFormat #

Source 
@(objc_type=Device)
@(objc_name="minimumTextureBufferAlignmentForPixelFormat")
Device_minimumTextureBufferAlignmentForPixelFormat :: proc "c" (self: ^Device, format: PixelFormat) -> UInteger {…}

Device_newArgumentEncoderWithArguments #

Source 
@(objc_type=Device)
@(objc_name="newArgumentEncoderWithArguments")
Device_newArgumentEncoderWithArguments :: proc "c" (self: ^Device, arguments: ^Array) -> ^ArgumentEncoder {…}

Device_newBufferWithSliceNoCopy #

Source 
@(objc_type=Device)
@(objc_name="newBufferWithSliceNoCopy")
Device_newBufferWithSliceNoCopy :: proc "c" (self: ^Device, slice: $S/[]$E, options: ResourceOptions, deallocator: rawptr) -> ^Buffer {…}

Device_newCommandQueueWithMaxCommandBufferCount #

Source 
@(objc_type=Device)
@(objc_name="newCommandQueueWithMaxCommandBufferCount")
Device_newCommandQueueWithMaxCommandBufferCount :: proc "c" (self: ^Device, maxCommandBufferCount: UInteger) -> ^CommandQueue {…}

Device_newComputePipelineStateWithFunction #

Source 
@(objc_type=Device)
@(objc_name="newComputePipelineStateWithFunction")
Device_newComputePipelineStateWithFunction :: proc "contextless" (self: ^Device, computeFunction: ^Function) -> (res: ^ComputePipelineState, error: ^Error) {…}

Device_newComputePipelineStateWithFunctionWithCompletionHandler #

Source 
@(objc_type=Device)
@(objc_name="newComputePipelineStateWithFunctionWithCompletionHandler")
Device_newComputePipelineStateWithFunctionWithCompletionHandler :: proc "c" (self: ^Device, computeFunction: ^Function, completionHandler: ^Block) -> ^ComputePipelineState {…}

Device_newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler #

Source 
@(objc_type=Device)
@(objc_name="newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler")
Device_newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler :: proc "c" (self: ^Device, computeFunction: ^Function, options: PipelineOption, completionHandler: ^Block) -> (res: ^ComputePipelineState) {…}

Device_newDefaultLibrary #

Source 
@(objc_type=Device)
@(objc_name="newDefaultLibrary")
Device_newDefaultLibrary :: proc "c" (self: ^Device) -> ^Library {…}

Device_newDefaultLibraryWithBundle #

Source 
@(objc_type=Device)
@(objc_name="newDefaultLibraryWithBundle")
Device_newDefaultLibraryWithBundle :: proc "contextless" (self: ^Device, bundle: ^Bundle) -> (library: ^Library, error: ^Error) {…}

Device_newDynamicLibraryWithURL #

Source 
@(objc_type=Device)
@(objc_name="newDynamicLibraryWithURL")
Device_newDynamicLibraryWithURL :: proc "contextless" (self: ^Device, url: ^URL) -> (dyn_library: ^DynamicLibrary, error: ^Error) {…}

Device_newEvent #

Source 
@(objc_type=Device)
@(objc_name="newEvent")
Device_newEvent :: proc "c" (self: ^Device) -> ^Event {…}

Device_newFence #

Source 
@(objc_type=Device)
@(objc_name="newFence")
Device_newFence :: proc "c" (self: ^Device) -> ^Fence {…}

Device_newLibraryWithData #

Source 
@(objc_type=Device)
@(objc_name="newLibraryWithData")
Device_newLibraryWithData :: proc "contextless" (self: ^Device, data: ^Object) -> (library: ^Library, error: ^Error) {…}

Device_newLibraryWithFile #

Source 
@(objc_type=Device)
@(objc_name="newLibraryWithFile")
Device_newLibraryWithFile :: proc "contextless" (self: ^Device, filepath: ^String) -> (library: ^Library, error: ^Error) {…}

Device_newLibraryWithSourceWithCompletionHandler #

Source 
@(objc_type=Device)
@(objc_name="newLibraryWithSourceWithCompletionHandler")
Device_newLibraryWithSourceWithCompletionHandler :: proc "c" (self: ^Device, source: ^String, options: ^CompileOptions, completionHandler: ^Block) -> ^Library {…}

Device_newLibraryWithURL #

Source 
@(objc_type=Device)
@(objc_name="newLibraryWithURL")
Device_newLibraryWithURL :: proc "contextless" (self: ^Device, url: ^URL) -> (library: ^Library, error: ^Error) {…}

Device_newRenderPipelineStateWithDescriptorWithCompletionHandler #

Source 
@(objc_type=Device)
@(objc_name="newRenderPipelineStateWithDescriptorWithCompletionHandler")
Device_newRenderPipelineStateWithDescriptorWithCompletionHandler :: proc "c" (self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: ^Block) -> ^RenderPipelineState {…}

Device_newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler #

Source 
@(objc_type=Device)
@(objc_name="newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler")
Device_newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler :: proc "c" (self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: ^Block) -> ^RenderPipelineState {…}

Device_newRenderPipelineStateWithMeshDescriptorAndCompletionHandler #

Source 
@(objc_type=Device)
@(objc_name="newRenderPipelineStateWithMeshDescriptorAndCompletionHandler")
Device_newRenderPipelineStateWithMeshDescriptorAndCompletionHandler :: proc "c" (self: ^Device, descriptor: ^MeshRenderPipelineDescriptor, options: PipelineOption, completionHandler: ^Block) {…}

Device_peerCount #

Source 
@(objc_type=Device)
@(objc_name="peerCount")
Device_peerCount :: proc "c" (self: ^Device) -> u32 {…}

Device_peerGroupID #

Source 
@(objc_type=Device)
@(objc_name="peerGroupID")
Device_peerGroupID :: proc "c" (self: ^Device) -> u64 {…}

Device_peerIndex #

Source 
@(objc_type=Device)
@(objc_name="peerIndex")
Device_peerIndex :: proc "c" (self: ^Device) -> u32 {…}

Device_recommendedMaxWorkingSetSize #

Source 
@(objc_type=Device)
@(objc_name="recommendedMaxWorkingSetSize")
Device_recommendedMaxWorkingSetSize :: proc "c" (self: ^Device) -> u64 {…}

Device_registryID #

Source 
@(objc_type=Device)
@(objc_name="registryID")
Device_registryID :: proc "c" (self: ^Device) -> u64 {…}

Device_sampleTimestamps #

Source 
@(objc_type=Device)
@(objc_name="sampleTimestamps")
Device_sampleTimestamps :: proc "c" (self: ^Device, cpuTimestamp: ^Timestamp, gpuTimestamp: ^Timestamp) {…}

Device_sparseTileSizeInBytes #

Source 
@(objc_type=Device)
@(objc_name="sparseTileSizeInBytes")
Device_sparseTileSizeInBytes :: proc "c" (self: ^Device) -> UInteger {…}

Device_supports32BitFloatFiltering #

Source 
@(objc_type=Device)
@(objc_name="supports32BitFloatFiltering")
Device_supports32BitFloatFiltering :: proc "c" (self: ^Device) -> bool {…}

Device_supports32BitMSAA #

Source 
@(objc_type=Device)
@(objc_name="supports32BitMSAA")
Device_supports32BitMSAA :: proc "c" (self: ^Device) -> bool {…}

Device_supportsBCTextureCompression #

Source 
@(objc_type=Device)
@(objc_name="supportsBCTextureCompression")
Device_supportsBCTextureCompression :: proc "c" (self: ^Device) -> bool {…}

Device_supportsDynamicLibraries #

Source 
@(objc_type=Device)
@(objc_name="supportsDynamicLibraries")
Device_supportsDynamicLibraries :: proc "c" (self: ^Device) -> bool {…}

Device_supportsFamily #

Source 
@(objc_type=Device)
@(objc_name="supportsFamily")
Device_supportsFamily :: proc "c" (self: ^Device, gpuFamily: GPUFamily) -> bool {…}

Device_supportsFeatureSet #

Source 
@(objc_type=Device)
@(objc_name="supportsFeatureSet")
Device_supportsFeatureSet :: proc "c" (self: ^Device, featureSet: FeatureSet) -> bool {…}

Device_supportsFunctionPointers #

Source 
@(objc_type=Device)
@(objc_name="supportsFunctionPointers")
Device_supportsFunctionPointers :: proc "c" (self: ^Device) -> bool {…}

Device_supportsPullModelInterpolation #

Source 
@(objc_type=Device)
@(objc_name="supportsPullModelInterpolation")
Device_supportsPullModelInterpolation :: proc "c" (self: ^Device) -> bool {…}

Device_supportsQueryTextureLOD #

Source 
@(objc_type=Device)
@(objc_name="supportsQueryTextureLOD")
Device_supportsQueryTextureLOD :: proc "c" (self: ^Device) -> bool {…}

Device_supportsRasterizationRateMapWithLayerCount #

Source 
@(objc_type=Device)
@(objc_name="supportsRasterizationRateMapWithLayerCount")
Device_supportsRasterizationRateMapWithLayerCount :: proc "c" (self: ^Device, layerCount: UInteger) -> bool {…}

Device_supportsRaytracing #

Source 
@(objc_type=Device)
@(objc_name="supportsRaytracing")
Device_supportsRaytracing :: proc "c" (self: ^Device) -> bool {…}

Device_supportsShaderBarycentricCoordinates #

Source 
@(objc_type=Device)
@(objc_name="supportsShaderBarycentricCoordinates")
Device_supportsShaderBarycentricCoordinates :: proc "c" (self: ^Device) -> bool {…}

Device_supportsTextureSampleCount #

Source 
@(objc_type=Device)
@(objc_name="supportsTextureSampleCount")
Device_supportsTextureSampleCount :: proc "c" (self: ^Device, sampleCount: UInteger) -> bool {…}

Device_supportsVertexAmplificationCount #

Source 
@(objc_type=Device)
@(objc_name="supportsVertexAmplificationCount")
Device_supportsVertexAmplificationCount :: proc "c" (self: ^Device, count: UInteger) -> bool {…}

Drawable_addPresentedHandler #

Source 
@(objc_type=Drawable)
@(objc_name="addPresentedHandler")
Drawable_addPresentedHandler :: proc "c" (self: ^Drawable, block: ^Block) {…}

Drawable_present #

Source 
@(objc_type=Drawable)
@(objc_name="present")
Drawable_present :: proc "c" (self: ^Drawable) {…}

Drawable_presentAfterMinimumDuration #

Source 
@(objc_type=Drawable)
@(objc_name="presentAfterMinimumDuration")
Drawable_presentAfterMinimumDuration :: proc "c" (self: ^Drawable, duration: TimeInterval) {…}

Drawable_presentAtTime #

Source 
@(objc_type=Drawable)
@(objc_name="presentAtTime")
Drawable_presentAtTime :: proc "c" (self: ^Drawable, presentationTime: TimeInterval) {…}

DynamicLibrary_installName #

Source 
@(objc_type=DynamicLibrary)
@(objc_name="installName")
DynamicLibrary_installName :: proc "c" (self: ^DynamicLibrary) -> ^String {…}

DynamicLibrary_serializeToURL #

Source 
@(objc_type=DynamicLibrary)
@(objc_name="serializeToURL")
DynamicLibrary_serializeToURL :: proc "contextless" (self: ^DynamicLibrary, url: ^URL) -> (ok: bool, error: ^Error) {…}

Event_setLabel #

Source 
@(objc_type=Event)
@(objc_name="setLabel")
Event_setLabel :: proc "c" (self: ^Event, label: ^String) {…}

Fence_setLabel #

Source 
@(objc_type=Fence)
@(objc_name="setLabel")
Fence_setLabel :: proc "c" (self: ^Fence, label: ^String) {…}

Function_functionConstantsDictionary #

Source 
@(objc_type=Function)
@(objc_name="functionConstantsDictionary")
Function_functionConstantsDictionary :: proc "c" (self: ^Function) -> ^Dictionary {…}

Function_newArgumentEncoderWithReflection #

Source 
@(objc_type=Function)
@(objc_name="newArgumentEncoderWithReflection")
Function_newArgumentEncoderWithReflection :: proc "c" (self: ^Function, bufferIndex: UInteger, reflection: ^^Argument) -> ^ArgumentEncoder {…}

Function_patchControlPointCount #

Source 
@(objc_type=Function)
@(objc_name="patchControlPointCount")
Function_patchControlPointCount :: proc "c" (self: ^Function) -> UInteger {…}

Function_setLabel #

Source 
@(objc_type=Function)
@(objc_name="setLabel")
Function_setLabel :: proc "c" (self: ^Function, label: ^String) {…}

Function_stageInputAttributes #

Source 
@(objc_type=Function)
@(objc_name="stageInputAttributes")
Function_stageInputAttributes :: proc "c" (self: ^Function) -> ^Array {…}

Function_vertexAttributes #

Source 
@(objc_type=Function)
@(objc_name="vertexAttributes")
Function_vertexAttributes :: proc "c" (self: ^Function) -> ^Array {…}

FunctionConstant_alloc #

Source 
@(objc_type=FunctionConstant)
@(objc_name="alloc")
@(objc_is_class_method=true)
FunctionConstant_alloc :: proc "c" () -> ^FunctionConstant {…}

FunctionConstantValues_alloc #

Source 
@(objc_type=FunctionConstantValues)
@(objc_name="alloc")
@(objc_is_class_method=true)
FunctionConstantValues_alloc :: proc "c" () -> ^FunctionConstantValues {…}

FunctionDescriptor_alloc #

Source 
@(objc_type=FunctionDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
FunctionDescriptor_alloc :: proc "c" () -> ^FunctionDescriptor {…}

FunctionDescriptor_functionDescriptor #

Source 
@(objc_type=FunctionDescriptor)
@(objc_name="functionDescriptor")
@(objc_is_class_method=true)
FunctionDescriptor_functionDescriptor :: proc "c" () -> ^FunctionDescriptor {…}

FunctionDescriptor_setSpecializedName #

Source 
@(objc_type=FunctionDescriptor)
@(objc_name="setSpecializedName")
FunctionDescriptor_setSpecializedName :: proc "c" (self: ^FunctionDescriptor, specializedName: ^String) {…}

FunctionDescriptor_specializedName #

Source 
@(objc_type=FunctionDescriptor)
@(objc_name="specializedName")
FunctionDescriptor_specializedName :: proc "c" (self: ^FunctionDescriptor) -> ^String {…}

FunctionLog_encoderLabel #

Source 
@(objc_type=FunctionLog)
@(objc_name="encoderLabel")
FunctionLog_encoderLabel :: proc "c" (self: ^FunctionLog) -> ^String {…}

Heap_currentAllocatedSize #

Source 
@(objc_type=Heap)
@(objc_name="currentAllocatedSize")
Heap_currentAllocatedSize :: proc "c" (self: ^Heap) -> UInteger {…}

Heap_maxAvailableSizeWithAlignment #

Source 
@(objc_type=Heap)
@(objc_name="maxAvailableSizeWithAlignment")
Heap_maxAvailableSizeWithAlignment :: proc "c" (self: ^Heap, alignment: UInteger) -> UInteger {…}

Heap_newAccelerationStructureWithSizeAndOffset #

Source 
@(objc_type=Heap)
@(objc_name="newAccelerationStructureWithSizeAndOffset")
Heap_newAccelerationStructureWithSizeAndOffset :: proc "c" (self: ^Heap, size, offset: UInteger) -> ^AccelerationStructure {…}

Heap_setLabel #

Source 
@(objc_type=Heap)
@(objc_name="setLabel")
Heap_setLabel :: proc "c" (self: ^Heap, label: ^String) {…}

HeapDescriptor_alloc #

Source 
@(objc_type=HeapDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
HeapDescriptor_alloc :: proc "c" () -> ^HeapDescriptor {…}

HeapDescriptor_setCpuCacheMode #

Source 
@(objc_type=HeapDescriptor)
@(objc_name="setCpuCacheMode")
HeapDescriptor_setCpuCacheMode :: proc "c" (self: ^HeapDescriptor, cpuCacheMode: CPUCacheMode) {…}

HeapDescriptor_setHazardTrackingMode #

Source 
@(objc_type=HeapDescriptor)
@(objc_name="setHazardTrackingMode")
HeapDescriptor_setHazardTrackingMode :: proc "c" (self: ^HeapDescriptor, hazardTrackingMode: HazardTrackingMode) {…}

HeapDescriptor_setResourceOptions #

Source 
@(objc_type=HeapDescriptor)
@(objc_name="setResourceOptions")
HeapDescriptor_setResourceOptions :: proc "c" (self: ^HeapDescriptor, resourceOptions: ResourceOptions) {…}

HeapDescriptor_setSparsePageSize #

Source 
@(objc_type=HeapDescriptor)
@(objc_name="setSparsePageSize")
HeapDescriptor_setSparsePageSize :: proc "c" (self: ^HeapDescriptor, sparsePageSize: SparsePageSize) {…}

HeapDescriptor_setStorageMode #

Source 
@(objc_type=HeapDescriptor)
@(objc_name="setStorageMode")
HeapDescriptor_setStorageMode :: proc "c" (self: ^HeapDescriptor, storageMode: StorageMode) {…}

IndirectCommandBuffer_resetWithRange #

Source 
@(objc_type=IndirectCommandBuffer)
@(objc_name="resetWithRange")
IndirectCommandBuffer_resetWithRange :: proc "c" (self: ^IndirectCommandBuffer, range: Range) {…}

IndirectCommandBuffer_setSupportRayTracing #

Source 
@(objc_type=IndirectCommandBuffer)
@(objc_name="setSupportRayTracing")
IndirectCommandBuffer_setSupportRayTracing :: proc "c" (self: ^IndirectCommandBuffer, supportRayTracing: bool) {…}

IndirectCommandBuffer_supportRayTracing #

Source 
@(objc_type=IndirectCommandBuffer)
@(objc_name="supportRayTracing")
IndirectCommandBuffer_supportRayTracing :: proc "c" (self: ^IndirectCommandBuffer) -> bool {…}

IndirectCommandBufferDescriptor_alloc #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
IndirectCommandBufferDescriptor_alloc :: proc "c" () -> ^IndirectCommandBufferDescriptor {…}

IndirectCommandBufferDescriptor_inheritBuffers #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="inheritBuffers")
IndirectCommandBufferDescriptor_inheritBuffers :: proc "c" (self: ^IndirectCommandBufferDescriptor) -> bool {…}

IndirectCommandBufferDescriptor_inheritPipelineState #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="inheritPipelineState")
IndirectCommandBufferDescriptor_inheritPipelineState :: proc "c" (self: ^IndirectCommandBufferDescriptor) -> bool {…}

IndirectCommandBufferDescriptor_maxFragmentBufferBindCount #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="maxFragmentBufferBindCount")
IndirectCommandBufferDescriptor_maxFragmentBufferBindCount :: proc "c" (self: ^IndirectCommandBufferDescriptor) -> UInteger {…}

IndirectCommandBufferDescriptor_maxKernelBufferBindCount #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="maxKernelBufferBindCount")
IndirectCommandBufferDescriptor_maxKernelBufferBindCount :: proc "c" (self: ^IndirectCommandBufferDescriptor) -> UInteger {…}

IndirectCommandBufferDescriptor_maxVertexBufferBindCount #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="maxVertexBufferBindCount")
IndirectCommandBufferDescriptor_maxVertexBufferBindCount :: proc "c" (self: ^IndirectCommandBufferDescriptor) -> UInteger {…}

IndirectCommandBufferDescriptor_setInheritBuffers #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="setInheritBuffers")
IndirectCommandBufferDescriptor_setInheritBuffers :: proc "c" (self: ^IndirectCommandBufferDescriptor, inheritBuffers: bool) {…}

IndirectCommandBufferDescriptor_setInheritPipelineState #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="setInheritPipelineState")
IndirectCommandBufferDescriptor_setInheritPipelineState :: proc "c" (self: ^IndirectCommandBufferDescriptor, inheritPipelineState: bool) {…}

IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="setMaxFragmentBufferBindCount")
IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount :: proc "c" (self: ^IndirectCommandBufferDescriptor, maxFragmentBufferBindCount: UInteger) {…}

IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="setMaxKernelBufferBindCount")
IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount :: proc "c" (self: ^IndirectCommandBufferDescriptor, maxKernelBufferBindCount: UInteger) {…}

IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount #

Source 
@(objc_type=IndirectCommandBufferDescriptor)
@(objc_name="setMaxVertexBufferBindCount")
IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount :: proc "c" (self: ^IndirectCommandBufferDescriptor, maxVertexBufferBindCount: UInteger) {…}

IndirectComputeCommand_clearBarrier #

Source 
@(objc_type=IndirectComputeCommand)
@(objc_name="clearBarrier")
IndirectComputeCommand_clearBarrier :: proc "c" (self: ^IndirectComputeCommand) {…}

IndirectComputeCommand_concurrentDispatchThreadgroups #

Source 
@(objc_type=IndirectComputeCommand)
@(objc_name="concurrentDispatchThreadgroups")
IndirectComputeCommand_concurrentDispatchThreadgroups :: proc "c" (self: ^IndirectComputeCommand, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) {…}

IndirectComputeCommand_concurrentDispatchThreads #

Source 
@(objc_type=IndirectComputeCommand)
@(objc_name="concurrentDispatchThreads")
IndirectComputeCommand_concurrentDispatchThreads :: proc "c" (self: ^IndirectComputeCommand, threadsPerGrid: Size, threadsPerThreadgroup: Size) {…}

IndirectComputeCommand_setBarrier #

Source 
@(objc_type=IndirectComputeCommand)
@(objc_name="setBarrier")
IndirectComputeCommand_setBarrier :: proc "c" (self: ^IndirectComputeCommand) {…}

IndirectComputeCommand_setStageInRegion #

Source 
@(objc_type=IndirectComputeCommand)
@(objc_name="setStageInRegion")
IndirectComputeCommand_setStageInRegion :: proc "c" (self: ^IndirectComputeCommand, region: Region) {…}

IndirectComputeCommand_setThreadgroupMemoryLength #

Source 
@(objc_type=IndirectComputeCommand)
@(objc_name="setThreadgroupMemoryLength")
IndirectComputeCommand_setThreadgroupMemoryLength :: proc "c" (self: ^IndirectComputeCommand, length: UInteger, index: UInteger) {…}

IndirectRenderCommand_drawIndexedPatches #

Source 
@(objc_type=IndirectRenderCommand)
@(objc_name="drawIndexedPatches")
IndirectRenderCommand_drawIndexedPatches :: proc "c" (
	self:                          ^IndirectRenderCommand, 
	numberOfPatchControlPoints:    UInteger, 
	patchStart, patchCount:        UInteger, 
	patchIndexBuffer:              ^Buffer, 
	patchIndexBufferOffset:        UInteger, 
	controlPointIndexBuffer:       ^Buffer, 
	controlPointIndexBufferOffset: UInteger, 
	instanceCount:                 UInteger, 
	baseInstance:                  UInteger, 
	buffer:                        ^Buffer, 
	offset:                        UInteger, 
	instanceStride:                UInteger, 
) {…}

InstanceAccelerationStructureDescriptor_alloc #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
InstanceAccelerationStructureDescriptor_alloc :: proc "c" () -> ^InstanceAccelerationStructureDescriptor {…}

InstanceAccelerationStructureDescriptor_descriptor #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="descriptor")
@(objc_is_class_method=true)
InstanceAccelerationStructureDescriptor_descriptor :: proc "c" () -> ^InstanceAccelerationStructureDescriptor {…}

InstanceAccelerationStructureDescriptor_instancedAccelerationStructures #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="instancedAccelerationStructures")
InstanceAccelerationStructureDescriptor_instancedAccelerationStructures :: proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> ^Array {…}

InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="instanceDescriptorBuffer")
InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> ^Buffer {…}

InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="instanceDescriptorBufferOffset")
InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> UInteger {…}

InstanceAccelerationStructureDescriptor_instanceDescriptorStride #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="instanceDescriptorStride")
InstanceAccelerationStructureDescriptor_instanceDescriptorStride :: proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> UInteger {…}

InstanceAccelerationStructureDescriptor_motionTransformBuffer #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="motionTransformBuffer")
InstanceAccelerationStructureDescriptor_motionTransformBuffer :: proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> ^Buffer {…}

InstanceAccelerationStructureDescriptor_motionTransformBufferOffset #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="motionTransformBufferOffset")
InstanceAccelerationStructureDescriptor_motionTransformBufferOffset :: proc "c" (self: ^InstanceAccelerationStructureDescriptor) -> UInteger {…}

InstanceAccelerationStructureDescriptor_setInstancedAccelerationStructures #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="setInstancedAccelerationStructures")
InstanceAccelerationStructureDescriptor_setInstancedAccelerationStructures :: proc "c" (self: ^InstanceAccelerationStructureDescriptor, instancedAccelerationStructures: ^Array) {…}

InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="setInstanceDescriptorBuffer")
InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer :: proc "c" (self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBuffer: ^Buffer) {…}

InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="setInstanceDescriptorBufferOffset")
InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset :: proc "c" (self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBufferOffset: UInteger) {…}

InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="setInstanceDescriptorStride")
InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride :: proc "c" (self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorStride: UInteger) {…}

InstanceAccelerationStructureDescriptor_setMotionTransformBuffer #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="setMotionTransformBuffer")
InstanceAccelerationStructureDescriptor_setMotionTransformBuffer :: proc "c" (self: ^InstanceAccelerationStructureDescriptor, buffer: ^Buffer) {…}

InstanceAccelerationStructureDescriptor_setMotionTransformBufferOffset #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="setMotionTransformBufferOffset")
InstanceAccelerationStructureDescriptor_setMotionTransformBufferOffset :: proc "c" (self: ^InstanceAccelerationStructureDescriptor, offset: UInteger) {…}

InstanceAccelerationStructureDescriptor_setMotionTransformCount #

Source 
@(objc_type=InstanceAccelerationStructureDescriptor)
@(objc_name="setMotionTransformCount")
InstanceAccelerationStructureDescriptor_setMotionTransformCount :: proc "c" (self: ^InstanceAccelerationStructureDescriptor, offset: UInteger) {…}

IntersectionFunctionDescriptor_alloc #

Source 
@(objc_type=IntersectionFunctionDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
IntersectionFunctionDescriptor_alloc :: proc "c" () -> ^IntersectionFunctionDescriptor {…}

IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature #

Source 
@(objc_type=IntersectionFunctionTable)
@(objc_name="setOpaqueTriangleIntersectionFunctionWithSignature")
IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature :: proc "c" (self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: UInteger) {…}

IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignatureWithRange #

Source 
@(objc_type=IntersectionFunctionTable)
@(objc_name="setOpaqueTriangleIntersectionFunctionWithSignatureWithRange")
IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignatureWithRange :: proc "c" (self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, range: Range) {…}

IntersectionFunctionTableDescriptor_alloc #

Source 
@(objc_type=IntersectionFunctionTableDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
IntersectionFunctionTableDescriptor_alloc :: proc "c" () -> ^IntersectionFunctionTableDescriptor {…}

IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor #

Source 
@(objc_type=IntersectionFunctionTableDescriptor)
@(objc_name="intersectionFunctionTableDescriptor")
@(objc_is_class_method=true)
IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor :: proc "c" () -> ^IntersectionFunctionTableDescriptor {…}

IOCommandBuffer_addBarrier #

Source 
@(objc_type=IOCommandBuffer)
@(objc_name="addBarrier")
IOCommandBuffer_addBarrier :: proc "c" (self: ^IOCommandBuffer) {…}

IOCommandBuffer_addCompletedHandler #

Source 
@(objc_type=IOCommandBuffer)
@(objc_name="addCompletedHandler")
IOCommandBuffer_addCompletedHandler :: proc "c" (self: ^IOCommandBuffer, block: ^Block) {…}

IOCommandBuffer_commit #

Source 
@(objc_type=IOCommandBuffer)
@(objc_name="commit")
IOCommandBuffer_commit :: proc "c" (self: ^IOCommandBuffer) {…}

IOCommandBuffer_copyStatusToBuffer #

Source 
@(objc_type=IOCommandBuffer)
@(objc_name="copyStatusToBuffer")
IOCommandBuffer_copyStatusToBuffer :: proc "c" (self: ^IOCommandBuffer, buffer: ^Buffer, offset: UInteger) {…}

IOCommandBuffer_enqueue #

Source 
@(objc_type=IOCommandBuffer)
@(objc_name="enqueue")
IOCommandBuffer_enqueue :: proc "c" (self: ^IOCommandBuffer) {…}

IOCommandBuffer_popDebugGroup #

Source 
@(objc_type=IOCommandBuffer)
@(objc_name="popDebugGroup")
IOCommandBuffer_popDebugGroup :: proc "c" (self: ^IOCommandBuffer) {…}

IOCommandBuffer_pushDebugGroup #

Source 
@(objc_type=IOCommandBuffer)
@(objc_name="pushDebugGroup")
IOCommandBuffer_pushDebugGroup :: proc "c" (self: ^IOCommandBuffer, name: ^String) {…}

IOCommandBuffer_tryCancel #

Source 
@(objc_type=IOCommandBuffer)
@(objc_name="tryCancel")
IOCommandBuffer_tryCancel :: proc "c" (self: ^IOCommandBuffer) {…}

IOCommandBuffer_waitUntilCompleted #

Source 
@(objc_type=IOCommandBuffer)
@(objc_name="waitUntilCompleted")
IOCommandBuffer_waitUntilCompleted :: proc "c" (self: ^IOCommandBuffer) {…}

IOCommandQueue_commandBufferWithUnretainedReferences #

Source 
@(objc_type=IOCommandQueue)
@(objc_name="commandBufferWithUnretainedReferences")
IOCommandQueue_commandBufferWithUnretainedReferences :: proc "c" (self: ^IOCommandQueue) -> ^IOCommandBuffer {…}

IOCommandQueue_enqueueBarrier #

Source 
@(objc_type=IOCommandQueue)
@(objc_name="enqueueBarrier")
IOCommandQueue_enqueueBarrier :: proc "c" (self: ^IOCommandQueue) {…}

IOCommandQueueDescriptor_alloc #

Source 
@(objc_type=IOCommandQueueDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
IOCommandQueueDescriptor_alloc :: proc "c" () -> ^IOCommandQueueDescriptor {…}

IOCommandQueueDescriptor_maxCommandBufferCount #

Source 
@(objc_type=IOCommandQueueDescriptor)
@(objc_name="maxCommandBufferCount")
IOCommandQueueDescriptor_maxCommandBufferCount :: proc "c" (self: ^IOCommandQueueDescriptor) -> UInteger {…}

IOCompressionContextDefaultChunkSize #

Source 
IOCompressionContextDefaultChunkSize :: proc "c" () -> uint ---

Library_functionNames #

Source 
@(objc_type=Library)
@(objc_name="functionNames")
Library_functionNames :: proc "c" (self: ^Library) -> ^Array {…}

Library_installName #

Source 
@(objc_type=Library)
@(objc_name="installName")
Library_installName :: proc "c" (self: ^Library) -> ^String {…}

Library_newFunctionWithCompletionHandler #

Source 
@(objc_type=Library)
@(objc_name="newFunctionWithCompletionHandler")
Library_newFunctionWithCompletionHandler :: proc "c" (self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: ^Block) -> ^Function {…}

Library_newFunctionWithConstantValuesAndCompletionHandler #

Source 
@(objc_type=Library)
@(objc_name="newFunctionWithConstantValuesAndCompletionHandler")
Library_newFunctionWithConstantValuesAndCompletionHandler :: proc "c" (self: ^Library, name: ^String, constantValues: ^FunctionConstantValues, completionHandler: ^Block) -> ^Function {…}

Library_newFunctionWithName #

Source 
@(objc_type=Library)
@(objc_name="newFunctionWithName")
Library_newFunctionWithName :: proc "c" (self: ^Library, functionName: ^String) -> ^Function {…}

Library_setLabel #

Source 
@(objc_type=Library)
@(objc_name="setLabel")
Library_setLabel :: proc "c" (self: ^Library, label: ^String) {…}

LinkedFunctions_alloc #

Source 
@(objc_type=LinkedFunctions)
@(objc_name="alloc")
@(objc_is_class_method=true)
LinkedFunctions_alloc :: proc "c" () -> ^LinkedFunctions {…}

LinkedFunctions_binaryFunctions #

Source 
@(objc_type=LinkedFunctions)
@(objc_name="binaryFunctions")
LinkedFunctions_binaryFunctions :: proc "c" (self: ^LinkedFunctions) -> ^Array {…}

LinkedFunctions_linkedFunctions #

Source 
@(objc_type=LinkedFunctions)
@(objc_name="linkedFunctions")
@(objc_is_class_method=true)
LinkedFunctions_linkedFunctions :: proc "c" () -> ^LinkedFunctions {…}

LinkedFunctions_setBinaryFunctions #

Source 
@(objc_type=LinkedFunctions)
@(objc_name="setBinaryFunctions")
LinkedFunctions_setBinaryFunctions :: proc "c" (self: ^LinkedFunctions, binaryFunctions: ^Array) {…}

LinkedFunctions_setFunctions #

Source 
@(objc_type=LinkedFunctions)
@(objc_name="setFunctions")
LinkedFunctions_setFunctions :: proc "c" (self: ^LinkedFunctions, functions: ^Array) {…}

MeshRenderPipelineDescriptor_alloc #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
MeshRenderPipelineDescriptor_alloc :: proc "c" () -> ^MeshRenderPipelineDescriptor {…}

MeshRenderPipelineDescriptor_alphaToCoverageEnabled #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="alphaToCoverageEnabled")
MeshRenderPipelineDescriptor_alphaToCoverageEnabled :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> bool {…}

MeshRenderPipelineDescriptor_alphaToOneEnabled #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="alphaToOneEnabled")
MeshRenderPipelineDescriptor_alphaToOneEnabled :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> bool {…}

MeshRenderPipelineDescriptor_binaryArchives #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="binaryArchives")
MeshRenderPipelineDescriptor_binaryArchives :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> ^Array {…}

MeshRenderPipelineDescriptor_depthAttachmentPixelFormat #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="depthAttachmentPixelFormat")
MeshRenderPipelineDescriptor_depthAttachmentPixelFormat :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> PixelFormat {…}

MeshRenderPipelineDescriptor_isAlphaToCoverageEnabled #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="isAlphaToCoverageEnabled")
MeshRenderPipelineDescriptor_isAlphaToCoverageEnabled :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> bool {…}

MeshRenderPipelineDescriptor_isAlphaToOneEnabled #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="isAlphaToOneEnabled")
MeshRenderPipelineDescriptor_isAlphaToOneEnabled :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> bool {…}

MeshRenderPipelineDescriptor_isRasterizationEnabled #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="isRasterizationEnabled")
MeshRenderPipelineDescriptor_isRasterizationEnabled :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> bool {…}

MeshRenderPipelineDescriptor_maxTotalThreadgroupsPerMeshGrid #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="maxTotalThreadgroupsPerMeshGrid")
MeshRenderPipelineDescriptor_maxTotalThreadgroupsPerMeshGrid :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> UInteger {…}

MeshRenderPipelineDescriptor_maxTotalThreadsPerMeshThreadgroup #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="maxTotalThreadsPerMeshThreadgroup")
MeshRenderPipelineDescriptor_maxTotalThreadsPerMeshThreadgroup :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> UInteger {…}

MeshRenderPipelineDescriptor_maxTotalThreadsPerObjectThreadgroup #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="maxTotalThreadsPerObjectThreadgroup")
MeshRenderPipelineDescriptor_maxTotalThreadsPerObjectThreadgroup :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> UInteger {…}

MeshRenderPipelineDescriptor_maxVertexAmplificationCount #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="maxVertexAmplificationCount")
MeshRenderPipelineDescriptor_maxVertexAmplificationCount :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> UInteger {…}

MeshRenderPipelineDescriptor_meshThreadgroupSizeIsMultipleOfThreadExecutionWidth #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="meshThreadgroupSizeIsMultipleOfThreadExecutionWidth")
MeshRenderPipelineDescriptor_meshThreadgroupSizeIsMultipleOfThreadExecutionWidth :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> bool {…}

MeshRenderPipelineDescriptor_objectThreadgroupSizeIsMultipleOfThreadExecutionWidth #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="objectThreadgroupSizeIsMultipleOfThreadExecutionWidth")
MeshRenderPipelineDescriptor_objectThreadgroupSizeIsMultipleOfThreadExecutionWidth :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> bool {…}

MeshRenderPipelineDescriptor_payloadMemoryLength #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="payloadMemoryLength")
MeshRenderPipelineDescriptor_payloadMemoryLength :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> UInteger {…}

MeshRenderPipelineDescriptor_rasterizationEnabled #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="rasterizationEnabled")
MeshRenderPipelineDescriptor_rasterizationEnabled :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> bool {…}

MeshRenderPipelineDescriptor_setAlphaToCoverageEnabled #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setAlphaToCoverageEnabled")
MeshRenderPipelineDescriptor_setAlphaToCoverageEnabled :: proc "c" (self: ^MeshRenderPipelineDescriptor, alphaToCoverageEnabled: bool) {…}

MeshRenderPipelineDescriptor_setAlphaToOneEnabled #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setAlphaToOneEnabled")
MeshRenderPipelineDescriptor_setAlphaToOneEnabled :: proc "c" (self: ^MeshRenderPipelineDescriptor, alphaToOneEnabled: bool) {…}

MeshRenderPipelineDescriptor_setBinaryArchives #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setBinaryArchives")
MeshRenderPipelineDescriptor_setBinaryArchives :: proc "c" (self: ^MeshRenderPipelineDescriptor, binaryArchives: ^Array) {…}

MeshRenderPipelineDescriptor_setDepthAttachmentPixelFormat #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setDepthAttachmentPixelFormat")
MeshRenderPipelineDescriptor_setDepthAttachmentPixelFormat :: proc "c" (self: ^MeshRenderPipelineDescriptor, depthAttachmentPixelFormat: PixelFormat) {…}

MeshRenderPipelineDescriptor_setFragmentFunction #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setFragmentFunction")
MeshRenderPipelineDescriptor_setFragmentFunction :: proc "c" (self: ^MeshRenderPipelineDescriptor, fragmentFunction: ^Function) {…}

MeshRenderPipelineDescriptor_setFragmentLinkedFunctions #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setFragmentLinkedFunctions")
MeshRenderPipelineDescriptor_setFragmentLinkedFunctions :: proc "c" (self: ^MeshRenderPipelineDescriptor, fragmentLinkedFunctions: ^LinkedFunctions) {…}

MeshRenderPipelineDescriptor_setMaxTotalThreadgroupsPerMeshGrid #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setMaxTotalThreadgroupsPerMeshGrid")
MeshRenderPipelineDescriptor_setMaxTotalThreadgroupsPerMeshGrid :: proc "c" (self: ^MeshRenderPipelineDescriptor, maxTotalThreadgroupsPerMeshGrid: UInteger) {…}

MeshRenderPipelineDescriptor_setMaxTotalThreadsPerMeshThreadgroup #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setMaxTotalThreadsPerMeshThreadgroup")
MeshRenderPipelineDescriptor_setMaxTotalThreadsPerMeshThreadgroup :: proc "c" (self: ^MeshRenderPipelineDescriptor, maxTotalThreadsPerMeshThreadgroup: UInteger) {…}

MeshRenderPipelineDescriptor_setMaxTotalThreadsPerObjectThreadgroup #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setMaxTotalThreadsPerObjectThreadgroup")
MeshRenderPipelineDescriptor_setMaxTotalThreadsPerObjectThreadgroup :: proc "c" (self: ^MeshRenderPipelineDescriptor, maxTotalThreadsPerObjectThreadgroup: UInteger) {…}

MeshRenderPipelineDescriptor_setMaxVertexAmplificationCount #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setMaxVertexAmplificationCount")
MeshRenderPipelineDescriptor_setMaxVertexAmplificationCount :: proc "c" (self: ^MeshRenderPipelineDescriptor, maxVertexAmplificationCount: UInteger) {…}

MeshRenderPipelineDescriptor_setMeshFunction #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setMeshFunction")
MeshRenderPipelineDescriptor_setMeshFunction :: proc "c" (self: ^MeshRenderPipelineDescriptor, meshFunction: ^Function) {…}

MeshRenderPipelineDescriptor_setMeshLinkedFunctions #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setMeshLinkedFunctions")
MeshRenderPipelineDescriptor_setMeshLinkedFunctions :: proc "c" (self: ^MeshRenderPipelineDescriptor, meshLinkedFunctions: ^LinkedFunctions) {…}

MeshRenderPipelineDescriptor_setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth")
MeshRenderPipelineDescriptor_setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth :: proc "c" (self: ^MeshRenderPipelineDescriptor, meshThreadgroupSizeIsMultipleOfThreadExecutionWidth: bool) {…}

MeshRenderPipelineDescriptor_setObjectFunction #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setObjectFunction")
MeshRenderPipelineDescriptor_setObjectFunction :: proc "c" (self: ^MeshRenderPipelineDescriptor, objectFunction: ^Function) {…}

MeshRenderPipelineDescriptor_setObjectLinkedFunctions #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setObjectLinkedFunctions")
MeshRenderPipelineDescriptor_setObjectLinkedFunctions :: proc "c" (self: ^MeshRenderPipelineDescriptor, objectLinkedFunctions: ^LinkedFunctions) {…}

MeshRenderPipelineDescriptor_setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth")
MeshRenderPipelineDescriptor_setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth :: proc "c" (self: ^MeshRenderPipelineDescriptor, objectThreadgroupSizeIsMultipleOfThreadExecutionWidth: bool) {…}

MeshRenderPipelineDescriptor_setPayloadMemoryLength #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setPayloadMemoryLength")
MeshRenderPipelineDescriptor_setPayloadMemoryLength :: proc "c" (self: ^MeshRenderPipelineDescriptor, payloadMemoryLength: UInteger) {…}

MeshRenderPipelineDescriptor_setRasterizationEnabled #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setRasterizationEnabled")
MeshRenderPipelineDescriptor_setRasterizationEnabled :: proc "c" (self: ^MeshRenderPipelineDescriptor, rasterizationEnabled: bool) {…}

MeshRenderPipelineDescriptor_setRasterSampleCount #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setRasterSampleCount")
MeshRenderPipelineDescriptor_setRasterSampleCount :: proc "c" (self: ^MeshRenderPipelineDescriptor, rasterSampleCount: UInteger) {…}

MeshRenderPipelineDescriptor_setStencilAttachmentPixelFormat #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setStencilAttachmentPixelFormat")
MeshRenderPipelineDescriptor_setStencilAttachmentPixelFormat :: proc "c" (self: ^MeshRenderPipelineDescriptor, stencilAttachmentPixelFormat: PixelFormat) {…}

MeshRenderPipelineDescriptor_setSupportIndirectCommandBuffers #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="setSupportIndirectCommandBuffers")
MeshRenderPipelineDescriptor_setSupportIndirectCommandBuffers :: proc "c" (self: ^MeshRenderPipelineDescriptor, supportIndirectCommandBuffers: bool) {…}

MeshRenderPipelineDescriptor_stencilAttachmentPixelFormat #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="stencilAttachmentPixelFormat")
MeshRenderPipelineDescriptor_stencilAttachmentPixelFormat :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> PixelFormat {…}

MeshRenderPipelineDescriptor_supportIndirectCommandBuffers #

Source 
@(objc_type=MeshRenderPipelineDescriptor)
@(objc_name="supportIndirectCommandBuffers")
MeshRenderPipelineDescriptor_supportIndirectCommandBuffers :: proc "c" (self: ^MeshRenderPipelineDescriptor) -> bool {…}

MotionKeyframeData_alloc #

Source 
@(objc_type=MotionKeyframeData)
@(objc_name="alloc")
@(objc_is_class_method=true)
MotionKeyframeData_alloc :: proc "c" () -> ^MotionKeyframeData {…}

MotionKeyframeData_buffer #

Source 
@(objc_type=MotionKeyframeData)
@(objc_name="buffer")
@(objc_is_class_method=true)
MotionKeyframeData_buffer :: proc "c" (self: ^MotionKeyframeData) -> ^Buffer {…}

MotionKeyframeData_data #

Source 
@(objc_type=MotionKeyframeData)
@(objc_name="data")
@(objc_is_class_method=true)
MotionKeyframeData_data :: proc "c" () -> ^MotionKeyframeData {…}

MotionKeyframeData_offset #

Source 
@(objc_type=MotionKeyframeData)
@(objc_name="offset")
@(objc_is_class_method=true)
MotionKeyframeData_offset :: proc "c" (self: ^MotionKeyframeData) -> UInteger {…}

MotionKeyframeData_setBuffer #

Source 
@(objc_type=MotionKeyframeData)
@(objc_name="setBuffer")
@(objc_is_class_method=true)
MotionKeyframeData_setBuffer :: proc "c" (self: ^MotionKeyframeData, buffer: ^Buffer) {…}

MotionKeyframeData_setOffset #

Source 
@(objc_type=MotionKeyframeData)
@(objc_name="setOffset")
@(objc_is_class_method=true)
MotionKeyframeData_setOffset :: proc "c" (self: ^MotionKeyframeData, offset: UInteger) {…}

ObjectPayloadBinding_objectPayloadAlignment #

Source 
@(objc_type=ObjectPayloadBinding)
@(objc_name="objectPayloadAlignment")
ObjectPayloadBinding_objectPayloadAlignment :: proc "c" (self: ^ObjectPayloadBinding) -> UInteger {…}

ObjectPayloadBinding_objectPayloadDataSize #

Source 
@(objc_type=ObjectPayloadBinding)
@(objc_name="objectPayloadDataSize")
ObjectPayloadBinding_objectPayloadDataSize :: proc "c" (self: ^ObjectPayloadBinding) -> UInteger {…}

ParallelRenderCommandEncoder_setDepthStoreAction #

Source 
@(objc_type=ParallelRenderCommandEncoder)
@(objc_name="setDepthStoreAction")
ParallelRenderCommandEncoder_setDepthStoreAction :: proc "c" (self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) {…}

ParallelRenderCommandEncoder_setDepthStoreActionOptions #

Source 
@(objc_type=ParallelRenderCommandEncoder)
@(objc_name="setDepthStoreActionOptions")
ParallelRenderCommandEncoder_setDepthStoreActionOptions :: proc "c" (self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) {…}

ParallelRenderCommandEncoder_setStencilStoreAction #

Source 
@(objc_type=ParallelRenderCommandEncoder)
@(objc_name="setStencilStoreAction")
ParallelRenderCommandEncoder_setStencilStoreAction :: proc "c" (self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) {…}

ParallelRenderCommandEncoder_setStencilStoreActionOptions #

Source 
@(objc_type=ParallelRenderCommandEncoder)
@(objc_name="setStencilStoreActionOptions")
ParallelRenderCommandEncoder_setStencilStoreActionOptions :: proc "c" (self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) {…}

PipelineBufferDescriptor_alloc #

Source 
@(objc_type=PipelineBufferDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
PipelineBufferDescriptor_alloc :: proc "c" () -> ^PipelineBufferDescriptor {…}

PipelineBufferDescriptorArray_alloc #

Source 
@(objc_type=PipelineBufferDescriptorArray)
@(objc_name="alloc")
@(objc_is_class_method=true)
PipelineBufferDescriptorArray_alloc :: proc "c" () -> ^PipelineBufferDescriptorArray {…}

PointerType_alloc #

Source 
@(objc_type=PointerType)
@(objc_name="alloc")
@(objc_is_class_method=true)
PointerType_alloc :: proc "c" () -> ^PointerType {…}

PointerType_elementArrayType #

Source 
@(objc_type=PointerType)
@(objc_name="elementArrayType")
PointerType_elementArrayType :: proc "c" (self: ^PointerType) -> ^ArrayType {…}

PointerType_elementIsArgumentBuffer #

Source 
@(objc_type=PointerType)
@(objc_name="elementIsArgumentBuffer")
PointerType_elementIsArgumentBuffer :: proc "c" (self: ^PointerType) -> bool {…}

PointerType_elementStructType #

Source 
@(objc_type=PointerType)
@(objc_name="elementStructType")
PointerType_elementStructType :: proc "c" (self: ^PointerType) -> ^StructType {…}

PrimitiveAccelerationStructureDescriptor_alloc #

Source 
@(objc_type=PrimitiveAccelerationStructureDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
PrimitiveAccelerationStructureDescriptor_alloc :: proc "c" () -> ^PrimitiveAccelerationStructureDescriptor {…}

PrimitiveAccelerationStructureDescriptor_descriptor #

Source 
@(objc_type=PrimitiveAccelerationStructureDescriptor)
@(objc_name="descriptor")
@(objc_is_class_method=true)
PrimitiveAccelerationStructureDescriptor_descriptor :: proc "c" () -> ^PrimitiveAccelerationStructureDescriptor {…}

PrimitiveAccelerationStructureDescriptor_geometryDescriptors #

Source 
@(objc_type=PrimitiveAccelerationStructureDescriptor)
@(objc_name="geometryDescriptors")
PrimitiveAccelerationStructureDescriptor_geometryDescriptors :: proc "c" (self: ^PrimitiveAccelerationStructureDescriptor) -> ^Array {…}

PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors #

Source 
@(objc_type=PrimitiveAccelerationStructureDescriptor)
@(objc_name="setGeometryDescriptors")
PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, geometryDescriptors: ^Array) {…}

PrimitiveAccelerationStructureDescriptor_setMotionEndTime #

Source 
@(objc_type=PrimitiveAccelerationStructureDescriptor)
@(objc_name="setMotionEndTime")
PrimitiveAccelerationStructureDescriptor_setMotionEndTime :: proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, motionEndTime: f32) {…}

PrimitiveAccelerationStructureDescriptor_setMotionKeyframeCount #

Source 
@(objc_type=PrimitiveAccelerationStructureDescriptor)
@(objc_name="setMotionKeyframeCount")
PrimitiveAccelerationStructureDescriptor_setMotionKeyframeCount :: proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, motionKeyframeCount: UInteger) {…}

PrimitiveAccelerationStructureDescriptor_setMotionStartTime #

Source 
@(objc_type=PrimitiveAccelerationStructureDescriptor)
@(objc_name="setMotionStartTime")
PrimitiveAccelerationStructureDescriptor_setMotionStartTime :: proc "c" (self: ^PrimitiveAccelerationStructureDescriptor, motionStartTime: f32) {…}

RasterizationRateLayerArray_alloc #

Source 
@(objc_type=RasterizationRateLayerArray)
@(objc_name="alloc")
@(objc_is_class_method=true)
RasterizationRateLayerArray_alloc :: proc "c" () -> ^RasterizationRateLayerArray {…}

RasterizationRateLayerDescriptor_alloc #

Source 
@(objc_type=RasterizationRateLayerDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RasterizationRateLayerDescriptor_alloc :: proc "c" () -> ^RasterizationRateLayerDescriptor {…}

RasterizationRateLayerDescriptor_horizontalSampleStorage #

Source 
@(objc_type=RasterizationRateLayerDescriptor)
@(objc_name="horizontalSampleStorage")
RasterizationRateLayerDescriptor_horizontalSampleStorage :: proc "c" (self: ^RasterizationRateLayerDescriptor) -> [^]f32 {…}

RasterizationRateLayerDescriptor_verticalSampleStorage #

Source 
@(objc_type=RasterizationRateLayerDescriptor)
@(objc_name="verticalSampleStorage")
RasterizationRateLayerDescriptor_verticalSampleStorage :: proc "c" (self: ^RasterizationRateLayerDescriptor) -> [^]f32 {…}

RasterizationRateMap_copyParameterDataToBuffer #

Source 
@(objc_type=RasterizationRateMap)
@(objc_name="copyParameterDataToBuffer")
RasterizationRateMap_copyParameterDataToBuffer :: proc "c" (self: ^RasterizationRateMap, buffer: ^Buffer, offset: UInteger) {…}

RasterizationRateMap_parameterBufferSizeAndAlign #

Source 
@(objc_type=RasterizationRateMap)
@(objc_name="parameterBufferSizeAndAlign")
RasterizationRateMap_parameterBufferSizeAndAlign :: proc "c" (self: ^RasterizationRateMap) -> (size, align: UInteger) {…}

RasterizationRateMap_physicalGranularity #

Source 
@(objc_type=RasterizationRateMap)
@(objc_name="physicalGranularity")
RasterizationRateMap_physicalGranularity :: proc "c" (self: ^RasterizationRateMap) -> Size {…}

RasterizationRateMap_physicalSizeForLayer #

Source 
@(objc_type=RasterizationRateMap)
@(objc_name="physicalSizeForLayer")
RasterizationRateMap_physicalSizeForLayer :: proc "c" (self: ^RasterizationRateMap, layerIndex: UInteger) -> Size {…}

RasterizationRateMapDescriptor_alloc #

Source 
@(objc_type=RasterizationRateMapDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RasterizationRateMapDescriptor_alloc :: proc "c" () -> ^RasterizationRateMapDescriptor {…}

RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize #

Source 
@(objc_type=RasterizationRateMapDescriptor)
@(objc_name="rasterizationRateMapDescriptorWithScreenSize")
@(objc_is_class_method=true)
RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize :: proc "c" (screenSize: Size) -> ^RasterizationRateMapDescriptor {…}

RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayer #

Source 
@(objc_type=RasterizationRateMapDescriptor)
@(objc_name="rasterizationRateMapDescriptorWithScreenSizeWithLayer")
@(objc_is_class_method=true)
RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayer :: proc "c" (screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor {…}

RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayers #

Source 
@(objc_type=RasterizationRateMapDescriptor)
@(objc_name="rasterizationRateMapDescriptorWithScreenSizeWithLayers")
@(objc_is_class_method=true)
RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSizeWithLayers :: proc "c" (screenSize: Size, layers: []^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor {…}

RasterizationRateMapDescriptor_setScreenSize #

Source 
@(objc_type=RasterizationRateMapDescriptor)
@(objc_name="setScreenSize")
RasterizationRateMapDescriptor_setScreenSize :: proc "c" (self: ^RasterizationRateMapDescriptor, screenSize: Size) {…}

RasterizationRateSampleArray_alloc #

Source 
@(objc_type=RasterizationRateSampleArray)
@(objc_name="alloc")
@(objc_is_class_method=true)
RasterizationRateSampleArray_alloc :: proc "c" () -> ^RasterizationRateSampleArray {…}

RenderCommandEncoder_dispatchThreadsPerTile #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="dispatchThreadsPerTile")
RenderCommandEncoder_dispatchThreadsPerTile :: proc "c" (self: ^RenderCommandEncoder, threadsPerTile: Size) {…}

RenderCommandEncoder_drawIndexedPatchesWihtIndirect #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="drawIndexedPatchesWihtIndirect")
RenderCommandEncoder_drawIndexedPatchesWihtIndirect :: proc "c" (
	self:                          ^RenderCommandEncoder, 
	numberOfPatchControlPoints:    UInteger, 
	patchIndexBuffer:              ^Buffer, 
	patchIndexBufferOffset:        UInteger, 
	controlPointIndexBuffer:       ^Buffer, 
	controlPointIndexBufferOffset: UInteger, 
	indirectBuffer:                ^Buffer, 
	indirectBufferOffset:          UInteger, 
) {…}

RenderCommandEncoder_drawIndexPatchesWithInstance #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="drawIndexPatchesWithInstances")
RenderCommandEncoder_drawIndexPatchesWithInstance :: proc "c" (
	self:                          ^RenderCommandEncoder, 
	numberOfPatchControlPoints:    UInteger, 
	patchStart, patchCount:        UInteger, 
	patchIndexBuffer:              ^Buffer, 
	patchIndexBufferOffset:        UInteger, 
	controlPointIndexBuffer:       ^Buffer, 
	controlPointIndexBufferOffset: UInteger, 
	instanceCount:                 UInteger, 
	baseInstance:                  UInteger, 
) {…}

RenderCommandEncoder_drawMeshThreadgroups #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="drawMeshThreadgroups")
RenderCommandEncoder_drawMeshThreadgroups :: proc "c" (self: ^RenderCommandEncoder, threadgroupsPerGrid, threadPerObjectThreadgroup, threadsPerMeshThreadgroup: Size) {…}

RenderCommandEncoder_drawMeshThreadgroupsWithIndirectBuffer #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="drawMeshThreadgroupsWithIndirectBuffer")
RenderCommandEncoder_drawMeshThreadgroupsWithIndirectBuffer :: proc "c" (self: ^RenderCommandEncoder, indirectBuffer: ^Buffer, indirectBufferOffset, threadPerObjectThreadgroup, threadsPerMeshThreadgroup: Size) {…}

RenderCommandEncoder_drawMeshThreads #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="drawMeshThreads")
RenderCommandEncoder_drawMeshThreads :: proc "c" (self: ^RenderCommandEncoder, threadsPerGrid, threadPerObjectThreadgroup, threadsPerMeshThreadgroup: Size) {…}

RenderCommandEncoder_drawPatchesWithInstance #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="drawPatchesWithInstances")
RenderCommandEncoder_drawPatchesWithInstance :: proc "c" (
	self:                       ^RenderCommandEncoder, 
	numberOfPatchControlPoints: UInteger, 
	patchStart, patchCount:     UInteger, 
	patchIndexBuffer:           ^Buffer, 
	patchIndexBufferOffset:     UInteger, 
	instanceCount:              UInteger, 
	baseInstance:               UInteger, 
) {…}

RenderCommandEncoder_drawPrimitivesWithIndirect #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="drawPrimitivesWithIndirect")
RenderCommandEncoder_drawPrimitivesWithIndirect :: proc "c" (self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^Buffer, indirectBufferOffset: UInteger) {…}

RenderCommandEncoder_executeCommandsInBuffer #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="executeCommandsInBuffer")
RenderCommandEncoder_executeCommandsInBuffer :: proc "c" (self: ^RenderCommandEncoder, indirectCommandbuffer: ^Buffer, indirectRangeBuffer: ^Buffer, indirectBufferOffset: UInteger) {…}

RenderCommandEncoder_executeCommandsInBufferWithRange #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="executeCommandsInBufferWithRange")
RenderCommandEncoder_executeCommandsInBufferWithRange :: proc "c" (self: ^RenderCommandEncoder, indirectCommandBuffer: ^Buffer, executionRange: Range) {…}

RenderCommandEncoder_sampleCountersInBuffer #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="sampleCountersInBuffer")
RenderCommandEncoder_sampleCountersInBuffer :: proc "c" (self: ^RenderCommandEncoder, sampleBuffer: ^Buffer, sampleIndex: UInteger, barrier: bool) {…}

RenderCommandEncoder_setBlendColorRed #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setBlendColorRed")
RenderCommandEncoder_setBlendColorRed :: proc "c" (self: ^RenderCommandEncoder, red: f32, green: f32, blue: f32, alpha: f32) {…}

RenderCommandEncoder_setColorStoreAction #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setColorStoreAction")
RenderCommandEncoder_setColorStoreAction :: proc "c" (self: ^RenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: UInteger) {…}

RenderCommandEncoder_setColorStoreActionOptions #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setColorStoreActionOptions")
RenderCommandEncoder_setColorStoreActionOptions :: proc "c" (self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: UInteger) {…}

RenderCommandEncoder_setDepthBias #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setDepthBias")
RenderCommandEncoder_setDepthBias :: proc "c" (self: ^RenderCommandEncoder, depthBias: f32, slopeScale: f32, clamp: f32) {…}

RenderCommandEncoder_setDepthStoreAction #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setDepthStoreAction")
RenderCommandEncoder_setDepthStoreAction :: proc "c" (self: ^RenderCommandEncoder, storeAction: StoreAction) {…}

RenderCommandEncoder_setDepthStoreActionOptions #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setDepthStoreActionOptions")
RenderCommandEncoder_setDepthStoreActionOptions :: proc "c" (self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) {…}

RenderCommandEncoder_setFragmentBufferOffset #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setFragmentBufferOffset")
RenderCommandEncoder_setFragmentBufferOffset :: proc "c" (self: ^RenderCommandEncoder, offset: UInteger, index: UInteger) {…}

RenderCommandEncoder_setFragmentBytes #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setFragmentBytes")
RenderCommandEncoder_setFragmentBytes :: proc "c" (self: ^RenderCommandEncoder, bytes: []u8, index: UInteger) {…}

RenderCommandEncoder_setFragmentSamplerStatesWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setFragmentSamplerStatesWithLod")
RenderCommandEncoder_setFragmentSamplerStatesWithLod :: proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: Range) {…}

RenderCommandEncoder_setFragmentSamplerStatesWithRange #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setFragmentSamplerStatesWithRange")
RenderCommandEncoder_setFragmentSamplerStatesWithRange :: proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, range: Range) {…}

RenderCommandEncoder_setFragmentSamplerStateWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setFragmentSamplerStateWithLod")
RenderCommandEncoder_setFragmentSamplerStateWithLod :: proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: UInteger) {…}

RenderCommandEncoder_setFragmentTextures #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setFragmentTextures")
RenderCommandEncoder_setFragmentTextures :: proc "c" (self: ^RenderCommandEncoder, textures: []^Texture, range: Range) {…}

RenderCommandEncoder_setFrontFacingWinding #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setFrontFacingWinding")
RenderCommandEncoder_setFrontFacingWinding :: proc "c" (self: ^RenderCommandEncoder, frontFacingWinding: Winding) {…}

RenderCommandEncoder_setMeshSamplerStatesWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setMeshSamplerStatesWithLod")
RenderCommandEncoder_setMeshSamplerStatesWithLod :: proc "c" (self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps, lodMaxClamps: [^]f32, range: Range) {…}

RenderCommandEncoder_setMeshSamplerStateWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setMeshSamplerStateWithLod")
RenderCommandEncoder_setMeshSamplerStateWithLod :: proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: UInteger) {…}

RenderCommandEncoder_setMeshTextures #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setMeshTextures")
RenderCommandEncoder_setMeshTextures :: proc "c" (self: ^RenderCommandEncoder, textures: [^]^Texture, range: Range) {…}

RenderCommandEncoder_setObjectSamplerStates #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setObjectSamplerStates")
RenderCommandEncoder_setObjectSamplerStates :: proc "c" (self: ^RenderCommandEncoder, samplers: [^]^SamplerState, range: Range) {…}

RenderCommandEncoder_setObjectSamplerStatesWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setObjectSamplerStatesWithLod")
RenderCommandEncoder_setObjectSamplerStatesWithLod :: proc "c" (self: ^RenderCommandEncoder, samplers: [^]^SamplerState, lodMinClamps, lodMaxClamps: [^]f32, range: Range) {…}

RenderCommandEncoder_setObjectSamplerStateWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setObjectSamplerStateWithLod")
RenderCommandEncoder_setObjectSamplerStateWithLod :: proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: UInteger) {…}

RenderCommandEncoder_setObjectTextures #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setObjectTextures")
RenderCommandEncoder_setObjectTextures :: proc "c" (self: ^RenderCommandEncoder, textures: [^]^Texture, range: Range) {…}

RenderCommandEncoder_setObjectThreadgroupMemoryLength #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setObjectThreadgroupMemoryLength")
RenderCommandEncoder_setObjectThreadgroupMemoryLength :: proc "c" (self: ^RenderCommandEncoder, length: UInteger, index: UInteger) {…}

RenderCommandEncoder_setScissorRects #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setScissorRects")
RenderCommandEncoder_setScissorRects :: proc "c" (self: ^RenderCommandEncoder, scissorRects: []ScissorRect) {…}

RenderCommandEncoder_setStencilFrontReferenceValue #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setStencilFrontReferenceValue")
RenderCommandEncoder_setStencilFrontReferenceValue :: proc "c" (self: ^RenderCommandEncoder, frontReferenceValue: u32, backReferenceValue: u32) {…}

RenderCommandEncoder_setStencilReferenceValue #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setStencilReferenceValue")
RenderCommandEncoder_setStencilReferenceValue :: proc "c" (self: ^RenderCommandEncoder, referenceValue: u32) {…}

RenderCommandEncoder_setStencilStoreAction #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setStencilStoreAction")
RenderCommandEncoder_setStencilStoreAction :: proc "c" (self: ^RenderCommandEncoder, storeAction: StoreAction) {…}

RenderCommandEncoder_setStencilStoreActionOptions #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setStencilStoreActionOptions")
RenderCommandEncoder_setStencilStoreActionOptions :: proc "c" (self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) {…}

RenderCommandEncoder_setTessellationFactorBuffer #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setTessellationFactorBuffer")
RenderCommandEncoder_setTessellationFactorBuffer :: proc "c" (self: ^RenderCommandEncoder, buffer: ^Buffer, offset: UInteger, instanceStride: UInteger) {…}

RenderCommandEncoder_setTessellationFactorScale #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setTessellationFactorScale")
RenderCommandEncoder_setTessellationFactorScale :: proc "c" (self: ^RenderCommandEncoder, scale: f32) {…}

RenderCommandEncoder_setTileSamplerStatesWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setTileSamplerStatesWithLod")
RenderCommandEncoder_setTileSamplerStatesWithLod :: proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: Range) {…}

RenderCommandEncoder_setTileSamplerStatesWithRange #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setTileSamplerStatesWithRange")
RenderCommandEncoder_setTileSamplerStatesWithRange :: proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, range: Range) {…}

RenderCommandEncoder_setTileSamplerStateWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setTileSamplerStateWithLod")
RenderCommandEncoder_setTileSamplerStateWithLod :: proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: UInteger) {…}

RenderCommandEncoder_setTileTextures #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setTileTextures")
RenderCommandEncoder_setTileTextures :: proc "c" (self: ^RenderCommandEncoder, textures: []^Texture, range: Range) {…}

RenderCommandEncoder_setVertexBytes #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setVertexBytes")
RenderCommandEncoder_setVertexBytes :: proc "c" (self: ^RenderCommandEncoder, bytes: []u8, index: UInteger) {…}

RenderCommandEncoder_setVertexSamplerStatesWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setVertexSamplerStatesWithLod")
RenderCommandEncoder_setVertexSamplerStatesWithLod :: proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, lodMinClamps, lodMaxClamps: []f32, range: Range) {…}

RenderCommandEncoder_setVertexSamplerStatesWithRange #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setVertexSamplerStatesWithRange")
RenderCommandEncoder_setVertexSamplerStatesWithRange :: proc "c" (self: ^RenderCommandEncoder, samplers: []^SamplerState, range: Range) {…}

RenderCommandEncoder_setVertexSamplerStateWithLod #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setVertexSamplerStateWithLod")
RenderCommandEncoder_setVertexSamplerStateWithLod :: proc "c" (self: ^RenderCommandEncoder, sampler: ^SamplerState, lodMinClamp: f32, lodMaxClamp: f32, index: UInteger) {…}

RenderCommandEncoder_setVertexTextures #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setVertexTextures")
RenderCommandEncoder_setVertexTextures :: proc "c" (self: ^RenderCommandEncoder, textures: []^Texture, range: Range) {…}

RenderCommandEncoder_setViewports #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="setViewports")
RenderCommandEncoder_setViewports :: proc "c" (self: ^RenderCommandEncoder, viewports: []Viewport) {…}

RenderCommandEncoder_textureBarrier #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="textureBarrier")
RenderCommandEncoder_textureBarrier :: proc "c" (self: ^RenderCommandEncoder) {…}

RenderCommandEncoder_useHeaps #

Source 
@(objc_type=RenderCommandEncoder)
@(objc_name="useHeaps")
RenderCommandEncoder_useHeaps :: proc "c" (self: ^RenderCommandEncoder, heaps: []^Heap) {…}

RenderPassAttachmentDescriptor_alloc #

Source 
@(objc_type=RenderPassAttachmentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPassAttachmentDescriptor_alloc :: proc "c" () -> ^RenderPassAttachmentDescriptor {…}

RenderPassAttachmentDescriptor_setResolveDepthPlane #

Source 
@(objc_type=RenderPassAttachmentDescriptor)
@(objc_name="setResolveDepthPlane")
RenderPassAttachmentDescriptor_setResolveDepthPlane :: proc "c" (self: ^RenderPassAttachmentDescriptor, resolveDepthPlane: UInteger) {…}

RenderPassAttachmentDescriptor_setResolveLevel #

Source 
@(objc_type=RenderPassAttachmentDescriptor)
@(objc_name="setResolveLevel")
RenderPassAttachmentDescriptor_setResolveLevel :: proc "c" (self: ^RenderPassAttachmentDescriptor, resolveLevel: UInteger) {…}

RenderPassAttachmentDescriptor_setResolveSlice #

Source 
@(objc_type=RenderPassAttachmentDescriptor)
@(objc_name="setResolveSlice")
RenderPassAttachmentDescriptor_setResolveSlice :: proc "c" (self: ^RenderPassAttachmentDescriptor, resolveSlice: UInteger) {…}

RenderPassAttachmentDescriptor_setResolveTexture #

Source 
@(objc_type=RenderPassAttachmentDescriptor)
@(objc_name="setResolveTexture")
RenderPassAttachmentDescriptor_setResolveTexture :: proc "c" (self: ^RenderPassAttachmentDescriptor, resolveTexture: ^Texture) {…}

RenderPassColorAttachmentDescriptor_alloc #

Source 
@(objc_type=RenderPassColorAttachmentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPassColorAttachmentDescriptor_alloc :: proc "c" () -> ^RenderPassColorAttachmentDescriptor {…}

RenderPassColorAttachmentDescriptorArray_alloc #

Source 
@(objc_type=RenderPassColorAttachmentDescriptorArray)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPassColorAttachmentDescriptorArray_alloc :: proc "c" () -> ^RenderPassColorAttachmentDescriptorArray {…}

RenderPassDepthAttachmentDescriptor_alloc #

Source 
@(objc_type=RenderPassDepthAttachmentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPassDepthAttachmentDescriptor_alloc :: proc "c" () -> ^RenderPassDepthAttachmentDescriptor {…}

RenderPassDepthAttachmentDescriptor_setClearDepth #

Source 
@(objc_type=RenderPassDepthAttachmentDescriptor)
@(objc_name="setClearDepth")
RenderPassDepthAttachmentDescriptor_setClearDepth :: proc "c" (self: ^RenderPassDepthAttachmentDescriptor, clearDepth: f64) {…}

RenderPassDescriptor_alloc #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPassDescriptor_alloc :: proc "c" () -> ^RenderPassDescriptor {…}

RenderPassDescriptor_defaultRasterSampleCount #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="defaultRasterSampleCount")
RenderPassDescriptor_defaultRasterSampleCount :: proc "c" (self: ^RenderPassDescriptor) -> UInteger {…}

RenderPassDescriptor_imageblockSampleLength #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="imageblockSampleLength")
RenderPassDescriptor_imageblockSampleLength :: proc "c" (self: ^RenderPassDescriptor) -> UInteger {…}

RenderPassDescriptor_renderPassDescriptor #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="renderPassDescriptor")
@(objc_is_class_method=true)
RenderPassDescriptor_renderPassDescriptor :: proc "c" () -> ^RenderPassDescriptor {…}

RenderPassDescriptor_renderTargetArrayLength #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="renderTargetArrayLength")
RenderPassDescriptor_renderTargetArrayLength :: proc "c" (self: ^RenderPassDescriptor) -> UInteger {…}

RenderPassDescriptor_renderTargetHeight #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="renderTargetHeight")
RenderPassDescriptor_renderTargetHeight :: proc "c" (self: ^RenderPassDescriptor) -> UInteger {…}

RenderPassDescriptor_renderTargetWidth #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="renderTargetWidth")
RenderPassDescriptor_renderTargetWidth :: proc "c" (self: ^RenderPassDescriptor) -> UInteger {…}

RenderPassDescriptor_setDefaultRasterSampleCount #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="setDefaultRasterSampleCount")
RenderPassDescriptor_setDefaultRasterSampleCount :: proc "c" (self: ^RenderPassDescriptor, defaultRasterSampleCount: UInteger) {…}

RenderPassDescriptor_setImageblockSampleLength #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="setImageblockSampleLength")
RenderPassDescriptor_setImageblockSampleLength :: proc "c" (self: ^RenderPassDescriptor, imageblockSampleLength: UInteger) {…}

RenderPassDescriptor_setRenderTargetArrayLength #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="setRenderTargetArrayLength")
RenderPassDescriptor_setRenderTargetArrayLength :: proc "c" (self: ^RenderPassDescriptor, renderTargetArrayLength: UInteger) {…}

RenderPassDescriptor_setRenderTargetHeight #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="setRenderTargetHeight")
RenderPassDescriptor_setRenderTargetHeight :: proc "c" (self: ^RenderPassDescriptor, renderTargetHeight: UInteger) {…}

RenderPassDescriptor_setRenderTargetWidth #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="setRenderTargetWidth")
RenderPassDescriptor_setRenderTargetWidth :: proc "c" (self: ^RenderPassDescriptor, renderTargetWidth: UInteger) {…}

RenderPassDescriptor_setThreadgroupMemoryLength #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="setThreadgroupMemoryLength")
RenderPassDescriptor_setThreadgroupMemoryLength :: proc "c" (self: ^RenderPassDescriptor, threadgroupMemoryLength: UInteger) {…}

RenderPassDescriptor_setTileHeight #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="setTileHeight")
RenderPassDescriptor_setTileHeight :: proc "c" (self: ^RenderPassDescriptor, tileHeight: UInteger) {…}

RenderPassDescriptor_setVisibilityResultBuffer #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="setVisibilityResultBuffer")
RenderPassDescriptor_setVisibilityResultBuffer :: proc "c" (self: ^RenderPassDescriptor, visibilityResultBuffer: ^Buffer) {…}

RenderPassDescriptor_threadgroupMemoryLength #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="threadgroupMemoryLength")
RenderPassDescriptor_threadgroupMemoryLength :: proc "c" (self: ^RenderPassDescriptor) -> UInteger {…}

RenderPassDescriptor_visibilityResultBuffer #

Source 
@(objc_type=RenderPassDescriptor)
@(objc_name="visibilityResultBuffer")
RenderPassDescriptor_visibilityResultBuffer :: proc "c" (self: ^RenderPassDescriptor) -> ^Buffer {…}

RenderPassSampleBufferAttachmentDescriptor_alloc #

Source 
@(objc_type=RenderPassSampleBufferAttachmentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPassSampleBufferAttachmentDescriptor_alloc :: proc "c" () -> ^RenderPassSampleBufferAttachmentDescriptor {…}

RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex #

Source 
@(objc_type=RenderPassSampleBufferAttachmentDescriptor)
@(objc_name="endOfFragmentSampleIndex")
RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex :: proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor) -> UInteger {…}

RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex #

Source 
@(objc_type=RenderPassSampleBufferAttachmentDescriptor)
@(objc_name="setEndOfFragmentSampleIndex")
RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: UInteger) {…}

RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex #

Source 
@(objc_type=RenderPassSampleBufferAttachmentDescriptor)
@(objc_name="setEndOfVertexSampleIndex")
RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor, endOfVertexSampleIndex: UInteger) {…}

RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex #

Source 
@(objc_type=RenderPassSampleBufferAttachmentDescriptor)
@(objc_name="setStartOfFragmentSampleIndex")
RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex :: proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor, startOfFragmentSampleIndex: UInteger) {…}

RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex #

Source 
@(objc_type=RenderPassSampleBufferAttachmentDescriptor)
@(objc_name="setStartOfVertexSampleIndex")
RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex :: proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor, startOfVertexSampleIndex: UInteger) {…}

RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex #

Source 
@(objc_type=RenderPassSampleBufferAttachmentDescriptor)
@(objc_name="startOfFragmentSampleIndex")
RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex :: proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor) -> UInteger {…}

RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex #

Source 
@(objc_type=RenderPassSampleBufferAttachmentDescriptor)
@(objc_name="startOfVertexSampleIndex")
RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex :: proc "c" (self: ^RenderPassSampleBufferAttachmentDescriptor) -> UInteger {…}

RenderPassStencilAttachmentDescriptor_alloc #

Source 
@(objc_type=RenderPassStencilAttachmentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPassStencilAttachmentDescriptor_alloc :: proc "c" () -> ^RenderPassStencilAttachmentDescriptor {…}

RenderPassStencilAttachmentDescriptor_setClearStencil #

Source 
@(objc_type=RenderPassStencilAttachmentDescriptor)
@(objc_name="setClearStencil")
RenderPassStencilAttachmentDescriptor_setClearStencil :: proc "c" (self: ^RenderPassStencilAttachmentDescriptor, clearStencil: u32) {…}

RenderPipelineColorAttachmentDescriptor_alloc #

Source 
@(objc_type=RenderPipelineColorAttachmentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPipelineColorAttachmentDescriptor_alloc :: proc "c" () -> ^RenderPipelineColorAttachmentDescriptor {…}

RenderPipelineColorAttachmentDescriptor_destinationAlphaBlendFactor #

Source 
@(objc_type=RenderPipelineColorAttachmentDescriptor)
@(objc_name="destinationAlphaBlendFactor")
RenderPipelineColorAttachmentDescriptor_destinationAlphaBlendFactor :: proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor {…}

RenderPipelineColorAttachmentDescriptor_isBlendingEnabled #

Source 
@(objc_type=RenderPipelineColorAttachmentDescriptor)
@(objc_name="isBlendingEnabled")
RenderPipelineColorAttachmentDescriptor_isBlendingEnabled :: proc "c" (self: ^RenderPipelineColorAttachmentDescriptor) -> bool {…}

RenderPipelineColorAttachmentDescriptor_setBlendingEnabled #

Source 
@(objc_type=RenderPipelineColorAttachmentDescriptor)
@(objc_name="setBlendingEnabled")
RenderPipelineColorAttachmentDescriptor_setBlendingEnabled :: proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, blendingEnabled: bool) {…}

RenderPipelineColorAttachmentDescriptor_setDestinationAlphaBlendFactor #

Source 
@(objc_type=RenderPipelineColorAttachmentDescriptor)
@(objc_name="setDestinationAlphaBlendFactor")
RenderPipelineColorAttachmentDescriptor_setDestinationAlphaBlendFactor :: proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, destinationAlphaBlendFactor: BlendFactor) {…}

RenderPipelineColorAttachmentDescriptor_setDestinationRGBBlendFactor #

Source 
@(objc_type=RenderPipelineColorAttachmentDescriptor)
@(objc_name="setDestinationRGBBlendFactor")
RenderPipelineColorAttachmentDescriptor_setDestinationRGBBlendFactor :: proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, destinationRGBBlendFactor: BlendFactor) {…}

RenderPipelineColorAttachmentDescriptor_setSourceAlphaBlendFactor #

Source 
@(objc_type=RenderPipelineColorAttachmentDescriptor)
@(objc_name="setSourceAlphaBlendFactor")
RenderPipelineColorAttachmentDescriptor_setSourceAlphaBlendFactor :: proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, sourceAlphaBlendFactor: BlendFactor) {…}

RenderPipelineColorAttachmentDescriptor_setSourceRGBBlendFactor #

Source 
@(objc_type=RenderPipelineColorAttachmentDescriptor)
@(objc_name="setSourceRGBBlendFactor")
RenderPipelineColorAttachmentDescriptor_setSourceRGBBlendFactor :: proc "c" (self: ^RenderPipelineColorAttachmentDescriptor, sourceRGBBlendFactor: BlendFactor) {…}

RenderPipelineDescriptor_alloc #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPipelineDescriptor_alloc :: proc "c" () -> ^RenderPipelineDescriptor {…}

RenderPipelineDescriptor_alphaToCoverageEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="alphaToCoverageEnabled")
RenderPipelineDescriptor_alphaToCoverageEnabled :: proc "c" (self: ^RenderPipelineDescriptor) -> bool {…}

RenderPipelineDescriptor_alphaToOneEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="alphaToOneEnabled")
RenderPipelineDescriptor_alphaToOneEnabled :: proc "c" (self: ^RenderPipelineDescriptor) -> bool {…}

RenderPipelineDescriptor_binaryArchives #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="binaryArchives")
RenderPipelineDescriptor_binaryArchives :: proc "c" (self: ^RenderPipelineDescriptor) -> ^Array {…}

RenderPipelineDescriptor_depthAttachmentPixelFormat #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="depthAttachmentPixelFormat")
RenderPipelineDescriptor_depthAttachmentPixelFormat :: proc "c" (self: ^RenderPipelineDescriptor) -> PixelFormat {…}

RenderPipelineDescriptor_isAlphaToCoverageEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="isAlphaToCoverageEnabled")
RenderPipelineDescriptor_isAlphaToCoverageEnabled :: proc "c" (self: ^RenderPipelineDescriptor) -> bool {…}

RenderPipelineDescriptor_isAlphaToOneEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="isAlphaToOneEnabled")
RenderPipelineDescriptor_isAlphaToOneEnabled :: proc "c" (self: ^RenderPipelineDescriptor) -> bool {…}

RenderPipelineDescriptor_isRasterizationEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="isRasterizationEnabled")
RenderPipelineDescriptor_isRasterizationEnabled :: proc "c" (self: ^RenderPipelineDescriptor) -> bool {…}

RenderPipelineDescriptor_isTessellationFactorScaleEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="isTessellationFactorScaleEnabled")
RenderPipelineDescriptor_isTessellationFactorScaleEnabled :: proc "c" (self: ^RenderPipelineDescriptor) -> bool {…}

RenderPipelineDescriptor_maxTessellationFactor #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="maxTessellationFactor")
RenderPipelineDescriptor_maxTessellationFactor :: proc "c" (self: ^RenderPipelineDescriptor) -> UInteger {…}

RenderPipelineDescriptor_maxVertexAmplificationCount #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="maxVertexAmplificationCount")
RenderPipelineDescriptor_maxVertexAmplificationCount :: proc "c" (self: ^RenderPipelineDescriptor) -> UInteger {…}

RenderPipelineDescriptor_rasterizationEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="rasterizationEnabled")
RenderPipelineDescriptor_rasterizationEnabled :: proc "c" (self: ^RenderPipelineDescriptor) -> bool {…}

RenderPipelineDescriptor_rasterSampleCount #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="rasterSampleCount")
RenderPipelineDescriptor_rasterSampleCount :: proc "c" (self: ^RenderPipelineDescriptor) -> UInteger {…}

RenderPipelineDescriptor_setAlphaToCoverageEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setAlphaToCoverageEnabled")
RenderPipelineDescriptor_setAlphaToCoverageEnabled :: proc "c" (self: ^RenderPipelineDescriptor, alphaToCoverageEnabled: bool) {…}

RenderPipelineDescriptor_setAlphaToOneEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setAlphaToOneEnabled")
RenderPipelineDescriptor_setAlphaToOneEnabled :: proc "c" (self: ^RenderPipelineDescriptor, alphaToOneEnabled: bool) {…}

RenderPipelineDescriptor_setBinaryArchives #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setBinaryArchives")
RenderPipelineDescriptor_setBinaryArchives :: proc "c" (self: ^RenderPipelineDescriptor, binaryArchives: ^Array) {…}

RenderPipelineDescriptor_setDepthAttachmentPixelFormat #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setDepthAttachmentPixelFormat")
RenderPipelineDescriptor_setDepthAttachmentPixelFormat :: proc "c" (self: ^RenderPipelineDescriptor, depthAttachmentPixelFormat: PixelFormat) {…}

RenderPipelineDescriptor_setFragmentFunction #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setFragmentFunction")
RenderPipelineDescriptor_setFragmentFunction :: proc "c" (self: ^RenderPipelineDescriptor, fragmentFunction: ^Function) {…}

RenderPipelineDescriptor_setFragmentLinkedFunctions #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setFragmentLinkedFunctions")
RenderPipelineDescriptor_setFragmentLinkedFunctions :: proc "c" (self: ^RenderPipelineDescriptor, fragmentLinkedFunctions: ^LinkedFunctions) {…}

RenderPipelineDescriptor_setMaxTessellationFactor #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setMaxTessellationFactor")
RenderPipelineDescriptor_setMaxTessellationFactor :: proc "c" (self: ^RenderPipelineDescriptor, maxTessellationFactor: UInteger) {…}

RenderPipelineDescriptor_setMaxVertexAmplificationCount #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setMaxVertexAmplificationCount")
RenderPipelineDescriptor_setMaxVertexAmplificationCount :: proc "c" (self: ^RenderPipelineDescriptor, maxVertexAmplificationCount: UInteger) {…}

RenderPipelineDescriptor_setRasterizationEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setRasterizationEnabled")
RenderPipelineDescriptor_setRasterizationEnabled :: proc "c" (self: ^RenderPipelineDescriptor, rasterizationEnabled: bool) {…}

RenderPipelineDescriptor_setRasterSampleCount #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setRasterSampleCount")
RenderPipelineDescriptor_setRasterSampleCount :: proc "c" (self: ^RenderPipelineDescriptor, rasterSampleCount: UInteger) {…}

RenderPipelineDescriptor_setSampleCount #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setSampleCount")
RenderPipelineDescriptor_setSampleCount :: proc "c" (self: ^RenderPipelineDescriptor, sampleCount: UInteger) {…}

RenderPipelineDescriptor_setStencilAttachmentPixelFormat #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setStencilAttachmentPixelFormat")
RenderPipelineDescriptor_setStencilAttachmentPixelFormat :: proc "c" (self: ^RenderPipelineDescriptor, stencilAttachmentPixelFormat: PixelFormat) {…}

RenderPipelineDescriptor_setSupportIndirectCommandBuffers #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setSupportIndirectCommandBuffers")
RenderPipelineDescriptor_setSupportIndirectCommandBuffers :: proc "c" (self: ^RenderPipelineDescriptor, supportIndirectCommandBuffers: bool) {…}

RenderPipelineDescriptor_setTessellationFactorScaleEnabled #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setTessellationFactorScaleEnabled")
RenderPipelineDescriptor_setTessellationFactorScaleEnabled :: proc "c" (self: ^RenderPipelineDescriptor, tessellationFactorScaleEnabled: bool) {…}

RenderPipelineDescriptor_setTessellationOutputWindingOrder #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setTessellationOutputWindingOrder")
RenderPipelineDescriptor_setTessellationOutputWindingOrder :: proc "c" (self: ^RenderPipelineDescriptor, tessellationOutputWindingOrder: Winding) {…}

RenderPipelineDescriptor_setVertexFunction #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setVertexFunction")
RenderPipelineDescriptor_setVertexFunction :: proc "c" (self: ^RenderPipelineDescriptor, vertexFunction: ^Function) {…}

RenderPipelineDescriptor_setVertexLinkedFunctions #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="setVertexLinkedFunctions")
RenderPipelineDescriptor_setVertexLinkedFunctions :: proc "c" (self: ^RenderPipelineDescriptor, vertexLinkedFunctions: ^LinkedFunctions) {…}

RenderPipelineDescriptor_stencilAttachmentPixelFormat #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="stencilAttachmentPixelFormat")
RenderPipelineDescriptor_stencilAttachmentPixelFormat :: proc "c" (self: ^RenderPipelineDescriptor) -> PixelFormat {…}

RenderPipelineDescriptor_supportIndirectCommandBuffers #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="supportIndirectCommandBuffers")
RenderPipelineDescriptor_supportIndirectCommandBuffers :: proc "c" (self: ^RenderPipelineDescriptor) -> bool {…}

RenderPipelineDescriptor_tessellationOutputWindingOrder #

Source 
@(objc_type=RenderPipelineDescriptor)
@(objc_name="tessellationOutputWindingOrder")
RenderPipelineDescriptor_tessellationOutputWindingOrder :: proc "c" (self: ^RenderPipelineDescriptor) -> Winding {…}

RenderPipelineFunctionsDescriptor_alloc #

Source 
@(objc_type=RenderPipelineFunctionsDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPipelineFunctionsDescriptor_alloc :: proc "c" () -> ^RenderPipelineFunctionsDescriptor {…}

RenderPipelineFunctionsDescriptor_fragmentAdditionalBinaryFunctions #

Source 
@(objc_type=RenderPipelineFunctionsDescriptor)
@(objc_name="fragmentAdditionalBinaryFunctions")
RenderPipelineFunctionsDescriptor_fragmentAdditionalBinaryFunctions :: proc "c" (self: ^RenderPipelineFunctionsDescriptor) -> ^Array {…}

RenderPipelineFunctionsDescriptor_setFragmentAdditionalBinaryFunctions #

Source 
@(objc_type=RenderPipelineFunctionsDescriptor)
@(objc_name="setFragmentAdditionalBinaryFunctions")
RenderPipelineFunctionsDescriptor_setFragmentAdditionalBinaryFunctions :: proc "c" (self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^Array) {…}

RenderPipelineFunctionsDescriptor_setTileAdditionalBinaryFunctions #

Source 
@(objc_type=RenderPipelineFunctionsDescriptor)
@(objc_name="setTileAdditionalBinaryFunctions")
RenderPipelineFunctionsDescriptor_setTileAdditionalBinaryFunctions :: proc "c" (self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^Array) {…}

RenderPipelineFunctionsDescriptor_setVertexAdditionalBinaryFunctions #

Source 
@(objc_type=RenderPipelineFunctionsDescriptor)
@(objc_name="setVertexAdditionalBinaryFunctions")
RenderPipelineFunctionsDescriptor_setVertexAdditionalBinaryFunctions :: proc "c" (self: ^RenderPipelineFunctionsDescriptor, binaryFunctions: ^Array) {…}

RenderPipelineFunctionsDescriptor_tileAdditionalBinaryFunctions #

Source 
@(objc_type=RenderPipelineFunctionsDescriptor)
@(objc_name="tileAdditionalBinaryFunctions")
RenderPipelineFunctionsDescriptor_tileAdditionalBinaryFunctions :: proc "c" (self: ^RenderPipelineFunctionsDescriptor) -> ^Array {…}

RenderPipelineFunctionsDescriptor_vertexAdditionalBinaryFunctions #

Source 
@(objc_type=RenderPipelineFunctionsDescriptor)
@(objc_name="vertexAdditionalBinaryFunctions")
RenderPipelineFunctionsDescriptor_vertexAdditionalBinaryFunctions :: proc "c" (self: ^RenderPipelineFunctionsDescriptor) -> ^Array {…}

RenderPipelineReflection_alloc #

Source 
@(objc_type=RenderPipelineReflection)
@(objc_name="alloc")
@(objc_is_class_method=true)
RenderPipelineReflection_alloc :: proc "c" () -> ^RenderPipelineReflection {…}

RenderPipelineReflection_fragmentArguments #

Source 
@(objc_type=RenderPipelineReflection)
@(objc_name="fragmentArguments")
RenderPipelineReflection_fragmentArguments :: proc "c" (self: ^RenderPipelineReflection) -> ^Array {…}

RenderPipelineReflection_fragmentBindings #

Source 
@(objc_type=RenderPipelineReflection)
@(objc_name="fragmentBindings")
RenderPipelineReflection_fragmentBindings :: proc "c" (self: ^RenderPipelineReflection) -> ^Array {…}

RenderPipelineReflection_objectBindings #

Source 
@(objc_type=RenderPipelineReflection)
@(objc_name="objectBindings")
RenderPipelineReflection_objectBindings :: proc "c" (self: ^RenderPipelineReflection) -> ^Array {…}

RenderPipelineReflection_tileArguments #

Source 
@(objc_type=RenderPipelineReflection)
@(objc_name="tileArguments")
RenderPipelineReflection_tileArguments :: proc "c" (self: ^RenderPipelineReflection) -> ^Array {…}

RenderPipelineReflection_vertexArguments #

Source 
@(objc_type=RenderPipelineReflection)
@(objc_name="vertexArguments")
RenderPipelineReflection_vertexArguments :: proc "c" (self: ^RenderPipelineReflection) -> ^Array {…}

RenderPipelineReflection_vertexBindings #

Source 
@(objc_type=RenderPipelineReflection)
@(objc_name="vertexBindings")
RenderPipelineReflection_vertexBindings :: proc "c" (self: ^RenderPipelineReflection) -> ^Array {…}

RenderPipelineState_imageblockMemoryLengthForDimensions #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="imageblockMemoryLengthForDimensions")
RenderPipelineState_imageblockMemoryLengthForDimensions :: proc "c" (self: ^RenderPipelineState, imageblockDimensions: Size) -> UInteger {…}

RenderPipelineState_imageblockSampleLength #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="imageblockSampleLength")
RenderPipelineState_imageblockSampleLength :: proc "c" (self: ^RenderPipelineState) -> UInteger {…}

RenderPipelineState_maxTotalThreadgroupsPerMeshGrid #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="maxTotalThreadgroupsPerMeshGrid")
RenderPipelineState_maxTotalThreadgroupsPerMeshGrid :: proc "c" (self: ^RenderPipelineState) -> UInteger {…}

RenderPipelineState_maxTotalThreadsPerMeshThreadgroup #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="maxTotalThreadsPerMeshThreadgroup")
RenderPipelineState_maxTotalThreadsPerMeshThreadgroup :: proc "c" (self: ^RenderPipelineState) -> UInteger {…}

RenderPipelineState_maxTotalThreadsPerObjectThreadgroup #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="maxTotalThreadsPerObjectThreadgroup")
RenderPipelineState_maxTotalThreadsPerObjectThreadgroup :: proc "c" (self: ^RenderPipelineState) -> UInteger {…}

RenderPipelineState_maxTotalThreadsPerThreadgroup #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="maxTotalThreadsPerThreadgroup")
RenderPipelineState_maxTotalThreadsPerThreadgroup :: proc "c" (self: ^RenderPipelineState) -> UInteger {…}

RenderPipelineState_meshThreadExecutionWidth #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="meshThreadExecutionWidth")
RenderPipelineState_meshThreadExecutionWidth :: proc "c" (self: ^RenderPipelineState) -> UInteger {…}

RenderPipelineState_objectThreadExecutionWidth #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="objectThreadExecutionWidth")
RenderPipelineState_objectThreadExecutionWidth :: proc "c" (self: ^RenderPipelineState) -> UInteger {…}

RenderPipelineState_supportIndirectCommandBuffers #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="supportIndirectCommandBuffers")
RenderPipelineState_supportIndirectCommandBuffers :: proc "c" (self: ^RenderPipelineState) -> bool {…}

RenderPipelineState_threadgroupSizeMatchesTileSize #

Source 
@(objc_type=RenderPipelineState)
@(objc_name="threadgroupSizeMatchesTileSize")
RenderPipelineState_threadgroupSizeMatchesTileSize :: proc "c" (self: ^RenderPipelineState) -> bool {…}

Resource_allocatedSize #

Source 
@(objc_type=Resource)
@(objc_name="allocatedSize")
Resource_allocatedSize :: proc "c" (self: ^Resource) -> UInteger {…}

Resource_isAliasable #

Source 
@(objc_type=Resource)
@(objc_name="isAliasable")
Resource_isAliasable :: proc "c" (self: ^Resource) -> bool {…}

Resource_makeAliasable #

Source 
@(objc_type=Resource)
@(objc_name="makeAliasable")
Resource_makeAliasable :: proc "c" (self: ^Resource) {…}

Resource_setLabel #

Source 
@(objc_type=Resource)
@(objc_name="setLabel")
Resource_setLabel :: proc "c" (self: ^Resource, label: ^String) {…}

ResourceStateCommandEncoder_moveTextureMappingsFromTexture #

Source 
@(objc_type=ResourceStateCommandEncoder)
@(objc_name="moveTextureMappingsFromTexture")
ResourceStateCommandEncoder_moveTextureMappingsFromTexture :: proc "c" (
	self:                               ^ResourceStateCommandEncoder, 
	sourceTexture:                      ^Texture, 
	sourceSlice, sourceLevel:           UInteger, 
	sourceOrigin:                       Origin, 
	sourceSize:                         Size, 
	destinationTexture:                 ^Texture, 
	destinationSlice, destinationLevel: UInteger, 
	destinationOrigin:                  Origin, 
) {…}

ResourceStateCommandEncoder_waitForFence #

Source 
@(objc_type=ResourceStateCommandEncoder)
@(objc_name="waitForFence")
ResourceStateCommandEncoder_waitForFence :: proc "c" (self: ^ResourceStateCommandEncoder, fence: ^Fence) {…}

ResourceStatePassDescriptor_alloc #

Source 
@(objc_type=ResourceStatePassDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
ResourceStatePassDescriptor_alloc :: proc "c" () -> ^ResourceStatePassDescriptor {…}

ResourceStatePassDescriptor_resourceStatePassDescriptor #

Source 
@(objc_type=ResourceStatePassDescriptor)
@(objc_name="resourceStatePassDescriptor")
@(objc_is_class_method=true)
ResourceStatePassDescriptor_resourceStatePassDescriptor :: proc "c" () -> ^ResourceStatePassDescriptor {…}

ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex #

Source 
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor)
@(objc_name="setEndOfEncoderSampleIndex")
ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: UInteger) {…}

ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex #

Source 
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor)
@(objc_name="setStartOfEncoderSampleIndex")
ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc "c" (self: ^ResourceStatePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: UInteger) {…}

SamplerDescriptor_alloc #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
SamplerDescriptor_alloc :: proc "c" () -> ^SamplerDescriptor {…}

SamplerDescriptor_lodAverage #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="lodAverage")
SamplerDescriptor_lodAverage :: proc "c" (self: ^SamplerDescriptor) -> bool {…}

SamplerDescriptor_lodMaxClamp #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="lodMaxClamp")
SamplerDescriptor_lodMaxClamp :: proc "c" (self: ^SamplerDescriptor) -> f32 {…}

SamplerDescriptor_lodMinClamp #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="lodMinClamp")
SamplerDescriptor_lodMinClamp :: proc "c" (self: ^SamplerDescriptor) -> f32 {…}

SamplerDescriptor_normalizedCoordinates #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="normalizedCoordinates")
SamplerDescriptor_normalizedCoordinates :: proc "c" (self: ^SamplerDescriptor) -> bool {…}

SamplerDescriptor_setLodAverage #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="setLodAverage")
SamplerDescriptor_setLodAverage :: proc "c" (self: ^SamplerDescriptor, lodAverage: bool) {…}

SamplerDescriptor_setLodMaxClamp #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="setLodMaxClamp")
SamplerDescriptor_setLodMaxClamp :: proc "c" (self: ^SamplerDescriptor, lodMaxClamp: f32) {…}

SamplerDescriptor_setLodMinClamp #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="setLodMinClamp")
SamplerDescriptor_setLodMinClamp :: proc "c" (self: ^SamplerDescriptor, lodMinClamp: f32) {…}

SamplerDescriptor_setMaxAnisotropy #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="setMaxAnisotropy")
SamplerDescriptor_setMaxAnisotropy :: proc "c" (self: ^SamplerDescriptor, maxAnisotropy: UInteger) {…}

SamplerDescriptor_setNormalizedCoordinates #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="setNormalizedCoordinates")
SamplerDescriptor_setNormalizedCoordinates :: proc "c" (self: ^SamplerDescriptor, normalizedCoordinates: bool) {…}

SamplerDescriptor_setSupportArgumentBuffers #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="setSupportArgumentBuffers")
SamplerDescriptor_setSupportArgumentBuffers :: proc "c" (self: ^SamplerDescriptor, supportArgumentBuffers: bool) {…}

SamplerDescriptor_supportArgumentBuffers #

Source 
@(objc_type=SamplerDescriptor)
@(objc_name="supportArgumentBuffers")
SamplerDescriptor_supportArgumentBuffers :: proc "c" (self: ^SamplerDescriptor) -> bool {…}

SharedEvent_setSignaledValue #

Source 
@(objc_type=SharedEvent)
@(objc_name="setSignaledValue")
SharedEvent_setSignaledValue :: proc "c" (self: ^SharedEvent, signaledValue: u64) {…}

SharedEvent_signaledValue #

Source 
@(objc_type=SharedEvent)
@(objc_name="signaledValue")
SharedEvent_signaledValue :: proc "c" (self: ^SharedEvent) -> u64 {…}

SharedEventHandle_alloc #

Source 
@(objc_type=SharedEventHandle)
@(objc_name="alloc")
@(objc_is_class_method=true)
SharedEventHandle_alloc :: proc "c" () -> ^SharedEventHandle {…}

SharedEventListener_alloc #

Source 
@(objc_type=SharedEventListener)
@(objc_name="alloc")
@(objc_is_class_method=true)
SharedEventListener_alloc :: proc "c" () -> ^SharedEventListener {…}

SharedEventListener_dispatchQueue #

Source 
@(objc_type=SharedEventListener)
@(objc_name="dispatchQueue")
SharedEventListener_dispatchQueue :: proc "c" (self: ^SharedEventListener) -> ^Object {…}

SharedTextureHandle_alloc #

Source 
@(objc_type=SharedTextureHandle)
@(objc_name="alloc")
@(objc_is_class_method=true)
SharedTextureHandle_alloc :: proc "c" () -> ^SharedTextureHandle {…}

StageInputOutputDescriptor_alloc #

Source 
@(objc_type=StageInputOutputDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
StageInputOutputDescriptor_alloc :: proc "c" () -> ^StageInputOutputDescriptor {…}

StageInputOutputDescriptor_setIndexBufferIndex #

Source 
@(objc_type=StageInputOutputDescriptor)
@(objc_name="setIndexBufferIndex")
StageInputOutputDescriptor_setIndexBufferIndex :: proc "c" (self: ^StageInputOutputDescriptor, indexBufferIndex: UInteger) {…}

StageInputOutputDescriptor_stageInputOutputDescriptor #

Source 
@(objc_type=StageInputOutputDescriptor)
@(objc_name="stageInputOutputDescriptor")
@(objc_is_class_method=true)
StageInputOutputDescriptor_stageInputOutputDescriptor :: proc "c" () -> ^StageInputOutputDescriptor {…}

StencilDescriptor_alloc #

Source 
@(objc_type=StencilDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
StencilDescriptor_alloc :: proc "c" () -> ^StencilDescriptor {…}

StencilDescriptor_readMask #

Source 
@(objc_type=StencilDescriptor)
@(objc_name="readMask")
StencilDescriptor_readMask :: proc "c" (self: ^StencilDescriptor) -> u32 {…}

StencilDescriptor_setDepthFailureOperation #

Source 
@(objc_type=StencilDescriptor)
@(objc_name="setDepthFailureOperation")
StencilDescriptor_setDepthFailureOperation :: proc "c" (self: ^StencilDescriptor, depthFailureOperation: StencilOperation) {…}

StencilDescriptor_setDepthStencilPassOperation #

Source 
@(objc_type=StencilDescriptor)
@(objc_name="setDepthStencilPassOperation")
StencilDescriptor_setDepthStencilPassOperation :: proc "c" (self: ^StencilDescriptor, depthStencilPassOperation: StencilOperation) {…}

StencilDescriptor_setReadMask #

Source 
@(objc_type=StencilDescriptor)
@(objc_name="setReadMask")
StencilDescriptor_setReadMask :: proc "c" (self: ^StencilDescriptor, readMask: u32) {…}

StencilDescriptor_setStencilCompareFunction #

Source 
@(objc_type=StencilDescriptor)
@(objc_name="setStencilCompareFunction")
StencilDescriptor_setStencilCompareFunction :: proc "c" (self: ^StencilDescriptor, stencilCompareFunction: CompareFunction) {…}

StencilDescriptor_setStencilFailureOperation #

Source 
@(objc_type=StencilDescriptor)
@(objc_name="setStencilFailureOperation")
StencilDescriptor_setStencilFailureOperation :: proc "c" (self: ^StencilDescriptor, stencilFailureOperation: StencilOperation) {…}

StencilDescriptor_setWriteMask #

Source 
@(objc_type=StencilDescriptor)
@(objc_name="setWriteMask")
StencilDescriptor_setWriteMask :: proc "c" (self: ^StencilDescriptor, writeMask: u32) {…}

StencilDescriptor_writeMask #

Source 
@(objc_type=StencilDescriptor)
@(objc_name="writeMask")
StencilDescriptor_writeMask :: proc "c" (self: ^StencilDescriptor) -> u32 {…}

StructMember_alloc #

Source 
@(objc_type=StructMember)
@(objc_name="alloc")
@(objc_is_class_method=true)
StructMember_alloc :: proc "c" () -> ^StructMember {…}

StructMember_argumentIndex #

Source 
@(objc_type=StructMember)
@(objc_name="argumentIndex")
StructMember_argumentIndex :: proc "c" (self: ^StructMember) -> UInteger {…}

StructType_alloc #

Source 
@(objc_type=StructType)
@(objc_name="alloc")
@(objc_is_class_method=true)
StructType_alloc :: proc "c" () -> ^StructType {…}

Texture_allowGPUOptimizedContents #

Source 
@(objc_type=Texture)
@(objc_name="allowGPUOptimizedContents")
Texture_allowGPUOptimizedContents :: proc "c" (self: ^Texture) -> bool {…}

Texture_bufferBytesPerRow #

Source 
@(objc_type=Texture)
@(objc_name="bufferBytesPerRow")
Texture_bufferBytesPerRow :: proc "c" (self: ^Texture) -> UInteger {…}

Texture_bufferOffset #

Source 
@(objc_type=Texture)
@(objc_name="bufferOffset")
Texture_bufferOffset :: proc "c" (self: ^Texture) -> UInteger {…}

Texture_firstMipmapInTail #

Source 
@(objc_type=Texture)
@(objc_name="firstMipmapInTail")
Texture_firstMipmapInTail :: proc "c" (self: ^Texture) -> UInteger {…}

Texture_iosurfacePlane #

Source 
@(objc_type=Texture)
@(objc_name="iosurfacePlane")
Texture_iosurfacePlane :: proc "c" (self: ^Texture) -> UInteger {…}

Texture_isFramebufferOnly #

Source 
@(objc_type=Texture)
@(objc_name="isFramebufferOnly")
Texture_isFramebufferOnly :: proc "c" (self: ^Texture) -> bool {…}

Texture_isShareable #

Source 
@(objc_type=Texture)
@(objc_name="isShareable")
Texture_isShareable :: proc "c" (self: ^Texture) -> bool {…}

Texture_isSparse #

Source 
@(objc_type=Texture)
@(objc_name="isSparse")
Texture_isSparse :: proc "c" (self: ^Texture) -> bool {…}

Texture_mipmapLevelCount #

Source 
@(objc_type=Texture)
@(objc_name="mipmapLevelCount")
Texture_mipmapLevelCount :: proc "c" (self: ^Texture) -> UInteger {…}

Texture_newRemoteTextureViewForDevice #

Source 
@(objc_type=Texture)
@(objc_name="newRemoteTextureViewForDevice")
Texture_newRemoteTextureViewForDevice :: proc "c" (self: ^Texture, device: ^Device) -> ^Texture {…}

Texture_newTextureViewWithPixelFormat #

Source 
@(objc_type=Texture)
@(objc_name="newTextureViewWithPixelFormat")
Texture_newTextureViewWithPixelFormat :: proc "c" (self: ^Texture, pixelFormat: PixelFormat) -> ^Texture {…}

Texture_parentRelativeLevel #

Source 
@(objc_type=Texture)
@(objc_name="parentRelativeLevel")
Texture_parentRelativeLevel :: proc "c" (self: ^Texture) -> UInteger {…}

Texture_parentRelativeSlice #

Source 
@(objc_type=Texture)
@(objc_name="parentRelativeSlice")
Texture_parentRelativeSlice :: proc "c" (self: ^Texture) -> UInteger {…}

Texture_parentTexture #

Source 
@(objc_type=Texture)
@(objc_name="parentTexture")
Texture_parentTexture :: proc "c" (self: ^Texture) -> ^Texture {…}

Texture_remoteStorageTexture #

Source 
@(objc_type=Texture)
@(objc_name="remoteStorageTexture")
Texture_remoteStorageTexture :: proc "c" (self: ^Texture) -> ^Texture {…}

Texture_rootResource #

Source 
@(objc_type=Texture)
@(objc_name="rootResource")
Texture_rootResource :: proc "c" (self: ^Texture) -> ^Resource {…}

Texture_tailSizeInBytes #

Source 
@(objc_type=Texture)
@(objc_name="tailSizeInBytes")
Texture_tailSizeInBytes :: proc "c" (self: ^Texture) -> UInteger {…}

TextureBinding_isDepthTexture #

Source 
@(objc_type=TextureBinding)
@(objc_name="isDepthTexture")
TextureBinding_isDepthTexture :: proc "c" (self: ^TextureBinding) -> bool {…}

TextureBinding_textureDataType #

Source 
@(objc_type=TextureBinding)
@(objc_name="textureDataType")
TextureBinding_textureDataType :: proc "c" (self: ^TextureBinding) -> DataType {…}

TextureDescriptor_alloc #

Source 
@(objc_type=TextureDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
TextureDescriptor_alloc :: proc "c" () -> ^TextureDescriptor {…}

TextureDescriptor_allowGPUOptimizedContents #

Source 
@(objc_type=TextureDescriptor)
@(objc_name="allowGPUOptimizedContents")
TextureDescriptor_allowGPUOptimizedContents :: proc "c" (self: ^TextureDescriptor) -> bool {…}

TextureDescriptor_mipmapLevelCount #

Source 
@(objc_type=TextureDescriptor)
@(objc_name="mipmapLevelCount")
TextureDescriptor_mipmapLevelCount :: proc "c" (self: ^TextureDescriptor) -> UInteger {…}

TextureDescriptor_setAllowGPUOptimizedContents #

Source 
@(objc_type=TextureDescriptor)
@(objc_name="setAllowGPUOptimizedContents")
TextureDescriptor_setAllowGPUOptimizedContents :: proc "c" (self: ^TextureDescriptor, allowGPUOptimizedContents: bool) {…}

TextureDescriptor_setArrayLength #

Source 
@(objc_type=TextureDescriptor)
@(objc_name="setArrayLength")
TextureDescriptor_setArrayLength :: proc "c" (self: ^TextureDescriptor, arrayLength: UInteger) {…}

TextureDescriptor_setMipmapLevelCount #

Source 
@(objc_type=TextureDescriptor)
@(objc_name="setMipmapLevelCount")
TextureDescriptor_setMipmapLevelCount :: proc "c" (self: ^TextureDescriptor, mipmapLevelCount: UInteger) {…}

TextureDescriptor_setSampleCount #

Source 
@(objc_type=TextureDescriptor)
@(objc_name="setSampleCount")
TextureDescriptor_setSampleCount :: proc "c" (self: ^TextureDescriptor, sampleCount: UInteger) {…}

TextureDescriptor_texture2DDescriptorWithPixelFormat #

Source 
@(objc_type=TextureDescriptor)
@(objc_name="texture2DDescriptorWithPixelFormat")
@(objc_is_class_method=true)
TextureDescriptor_texture2DDescriptorWithPixelFormat :: proc "c" (pixelFormat: PixelFormat, width: UInteger, height: UInteger, mipmapped: bool) -> ^TextureDescriptor {…}

TextureDescriptor_textureCubeDescriptorWithPixelFormat #

Source 
@(objc_type=TextureDescriptor)
@(objc_name="textureCubeDescriptorWithPixelFormat")
@(objc_is_class_method=true)
TextureDescriptor_textureCubeDescriptorWithPixelFormat :: proc "c" (pixelFormat: PixelFormat, size: UInteger, mipmapped: bool) -> ^TextureDescriptor {…}

TextureReferenceType_alloc #

Source 
@(objc_type=TextureReferenceType)
@(objc_name="alloc")
@(objc_is_class_method=true)
TextureReferenceType_alloc :: proc "c" () -> ^TextureReferenceType {…}

TextureReferenceType_isDepthTexture #

Source 
@(objc_type=TextureReferenceType)
@(objc_name="isDepthTexture")
TextureReferenceType_isDepthTexture :: proc "c" (self: ^TextureReferenceType) -> bool {…}

ThreadgroupBinding_threadgroupMemoryAlignment #

Source 
@(objc_type=ThreadgroupBinding)
@(objc_name="threadgroupMemoryAlignment")
ThreadgroupBinding_threadgroupMemoryAlignment :: proc "c" (self: ^ThreadgroupBinding) -> UInteger {…}

ThreadgroupBinding_threadgroupMemoryDataSize #

Source 
@(objc_type=ThreadgroupBinding)
@(objc_name="threadgroupMemoryDataSize")
ThreadgroupBinding_threadgroupMemoryDataSize :: proc "c" (self: ^ThreadgroupBinding) -> UInteger {…}

TileRenderPipelineColorAttachmentDescriptor_alloc #

Source 
@(objc_type=TileRenderPipelineColorAttachmentDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
TileRenderPipelineColorAttachmentDescriptor_alloc :: proc "c" () -> ^TileRenderPipelineColorAttachmentDescriptor {…}

TileRenderPipelineDescriptor_alloc #

Source 
@(objc_type=TileRenderPipelineDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
TileRenderPipelineDescriptor_alloc :: proc "c" () -> ^TileRenderPipelineDescriptor {…}

TileRenderPipelineDescriptor_binaryArchives #

Source 
@(objc_type=TileRenderPipelineDescriptor)
@(objc_name="binaryArchives")
TileRenderPipelineDescriptor_binaryArchives :: proc "c" (self: ^TileRenderPipelineDescriptor) -> ^Array {…}

TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup #

Source 
@(objc_type=TileRenderPipelineDescriptor)
@(objc_name="maxTotalThreadsPerThreadgroup")
TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup :: proc "c" (self: ^TileRenderPipelineDescriptor) -> UInteger {…}

TileRenderPipelineDescriptor_setBinaryArchives #

Source 
@(objc_type=TileRenderPipelineDescriptor)
@(objc_name="setBinaryArchives")
TileRenderPipelineDescriptor_setBinaryArchives :: proc "c" (self: ^TileRenderPipelineDescriptor, binaryArchives: ^Array) {…}

TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup #

Source 
@(objc_type=TileRenderPipelineDescriptor)
@(objc_name="setMaxTotalThreadsPerThreadgroup")
TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: proc "c" (self: ^TileRenderPipelineDescriptor, maxTotalThreadsPerThreadgroup: UInteger) {…}

TileRenderPipelineDescriptor_setRasterSampleCount #

Source 
@(objc_type=TileRenderPipelineDescriptor)
@(objc_name="setRasterSampleCount")
TileRenderPipelineDescriptor_setRasterSampleCount :: proc "c" (self: ^TileRenderPipelineDescriptor, rasterSampleCount: UInteger) {…}

TileRenderPipelineDescriptor_setThreadgroupSizeMatchesTileSize #

Source 
@(objc_type=TileRenderPipelineDescriptor)
@(objc_name="setThreadgroupSizeMatchesTileSize")
TileRenderPipelineDescriptor_setThreadgroupSizeMatchesTileSize :: proc "c" (self: ^TileRenderPipelineDescriptor, threadgroupSizeMatchesTileSize: bool) {…}

TileRenderPipelineDescriptor_setTileFunction #

Source 
@(objc_type=TileRenderPipelineDescriptor)
@(objc_name="setTileFunction")
TileRenderPipelineDescriptor_setTileFunction :: proc "c" (self: ^TileRenderPipelineDescriptor, tileFunction: ^Function) {…}

TileRenderPipelineDescriptor_threadgroupSizeMatchesTileSize #

Source 
@(objc_type=TileRenderPipelineDescriptor)
@(objc_name="threadgroupSizeMatchesTileSize")
TileRenderPipelineDescriptor_threadgroupSizeMatchesTileSize :: proc "c" (self: ^TileRenderPipelineDescriptor) -> bool {…}

Type_alloc #

Source 
@(objc_type=Type)
@(objc_name="alloc")
@(objc_is_class_method=true)
Type_alloc :: proc "c" () -> ^Type {…}

VertexAttribute_alloc #

Source 
@(objc_type=VertexAttribute)
@(objc_name="alloc")
@(objc_is_class_method=true)
VertexAttribute_alloc :: proc "c" () -> ^VertexAttribute {…}

VertexAttribute_attributeIndex #

Source 
@(objc_type=VertexAttribute)
@(objc_name="attributeIndex")
VertexAttribute_attributeIndex :: proc "c" (self: ^VertexAttribute) -> UInteger {…}

VertexAttribute_isPatchControlPointData #

Source 
@(objc_type=VertexAttribute)
@(objc_name="isPatchControlPointData")
VertexAttribute_isPatchControlPointData :: proc "c" (self: ^VertexAttribute) -> bool {…}

VertexAttribute_isPatchData #

Source 
@(objc_type=VertexAttribute)
@(objc_name="isPatchData")
VertexAttribute_isPatchData :: proc "c" (self: ^VertexAttribute) -> bool {…}

VertexAttributeDescriptor_alloc #

Source 
@(objc_type=VertexAttributeDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
VertexAttributeDescriptor_alloc :: proc "c" () -> ^VertexAttributeDescriptor {…}

VertexAttributeDescriptor_setBufferIndex #

Source 
@(objc_type=VertexAttributeDescriptor)
@(objc_name="setBufferIndex")
VertexAttributeDescriptor_setBufferIndex :: proc "c" (self: ^VertexAttributeDescriptor, bufferIndex: UInteger) {…}

VertexAttributeDescriptorArray_alloc #

Source 
@(objc_type=VertexAttributeDescriptorArray)
@(objc_name="alloc")
@(objc_is_class_method=true)
VertexAttributeDescriptorArray_alloc :: proc "c" () -> ^VertexAttributeDescriptorArray {…}

VertexBufferLayoutDescriptor_alloc #

Source 
@(objc_type=VertexBufferLayoutDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
VertexBufferLayoutDescriptor_alloc :: proc "c" () -> ^VertexBufferLayoutDescriptor {…}

VertexBufferLayoutDescriptorArray_alloc #

Source 
@(objc_type=VertexBufferLayoutDescriptorArray)
@(objc_name="alloc")
@(objc_is_class_method=true)
VertexBufferLayoutDescriptorArray_alloc :: proc "c" () -> ^VertexBufferLayoutDescriptorArray {…}

VertexDescriptor_alloc #

Source 
@(objc_type=VertexDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
VertexDescriptor_alloc :: proc "c" () -> ^VertexDescriptor {…}

VertexDescriptor_reset #

Source 
@(objc_type=VertexDescriptor)
@(objc_name="reset")
VertexDescriptor_reset :: proc "c" (self: ^VertexDescriptor) {…}

VertexDescriptor_vertexDescriptor #

Source 
@(objc_type=VertexDescriptor)
@(objc_name="vertexDescriptor")
@(objc_is_class_method=true)
VertexDescriptor_vertexDescriptor :: proc "c" () -> ^VertexDescriptor {…}

VisibleFunctionTableDescriptor_alloc #

Source 
@(objc_type=VisibleFunctionTableDescriptor)
@(objc_name="alloc")
@(objc_is_class_method=true)
VisibleFunctionTableDescriptor_alloc :: proc "c" () -> ^VisibleFunctionTableDescriptor {…}

VisibleFunctionTableDescriptor_setFunctionCount #

Source 
@(objc_type=VisibleFunctionTableDescriptor)
@(objc_name="setFunctionCount")
VisibleFunctionTableDescriptor_setFunctionCount :: proc "c" (self: ^VisibleFunctionTableDescriptor, functionCount: UInteger) {…}

VisibleFunctionTableDescriptor_visibleFunctionTableDescriptor #

Source 
@(objc_type=VisibleFunctionTableDescriptor)
@(objc_name="visibleFunctionTableDescriptor")
@(objc_is_class_method=true)
VisibleFunctionTableDescriptor_visibleFunctionTableDescriptor :: proc "c" () -> ^VisibleFunctionTableDescriptor {…}

Procedure Groups

12

Device_newComputePipelineState #

Source 
@(objc_type=Device)
@(objc_name="newComputePipelineState")
Device_newComputePipelineState :: proc{
	Device_newComputePipelineStateWithDescriptorWithCompletionHandler,
	Device_newComputePipelineStateWithDescriptorWithReflection,
	Device_newComputePipelineStateWithFunctionWithCompletionHandler,
	Device_newComputePipelineStateWithFunction,
	Device_newComputePipelineStateWithFunctionWithOptionsAndCompletionHandler,
	Device_newComputePipelineStateWithFunctionWithReflection,
}

Device_newRenderPipelineState #

Source 
@(objc_type=Device)
@(objc_name="newRenderPipelineState")
Device_newRenderPipelineState :: proc{
	Device_newRenderPipelineStateWithDescriptorWithCompletionHandler,
	Device_newRenderPipelineStateWithDescriptor,
	Device_newRenderPipelineStateWithDescriptorWithOptionsAndCompletionHandler,
	Device_newRenderPipelineStateWithDescriptorWithReflection,
	Device_newRenderPipelineStateWithTileDescriptorWithCompletionHandler,
	Device_newRenderPipelineStateWithTileDescriptorWithReflection,
}

Variables

23

CommandBufferEncoderInfoErrorKey #

Source 
@(linkage="weak")
CommandBufferEncoderInfoErrorKey: ^^String

CommonCounterClipperInvocations #

Source 
@(linkage="weak")
CommonCounterClipperInvocations: ^String

CommonCounterClipperPrimitivesOut #

Source 
@(linkage="weak")
CommonCounterClipperPrimitivesOut: ^String

CommonCounterComputeKernelInvocations #

Source 
@(linkage="weak")
CommonCounterComputeKernelInvocations: ^String

CommonCounterFragmentInvocations #

Source 
@(linkage="weak")
CommonCounterFragmentInvocations: ^String

CommonCounterPostTessellationVertexCycles #

Source 
@(linkage="weak")
CommonCounterPostTessellationVertexCycles: ^String

CommonCounterPostTessellationVertexInvocations #

Source 
@(linkage="weak")
CommonCounterPostTessellationVertexInvocations: ^String

CommonCounterRenderTargetWriteCycles #

Source 
@(linkage="weak")
CommonCounterRenderTargetWriteCycles: ^String

CommonCounterSetStageUtilization #

Source 
@(linkage="weak")
CommonCounterSetStageUtilization: ^String

CommonCounterTessellationCycles #

Source 
@(linkage="weak")
CommonCounterTessellationCycles: ^String

CommonCounterTessellationInputPatches #

Source 
@(linkage="weak")
CommonCounterTessellationInputPatches: ^String

DeviceRemovalRequestedNotification #

Source 
@(linkage="weak")
DeviceRemovalRequestedNotification: ^String