mirror of
https://github.com/Ed94/Odin.git
synced 2026-06-20 12:44:59 -07:00
gingerBill
8077 lines
378 KiB
Odin
8077 lines
378 KiB
Odin
package objc_Metal
|
|
|
|
import NS "core:sys/darwin/Foundation"
|
|
|
|
foreign import "system:Metal.framework"
|
|
|
|
@(default_calling_convention="c", link_prefix="MTL")
|
|
foreign Metal {
|
|
CopyAllDevices :: proc() -> ^NS.Array ---
|
|
CopyAllDevicesWithObserver :: proc(observer: ^^NS.Object, handler: DeviceNotificationHandler) -> ^NS.Array ---
|
|
CreateSystemDefaultDevice :: proc() -> ^NS.Object ---
|
|
RemoveDeviceObserver :: proc(observer: ^NS.Object) ---
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
AccelerationStructureBoundingBoxGeometryDescriptor
|
|
Class Methods:
|
|
alloc
|
|
descriptor
|
|
Methods:
|
|
init
|
|
boundingBoxBuffer
|
|
boundingBoxBufferOffset
|
|
boundingBoxCount
|
|
boundingBoxStride
|
|
setBoundingBoxBuffer
|
|
setBoundingBoxBufferOffset
|
|
setBoundingBoxCount
|
|
setBoundingBoxStride
|
|
*/
|
|
@(objc_class="MTLAccelerationStructureBoundingBoxGeometryDescriptor")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureBoundingBoxGeometryDescriptor) }
|
|
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="alloc")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_alloc :: proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "alloc")
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="init")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_init :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "init")
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBuffer")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> ^AccelerationStructureBoundingBoxGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, self, "boundingBoxBuffer")
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxBufferOffset")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "boundingBoxBufferOffset")
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxCount")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "boundingBoxCount")
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="boundingBoxStride")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_boundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "boundingBoxStride")
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_class_name="descriptor")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_descriptor :: proc() -> ^AccelerationStructureBoundingBoxGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureBoundingBoxGeometryDescriptor, "descriptor")
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBuffer")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBuffer :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBuffer: ^NS.Object) {
|
|
msgSend(nil, self, "setBoundingBoxBuffer:", boundingBoxBuffer)
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxBufferOffset")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxBufferOffset :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxBufferOffset: NS.Integer) {
|
|
msgSend(nil, self, "setBoundingBoxBufferOffset:", boundingBoxBufferOffset)
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxCount")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxCount :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxCount: NS.Integer) {
|
|
msgSend(nil, self, "setBoundingBoxCount:", boundingBoxCount)
|
|
}
|
|
@(objc_type=AccelerationStructureBoundingBoxGeometryDescriptor, objc_name="setBoundingBoxStride")
|
|
AccelerationStructureBoundingBoxGeometryDescriptor_setBoundingBoxStride :: proc(self: ^AccelerationStructureBoundingBoxGeometryDescriptor, boundingBoxStride: NS.Integer) {
|
|
msgSend(nil, self, "setBoundingBoxStride:", boundingBoxStride)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
AccelerationStructureDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
setUsage
|
|
usage
|
|
*/
|
|
@(objc_class="MTLAccelerationStructureDescriptor")
|
|
AccelerationStructureDescriptor :: struct { using _: NS.Copying(AccelerationStructureDescriptor) }
|
|
|
|
@(objc_type=AccelerationStructureDescriptor, objc_class_name="alloc")
|
|
AccelerationStructureDescriptor_alloc :: proc() -> ^AccelerationStructureDescriptor {
|
|
return msgSend(^AccelerationStructureDescriptor, AccelerationStructureDescriptor, "alloc")
|
|
}
|
|
@(objc_type=AccelerationStructureDescriptor, objc_name="init")
|
|
AccelerationStructureDescriptor_init :: proc(self: ^AccelerationStructureDescriptor) -> ^AccelerationStructureDescriptor {
|
|
return msgSend(^AccelerationStructureDescriptor, self, "init")
|
|
}
|
|
@(objc_type=AccelerationStructureDescriptor, objc_name="setUsage")
|
|
AccelerationStructureDescriptor_setUsage :: proc(self: ^AccelerationStructureDescriptor, usage: AccelerationStructureUsage) {
|
|
msgSend(nil, self, "setUsage:", usage)
|
|
}
|
|
@(objc_type=AccelerationStructureDescriptor, objc_name="usage")
|
|
AccelerationStructureDescriptor_usage :: proc(self: ^AccelerationStructureDescriptor) -> AccelerationStructureUsage {
|
|
return msgSend(AccelerationStructureUsage, self, "usage")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
AccelerationStructureGeometryDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
allowDuplicateIntersectionFunctionInvocation
|
|
intersectionFunctionTableOffset
|
|
opaque
|
|
setAllowDuplicateIntersectionFunctionInvocation
|
|
setIntersectionFunctionTableOffset
|
|
setOpaque
|
|
*/
|
|
@(objc_class="MTLAccelerationStructureGeometryDescriptor")
|
|
AccelerationStructureGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureGeometryDescriptor) }
|
|
|
|
@(objc_type=AccelerationStructureGeometryDescriptor, objc_class_name="alloc")
|
|
AccelerationStructureGeometryDescriptor_alloc :: proc() -> ^AccelerationStructureGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureGeometryDescriptor, AccelerationStructureGeometryDescriptor, "alloc")
|
|
}
|
|
@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="init")
|
|
AccelerationStructureGeometryDescriptor_init :: proc(self: ^AccelerationStructureGeometryDescriptor) -> ^AccelerationStructureGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureGeometryDescriptor, self, "init")
|
|
}
|
|
@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="allowDuplicateIntersectionFunctionInvocation")
|
|
AccelerationStructureGeometryDescriptor_allowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "allowDuplicateIntersectionFunctionInvocation")
|
|
}
|
|
@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="intersectionFunctionTableOffset")
|
|
AccelerationStructureGeometryDescriptor_intersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "intersectionFunctionTableOffset")
|
|
}
|
|
@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="opaque")
|
|
AccelerationStructureGeometryDescriptor_opaque :: proc(self: ^AccelerationStructureGeometryDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "opaque")
|
|
}
|
|
@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setAllowDuplicateIntersectionFunctionInvocation")
|
|
AccelerationStructureGeometryDescriptor_setAllowDuplicateIntersectionFunctionInvocation :: proc(self: ^AccelerationStructureGeometryDescriptor, allowDuplicateIntersectionFunctionInvocation: BOOL) {
|
|
msgSend(nil, self, "setAllowDuplicateIntersectionFunctionInvocation:", allowDuplicateIntersectionFunctionInvocation)
|
|
}
|
|
@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setIntersectionFunctionTableOffset")
|
|
AccelerationStructureGeometryDescriptor_setIntersectionFunctionTableOffset :: proc(self: ^AccelerationStructureGeometryDescriptor, intersectionFunctionTableOffset: NS.Integer) {
|
|
msgSend(nil, self, "setIntersectionFunctionTableOffset:", intersectionFunctionTableOffset)
|
|
}
|
|
@(objc_type=AccelerationStructureGeometryDescriptor, objc_name="setOpaque")
|
|
AccelerationStructureGeometryDescriptor_setOpaque :: proc(self: ^AccelerationStructureGeometryDescriptor, opaque: BOOL) {
|
|
msgSend(nil, self, "setOpaque:", opaque)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
AccelerationStructureTriangleGeometryDescriptor
|
|
Class Methods:
|
|
alloc
|
|
descriptor
|
|
Methods:
|
|
init
|
|
indexBuffer
|
|
indexBufferOffset
|
|
indexType
|
|
setIndexBuffer
|
|
setIndexBufferOffset
|
|
setIndexType
|
|
setTriangleCount
|
|
setVertexBuffer
|
|
setVertexBufferOffset
|
|
setVertexStride
|
|
triangleCount
|
|
vertexBuffer
|
|
vertexBufferOffset
|
|
vertexStride
|
|
*/
|
|
@(objc_class="MTLAccelerationStructureTriangleGeometryDescriptor")
|
|
AccelerationStructureTriangleGeometryDescriptor :: struct { using _: NS.Copying(AccelerationStructureTriangleGeometryDescriptor) }
|
|
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_class_name="alloc")
|
|
AccelerationStructureTriangleGeometryDescriptor_alloc :: proc() -> ^AccelerationStructureTriangleGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "alloc")
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="init")
|
|
AccelerationStructureTriangleGeometryDescriptor_init :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "init")
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_class_name="descriptor")
|
|
AccelerationStructureTriangleGeometryDescriptor_descriptor :: proc() -> ^AccelerationStructureTriangleGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureTriangleGeometryDescriptor, "descriptor")
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBuffer")
|
|
AccelerationStructureTriangleGeometryDescriptor_indexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "indexBuffer")
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexBufferOffset")
|
|
AccelerationStructureTriangleGeometryDescriptor_indexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "indexBufferOffset")
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="indexType")
|
|
AccelerationStructureTriangleGeometryDescriptor_indexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> IndexType {
|
|
return msgSend(IndexType, self, "indexType")
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBuffer")
|
|
AccelerationStructureTriangleGeometryDescriptor_setIndexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBuffer: ^NS.Object) {
|
|
msgSend(nil, self, "setIndexBuffer:", indexBuffer)
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexBufferOffset")
|
|
AccelerationStructureTriangleGeometryDescriptor_setIndexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexBufferOffset: NS.Integer) {
|
|
msgSend(nil, self, "setIndexBufferOffset:", indexBufferOffset)
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setIndexType")
|
|
AccelerationStructureTriangleGeometryDescriptor_setIndexType :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, indexType: IndexType) {
|
|
msgSend(nil, self, "setIndexType:", indexType)
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setTriangleCount")
|
|
AccelerationStructureTriangleGeometryDescriptor_setTriangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, triangleCount: NS.Integer) {
|
|
msgSend(nil, self, "setTriangleCount:", triangleCount)
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBuffer")
|
|
AccelerationStructureTriangleGeometryDescriptor_setVertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBuffer: ^NS.Object) {
|
|
msgSend(nil, self, "setVertexBuffer:", vertexBuffer)
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexBufferOffset")
|
|
AccelerationStructureTriangleGeometryDescriptor_setVertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexBufferOffset: NS.Integer) {
|
|
msgSend(nil, self, "setVertexBufferOffset:", vertexBufferOffset)
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="setVertexStride")
|
|
AccelerationStructureTriangleGeometryDescriptor_setVertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor, vertexStride: NS.Integer) {
|
|
msgSend(nil, self, "setVertexStride:", vertexStride)
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="triangleCount")
|
|
AccelerationStructureTriangleGeometryDescriptor_triangleCount :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "triangleCount")
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBuffer")
|
|
AccelerationStructureTriangleGeometryDescriptor_vertexBuffer :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> ^AccelerationStructureTriangleGeometryDescriptor {
|
|
return msgSend(^AccelerationStructureTriangleGeometryDescriptor, self, "vertexBuffer")
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexBufferOffset")
|
|
AccelerationStructureTriangleGeometryDescriptor_vertexBufferOffset :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "vertexBufferOffset")
|
|
}
|
|
@(objc_type=AccelerationStructureTriangleGeometryDescriptor, objc_name="vertexStride")
|
|
AccelerationStructureTriangleGeometryDescriptor_vertexStride :: proc(self: ^AccelerationStructureTriangleGeometryDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "vertexStride")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Argument
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
access
|
|
arrayLength
|
|
bufferAlignment
|
|
bufferDataSize
|
|
bufferDataType
|
|
bufferPointerType
|
|
bufferStructType
|
|
index
|
|
isActive
|
|
isDepthTexture
|
|
name
|
|
textureDataType
|
|
textureType
|
|
threadgroupMemoryAlignment
|
|
threadgroupMemoryDataSize
|
|
type
|
|
*/
|
|
@(objc_class="MTLArgument")
|
|
Argument :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Argument, objc_class_name="alloc")
|
|
Argument_alloc :: proc() -> ^Argument {
|
|
return msgSend(^Argument, Argument, "alloc")
|
|
}
|
|
@(objc_type=Argument, objc_name="init")
|
|
Argument_init :: proc(self: ^Argument) -> ^Argument {
|
|
return msgSend(^Argument, self, "init")
|
|
}
|
|
@(objc_type=Argument, objc_name="access")
|
|
Argument_access :: proc(self: ^Argument) -> ArgumentAccess {
|
|
return msgSend(ArgumentAccess, self, "access")
|
|
}
|
|
@(objc_type=Argument, objc_name="arrayLength")
|
|
Argument_arrayLength :: proc(self: ^Argument) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "arrayLength")
|
|
}
|
|
@(objc_type=Argument, objc_name="bufferAlignment")
|
|
Argument_bufferAlignment :: proc(self: ^Argument) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "bufferAlignment")
|
|
}
|
|
@(objc_type=Argument, objc_name="bufferDataSize")
|
|
Argument_bufferDataSize :: proc(self: ^Argument) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "bufferDataSize")
|
|
}
|
|
@(objc_type=Argument, objc_name="bufferDataType")
|
|
Argument_bufferDataType :: proc(self: ^Argument) -> DataType {
|
|
return msgSend(DataType, self, "bufferDataType")
|
|
}
|
|
@(objc_type=Argument, objc_name="bufferPointerType")
|
|
Argument_bufferPointerType :: proc(self: ^Argument) -> ^PointerType {
|
|
return msgSend(^PointerType, self, "bufferPointerType")
|
|
}
|
|
@(objc_type=Argument, objc_name="bufferStructType")
|
|
Argument_bufferStructType :: proc(self: ^Argument) -> ^StructType {
|
|
return msgSend(^StructType, self, "bufferStructType")
|
|
}
|
|
@(objc_type=Argument, objc_name="index")
|
|
Argument_index :: proc(self: ^Argument) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "index")
|
|
}
|
|
@(objc_type=Argument, objc_name="isActive")
|
|
Argument_isActive :: proc(self: ^Argument) -> BOOL {
|
|
return msgSend(BOOL, self, "isActive")
|
|
}
|
|
@(objc_type=Argument, objc_name="isDepthTexture")
|
|
Argument_isDepthTexture :: proc(self: ^Argument) -> BOOL {
|
|
return msgSend(BOOL, self, "isDepthTexture")
|
|
}
|
|
@(objc_type=Argument, objc_name="name")
|
|
Argument_name :: proc(self: ^Argument) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
@(objc_type=Argument, objc_name="textureDataType")
|
|
Argument_textureDataType :: proc(self: ^Argument) -> DataType {
|
|
return msgSend(DataType, self, "textureDataType")
|
|
}
|
|
@(objc_type=Argument, objc_name="textureType")
|
|
Argument_textureType :: proc(self: ^Argument) -> TextureType {
|
|
return msgSend(TextureType, self, "textureType")
|
|
}
|
|
@(objc_type=Argument, objc_name="threadgroupMemoryAlignment")
|
|
Argument_threadgroupMemoryAlignment :: proc(self: ^Argument) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "threadgroupMemoryAlignment")
|
|
}
|
|
@(objc_type=Argument, objc_name="threadgroupMemoryDataSize")
|
|
Argument_threadgroupMemoryDataSize :: proc(self: ^Argument) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "threadgroupMemoryDataSize")
|
|
}
|
|
@(objc_type=Argument, objc_name="type")
|
|
Argument_type :: proc(self: ^Argument) -> ArgumentType {
|
|
return msgSend(ArgumentType, self, "type")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ArgumentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
argumentDescriptor
|
|
Methods:
|
|
init
|
|
access
|
|
arrayLength
|
|
constantBlockAlignment
|
|
dataType
|
|
index
|
|
setAccess
|
|
setArrayLength
|
|
setConstantBlockAlignment
|
|
setDataType
|
|
setIndex
|
|
setTextureType
|
|
textureType
|
|
*/
|
|
@(objc_class="MTLArgumentDescriptor")
|
|
ArgumentDescriptor :: struct { using _: NS.Copying(ArgumentDescriptor) }
|
|
|
|
@(objc_type=ArgumentDescriptor, objc_class_name="alloc")
|
|
ArgumentDescriptor_alloc :: proc() -> ^ArgumentDescriptor {
|
|
return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="init")
|
|
ArgumentDescriptor_init :: proc(self: ^ArgumentDescriptor) -> ^ArgumentDescriptor {
|
|
return msgSend(^ArgumentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="access")
|
|
ArgumentDescriptor_access :: proc(self: ^ArgumentDescriptor) -> ArgumentAccess {
|
|
return msgSend(ArgumentAccess, self, "access")
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_class_name="argumentDescriptor")
|
|
ArgumentDescriptor_argumentDescriptor :: proc() -> ^ArgumentDescriptor {
|
|
return msgSend(^ArgumentDescriptor, ArgumentDescriptor, "argumentDescriptor")
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="arrayLength")
|
|
ArgumentDescriptor_arrayLength :: proc(self: ^ArgumentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "arrayLength")
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="constantBlockAlignment")
|
|
ArgumentDescriptor_constantBlockAlignment :: proc(self: ^ArgumentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "constantBlockAlignment")
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="dataType")
|
|
ArgumentDescriptor_dataType :: proc(self: ^ArgumentDescriptor) -> DataType {
|
|
return msgSend(DataType, self, "dataType")
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="index")
|
|
ArgumentDescriptor_index :: proc(self: ^ArgumentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "index")
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="setAccess")
|
|
ArgumentDescriptor_setAccess :: proc(self: ^ArgumentDescriptor, access: ArgumentAccess) {
|
|
msgSend(nil, self, "setAccess:", access)
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="setArrayLength")
|
|
ArgumentDescriptor_setArrayLength :: proc(self: ^ArgumentDescriptor, arrayLength: NS.Integer) {
|
|
msgSend(nil, self, "setArrayLength:", arrayLength)
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="setConstantBlockAlignment")
|
|
ArgumentDescriptor_setConstantBlockAlignment :: proc(self: ^ArgumentDescriptor, constantBlockAlignment: NS.Integer) {
|
|
msgSend(nil, self, "setConstantBlockAlignment:", constantBlockAlignment)
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="setDataType")
|
|
ArgumentDescriptor_setDataType :: proc(self: ^ArgumentDescriptor, dataType: DataType) {
|
|
msgSend(nil, self, "setDataType:", dataType)
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="setIndex")
|
|
ArgumentDescriptor_setIndex :: proc(self: ^ArgumentDescriptor, index: NS.Integer) {
|
|
msgSend(nil, self, "setIndex:", index)
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="setTextureType")
|
|
ArgumentDescriptor_setTextureType :: proc(self: ^ArgumentDescriptor, textureType: TextureType) {
|
|
msgSend(nil, self, "setTextureType:", textureType)
|
|
}
|
|
@(objc_type=ArgumentDescriptor, objc_name="textureType")
|
|
ArgumentDescriptor_textureType :: proc(self: ^ArgumentDescriptor) -> TextureType {
|
|
return msgSend(TextureType, self, "textureType")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ArrayType
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
argumentIndexStride
|
|
arrayLength
|
|
elementArrayType
|
|
elementPointerType
|
|
elementStructType
|
|
elementTextureReferenceType
|
|
elementType
|
|
stride
|
|
*/
|
|
@(objc_class="MTLArrayType")
|
|
ArrayType :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=ArrayType, objc_class_name="alloc")
|
|
ArrayType_alloc :: proc() -> ^ArrayType {
|
|
return msgSend(^ArrayType, ArrayType, "alloc")
|
|
}
|
|
@(objc_type=ArrayType, objc_name="init")
|
|
ArrayType_init :: proc(self: ^ArrayType) -> ^ArrayType {
|
|
return msgSend(^ArrayType, self, "init")
|
|
}
|
|
@(objc_type=ArrayType, objc_name="argumentIndexStride")
|
|
ArrayType_argumentIndexStride :: proc(self: ^ArrayType) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "argumentIndexStride")
|
|
}
|
|
@(objc_type=ArrayType, objc_name="arrayLength")
|
|
ArrayType_arrayLength :: proc(self: ^ArrayType) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "arrayLength")
|
|
}
|
|
@(objc_type=ArrayType, objc_name="elementArrayType")
|
|
ArrayType_elementArrayType :: proc(self: ^ArrayType) -> ^ArrayType {
|
|
return msgSend(^ArrayType, self, "elementArrayType")
|
|
}
|
|
@(objc_type=ArrayType, objc_name="elementPointerType")
|
|
ArrayType_elementPointerType :: proc(self: ^ArrayType) -> ^PointerType {
|
|
return msgSend(^PointerType, self, "elementPointerType")
|
|
}
|
|
@(objc_type=ArrayType, objc_name="elementStructType")
|
|
ArrayType_elementStructType :: proc(self: ^ArrayType) -> ^StructType {
|
|
return msgSend(^StructType, self, "elementStructType")
|
|
}
|
|
@(objc_type=ArrayType, objc_name="elementTextureReferenceType")
|
|
ArrayType_elementTextureReferenceType :: proc(self: ^ArrayType) -> ^TextureReferenceType {
|
|
return msgSend(^TextureReferenceType, self, "elementTextureReferenceType")
|
|
}
|
|
@(objc_type=ArrayType, objc_name="elementType")
|
|
ArrayType_elementType :: proc(self: ^ArrayType) -> DataType {
|
|
return msgSend(DataType, self, "elementType")
|
|
}
|
|
@(objc_type=ArrayType, objc_name="stride")
|
|
ArrayType_stride :: proc(self: ^ArrayType) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "stride")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Attribute
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
attributeIndex
|
|
attributeType
|
|
isActive
|
|
isPatchControlPointData
|
|
isPatchData
|
|
name
|
|
*/
|
|
@(objc_class="MTLAttribute")
|
|
Attribute :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Attribute, objc_class_name="alloc")
|
|
Attribute_alloc :: proc() -> ^Attribute {
|
|
return msgSend(^Attribute, Attribute, "alloc")
|
|
}
|
|
@(objc_type=Attribute, objc_name="init")
|
|
Attribute_init :: proc(self: ^Attribute) -> ^Attribute {
|
|
return msgSend(^Attribute, self, "init")
|
|
}
|
|
@(objc_type=Attribute, objc_name="attributeIndex")
|
|
Attribute_attributeIndex :: proc(self: ^Attribute) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "attributeIndex")
|
|
}
|
|
@(objc_type=Attribute, objc_name="attributeType")
|
|
Attribute_attributeType :: proc(self: ^Attribute) -> DataType {
|
|
return msgSend(DataType, self, "attributeType")
|
|
}
|
|
@(objc_type=Attribute, objc_name="isActive")
|
|
Attribute_isActive :: proc(self: ^Attribute) -> BOOL {
|
|
return msgSend(BOOL, self, "isActive")
|
|
}
|
|
@(objc_type=Attribute, objc_name="isPatchControlPointData")
|
|
Attribute_isPatchControlPointData :: proc(self: ^Attribute) -> BOOL {
|
|
return msgSend(BOOL, self, "isPatchControlPointData")
|
|
}
|
|
@(objc_type=Attribute, objc_name="isPatchData")
|
|
Attribute_isPatchData :: proc(self: ^Attribute) -> BOOL {
|
|
return msgSend(BOOL, self, "isPatchData")
|
|
}
|
|
@(objc_type=Attribute, objc_name="name")
|
|
Attribute_name :: proc(self: ^Attribute) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
AttributeDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
bufferIndex
|
|
format
|
|
offset
|
|
setBufferIndex
|
|
setFormat
|
|
setOffset
|
|
*/
|
|
@(objc_class="MTLAttributeDescriptor")
|
|
AttributeDescriptor :: struct { using _: NS.Copying(AttributeDescriptor) }
|
|
|
|
@(objc_type=AttributeDescriptor, objc_class_name="alloc")
|
|
AttributeDescriptor_alloc :: proc() -> ^AttributeDescriptor {
|
|
return msgSend(^AttributeDescriptor, AttributeDescriptor, "alloc")
|
|
}
|
|
@(objc_type=AttributeDescriptor, objc_name="init")
|
|
AttributeDescriptor_init :: proc(self: ^AttributeDescriptor) -> ^AttributeDescriptor {
|
|
return msgSend(^AttributeDescriptor, self, "init")
|
|
}
|
|
@(objc_type=AttributeDescriptor, objc_name="bufferIndex")
|
|
AttributeDescriptor_bufferIndex :: proc(self: ^AttributeDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "bufferIndex")
|
|
}
|
|
@(objc_type=AttributeDescriptor, objc_name="format")
|
|
AttributeDescriptor_format :: proc(self: ^AttributeDescriptor) -> AttributeFormat {
|
|
return msgSend(AttributeFormat, self, "format")
|
|
}
|
|
@(objc_type=AttributeDescriptor, objc_name="offset")
|
|
AttributeDescriptor_offset :: proc(self: ^AttributeDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "offset")
|
|
}
|
|
@(objc_type=AttributeDescriptor, objc_name="setBufferIndex")
|
|
AttributeDescriptor_setBufferIndex :: proc(self: ^AttributeDescriptor, bufferIndex: NS.Integer) {
|
|
msgSend(nil, self, "setBufferIndex:", bufferIndex)
|
|
}
|
|
@(objc_type=AttributeDescriptor, objc_name="setFormat")
|
|
AttributeDescriptor_setFormat :: proc(self: ^AttributeDescriptor, format: AttributeFormat) {
|
|
msgSend(nil, self, "setFormat:", format)
|
|
}
|
|
@(objc_type=AttributeDescriptor, objc_name="setOffset")
|
|
AttributeDescriptor_setOffset :: proc(self: ^AttributeDescriptor, offset: NS.Integer) {
|
|
msgSend(nil, self, "setOffset:", offset)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
AttributeDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLAttributeDescriptorArray")
|
|
AttributeDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=AttributeDescriptorArray, objc_class_name="alloc")
|
|
AttributeDescriptorArray_alloc :: proc() -> ^AttributeDescriptorArray {
|
|
return msgSend(^AttributeDescriptorArray, AttributeDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=AttributeDescriptorArray, objc_name="init")
|
|
AttributeDescriptorArray_init :: proc(self: ^AttributeDescriptorArray) -> ^AttributeDescriptorArray {
|
|
return msgSend(^AttributeDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=AttributeDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
AttributeDescriptorArray_objectAtIndexedSubscript :: proc(self: ^AttributeDescriptorArray, index: ^NS.Object) -> ^AttributeDescriptor {
|
|
return msgSend(^AttributeDescriptor, self, "objectAtIndexedSubscript:", index)
|
|
}
|
|
@(objc_type=AttributeDescriptorArray, objc_name="setObject")
|
|
AttributeDescriptorArray_setObject :: proc(self: ^AttributeDescriptorArray, attributeDesc: ^AttributeDescriptor, index: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
BinaryArchiveDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
setUrl
|
|
url
|
|
*/
|
|
@(objc_class="MTLBinaryArchiveDescriptor")
|
|
BinaryArchiveDescriptor :: struct { using _: NS.Copying(BinaryArchiveDescriptor) }
|
|
|
|
@(objc_type=BinaryArchiveDescriptor, objc_class_name="alloc")
|
|
BinaryArchiveDescriptor_alloc :: proc() -> ^BinaryArchiveDescriptor {
|
|
return msgSend(^BinaryArchiveDescriptor, BinaryArchiveDescriptor, "alloc")
|
|
}
|
|
@(objc_type=BinaryArchiveDescriptor, objc_name="init")
|
|
BinaryArchiveDescriptor_init :: proc(self: ^BinaryArchiveDescriptor) -> ^BinaryArchiveDescriptor {
|
|
return msgSend(^BinaryArchiveDescriptor, self, "init")
|
|
}
|
|
@(objc_type=BinaryArchiveDescriptor, objc_name="setUrl")
|
|
BinaryArchiveDescriptor_setUrl :: proc(self: ^BinaryArchiveDescriptor, url: ^NS.URL) {
|
|
msgSend(nil, self, "setUrl:", url)
|
|
}
|
|
@(objc_type=BinaryArchiveDescriptor, objc_name="url")
|
|
BinaryArchiveDescriptor_url :: proc(self: ^BinaryArchiveDescriptor) -> ^NS.URL {
|
|
return msgSend(^NS.URL, self, "url")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
BlitPassDescriptor
|
|
Class Methods:
|
|
alloc
|
|
blitPassDescriptor
|
|
Methods:
|
|
init
|
|
sampleBufferAttachments
|
|
*/
|
|
@(objc_class="MTLBlitPassDescriptor")
|
|
BlitPassDescriptor :: struct { using _: NS.Copying(BlitPassDescriptor) }
|
|
|
|
@(objc_type=BlitPassDescriptor, objc_class_name="alloc")
|
|
BlitPassDescriptor_alloc :: proc() -> ^BlitPassDescriptor {
|
|
return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "alloc")
|
|
}
|
|
@(objc_type=BlitPassDescriptor, objc_name="init")
|
|
BlitPassDescriptor_init :: proc(self: ^BlitPassDescriptor) -> ^BlitPassDescriptor {
|
|
return msgSend(^BlitPassDescriptor, self, "init")
|
|
}
|
|
@(objc_type=BlitPassDescriptor, objc_class_name="blitPassDescriptor")
|
|
BlitPassDescriptor_blitPassDescriptor :: proc() -> ^BlitPassDescriptor {
|
|
return msgSend(^BlitPassDescriptor, BlitPassDescriptor, "blitPassDescriptor")
|
|
}
|
|
@(objc_type=BlitPassDescriptor, objc_name="sampleBufferAttachments")
|
|
BlitPassDescriptor_sampleBufferAttachments :: proc(self: ^BlitPassDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
BlitPassSampleBufferAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
endOfEncoderSampleIndex
|
|
sampleBuffer
|
|
setEndOfEncoderSampleIndex
|
|
setSampleBuffer
|
|
setStartOfEncoderSampleIndex
|
|
startOfEncoderSampleIndex
|
|
*/
|
|
@(objc_class="MTLBlitPassSampleBufferAttachmentDescriptor")
|
|
BlitPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(BlitPassSampleBufferAttachmentDescriptor) }
|
|
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_class_name="alloc")
|
|
BlitPassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^BlitPassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^BlitPassSampleBufferAttachmentDescriptor, BlitPassSampleBufferAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="init")
|
|
BlitPassSampleBufferAttachmentDescriptor_init :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex")
|
|
BlitPassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "endOfEncoderSampleIndex")
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer")
|
|
BlitPassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> ^BlitPassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "sampleBuffer")
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex")
|
|
BlitPassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex)
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer")
|
|
BlitPassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) {
|
|
msgSend(nil, self, "setSampleBuffer:", sampleBuffer)
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex")
|
|
BlitPassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex)
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex")
|
|
BlitPassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc(self: ^BlitPassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "startOfEncoderSampleIndex")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
BlitPassSampleBufferAttachmentDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLBlitPassSampleBufferAttachmentDescriptorArray")
|
|
BlitPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc")
|
|
BlitPassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^BlitPassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, BlitPassSampleBufferAttachmentDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="init")
|
|
BlitPassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray) -> ^BlitPassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^BlitPassSampleBufferAttachmentDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
BlitPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^BlitPassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^BlitPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex)
|
|
}
|
|
@(objc_type=BlitPassSampleBufferAttachmentDescriptorArray, objc_name="setObject")
|
|
BlitPassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^BlitPassSampleBufferAttachmentDescriptorArray, attachment: ^BlitPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
BufferLayoutDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
setStepFunction
|
|
setStepRate
|
|
setStride
|
|
stepFunction
|
|
stepRate
|
|
stride
|
|
*/
|
|
@(objc_class="MTLBufferLayoutDescriptor")
|
|
BufferLayoutDescriptor :: struct { using _: NS.Copying(BufferLayoutDescriptor) }
|
|
|
|
@(objc_type=BufferLayoutDescriptor, objc_class_name="alloc")
|
|
BufferLayoutDescriptor_alloc :: proc() -> ^BufferLayoutDescriptor {
|
|
return msgSend(^BufferLayoutDescriptor, BufferLayoutDescriptor, "alloc")
|
|
}
|
|
@(objc_type=BufferLayoutDescriptor, objc_name="init")
|
|
BufferLayoutDescriptor_init :: proc(self: ^BufferLayoutDescriptor) -> ^BufferLayoutDescriptor {
|
|
return msgSend(^BufferLayoutDescriptor, self, "init")
|
|
}
|
|
@(objc_type=BufferLayoutDescriptor, objc_name="setStepFunction")
|
|
BufferLayoutDescriptor_setStepFunction :: proc(self: ^BufferLayoutDescriptor, stepFunction: StepFunction) {
|
|
msgSend(nil, self, "setStepFunction:", stepFunction)
|
|
}
|
|
@(objc_type=BufferLayoutDescriptor, objc_name="setStepRate")
|
|
BufferLayoutDescriptor_setStepRate :: proc(self: ^BufferLayoutDescriptor, stepRate: NS.Integer) {
|
|
msgSend(nil, self, "setStepRate:", stepRate)
|
|
}
|
|
@(objc_type=BufferLayoutDescriptor, objc_name="setStride")
|
|
BufferLayoutDescriptor_setStride :: proc(self: ^BufferLayoutDescriptor, stride: NS.Integer) {
|
|
msgSend(nil, self, "setStride:", stride)
|
|
}
|
|
@(objc_type=BufferLayoutDescriptor, objc_name="stepFunction")
|
|
BufferLayoutDescriptor_stepFunction :: proc(self: ^BufferLayoutDescriptor) -> StepFunction {
|
|
return msgSend(StepFunction, self, "stepFunction")
|
|
}
|
|
@(objc_type=BufferLayoutDescriptor, objc_name="stepRate")
|
|
BufferLayoutDescriptor_stepRate :: proc(self: ^BufferLayoutDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "stepRate")
|
|
}
|
|
@(objc_type=BufferLayoutDescriptor, objc_name="stride")
|
|
BufferLayoutDescriptor_stride :: proc(self: ^BufferLayoutDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "stride")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
BufferLayoutDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLBufferLayoutDescriptorArray")
|
|
BufferLayoutDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=BufferLayoutDescriptorArray, objc_class_name="alloc")
|
|
BufferLayoutDescriptorArray_alloc :: proc() -> ^BufferLayoutDescriptorArray {
|
|
return msgSend(^BufferLayoutDescriptorArray, BufferLayoutDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=BufferLayoutDescriptorArray, objc_name="init")
|
|
BufferLayoutDescriptorArray_init :: proc(self: ^BufferLayoutDescriptorArray) -> ^BufferLayoutDescriptorArray {
|
|
return msgSend(^BufferLayoutDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=BufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
BufferLayoutDescriptorArray_objectAtIndexedSubscript :: proc(self: ^BufferLayoutDescriptorArray, index: ^NS.Object) -> ^BufferLayoutDescriptor {
|
|
return msgSend(^BufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index)
|
|
}
|
|
@(objc_type=BufferLayoutDescriptorArray, objc_name="setObject")
|
|
BufferLayoutDescriptorArray_setObject :: proc(self: ^BufferLayoutDescriptorArray, bufferDesc: ^BufferLayoutDescriptor, index: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CaptureDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
captureObject
|
|
destination
|
|
outputURL
|
|
setCaptureObject
|
|
setDestination
|
|
setOutputURL
|
|
*/
|
|
@(objc_class="MTLCaptureDescriptor")
|
|
CaptureDescriptor :: struct { using _: NS.Copying(CaptureDescriptor) }
|
|
|
|
@(objc_type=CaptureDescriptor, objc_class_name="alloc")
|
|
CaptureDescriptor_alloc :: proc() -> ^CaptureDescriptor {
|
|
return msgSend(^CaptureDescriptor, CaptureDescriptor, "alloc")
|
|
}
|
|
@(objc_type=CaptureDescriptor, objc_name="init")
|
|
CaptureDescriptor_init :: proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor {
|
|
return msgSend(^CaptureDescriptor, self, "init")
|
|
}
|
|
@(objc_type=CaptureDescriptor, objc_name="captureObject")
|
|
CaptureDescriptor_captureObject :: proc(self: ^CaptureDescriptor) -> ^CaptureDescriptor {
|
|
return msgSend(^CaptureDescriptor, self, "captureObject")
|
|
}
|
|
@(objc_type=CaptureDescriptor, objc_name="destination")
|
|
CaptureDescriptor_destination :: proc(self: ^CaptureDescriptor) -> CaptureDestination {
|
|
return msgSend(CaptureDestination, self, "destination")
|
|
}
|
|
@(objc_type=CaptureDescriptor, objc_name="outputURL")
|
|
CaptureDescriptor_outputURL :: proc(self: ^CaptureDescriptor) -> ^NS.URL {
|
|
return msgSend(^NS.URL, self, "outputURL")
|
|
}
|
|
@(objc_type=CaptureDescriptor, objc_name="setCaptureObject")
|
|
CaptureDescriptor_setCaptureObject :: proc(self: ^CaptureDescriptor, captureObject: ^NS.Object) {
|
|
msgSend(nil, self, "setCaptureObject:", captureObject)
|
|
}
|
|
@(objc_type=CaptureDescriptor, objc_name="setDestination")
|
|
CaptureDescriptor_setDestination :: proc(self: ^CaptureDescriptor, destination: CaptureDestination) {
|
|
msgSend(nil, self, "setDestination:", destination)
|
|
}
|
|
@(objc_type=CaptureDescriptor, objc_name="setOutputURL")
|
|
CaptureDescriptor_setOutputURL :: proc(self: ^CaptureDescriptor, outputURL: ^NS.URL) {
|
|
msgSend(nil, self, "setOutputURL:", outputURL)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CaptureManager
|
|
Class Methods:
|
|
alloc
|
|
sharedCaptureManager
|
|
Methods:
|
|
defaultCaptureScope
|
|
init
|
|
isCapturing
|
|
newCaptureScopeWithCommandQueue
|
|
newCaptureScopeWithDevice
|
|
setDefaultCaptureScope
|
|
startCaptureWithCommandQueue
|
|
startCaptureWithDescriptor
|
|
startCaptureWithDevice
|
|
startCaptureWithScope
|
|
stopCapture
|
|
supportsDestination
|
|
*/
|
|
@(objc_class="MTLCaptureManager")
|
|
CaptureManager :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=CaptureManager, objc_class_name="alloc")
|
|
CaptureManager_alloc :: proc() -> ^CaptureManager {
|
|
return msgSend(^CaptureManager, CaptureManager, "alloc")
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="defaultCaptureScope")
|
|
CaptureManager_defaultCaptureScope :: proc(self: ^CaptureManager) -> ^CaptureManager {
|
|
return msgSend(^CaptureManager, self, "defaultCaptureScope")
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="init")
|
|
CaptureManager_init :: proc(self: ^CaptureManager) -> ^CaptureManager {
|
|
return msgSend(^CaptureManager, self, "init")
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="isCapturing")
|
|
CaptureManager_isCapturing :: proc(self: ^CaptureManager) -> BOOL {
|
|
return msgSend(BOOL, self, "isCapturing")
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="newCaptureScopeWithCommandQueue")
|
|
CaptureManager_newCaptureScopeWithCommandQueue :: proc(self: ^CaptureManager, commandQueue: ^NS.Object) -> ^CaptureManager {
|
|
return msgSend(^CaptureManager, self, "newCaptureScopeWithCommandQueue:", commandQueue)
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="newCaptureScopeWithDevice")
|
|
CaptureManager_newCaptureScopeWithDevice :: proc(self: ^CaptureManager, device: ^NS.Object) -> ^CaptureManager {
|
|
return msgSend(^CaptureManager, self, "newCaptureScopeWithDevice:", device)
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="setDefaultCaptureScope")
|
|
CaptureManager_setDefaultCaptureScope :: proc(self: ^CaptureManager, defaultCaptureScope: ^NS.Object) {
|
|
msgSend(nil, self, "setDefaultCaptureScope:", defaultCaptureScope)
|
|
}
|
|
@(objc_type=CaptureManager, objc_class_name="sharedCaptureManager")
|
|
CaptureManager_sharedCaptureManager :: proc() -> ^CaptureManager {
|
|
return msgSend(^CaptureManager, CaptureManager, "sharedCaptureManager")
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="startCaptureWithCommandQueue")
|
|
CaptureManager_startCaptureWithCommandQueue :: proc(self: ^CaptureManager, commandQueue: ^NS.Object) {
|
|
msgSend(nil, self, "startCaptureWithCommandQueue:", commandQueue)
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="startCaptureWithDescriptor")
|
|
CaptureManager_startCaptureWithDescriptor :: proc(self: ^CaptureManager, descriptor: ^CaptureDescriptor, error: ^^NS.Error ) -> BOOL {
|
|
return msgSend(BOOL, self, "startCaptureWithDescriptor:error:", descriptor, error)
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="startCaptureWithDevice")
|
|
CaptureManager_startCaptureWithDevice :: proc(self: ^CaptureManager, device: ^NS.Object) {
|
|
msgSend(nil, self, "startCaptureWithDevice:", device)
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="startCaptureWithScope")
|
|
CaptureManager_startCaptureWithScope :: proc(self: ^CaptureManager, captureScope: ^NS.Object) {
|
|
msgSend(nil, self, "startCaptureWithScope:", captureScope)
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="stopCapture")
|
|
CaptureManager_stopCapture :: proc(self: ^CaptureManager) {
|
|
msgSend(nil, self, "stopCapture")
|
|
}
|
|
@(objc_type=CaptureManager, objc_name="supportsDestination")
|
|
CaptureManager_supportsDestination :: proc(self: ^CaptureManager, destination: CaptureDestination) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsDestination:", destination)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CommandBufferDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
errorOptions
|
|
retainedReferences
|
|
setErrorOptions
|
|
setRetainedReferences
|
|
*/
|
|
@(objc_class="MTLCommandBufferDescriptor")
|
|
CommandBufferDescriptor :: struct { using _: NS.Copying(CommandBufferDescriptor) }
|
|
|
|
@(objc_type=CommandBufferDescriptor, objc_class_name="alloc")
|
|
CommandBufferDescriptor_alloc :: proc() -> ^CommandBufferDescriptor {
|
|
return msgSend(^CommandBufferDescriptor, CommandBufferDescriptor, "alloc")
|
|
}
|
|
@(objc_type=CommandBufferDescriptor, objc_name="init")
|
|
CommandBufferDescriptor_init :: proc(self: ^CommandBufferDescriptor) -> ^CommandBufferDescriptor {
|
|
return msgSend(^CommandBufferDescriptor, self, "init")
|
|
}
|
|
@(objc_type=CommandBufferDescriptor, objc_name="errorOptions")
|
|
CommandBufferDescriptor_errorOptions :: proc(self: ^CommandBufferDescriptor) -> CommandBufferErrorOption {
|
|
return msgSend(CommandBufferErrorOption, self, "errorOptions")
|
|
}
|
|
@(objc_type=CommandBufferDescriptor, objc_name="retainedReferences")
|
|
CommandBufferDescriptor_retainedReferences :: proc(self: ^CommandBufferDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "retainedReferences")
|
|
}
|
|
@(objc_type=CommandBufferDescriptor, objc_name="setErrorOptions")
|
|
CommandBufferDescriptor_setErrorOptions :: proc(self: ^CommandBufferDescriptor, errorOptions: CommandBufferErrorOption) {
|
|
msgSend(nil, self, "setErrorOptions:", errorOptions)
|
|
}
|
|
@(objc_type=CommandBufferDescriptor, objc_name="setRetainedReferences")
|
|
CommandBufferDescriptor_setRetainedReferences :: proc(self: ^CommandBufferDescriptor, retainedReferences: BOOL) {
|
|
msgSend(nil, self, "setRetainedReferences:", retainedReferences)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CompileOptions
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
fastMathEnabled
|
|
installName
|
|
languageVersion
|
|
libraries
|
|
libraryType
|
|
preprocessorMacros
|
|
preserveInvariance
|
|
setFastMathEnabled
|
|
setInstallName
|
|
setLanguageVersion
|
|
setLibraries
|
|
setLibraryType
|
|
setPreprocessorMacros
|
|
setPreserveInvariance
|
|
*/
|
|
@(objc_class="MTLCompileOptions")
|
|
CompileOptions :: struct { using _: NS.Copying(CompileOptions) }
|
|
|
|
@(objc_type=CompileOptions, objc_class_name="alloc")
|
|
CompileOptions_alloc :: proc() -> ^CompileOptions {
|
|
return msgSend(^CompileOptions, CompileOptions, "alloc")
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="init")
|
|
CompileOptions_init :: proc(self: ^CompileOptions) -> ^CompileOptions {
|
|
return msgSend(^CompileOptions, self, "init")
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="fastMathEnabled")
|
|
CompileOptions_fastMathEnabled :: proc(self: ^CompileOptions) -> BOOL {
|
|
return msgSend(BOOL, self, "fastMathEnabled")
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="installName")
|
|
CompileOptions_installName :: proc(self: ^CompileOptions) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "installName")
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="languageVersion")
|
|
CompileOptions_languageVersion :: proc(self: ^CompileOptions) -> LanguageVersion {
|
|
return msgSend(LanguageVersion, self, "languageVersion")
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="libraries")
|
|
CompileOptions_libraries :: proc(self: ^CompileOptions) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "libraries")
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="libraryType")
|
|
CompileOptions_libraryType :: proc(self: ^CompileOptions) -> LibraryType {
|
|
return msgSend(LibraryType, self, "libraryType")
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="preprocessorMacros")
|
|
CompileOptions_preprocessorMacros :: proc(self: ^CompileOptions) -> ^NS.Dictionary {
|
|
return msgSend(^NS.Dictionary, self, "preprocessorMacros")
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="preserveInvariance")
|
|
CompileOptions_preserveInvariance :: proc(self: ^CompileOptions) -> BOOL {
|
|
return msgSend(BOOL, self, "preserveInvariance")
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="setFastMathEnabled")
|
|
CompileOptions_setFastMathEnabled :: proc(self: ^CompileOptions, fastMathEnabled: BOOL) {
|
|
msgSend(nil, self, "setFastMathEnabled:", fastMathEnabled)
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="setInstallName")
|
|
CompileOptions_setInstallName :: proc(self: ^CompileOptions, installName: ^NS.String) {
|
|
msgSend(nil, self, "setInstallName:", installName)
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="setLanguageVersion")
|
|
CompileOptions_setLanguageVersion :: proc(self: ^CompileOptions, languageVersion: LanguageVersion) {
|
|
msgSend(nil, self, "setLanguageVersion:", languageVersion)
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="setLibraries")
|
|
CompileOptions_setLibraries :: proc(self: ^CompileOptions, libraries: ^NS.Array) {
|
|
msgSend(nil, self, "setLibraries:", libraries)
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="setLibraryType")
|
|
CompileOptions_setLibraryType :: proc(self: ^CompileOptions, libraryType: LibraryType) {
|
|
msgSend(nil, self, "setLibraryType:", libraryType)
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="setPreprocessorMacros")
|
|
CompileOptions_setPreprocessorMacros :: proc(self: ^CompileOptions, preprocessorMacros: ^NS.Dictionary) {
|
|
msgSend(nil, self, "setPreprocessorMacros:", preprocessorMacros)
|
|
}
|
|
@(objc_type=CompileOptions, objc_name="setPreserveInvariance")
|
|
CompileOptions_setPreserveInvariance :: proc(self: ^CompileOptions, preserveInvariance: BOOL) {
|
|
msgSend(nil, self, "setPreserveInvariance:", preserveInvariance)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ComputePassDescriptor
|
|
Class Methods:
|
|
alloc
|
|
computePassDescriptor
|
|
Methods:
|
|
init
|
|
dispatchType
|
|
sampleBufferAttachments
|
|
setDispatchType
|
|
*/
|
|
@(objc_class="MTLComputePassDescriptor")
|
|
ComputePassDescriptor :: struct { using _: NS.Copying(ComputePassDescriptor) }
|
|
|
|
@(objc_type=ComputePassDescriptor, objc_class_name="alloc")
|
|
ComputePassDescriptor_alloc :: proc() -> ^ComputePassDescriptor {
|
|
return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "alloc")
|
|
}
|
|
@(objc_type=ComputePassDescriptor, objc_name="init")
|
|
ComputePassDescriptor_init :: proc(self: ^ComputePassDescriptor) -> ^ComputePassDescriptor {
|
|
return msgSend(^ComputePassDescriptor, self, "init")
|
|
}
|
|
@(objc_type=ComputePassDescriptor, objc_class_name="computePassDescriptor")
|
|
ComputePassDescriptor_computePassDescriptor :: proc() -> ^ComputePassDescriptor {
|
|
return msgSend(^ComputePassDescriptor, ComputePassDescriptor, "computePassDescriptor")
|
|
}
|
|
@(objc_type=ComputePassDescriptor, objc_name="dispatchType")
|
|
ComputePassDescriptor_dispatchType :: proc(self: ^ComputePassDescriptor) -> DispatchType {
|
|
return msgSend(DispatchType, self, "dispatchType")
|
|
}
|
|
@(objc_type=ComputePassDescriptor, objc_name="sampleBufferAttachments")
|
|
ComputePassDescriptor_sampleBufferAttachments :: proc(self: ^ComputePassDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments")
|
|
}
|
|
@(objc_type=ComputePassDescriptor, objc_name="setDispatchType")
|
|
ComputePassDescriptor_setDispatchType :: proc(self: ^ComputePassDescriptor, dispatchType: DispatchType) {
|
|
msgSend(nil, self, "setDispatchType:", dispatchType)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ComputePassSampleBufferAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
endOfEncoderSampleIndex
|
|
sampleBuffer
|
|
setEndOfEncoderSampleIndex
|
|
setSampleBuffer
|
|
setStartOfEncoderSampleIndex
|
|
startOfEncoderSampleIndex
|
|
*/
|
|
@(objc_class="MTLComputePassSampleBufferAttachmentDescriptor")
|
|
ComputePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ComputePassSampleBufferAttachmentDescriptor) }
|
|
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_class_name="alloc")
|
|
ComputePassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^ComputePassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^ComputePassSampleBufferAttachmentDescriptor, ComputePassSampleBufferAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="init")
|
|
ComputePassSampleBufferAttachmentDescriptor_init :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex")
|
|
ComputePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "endOfEncoderSampleIndex")
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer")
|
|
ComputePassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> ^ComputePassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "sampleBuffer")
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex")
|
|
ComputePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex)
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer")
|
|
ComputePassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) {
|
|
msgSend(nil, self, "setSampleBuffer:", sampleBuffer)
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex")
|
|
ComputePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex)
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex")
|
|
ComputePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc(self: ^ComputePassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "startOfEncoderSampleIndex")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ComputePassSampleBufferAttachmentDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLComputePassSampleBufferAttachmentDescriptorArray")
|
|
ComputePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc")
|
|
ComputePassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^ComputePassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, ComputePassSampleBufferAttachmentDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="init")
|
|
ComputePassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray) -> ^ComputePassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^ComputePassSampleBufferAttachmentDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
ComputePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ComputePassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^ComputePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex)
|
|
}
|
|
@(objc_type=ComputePassSampleBufferAttachmentDescriptorArray, objc_name="setObject")
|
|
ComputePassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^ComputePassSampleBufferAttachmentDescriptorArray, attachment: ^ComputePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ComputePipelineDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
binaryArchives
|
|
buffers
|
|
computeFunction
|
|
insertLibraries
|
|
label
|
|
linkedFunctions
|
|
maxCallStackDepth
|
|
maxTotalThreadsPerThreadgroup
|
|
reset
|
|
setBinaryArchives
|
|
setComputeFunction
|
|
setInsertLibraries
|
|
setLabel
|
|
setLinkedFunctions
|
|
setMaxCallStackDepth
|
|
setMaxTotalThreadsPerThreadgroup
|
|
setStageInputDescriptor
|
|
setSupportAddingBinaryFunctions
|
|
setSupportIndirectCommandBuffers
|
|
setThreadGroupSizeIsMultipleOfThreadExecutionWidth
|
|
stageInputDescriptor
|
|
supportAddingBinaryFunctions
|
|
supportIndirectCommandBuffers
|
|
threadGroupSizeIsMultipleOfThreadExecutionWidth
|
|
*/
|
|
@(objc_class="MTLComputePipelineDescriptor")
|
|
ComputePipelineDescriptor :: struct { using _: NS.Copying(ComputePipelineDescriptor) }
|
|
|
|
@(objc_type=ComputePipelineDescriptor, objc_class_name="alloc")
|
|
ComputePipelineDescriptor_alloc :: proc() -> ^ComputePipelineDescriptor {
|
|
return msgSend(^ComputePipelineDescriptor, ComputePipelineDescriptor, "alloc")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="init")
|
|
ComputePipelineDescriptor_init :: proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor {
|
|
return msgSend(^ComputePipelineDescriptor, self, "init")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="binaryArchives")
|
|
ComputePipelineDescriptor_binaryArchives :: proc(self: ^ComputePipelineDescriptor) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "binaryArchives")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="buffers")
|
|
ComputePipelineDescriptor_buffers :: proc(self: ^ComputePipelineDescriptor) -> ^PipelineBufferDescriptorArray {
|
|
return msgSend(^PipelineBufferDescriptorArray, self, "buffers")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="computeFunction")
|
|
ComputePipelineDescriptor_computeFunction :: proc(self: ^ComputePipelineDescriptor) -> ^ComputePipelineDescriptor {
|
|
return msgSend(^ComputePipelineDescriptor, self, "computeFunction")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="insertLibraries")
|
|
ComputePipelineDescriptor_insertLibraries :: proc(self: ^ComputePipelineDescriptor) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "insertLibraries")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="label")
|
|
ComputePipelineDescriptor_label :: proc(self: ^ComputePipelineDescriptor) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="linkedFunctions")
|
|
ComputePipelineDescriptor_linkedFunctions :: proc(self: ^ComputePipelineDescriptor) -> ^LinkedFunctions {
|
|
return msgSend(^LinkedFunctions, self, "linkedFunctions")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="maxCallStackDepth")
|
|
ComputePipelineDescriptor_maxCallStackDepth :: proc(self: ^ComputePipelineDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxCallStackDepth")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup")
|
|
ComputePipelineDescriptor_maxTotalThreadsPerThreadgroup :: proc(self: ^ComputePipelineDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="reset")
|
|
ComputePipelineDescriptor_reset :: proc(self: ^ComputePipelineDescriptor) {
|
|
msgSend(nil, self, "reset")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setBinaryArchives")
|
|
ComputePipelineDescriptor_setBinaryArchives :: proc(self: ^ComputePipelineDescriptor, binaryArchives: ^NS.Array) {
|
|
msgSend(nil, self, "setBinaryArchives:", binaryArchives)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setComputeFunction")
|
|
ComputePipelineDescriptor_setComputeFunction :: proc(self: ^ComputePipelineDescriptor, computeFunction: ^NS.Object) {
|
|
msgSend(nil, self, "setComputeFunction:", computeFunction)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setInsertLibraries")
|
|
ComputePipelineDescriptor_setInsertLibraries :: proc(self: ^ComputePipelineDescriptor, insertLibraries: ^NS.Array) {
|
|
msgSend(nil, self, "setInsertLibraries:", insertLibraries)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setLabel")
|
|
ComputePipelineDescriptor_setLabel :: proc(self: ^ComputePipelineDescriptor, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setLinkedFunctions")
|
|
ComputePipelineDescriptor_setLinkedFunctions :: proc(self: ^ComputePipelineDescriptor, linkedFunctions: ^LinkedFunctions) {
|
|
msgSend(nil, self, "setLinkedFunctions:", linkedFunctions)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setMaxCallStackDepth")
|
|
ComputePipelineDescriptor_setMaxCallStackDepth :: proc(self: ^ComputePipelineDescriptor, maxCallStackDepth: NS.Integer) {
|
|
msgSend(nil, self, "setMaxCallStackDepth:", maxCallStackDepth)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup")
|
|
ComputePipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: proc(self: ^ComputePipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) {
|
|
msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setStageInputDescriptor")
|
|
ComputePipelineDescriptor_setStageInputDescriptor :: proc(self: ^ComputePipelineDescriptor, stageInputDescriptor: ^StageInputOutputDescriptor) {
|
|
msgSend(nil, self, "setStageInputDescriptor:", stageInputDescriptor)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setSupportAddingBinaryFunctions")
|
|
ComputePipelineDescriptor_setSupportAddingBinaryFunctions :: proc(self: ^ComputePipelineDescriptor, supportAddingBinaryFunctions: BOOL) {
|
|
msgSend(nil, self, "setSupportAddingBinaryFunctions:", supportAddingBinaryFunctions)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setSupportIndirectCommandBuffers")
|
|
ComputePipelineDescriptor_setSupportIndirectCommandBuffers :: proc(self: ^ComputePipelineDescriptor, supportIndirectCommandBuffers: BOOL) {
|
|
msgSend(nil, self, "setSupportIndirectCommandBuffers:", supportIndirectCommandBuffers)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="setThreadGroupSizeIsMultipleOfThreadExecutionWidth")
|
|
ComputePipelineDescriptor_setThreadGroupSizeIsMultipleOfThreadExecutionWidth :: proc(self: ^ComputePipelineDescriptor, threadGroupSizeIsMultipleOfThreadExecutionWidth: BOOL) {
|
|
msgSend(nil, self, "setThreadGroupSizeIsMultipleOfThreadExecutionWidth:", threadGroupSizeIsMultipleOfThreadExecutionWidth)
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="stageInputDescriptor")
|
|
ComputePipelineDescriptor_stageInputDescriptor :: proc(self: ^ComputePipelineDescriptor) -> ^StageInputOutputDescriptor {
|
|
return msgSend(^StageInputOutputDescriptor, self, "stageInputDescriptor")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="supportAddingBinaryFunctions")
|
|
ComputePipelineDescriptor_supportAddingBinaryFunctions :: proc(self: ^ComputePipelineDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "supportAddingBinaryFunctions")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="supportIndirectCommandBuffers")
|
|
ComputePipelineDescriptor_supportIndirectCommandBuffers :: proc(self: ^ComputePipelineDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "supportIndirectCommandBuffers")
|
|
}
|
|
@(objc_type=ComputePipelineDescriptor, objc_name="threadGroupSizeIsMultipleOfThreadExecutionWidth")
|
|
ComputePipelineDescriptor_threadGroupSizeIsMultipleOfThreadExecutionWidth :: proc(self: ^ComputePipelineDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "threadGroupSizeIsMultipleOfThreadExecutionWidth")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ComputePipelineReflection
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
arguments
|
|
*/
|
|
@(objc_class="MTLComputePipelineReflection")
|
|
ComputePipelineReflection :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=ComputePipelineReflection, objc_class_name="alloc")
|
|
ComputePipelineReflection_alloc :: proc() -> ^ComputePipelineReflection {
|
|
return msgSend(^ComputePipelineReflection, ComputePipelineReflection, "alloc")
|
|
}
|
|
@(objc_type=ComputePipelineReflection, objc_name="init")
|
|
ComputePipelineReflection_init :: proc(self: ^ComputePipelineReflection) -> ^ComputePipelineReflection {
|
|
return msgSend(^ComputePipelineReflection, self, "init")
|
|
}
|
|
@(objc_type=ComputePipelineReflection, objc_name="arguments")
|
|
ComputePipelineReflection_arguments :: proc(self: ^ComputePipelineReflection) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "arguments")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CounterSampleBufferDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
counterSet
|
|
label
|
|
sampleCount
|
|
setCounterSet
|
|
setLabel
|
|
setSampleCount
|
|
setStorageMode
|
|
storageMode
|
|
*/
|
|
@(objc_class="MTLCounterSampleBufferDescriptor")
|
|
CounterSampleBufferDescriptor :: struct { using _: NS.Copying(CounterSampleBufferDescriptor) }
|
|
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_class_name="alloc")
|
|
CounterSampleBufferDescriptor_alloc :: proc() -> ^CounterSampleBufferDescriptor {
|
|
return msgSend(^CounterSampleBufferDescriptor, CounterSampleBufferDescriptor, "alloc")
|
|
}
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_name="init")
|
|
CounterSampleBufferDescriptor_init :: proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor {
|
|
return msgSend(^CounterSampleBufferDescriptor, self, "init")
|
|
}
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_name="counterSet")
|
|
CounterSampleBufferDescriptor_counterSet :: proc(self: ^CounterSampleBufferDescriptor) -> ^CounterSampleBufferDescriptor {
|
|
return msgSend(^CounterSampleBufferDescriptor, self, "counterSet")
|
|
}
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_name="label")
|
|
CounterSampleBufferDescriptor_label :: proc(self: ^CounterSampleBufferDescriptor) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_name="sampleCount")
|
|
CounterSampleBufferDescriptor_sampleCount :: proc(self: ^CounterSampleBufferDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "sampleCount")
|
|
}
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_name="setCounterSet")
|
|
CounterSampleBufferDescriptor_setCounterSet :: proc(self: ^CounterSampleBufferDescriptor, counterSet: ^NS.Object) {
|
|
msgSend(nil, self, "setCounterSet:", counterSet)
|
|
}
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_name="setLabel")
|
|
CounterSampleBufferDescriptor_setLabel :: proc(self: ^CounterSampleBufferDescriptor, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_name="setSampleCount")
|
|
CounterSampleBufferDescriptor_setSampleCount :: proc(self: ^CounterSampleBufferDescriptor, sampleCount: NS.Integer) {
|
|
msgSend(nil, self, "setSampleCount:", sampleCount)
|
|
}
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_name="setStorageMode")
|
|
CounterSampleBufferDescriptor_setStorageMode :: proc(self: ^CounterSampleBufferDescriptor, storageMode: StorageMode) {
|
|
msgSend(nil, self, "setStorageMode:", storageMode)
|
|
}
|
|
@(objc_type=CounterSampleBufferDescriptor, objc_name="storageMode")
|
|
CounterSampleBufferDescriptor_storageMode :: proc(self: ^CounterSampleBufferDescriptor) -> StorageMode {
|
|
return msgSend(StorageMode, self, "storageMode")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
DepthStencilDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
backFaceStencil
|
|
depthCompareFunction
|
|
frontFaceStencil
|
|
isDepthWriteEnabled
|
|
label
|
|
setBackFaceStencil
|
|
setDepthCompareFunction
|
|
setDepthWriteEnabled
|
|
setFrontFaceStencil
|
|
setLabel
|
|
*/
|
|
@(objc_class="MTLDepthStencilDescriptor")
|
|
DepthStencilDescriptor :: struct { using _: NS.Copying(DepthStencilDescriptor) }
|
|
|
|
@(objc_type=DepthStencilDescriptor, objc_class_name="alloc")
|
|
DepthStencilDescriptor_alloc :: proc() -> ^DepthStencilDescriptor {
|
|
return msgSend(^DepthStencilDescriptor, DepthStencilDescriptor, "alloc")
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="init")
|
|
DepthStencilDescriptor_init :: proc(self: ^DepthStencilDescriptor) -> ^DepthStencilDescriptor {
|
|
return msgSend(^DepthStencilDescriptor, self, "init")
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="backFaceStencil")
|
|
DepthStencilDescriptor_backFaceStencil :: proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor {
|
|
return msgSend(^StencilDescriptor, self, "backFaceStencil")
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="depthCompareFunction")
|
|
DepthStencilDescriptor_depthCompareFunction :: proc(self: ^DepthStencilDescriptor) -> CompareFunction {
|
|
return msgSend(CompareFunction, self, "depthCompareFunction")
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="frontFaceStencil")
|
|
DepthStencilDescriptor_frontFaceStencil :: proc(self: ^DepthStencilDescriptor) -> ^StencilDescriptor {
|
|
return msgSend(^StencilDescriptor, self, "frontFaceStencil")
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="isDepthWriteEnabled")
|
|
DepthStencilDescriptor_isDepthWriteEnabled :: proc(self: ^DepthStencilDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "isDepthWriteEnabled")
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="label")
|
|
DepthStencilDescriptor_label :: proc(self: ^DepthStencilDescriptor) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="setBackFaceStencil")
|
|
DepthStencilDescriptor_setBackFaceStencil :: proc(self: ^DepthStencilDescriptor, backFaceStencil: ^StencilDescriptor) {
|
|
msgSend(nil, self, "setBackFaceStencil:", backFaceStencil)
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="setDepthCompareFunction")
|
|
DepthStencilDescriptor_setDepthCompareFunction :: proc(self: ^DepthStencilDescriptor, depthCompareFunction: CompareFunction) {
|
|
msgSend(nil, self, "setDepthCompareFunction:", depthCompareFunction)
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="setDepthWriteEnabled")
|
|
DepthStencilDescriptor_setDepthWriteEnabled :: proc(self: ^DepthStencilDescriptor, depthWriteEnabled: BOOL) {
|
|
msgSend(nil, self, "setDepthWriteEnabled:", depthWriteEnabled)
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="setFrontFaceStencil")
|
|
DepthStencilDescriptor_setFrontFaceStencil :: proc(self: ^DepthStencilDescriptor, frontFaceStencil: ^StencilDescriptor) {
|
|
msgSend(nil, self, "setFrontFaceStencil:", frontFaceStencil)
|
|
}
|
|
@(objc_type=DepthStencilDescriptor, objc_name="setLabel")
|
|
DepthStencilDescriptor_setLabel :: proc(self: ^DepthStencilDescriptor, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
FunctionConstant
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
index
|
|
name
|
|
required
|
|
type
|
|
*/
|
|
@(objc_class="MTLFunctionConstant")
|
|
FunctionConstant :: struct { using _: NS.Copying(FunctionConstant) }
|
|
|
|
@(objc_type=FunctionConstant, objc_class_name="alloc")
|
|
FunctionConstant_alloc :: proc() -> ^FunctionConstant {
|
|
return msgSend(^FunctionConstant, FunctionConstant, "alloc")
|
|
}
|
|
@(objc_type=FunctionConstant, objc_name="init")
|
|
FunctionConstant_init :: proc(self: ^FunctionConstant) -> ^FunctionConstant {
|
|
return msgSend(^FunctionConstant, self, "init")
|
|
}
|
|
@(objc_type=FunctionConstant, objc_name="index")
|
|
FunctionConstant_index :: proc(self: ^FunctionConstant) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "index")
|
|
}
|
|
@(objc_type=FunctionConstant, objc_name="name")
|
|
FunctionConstant_name :: proc(self: ^FunctionConstant) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
@(objc_type=FunctionConstant, objc_name="required")
|
|
FunctionConstant_required :: proc(self: ^FunctionConstant) -> BOOL {
|
|
return msgSend(BOOL, self, "required")
|
|
}
|
|
@(objc_type=FunctionConstant, objc_name="type")
|
|
FunctionConstant_type :: proc(self: ^FunctionConstant) -> DataType {
|
|
return msgSend(DataType, self, "type")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
FunctionConstantValues
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
reset
|
|
setConstantValue
|
|
setConstantValue
|
|
setConstantValues
|
|
*/
|
|
@(objc_class="MTLFunctionConstantValues")
|
|
FunctionConstantValues :: struct { using _: NS.Copying(FunctionConstantValues) }
|
|
|
|
@(objc_type=FunctionConstantValues, objc_class_name="alloc")
|
|
FunctionConstantValues_alloc :: proc() -> ^FunctionConstantValues {
|
|
return msgSend(^FunctionConstantValues, FunctionConstantValues, "alloc")
|
|
}
|
|
@(objc_type=FunctionConstantValues, objc_name="init")
|
|
FunctionConstantValues_init :: proc(self: ^FunctionConstantValues) -> ^FunctionConstantValues {
|
|
return msgSend(^FunctionConstantValues, self, "init")
|
|
}
|
|
@(objc_type=FunctionConstantValues, objc_name="reset")
|
|
FunctionConstantValues_reset :: proc(self: ^FunctionConstantValues) {
|
|
msgSend(nil, self, "reset")
|
|
}
|
|
@(objc_type=FunctionConstantValues, objc_name="setConstantValue_type_atIndex_")
|
|
FunctionConstantValues_setConstantValue_type_atIndex_ :: proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, index: ^NS.Object) {
|
|
msgSend(nil, self, "setConstantValue:type:atIndex:", value, type, index)
|
|
}
|
|
@(objc_type=FunctionConstantValues, objc_name="setConstantValue_type_withName_")
|
|
FunctionConstantValues_setConstantValue_type_withName_ :: proc(self: ^FunctionConstantValues, value: rawptr, type: DataType, name: ^NS.String) {
|
|
msgSend(nil, self, "setConstantValue:type:withName:", value, type, name)
|
|
}
|
|
@(objc_type=FunctionConstantValues, objc_name="setConstantValues")
|
|
FunctionConstantValues_setConstantValues :: proc(self: ^FunctionConstantValues, values: rawptr, type: DataType, range: NS.Range) {
|
|
msgSend(nil, self, "setConstantValues:type:withRange:", values, type, range)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
FunctionDescriptor
|
|
Class Methods:
|
|
alloc
|
|
functionDescriptor
|
|
Methods:
|
|
init
|
|
constantValues
|
|
name
|
|
options
|
|
setConstantValues
|
|
setName
|
|
setOptions
|
|
setSpecializedName
|
|
specializedName
|
|
*/
|
|
@(objc_class="MTLFunctionDescriptor")
|
|
FunctionDescriptor :: struct { using _: NS.Copying(FunctionDescriptor) }
|
|
|
|
@(objc_type=FunctionDescriptor, objc_class_name="alloc")
|
|
FunctionDescriptor_alloc :: proc() -> ^FunctionDescriptor {
|
|
return msgSend(^FunctionDescriptor, FunctionDescriptor, "alloc")
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_name="init")
|
|
FunctionDescriptor_init :: proc(self: ^FunctionDescriptor) -> ^FunctionDescriptor {
|
|
return msgSend(^FunctionDescriptor, self, "init")
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_name="constantValues")
|
|
FunctionDescriptor_constantValues :: proc(self: ^FunctionDescriptor) -> ^FunctionConstantValues {
|
|
return msgSend(^FunctionConstantValues, self, "constantValues")
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_class_name="functionDescriptor")
|
|
FunctionDescriptor_functionDescriptor :: proc() -> ^FunctionDescriptor {
|
|
return msgSend(^FunctionDescriptor, FunctionDescriptor, "functionDescriptor")
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_name="name")
|
|
FunctionDescriptor_name :: proc(self: ^FunctionDescriptor) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_name="options")
|
|
FunctionDescriptor_options :: proc(self: ^FunctionDescriptor) -> FunctionOptions {
|
|
return msgSend(FunctionOptions, self, "options")
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_name="setConstantValues")
|
|
FunctionDescriptor_setConstantValues :: proc(self: ^FunctionDescriptor, constantValues: ^FunctionConstantValues) {
|
|
msgSend(nil, self, "setConstantValues:", constantValues)
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_name="setName")
|
|
FunctionDescriptor_setName :: proc(self: ^FunctionDescriptor, name: ^NS.String) {
|
|
msgSend(nil, self, "setName:", name)
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_name="setOptions")
|
|
FunctionDescriptor_setOptions :: proc(self: ^FunctionDescriptor, options: FunctionOptions) {
|
|
msgSend(nil, self, "setOptions:", options)
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_name="setSpecializedName")
|
|
FunctionDescriptor_setSpecializedName :: proc(self: ^FunctionDescriptor, specializedName: ^NS.String) {
|
|
msgSend(nil, self, "setSpecializedName:", specializedName)
|
|
}
|
|
@(objc_type=FunctionDescriptor, objc_name="specializedName")
|
|
FunctionDescriptor_specializedName :: proc(self: ^FunctionDescriptor) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "specializedName")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
IntersectionFunctionDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
*/
|
|
@(objc_class="MTLIntersectionFunctionDescriptor")
|
|
IntersectionFunctionDescriptor :: struct { using _: NS.Copying(IntersectionFunctionDescriptor) }
|
|
|
|
@(objc_type=IntersectionFunctionDescriptor, objc_class_name="alloc")
|
|
IntersectionFunctionDescriptor_alloc :: proc() -> ^IntersectionFunctionDescriptor {
|
|
return msgSend(^IntersectionFunctionDescriptor, IntersectionFunctionDescriptor, "alloc")
|
|
}
|
|
@(objc_type=IntersectionFunctionDescriptor, objc_name="init")
|
|
IntersectionFunctionDescriptor_init :: proc(self: ^IntersectionFunctionDescriptor) -> ^IntersectionFunctionDescriptor {
|
|
return msgSend(^IntersectionFunctionDescriptor, self, "init")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
HeapDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
cpuCacheMode
|
|
hazardTrackingMode
|
|
resourceOptions
|
|
setCpuCacheMode
|
|
setHazardTrackingMode
|
|
setResourceOptions
|
|
setSize
|
|
setStorageMode
|
|
setType
|
|
size
|
|
storageMode
|
|
type
|
|
*/
|
|
@(objc_class="MTLHeapDescriptor")
|
|
HeapDescriptor :: struct { using _: NS.Copying(HeapDescriptor) }
|
|
|
|
@(objc_type=HeapDescriptor, objc_class_name="alloc")
|
|
HeapDescriptor_alloc :: proc() -> ^HeapDescriptor {
|
|
return msgSend(^HeapDescriptor, HeapDescriptor, "alloc")
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="init")
|
|
HeapDescriptor_init :: proc(self: ^HeapDescriptor) -> ^HeapDescriptor {
|
|
return msgSend(^HeapDescriptor, self, "init")
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="cpuCacheMode")
|
|
HeapDescriptor_cpuCacheMode :: proc(self: ^HeapDescriptor) -> CPUCacheMode {
|
|
return msgSend(CPUCacheMode, self, "cpuCacheMode")
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="hazardTrackingMode")
|
|
HeapDescriptor_hazardTrackingMode :: proc(self: ^HeapDescriptor) -> HazardTrackingMode {
|
|
return msgSend(HazardTrackingMode, self, "hazardTrackingMode")
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="resourceOptions")
|
|
HeapDescriptor_resourceOptions :: proc(self: ^HeapDescriptor) -> ResourceOptions {
|
|
return msgSend(ResourceOptions, self, "resourceOptions")
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="setCpuCacheMode")
|
|
HeapDescriptor_setCpuCacheMode :: proc(self: ^HeapDescriptor, cpuCacheMode: CPUCacheMode) {
|
|
msgSend(nil, self, "setCpuCacheMode:", cpuCacheMode)
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="setHazardTrackingMode")
|
|
HeapDescriptor_setHazardTrackingMode :: proc(self: ^HeapDescriptor, hazardTrackingMode: HazardTrackingMode) {
|
|
msgSend(nil, self, "setHazardTrackingMode:", hazardTrackingMode)
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="setResourceOptions")
|
|
HeapDescriptor_setResourceOptions :: proc(self: ^HeapDescriptor, resourceOptions: ResourceOptions) {
|
|
msgSend(nil, self, "setResourceOptions:", resourceOptions)
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="setSize")
|
|
HeapDescriptor_setSize :: proc(self: ^HeapDescriptor, size: NS.Integer) {
|
|
msgSend(nil, self, "setSize:", size)
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="setStorageMode")
|
|
HeapDescriptor_setStorageMode :: proc(self: ^HeapDescriptor, storageMode: StorageMode) {
|
|
msgSend(nil, self, "setStorageMode:", storageMode)
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="setType")
|
|
HeapDescriptor_setType :: proc(self: ^HeapDescriptor, type: HeapType) {
|
|
msgSend(nil, self, "setType:", type)
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="size")
|
|
HeapDescriptor_size :: proc(self: ^HeapDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "size")
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="storageMode")
|
|
HeapDescriptor_storageMode :: proc(self: ^HeapDescriptor) -> StorageMode {
|
|
return msgSend(StorageMode, self, "storageMode")
|
|
}
|
|
@(objc_type=HeapDescriptor, objc_name="type")
|
|
HeapDescriptor_type :: proc(self: ^HeapDescriptor) -> HeapType {
|
|
return msgSend(HeapType, self, "type")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
IndirectCommandBufferDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
commandTypes
|
|
inheritBuffers
|
|
inheritPipelineState
|
|
maxFragmentBufferBindCount
|
|
maxKernelBufferBindCount
|
|
maxVertexBufferBindCount
|
|
setCommandTypes
|
|
setInheritBuffers
|
|
setInheritPipelineState
|
|
setMaxFragmentBufferBindCount
|
|
setMaxKernelBufferBindCount
|
|
setMaxVertexBufferBindCount
|
|
*/
|
|
@(objc_class="MTLIndirectCommandBufferDescriptor")
|
|
IndirectCommandBufferDescriptor :: struct { using _: NS.Copying(IndirectCommandBufferDescriptor) }
|
|
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_class_name="alloc")
|
|
IndirectCommandBufferDescriptor_alloc :: proc() -> ^IndirectCommandBufferDescriptor {
|
|
return msgSend(^IndirectCommandBufferDescriptor, IndirectCommandBufferDescriptor, "alloc")
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="init")
|
|
IndirectCommandBufferDescriptor_init :: proc(self: ^IndirectCommandBufferDescriptor) -> ^IndirectCommandBufferDescriptor {
|
|
return msgSend(^IndirectCommandBufferDescriptor, self, "init")
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="commandTypes")
|
|
IndirectCommandBufferDescriptor_commandTypes :: proc(self: ^IndirectCommandBufferDescriptor) -> IndirectCommandType {
|
|
return msgSend(IndirectCommandType, self, "commandTypes")
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="inheritBuffers")
|
|
IndirectCommandBufferDescriptor_inheritBuffers :: proc(self: ^IndirectCommandBufferDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "inheritBuffers")
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="inheritPipelineState")
|
|
IndirectCommandBufferDescriptor_inheritPipelineState :: proc(self: ^IndirectCommandBufferDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "inheritPipelineState")
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="maxFragmentBufferBindCount")
|
|
IndirectCommandBufferDescriptor_maxFragmentBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxFragmentBufferBindCount")
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="maxKernelBufferBindCount")
|
|
IndirectCommandBufferDescriptor_maxKernelBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxKernelBufferBindCount")
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="maxVertexBufferBindCount")
|
|
IndirectCommandBufferDescriptor_maxVertexBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxVertexBufferBindCount")
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="setCommandTypes")
|
|
IndirectCommandBufferDescriptor_setCommandTypes :: proc(self: ^IndirectCommandBufferDescriptor, commandTypes: IndirectCommandType) {
|
|
msgSend(nil, self, "setCommandTypes:", commandTypes)
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="setInheritBuffers")
|
|
IndirectCommandBufferDescriptor_setInheritBuffers :: proc(self: ^IndirectCommandBufferDescriptor, inheritBuffers: BOOL) {
|
|
msgSend(nil, self, "setInheritBuffers:", inheritBuffers)
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="setInheritPipelineState")
|
|
IndirectCommandBufferDescriptor_setInheritPipelineState :: proc(self: ^IndirectCommandBufferDescriptor, inheritPipelineState: BOOL) {
|
|
msgSend(nil, self, "setInheritPipelineState:", inheritPipelineState)
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxFragmentBufferBindCount")
|
|
IndirectCommandBufferDescriptor_setMaxFragmentBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor, maxFragmentBufferBindCount: NS.Integer) {
|
|
msgSend(nil, self, "setMaxFragmentBufferBindCount:", maxFragmentBufferBindCount)
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxKernelBufferBindCount")
|
|
IndirectCommandBufferDescriptor_setMaxKernelBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor, maxKernelBufferBindCount: NS.Integer) {
|
|
msgSend(nil, self, "setMaxKernelBufferBindCount:", maxKernelBufferBindCount)
|
|
}
|
|
@(objc_type=IndirectCommandBufferDescriptor, objc_name="setMaxVertexBufferBindCount")
|
|
IndirectCommandBufferDescriptor_setMaxVertexBufferBindCount :: proc(self: ^IndirectCommandBufferDescriptor, maxVertexBufferBindCount: NS.Integer) {
|
|
msgSend(nil, self, "setMaxVertexBufferBindCount:", maxVertexBufferBindCount)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
InstanceAccelerationStructureDescriptor
|
|
Class Methods:
|
|
alloc
|
|
descriptor
|
|
Methods:
|
|
init
|
|
instanceCount
|
|
instanceDescriptorBuffer
|
|
instanceDescriptorBufferOffset
|
|
instanceDescriptorStride
|
|
instancedAccelerationStructures
|
|
setInstanceCount
|
|
setInstanceDescriptorBuffer
|
|
setInstanceDescriptorBufferOffset
|
|
setInstanceDescriptorStride
|
|
setInstancedAccelerationStructures
|
|
*/
|
|
@(objc_class="MTLInstanceAccelerationStructureDescriptor")
|
|
InstanceAccelerationStructureDescriptor :: struct { using _: NS.Copying(InstanceAccelerationStructureDescriptor) }
|
|
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_class_name="alloc")
|
|
InstanceAccelerationStructureDescriptor_alloc :: proc() -> ^InstanceAccelerationStructureDescriptor {
|
|
return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "alloc")
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="init")
|
|
InstanceAccelerationStructureDescriptor_init :: proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor {
|
|
return msgSend(^InstanceAccelerationStructureDescriptor, self, "init")
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_class_name="descriptor")
|
|
InstanceAccelerationStructureDescriptor_descriptor :: proc() -> ^InstanceAccelerationStructureDescriptor {
|
|
return msgSend(^InstanceAccelerationStructureDescriptor, InstanceAccelerationStructureDescriptor, "descriptor")
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceCount")
|
|
InstanceAccelerationStructureDescriptor_instanceCount :: proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "instanceCount")
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBuffer")
|
|
InstanceAccelerationStructureDescriptor_instanceDescriptorBuffer :: proc(self: ^InstanceAccelerationStructureDescriptor) -> ^InstanceAccelerationStructureDescriptor {
|
|
return msgSend(^InstanceAccelerationStructureDescriptor, self, "instanceDescriptorBuffer")
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorBufferOffset")
|
|
InstanceAccelerationStructureDescriptor_instanceDescriptorBufferOffset :: proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "instanceDescriptorBufferOffset")
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instanceDescriptorStride")
|
|
InstanceAccelerationStructureDescriptor_instanceDescriptorStride :: proc(self: ^InstanceAccelerationStructureDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "instanceDescriptorStride")
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="instancedAccelerationStructures")
|
|
InstanceAccelerationStructureDescriptor_instancedAccelerationStructures :: proc(self: ^InstanceAccelerationStructureDescriptor) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "instancedAccelerationStructures")
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceCount")
|
|
InstanceAccelerationStructureDescriptor_setInstanceCount :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceCount: NS.Integer) {
|
|
msgSend(nil, self, "setInstanceCount:", instanceCount)
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBuffer")
|
|
InstanceAccelerationStructureDescriptor_setInstanceDescriptorBuffer :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBuffer: ^NS.Object) {
|
|
msgSend(nil, self, "setInstanceDescriptorBuffer:", instanceDescriptorBuffer)
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorBufferOffset")
|
|
InstanceAccelerationStructureDescriptor_setInstanceDescriptorBufferOffset :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorBufferOffset: NS.Integer) {
|
|
msgSend(nil, self, "setInstanceDescriptorBufferOffset:", instanceDescriptorBufferOffset)
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstanceDescriptorStride")
|
|
InstanceAccelerationStructureDescriptor_setInstanceDescriptorStride :: proc(self: ^InstanceAccelerationStructureDescriptor, instanceDescriptorStride: NS.Integer) {
|
|
msgSend(nil, self, "setInstanceDescriptorStride:", instanceDescriptorStride)
|
|
}
|
|
@(objc_type=InstanceAccelerationStructureDescriptor, objc_name="setInstancedAccelerationStructures")
|
|
InstanceAccelerationStructureDescriptor_setInstancedAccelerationStructures :: proc(self: ^InstanceAccelerationStructureDescriptor, instancedAccelerationStructures: ^NS.Array) {
|
|
msgSend(nil, self, "setInstancedAccelerationStructures:", instancedAccelerationStructures)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
IntersectionFunctionTableDescriptor
|
|
Class Methods:
|
|
alloc
|
|
intersectionFunctionTableDescriptor
|
|
Methods:
|
|
init
|
|
functionCount
|
|
setFunctionCount
|
|
*/
|
|
@(objc_class="MTLIntersectionFunctionTableDescriptor")
|
|
IntersectionFunctionTableDescriptor :: struct { using _: NS.Copying(IntersectionFunctionTableDescriptor) }
|
|
|
|
@(objc_type=IntersectionFunctionTableDescriptor, objc_class_name="alloc")
|
|
IntersectionFunctionTableDescriptor_alloc :: proc() -> ^IntersectionFunctionTableDescriptor {
|
|
return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "alloc")
|
|
}
|
|
@(objc_type=IntersectionFunctionTableDescriptor, objc_name="init")
|
|
IntersectionFunctionTableDescriptor_init :: proc(self: ^IntersectionFunctionTableDescriptor) -> ^IntersectionFunctionTableDescriptor {
|
|
return msgSend(^IntersectionFunctionTableDescriptor, self, "init")
|
|
}
|
|
@(objc_type=IntersectionFunctionTableDescriptor, objc_name="functionCount")
|
|
IntersectionFunctionTableDescriptor_functionCount :: proc(self: ^IntersectionFunctionTableDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "functionCount")
|
|
}
|
|
@(objc_type=IntersectionFunctionTableDescriptor, objc_class_name="intersectionFunctionTableDescriptor")
|
|
IntersectionFunctionTableDescriptor_intersectionFunctionTableDescriptor :: proc() -> ^IntersectionFunctionTableDescriptor {
|
|
return msgSend(^IntersectionFunctionTableDescriptor, IntersectionFunctionTableDescriptor, "intersectionFunctionTableDescriptor")
|
|
}
|
|
@(objc_type=IntersectionFunctionTableDescriptor, objc_name="setFunctionCount")
|
|
IntersectionFunctionTableDescriptor_setFunctionCount :: proc(self: ^IntersectionFunctionTableDescriptor, functionCount: NS.Integer) {
|
|
msgSend(nil, self, "setFunctionCount:", functionCount)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
LinkedFunctions
|
|
Class Methods:
|
|
alloc
|
|
linkedFunctions
|
|
Methods:
|
|
init
|
|
binaryFunctions
|
|
functions
|
|
groups
|
|
setBinaryFunctions
|
|
setFunctions
|
|
setGroups
|
|
*/
|
|
@(objc_class="MTLLinkedFunctions")
|
|
LinkedFunctions :: struct { using _: NS.Copying(LinkedFunctions) }
|
|
|
|
@(objc_type=LinkedFunctions, objc_class_name="alloc")
|
|
LinkedFunctions_alloc :: proc() -> ^LinkedFunctions {
|
|
return msgSend(^LinkedFunctions, LinkedFunctions, "alloc")
|
|
}
|
|
@(objc_type=LinkedFunctions, objc_name="init")
|
|
LinkedFunctions_init :: proc(self: ^LinkedFunctions) -> ^LinkedFunctions {
|
|
return msgSend(^LinkedFunctions, self, "init")
|
|
}
|
|
@(objc_type=LinkedFunctions, objc_name="binaryFunctions")
|
|
LinkedFunctions_binaryFunctions :: proc(self: ^LinkedFunctions) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "binaryFunctions")
|
|
}
|
|
@(objc_type=LinkedFunctions, objc_name="functions")
|
|
LinkedFunctions_functions :: proc(self: ^LinkedFunctions) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "functions")
|
|
}
|
|
@(objc_type=LinkedFunctions, objc_name="groups")
|
|
LinkedFunctions_groups :: proc(self: ^LinkedFunctions) -> ^NS.Dictionary {
|
|
return msgSend(^NS.Dictionary, self, "groups")
|
|
}
|
|
@(objc_type=LinkedFunctions, objc_class_name="linkedFunctions")
|
|
LinkedFunctions_linkedFunctions :: proc() -> ^LinkedFunctions {
|
|
return msgSend(^LinkedFunctions, LinkedFunctions, "linkedFunctions")
|
|
}
|
|
@(objc_type=LinkedFunctions, objc_name="setBinaryFunctions")
|
|
LinkedFunctions_setBinaryFunctions :: proc(self: ^LinkedFunctions, binaryFunctions: ^NS.Array) {
|
|
msgSend(nil, self, "setBinaryFunctions:", binaryFunctions)
|
|
}
|
|
@(objc_type=LinkedFunctions, objc_name="setFunctions")
|
|
LinkedFunctions_setFunctions :: proc(self: ^LinkedFunctions, functions: ^NS.Array) {
|
|
msgSend(nil, self, "setFunctions:", functions)
|
|
}
|
|
@(objc_type=LinkedFunctions, objc_name="setGroups")
|
|
LinkedFunctions_setGroups :: proc(self: ^LinkedFunctions, groups: ^NS.Dictionary) {
|
|
msgSend(nil, self, "setGroups:", groups)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
PipelineBufferDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
mutability
|
|
setMutability
|
|
*/
|
|
@(objc_class="MTLPipelineBufferDescriptor")
|
|
PipelineBufferDescriptor :: struct { using _: NS.Copying(PipelineBufferDescriptor) }
|
|
|
|
@(objc_type=PipelineBufferDescriptor, objc_class_name="alloc")
|
|
PipelineBufferDescriptor_alloc :: proc() -> ^PipelineBufferDescriptor {
|
|
return msgSend(^PipelineBufferDescriptor, PipelineBufferDescriptor, "alloc")
|
|
}
|
|
@(objc_type=PipelineBufferDescriptor, objc_name="init")
|
|
PipelineBufferDescriptor_init :: proc(self: ^PipelineBufferDescriptor) -> ^PipelineBufferDescriptor {
|
|
return msgSend(^PipelineBufferDescriptor, self, "init")
|
|
}
|
|
@(objc_type=PipelineBufferDescriptor, objc_name="mutability")
|
|
PipelineBufferDescriptor_mutability :: proc(self: ^PipelineBufferDescriptor) -> Mutability {
|
|
return msgSend(Mutability, self, "mutability")
|
|
}
|
|
@(objc_type=PipelineBufferDescriptor, objc_name="setMutability")
|
|
PipelineBufferDescriptor_setMutability :: proc(self: ^PipelineBufferDescriptor, mutability: Mutability) {
|
|
msgSend(nil, self, "setMutability:", mutability)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
PipelineBufferDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLPipelineBufferDescriptorArray")
|
|
PipelineBufferDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=PipelineBufferDescriptorArray, objc_class_name="alloc")
|
|
PipelineBufferDescriptorArray_alloc :: proc() -> ^PipelineBufferDescriptorArray {
|
|
return msgSend(^PipelineBufferDescriptorArray, PipelineBufferDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=PipelineBufferDescriptorArray, objc_name="init")
|
|
PipelineBufferDescriptorArray_init :: proc(self: ^PipelineBufferDescriptorArray) -> ^PipelineBufferDescriptorArray {
|
|
return msgSend(^PipelineBufferDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=PipelineBufferDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
PipelineBufferDescriptorArray_objectAtIndexedSubscript :: proc(self: ^PipelineBufferDescriptorArray, bufferIndex: ^NS.Object) -> ^PipelineBufferDescriptor {
|
|
return msgSend(^PipelineBufferDescriptor, self, "objectAtIndexedSubscript:", bufferIndex)
|
|
}
|
|
@(objc_type=PipelineBufferDescriptorArray, objc_name="setObject")
|
|
PipelineBufferDescriptorArray_setObject :: proc(self: ^PipelineBufferDescriptorArray, buffer: ^PipelineBufferDescriptor, bufferIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", buffer, bufferIndex)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
PointerType
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
access
|
|
alignment
|
|
dataSize
|
|
elementArrayType
|
|
elementIsArgumentBuffer
|
|
elementStructType
|
|
elementType
|
|
*/
|
|
@(objc_class="MTLPointerType")
|
|
PointerType :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=PointerType, objc_class_name="alloc")
|
|
PointerType_alloc :: proc() -> ^PointerType {
|
|
return msgSend(^PointerType, PointerType, "alloc")
|
|
}
|
|
@(objc_type=PointerType, objc_name="init")
|
|
PointerType_init :: proc(self: ^PointerType) -> ^PointerType {
|
|
return msgSend(^PointerType, self, "init")
|
|
}
|
|
@(objc_type=PointerType, objc_name="access")
|
|
PointerType_access :: proc(self: ^PointerType) -> ArgumentAccess {
|
|
return msgSend(ArgumentAccess, self, "access")
|
|
}
|
|
@(objc_type=PointerType, objc_name="alignment")
|
|
PointerType_alignment :: proc(self: ^PointerType) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "alignment")
|
|
}
|
|
@(objc_type=PointerType, objc_name="dataSize")
|
|
PointerType_dataSize :: proc(self: ^PointerType) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "dataSize")
|
|
}
|
|
@(objc_type=PointerType, objc_name="elementArrayType")
|
|
PointerType_elementArrayType :: proc(self: ^PointerType) -> ^ArrayType {
|
|
return msgSend(^ArrayType, self, "elementArrayType")
|
|
}
|
|
@(objc_type=PointerType, objc_name="elementIsArgumentBuffer")
|
|
PointerType_elementIsArgumentBuffer :: proc(self: ^PointerType) -> BOOL {
|
|
return msgSend(BOOL, self, "elementIsArgumentBuffer")
|
|
}
|
|
@(objc_type=PointerType, objc_name="elementStructType")
|
|
PointerType_elementStructType :: proc(self: ^PointerType) -> ^StructType {
|
|
return msgSend(^StructType, self, "elementStructType")
|
|
}
|
|
@(objc_type=PointerType, objc_name="elementType")
|
|
PointerType_elementType :: proc(self: ^PointerType) -> DataType {
|
|
return msgSend(DataType, self, "elementType")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
PrimitiveAccelerationStructureDescriptor
|
|
Class Methods:
|
|
alloc
|
|
descriptor
|
|
Methods:
|
|
init
|
|
geometryDescriptors
|
|
setGeometryDescriptors
|
|
*/
|
|
@(objc_class="MTLPrimitiveAccelerationStructureDescriptor")
|
|
PrimitiveAccelerationStructureDescriptor :: struct { using _: NS.Copying(PrimitiveAccelerationStructureDescriptor) }
|
|
|
|
@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_class_name="alloc")
|
|
PrimitiveAccelerationStructureDescriptor_alloc :: proc() -> ^PrimitiveAccelerationStructureDescriptor {
|
|
return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "alloc")
|
|
}
|
|
@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="init")
|
|
PrimitiveAccelerationStructureDescriptor_init :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^PrimitiveAccelerationStructureDescriptor {
|
|
return msgSend(^PrimitiveAccelerationStructureDescriptor, self, "init")
|
|
}
|
|
@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_class_name="descriptor")
|
|
PrimitiveAccelerationStructureDescriptor_descriptor :: proc() -> ^PrimitiveAccelerationStructureDescriptor {
|
|
return msgSend(^PrimitiveAccelerationStructureDescriptor, PrimitiveAccelerationStructureDescriptor, "descriptor")
|
|
}
|
|
@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="geometryDescriptors")
|
|
PrimitiveAccelerationStructureDescriptor_geometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "geometryDescriptors")
|
|
}
|
|
@(objc_type=PrimitiveAccelerationStructureDescriptor, objc_name="setGeometryDescriptors")
|
|
PrimitiveAccelerationStructureDescriptor_setGeometryDescriptors :: proc(self: ^PrimitiveAccelerationStructureDescriptor, geometryDescriptors: ^NS.Array) {
|
|
msgSend(nil, self, "setGeometryDescriptors:", geometryDescriptors)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RasterizationRateLayerArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLRasterizationRateLayerArray")
|
|
RasterizationRateLayerArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=RasterizationRateLayerArray, objc_class_name="alloc")
|
|
RasterizationRateLayerArray_alloc :: proc() -> ^RasterizationRateLayerArray {
|
|
return msgSend(^RasterizationRateLayerArray, RasterizationRateLayerArray, "alloc")
|
|
}
|
|
@(objc_type=RasterizationRateLayerArray, objc_name="init")
|
|
RasterizationRateLayerArray_init :: proc(self: ^RasterizationRateLayerArray) -> ^RasterizationRateLayerArray {
|
|
return msgSend(^RasterizationRateLayerArray, self, "init")
|
|
}
|
|
@(objc_type=RasterizationRateLayerArray, objc_name="objectAtIndexedSubscript")
|
|
RasterizationRateLayerArray_objectAtIndexedSubscript :: proc(self: ^RasterizationRateLayerArray, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor {
|
|
return msgSend(^RasterizationRateLayerDescriptor, self, "objectAtIndexedSubscript:", layerIndex)
|
|
}
|
|
@(objc_type=RasterizationRateLayerArray, objc_name="setObject")
|
|
RasterizationRateLayerArray_setObject :: proc(self: ^RasterizationRateLayerArray, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", layer, layerIndex)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RasterizationRateLayerDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
horizontal
|
|
horizontalSampleStorage
|
|
init
|
|
initWithSampleCount
|
|
initWithSampleCount
|
|
sampleCount
|
|
vertical
|
|
verticalSampleStorage
|
|
*/
|
|
@(objc_class="MTLRasterizationRateLayerDescriptor")
|
|
RasterizationRateLayerDescriptor :: struct { using _: NS.Copying(RasterizationRateLayerDescriptor) }
|
|
|
|
@(objc_type=RasterizationRateLayerDescriptor, objc_class_name="alloc")
|
|
RasterizationRateLayerDescriptor_alloc :: proc() -> ^RasterizationRateLayerDescriptor {
|
|
return msgSend(^RasterizationRateLayerDescriptor, RasterizationRateLayerDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RasterizationRateLayerDescriptor, objc_name="horizontal")
|
|
RasterizationRateLayerDescriptor_horizontal :: proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray {
|
|
return msgSend(^RasterizationRateSampleArray, self, "horizontal")
|
|
}
|
|
@(objc_type=RasterizationRateLayerDescriptor, objc_name="horizontalSampleStorage")
|
|
RasterizationRateLayerDescriptor_horizontalSampleStorage :: proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 {
|
|
return msgSend(^f32, self, "horizontalSampleStorage")
|
|
}
|
|
@(objc_type=RasterizationRateLayerDescriptor, objc_name="init")
|
|
RasterizationRateLayerDescriptor_init :: proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateLayerDescriptor {
|
|
return msgSend(^RasterizationRateLayerDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RasterizationRateLayerDescriptor, objc_name="initWithSampleCount")
|
|
RasterizationRateLayerDescriptor_initWithSampleCount :: proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size) -> ^RasterizationRateLayerDescriptor {
|
|
return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:", sampleCount)
|
|
}
|
|
@(objc_type=RasterizationRateLayerDescriptor, objc_name="initWithSampleCountWithDimensions")
|
|
RasterizationRateLayerDescriptor_initWithSampleCountWithDimensions :: proc(self: ^RasterizationRateLayerDescriptor, sampleCount: Size, horizontal: ^f32, vertical: ^f32) -> ^RasterizationRateLayerDescriptor {
|
|
return msgSend(^RasterizationRateLayerDescriptor, self, "initWithSampleCount:horizontal:vertical:", sampleCount, horizontal, vertical)
|
|
}
|
|
@(objc_type=RasterizationRateLayerDescriptor, objc_name="sampleCount")
|
|
RasterizationRateLayerDescriptor_sampleCount :: proc(self: ^RasterizationRateLayerDescriptor) -> Size {
|
|
return msgSend(Size, self, "sampleCount")
|
|
}
|
|
@(objc_type=RasterizationRateLayerDescriptor, objc_name="vertical")
|
|
RasterizationRateLayerDescriptor_vertical :: proc(self: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateSampleArray {
|
|
return msgSend(^RasterizationRateSampleArray, self, "vertical")
|
|
}
|
|
@(objc_type=RasterizationRateLayerDescriptor, objc_name="verticalSampleStorage")
|
|
RasterizationRateLayerDescriptor_verticalSampleStorage :: proc(self: ^RasterizationRateLayerDescriptor) -> ^f32 {
|
|
return msgSend(^f32, self, "verticalSampleStorage")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RasterizationRateMapDescriptor
|
|
Class Methods:
|
|
alloc
|
|
rasterizationRateMapDescriptorWithScreenSize
|
|
rasterizationRateMapDescriptorWithScreenSize
|
|
rasterizationRateMapDescriptorWithScreenSize
|
|
Methods:
|
|
init
|
|
label
|
|
layerAtIndex
|
|
layerCount
|
|
layers
|
|
screenSize
|
|
setLabel
|
|
setLayer
|
|
setScreenSize
|
|
*/
|
|
@(objc_class="MTLRasterizationRateMapDescriptor")
|
|
RasterizationRateMapDescriptor :: struct { using _: NS.Copying(RasterizationRateMapDescriptor) }
|
|
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_class_name="alloc")
|
|
RasterizationRateMapDescriptor_alloc :: proc() -> ^RasterizationRateMapDescriptor {
|
|
return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_name="init")
|
|
RasterizationRateMapDescriptor_init :: proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateMapDescriptor {
|
|
return msgSend(^RasterizationRateMapDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_name="label")
|
|
RasterizationRateMapDescriptor_label :: proc(self: ^RasterizationRateMapDescriptor) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_name="layerAtIndex")
|
|
RasterizationRateMapDescriptor_layerAtIndex :: proc(self: ^RasterizationRateMapDescriptor, layerIndex: ^NS.Object) -> ^RasterizationRateLayerDescriptor {
|
|
return msgSend(^RasterizationRateLayerDescriptor, self, "layerAtIndex:", layerIndex)
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_name="layerCount")
|
|
RasterizationRateMapDescriptor_layerCount :: proc(self: ^RasterizationRateMapDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "layerCount")
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_name="layers")
|
|
RasterizationRateMapDescriptor_layers :: proc(self: ^RasterizationRateMapDescriptor) -> ^RasterizationRateLayerArray {
|
|
return msgSend(^RasterizationRateLayerArray, self, "layers")
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize")
|
|
RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize :: proc(screenSize: Size) -> ^RasterizationRateMapDescriptor {
|
|
return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:", screenSize)
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize_layer_")
|
|
RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layer_ :: proc(screenSize: Size, layer: ^RasterizationRateLayerDescriptor) -> ^RasterizationRateMapDescriptor {
|
|
return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layer:", screenSize, layer)
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_class_name="rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_")
|
|
RasterizationRateMapDescriptor_rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_ :: proc(screenSize: Size, layerCount: ^NS.Object, layers: ^^RasterizationRateLayerDescriptor ) -> ^RasterizationRateMapDescriptor {
|
|
return msgSend(^RasterizationRateMapDescriptor, RasterizationRateMapDescriptor, "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:", screenSize, layerCount, layers)
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_name="screenSize")
|
|
RasterizationRateMapDescriptor_screenSize :: proc(self: ^RasterizationRateMapDescriptor) -> Size {
|
|
return msgSend(Size, self, "screenSize")
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_name="setLabel")
|
|
RasterizationRateMapDescriptor_setLabel :: proc(self: ^RasterizationRateMapDescriptor, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_name="setLayer")
|
|
RasterizationRateMapDescriptor_setLayer :: proc(self: ^RasterizationRateMapDescriptor, layer: ^RasterizationRateLayerDescriptor, layerIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setLayer:atIndex:", layer, layerIndex)
|
|
}
|
|
@(objc_type=RasterizationRateMapDescriptor, objc_name="setScreenSize")
|
|
RasterizationRateMapDescriptor_setScreenSize :: proc(self: ^RasterizationRateMapDescriptor, screenSize: Size) {
|
|
msgSend(nil, self, "setScreenSize:", screenSize)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RasterizationRateSampleArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLRasterizationRateSampleArray")
|
|
RasterizationRateSampleArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=RasterizationRateSampleArray, objc_class_name="alloc")
|
|
RasterizationRateSampleArray_alloc :: proc() -> ^RasterizationRateSampleArray {
|
|
return msgSend(^RasterizationRateSampleArray, RasterizationRateSampleArray, "alloc")
|
|
}
|
|
@(objc_type=RasterizationRateSampleArray, objc_name="init")
|
|
RasterizationRateSampleArray_init :: proc(self: ^RasterizationRateSampleArray) -> ^RasterizationRateSampleArray {
|
|
return msgSend(^RasterizationRateSampleArray, self, "init")
|
|
}
|
|
@(objc_type=RasterizationRateSampleArray, objc_name="objectAtIndexedSubscript")
|
|
RasterizationRateSampleArray_objectAtIndexedSubscript :: proc(self: ^RasterizationRateSampleArray, index: ^NS.Object) -> ^NS.Number {
|
|
return msgSend(^NS.Number, self, "objectAtIndexedSubscript:", index)
|
|
}
|
|
@(objc_type=RasterizationRateSampleArray, objc_name="setObject")
|
|
RasterizationRateSampleArray_setObject :: proc(self: ^RasterizationRateSampleArray, value: ^NS.Number, index: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", value, index)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPassAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
depthPlane
|
|
level
|
|
loadAction
|
|
resolveDepthPlane
|
|
resolveLevel
|
|
resolveSlice
|
|
resolveTexture
|
|
setDepthPlane
|
|
setLevel
|
|
setLoadAction
|
|
setResolveDepthPlane
|
|
setResolveLevel
|
|
setResolveSlice
|
|
setResolveTexture
|
|
setSlice
|
|
setStoreAction
|
|
setStoreActionOptions
|
|
setTexture
|
|
slice
|
|
storeAction
|
|
storeActionOptions
|
|
texture
|
|
*/
|
|
@(objc_class="MTLRenderPassAttachmentDescriptor")
|
|
RenderPassAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassAttachmentDescriptor) }
|
|
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_class_name="alloc")
|
|
RenderPassAttachmentDescriptor_alloc :: proc() -> ^RenderPassAttachmentDescriptor {
|
|
return msgSend(^RenderPassAttachmentDescriptor, RenderPassAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="init")
|
|
RenderPassAttachmentDescriptor_init :: proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor {
|
|
return msgSend(^RenderPassAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="depthPlane")
|
|
RenderPassAttachmentDescriptor_depthPlane :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "depthPlane")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="level")
|
|
RenderPassAttachmentDescriptor_level :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "level")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="loadAction")
|
|
RenderPassAttachmentDescriptor_loadAction :: proc(self: ^RenderPassAttachmentDescriptor) -> LoadAction {
|
|
return msgSend(LoadAction, self, "loadAction")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveDepthPlane")
|
|
RenderPassAttachmentDescriptor_resolveDepthPlane :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "resolveDepthPlane")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveLevel")
|
|
RenderPassAttachmentDescriptor_resolveLevel :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "resolveLevel")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveSlice")
|
|
RenderPassAttachmentDescriptor_resolveSlice :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "resolveSlice")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="resolveTexture")
|
|
RenderPassAttachmentDescriptor_resolveTexture :: proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor {
|
|
return msgSend(^RenderPassAttachmentDescriptor, self, "resolveTexture")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setDepthPlane")
|
|
RenderPassAttachmentDescriptor_setDepthPlane :: proc(self: ^RenderPassAttachmentDescriptor, depthPlane: NS.Integer) {
|
|
msgSend(nil, self, "setDepthPlane:", depthPlane)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setLevel")
|
|
RenderPassAttachmentDescriptor_setLevel :: proc(self: ^RenderPassAttachmentDescriptor, level: NS.Integer) {
|
|
msgSend(nil, self, "setLevel:", level)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setLoadAction")
|
|
RenderPassAttachmentDescriptor_setLoadAction :: proc(self: ^RenderPassAttachmentDescriptor, loadAction: LoadAction) {
|
|
msgSend(nil, self, "setLoadAction:", loadAction)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveDepthPlane")
|
|
RenderPassAttachmentDescriptor_setResolveDepthPlane :: proc(self: ^RenderPassAttachmentDescriptor, resolveDepthPlane: NS.Integer) {
|
|
msgSend(nil, self, "setResolveDepthPlane:", resolveDepthPlane)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveLevel")
|
|
RenderPassAttachmentDescriptor_setResolveLevel :: proc(self: ^RenderPassAttachmentDescriptor, resolveLevel: NS.Integer) {
|
|
msgSend(nil, self, "setResolveLevel:", resolveLevel)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveSlice")
|
|
RenderPassAttachmentDescriptor_setResolveSlice :: proc(self: ^RenderPassAttachmentDescriptor, resolveSlice: NS.Integer) {
|
|
msgSend(nil, self, "setResolveSlice:", resolveSlice)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setResolveTexture")
|
|
RenderPassAttachmentDescriptor_setResolveTexture :: proc(self: ^RenderPassAttachmentDescriptor, resolveTexture: ^NS.Object) {
|
|
msgSend(nil, self, "setResolveTexture:", resolveTexture)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setSlice")
|
|
RenderPassAttachmentDescriptor_setSlice :: proc(self: ^RenderPassAttachmentDescriptor, slice: NS.Integer) {
|
|
msgSend(nil, self, "setSlice:", slice)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setStoreAction")
|
|
RenderPassAttachmentDescriptor_setStoreAction :: proc(self: ^RenderPassAttachmentDescriptor, storeAction: StoreAction) {
|
|
msgSend(nil, self, "setStoreAction:", storeAction)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setStoreActionOptions")
|
|
RenderPassAttachmentDescriptor_setStoreActionOptions :: proc(self: ^RenderPassAttachmentDescriptor, storeActionOptions: StoreActionOptions) {
|
|
msgSend(nil, self, "setStoreActionOptions:", storeActionOptions)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="setTexture")
|
|
RenderPassAttachmentDescriptor_setTexture :: proc(self: ^RenderPassAttachmentDescriptor, texture: ^NS.Object) {
|
|
msgSend(nil, self, "setTexture:", texture)
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="slice")
|
|
RenderPassAttachmentDescriptor_slice :: proc(self: ^RenderPassAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "slice")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="storeAction")
|
|
RenderPassAttachmentDescriptor_storeAction :: proc(self: ^RenderPassAttachmentDescriptor) -> StoreAction {
|
|
return msgSend(StoreAction, self, "storeAction")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="storeActionOptions")
|
|
RenderPassAttachmentDescriptor_storeActionOptions :: proc(self: ^RenderPassAttachmentDescriptor) -> StoreActionOptions {
|
|
return msgSend(StoreActionOptions, self, "storeActionOptions")
|
|
}
|
|
@(objc_type=RenderPassAttachmentDescriptor, objc_name="texture")
|
|
RenderPassAttachmentDescriptor_texture :: proc(self: ^RenderPassAttachmentDescriptor) -> ^RenderPassAttachmentDescriptor {
|
|
return msgSend(^RenderPassAttachmentDescriptor, self, "texture")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPassColorAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
clearColor
|
|
setClearColor
|
|
*/
|
|
@(objc_class="MTLRenderPassColorAttachmentDescriptor")
|
|
RenderPassColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassColorAttachmentDescriptor) }
|
|
|
|
@(objc_type=RenderPassColorAttachmentDescriptor, objc_class_name="alloc")
|
|
RenderPassColorAttachmentDescriptor_alloc :: proc() -> ^RenderPassColorAttachmentDescriptor {
|
|
return msgSend(^RenderPassColorAttachmentDescriptor, RenderPassColorAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RenderPassColorAttachmentDescriptor, objc_name="init")
|
|
RenderPassColorAttachmentDescriptor_init :: proc(self: ^RenderPassColorAttachmentDescriptor) -> ^RenderPassColorAttachmentDescriptor {
|
|
return msgSend(^RenderPassColorAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RenderPassColorAttachmentDescriptor, objc_name="clearColor")
|
|
RenderPassColorAttachmentDescriptor_clearColor :: proc(self: ^RenderPassColorAttachmentDescriptor) -> ClearColor {
|
|
return msgSend(ClearColor, self, "clearColor")
|
|
}
|
|
@(objc_type=RenderPassColorAttachmentDescriptor, objc_name="setClearColor")
|
|
RenderPassColorAttachmentDescriptor_setClearColor :: proc(self: ^RenderPassColorAttachmentDescriptor, clearColor: ClearColor) {
|
|
msgSend(nil, self, "setClearColor:", clearColor)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPassColorAttachmentDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLRenderPassColorAttachmentDescriptorArray")
|
|
RenderPassColorAttachmentDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_class_name="alloc")
|
|
RenderPassColorAttachmentDescriptorArray_alloc :: proc() -> ^RenderPassColorAttachmentDescriptorArray {
|
|
return msgSend(^RenderPassColorAttachmentDescriptorArray, RenderPassColorAttachmentDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="init")
|
|
RenderPassColorAttachmentDescriptorArray_init :: proc(self: ^RenderPassColorAttachmentDescriptorArray) -> ^RenderPassColorAttachmentDescriptorArray {
|
|
return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
RenderPassColorAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^RenderPassColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassColorAttachmentDescriptor {
|
|
return msgSend(^RenderPassColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex)
|
|
}
|
|
@(objc_type=RenderPassColorAttachmentDescriptorArray, objc_name="setObject")
|
|
RenderPassColorAttachmentDescriptorArray_setObject :: proc(self: ^RenderPassColorAttachmentDescriptorArray, attachment: ^RenderPassColorAttachmentDescriptor, attachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPassDepthAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
clearDepth
|
|
depthResolveFilter
|
|
setClearDepth
|
|
setDepthResolveFilter
|
|
*/
|
|
@(objc_class="MTLRenderPassDepthAttachmentDescriptor")
|
|
RenderPassDepthAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassDepthAttachmentDescriptor) }
|
|
|
|
@(objc_type=RenderPassDepthAttachmentDescriptor, objc_class_name="alloc")
|
|
RenderPassDepthAttachmentDescriptor_alloc :: proc() -> ^RenderPassDepthAttachmentDescriptor {
|
|
return msgSend(^RenderPassDepthAttachmentDescriptor, RenderPassDepthAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="init")
|
|
RenderPassDepthAttachmentDescriptor_init :: proc(self: ^RenderPassDepthAttachmentDescriptor) -> ^RenderPassDepthAttachmentDescriptor {
|
|
return msgSend(^RenderPassDepthAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="clearDepth")
|
|
RenderPassDepthAttachmentDescriptor_clearDepth :: proc(self: ^RenderPassDepthAttachmentDescriptor) -> f64 {
|
|
return msgSend(f64, self, "clearDepth")
|
|
}
|
|
@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="depthResolveFilter")
|
|
RenderPassDepthAttachmentDescriptor_depthResolveFilter :: proc(self: ^RenderPassDepthAttachmentDescriptor) -> MultisampleDepthResolveFilter {
|
|
return msgSend(MultisampleDepthResolveFilter, self, "depthResolveFilter")
|
|
}
|
|
@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="setClearDepth")
|
|
RenderPassDepthAttachmentDescriptor_setClearDepth :: proc(self: ^RenderPassDepthAttachmentDescriptor, clearDepth: f64) {
|
|
msgSend(nil, self, "setClearDepth:", clearDepth)
|
|
}
|
|
@(objc_type=RenderPassDepthAttachmentDescriptor, objc_name="setDepthResolveFilter")
|
|
RenderPassDepthAttachmentDescriptor_setDepthResolveFilter :: proc(self: ^RenderPassDepthAttachmentDescriptor, depthResolveFilter: MultisampleDepthResolveFilter) {
|
|
msgSend(nil, self, "setDepthResolveFilter:", depthResolveFilter)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPassDescriptor
|
|
Class Methods:
|
|
alloc
|
|
renderPassDescriptor
|
|
Methods:
|
|
init
|
|
colorAttachments
|
|
defaultRasterSampleCount
|
|
depthAttachment
|
|
getSamplePositions
|
|
imageblockSampleLength
|
|
rasterizationRateMap
|
|
renderTargetArrayLength
|
|
renderTargetHeight
|
|
renderTargetWidth
|
|
sampleBufferAttachments
|
|
setDefaultRasterSampleCount
|
|
setDepthAttachment
|
|
setImageblockSampleLength
|
|
setRasterizationRateMap
|
|
setRenderTargetArrayLength
|
|
setRenderTargetHeight
|
|
setRenderTargetWidth
|
|
setSamplePositions
|
|
setStencilAttachment
|
|
setThreadgroupMemoryLength
|
|
setTileHeight
|
|
setTileWidth
|
|
setVisibilityResultBuffer
|
|
stencilAttachment
|
|
threadgroupMemoryLength
|
|
tileHeight
|
|
tileWidth
|
|
visibilityResultBuffer
|
|
*/
|
|
@(objc_class="MTLRenderPassDescriptor")
|
|
RenderPassDescriptor :: struct { using _: NS.Copying(RenderPassDescriptor) }
|
|
|
|
@(objc_type=RenderPassDescriptor, objc_class_name="alloc")
|
|
RenderPassDescriptor_alloc :: proc() -> ^RenderPassDescriptor {
|
|
return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="init")
|
|
RenderPassDescriptor_init :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor {
|
|
return msgSend(^RenderPassDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="colorAttachments")
|
|
RenderPassDescriptor_colorAttachments :: proc(self: ^RenderPassDescriptor) -> ^RenderPassColorAttachmentDescriptorArray {
|
|
return msgSend(^RenderPassColorAttachmentDescriptorArray, self, "colorAttachments")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="defaultRasterSampleCount")
|
|
RenderPassDescriptor_defaultRasterSampleCount :: proc(self: ^RenderPassDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "defaultRasterSampleCount")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="depthAttachment")
|
|
RenderPassDescriptor_depthAttachment :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDepthAttachmentDescriptor {
|
|
return msgSend(^RenderPassDepthAttachmentDescriptor, self, "depthAttachment")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="getSamplePositions")
|
|
RenderPassDescriptor_getSamplePositions :: proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) -> ^RenderPassDescriptor {
|
|
return msgSend(^RenderPassDescriptor, self, "getSamplePositions:count:", positions, count)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="imageblockSampleLength")
|
|
RenderPassDescriptor_imageblockSampleLength :: proc(self: ^RenderPassDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "imageblockSampleLength")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="rasterizationRateMap")
|
|
RenderPassDescriptor_rasterizationRateMap :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor {
|
|
return msgSend(^RenderPassDescriptor, self, "rasterizationRateMap")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_class_name="renderPassDescriptor")
|
|
RenderPassDescriptor_renderPassDescriptor :: proc() -> ^RenderPassDescriptor {
|
|
return msgSend(^RenderPassDescriptor, RenderPassDescriptor, "renderPassDescriptor")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="renderTargetArrayLength")
|
|
RenderPassDescriptor_renderTargetArrayLength :: proc(self: ^RenderPassDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "renderTargetArrayLength")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="renderTargetHeight")
|
|
RenderPassDescriptor_renderTargetHeight :: proc(self: ^RenderPassDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "renderTargetHeight")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="renderTargetWidth")
|
|
RenderPassDescriptor_renderTargetWidth :: proc(self: ^RenderPassDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "renderTargetWidth")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="sampleBufferAttachments")
|
|
RenderPassDescriptor_sampleBufferAttachments :: proc(self: ^RenderPassDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setDefaultRasterSampleCount")
|
|
RenderPassDescriptor_setDefaultRasterSampleCount :: proc(self: ^RenderPassDescriptor, defaultRasterSampleCount: NS.Integer) {
|
|
msgSend(nil, self, "setDefaultRasterSampleCount:", defaultRasterSampleCount)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setDepthAttachment")
|
|
RenderPassDescriptor_setDepthAttachment :: proc(self: ^RenderPassDescriptor, depthAttachment: ^RenderPassDepthAttachmentDescriptor) {
|
|
msgSend(nil, self, "setDepthAttachment:", depthAttachment)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setImageblockSampleLength")
|
|
RenderPassDescriptor_setImageblockSampleLength :: proc(self: ^RenderPassDescriptor, imageblockSampleLength: NS.Integer) {
|
|
msgSend(nil, self, "setImageblockSampleLength:", imageblockSampleLength)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setRasterizationRateMap")
|
|
RenderPassDescriptor_setRasterizationRateMap :: proc(self: ^RenderPassDescriptor, rasterizationRateMap: ^NS.Object) {
|
|
msgSend(nil, self, "setRasterizationRateMap:", rasterizationRateMap)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setRenderTargetArrayLength")
|
|
RenderPassDescriptor_setRenderTargetArrayLength :: proc(self: ^RenderPassDescriptor, renderTargetArrayLength: NS.Integer) {
|
|
msgSend(nil, self, "setRenderTargetArrayLength:", renderTargetArrayLength)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setRenderTargetHeight")
|
|
RenderPassDescriptor_setRenderTargetHeight :: proc(self: ^RenderPassDescriptor, renderTargetHeight: NS.Integer) {
|
|
msgSend(nil, self, "setRenderTargetHeight:", renderTargetHeight)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setRenderTargetWidth")
|
|
RenderPassDescriptor_setRenderTargetWidth :: proc(self: ^RenderPassDescriptor, renderTargetWidth: NS.Integer) {
|
|
msgSend(nil, self, "setRenderTargetWidth:", renderTargetWidth)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setSamplePositions")
|
|
RenderPassDescriptor_setSamplePositions :: proc(self: ^RenderPassDescriptor, positions: ^SamplePosition, count: ^NS.Object) {
|
|
msgSend(nil, self, "setSamplePositions:count:", positions, count)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setStencilAttachment")
|
|
RenderPassDescriptor_setStencilAttachment :: proc(self: ^RenderPassDescriptor, stencilAttachment: ^RenderPassStencilAttachmentDescriptor) {
|
|
msgSend(nil, self, "setStencilAttachment:", stencilAttachment)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setThreadgroupMemoryLength")
|
|
RenderPassDescriptor_setThreadgroupMemoryLength :: proc(self: ^RenderPassDescriptor, threadgroupMemoryLength: NS.Integer) {
|
|
msgSend(nil, self, "setThreadgroupMemoryLength:", threadgroupMemoryLength)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setTileHeight")
|
|
RenderPassDescriptor_setTileHeight :: proc(self: ^RenderPassDescriptor, tileHeight: NS.Integer) {
|
|
msgSend(nil, self, "setTileHeight:", tileHeight)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setTileWidth")
|
|
RenderPassDescriptor_setTileWidth :: proc(self: ^RenderPassDescriptor, tileWidth: NS.Integer) {
|
|
msgSend(nil, self, "setTileWidth:", tileWidth)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="setVisibilityResultBuffer")
|
|
RenderPassDescriptor_setVisibilityResultBuffer :: proc(self: ^RenderPassDescriptor, visibilityResultBuffer: ^NS.Object) {
|
|
msgSend(nil, self, "setVisibilityResultBuffer:", visibilityResultBuffer)
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="stencilAttachment")
|
|
RenderPassDescriptor_stencilAttachment :: proc(self: ^RenderPassDescriptor) -> ^RenderPassStencilAttachmentDescriptor {
|
|
return msgSend(^RenderPassStencilAttachmentDescriptor, self, "stencilAttachment")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="threadgroupMemoryLength")
|
|
RenderPassDescriptor_threadgroupMemoryLength :: proc(self: ^RenderPassDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "threadgroupMemoryLength")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="tileHeight")
|
|
RenderPassDescriptor_tileHeight :: proc(self: ^RenderPassDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "tileHeight")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="tileWidth")
|
|
RenderPassDescriptor_tileWidth :: proc(self: ^RenderPassDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "tileWidth")
|
|
}
|
|
@(objc_type=RenderPassDescriptor, objc_name="visibilityResultBuffer")
|
|
RenderPassDescriptor_visibilityResultBuffer :: proc(self: ^RenderPassDescriptor) -> ^RenderPassDescriptor {
|
|
return msgSend(^RenderPassDescriptor, self, "visibilityResultBuffer")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPassSampleBufferAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
endOfFragmentSampleIndex
|
|
endOfVertexSampleIndex
|
|
sampleBuffer
|
|
setEndOfFragmentSampleIndex
|
|
setEndOfVertexSampleIndex
|
|
setSampleBuffer
|
|
setStartOfFragmentSampleIndex
|
|
setStartOfVertexSampleIndex
|
|
startOfFragmentSampleIndex
|
|
startOfVertexSampleIndex
|
|
*/
|
|
@(objc_class="MTLRenderPassSampleBufferAttachmentDescriptor")
|
|
RenderPassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassSampleBufferAttachmentDescriptor) }
|
|
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_class_name="alloc")
|
|
RenderPassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^RenderPassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^RenderPassSampleBufferAttachmentDescriptor, RenderPassSampleBufferAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="init")
|
|
RenderPassSampleBufferAttachmentDescriptor_init :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfFragmentSampleIndex")
|
|
RenderPassSampleBufferAttachmentDescriptor_endOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "endOfFragmentSampleIndex")
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="endOfVertexSampleIndex")
|
|
RenderPassSampleBufferAttachmentDescriptor_endOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "endOfVertexSampleIndex")
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer")
|
|
RenderPassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> ^RenderPassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "sampleBuffer")
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfFragmentSampleIndex")
|
|
RenderPassSampleBufferAttachmentDescriptor_setEndOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfFragmentSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setEndOfFragmentSampleIndex:", endOfFragmentSampleIndex)
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setEndOfVertexSampleIndex")
|
|
RenderPassSampleBufferAttachmentDescriptor_setEndOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, endOfVertexSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setEndOfVertexSampleIndex:", endOfVertexSampleIndex)
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer")
|
|
RenderPassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) {
|
|
msgSend(nil, self, "setSampleBuffer:", sampleBuffer)
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfFragmentSampleIndex")
|
|
RenderPassSampleBufferAttachmentDescriptor_setStartOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfFragmentSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setStartOfFragmentSampleIndex:", startOfFragmentSampleIndex)
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="setStartOfVertexSampleIndex")
|
|
RenderPassSampleBufferAttachmentDescriptor_setStartOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor, startOfVertexSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setStartOfVertexSampleIndex:", startOfVertexSampleIndex)
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfFragmentSampleIndex")
|
|
RenderPassSampleBufferAttachmentDescriptor_startOfFragmentSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "startOfFragmentSampleIndex")
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptor, objc_name="startOfVertexSampleIndex")
|
|
RenderPassSampleBufferAttachmentDescriptor_startOfVertexSampleIndex :: proc(self: ^RenderPassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "startOfVertexSampleIndex")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPassSampleBufferAttachmentDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLRenderPassSampleBufferAttachmentDescriptorArray")
|
|
RenderPassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc")
|
|
RenderPassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^RenderPassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, RenderPassSampleBufferAttachmentDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="init")
|
|
RenderPassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray) -> ^RenderPassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^RenderPassSampleBufferAttachmentDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
RenderPassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^RenderPassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex)
|
|
}
|
|
@(objc_type=RenderPassSampleBufferAttachmentDescriptorArray, objc_name="setObject")
|
|
RenderPassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^RenderPassSampleBufferAttachmentDescriptorArray, attachment: ^RenderPassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPassStencilAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
clearStencil
|
|
setClearStencil
|
|
setStencilResolveFilter
|
|
stencilResolveFilter
|
|
*/
|
|
@(objc_class="MTLRenderPassStencilAttachmentDescriptor")
|
|
RenderPassStencilAttachmentDescriptor :: struct { using _: NS.Copying(RenderPassStencilAttachmentDescriptor) }
|
|
|
|
@(objc_type=RenderPassStencilAttachmentDescriptor, objc_class_name="alloc")
|
|
RenderPassStencilAttachmentDescriptor_alloc :: proc() -> ^RenderPassStencilAttachmentDescriptor {
|
|
return msgSend(^RenderPassStencilAttachmentDescriptor, RenderPassStencilAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="init")
|
|
RenderPassStencilAttachmentDescriptor_init :: proc(self: ^RenderPassStencilAttachmentDescriptor) -> ^RenderPassStencilAttachmentDescriptor {
|
|
return msgSend(^RenderPassStencilAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="clearStencil")
|
|
RenderPassStencilAttachmentDescriptor_clearStencil :: proc(self: ^RenderPassStencilAttachmentDescriptor) -> u32 {
|
|
return msgSend(u32, self, "clearStencil")
|
|
}
|
|
@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="setClearStencil")
|
|
RenderPassStencilAttachmentDescriptor_setClearStencil :: proc(self: ^RenderPassStencilAttachmentDescriptor, clearStencil: u32) {
|
|
msgSend(nil, self, "setClearStencil:", clearStencil)
|
|
}
|
|
@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="setStencilResolveFilter")
|
|
RenderPassStencilAttachmentDescriptor_setStencilResolveFilter :: proc(self: ^RenderPassStencilAttachmentDescriptor, stencilResolveFilter: MultisampleStencilResolveFilter) {
|
|
msgSend(nil, self, "setStencilResolveFilter:", stencilResolveFilter)
|
|
}
|
|
@(objc_type=RenderPassStencilAttachmentDescriptor, objc_name="stencilResolveFilter")
|
|
RenderPassStencilAttachmentDescriptor_stencilResolveFilter :: proc(self: ^RenderPassStencilAttachmentDescriptor) -> MultisampleStencilResolveFilter {
|
|
return msgSend(MultisampleStencilResolveFilter, self, "stencilResolveFilter")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPipelineColorAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
alphaBlendOperation
|
|
destinationAlphaBlendFactor
|
|
destinationRGBBlendFactor
|
|
isBlendingEnabled
|
|
pixelFormat
|
|
rgbBlendOperation
|
|
setAlphaBlendOperation
|
|
setBlendingEnabled
|
|
setDestinationAlphaBlendFactor
|
|
setDestinationRGBBlendFactor
|
|
setPixelFormat
|
|
setRgbBlendOperation
|
|
setSourceAlphaBlendFactor
|
|
setSourceRGBBlendFactor
|
|
setWriteMask
|
|
sourceAlphaBlendFactor
|
|
sourceRGBBlendFactor
|
|
writeMask
|
|
*/
|
|
@(objc_class="MTLRenderPipelineColorAttachmentDescriptor")
|
|
RenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(RenderPipelineColorAttachmentDescriptor) }
|
|
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_class_name="alloc")
|
|
RenderPipelineColorAttachmentDescriptor_alloc :: proc() -> ^RenderPipelineColorAttachmentDescriptor {
|
|
return msgSend(^RenderPipelineColorAttachmentDescriptor, RenderPipelineColorAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="init")
|
|
RenderPipelineColorAttachmentDescriptor_init :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ^RenderPipelineColorAttachmentDescriptor {
|
|
return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="alphaBlendOperation")
|
|
RenderPipelineColorAttachmentDescriptor_alphaBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation {
|
|
return msgSend(BlendOperation, self, "alphaBlendOperation")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="destinationAlphaBlendFactor")
|
|
RenderPipelineColorAttachmentDescriptor_destinationAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor {
|
|
return msgSend(BlendFactor, self, "destinationAlphaBlendFactor")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="destinationRGBBlendFactor")
|
|
RenderPipelineColorAttachmentDescriptor_destinationRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor {
|
|
return msgSend(BlendFactor, self, "destinationRGBBlendFactor")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="isBlendingEnabled")
|
|
RenderPipelineColorAttachmentDescriptor_isBlendingEnabled :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "isBlendingEnabled")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="pixelFormat")
|
|
RenderPipelineColorAttachmentDescriptor_pixelFormat :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> PixelFormat {
|
|
return msgSend(PixelFormat, self, "pixelFormat")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="rgbBlendOperation")
|
|
RenderPipelineColorAttachmentDescriptor_rgbBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendOperation {
|
|
return msgSend(BlendOperation, self, "rgbBlendOperation")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setAlphaBlendOperation")
|
|
RenderPipelineColorAttachmentDescriptor_setAlphaBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor, alphaBlendOperation: BlendOperation) {
|
|
msgSend(nil, self, "setAlphaBlendOperation:", alphaBlendOperation)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setBlendingEnabled")
|
|
RenderPipelineColorAttachmentDescriptor_setBlendingEnabled :: proc(self: ^RenderPipelineColorAttachmentDescriptor, blendingEnabled: BOOL) {
|
|
msgSend(nil, self, "setBlendingEnabled:", blendingEnabled)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setDestinationAlphaBlendFactor")
|
|
RenderPipelineColorAttachmentDescriptor_setDestinationAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationAlphaBlendFactor: BlendFactor) {
|
|
msgSend(nil, self, "setDestinationAlphaBlendFactor:", destinationAlphaBlendFactor)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setDestinationRGBBlendFactor")
|
|
RenderPipelineColorAttachmentDescriptor_setDestinationRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, destinationRGBBlendFactor: BlendFactor) {
|
|
msgSend(nil, self, "setDestinationRGBBlendFactor:", destinationRGBBlendFactor)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setPixelFormat")
|
|
RenderPipelineColorAttachmentDescriptor_setPixelFormat :: proc(self: ^RenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) {
|
|
msgSend(nil, self, "setPixelFormat:", pixelFormat)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setRgbBlendOperation")
|
|
RenderPipelineColorAttachmentDescriptor_setRgbBlendOperation :: proc(self: ^RenderPipelineColorAttachmentDescriptor, rgbBlendOperation: BlendOperation) {
|
|
msgSend(nil, self, "setRgbBlendOperation:", rgbBlendOperation)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setSourceAlphaBlendFactor")
|
|
RenderPipelineColorAttachmentDescriptor_setSourceAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceAlphaBlendFactor: BlendFactor) {
|
|
msgSend(nil, self, "setSourceAlphaBlendFactor:", sourceAlphaBlendFactor)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setSourceRGBBlendFactor")
|
|
RenderPipelineColorAttachmentDescriptor_setSourceRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor, sourceRGBBlendFactor: BlendFactor) {
|
|
msgSend(nil, self, "setSourceRGBBlendFactor:", sourceRGBBlendFactor)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="setWriteMask")
|
|
RenderPipelineColorAttachmentDescriptor_setWriteMask :: proc(self: ^RenderPipelineColorAttachmentDescriptor, writeMask: ColorWriteMask) {
|
|
msgSend(nil, self, "setWriteMask:", writeMask)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="sourceAlphaBlendFactor")
|
|
RenderPipelineColorAttachmentDescriptor_sourceAlphaBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor {
|
|
return msgSend(BlendFactor, self, "sourceAlphaBlendFactor")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="sourceRGBBlendFactor")
|
|
RenderPipelineColorAttachmentDescriptor_sourceRGBBlendFactor :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> BlendFactor {
|
|
return msgSend(BlendFactor, self, "sourceRGBBlendFactor")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptor, objc_name="writeMask")
|
|
RenderPipelineColorAttachmentDescriptor_writeMask :: proc(self: ^RenderPipelineColorAttachmentDescriptor) -> ColorWriteMask {
|
|
return msgSend(ColorWriteMask, self, "writeMask")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPipelineColorAttachmentDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLRenderPipelineColorAttachmentDescriptorArray")
|
|
RenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_class_name="alloc")
|
|
RenderPipelineColorAttachmentDescriptorArray_alloc :: proc() -> ^RenderPipelineColorAttachmentDescriptorArray {
|
|
return msgSend(^RenderPipelineColorAttachmentDescriptorArray, RenderPipelineColorAttachmentDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="init")
|
|
RenderPipelineColorAttachmentDescriptorArray_init :: proc(self: ^RenderPipelineColorAttachmentDescriptorArray) -> ^RenderPipelineColorAttachmentDescriptorArray {
|
|
return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
RenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^RenderPipelineColorAttachmentDescriptor {
|
|
return msgSend(^RenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex)
|
|
}
|
|
@(objc_type=RenderPipelineColorAttachmentDescriptorArray, objc_name="setObject")
|
|
RenderPipelineColorAttachmentDescriptorArray_setObject :: proc(self: ^RenderPipelineColorAttachmentDescriptorArray, attachment: ^RenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPipelineDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
binaryArchives
|
|
colorAttachments
|
|
depthAttachmentPixelFormat
|
|
fragmentBuffers
|
|
fragmentFunction
|
|
inputPrimitiveTopology
|
|
isAlphaToCoverageEnabled
|
|
isAlphaToOneEnabled
|
|
isRasterizationEnabled
|
|
isTessellationFactorScaleEnabled
|
|
label
|
|
maxTessellationFactor
|
|
maxVertexAmplificationCount
|
|
rasterSampleCount
|
|
reset
|
|
sampleCount
|
|
setAlphaToCoverageEnabled
|
|
setAlphaToOneEnabled
|
|
setBinaryArchives
|
|
setDepthAttachmentPixelFormat
|
|
setFragmentFunction
|
|
setInputPrimitiveTopology
|
|
setLabel
|
|
setMaxTessellationFactor
|
|
setMaxVertexAmplificationCount
|
|
setRasterSampleCount
|
|
setRasterizationEnabled
|
|
setSampleCount
|
|
setStencilAttachmentPixelFormat
|
|
setSupportIndirectCommandBuffers
|
|
setTessellationControlPointIndexType
|
|
setTessellationFactorFormat
|
|
setTessellationFactorScaleEnabled
|
|
setTessellationFactorStepFunction
|
|
setTessellationOutputWindingOrder
|
|
setTessellationPartitionMode
|
|
setVertexDescriptor
|
|
setVertexFunction
|
|
stencilAttachmentPixelFormat
|
|
supportIndirectCommandBuffers
|
|
tessellationControlPointIndexType
|
|
tessellationFactorFormat
|
|
tessellationFactorStepFunction
|
|
tessellationOutputWindingOrder
|
|
tessellationPartitionMode
|
|
vertexBuffers
|
|
vertexDescriptor
|
|
vertexFunction
|
|
*/
|
|
@(objc_class="MTLRenderPipelineDescriptor")
|
|
RenderPipelineDescriptor :: struct { using _: NS.Copying(RenderPipelineDescriptor) }
|
|
|
|
@(objc_type=RenderPipelineDescriptor, objc_class_name="alloc")
|
|
RenderPipelineDescriptor_alloc :: proc() -> ^RenderPipelineDescriptor {
|
|
return msgSend(^RenderPipelineDescriptor, RenderPipelineDescriptor, "alloc")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="init")
|
|
RenderPipelineDescriptor_init :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor {
|
|
return msgSend(^RenderPipelineDescriptor, self, "init")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="binaryArchives")
|
|
RenderPipelineDescriptor_binaryArchives :: proc(self: ^RenderPipelineDescriptor) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "binaryArchives")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="colorAttachments")
|
|
RenderPipelineDescriptor_colorAttachments :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineColorAttachmentDescriptorArray {
|
|
return msgSend(^RenderPipelineColorAttachmentDescriptorArray, self, "colorAttachments")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="depthAttachmentPixelFormat")
|
|
RenderPipelineDescriptor_depthAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor) -> PixelFormat {
|
|
return msgSend(PixelFormat, self, "depthAttachmentPixelFormat")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="fragmentBuffers")
|
|
RenderPipelineDescriptor_fragmentBuffers :: proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray {
|
|
return msgSend(^PipelineBufferDescriptorArray, self, "fragmentBuffers")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="fragmentFunction")
|
|
RenderPipelineDescriptor_fragmentFunction :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor {
|
|
return msgSend(^RenderPipelineDescriptor, self, "fragmentFunction")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="inputPrimitiveTopology")
|
|
RenderPipelineDescriptor_inputPrimitiveTopology :: proc(self: ^RenderPipelineDescriptor) -> PrimitiveTopologyClass {
|
|
return msgSend(PrimitiveTopologyClass, self, "inputPrimitiveTopology")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="isAlphaToCoverageEnabled")
|
|
RenderPipelineDescriptor_isAlphaToCoverageEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "isAlphaToCoverageEnabled")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="isAlphaToOneEnabled")
|
|
RenderPipelineDescriptor_isAlphaToOneEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "isAlphaToOneEnabled")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="isRasterizationEnabled")
|
|
RenderPipelineDescriptor_isRasterizationEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "isRasterizationEnabled")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="isTessellationFactorScaleEnabled")
|
|
RenderPipelineDescriptor_isTessellationFactorScaleEnabled :: proc(self: ^RenderPipelineDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "isTessellationFactorScaleEnabled")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="label")
|
|
RenderPipelineDescriptor_label :: proc(self: ^RenderPipelineDescriptor) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="maxTessellationFactor")
|
|
RenderPipelineDescriptor_maxTessellationFactor :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxTessellationFactor")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="maxVertexAmplificationCount")
|
|
RenderPipelineDescriptor_maxVertexAmplificationCount :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxVertexAmplificationCount")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="rasterSampleCount")
|
|
RenderPipelineDescriptor_rasterSampleCount :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "rasterSampleCount")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="reset")
|
|
RenderPipelineDescriptor_reset :: proc(self: ^RenderPipelineDescriptor) {
|
|
msgSend(nil, self, "reset")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="sampleCount")
|
|
RenderPipelineDescriptor_sampleCount :: proc(self: ^RenderPipelineDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "sampleCount")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setAlphaToCoverageEnabled")
|
|
RenderPipelineDescriptor_setAlphaToCoverageEnabled :: proc(self: ^RenderPipelineDescriptor, alphaToCoverageEnabled: BOOL) {
|
|
msgSend(nil, self, "setAlphaToCoverageEnabled:", alphaToCoverageEnabled)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setAlphaToOneEnabled")
|
|
RenderPipelineDescriptor_setAlphaToOneEnabled :: proc(self: ^RenderPipelineDescriptor, alphaToOneEnabled: BOOL) {
|
|
msgSend(nil, self, "setAlphaToOneEnabled:", alphaToOneEnabled)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setBinaryArchives")
|
|
RenderPipelineDescriptor_setBinaryArchives :: proc(self: ^RenderPipelineDescriptor, binaryArchives: ^NS.Array) {
|
|
msgSend(nil, self, "setBinaryArchives:", binaryArchives)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setDepthAttachmentPixelFormat")
|
|
RenderPipelineDescriptor_setDepthAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor, depthAttachmentPixelFormat: PixelFormat) {
|
|
msgSend(nil, self, "setDepthAttachmentPixelFormat:", depthAttachmentPixelFormat)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setFragmentFunction")
|
|
RenderPipelineDescriptor_setFragmentFunction :: proc(self: ^RenderPipelineDescriptor, fragmentFunction: ^NS.Object) {
|
|
msgSend(nil, self, "setFragmentFunction:", fragmentFunction)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setInputPrimitiveTopology")
|
|
RenderPipelineDescriptor_setInputPrimitiveTopology :: proc(self: ^RenderPipelineDescriptor, inputPrimitiveTopology: PrimitiveTopologyClass) {
|
|
msgSend(nil, self, "setInputPrimitiveTopology:", inputPrimitiveTopology)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setLabel")
|
|
RenderPipelineDescriptor_setLabel :: proc(self: ^RenderPipelineDescriptor, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setMaxTessellationFactor")
|
|
RenderPipelineDescriptor_setMaxTessellationFactor :: proc(self: ^RenderPipelineDescriptor, maxTessellationFactor: NS.Integer) {
|
|
msgSend(nil, self, "setMaxTessellationFactor:", maxTessellationFactor)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setMaxVertexAmplificationCount")
|
|
RenderPipelineDescriptor_setMaxVertexAmplificationCount :: proc(self: ^RenderPipelineDescriptor, maxVertexAmplificationCount: NS.Integer) {
|
|
msgSend(nil, self, "setMaxVertexAmplificationCount:", maxVertexAmplificationCount)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setRasterSampleCount")
|
|
RenderPipelineDescriptor_setRasterSampleCount :: proc(self: ^RenderPipelineDescriptor, rasterSampleCount: NS.Integer) {
|
|
msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setRasterizationEnabled")
|
|
RenderPipelineDescriptor_setRasterizationEnabled :: proc(self: ^RenderPipelineDescriptor, rasterizationEnabled: BOOL) {
|
|
msgSend(nil, self, "setRasterizationEnabled:", rasterizationEnabled)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setSampleCount")
|
|
RenderPipelineDescriptor_setSampleCount :: proc(self: ^RenderPipelineDescriptor, sampleCount: NS.Integer) {
|
|
msgSend(nil, self, "setSampleCount:", sampleCount)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setStencilAttachmentPixelFormat")
|
|
RenderPipelineDescriptor_setStencilAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor, stencilAttachmentPixelFormat: PixelFormat) {
|
|
msgSend(nil, self, "setStencilAttachmentPixelFormat:", stencilAttachmentPixelFormat)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setSupportIndirectCommandBuffers")
|
|
RenderPipelineDescriptor_setSupportIndirectCommandBuffers :: proc(self: ^RenderPipelineDescriptor, supportIndirectCommandBuffers: BOOL) {
|
|
msgSend(nil, self, "setSupportIndirectCommandBuffers:", supportIndirectCommandBuffers)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationControlPointIndexType")
|
|
RenderPipelineDescriptor_setTessellationControlPointIndexType :: proc(self: ^RenderPipelineDescriptor, tessellationControlPointIndexType: TessellationControlPointIndexType) {
|
|
msgSend(nil, self, "setTessellationControlPointIndexType:", tessellationControlPointIndexType)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorFormat")
|
|
RenderPipelineDescriptor_setTessellationFactorFormat :: proc(self: ^RenderPipelineDescriptor, tessellationFactorFormat: TessellationFactorFormat) {
|
|
msgSend(nil, self, "setTessellationFactorFormat:", tessellationFactorFormat)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorScaleEnabled")
|
|
RenderPipelineDescriptor_setTessellationFactorScaleEnabled :: proc(self: ^RenderPipelineDescriptor, tessellationFactorScaleEnabled: BOOL) {
|
|
msgSend(nil, self, "setTessellationFactorScaleEnabled:", tessellationFactorScaleEnabled)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationFactorStepFunction")
|
|
RenderPipelineDescriptor_setTessellationFactorStepFunction :: proc(self: ^RenderPipelineDescriptor, tessellationFactorStepFunction: TessellationFactorStepFunction) {
|
|
msgSend(nil, self, "setTessellationFactorStepFunction:", tessellationFactorStepFunction)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationOutputWindingOrder")
|
|
RenderPipelineDescriptor_setTessellationOutputWindingOrder :: proc(self: ^RenderPipelineDescriptor, tessellationOutputWindingOrder: Winding) {
|
|
msgSend(nil, self, "setTessellationOutputWindingOrder:", tessellationOutputWindingOrder)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setTessellationPartitionMode")
|
|
RenderPipelineDescriptor_setTessellationPartitionMode :: proc(self: ^RenderPipelineDescriptor, tessellationPartitionMode: TessellationPartitionMode) {
|
|
msgSend(nil, self, "setTessellationPartitionMode:", tessellationPartitionMode)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setVertexDescriptor")
|
|
RenderPipelineDescriptor_setVertexDescriptor :: proc(self: ^RenderPipelineDescriptor, vertexDescriptor: ^VertexDescriptor) {
|
|
msgSend(nil, self, "setVertexDescriptor:", vertexDescriptor)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="setVertexFunction")
|
|
RenderPipelineDescriptor_setVertexFunction :: proc(self: ^RenderPipelineDescriptor, vertexFunction: ^NS.Object) {
|
|
msgSend(nil, self, "setVertexFunction:", vertexFunction)
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="stencilAttachmentPixelFormat")
|
|
RenderPipelineDescriptor_stencilAttachmentPixelFormat :: proc(self: ^RenderPipelineDescriptor) -> PixelFormat {
|
|
return msgSend(PixelFormat, self, "stencilAttachmentPixelFormat")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="supportIndirectCommandBuffers")
|
|
RenderPipelineDescriptor_supportIndirectCommandBuffers :: proc(self: ^RenderPipelineDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "supportIndirectCommandBuffers")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="tessellationControlPointIndexType")
|
|
RenderPipelineDescriptor_tessellationControlPointIndexType :: proc(self: ^RenderPipelineDescriptor) -> TessellationControlPointIndexType {
|
|
return msgSend(TessellationControlPointIndexType, self, "tessellationControlPointIndexType")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="tessellationFactorFormat")
|
|
RenderPipelineDescriptor_tessellationFactorFormat :: proc(self: ^RenderPipelineDescriptor) -> TessellationFactorFormat {
|
|
return msgSend(TessellationFactorFormat, self, "tessellationFactorFormat")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="tessellationFactorStepFunction")
|
|
RenderPipelineDescriptor_tessellationFactorStepFunction :: proc(self: ^RenderPipelineDescriptor) -> TessellationFactorStepFunction {
|
|
return msgSend(TessellationFactorStepFunction, self, "tessellationFactorStepFunction")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="tessellationOutputWindingOrder")
|
|
RenderPipelineDescriptor_tessellationOutputWindingOrder :: proc(self: ^RenderPipelineDescriptor) -> Winding {
|
|
return msgSend(Winding, self, "tessellationOutputWindingOrder")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="tessellationPartitionMode")
|
|
RenderPipelineDescriptor_tessellationPartitionMode :: proc(self: ^RenderPipelineDescriptor) -> TessellationPartitionMode {
|
|
return msgSend(TessellationPartitionMode, self, "tessellationPartitionMode")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="vertexBuffers")
|
|
RenderPipelineDescriptor_vertexBuffers :: proc(self: ^RenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray {
|
|
return msgSend(^PipelineBufferDescriptorArray, self, "vertexBuffers")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="vertexDescriptor")
|
|
RenderPipelineDescriptor_vertexDescriptor :: proc(self: ^RenderPipelineDescriptor) -> ^VertexDescriptor {
|
|
return msgSend(^VertexDescriptor, self, "vertexDescriptor")
|
|
}
|
|
@(objc_type=RenderPipelineDescriptor, objc_name="vertexFunction")
|
|
RenderPipelineDescriptor_vertexFunction :: proc(self: ^RenderPipelineDescriptor) -> ^RenderPipelineDescriptor {
|
|
return msgSend(^RenderPipelineDescriptor, self, "vertexFunction")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPipelineReflection
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
fragmentArguments
|
|
tileArguments
|
|
vertexArguments
|
|
*/
|
|
@(objc_class="MTLRenderPipelineReflection")
|
|
RenderPipelineReflection :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=RenderPipelineReflection, objc_class_name="alloc")
|
|
RenderPipelineReflection_alloc :: proc() -> ^RenderPipelineReflection {
|
|
return msgSend(^RenderPipelineReflection, RenderPipelineReflection, "alloc")
|
|
}
|
|
@(objc_type=RenderPipelineReflection, objc_name="init")
|
|
RenderPipelineReflection_init :: proc(self: ^RenderPipelineReflection) -> ^RenderPipelineReflection {
|
|
return msgSend(^RenderPipelineReflection, self, "init")
|
|
}
|
|
@(objc_type=RenderPipelineReflection, objc_name="fragmentArguments")
|
|
RenderPipelineReflection_fragmentArguments :: proc(self: ^RenderPipelineReflection) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "fragmentArguments")
|
|
}
|
|
@(objc_type=RenderPipelineReflection, objc_name="tileArguments")
|
|
RenderPipelineReflection_tileArguments :: proc(self: ^RenderPipelineReflection) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "tileArguments")
|
|
}
|
|
@(objc_type=RenderPipelineReflection, objc_name="vertexArguments")
|
|
RenderPipelineReflection_vertexArguments :: proc(self: ^RenderPipelineReflection) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "vertexArguments")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ResourceStatePassDescriptor
|
|
Class Methods:
|
|
alloc
|
|
resourceStatePassDescriptor
|
|
Methods:
|
|
init
|
|
sampleBufferAttachments
|
|
*/
|
|
@(objc_class="MTLResourceStatePassDescriptor")
|
|
ResourceStatePassDescriptor :: struct { using _: NS.Copying(ResourceStatePassDescriptor) }
|
|
|
|
@(objc_type=ResourceStatePassDescriptor, objc_class_name="alloc")
|
|
ResourceStatePassDescriptor_alloc :: proc() -> ^ResourceStatePassDescriptor {
|
|
return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "alloc")
|
|
}
|
|
@(objc_type=ResourceStatePassDescriptor, objc_name="init")
|
|
ResourceStatePassDescriptor_init :: proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassDescriptor {
|
|
return msgSend(^ResourceStatePassDescriptor, self, "init")
|
|
}
|
|
@(objc_type=ResourceStatePassDescriptor, objc_class_name="resourceStatePassDescriptor")
|
|
ResourceStatePassDescriptor_resourceStatePassDescriptor :: proc() -> ^ResourceStatePassDescriptor {
|
|
return msgSend(^ResourceStatePassDescriptor, ResourceStatePassDescriptor, "resourceStatePassDescriptor")
|
|
}
|
|
@(objc_type=ResourceStatePassDescriptor, objc_name="sampleBufferAttachments")
|
|
ResourceStatePassDescriptor_sampleBufferAttachments :: proc(self: ^ResourceStatePassDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "sampleBufferAttachments")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ResourceStatePassSampleBufferAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
endOfEncoderSampleIndex
|
|
sampleBuffer
|
|
setEndOfEncoderSampleIndex
|
|
setSampleBuffer
|
|
setStartOfEncoderSampleIndex
|
|
startOfEncoderSampleIndex
|
|
*/
|
|
@(objc_class="MTLResourceStatePassSampleBufferAttachmentDescriptor")
|
|
ResourceStatePassSampleBufferAttachmentDescriptor :: struct { using _: NS.Copying(ResourceStatePassSampleBufferAttachmentDescriptor) }
|
|
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_class_name="alloc")
|
|
ResourceStatePassSampleBufferAttachmentDescriptor_alloc :: proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, ResourceStatePassSampleBufferAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="init")
|
|
ResourceStatePassSampleBufferAttachmentDescriptor_init :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="endOfEncoderSampleIndex")
|
|
ResourceStatePassSampleBufferAttachmentDescriptor_endOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "endOfEncoderSampleIndex")
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="sampleBuffer")
|
|
ResourceStatePassSampleBufferAttachmentDescriptor_sampleBuffer :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> ^ResourceStatePassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "sampleBuffer")
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setEndOfEncoderSampleIndex")
|
|
ResourceStatePassSampleBufferAttachmentDescriptor_setEndOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, endOfEncoderSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setEndOfEncoderSampleIndex:", endOfEncoderSampleIndex)
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setSampleBuffer")
|
|
ResourceStatePassSampleBufferAttachmentDescriptor_setSampleBuffer :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, sampleBuffer: ^NS.Object) {
|
|
msgSend(nil, self, "setSampleBuffer:", sampleBuffer)
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="setStartOfEncoderSampleIndex")
|
|
ResourceStatePassSampleBufferAttachmentDescriptor_setStartOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor, startOfEncoderSampleIndex: NS.Integer) {
|
|
msgSend(nil, self, "setStartOfEncoderSampleIndex:", startOfEncoderSampleIndex)
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptor, objc_name="startOfEncoderSampleIndex")
|
|
ResourceStatePassSampleBufferAttachmentDescriptor_startOfEncoderSampleIndex :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "startOfEncoderSampleIndex")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ResourceStatePassSampleBufferAttachmentDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLResourceStatePassSampleBufferAttachmentDescriptorArray")
|
|
ResourceStatePassSampleBufferAttachmentDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_class_name="alloc")
|
|
ResourceStatePassSampleBufferAttachmentDescriptorArray_alloc :: proc() -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, ResourceStatePassSampleBufferAttachmentDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="init")
|
|
ResourceStatePassSampleBufferAttachmentDescriptorArray_init :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray) -> ^ResourceStatePassSampleBufferAttachmentDescriptorArray {
|
|
return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
ResourceStatePassSampleBufferAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^ResourceStatePassSampleBufferAttachmentDescriptor {
|
|
return msgSend(^ResourceStatePassSampleBufferAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex)
|
|
}
|
|
@(objc_type=ResourceStatePassSampleBufferAttachmentDescriptorArray, objc_name="setObject")
|
|
ResourceStatePassSampleBufferAttachmentDescriptorArray_setObject :: proc(self: ^ResourceStatePassSampleBufferAttachmentDescriptorArray, attachment: ^ResourceStatePassSampleBufferAttachmentDescriptor, attachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
SamplerDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
borderColor
|
|
compareFunction
|
|
label
|
|
lodAverage
|
|
lodMaxClamp
|
|
lodMinClamp
|
|
magFilter
|
|
maxAnisotropy
|
|
minFilter
|
|
mipFilter
|
|
normalizedCoordinates
|
|
rAddressMode
|
|
sAddressMode
|
|
setBorderColor
|
|
setCompareFunction
|
|
setLabel
|
|
setLodAverage
|
|
setLodMaxClamp
|
|
setLodMinClamp
|
|
setMagFilter
|
|
setMaxAnisotropy
|
|
setMinFilter
|
|
setMipFilter
|
|
setNormalizedCoordinates
|
|
setRAddressMode
|
|
setSAddressMode
|
|
setSupportArgumentBuffers
|
|
setTAddressMode
|
|
supportArgumentBuffers
|
|
tAddressMode
|
|
*/
|
|
@(objc_class="MTLSamplerDescriptor")
|
|
SamplerDescriptor :: struct { using _: NS.Copying(SamplerDescriptor) }
|
|
|
|
@(objc_type=SamplerDescriptor, objc_class_name="alloc")
|
|
SamplerDescriptor_alloc :: proc() -> ^SamplerDescriptor {
|
|
return msgSend(^SamplerDescriptor, SamplerDescriptor, "alloc")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="init")
|
|
SamplerDescriptor_init :: proc(self: ^SamplerDescriptor) -> ^SamplerDescriptor {
|
|
return msgSend(^SamplerDescriptor, self, "init")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="borderColor")
|
|
SamplerDescriptor_borderColor :: proc(self: ^SamplerDescriptor) -> SamplerBorderColor {
|
|
return msgSend(SamplerBorderColor, self, "borderColor")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="compareFunction")
|
|
SamplerDescriptor_compareFunction :: proc(self: ^SamplerDescriptor) -> CompareFunction {
|
|
return msgSend(CompareFunction, self, "compareFunction")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="label")
|
|
SamplerDescriptor_label :: proc(self: ^SamplerDescriptor) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="lodAverage")
|
|
SamplerDescriptor_lodAverage :: proc(self: ^SamplerDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "lodAverage")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="lodMaxClamp")
|
|
SamplerDescriptor_lodMaxClamp :: proc(self: ^SamplerDescriptor) -> f32 {
|
|
return msgSend(f32, self, "lodMaxClamp")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="lodMinClamp")
|
|
SamplerDescriptor_lodMinClamp :: proc(self: ^SamplerDescriptor) -> f32 {
|
|
return msgSend(f32, self, "lodMinClamp")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="magFilter")
|
|
SamplerDescriptor_magFilter :: proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter {
|
|
return msgSend(SamplerMinMagFilter, self, "magFilter")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="maxAnisotropy")
|
|
SamplerDescriptor_maxAnisotropy :: proc(self: ^SamplerDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxAnisotropy")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="minFilter")
|
|
SamplerDescriptor_minFilter :: proc(self: ^SamplerDescriptor) -> SamplerMinMagFilter {
|
|
return msgSend(SamplerMinMagFilter, self, "minFilter")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="mipFilter")
|
|
SamplerDescriptor_mipFilter :: proc(self: ^SamplerDescriptor) -> SamplerMipFilter {
|
|
return msgSend(SamplerMipFilter, self, "mipFilter")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="normalizedCoordinates")
|
|
SamplerDescriptor_normalizedCoordinates :: proc(self: ^SamplerDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "normalizedCoordinates")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="rAddressMode")
|
|
SamplerDescriptor_rAddressMode :: proc(self: ^SamplerDescriptor) -> SamplerAddressMode {
|
|
return msgSend(SamplerAddressMode, self, "rAddressMode")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="sAddressMode")
|
|
SamplerDescriptor_sAddressMode :: proc(self: ^SamplerDescriptor) -> SamplerAddressMode {
|
|
return msgSend(SamplerAddressMode, self, "sAddressMode")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setBorderColor")
|
|
SamplerDescriptor_setBorderColor :: proc(self: ^SamplerDescriptor, borderColor: SamplerBorderColor) {
|
|
msgSend(nil, self, "setBorderColor:", borderColor)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setCompareFunction")
|
|
SamplerDescriptor_setCompareFunction :: proc(self: ^SamplerDescriptor, compareFunction: CompareFunction) {
|
|
msgSend(nil, self, "setCompareFunction:", compareFunction)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setLabel")
|
|
SamplerDescriptor_setLabel :: proc(self: ^SamplerDescriptor, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setLodAverage")
|
|
SamplerDescriptor_setLodAverage :: proc(self: ^SamplerDescriptor, lodAverage: BOOL) {
|
|
msgSend(nil, self, "setLodAverage:", lodAverage)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setLodMaxClamp")
|
|
SamplerDescriptor_setLodMaxClamp :: proc(self: ^SamplerDescriptor, lodMaxClamp: f32) {
|
|
msgSend(nil, self, "setLodMaxClamp:", lodMaxClamp)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setLodMinClamp")
|
|
SamplerDescriptor_setLodMinClamp :: proc(self: ^SamplerDescriptor, lodMinClamp: f32) {
|
|
msgSend(nil, self, "setLodMinClamp:", lodMinClamp)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setMagFilter")
|
|
SamplerDescriptor_setMagFilter :: proc(self: ^SamplerDescriptor, magFilter: SamplerMinMagFilter) {
|
|
msgSend(nil, self, "setMagFilter:", magFilter)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setMaxAnisotropy")
|
|
SamplerDescriptor_setMaxAnisotropy :: proc(self: ^SamplerDescriptor, maxAnisotropy: NS.Integer) {
|
|
msgSend(nil, self, "setMaxAnisotropy:", maxAnisotropy)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setMinFilter")
|
|
SamplerDescriptor_setMinFilter :: proc(self: ^SamplerDescriptor, minFilter: SamplerMinMagFilter) {
|
|
msgSend(nil, self, "setMinFilter:", minFilter)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setMipFilter")
|
|
SamplerDescriptor_setMipFilter :: proc(self: ^SamplerDescriptor, mipFilter: SamplerMipFilter) {
|
|
msgSend(nil, self, "setMipFilter:", mipFilter)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setNormalizedCoordinates")
|
|
SamplerDescriptor_setNormalizedCoordinates :: proc(self: ^SamplerDescriptor, normalizedCoordinates: BOOL) {
|
|
msgSend(nil, self, "setNormalizedCoordinates:", normalizedCoordinates)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setRAddressMode")
|
|
SamplerDescriptor_setRAddressMode :: proc(self: ^SamplerDescriptor, rAddressMode: SamplerAddressMode) {
|
|
msgSend(nil, self, "setRAddressMode:", rAddressMode)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setSAddressMode")
|
|
SamplerDescriptor_setSAddressMode :: proc(self: ^SamplerDescriptor, sAddressMode: SamplerAddressMode) {
|
|
msgSend(nil, self, "setSAddressMode:", sAddressMode)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setSupportArgumentBuffers")
|
|
SamplerDescriptor_setSupportArgumentBuffers :: proc(self: ^SamplerDescriptor, supportArgumentBuffers: BOOL) {
|
|
msgSend(nil, self, "setSupportArgumentBuffers:", supportArgumentBuffers)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="setTAddressMode")
|
|
SamplerDescriptor_setTAddressMode :: proc(self: ^SamplerDescriptor, tAddressMode: SamplerAddressMode) {
|
|
msgSend(nil, self, "setTAddressMode:", tAddressMode)
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="supportArgumentBuffers")
|
|
SamplerDescriptor_supportArgumentBuffers :: proc(self: ^SamplerDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "supportArgumentBuffers")
|
|
}
|
|
@(objc_type=SamplerDescriptor, objc_name="tAddressMode")
|
|
SamplerDescriptor_tAddressMode :: proc(self: ^SamplerDescriptor) -> SamplerAddressMode {
|
|
return msgSend(SamplerAddressMode, self, "tAddressMode")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
SharedEventHandle
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
label
|
|
*/
|
|
@(objc_class="MTLSharedEventHandle")
|
|
SharedEventHandle :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=SharedEventHandle, objc_class_name="alloc")
|
|
SharedEventHandle_alloc :: proc() -> ^SharedEventHandle {
|
|
return msgSend(^SharedEventHandle, SharedEventHandle, "alloc")
|
|
}
|
|
@(objc_type=SharedEventHandle, objc_name="init")
|
|
SharedEventHandle_init :: proc(self: ^SharedEventHandle) -> ^SharedEventHandle {
|
|
return msgSend(^SharedEventHandle, self, "init")
|
|
}
|
|
@(objc_type=SharedEventHandle, objc_name="label")
|
|
SharedEventHandle_label :: proc(self: ^SharedEventHandle) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
SharedEventListener
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
dispatchQueue
|
|
init
|
|
initWithDispatchQueue
|
|
*/
|
|
@(objc_class="MTLSharedEventListener")
|
|
SharedEventListener :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=SharedEventListener, objc_class_name="alloc")
|
|
SharedEventListener_alloc :: proc() -> ^SharedEventListener {
|
|
return msgSend(^SharedEventListener, SharedEventListener, "alloc")
|
|
}
|
|
@(objc_type=SharedEventListener, objc_name="dispatchQueue")
|
|
SharedEventListener_dispatchQueue :: proc(self: ^SharedEventListener) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "dispatchQueue")
|
|
}
|
|
@(objc_type=SharedEventListener, objc_name="init")
|
|
SharedEventListener_init :: proc(self: ^SharedEventListener) -> ^SharedEventListener {
|
|
return msgSend(^SharedEventListener, self, "init")
|
|
}
|
|
@(objc_type=SharedEventListener, objc_name="initWithDispatchQueue")
|
|
SharedEventListener_initWithDispatchQueue :: proc(self: ^SharedEventListener, dispatchQueue: ^NS.Object) -> ^SharedEventListener {
|
|
return msgSend(^SharedEventListener, self, "initWithDispatchQueue:", dispatchQueue)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
SharedTextureHandle
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
device
|
|
label
|
|
*/
|
|
@(objc_class="MTLSharedTextureHandle")
|
|
SharedTextureHandle :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=SharedTextureHandle, objc_class_name="alloc")
|
|
SharedTextureHandle_alloc :: proc() -> ^SharedTextureHandle {
|
|
return msgSend(^SharedTextureHandle, SharedTextureHandle, "alloc")
|
|
}
|
|
@(objc_type=SharedTextureHandle, objc_name="init")
|
|
SharedTextureHandle_init :: proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle {
|
|
return msgSend(^SharedTextureHandle, self, "init")
|
|
}
|
|
@(objc_type=SharedTextureHandle, objc_name="device")
|
|
SharedTextureHandle_device :: proc(self: ^SharedTextureHandle) -> ^SharedTextureHandle {
|
|
return msgSend(^SharedTextureHandle, self, "device")
|
|
}
|
|
@(objc_type=SharedTextureHandle, objc_name="label")
|
|
SharedTextureHandle_label :: proc(self: ^SharedTextureHandle) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
StageInputOutputDescriptor
|
|
Class Methods:
|
|
alloc
|
|
stageInputOutputDescriptor
|
|
Methods:
|
|
init
|
|
attributes
|
|
indexBufferIndex
|
|
indexType
|
|
layouts
|
|
reset
|
|
setIndexBufferIndex
|
|
setIndexType
|
|
*/
|
|
@(objc_class="MTLStageInputOutputDescriptor")
|
|
StageInputOutputDescriptor :: struct { using _: NS.Copying(StageInputOutputDescriptor) }
|
|
|
|
@(objc_type=StageInputOutputDescriptor, objc_class_name="alloc")
|
|
StageInputOutputDescriptor_alloc :: proc() -> ^StageInputOutputDescriptor {
|
|
return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "alloc")
|
|
}
|
|
@(objc_type=StageInputOutputDescriptor, objc_name="init")
|
|
StageInputOutputDescriptor_init :: proc(self: ^StageInputOutputDescriptor) -> ^StageInputOutputDescriptor {
|
|
return msgSend(^StageInputOutputDescriptor, self, "init")
|
|
}
|
|
@(objc_type=StageInputOutputDescriptor, objc_name="attributes")
|
|
StageInputOutputDescriptor_attributes :: proc(self: ^StageInputOutputDescriptor) -> ^AttributeDescriptorArray {
|
|
return msgSend(^AttributeDescriptorArray, self, "attributes")
|
|
}
|
|
@(objc_type=StageInputOutputDescriptor, objc_name="indexBufferIndex")
|
|
StageInputOutputDescriptor_indexBufferIndex :: proc(self: ^StageInputOutputDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "indexBufferIndex")
|
|
}
|
|
@(objc_type=StageInputOutputDescriptor, objc_name="indexType")
|
|
StageInputOutputDescriptor_indexType :: proc(self: ^StageInputOutputDescriptor) -> IndexType {
|
|
return msgSend(IndexType, self, "indexType")
|
|
}
|
|
@(objc_type=StageInputOutputDescriptor, objc_name="layouts")
|
|
StageInputOutputDescriptor_layouts :: proc(self: ^StageInputOutputDescriptor) -> ^BufferLayoutDescriptorArray {
|
|
return msgSend(^BufferLayoutDescriptorArray, self, "layouts")
|
|
}
|
|
@(objc_type=StageInputOutputDescriptor, objc_name="reset")
|
|
StageInputOutputDescriptor_reset :: proc(self: ^StageInputOutputDescriptor) {
|
|
msgSend(nil, self, "reset")
|
|
}
|
|
@(objc_type=StageInputOutputDescriptor, objc_name="setIndexBufferIndex")
|
|
StageInputOutputDescriptor_setIndexBufferIndex :: proc(self: ^StageInputOutputDescriptor, indexBufferIndex: NS.Integer) {
|
|
msgSend(nil, self, "setIndexBufferIndex:", indexBufferIndex)
|
|
}
|
|
@(objc_type=StageInputOutputDescriptor, objc_name="setIndexType")
|
|
StageInputOutputDescriptor_setIndexType :: proc(self: ^StageInputOutputDescriptor, indexType: IndexType) {
|
|
msgSend(nil, self, "setIndexType:", indexType)
|
|
}
|
|
@(objc_type=StageInputOutputDescriptor, objc_class_name="stageInputOutputDescriptor")
|
|
StageInputOutputDescriptor_stageInputOutputDescriptor :: proc() -> ^StageInputOutputDescriptor {
|
|
return msgSend(^StageInputOutputDescriptor, StageInputOutputDescriptor, "stageInputOutputDescriptor")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
StencilDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
depthFailureOperation
|
|
depthStencilPassOperation
|
|
readMask
|
|
setDepthFailureOperation
|
|
setDepthStencilPassOperation
|
|
setReadMask
|
|
setStencilCompareFunction
|
|
setStencilFailureOperation
|
|
setWriteMask
|
|
stencilCompareFunction
|
|
stencilFailureOperation
|
|
writeMask
|
|
*/
|
|
@(objc_class="MTLStencilDescriptor")
|
|
StencilDescriptor :: struct { using _: NS.Copying(StencilDescriptor) }
|
|
|
|
@(objc_type=StencilDescriptor, objc_class_name="alloc")
|
|
StencilDescriptor_alloc :: proc() -> ^StencilDescriptor {
|
|
return msgSend(^StencilDescriptor, StencilDescriptor, "alloc")
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="init")
|
|
StencilDescriptor_init :: proc(self: ^StencilDescriptor) -> ^StencilDescriptor {
|
|
return msgSend(^StencilDescriptor, self, "init")
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="depthFailureOperation")
|
|
StencilDescriptor_depthFailureOperation :: proc(self: ^StencilDescriptor) -> StencilOperation {
|
|
return msgSend(StencilOperation, self, "depthFailureOperation")
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="depthStencilPassOperation")
|
|
StencilDescriptor_depthStencilPassOperation :: proc(self: ^StencilDescriptor) -> StencilOperation {
|
|
return msgSend(StencilOperation, self, "depthStencilPassOperation")
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="readMask")
|
|
StencilDescriptor_readMask :: proc(self: ^StencilDescriptor) -> u32 {
|
|
return msgSend(u32, self, "readMask")
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="setDepthFailureOperation")
|
|
StencilDescriptor_setDepthFailureOperation :: proc(self: ^StencilDescriptor, depthFailureOperation: StencilOperation) {
|
|
msgSend(nil, self, "setDepthFailureOperation:", depthFailureOperation)
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="setDepthStencilPassOperation")
|
|
StencilDescriptor_setDepthStencilPassOperation :: proc(self: ^StencilDescriptor, depthStencilPassOperation: StencilOperation) {
|
|
msgSend(nil, self, "setDepthStencilPassOperation:", depthStencilPassOperation)
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="setReadMask")
|
|
StencilDescriptor_setReadMask :: proc(self: ^StencilDescriptor, readMask: u32) {
|
|
msgSend(nil, self, "setReadMask:", readMask)
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="setStencilCompareFunction")
|
|
StencilDescriptor_setStencilCompareFunction :: proc(self: ^StencilDescriptor, stencilCompareFunction: CompareFunction) {
|
|
msgSend(nil, self, "setStencilCompareFunction:", stencilCompareFunction)
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="setStencilFailureOperation")
|
|
StencilDescriptor_setStencilFailureOperation :: proc(self: ^StencilDescriptor, stencilFailureOperation: StencilOperation) {
|
|
msgSend(nil, self, "setStencilFailureOperation:", stencilFailureOperation)
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="setWriteMask")
|
|
StencilDescriptor_setWriteMask :: proc(self: ^StencilDescriptor, writeMask: u32) {
|
|
msgSend(nil, self, "setWriteMask:", writeMask)
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="stencilCompareFunction")
|
|
StencilDescriptor_stencilCompareFunction :: proc(self: ^StencilDescriptor) -> CompareFunction {
|
|
return msgSend(CompareFunction, self, "stencilCompareFunction")
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="stencilFailureOperation")
|
|
StencilDescriptor_stencilFailureOperation :: proc(self: ^StencilDescriptor) -> StencilOperation {
|
|
return msgSend(StencilOperation, self, "stencilFailureOperation")
|
|
}
|
|
@(objc_type=StencilDescriptor, objc_name="writeMask")
|
|
StencilDescriptor_writeMask :: proc(self: ^StencilDescriptor) -> u32 {
|
|
return msgSend(u32, self, "writeMask")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
StructMember
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
argumentIndex
|
|
arrayType
|
|
dataType
|
|
name
|
|
offset
|
|
pointerType
|
|
structType
|
|
textureReferenceType
|
|
*/
|
|
@(objc_class="MTLStructMember")
|
|
StructMember :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=StructMember, objc_class_name="alloc")
|
|
StructMember_alloc :: proc() -> ^StructMember {
|
|
return msgSend(^StructMember, StructMember, "alloc")
|
|
}
|
|
@(objc_type=StructMember, objc_name="init")
|
|
StructMember_init :: proc(self: ^StructMember) -> ^StructMember {
|
|
return msgSend(^StructMember, self, "init")
|
|
}
|
|
@(objc_type=StructMember, objc_name="argumentIndex")
|
|
StructMember_argumentIndex :: proc(self: ^StructMember) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "argumentIndex")
|
|
}
|
|
@(objc_type=StructMember, objc_name="arrayType")
|
|
StructMember_arrayType :: proc(self: ^StructMember) -> ^ArrayType {
|
|
return msgSend(^ArrayType, self, "arrayType")
|
|
}
|
|
@(objc_type=StructMember, objc_name="dataType")
|
|
StructMember_dataType :: proc(self: ^StructMember) -> DataType {
|
|
return msgSend(DataType, self, "dataType")
|
|
}
|
|
@(objc_type=StructMember, objc_name="name")
|
|
StructMember_name :: proc(self: ^StructMember) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
@(objc_type=StructMember, objc_name="offset")
|
|
StructMember_offset :: proc(self: ^StructMember) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "offset")
|
|
}
|
|
@(objc_type=StructMember, objc_name="pointerType")
|
|
StructMember_pointerType :: proc(self: ^StructMember) -> ^PointerType {
|
|
return msgSend(^PointerType, self, "pointerType")
|
|
}
|
|
@(objc_type=StructMember, objc_name="structType")
|
|
StructMember_structType :: proc(self: ^StructMember) -> ^StructType {
|
|
return msgSend(^StructType, self, "structType")
|
|
}
|
|
@(objc_type=StructMember, objc_name="textureReferenceType")
|
|
StructMember_textureReferenceType :: proc(self: ^StructMember) -> ^TextureReferenceType {
|
|
return msgSend(^TextureReferenceType, self, "textureReferenceType")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
StructType
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
memberByName
|
|
members
|
|
*/
|
|
@(objc_class="MTLStructType")
|
|
StructType :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=StructType, objc_class_name="alloc")
|
|
StructType_alloc :: proc() -> ^StructType {
|
|
return msgSend(^StructType, StructType, "alloc")
|
|
}
|
|
@(objc_type=StructType, objc_name="init")
|
|
StructType_init :: proc(self: ^StructType) -> ^StructType {
|
|
return msgSend(^StructType, self, "init")
|
|
}
|
|
@(objc_type=StructType, objc_name="memberByName")
|
|
StructType_memberByName :: proc(self: ^StructType, name: ^NS.String) -> ^StructMember {
|
|
return msgSend(^StructMember, self, "memberByName:", name)
|
|
}
|
|
@(objc_type=StructType, objc_name="members")
|
|
StructType_members :: proc(self: ^StructType) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "members")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
TextureDescriptor
|
|
Class Methods:
|
|
alloc
|
|
texture2DDescriptorWithPixelFormat
|
|
textureBufferDescriptorWithPixelFormat
|
|
textureCubeDescriptorWithPixelFormat
|
|
Methods:
|
|
init
|
|
allowGPUOptimizedContents
|
|
arrayLength
|
|
cpuCacheMode
|
|
depth
|
|
hazardTrackingMode
|
|
height
|
|
mipmapLevelCount
|
|
pixelFormat
|
|
resourceOptions
|
|
sampleCount
|
|
setAllowGPUOptimizedContents
|
|
setArrayLength
|
|
setCpuCacheMode
|
|
setDepth
|
|
setHazardTrackingMode
|
|
setHeight
|
|
setMipmapLevelCount
|
|
setPixelFormat
|
|
setResourceOptions
|
|
setSampleCount
|
|
setStorageMode
|
|
setSwizzle
|
|
setTextureType
|
|
setUsage
|
|
setWidth
|
|
storageMode
|
|
swizzle
|
|
textureType
|
|
usage
|
|
width
|
|
*/
|
|
@(objc_class="MTLTextureDescriptor")
|
|
TextureDescriptor :: struct { using _: NS.Copying(TextureDescriptor) }
|
|
|
|
@(objc_type=TextureDescriptor, objc_class_name="alloc")
|
|
TextureDescriptor_alloc :: proc() -> ^TextureDescriptor {
|
|
return msgSend(^TextureDescriptor, TextureDescriptor, "alloc")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="init")
|
|
TextureDescriptor_init :: proc(self: ^TextureDescriptor) -> ^TextureDescriptor {
|
|
return msgSend(^TextureDescriptor, self, "init")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="allowGPUOptimizedContents")
|
|
TextureDescriptor_allowGPUOptimizedContents :: proc(self: ^TextureDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "allowGPUOptimizedContents")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="arrayLength")
|
|
TextureDescriptor_arrayLength :: proc(self: ^TextureDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "arrayLength")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="cpuCacheMode")
|
|
TextureDescriptor_cpuCacheMode :: proc(self: ^TextureDescriptor) -> CPUCacheMode {
|
|
return msgSend(CPUCacheMode, self, "cpuCacheMode")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="depth")
|
|
TextureDescriptor_depth :: proc(self: ^TextureDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "depth")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="hazardTrackingMode")
|
|
TextureDescriptor_hazardTrackingMode :: proc(self: ^TextureDescriptor) -> HazardTrackingMode {
|
|
return msgSend(HazardTrackingMode, self, "hazardTrackingMode")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="height")
|
|
TextureDescriptor_height :: proc(self: ^TextureDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "height")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="mipmapLevelCount")
|
|
TextureDescriptor_mipmapLevelCount :: proc(self: ^TextureDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "mipmapLevelCount")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="pixelFormat")
|
|
TextureDescriptor_pixelFormat :: proc(self: ^TextureDescriptor) -> PixelFormat {
|
|
return msgSend(PixelFormat, self, "pixelFormat")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="resourceOptions")
|
|
TextureDescriptor_resourceOptions :: proc(self: ^TextureDescriptor) -> ResourceOptions {
|
|
return msgSend(ResourceOptions, self, "resourceOptions")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="sampleCount")
|
|
TextureDescriptor_sampleCount :: proc(self: ^TextureDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "sampleCount")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setAllowGPUOptimizedContents")
|
|
TextureDescriptor_setAllowGPUOptimizedContents :: proc(self: ^TextureDescriptor, allowGPUOptimizedContents: BOOL) {
|
|
msgSend(nil, self, "setAllowGPUOptimizedContents:", allowGPUOptimizedContents)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setArrayLength")
|
|
TextureDescriptor_setArrayLength :: proc(self: ^TextureDescriptor, arrayLength: NS.Integer) {
|
|
msgSend(nil, self, "setArrayLength:", arrayLength)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setCpuCacheMode")
|
|
TextureDescriptor_setCpuCacheMode :: proc(self: ^TextureDescriptor, cpuCacheMode: CPUCacheMode) {
|
|
msgSend(nil, self, "setCpuCacheMode:", cpuCacheMode)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setDepth")
|
|
TextureDescriptor_setDepth :: proc(self: ^TextureDescriptor, depth: NS.Integer) {
|
|
msgSend(nil, self, "setDepth:", depth)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setHazardTrackingMode")
|
|
TextureDescriptor_setHazardTrackingMode :: proc(self: ^TextureDescriptor, hazardTrackingMode: HazardTrackingMode) {
|
|
msgSend(nil, self, "setHazardTrackingMode:", hazardTrackingMode)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setHeight")
|
|
TextureDescriptor_setHeight :: proc(self: ^TextureDescriptor, height: NS.Integer) {
|
|
msgSend(nil, self, "setHeight:", height)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setMipmapLevelCount")
|
|
TextureDescriptor_setMipmapLevelCount :: proc(self: ^TextureDescriptor, mipmapLevelCount: NS.Integer) {
|
|
msgSend(nil, self, "setMipmapLevelCount:", mipmapLevelCount)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setPixelFormat")
|
|
TextureDescriptor_setPixelFormat :: proc(self: ^TextureDescriptor, pixelFormat: PixelFormat) {
|
|
msgSend(nil, self, "setPixelFormat:", pixelFormat)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setResourceOptions")
|
|
TextureDescriptor_setResourceOptions :: proc(self: ^TextureDescriptor, resourceOptions: ResourceOptions) {
|
|
msgSend(nil, self, "setResourceOptions:", resourceOptions)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setSampleCount")
|
|
TextureDescriptor_setSampleCount :: proc(self: ^TextureDescriptor, sampleCount: NS.Integer) {
|
|
msgSend(nil, self, "setSampleCount:", sampleCount)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setStorageMode")
|
|
TextureDescriptor_setStorageMode :: proc(self: ^TextureDescriptor, storageMode: StorageMode) {
|
|
msgSend(nil, self, "setStorageMode:", storageMode)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setSwizzle")
|
|
TextureDescriptor_setSwizzle :: proc(self: ^TextureDescriptor, swizzle: TextureSwizzleChannels) {
|
|
msgSend(nil, self, "setSwizzle:", swizzle)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setTextureType")
|
|
TextureDescriptor_setTextureType :: proc(self: ^TextureDescriptor, textureType: TextureType) {
|
|
msgSend(nil, self, "setTextureType:", textureType)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setUsage")
|
|
TextureDescriptor_setUsage :: proc(self: ^TextureDescriptor, usage: TextureUsage) {
|
|
msgSend(nil, self, "setUsage:", usage)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="setWidth")
|
|
TextureDescriptor_setWidth :: proc(self: ^TextureDescriptor, width: NS.Integer) {
|
|
msgSend(nil, self, "setWidth:", width)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="storageMode")
|
|
TextureDescriptor_storageMode :: proc(self: ^TextureDescriptor) -> StorageMode {
|
|
return msgSend(StorageMode, self, "storageMode")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="swizzle")
|
|
TextureDescriptor_swizzle :: proc(self: ^TextureDescriptor) -> TextureSwizzleChannels {
|
|
return msgSend(TextureSwizzleChannels, self, "swizzle")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_class_name="texture2DDescriptorWithPixelFormat")
|
|
TextureDescriptor_texture2DDescriptorWithPixelFormat :: proc(pixelFormat: PixelFormat, width: ^NS.Object, height: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor {
|
|
return msgSend(^TextureDescriptor, TextureDescriptor, "texture2DDescriptorWithPixelFormat:width:height:mipmapped:", pixelFormat, width, height, mipmapped)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_class_name="textureBufferDescriptorWithPixelFormat")
|
|
TextureDescriptor_textureBufferDescriptorWithPixelFormat :: proc(pixelFormat: PixelFormat, width: ^NS.Object, resourceOptions: ResourceOptions, usage: TextureUsage) -> ^TextureDescriptor {
|
|
return msgSend(^TextureDescriptor, TextureDescriptor, "textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:", pixelFormat, width, resourceOptions, usage)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_class_name="textureCubeDescriptorWithPixelFormat")
|
|
TextureDescriptor_textureCubeDescriptorWithPixelFormat :: proc(pixelFormat: PixelFormat, size: ^NS.Object, mipmapped: BOOL) -> ^TextureDescriptor {
|
|
return msgSend(^TextureDescriptor, TextureDescriptor, "textureCubeDescriptorWithPixelFormat:size:mipmapped:", pixelFormat, size, mipmapped)
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="textureType")
|
|
TextureDescriptor_textureType :: proc(self: ^TextureDescriptor) -> TextureType {
|
|
return msgSend(TextureType, self, "textureType")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="usage")
|
|
TextureDescriptor_usage :: proc(self: ^TextureDescriptor) -> TextureUsage {
|
|
return msgSend(TextureUsage, self, "usage")
|
|
}
|
|
@(objc_type=TextureDescriptor, objc_name="width")
|
|
TextureDescriptor_width :: proc(self: ^TextureDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "width")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
TextureReferenceType
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
access
|
|
isDepthTexture
|
|
textureDataType
|
|
textureType
|
|
*/
|
|
@(objc_class="MTLTextureReferenceType")
|
|
TextureReferenceType :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=TextureReferenceType, objc_class_name="alloc")
|
|
TextureReferenceType_alloc :: proc() -> ^TextureReferenceType {
|
|
return msgSend(^TextureReferenceType, TextureReferenceType, "alloc")
|
|
}
|
|
@(objc_type=TextureReferenceType, objc_name="init")
|
|
TextureReferenceType_init :: proc(self: ^TextureReferenceType) -> ^TextureReferenceType {
|
|
return msgSend(^TextureReferenceType, self, "init")
|
|
}
|
|
@(objc_type=TextureReferenceType, objc_name="access")
|
|
TextureReferenceType_access :: proc(self: ^TextureReferenceType) -> ArgumentAccess {
|
|
return msgSend(ArgumentAccess, self, "access")
|
|
}
|
|
@(objc_type=TextureReferenceType, objc_name="isDepthTexture")
|
|
TextureReferenceType_isDepthTexture :: proc(self: ^TextureReferenceType) -> BOOL {
|
|
return msgSend(BOOL, self, "isDepthTexture")
|
|
}
|
|
@(objc_type=TextureReferenceType, objc_name="textureDataType")
|
|
TextureReferenceType_textureDataType :: proc(self: ^TextureReferenceType) -> DataType {
|
|
return msgSend(DataType, self, "textureDataType")
|
|
}
|
|
@(objc_type=TextureReferenceType, objc_name="textureType")
|
|
TextureReferenceType_textureType :: proc(self: ^TextureReferenceType) -> TextureType {
|
|
return msgSend(TextureType, self, "textureType")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
TileRenderPipelineColorAttachmentDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
pixelFormat
|
|
setPixelFormat
|
|
*/
|
|
@(objc_class="MTLTileRenderPipelineColorAttachmentDescriptor")
|
|
TileRenderPipelineColorAttachmentDescriptor :: struct { using _: NS.Copying(TileRenderPipelineColorAttachmentDescriptor) }
|
|
|
|
@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_class_name="alloc")
|
|
TileRenderPipelineColorAttachmentDescriptor_alloc :: proc() -> ^TileRenderPipelineColorAttachmentDescriptor {
|
|
return msgSend(^TileRenderPipelineColorAttachmentDescriptor, TileRenderPipelineColorAttachmentDescriptor, "alloc")
|
|
}
|
|
@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="init")
|
|
TileRenderPipelineColorAttachmentDescriptor_init :: proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptor {
|
|
return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "init")
|
|
}
|
|
@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="pixelFormat")
|
|
TileRenderPipelineColorAttachmentDescriptor_pixelFormat :: proc(self: ^TileRenderPipelineColorAttachmentDescriptor) -> PixelFormat {
|
|
return msgSend(PixelFormat, self, "pixelFormat")
|
|
}
|
|
@(objc_type=TileRenderPipelineColorAttachmentDescriptor, objc_name="setPixelFormat")
|
|
TileRenderPipelineColorAttachmentDescriptor_setPixelFormat :: proc(self: ^TileRenderPipelineColorAttachmentDescriptor, pixelFormat: PixelFormat) {
|
|
msgSend(nil, self, "setPixelFormat:", pixelFormat)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
TileRenderPipelineColorAttachmentDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLTileRenderPipelineColorAttachmentDescriptorArray")
|
|
TileRenderPipelineColorAttachmentDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_class_name="alloc")
|
|
TileRenderPipelineColorAttachmentDescriptorArray_alloc :: proc() -> ^TileRenderPipelineColorAttachmentDescriptorArray {
|
|
return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, TileRenderPipelineColorAttachmentDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="init")
|
|
TileRenderPipelineColorAttachmentDescriptorArray_init :: proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray) -> ^TileRenderPipelineColorAttachmentDescriptorArray {
|
|
return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
TileRenderPipelineColorAttachmentDescriptorArray_objectAtIndexedSubscript :: proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachmentIndex: ^NS.Object) -> ^TileRenderPipelineColorAttachmentDescriptor {
|
|
return msgSend(^TileRenderPipelineColorAttachmentDescriptor, self, "objectAtIndexedSubscript:", attachmentIndex)
|
|
}
|
|
@(objc_type=TileRenderPipelineColorAttachmentDescriptorArray, objc_name="setObject")
|
|
TileRenderPipelineColorAttachmentDescriptorArray_setObject :: proc(self: ^TileRenderPipelineColorAttachmentDescriptorArray, attachment: ^TileRenderPipelineColorAttachmentDescriptor, attachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", attachment, attachmentIndex)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
TileRenderPipelineDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
binaryArchives
|
|
colorAttachments
|
|
label
|
|
maxTotalThreadsPerThreadgroup
|
|
rasterSampleCount
|
|
reset
|
|
setBinaryArchives
|
|
setLabel
|
|
setMaxTotalThreadsPerThreadgroup
|
|
setRasterSampleCount
|
|
setThreadgroupSizeMatchesTileSize
|
|
setTileFunction
|
|
threadgroupSizeMatchesTileSize
|
|
tileBuffers
|
|
tileFunction
|
|
*/
|
|
@(objc_class="MTLTileRenderPipelineDescriptor")
|
|
TileRenderPipelineDescriptor :: struct { using _: NS.Copying(TileRenderPipelineDescriptor) }
|
|
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_class_name="alloc")
|
|
TileRenderPipelineDescriptor_alloc :: proc() -> ^TileRenderPipelineDescriptor {
|
|
return msgSend(^TileRenderPipelineDescriptor, TileRenderPipelineDescriptor, "alloc")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="init")
|
|
TileRenderPipelineDescriptor_init :: proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor {
|
|
return msgSend(^TileRenderPipelineDescriptor, self, "init")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="binaryArchives")
|
|
TileRenderPipelineDescriptor_binaryArchives :: proc(self: ^TileRenderPipelineDescriptor) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "binaryArchives")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="colorAttachments")
|
|
TileRenderPipelineDescriptor_colorAttachments :: proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineColorAttachmentDescriptorArray {
|
|
return msgSend(^TileRenderPipelineColorAttachmentDescriptorArray, self, "colorAttachments")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="label")
|
|
TileRenderPipelineDescriptor_label :: proc(self: ^TileRenderPipelineDescriptor) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="maxTotalThreadsPerThreadgroup")
|
|
TileRenderPipelineDescriptor_maxTotalThreadsPerThreadgroup :: proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="rasterSampleCount")
|
|
TileRenderPipelineDescriptor_rasterSampleCount :: proc(self: ^TileRenderPipelineDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "rasterSampleCount")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="reset")
|
|
TileRenderPipelineDescriptor_reset :: proc(self: ^TileRenderPipelineDescriptor) {
|
|
msgSend(nil, self, "reset")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="setBinaryArchives")
|
|
TileRenderPipelineDescriptor_setBinaryArchives :: proc(self: ^TileRenderPipelineDescriptor, binaryArchives: ^NS.Array) {
|
|
msgSend(nil, self, "setBinaryArchives:", binaryArchives)
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="setLabel")
|
|
TileRenderPipelineDescriptor_setLabel :: proc(self: ^TileRenderPipelineDescriptor, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="setMaxTotalThreadsPerThreadgroup")
|
|
TileRenderPipelineDescriptor_setMaxTotalThreadsPerThreadgroup :: proc(self: ^TileRenderPipelineDescriptor, maxTotalThreadsPerThreadgroup: NS.Integer) {
|
|
msgSend(nil, self, "setMaxTotalThreadsPerThreadgroup:", maxTotalThreadsPerThreadgroup)
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="setRasterSampleCount")
|
|
TileRenderPipelineDescriptor_setRasterSampleCount :: proc(self: ^TileRenderPipelineDescriptor, rasterSampleCount: NS.Integer) {
|
|
msgSend(nil, self, "setRasterSampleCount:", rasterSampleCount)
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="setThreadgroupSizeMatchesTileSize")
|
|
TileRenderPipelineDescriptor_setThreadgroupSizeMatchesTileSize :: proc(self: ^TileRenderPipelineDescriptor, threadgroupSizeMatchesTileSize: BOOL) {
|
|
msgSend(nil, self, "setThreadgroupSizeMatchesTileSize:", threadgroupSizeMatchesTileSize)
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="setTileFunction")
|
|
TileRenderPipelineDescriptor_setTileFunction :: proc(self: ^TileRenderPipelineDescriptor, tileFunction: ^NS.Object) {
|
|
msgSend(nil, self, "setTileFunction:", tileFunction)
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="threadgroupSizeMatchesTileSize")
|
|
TileRenderPipelineDescriptor_threadgroupSizeMatchesTileSize :: proc(self: ^TileRenderPipelineDescriptor) -> BOOL {
|
|
return msgSend(BOOL, self, "threadgroupSizeMatchesTileSize")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="tileBuffers")
|
|
TileRenderPipelineDescriptor_tileBuffers :: proc(self: ^TileRenderPipelineDescriptor) -> ^PipelineBufferDescriptorArray {
|
|
return msgSend(^PipelineBufferDescriptorArray, self, "tileBuffers")
|
|
}
|
|
@(objc_type=TileRenderPipelineDescriptor, objc_name="tileFunction")
|
|
TileRenderPipelineDescriptor_tileFunction :: proc(self: ^TileRenderPipelineDescriptor) -> ^TileRenderPipelineDescriptor {
|
|
return msgSend(^TileRenderPipelineDescriptor, self, "tileFunction")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Type
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
dataType
|
|
*/
|
|
@(objc_class="MTLType")
|
|
Type :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Type, objc_class_name="alloc")
|
|
Type_alloc :: proc() -> ^Type {
|
|
return msgSend(^Type, Type, "alloc")
|
|
}
|
|
@(objc_type=Type, objc_name="init")
|
|
Type_init :: proc(self: ^Type) -> ^Type {
|
|
return msgSend(^Type, self, "init")
|
|
}
|
|
@(objc_type=Type, objc_name="dataType")
|
|
Type_dataType :: proc(self: ^Type) -> DataType {
|
|
return msgSend(DataType, self, "dataType")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
VertexAttribute
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
attributeIndex
|
|
attributeType
|
|
isActive
|
|
isPatchControlPointData
|
|
isPatchData
|
|
name
|
|
*/
|
|
@(objc_class="MTLVertexAttribute")
|
|
VertexAttribute :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=VertexAttribute, objc_class_name="alloc")
|
|
VertexAttribute_alloc :: proc() -> ^VertexAttribute {
|
|
return msgSend(^VertexAttribute, VertexAttribute, "alloc")
|
|
}
|
|
@(objc_type=VertexAttribute, objc_name="init")
|
|
VertexAttribute_init :: proc(self: ^VertexAttribute) -> ^VertexAttribute {
|
|
return msgSend(^VertexAttribute, self, "init")
|
|
}
|
|
@(objc_type=VertexAttribute, objc_name="attributeIndex")
|
|
VertexAttribute_attributeIndex :: proc(self: ^VertexAttribute) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "attributeIndex")
|
|
}
|
|
@(objc_type=VertexAttribute, objc_name="attributeType")
|
|
VertexAttribute_attributeType :: proc(self: ^VertexAttribute) -> DataType {
|
|
return msgSend(DataType, self, "attributeType")
|
|
}
|
|
@(objc_type=VertexAttribute, objc_name="isActive")
|
|
VertexAttribute_isActive :: proc(self: ^VertexAttribute) -> BOOL {
|
|
return msgSend(BOOL, self, "isActive")
|
|
}
|
|
@(objc_type=VertexAttribute, objc_name="isPatchControlPointData")
|
|
VertexAttribute_isPatchControlPointData :: proc(self: ^VertexAttribute) -> BOOL {
|
|
return msgSend(BOOL, self, "isPatchControlPointData")
|
|
}
|
|
@(objc_type=VertexAttribute, objc_name="isPatchData")
|
|
VertexAttribute_isPatchData :: proc(self: ^VertexAttribute) -> BOOL {
|
|
return msgSend(BOOL, self, "isPatchData")
|
|
}
|
|
@(objc_type=VertexAttribute, objc_name="name")
|
|
VertexAttribute_name :: proc(self: ^VertexAttribute) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
VertexAttributeDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
bufferIndex
|
|
format
|
|
offset
|
|
setBufferIndex
|
|
setFormat
|
|
setOffset
|
|
*/
|
|
@(objc_class="MTLVertexAttributeDescriptor")
|
|
VertexAttributeDescriptor :: struct { using _: NS.Copying(VertexAttributeDescriptor) }
|
|
|
|
@(objc_type=VertexAttributeDescriptor, objc_class_name="alloc")
|
|
VertexAttributeDescriptor_alloc :: proc() -> ^VertexAttributeDescriptor {
|
|
return msgSend(^VertexAttributeDescriptor, VertexAttributeDescriptor, "alloc")
|
|
}
|
|
@(objc_type=VertexAttributeDescriptor, objc_name="init")
|
|
VertexAttributeDescriptor_init :: proc(self: ^VertexAttributeDescriptor) -> ^VertexAttributeDescriptor {
|
|
return msgSend(^VertexAttributeDescriptor, self, "init")
|
|
}
|
|
@(objc_type=VertexAttributeDescriptor, objc_name="bufferIndex")
|
|
VertexAttributeDescriptor_bufferIndex :: proc(self: ^VertexAttributeDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "bufferIndex")
|
|
}
|
|
@(objc_type=VertexAttributeDescriptor, objc_name="format")
|
|
VertexAttributeDescriptor_format :: proc(self: ^VertexAttributeDescriptor) -> VertexFormat {
|
|
return msgSend(VertexFormat, self, "format")
|
|
}
|
|
@(objc_type=VertexAttributeDescriptor, objc_name="offset")
|
|
VertexAttributeDescriptor_offset :: proc(self: ^VertexAttributeDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "offset")
|
|
}
|
|
@(objc_type=VertexAttributeDescriptor, objc_name="setBufferIndex")
|
|
VertexAttributeDescriptor_setBufferIndex :: proc(self: ^VertexAttributeDescriptor, bufferIndex: NS.Integer) {
|
|
msgSend(nil, self, "setBufferIndex:", bufferIndex)
|
|
}
|
|
@(objc_type=VertexAttributeDescriptor, objc_name="setFormat")
|
|
VertexAttributeDescriptor_setFormat :: proc(self: ^VertexAttributeDescriptor, format: VertexFormat) {
|
|
msgSend(nil, self, "setFormat:", format)
|
|
}
|
|
@(objc_type=VertexAttributeDescriptor, objc_name="setOffset")
|
|
VertexAttributeDescriptor_setOffset :: proc(self: ^VertexAttributeDescriptor, offset: NS.Integer) {
|
|
msgSend(nil, self, "setOffset:", offset)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
VertexAttributeDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLVertexAttributeDescriptorArray")
|
|
VertexAttributeDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=VertexAttributeDescriptorArray, objc_class_name="alloc")
|
|
VertexAttributeDescriptorArray_alloc :: proc() -> ^VertexAttributeDescriptorArray {
|
|
return msgSend(^VertexAttributeDescriptorArray, VertexAttributeDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=VertexAttributeDescriptorArray, objc_name="init")
|
|
VertexAttributeDescriptorArray_init :: proc(self: ^VertexAttributeDescriptorArray) -> ^VertexAttributeDescriptorArray {
|
|
return msgSend(^VertexAttributeDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=VertexAttributeDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
VertexAttributeDescriptorArray_objectAtIndexedSubscript :: proc(self: ^VertexAttributeDescriptorArray, index: ^NS.Object) -> ^VertexAttributeDescriptor {
|
|
return msgSend(^VertexAttributeDescriptor, self, "objectAtIndexedSubscript:", index)
|
|
}
|
|
@(objc_type=VertexAttributeDescriptorArray, objc_name="setObject")
|
|
VertexAttributeDescriptorArray_setObject :: proc(self: ^VertexAttributeDescriptorArray, attributeDesc: ^VertexAttributeDescriptor, index: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", attributeDesc, index)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
VertexBufferLayoutDescriptor
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
setStepFunction
|
|
setStepRate
|
|
setStride
|
|
stepFunction
|
|
stepRate
|
|
stride
|
|
*/
|
|
@(objc_class="MTLVertexBufferLayoutDescriptor")
|
|
VertexBufferLayoutDescriptor :: struct { using _: NS.Copying(VertexBufferLayoutDescriptor) }
|
|
|
|
@(objc_type=VertexBufferLayoutDescriptor, objc_class_name="alloc")
|
|
VertexBufferLayoutDescriptor_alloc :: proc() -> ^VertexBufferLayoutDescriptor {
|
|
return msgSend(^VertexBufferLayoutDescriptor, VertexBufferLayoutDescriptor, "alloc")
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptor, objc_name="init")
|
|
VertexBufferLayoutDescriptor_init :: proc(self: ^VertexBufferLayoutDescriptor) -> ^VertexBufferLayoutDescriptor {
|
|
return msgSend(^VertexBufferLayoutDescriptor, self, "init")
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptor, objc_name="setStepFunction")
|
|
VertexBufferLayoutDescriptor_setStepFunction :: proc(self: ^VertexBufferLayoutDescriptor, stepFunction: VertexStepFunction) {
|
|
msgSend(nil, self, "setStepFunction:", stepFunction)
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptor, objc_name="setStepRate")
|
|
VertexBufferLayoutDescriptor_setStepRate :: proc(self: ^VertexBufferLayoutDescriptor, stepRate: NS.Integer) {
|
|
msgSend(nil, self, "setStepRate:", stepRate)
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptor, objc_name="setStride")
|
|
VertexBufferLayoutDescriptor_setStride :: proc(self: ^VertexBufferLayoutDescriptor, stride: NS.Integer) {
|
|
msgSend(nil, self, "setStride:", stride)
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptor, objc_name="stepFunction")
|
|
VertexBufferLayoutDescriptor_stepFunction :: proc(self: ^VertexBufferLayoutDescriptor) -> VertexStepFunction {
|
|
return msgSend(VertexStepFunction, self, "stepFunction")
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptor, objc_name="stepRate")
|
|
VertexBufferLayoutDescriptor_stepRate :: proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "stepRate")
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptor, objc_name="stride")
|
|
VertexBufferLayoutDescriptor_stride :: proc(self: ^VertexBufferLayoutDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "stride")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
VertexBufferLayoutDescriptorArray
|
|
Class Methods:
|
|
alloc
|
|
Methods:
|
|
init
|
|
objectAtIndexedSubscript
|
|
setObject
|
|
*/
|
|
@(objc_class="MTLVertexBufferLayoutDescriptorArray")
|
|
VertexBufferLayoutDescriptorArray :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=VertexBufferLayoutDescriptorArray, objc_class_name="alloc")
|
|
VertexBufferLayoutDescriptorArray_alloc :: proc() -> ^VertexBufferLayoutDescriptorArray {
|
|
return msgSend(^VertexBufferLayoutDescriptorArray, VertexBufferLayoutDescriptorArray, "alloc")
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptorArray, objc_name="init")
|
|
VertexBufferLayoutDescriptorArray_init :: proc(self: ^VertexBufferLayoutDescriptorArray) -> ^VertexBufferLayoutDescriptorArray {
|
|
return msgSend(^VertexBufferLayoutDescriptorArray, self, "init")
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptorArray, objc_name="objectAtIndexedSubscript")
|
|
VertexBufferLayoutDescriptorArray_objectAtIndexedSubscript :: proc(self: ^VertexBufferLayoutDescriptorArray, index: ^NS.Object) -> ^VertexBufferLayoutDescriptor {
|
|
return msgSend(^VertexBufferLayoutDescriptor, self, "objectAtIndexedSubscript:", index)
|
|
}
|
|
@(objc_type=VertexBufferLayoutDescriptorArray, objc_name="setObject")
|
|
VertexBufferLayoutDescriptorArray_setObject :: proc(self: ^VertexBufferLayoutDescriptorArray, bufferDesc: ^VertexBufferLayoutDescriptor, index: ^NS.Object) {
|
|
msgSend(nil, self, "setObject:atIndexedSubscript:", bufferDesc, index)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
VertexDescriptor
|
|
Class Methods:
|
|
alloc
|
|
vertexDescriptor
|
|
Methods:
|
|
init
|
|
attributes
|
|
layouts
|
|
reset
|
|
*/
|
|
@(objc_class="MTLVertexDescriptor")
|
|
VertexDescriptor :: struct { using _: NS.Copying(VertexDescriptor) }
|
|
|
|
@(objc_type=VertexDescriptor, objc_class_name="alloc")
|
|
VertexDescriptor_alloc :: proc() -> ^VertexDescriptor {
|
|
return msgSend(^VertexDescriptor, VertexDescriptor, "alloc")
|
|
}
|
|
@(objc_type=VertexDescriptor, objc_name="init")
|
|
VertexDescriptor_init :: proc(self: ^VertexDescriptor) -> ^VertexDescriptor {
|
|
return msgSend(^VertexDescriptor, self, "init")
|
|
}
|
|
@(objc_type=VertexDescriptor, objc_name="attributes")
|
|
VertexDescriptor_attributes :: proc(self: ^VertexDescriptor) -> ^VertexAttributeDescriptorArray {
|
|
return msgSend(^VertexAttributeDescriptorArray, self, "attributes")
|
|
}
|
|
@(objc_type=VertexDescriptor, objc_name="layouts")
|
|
VertexDescriptor_layouts :: proc(self: ^VertexDescriptor) -> ^VertexBufferLayoutDescriptorArray {
|
|
return msgSend(^VertexBufferLayoutDescriptorArray, self, "layouts")
|
|
}
|
|
@(objc_type=VertexDescriptor, objc_name="reset")
|
|
VertexDescriptor_reset :: proc(self: ^VertexDescriptor) {
|
|
msgSend(nil, self, "reset")
|
|
}
|
|
@(objc_type=VertexDescriptor, objc_class_name="vertexDescriptor")
|
|
VertexDescriptor_vertexDescriptor :: proc() -> ^VertexDescriptor {
|
|
return msgSend(^VertexDescriptor, VertexDescriptor, "vertexDescriptor")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
VisibleFunctionTableDescriptor
|
|
Class Methods:
|
|
alloc
|
|
visibleFunctionTableDescriptor
|
|
Methods:
|
|
init
|
|
functionCount
|
|
setFunctionCount
|
|
*/
|
|
@(objc_class="MTLVisibleFunctionTableDescriptor")
|
|
VisibleFunctionTableDescriptor :: struct { using _: NS.Copying(VisibleFunctionTableDescriptor) }
|
|
|
|
@(objc_type=VisibleFunctionTableDescriptor, objc_class_name="alloc")
|
|
VisibleFunctionTableDescriptor_alloc :: proc() -> ^VisibleFunctionTableDescriptor {
|
|
return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "alloc")
|
|
}
|
|
@(objc_type=VisibleFunctionTableDescriptor, objc_name="init")
|
|
VisibleFunctionTableDescriptor_init :: proc(self: ^VisibleFunctionTableDescriptor) -> ^VisibleFunctionTableDescriptor {
|
|
return msgSend(^VisibleFunctionTableDescriptor, self, "init")
|
|
}
|
|
@(objc_type=VisibleFunctionTableDescriptor, objc_name="functionCount")
|
|
VisibleFunctionTableDescriptor_functionCount :: proc(self: ^VisibleFunctionTableDescriptor) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "functionCount")
|
|
}
|
|
@(objc_type=VisibleFunctionTableDescriptor, objc_name="setFunctionCount")
|
|
VisibleFunctionTableDescriptor_setFunctionCount :: proc(self: ^VisibleFunctionTableDescriptor, functionCount: NS.Integer) {
|
|
msgSend(nil, self, "setFunctionCount:", functionCount)
|
|
}
|
|
@(objc_type=VisibleFunctionTableDescriptor, objc_class_name="visibleFunctionTableDescriptor")
|
|
VisibleFunctionTableDescriptor_visibleFunctionTableDescriptor :: proc() -> ^VisibleFunctionTableDescriptor {
|
|
return msgSend(^VisibleFunctionTableDescriptor, VisibleFunctionTableDescriptor, "visibleFunctionTableDescriptor")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
AccelerationStructure
|
|
Class Methods:
|
|
Methods:
|
|
size
|
|
*/
|
|
@(objc_class="MTLAccelerationStructure")
|
|
AccelerationStructure :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=AccelerationStructure, objc_name="size")
|
|
AccelerationStructure_size :: proc(self: ^AccelerationStructure) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "size")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
AccelerationStructureCommandEncoder
|
|
Class Methods:
|
|
Methods:
|
|
buildAccelerationStructure
|
|
copyAccelerationStructure
|
|
copyAndCompactAccelerationStructure
|
|
refitAccelerationStructure
|
|
sampleCountersInBuffer
|
|
updateFence
|
|
useHeap
|
|
useHeaps
|
|
useResource
|
|
useResources
|
|
waitForFence
|
|
writeCompactedAccelerationStructureSize
|
|
*/
|
|
@(objc_class="MTLAccelerationStructureCommandEncoder")
|
|
AccelerationStructureCommandEncoder :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="buildAccelerationStructure")
|
|
AccelerationStructureCommandEncoder_buildAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:", accelerationStructure, descriptor, scratchBuffer, scratchBufferOffset)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAccelerationStructure")
|
|
AccelerationStructureCommandEncoder_copyAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) {
|
|
msgSend(nil, self, "copyAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="copyAndCompactAccelerationStructure")
|
|
AccelerationStructureCommandEncoder_copyAndCompactAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, destinationAccelerationStructure: ^NS.Object) {
|
|
msgSend(nil, self, "copyAndCompactAccelerationStructure:toAccelerationStructure:", sourceAccelerationStructure, destinationAccelerationStructure)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="refitAccelerationStructure")
|
|
AccelerationStructureCommandEncoder_refitAccelerationStructure :: proc(self: ^AccelerationStructureCommandEncoder, sourceAccelerationStructure: ^NS.Object, descriptor: ^AccelerationStructureDescriptor, destinationAccelerationStructure: ^NS.Object, scratchBuffer: ^NS.Object, scratchBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:", sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="sampleCountersInBuffer")
|
|
AccelerationStructureCommandEncoder_sampleCountersInBuffer :: proc(self: ^AccelerationStructureCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) {
|
|
msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="updateFence")
|
|
AccelerationStructureCommandEncoder_updateFence :: proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) {
|
|
msgSend(nil, self, "updateFence:", fence)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeap")
|
|
AccelerationStructureCommandEncoder_useHeap :: proc(self: ^AccelerationStructureCommandEncoder, heap: ^NS.Object) {
|
|
msgSend(nil, self, "useHeap:", heap)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="useHeaps")
|
|
AccelerationStructureCommandEncoder_useHeaps :: proc(self: ^AccelerationStructureCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) {
|
|
msgSend(nil, self, "useHeaps:count:", heaps, count)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="useResource")
|
|
AccelerationStructureCommandEncoder_useResource :: proc(self: ^AccelerationStructureCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) {
|
|
msgSend(nil, self, "useResource:usage:", resource, usage)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="useResources")
|
|
AccelerationStructureCommandEncoder_useResources :: proc(self: ^AccelerationStructureCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) {
|
|
msgSend(nil, self, "useResources:count:usage:", resources, count, usage)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="waitForFence")
|
|
AccelerationStructureCommandEncoder_waitForFence :: proc(self: ^AccelerationStructureCommandEncoder, fence: ^NS.Object) {
|
|
msgSend(nil, self, "waitForFence:", fence)
|
|
}
|
|
@(objc_type=AccelerationStructureCommandEncoder, objc_name="writeCompactedAccelerationStructureSize")
|
|
AccelerationStructureCommandEncoder_writeCompactedAccelerationStructureSize :: proc(self: ^AccelerationStructureCommandEncoder, accelerationStructure: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object) {
|
|
msgSend(nil, self, "writeCompactedAccelerationStructureSize:toBuffer:offset:", accelerationStructure, buffer, offset)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ArgumentEncoder
|
|
Class Methods:
|
|
Methods:
|
|
alignment
|
|
constantDataAtIndex
|
|
device
|
|
encodedLength
|
|
label
|
|
newArgumentEncoderForBufferAtIndex
|
|
setAccelerationStructure
|
|
setArgumentBuffer
|
|
setArgumentBuffer
|
|
setBuffer
|
|
setBuffers
|
|
setComputePipelineState
|
|
setComputePipelineStates
|
|
setIndirectCommandBuffer
|
|
setIndirectCommandBuffers
|
|
setIntersectionFunctionTable
|
|
setIntersectionFunctionTables
|
|
setLabel
|
|
setRenderPipelineState
|
|
setRenderPipelineStates
|
|
setSamplerState
|
|
setSamplerStates
|
|
setTexture
|
|
setTextures
|
|
setVisibleFunctionTable
|
|
setVisibleFunctionTables
|
|
*/
|
|
@(objc_class="MTLArgumentEncoder")
|
|
ArgumentEncoder :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=ArgumentEncoder, objc_name="alignment")
|
|
ArgumentEncoder_alignment :: proc(self: ^ArgumentEncoder) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "alignment")
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="constantDataAtIndex")
|
|
ArgumentEncoder_constantDataAtIndex :: proc(self: ^ArgumentEncoder, index: ^NS.Object) -> rawptr {
|
|
return msgSend(rawptr, self, "constantDataAtIndex:", index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="device")
|
|
ArgumentEncoder_device :: proc(self: ^ArgumentEncoder) -> ^ArgumentEncoder {
|
|
return msgSend(^ArgumentEncoder, self, "device")
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="encodedLength")
|
|
ArgumentEncoder_encodedLength :: proc(self: ^ArgumentEncoder) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "encodedLength")
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="label")
|
|
ArgumentEncoder_label :: proc(self: ^ArgumentEncoder) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="newArgumentEncoderForBufferAtIndex")
|
|
ArgumentEncoder_newArgumentEncoderForBufferAtIndex :: proc(self: ^ArgumentEncoder, index: ^NS.Object) -> ^ArgumentEncoder {
|
|
return msgSend(^ArgumentEncoder, self, "newArgumentEncoderForBufferAtIndex:", index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setAccelerationStructure")
|
|
ArgumentEncoder_setAccelerationStructure :: proc(self: ^ArgumentEncoder, accelerationStructure: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setAccelerationStructure:atIndex:", accelerationStructure, index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_offset_")
|
|
ArgumentEncoder_setArgumentBuffer_offset_ :: proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, offset: ^NS.Object) {
|
|
msgSend(nil, self, "setArgumentBuffer:offset:", argumentBuffer, offset)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setArgumentBuffer_startOffset_arrayElement_")
|
|
ArgumentEncoder_setArgumentBuffer_startOffset_arrayElement_ :: proc(self: ^ArgumentEncoder, argumentBuffer: ^NS.Object, startOffset: ^NS.Object, arrayElement: ^NS.Object) {
|
|
msgSend(nil, self, "setArgumentBuffer:startOffset:arrayElement:", argumentBuffer, startOffset, arrayElement)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setBuffer")
|
|
ArgumentEncoder_setBuffer :: proc(self: ^ArgumentEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setBuffers")
|
|
ArgumentEncoder_setBuffers :: proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) {
|
|
msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setComputePipelineState")
|
|
ArgumentEncoder_setComputePipelineState :: proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setComputePipelineState:atIndex:", pipeline, index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setComputePipelineStates")
|
|
ArgumentEncoder_setComputePipelineStates :: proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setComputePipelineStates:withRange:", pipelines, range)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffer")
|
|
ArgumentEncoder_setIndirectCommandBuffer :: proc(self: ^ArgumentEncoder, indirectCommandBuffer: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setIndirectCommandBuffer:atIndex:", indirectCommandBuffer, index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setIndirectCommandBuffers")
|
|
ArgumentEncoder_setIndirectCommandBuffers :: proc(self: ^ArgumentEncoder, buffers: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setIndirectCommandBuffers:withRange:", buffers, range)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTable")
|
|
ArgumentEncoder_setIntersectionFunctionTable :: proc(self: ^ArgumentEncoder, intersectionFunctionTable: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setIntersectionFunctionTable:atIndex:", intersectionFunctionTable, index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setIntersectionFunctionTables")
|
|
ArgumentEncoder_setIntersectionFunctionTables :: proc(self: ^ArgumentEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setIntersectionFunctionTables:withRange:", intersectionFunctionTables, range)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setLabel")
|
|
ArgumentEncoder_setLabel :: proc(self: ^ArgumentEncoder, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setRenderPipelineState")
|
|
ArgumentEncoder_setRenderPipelineState :: proc(self: ^ArgumentEncoder, pipeline: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setRenderPipelineState:atIndex:", pipeline, index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setRenderPipelineStates")
|
|
ArgumentEncoder_setRenderPipelineStates :: proc(self: ^ArgumentEncoder, pipelines: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setRenderPipelineStates:withRange:", pipelines, range)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setSamplerState")
|
|
ArgumentEncoder_setSamplerState :: proc(self: ^ArgumentEncoder, sampler: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setSamplerState:atIndex:", sampler, index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setSamplerStates")
|
|
ArgumentEncoder_setSamplerStates :: proc(self: ^ArgumentEncoder, samplers: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setSamplerStates:withRange:", samplers, range)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setTexture")
|
|
ArgumentEncoder_setTexture :: proc(self: ^ArgumentEncoder, texture: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setTexture:atIndex:", texture, index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setTextures")
|
|
ArgumentEncoder_setTextures :: proc(self: ^ArgumentEncoder, textures: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setTextures:withRange:", textures, range)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTable")
|
|
ArgumentEncoder_setVisibleFunctionTable :: proc(self: ^ArgumentEncoder, visibleFunctionTable: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setVisibleFunctionTable:atIndex:", visibleFunctionTable, index)
|
|
}
|
|
@(objc_type=ArgumentEncoder, objc_name="setVisibleFunctionTables")
|
|
ArgumentEncoder_setVisibleFunctionTables :: proc(self: ^ArgumentEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setVisibleFunctionTables:withRange:", visibleFunctionTables, range)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
BinaryArchive
|
|
Class Methods:
|
|
Methods:
|
|
addComputePipelineFunctionsWithDescriptor
|
|
addRenderPipelineFunctionsWithDescriptor
|
|
addTileRenderPipelineFunctionsWithDescriptor
|
|
device
|
|
label
|
|
serializeToURL
|
|
setLabel
|
|
*/
|
|
@(objc_class="MTLBinaryArchive")
|
|
BinaryArchive :: struct { using _: NS.Copying(BinaryArchive) }
|
|
|
|
@(objc_type=BinaryArchive, objc_name="addComputePipelineFunctionsWithDescriptor")
|
|
BinaryArchive_addComputePipelineFunctionsWithDescriptor :: proc(self: ^BinaryArchive, descriptor: ^ComputePipelineDescriptor, error: ^^NS.Error ) -> BOOL {
|
|
return msgSend(BOOL, self, "addComputePipelineFunctionsWithDescriptor:error:", descriptor, error)
|
|
}
|
|
@(objc_type=BinaryArchive, objc_name="addRenderPipelineFunctionsWithDescriptor")
|
|
BinaryArchive_addRenderPipelineFunctionsWithDescriptor :: proc(self: ^BinaryArchive, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL {
|
|
return msgSend(BOOL, self, "addRenderPipelineFunctionsWithDescriptor:error:", descriptor, error)
|
|
}
|
|
@(objc_type=BinaryArchive, objc_name="addTileRenderPipelineFunctionsWithDescriptor")
|
|
BinaryArchive_addTileRenderPipelineFunctionsWithDescriptor :: proc(self: ^BinaryArchive, descriptor: ^TileRenderPipelineDescriptor, error: ^^NS.Error ) -> BOOL {
|
|
return msgSend(BOOL, self, "addTileRenderPipelineFunctionsWithDescriptor:error:", descriptor, error)
|
|
}
|
|
@(objc_type=BinaryArchive, objc_name="device")
|
|
BinaryArchive_device :: proc(self: ^BinaryArchive) -> ^BinaryArchive {
|
|
return msgSend(^BinaryArchive, self, "device")
|
|
}
|
|
@(objc_type=BinaryArchive, objc_name="label")
|
|
BinaryArchive_label :: proc(self: ^BinaryArchive) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=BinaryArchive, objc_name="serializeToURL")
|
|
BinaryArchive_serializeToURL :: proc(self: ^BinaryArchive, url: ^NS.URL, error: ^^NS.Error ) -> BOOL {
|
|
return msgSend(BOOL, self, "serializeToURL:error:", url, error)
|
|
}
|
|
@(objc_type=BinaryArchive, objc_name="setLabel")
|
|
BinaryArchive_setLabel :: proc(self: ^BinaryArchive, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
BlitCommandEncoder
|
|
Class Methods:
|
|
Methods:
|
|
copyFromBuffer
|
|
copyFromBuffer
|
|
copyFromBuffer
|
|
copyFromTexture
|
|
copyFromTexture
|
|
copyFromTexture
|
|
copyFromTexture
|
|
copyFromTexture
|
|
copyIndirectCommandBuffer
|
|
fillBuffer
|
|
generateMipmapsForTexture
|
|
getTextureAccessCounters
|
|
optimizeContentsForCPUAccess
|
|
optimizeContentsForCPUAccess
|
|
optimizeContentsForGPUAccess
|
|
optimizeContentsForGPUAccess
|
|
optimizeIndirectCommandBuffer
|
|
resetCommandsInBuffer
|
|
resetTextureAccessCounters
|
|
resolveCounters
|
|
sampleCountersInBuffer
|
|
synchronizeResource
|
|
synchronizeTexture
|
|
updateFence
|
|
waitForFence
|
|
*/
|
|
@(objc_class="MTLBlitCommandEncoder")
|
|
BlitCommandEncoder :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_")
|
|
BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) {
|
|
msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_")
|
|
BlitCommandEncoder_copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_ :: proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, sourceBytesPerRow: ^NS.Object, sourceBytesPerImage: ^NS.Object, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin, options: BlitOption) {
|
|
msgSend(nil, self, "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:", sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_")
|
|
BlitCommandEncoder_copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_ :: proc(self: ^BlitCommandEncoder, sourceBuffer: ^NS.Object, sourceOffset: ^NS.Object, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, size: ^NS.Object) {
|
|
msgSend(nil, self, "copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:", sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_")
|
|
BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object) {
|
|
msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_")
|
|
BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object, destinationBytesPerRow: ^NS.Object, destinationBytesPerImage: ^NS.Object, options: BlitOption) {
|
|
msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_")
|
|
BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, sourceOrigin: Origin, sourceSize: Size, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, destinationOrigin: Origin) {
|
|
msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:", sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_")
|
|
BlitCommandEncoder_copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, sourceSlice: ^NS.Object, sourceLevel: ^NS.Object, destinationTexture: ^NS.Object, destinationSlice: ^NS.Object, destinationLevel: ^NS.Object, sliceCount: ^NS.Object, levelCount: ^NS.Object) {
|
|
msgSend(nil, self, "copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:", sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="copyFromTexture_toTexture_")
|
|
BlitCommandEncoder_copyFromTexture_toTexture_ :: proc(self: ^BlitCommandEncoder, sourceTexture: ^NS.Object, destinationTexture: ^NS.Object) {
|
|
msgSend(nil, self, "copyFromTexture:toTexture:", sourceTexture, destinationTexture)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="copyIndirectCommandBuffer")
|
|
BlitCommandEncoder_copyIndirectCommandBuffer :: proc(self: ^BlitCommandEncoder, source: ^NS.Object, sourceRange: NS.Range, destination: ^NS.Object, destinationIndex: ^NS.Object) {
|
|
msgSend(nil, self, "copyIndirectCommandBuffer:sourceRange:destination:destinationIndex:", source, sourceRange, destination, destinationIndex)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="fillBuffer")
|
|
BlitCommandEncoder_fillBuffer :: proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range, value: u8) {
|
|
msgSend(nil, self, "fillBuffer:range:value:", buffer, range, value)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="generateMipmapsForTexture")
|
|
BlitCommandEncoder_generateMipmapsForTexture :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object) {
|
|
msgSend(nil, self, "generateMipmapsForTexture:", texture)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="getTextureAccessCounters")
|
|
BlitCommandEncoder_getTextureAccessCounters :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object, resetCounters: BOOL, countersBuffer: ^NS.Object, countersBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "getTextureAccessCounters:region:mipLevel:slice:resetCounters:countersBuffer:countersBufferOffset:", texture, region, mipLevel, slice, resetCounters, countersBuffer, countersBufferOffset)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccess")
|
|
BlitCommandEncoder_optimizeContentsForCPUAccess :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object) {
|
|
msgSend(nil, self, "optimizeContentsForCPUAccess:", texture)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForCPUAccess_slice_level_")
|
|
BlitCommandEncoder_optimizeContentsForCPUAccess_slice_level_ :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) {
|
|
msgSend(nil, self, "optimizeContentsForCPUAccess:slice:level:", texture, slice, level)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccess")
|
|
BlitCommandEncoder_optimizeContentsForGPUAccess :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object) {
|
|
msgSend(nil, self, "optimizeContentsForGPUAccess:", texture)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="optimizeContentsForGPUAccess_slice_level_")
|
|
BlitCommandEncoder_optimizeContentsForGPUAccess_slice_level_ :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) {
|
|
msgSend(nil, self, "optimizeContentsForGPUAccess:slice:level:", texture, slice, level)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="optimizeIndirectCommandBuffer")
|
|
BlitCommandEncoder_optimizeIndirectCommandBuffer :: proc(self: ^BlitCommandEncoder, indirectCommandBuffer: ^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "optimizeIndirectCommandBuffer:withRange:", indirectCommandBuffer, range)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="resetCommandsInBuffer")
|
|
BlitCommandEncoder_resetCommandsInBuffer :: proc(self: ^BlitCommandEncoder, buffer: ^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "resetCommandsInBuffer:withRange:", buffer, range)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="resetTextureAccessCounters")
|
|
BlitCommandEncoder_resetTextureAccessCounters :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, region: Region, mipLevel: ^NS.Object, slice: ^NS.Object) {
|
|
msgSend(nil, self, "resetTextureAccessCounters:region:mipLevel:slice:", texture, region, mipLevel, slice)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="resolveCounters")
|
|
BlitCommandEncoder_resolveCounters :: proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, range: NS.Range, destinationBuffer: ^NS.Object, destinationOffset: ^NS.Object) {
|
|
msgSend(nil, self, "resolveCounters:inRange:destinationBuffer:destinationOffset:", sampleBuffer, range, destinationBuffer, destinationOffset)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="sampleCountersInBuffer")
|
|
BlitCommandEncoder_sampleCountersInBuffer :: proc(self: ^BlitCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) {
|
|
msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="synchronizeResource")
|
|
BlitCommandEncoder_synchronizeResource :: proc(self: ^BlitCommandEncoder, resource: ^NS.Object) {
|
|
msgSend(nil, self, "synchronizeResource:", resource)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="synchronizeTexture")
|
|
BlitCommandEncoder_synchronizeTexture :: proc(self: ^BlitCommandEncoder, texture: ^NS.Object, slice: ^NS.Object, level: ^NS.Object) {
|
|
msgSend(nil, self, "synchronizeTexture:slice:level:", texture, slice, level)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="updateFence")
|
|
BlitCommandEncoder_updateFence :: proc(self: ^BlitCommandEncoder, fence: ^NS.Object) {
|
|
msgSend(nil, self, "updateFence:", fence)
|
|
}
|
|
@(objc_type=BlitCommandEncoder, objc_name="waitForFence")
|
|
BlitCommandEncoder_waitForFence :: proc(self: ^BlitCommandEncoder, fence: ^NS.Object) {
|
|
msgSend(nil, self, "waitForFence:", fence)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Buffer
|
|
Class Methods:
|
|
Methods:
|
|
addDebugMarker
|
|
contents
|
|
didModifyRange
|
|
length
|
|
newRemoteBufferViewForDevice
|
|
newTextureWithDescriptor
|
|
remoteStorageBuffer
|
|
removeAllDebugMarkers
|
|
*/
|
|
@(objc_class="MTLBuffer")
|
|
Buffer :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Buffer, objc_name="addDebugMarker")
|
|
Buffer_addDebugMarker :: proc(self: ^Buffer, marker: ^NS.String, range: NS.Range) {
|
|
msgSend(nil, self, "addDebugMarker:range:", marker, range)
|
|
}
|
|
@(objc_type=Buffer, objc_name="contents")
|
|
Buffer_contents :: proc(self: ^Buffer) -> rawptr {
|
|
return msgSend(rawptr, self, "contents")
|
|
}
|
|
@(objc_type=Buffer, objc_name="didModifyRange")
|
|
Buffer_didModifyRange :: proc(self: ^Buffer, range: NS.Range) {
|
|
msgSend(nil, self, "didModifyRange:", range)
|
|
}
|
|
@(objc_type=Buffer, objc_name="length")
|
|
Buffer_length :: proc(self: ^Buffer) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "length")
|
|
}
|
|
@(objc_type=Buffer, objc_name="newRemoteBufferViewForDevice")
|
|
Buffer_newRemoteBufferViewForDevice :: proc(self: ^Buffer, device: ^NS.Object) -> ^Buffer {
|
|
return msgSend(^Buffer, self, "newRemoteBufferViewForDevice:", device)
|
|
}
|
|
@(objc_type=Buffer, objc_name="newTextureWithDescriptor")
|
|
Buffer_newTextureWithDescriptor :: proc(self: ^Buffer, descriptor: ^TextureDescriptor, offset: ^NS.Object, bytesPerRow: ^NS.Object) -> ^Buffer {
|
|
return msgSend(^Buffer, self, "newTextureWithDescriptor:offset:bytesPerRow:", descriptor, offset, bytesPerRow)
|
|
}
|
|
@(objc_type=Buffer, objc_name="remoteStorageBuffer")
|
|
Buffer_remoteStorageBuffer :: proc(self: ^Buffer) -> ^Buffer {
|
|
return msgSend(^Buffer, self, "remoteStorageBuffer")
|
|
}
|
|
@(objc_type=Buffer, objc_name="removeAllDebugMarkers")
|
|
Buffer_removeAllDebugMarkers :: proc(self: ^Buffer) {
|
|
msgSend(nil, self, "removeAllDebugMarkers")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CaptureScope
|
|
Class Methods:
|
|
Methods:
|
|
beginScope
|
|
commandQueue
|
|
device
|
|
endScope
|
|
label
|
|
setLabel
|
|
*/
|
|
@(objc_class="MTLCaptureScope")
|
|
CaptureScope :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=CaptureScope, objc_name="beginScope")
|
|
CaptureScope_beginScope :: proc(self: ^CaptureScope) {
|
|
msgSend(nil, self, "beginScope")
|
|
}
|
|
@(objc_type=CaptureScope, objc_name="commandQueue")
|
|
CaptureScope_commandQueue :: proc(self: ^CaptureScope) -> ^CaptureScope {
|
|
return msgSend(^CaptureScope, self, "commandQueue")
|
|
}
|
|
@(objc_type=CaptureScope, objc_name="device")
|
|
CaptureScope_device :: proc(self: ^CaptureScope) -> ^CaptureScope {
|
|
return msgSend(^CaptureScope, self, "device")
|
|
}
|
|
@(objc_type=CaptureScope, objc_name="endScope")
|
|
CaptureScope_endScope :: proc(self: ^CaptureScope) {
|
|
msgSend(nil, self, "endScope")
|
|
}
|
|
@(objc_type=CaptureScope, objc_name="label")
|
|
CaptureScope_label :: proc(self: ^CaptureScope) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=CaptureScope, objc_name="setLabel")
|
|
CaptureScope_setLabel :: proc(self: ^CaptureScope, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CommandBuffer
|
|
Class Methods:
|
|
Methods:
|
|
GPUEndTime
|
|
GPUStartTime
|
|
accelerationStructureCommandEncoder
|
|
addCompletedHandler
|
|
addScheduledHandler
|
|
blitCommandEncoder
|
|
blitCommandEncoderWithDescriptor
|
|
commandQueue
|
|
commit
|
|
computeCommandEncoder
|
|
computeCommandEncoderWithDescriptor
|
|
computeCommandEncoderWithDispatchType
|
|
device
|
|
encodeSignalEvent
|
|
encodeWaitForEvent
|
|
enqueue
|
|
error
|
|
errorOptions
|
|
kernelEndTime
|
|
kernelStartTime
|
|
label
|
|
logs
|
|
parallelRenderCommandEncoderWithDescriptor
|
|
popDebugGroup
|
|
presentDrawable
|
|
presentDrawable
|
|
presentDrawable
|
|
pushDebugGroup
|
|
renderCommandEncoderWithDescriptor
|
|
resourceStateCommandEncoder
|
|
resourceStateCommandEncoderWithDescriptor
|
|
retainedReferences
|
|
setLabel
|
|
status
|
|
waitUntilCompleted
|
|
waitUntilScheduled
|
|
*/
|
|
@(objc_class="MTLCommandBuffer")
|
|
CommandBuffer :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=CommandBuffer, objc_name="GPUEndTime")
|
|
CommandBuffer_GPUEndTime :: proc(self: ^CommandBuffer) -> CFTimeInterval {
|
|
return msgSend(CFTimeInterval, self, "GPUEndTime")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="GPUStartTime")
|
|
CommandBuffer_GPUStartTime :: proc(self: ^CommandBuffer) -> CFTimeInterval {
|
|
return msgSend(CFTimeInterval, self, "GPUStartTime")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="accelerationStructureCommandEncoder")
|
|
CommandBuffer_accelerationStructureCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "accelerationStructureCommandEncoder")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="addCompletedHandler")
|
|
CommandBuffer_addCompletedHandler :: proc(self: ^CommandBuffer, block: CommandBufferHandler) {
|
|
msgSend(nil, self, "addCompletedHandler:", block)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="addScheduledHandler")
|
|
CommandBuffer_addScheduledHandler :: proc(self: ^CommandBuffer, block: CommandBufferHandler) {
|
|
msgSend(nil, self, "addScheduledHandler:", block)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="blitCommandEncoder")
|
|
CommandBuffer_blitCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "blitCommandEncoder")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="blitCommandEncoderWithDescriptor")
|
|
CommandBuffer_blitCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, blitPassDescriptor: ^BlitPassDescriptor) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "blitCommandEncoderWithDescriptor:", blitPassDescriptor)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="commandQueue")
|
|
CommandBuffer_commandQueue :: proc(self: ^CommandBuffer) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "commandQueue")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="commit")
|
|
CommandBuffer_commit :: proc(self: ^CommandBuffer) {
|
|
msgSend(nil, self, "commit")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="computeCommandEncoder")
|
|
CommandBuffer_computeCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "computeCommandEncoder")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDescriptor")
|
|
CommandBuffer_computeCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, computePassDescriptor: ^ComputePassDescriptor) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "computeCommandEncoderWithDescriptor:", computePassDescriptor)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="computeCommandEncoderWithDispatchType")
|
|
CommandBuffer_computeCommandEncoderWithDispatchType :: proc(self: ^CommandBuffer, dispatchType: DispatchType) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "computeCommandEncoderWithDispatchType:", dispatchType)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="device")
|
|
CommandBuffer_device :: proc(self: ^CommandBuffer) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "device")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="encodeSignalEvent")
|
|
CommandBuffer_encodeSignalEvent :: proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) {
|
|
msgSend(nil, self, "encodeSignalEvent:value:", event, value)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="encodeWaitForEvent")
|
|
CommandBuffer_encodeWaitForEvent :: proc(self: ^CommandBuffer, event: ^NS.Object, value: u64) {
|
|
msgSend(nil, self, "encodeWaitForEvent:value:", event, value)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="enqueue")
|
|
CommandBuffer_enqueue :: proc(self: ^CommandBuffer) {
|
|
msgSend(nil, self, "enqueue")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="error")
|
|
CommandBuffer_error :: proc(self: ^CommandBuffer) -> ^NS.Error {
|
|
return msgSend(^NS.Error, self, "error")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="errorOptions")
|
|
CommandBuffer_errorOptions :: proc(self: ^CommandBuffer) -> CommandBufferErrorOption {
|
|
return msgSend(CommandBufferErrorOption, self, "errorOptions")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="kernelEndTime")
|
|
CommandBuffer_kernelEndTime :: proc(self: ^CommandBuffer) -> CFTimeInterval {
|
|
return msgSend(CFTimeInterval, self, "kernelEndTime")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="kernelStartTime")
|
|
CommandBuffer_kernelStartTime :: proc(self: ^CommandBuffer) -> CFTimeInterval {
|
|
return msgSend(CFTimeInterval, self, "kernelStartTime")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="label")
|
|
CommandBuffer_label :: proc(self: ^CommandBuffer) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="logs")
|
|
CommandBuffer_logs :: proc(self: ^CommandBuffer) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "logs")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="parallelRenderCommandEncoderWithDescriptor")
|
|
CommandBuffer_parallelRenderCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "parallelRenderCommandEncoderWithDescriptor:", renderPassDescriptor)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="popDebugGroup")
|
|
CommandBuffer_popDebugGroup :: proc(self: ^CommandBuffer) {
|
|
msgSend(nil, self, "popDebugGroup")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="presentDrawable")
|
|
CommandBuffer_presentDrawable :: proc(self: ^CommandBuffer, drawable: ^NS.Object) {
|
|
msgSend(nil, self, "presentDrawable:", drawable)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="presentDrawable_afterMinimumDuration_")
|
|
CommandBuffer_presentDrawable_afterMinimumDuration_ :: proc(self: ^CommandBuffer, drawable: ^NS.Object, duration: CFTimeInterval) {
|
|
msgSend(nil, self, "presentDrawable:afterMinimumDuration:", drawable, duration)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="presentDrawable_atTime_")
|
|
CommandBuffer_presentDrawable_atTime_ :: proc(self: ^CommandBuffer, drawable: ^NS.Object, presentationTime: CFTimeInterval) {
|
|
msgSend(nil, self, "presentDrawable:atTime:", drawable, presentationTime)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="pushDebugGroup")
|
|
CommandBuffer_pushDebugGroup :: proc(self: ^CommandBuffer, string: ^NS.String) {
|
|
msgSend(nil, self, "pushDebugGroup:", string)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="renderCommandEncoderWithDescriptor")
|
|
CommandBuffer_renderCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, renderPassDescriptor: ^RenderPassDescriptor) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "renderCommandEncoderWithDescriptor:", renderPassDescriptor)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoder")
|
|
CommandBuffer_resourceStateCommandEncoder :: proc(self: ^CommandBuffer) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "resourceStateCommandEncoder")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="resourceStateCommandEncoderWithDescriptor")
|
|
CommandBuffer_resourceStateCommandEncoderWithDescriptor :: proc(self: ^CommandBuffer, resourceStatePassDescriptor: ^ResourceStatePassDescriptor) -> ^CommandBuffer {
|
|
return msgSend(^CommandBuffer, self, "resourceStateCommandEncoderWithDescriptor:", resourceStatePassDescriptor)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="retainedReferences")
|
|
CommandBuffer_retainedReferences :: proc(self: ^CommandBuffer) -> BOOL {
|
|
return msgSend(BOOL, self, "retainedReferences")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="setLabel")
|
|
CommandBuffer_setLabel :: proc(self: ^CommandBuffer, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="status")
|
|
CommandBuffer_status :: proc(self: ^CommandBuffer) -> CommandBufferStatus {
|
|
return msgSend(CommandBufferStatus, self, "status")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="waitUntilCompleted")
|
|
CommandBuffer_waitUntilCompleted :: proc(self: ^CommandBuffer) {
|
|
msgSend(nil, self, "waitUntilCompleted")
|
|
}
|
|
@(objc_type=CommandBuffer, objc_name="waitUntilScheduled")
|
|
CommandBuffer_waitUntilScheduled :: proc(self: ^CommandBuffer) {
|
|
msgSend(nil, self, "waitUntilScheduled")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CommandBufferEncoderInfo
|
|
Class Methods:
|
|
Methods:
|
|
debugSignposts
|
|
errorState
|
|
label
|
|
*/
|
|
@(objc_class="MTLCommandBufferEncoderInfo")
|
|
CommandBufferEncoderInfo :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=CommandBufferEncoderInfo, objc_name="debugSignposts")
|
|
CommandBufferEncoderInfo_debugSignposts :: proc(self: ^CommandBufferEncoderInfo) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "debugSignposts")
|
|
}
|
|
@(objc_type=CommandBufferEncoderInfo, objc_name="errorState")
|
|
CommandBufferEncoderInfo_errorState :: proc(self: ^CommandBufferEncoderInfo) -> CommandEncoderErrorState {
|
|
return msgSend(CommandEncoderErrorState, self, "errorState")
|
|
}
|
|
@(objc_type=CommandBufferEncoderInfo, objc_name="label")
|
|
CommandBufferEncoderInfo_label :: proc(self: ^CommandBufferEncoderInfo) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CommandEncoder
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
endEncoding
|
|
insertDebugSignpost
|
|
label
|
|
popDebugGroup
|
|
pushDebugGroup
|
|
setLabel
|
|
*/
|
|
@(objc_class="MTLCommandEncoder")
|
|
CommandEncoder :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=CommandEncoder, objc_name="device")
|
|
CommandEncoder_device :: proc(self: ^CommandEncoder) -> ^CommandEncoder {
|
|
return msgSend(^CommandEncoder, self, "device")
|
|
}
|
|
@(objc_type=CommandEncoder, objc_name="endEncoding")
|
|
CommandEncoder_endEncoding :: proc(self: ^CommandEncoder) {
|
|
msgSend(nil, self, "endEncoding")
|
|
}
|
|
@(objc_type=CommandEncoder, objc_name="insertDebugSignpost")
|
|
CommandEncoder_insertDebugSignpost :: proc(self: ^CommandEncoder, string: ^NS.String) {
|
|
msgSend(nil, self, "insertDebugSignpost:", string)
|
|
}
|
|
@(objc_type=CommandEncoder, objc_name="label")
|
|
CommandEncoder_label :: proc(self: ^CommandEncoder) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=CommandEncoder, objc_name="popDebugGroup")
|
|
CommandEncoder_popDebugGroup :: proc(self: ^CommandEncoder) {
|
|
msgSend(nil, self, "popDebugGroup")
|
|
}
|
|
@(objc_type=CommandEncoder, objc_name="pushDebugGroup")
|
|
CommandEncoder_pushDebugGroup :: proc(self: ^CommandEncoder, string: ^NS.String) {
|
|
msgSend(nil, self, "pushDebugGroup:", string)
|
|
}
|
|
@(objc_type=CommandEncoder, objc_name="setLabel")
|
|
CommandEncoder_setLabel :: proc(self: ^CommandEncoder, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CommandQueue
|
|
Class Methods:
|
|
Methods:
|
|
commandBuffer
|
|
commandBufferWithDescriptor
|
|
commandBufferWithUnretainedReferences
|
|
device
|
|
insertDebugCaptureBoundary
|
|
label
|
|
setLabel
|
|
*/
|
|
@(objc_class="MTLCommandQueue")
|
|
CommandQueue :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=CommandQueue, objc_name="commandBuffer")
|
|
CommandQueue_commandBuffer :: proc(self: ^CommandQueue) -> ^CommandQueue {
|
|
return msgSend(^CommandQueue, self, "commandBuffer")
|
|
}
|
|
@(objc_type=CommandQueue, objc_name="commandBufferWithDescriptor")
|
|
CommandQueue_commandBufferWithDescriptor :: proc(self: ^CommandQueue, descriptor: ^CommandBufferDescriptor) -> ^CommandQueue {
|
|
return msgSend(^CommandQueue, self, "commandBufferWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=CommandQueue, objc_name="commandBufferWithUnretainedReferences")
|
|
CommandQueue_commandBufferWithUnretainedReferences :: proc(self: ^CommandQueue) -> ^CommandQueue {
|
|
return msgSend(^CommandQueue, self, "commandBufferWithUnretainedReferences")
|
|
}
|
|
@(objc_type=CommandQueue, objc_name="device")
|
|
CommandQueue_device :: proc(self: ^CommandQueue) -> ^CommandQueue {
|
|
return msgSend(^CommandQueue, self, "device")
|
|
}
|
|
@(objc_type=CommandQueue, objc_name="insertDebugCaptureBoundary")
|
|
CommandQueue_insertDebugCaptureBoundary :: proc(self: ^CommandQueue) {
|
|
msgSend(nil, self, "insertDebugCaptureBoundary")
|
|
}
|
|
@(objc_type=CommandQueue, objc_name="label")
|
|
CommandQueue_label :: proc(self: ^CommandQueue) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=CommandQueue, objc_name="setLabel")
|
|
CommandQueue_setLabel :: proc(self: ^CommandQueue, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ComputeCommandEncoder
|
|
Class Methods:
|
|
Methods:
|
|
dispatchThreadgroups
|
|
dispatchThreadgroupsWithIndirectBuffer
|
|
dispatchThreads
|
|
dispatchType
|
|
executeCommandsInBuffer
|
|
executeCommandsInBuffer
|
|
memoryBarrierWithResources
|
|
memoryBarrierWithScope
|
|
sampleCountersInBuffer
|
|
setAccelerationStructure
|
|
setBuffer
|
|
setBufferOffset
|
|
setBuffers
|
|
setBytes
|
|
setComputePipelineState
|
|
setImageblockWidth
|
|
setIntersectionFunctionTable
|
|
setIntersectionFunctionTables
|
|
setSamplerState
|
|
setSamplerState
|
|
setSamplerStates
|
|
setSamplerStates
|
|
setStageInRegion
|
|
setStageInRegionWithIndirectBuffer
|
|
setTexture
|
|
setTextures
|
|
setThreadgroupMemoryLength
|
|
setVisibleFunctionTable
|
|
setVisibleFunctionTables
|
|
updateFence
|
|
useHeap
|
|
useHeaps
|
|
useResource
|
|
useResources
|
|
waitForFence
|
|
*/
|
|
@(objc_class="MTLComputeCommandEncoder")
|
|
ComputeCommandEncoder :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroups")
|
|
ComputeCommandEncoder_dispatchThreadgroups :: proc(self: ^ComputeCommandEncoder, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) {
|
|
msgSend(nil, self, "dispatchThreadgroups:threadsPerThreadgroup:", threadgroupsPerGrid, threadsPerThreadgroup)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="dispatchThreadgroupsWithIndirectBuffer")
|
|
ComputeCommandEncoder_dispatchThreadgroupsWithIndirectBuffer :: proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object, threadsPerThreadgroup: Size) {
|
|
msgSend(nil, self, "dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup:", indirectBuffer, indirectBufferOffset, threadsPerThreadgroup)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="dispatchThreads")
|
|
ComputeCommandEncoder_dispatchThreads :: proc(self: ^ComputeCommandEncoder, threadsPerGrid: Size, threadsPerThreadgroup: Size) {
|
|
msgSend(nil, self, "dispatchThreads:threadsPerThreadgroup:", threadsPerGrid, threadsPerThreadgroup)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="dispatchType")
|
|
ComputeCommandEncoder_dispatchType :: proc(self: ^ComputeCommandEncoder) -> DispatchType {
|
|
return msgSend(DispatchType, self, "dispatchType")
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_")
|
|
ComputeCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: proc(self: ^ComputeCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="executeCommandsInBuffer_withRange_")
|
|
ComputeCommandEncoder_executeCommandsInBuffer_withRange_ :: proc(self: ^ComputeCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) {
|
|
msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithResources")
|
|
ComputeCommandEncoder_memoryBarrierWithResources :: proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object) {
|
|
msgSend(nil, self, "memoryBarrierWithResources:count:", resources, count)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="memoryBarrierWithScope")
|
|
ComputeCommandEncoder_memoryBarrierWithScope :: proc(self: ^ComputeCommandEncoder, scope: BarrierScope) {
|
|
msgSend(nil, self, "memoryBarrierWithScope:", scope)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="sampleCountersInBuffer")
|
|
ComputeCommandEncoder_sampleCountersInBuffer :: proc(self: ^ComputeCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) {
|
|
msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setAccelerationStructure")
|
|
ComputeCommandEncoder_setAccelerationStructure :: proc(self: ^ComputeCommandEncoder, accelerationStructure: ^NS.Object, bufferIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setAccelerationStructure:atBufferIndex:", accelerationStructure, bufferIndex)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setBuffer")
|
|
ComputeCommandEncoder_setBuffer :: proc(self: ^ComputeCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setBufferOffset")
|
|
ComputeCommandEncoder_setBufferOffset :: proc(self: ^ComputeCommandEncoder, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setBufferOffset:atIndex:", offset, index)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setBuffers")
|
|
ComputeCommandEncoder_setBuffers :: proc(self: ^ComputeCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) {
|
|
msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setBytes")
|
|
ComputeCommandEncoder_setBytes :: proc(self: ^ComputeCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setBytes:length:atIndex:", bytes, length, index)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setComputePipelineState")
|
|
ComputeCommandEncoder_setComputePipelineState :: proc(self: ^ComputeCommandEncoder, pipelineState: ^NS.Object) {
|
|
msgSend(nil, self, "setComputePipelineState:", pipelineState)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setImageblockWidth")
|
|
ComputeCommandEncoder_setImageblockWidth :: proc(self: ^ComputeCommandEncoder, width: ^NS.Object, height: ^NS.Object) {
|
|
msgSend(nil, self, "setImageblockWidth:height:", width, height)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTable")
|
|
ComputeCommandEncoder_setIntersectionFunctionTable :: proc(self: ^ComputeCommandEncoder, intersectionFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setIntersectionFunctionTable:atBufferIndex:", intersectionFunctionTable, bufferIndex)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setIntersectionFunctionTables")
|
|
ComputeCommandEncoder_setIntersectionFunctionTables :: proc(self: ^ComputeCommandEncoder, intersectionFunctionTables: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setIntersectionFunctionTables:withBufferRange:", intersectionFunctionTables, range)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_atIndex_")
|
|
ComputeCommandEncoder_setSamplerState_atIndex_ :: proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setSamplerState:atIndex:", sampler, index)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setSamplerState_lodMinClamp_lodMaxClamp_atIndex_")
|
|
ComputeCommandEncoder_setSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^ComputeCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) {
|
|
msgSend(nil, self, "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_lodMinClamps_lodMaxClamps_withRange_")
|
|
ComputeCommandEncoder_setSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) {
|
|
msgSend(nil, self, "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setSamplerStates_withRange_")
|
|
ComputeCommandEncoder_setSamplerStates_withRange_ :: proc(self: ^ComputeCommandEncoder, samplers: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setSamplerStates:withRange:", samplers, range)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setStageInRegion")
|
|
ComputeCommandEncoder_setStageInRegion :: proc(self: ^ComputeCommandEncoder, region: Region) {
|
|
msgSend(nil, self, "setStageInRegion:", region)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setStageInRegionWithIndirectBuffer")
|
|
ComputeCommandEncoder_setStageInRegionWithIndirectBuffer :: proc(self: ^ComputeCommandEncoder, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "setStageInRegionWithIndirectBuffer:indirectBufferOffset:", indirectBuffer, indirectBufferOffset)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setTexture")
|
|
ComputeCommandEncoder_setTexture :: proc(self: ^ComputeCommandEncoder, texture: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setTexture:atIndex:", texture, index)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setTextures")
|
|
ComputeCommandEncoder_setTextures :: proc(self: ^ComputeCommandEncoder, textures: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setTextures:withRange:", textures, range)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setThreadgroupMemoryLength")
|
|
ComputeCommandEncoder_setThreadgroupMemoryLength :: proc(self: ^ComputeCommandEncoder, length: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTable")
|
|
ComputeCommandEncoder_setVisibleFunctionTable :: proc(self: ^ComputeCommandEncoder, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="setVisibleFunctionTables")
|
|
ComputeCommandEncoder_setVisibleFunctionTables :: proc(self: ^ComputeCommandEncoder, visibleFunctionTables: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="updateFence")
|
|
ComputeCommandEncoder_updateFence :: proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) {
|
|
msgSend(nil, self, "updateFence:", fence)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="useHeap")
|
|
ComputeCommandEncoder_useHeap :: proc(self: ^ComputeCommandEncoder, heap: ^NS.Object) {
|
|
msgSend(nil, self, "useHeap:", heap)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="useHeaps")
|
|
ComputeCommandEncoder_useHeaps :: proc(self: ^ComputeCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) {
|
|
msgSend(nil, self, "useHeaps:count:", heaps, count)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="useResource")
|
|
ComputeCommandEncoder_useResource :: proc(self: ^ComputeCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) {
|
|
msgSend(nil, self, "useResource:usage:", resource, usage)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="useResources")
|
|
ComputeCommandEncoder_useResources :: proc(self: ^ComputeCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) {
|
|
msgSend(nil, self, "useResources:count:usage:", resources, count, usage)
|
|
}
|
|
@(objc_type=ComputeCommandEncoder, objc_name="waitForFence")
|
|
ComputeCommandEncoder_waitForFence :: proc(self: ^ComputeCommandEncoder, fence: ^NS.Object) {
|
|
msgSend(nil, self, "waitForFence:", fence)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ComputePipelineState
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
functionHandleWithFunction
|
|
imageblockMemoryLengthForDimensions
|
|
label
|
|
maxTotalThreadsPerThreadgroup
|
|
newComputePipelineStateWithAdditionalBinaryFunctions
|
|
newIntersectionFunctionTableWithDescriptor
|
|
newVisibleFunctionTableWithDescriptor
|
|
staticThreadgroupMemoryLength
|
|
supportIndirectCommandBuffers
|
|
threadExecutionWidth
|
|
*/
|
|
@(objc_class="MTLComputePipelineState")
|
|
ComputePipelineState :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=ComputePipelineState, objc_name="device")
|
|
ComputePipelineState_device :: proc(self: ^ComputePipelineState) -> ^ComputePipelineState {
|
|
return msgSend(^ComputePipelineState, self, "device")
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="functionHandleWithFunction")
|
|
ComputePipelineState_functionHandleWithFunction :: proc(self: ^ComputePipelineState, function: ^NS.Object) -> ^ComputePipelineState {
|
|
return msgSend(^ComputePipelineState, self, "functionHandleWithFunction:", function)
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="imageblockMemoryLengthForDimensions")
|
|
ComputePipelineState_imageblockMemoryLengthForDimensions :: proc(self: ^ComputePipelineState, imageblockDimensions: Size) -> ^ComputePipelineState {
|
|
return msgSend(^ComputePipelineState, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions)
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="label")
|
|
ComputePipelineState_label :: proc(self: ^ComputePipelineState) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="maxTotalThreadsPerThreadgroup")
|
|
ComputePipelineState_maxTotalThreadsPerThreadgroup :: proc(self: ^ComputePipelineState) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup")
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="newComputePipelineStateWithAdditionalBinaryFunctions")
|
|
ComputePipelineState_newComputePipelineStateWithAdditionalBinaryFunctions :: proc(self: ^ComputePipelineState, functions: ^NS.Array, error: ^^NS.Error ) -> ^ComputePipelineState {
|
|
return msgSend(^ComputePipelineState, self, "newComputePipelineStateWithAdditionalBinaryFunctions:error:", functions, error)
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="newIntersectionFunctionTableWithDescriptor")
|
|
ComputePipelineState_newIntersectionFunctionTableWithDescriptor :: proc(self: ^ComputePipelineState, descriptor: ^IntersectionFunctionTableDescriptor) -> ^ComputePipelineState {
|
|
return msgSend(^ComputePipelineState, self, "newIntersectionFunctionTableWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="newVisibleFunctionTableWithDescriptor")
|
|
ComputePipelineState_newVisibleFunctionTableWithDescriptor :: proc(self: ^ComputePipelineState, descriptor: ^VisibleFunctionTableDescriptor) -> ^ComputePipelineState {
|
|
return msgSend(^ComputePipelineState, self, "newVisibleFunctionTableWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="staticThreadgroupMemoryLength")
|
|
ComputePipelineState_staticThreadgroupMemoryLength :: proc(self: ^ComputePipelineState) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "staticThreadgroupMemoryLength")
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="supportIndirectCommandBuffers")
|
|
ComputePipelineState_supportIndirectCommandBuffers :: proc(self: ^ComputePipelineState) -> BOOL {
|
|
return msgSend(BOOL, self, "supportIndirectCommandBuffers")
|
|
}
|
|
@(objc_type=ComputePipelineState, objc_name="threadExecutionWidth")
|
|
ComputePipelineState_threadExecutionWidth :: proc(self: ^ComputePipelineState) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "threadExecutionWidth")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Counter
|
|
Class Methods:
|
|
Methods:
|
|
name
|
|
*/
|
|
@(objc_class="MTLCounter")
|
|
Counter :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Counter, objc_name="name")
|
|
Counter_name :: proc(self: ^Counter) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CounterSampleBuffer
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
label
|
|
resolveCounterRange
|
|
sampleCount
|
|
*/
|
|
@(objc_class="MTLCounterSampleBuffer")
|
|
CounterSampleBuffer :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=CounterSampleBuffer, objc_name="device")
|
|
CounterSampleBuffer_device :: proc(self: ^CounterSampleBuffer) -> ^CounterSampleBuffer {
|
|
return msgSend(^CounterSampleBuffer, self, "device")
|
|
}
|
|
@(objc_type=CounterSampleBuffer, objc_name="label")
|
|
CounterSampleBuffer_label :: proc(self: ^CounterSampleBuffer) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=CounterSampleBuffer, objc_name="resolveCounterRange")
|
|
CounterSampleBuffer_resolveCounterRange :: proc(self: ^CounterSampleBuffer, range: NS.Range) -> ^NS.Data {
|
|
return msgSend(^NS.Data, self, "resolveCounterRange:", range)
|
|
}
|
|
@(objc_type=CounterSampleBuffer, objc_name="sampleCount")
|
|
CounterSampleBuffer_sampleCount :: proc(self: ^CounterSampleBuffer) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "sampleCount")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
CounterSet
|
|
Class Methods:
|
|
Methods:
|
|
counters
|
|
name
|
|
*/
|
|
@(objc_class="MTLCounterSet")
|
|
CounterSet :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=CounterSet, objc_name="counters")
|
|
CounterSet_counters :: proc(self: ^CounterSet) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "counters")
|
|
}
|
|
@(objc_type=CounterSet, objc_name="name")
|
|
CounterSet_name :: proc(self: ^CounterSet) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
DepthStencilState
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
label
|
|
*/
|
|
@(objc_class="MTLDepthStencilState")
|
|
DepthStencilState :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=DepthStencilState, objc_name="device")
|
|
DepthStencilState_device :: proc(self: ^DepthStencilState) -> ^DepthStencilState {
|
|
return msgSend(^DepthStencilState, self, "device")
|
|
}
|
|
@(objc_type=DepthStencilState, objc_name="label")
|
|
DepthStencilState_label :: proc(self: ^DepthStencilState) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Device
|
|
Class Methods:
|
|
Methods:
|
|
accelerationStructureSizesWithDescriptor
|
|
areBarycentricCoordsSupported
|
|
areProgrammableSamplePositionsSupported
|
|
areRasterOrderGroupsSupported
|
|
argumentBuffersSupport
|
|
convertSparsePixelRegions
|
|
convertSparseTileRegions
|
|
counterSets
|
|
currentAllocatedSize
|
|
getDefaultSamplePositions
|
|
hasUnifiedMemory
|
|
heapBufferSizeAndAlignWithLength
|
|
heapTextureSizeAndAlignWithDescriptor
|
|
isDepth24Stencil8PixelFormatSupported
|
|
isHeadless
|
|
isLowPower
|
|
isRemovable
|
|
location
|
|
locationNumber
|
|
maxArgumentBufferSamplerCount
|
|
maxBufferLength
|
|
maxThreadgroupMemoryLength
|
|
maxThreadsPerThreadgroup
|
|
maxTransferRate
|
|
minimumLinearTextureAlignmentForPixelFormat
|
|
minimumTextureBufferAlignmentForPixelFormat
|
|
name
|
|
newAccelerationStructureWithDescriptor
|
|
newAccelerationStructureWithSize
|
|
newArgumentEncoderWithArguments
|
|
newBinaryArchiveWithDescriptor
|
|
newBufferWithBytes
|
|
newBufferWithBytesNoCopy
|
|
newBufferWithLength
|
|
newCommandQueue
|
|
newCommandQueueWithMaxCommandBufferCount
|
|
newComputePipelineStateWithDescriptor
|
|
newComputePipelineStateWithDescriptor
|
|
newComputePipelineStateWithFunction
|
|
newComputePipelineStateWithFunction
|
|
newComputePipelineStateWithFunction
|
|
newComputePipelineStateWithFunction
|
|
newCounterSampleBufferWithDescriptor
|
|
newDefaultLibrary
|
|
newDefaultLibraryWithBundle
|
|
newDepthStencilStateWithDescriptor
|
|
newDynamicLibrary
|
|
newDynamicLibraryWithURL
|
|
newEvent
|
|
newFence
|
|
newHeapWithDescriptor
|
|
newIndirectCommandBufferWithDescriptor
|
|
newLibraryWithData
|
|
newLibraryWithFile
|
|
newLibraryWithSource
|
|
newLibraryWithSource
|
|
newLibraryWithURL
|
|
newRasterizationRateMapWithDescriptor
|
|
newRenderPipelineStateWithDescriptor
|
|
newRenderPipelineStateWithDescriptor
|
|
newRenderPipelineStateWithDescriptor
|
|
newRenderPipelineStateWithDescriptor
|
|
newRenderPipelineStateWithTileDescriptor
|
|
newRenderPipelineStateWithTileDescriptor
|
|
newSamplerStateWithDescriptor
|
|
newSharedEvent
|
|
newSharedEventWithHandle
|
|
newSharedTextureWithDescriptor
|
|
newSharedTextureWithHandle
|
|
newTextureWithDescriptor
|
|
newTextureWithDescriptor
|
|
peerCount
|
|
peerGroupID
|
|
peerIndex
|
|
readWriteTextureSupport
|
|
recommendedMaxWorkingSetSize
|
|
registryID
|
|
sampleTimestamps
|
|
sparseTileSizeInBytes
|
|
sparseTileSizeWithTextureType
|
|
supports32BitFloatFiltering
|
|
supports32BitMSAA
|
|
supportsBCTextureCompression
|
|
supportsCounterSampling
|
|
supportsDynamicLibraries
|
|
supportsFamily
|
|
supportsFeatureSet
|
|
supportsFunctionPointers
|
|
supportsPullModelInterpolation
|
|
supportsQueryTextureLOD
|
|
supportsRasterizationRateMapWithLayerCount
|
|
supportsRaytracing
|
|
supportsShaderBarycentricCoordinates
|
|
supportsTextureSampleCount
|
|
supportsVertexAmplificationCount
|
|
*/
|
|
@(objc_class="MTLDevice")
|
|
Device :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Device, objc_name="accelerationStructureSizesWithDescriptor")
|
|
Device_accelerationStructureSizesWithDescriptor :: proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> AccelerationStructureSizes {
|
|
return msgSend(AccelerationStructureSizes, self, "accelerationStructureSizesWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=Device, objc_name="areBarycentricCoordsSupported")
|
|
Device_areBarycentricCoordsSupported :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "areBarycentricCoordsSupported")
|
|
}
|
|
@(objc_type=Device, objc_name="areProgrammableSamplePositionsSupported")
|
|
Device_areProgrammableSamplePositionsSupported :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "areProgrammableSamplePositionsSupported")
|
|
}
|
|
@(objc_type=Device, objc_name="areRasterOrderGroupsSupported")
|
|
Device_areRasterOrderGroupsSupported :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "areRasterOrderGroupsSupported")
|
|
}
|
|
@(objc_type=Device, objc_name="argumentBuffersSupport")
|
|
Device_argumentBuffersSupport :: proc(self: ^Device) -> ArgumentBuffersTier {
|
|
return msgSend(ArgumentBuffersTier, self, "argumentBuffersSupport")
|
|
}
|
|
@(objc_type=Device, objc_name="convertSparsePixelRegions")
|
|
Device_convertSparsePixelRegions :: proc(self: ^Device, pixelRegions: ^Region, tileRegions: ^Region, tileSize: Size, mode: SparseTextureRegionAlignmentMode, numRegions: ^NS.Object) {
|
|
msgSend(nil, self, "convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:", pixelRegions, tileRegions, tileSize, mode, numRegions)
|
|
}
|
|
@(objc_type=Device, objc_name="convertSparseTileRegions")
|
|
Device_convertSparseTileRegions :: proc(self: ^Device, tileRegions: ^Region, pixelRegions: ^Region, tileSize: Size, numRegions: ^NS.Object) {
|
|
msgSend(nil, self, "convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:", tileRegions, pixelRegions, tileSize, numRegions)
|
|
}
|
|
@(objc_type=Device, objc_name="counterSets")
|
|
Device_counterSets :: proc(self: ^Device) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "counterSets")
|
|
}
|
|
@(objc_type=Device, objc_name="currentAllocatedSize")
|
|
Device_currentAllocatedSize :: proc(self: ^Device) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "currentAllocatedSize")
|
|
}
|
|
@(objc_type=Device, objc_name="getDefaultSamplePositions")
|
|
Device_getDefaultSamplePositions :: proc(self: ^Device, positions: ^SamplePosition, count: ^NS.Object) {
|
|
msgSend(nil, self, "getDefaultSamplePositions:count:", positions, count)
|
|
}
|
|
@(objc_type=Device, objc_name="hasUnifiedMemory")
|
|
Device_hasUnifiedMemory :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "hasUnifiedMemory")
|
|
}
|
|
@(objc_type=Device, objc_name="heapBufferSizeAndAlignWithLength")
|
|
Device_heapBufferSizeAndAlignWithLength :: proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> SizeAndAlign {
|
|
return msgSend(SizeAndAlign, self, "heapBufferSizeAndAlignWithLength:options:", length, options)
|
|
}
|
|
@(objc_type=Device, objc_name="heapTextureSizeAndAlignWithDescriptor")
|
|
Device_heapTextureSizeAndAlignWithDescriptor :: proc(self: ^Device, desc: ^TextureDescriptor) -> SizeAndAlign {
|
|
return msgSend(SizeAndAlign, self, "heapTextureSizeAndAlignWithDescriptor:", desc)
|
|
}
|
|
@(objc_type=Device, objc_name="isDepth24Stencil8PixelFormatSupported")
|
|
Device_isDepth24Stencil8PixelFormatSupported :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "isDepth24Stencil8PixelFormatSupported")
|
|
}
|
|
@(objc_type=Device, objc_name="isHeadless")
|
|
Device_isHeadless :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "isHeadless")
|
|
}
|
|
@(objc_type=Device, objc_name="isLowPower")
|
|
Device_isLowPower :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "isLowPower")
|
|
}
|
|
@(objc_type=Device, objc_name="isRemovable")
|
|
Device_isRemovable :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "isRemovable")
|
|
}
|
|
@(objc_type=Device, objc_name="location")
|
|
Device_location :: proc(self: ^Device) -> DeviceLocation {
|
|
return msgSend(DeviceLocation, self, "location")
|
|
}
|
|
@(objc_type=Device, objc_name="locationNumber")
|
|
Device_locationNumber :: proc(self: ^Device) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "locationNumber")
|
|
}
|
|
@(objc_type=Device, objc_name="maxArgumentBufferSamplerCount")
|
|
Device_maxArgumentBufferSamplerCount :: proc(self: ^Device) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxArgumentBufferSamplerCount")
|
|
}
|
|
@(objc_type=Device, objc_name="maxBufferLength")
|
|
Device_maxBufferLength :: proc(self: ^Device) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxBufferLength")
|
|
}
|
|
@(objc_type=Device, objc_name="maxThreadgroupMemoryLength")
|
|
Device_maxThreadgroupMemoryLength :: proc(self: ^Device) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxThreadgroupMemoryLength")
|
|
}
|
|
@(objc_type=Device, objc_name="maxThreadsPerThreadgroup")
|
|
Device_maxThreadsPerThreadgroup :: proc(self: ^Device) -> Size {
|
|
return msgSend(Size, self, "maxThreadsPerThreadgroup")
|
|
}
|
|
@(objc_type=Device, objc_name="maxTransferRate")
|
|
Device_maxTransferRate :: proc(self: ^Device) -> u64 {
|
|
return msgSend(u64, self, "maxTransferRate")
|
|
}
|
|
@(objc_type=Device, objc_name="minimumLinearTextureAlignmentForPixelFormat")
|
|
Device_minimumLinearTextureAlignmentForPixelFormat :: proc(self: ^Device, format: PixelFormat) -> ^Device {
|
|
return msgSend(^Device, self, "minimumLinearTextureAlignmentForPixelFormat:", format)
|
|
}
|
|
@(objc_type=Device, objc_name="minimumTextureBufferAlignmentForPixelFormat")
|
|
Device_minimumTextureBufferAlignmentForPixelFormat :: proc(self: ^Device, format: PixelFormat) -> ^Device {
|
|
return msgSend(^Device, self, "minimumTextureBufferAlignmentForPixelFormat:", format)
|
|
}
|
|
@(objc_type=Device, objc_name="name")
|
|
Device_name :: proc(self: ^Device) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
@(objc_type=Device, objc_name="newAccelerationStructureWithDescriptor")
|
|
Device_newAccelerationStructureWithDescriptor :: proc(self: ^Device, descriptor: ^AccelerationStructureDescriptor) -> ^Device {
|
|
return msgSend(^Device, self, "newAccelerationStructureWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=Device, objc_name="newAccelerationStructureWithSize")
|
|
Device_newAccelerationStructureWithSize :: proc(self: ^Device, size: ^NS.Object) -> ^Device {
|
|
return msgSend(^Device, self, "newAccelerationStructureWithSize:", size)
|
|
}
|
|
@(objc_type=Device, objc_name="newArgumentEncoderWithArguments")
|
|
Device_newArgumentEncoderWithArguments :: proc(self: ^Device, arguments: ^NS.Array) -> ^Device {
|
|
return msgSend(^Device, self, "newArgumentEncoderWithArguments:", arguments)
|
|
}
|
|
@(objc_type=Device, objc_name="newBinaryArchiveWithDescriptor")
|
|
Device_newBinaryArchiveWithDescriptor :: proc(self: ^Device, descriptor: ^BinaryArchiveDescriptor, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newBinaryArchiveWithDescriptor:error:", descriptor, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newBufferWithBytes")
|
|
Device_newBufferWithBytes :: proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions) -> ^Device {
|
|
return msgSend(^Device, self, "newBufferWithBytes:length:options:", pointer, length, options)
|
|
}
|
|
@(objc_type=Device, objc_name="newBufferWithBytesNoCopy")
|
|
Device_newBufferWithBytesNoCopy :: proc(self: ^Device, pointer: rawptr, length: ^NS.Object, options: ResourceOptions, deallocator: rawptr) -> ^Device {
|
|
return msgSend(^Device, self, "newBufferWithBytesNoCopy:length:options:deallocator:", pointer, length, options, deallocator)
|
|
}
|
|
@(objc_type=Device, objc_name="newBufferWithLength")
|
|
Device_newBufferWithLength :: proc(self: ^Device, length: ^NS.Object, options: ResourceOptions) -> ^Device {
|
|
return msgSend(^Device, self, "newBufferWithLength:options:", length, options)
|
|
}
|
|
@(objc_type=Device, objc_name="newCommandQueue")
|
|
Device_newCommandQueue :: proc(self: ^Device) -> ^Device {
|
|
return msgSend(^Device, self, "newCommandQueue")
|
|
}
|
|
@(objc_type=Device, objc_name="newCommandQueueWithMaxCommandBufferCount")
|
|
Device_newCommandQueueWithMaxCommandBufferCount :: proc(self: ^Device, maxCommandBufferCount: ^NS.Object) -> ^Device {
|
|
return msgSend(^Device, self, "newCommandQueueWithMaxCommandBufferCount:", maxCommandBufferCount)
|
|
}
|
|
@(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_completionHandler_")
|
|
Device_newComputePipelineStateWithDescriptor_options_completionHandler_ :: proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) {
|
|
msgSend(nil, self, "newComputePipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler)
|
|
}
|
|
@(objc_type=Device, objc_name="newComputePipelineStateWithDescriptor_options_reflection_error_")
|
|
Device_newComputePipelineStateWithDescriptor_options_reflection_error_ :: proc(self: ^Device, descriptor: ^ComputePipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newComputePipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_completionHandler_")
|
|
Device_newComputePipelineStateWithFunction_completionHandler_ :: proc(self: ^Device, computeFunction: ^NS.Object, completionHandler: NewComputePipelineStateCompletionHandler) {
|
|
msgSend(nil, self, "newComputePipelineStateWithFunction:completionHandler:", computeFunction, completionHandler)
|
|
}
|
|
@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_error_")
|
|
Device_newComputePipelineStateWithFunction_error_ :: proc(self: ^Device, computeFunction: ^NS.Object, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newComputePipelineStateWithFunction:error:", computeFunction, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_completionHandler_")
|
|
Device_newComputePipelineStateWithFunction_options_completionHandler_ :: proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, completionHandler: NewComputePipelineStateWithReflectionCompletionHandler) {
|
|
msgSend(nil, self, "newComputePipelineStateWithFunction:options:completionHandler:", computeFunction, options, completionHandler)
|
|
}
|
|
@(objc_type=Device, objc_name="newComputePipelineStateWithFunction_options_reflection_error_")
|
|
Device_newComputePipelineStateWithFunction_options_reflection_error_ :: proc(self: ^Device, computeFunction: ^NS.Object, options: PipelineOption, reflection: ^AutoreleasedComputePipelineReflection, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newComputePipelineStateWithFunction:options:reflection:error:", computeFunction, options, reflection, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newCounterSampleBufferWithDescriptor")
|
|
Device_newCounterSampleBufferWithDescriptor :: proc(self: ^Device, descriptor: ^CounterSampleBufferDescriptor, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newCounterSampleBufferWithDescriptor:error:", descriptor, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newDefaultLibrary")
|
|
Device_newDefaultLibrary :: proc(self: ^Device) -> ^Device {
|
|
return msgSend(^Device, self, "newDefaultLibrary")
|
|
}
|
|
@(objc_type=Device, objc_name="newDefaultLibraryWithBundle")
|
|
Device_newDefaultLibraryWithBundle :: proc(self: ^Device, bundle: ^NS.Bundle, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newDefaultLibraryWithBundle:error:", bundle, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newDepthStencilStateWithDescriptor")
|
|
Device_newDepthStencilStateWithDescriptor :: proc(self: ^Device, descriptor: ^DepthStencilDescriptor) -> ^Device {
|
|
return msgSend(^Device, self, "newDepthStencilStateWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=Device, objc_name="newDynamicLibrary")
|
|
Device_newDynamicLibrary :: proc(self: ^Device, library: ^NS.Object, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newDynamicLibrary:error:", library, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newDynamicLibraryWithURL")
|
|
Device_newDynamicLibraryWithURL :: proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newDynamicLibraryWithURL:error:", url, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newEvent")
|
|
Device_newEvent :: proc(self: ^Device) -> ^Device {
|
|
return msgSend(^Device, self, "newEvent")
|
|
}
|
|
@(objc_type=Device, objc_name="newFence")
|
|
Device_newFence :: proc(self: ^Device) -> ^Device {
|
|
return msgSend(^Device, self, "newFence")
|
|
}
|
|
@(objc_type=Device, objc_name="newHeapWithDescriptor")
|
|
Device_newHeapWithDescriptor :: proc(self: ^Device, descriptor: ^HeapDescriptor) -> ^Device {
|
|
return msgSend(^Device, self, "newHeapWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=Device, objc_name="newIndirectCommandBufferWithDescriptor")
|
|
Device_newIndirectCommandBufferWithDescriptor :: proc(self: ^Device, descriptor: ^IndirectCommandBufferDescriptor, maxCount: ^NS.Object, options: ResourceOptions) -> ^Device {
|
|
return msgSend(^Device, self, "newIndirectCommandBufferWithDescriptor:maxCommandCount:options:", descriptor, maxCount, options)
|
|
}
|
|
@(objc_type=Device, objc_name="newLibraryWithData")
|
|
Device_newLibraryWithData :: proc(self: ^Device, data: ^NS.Object, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newLibraryWithData:error:", data, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newLibraryWithFile")
|
|
Device_newLibraryWithFile :: proc(self: ^Device, filepath: ^NS.String, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newLibraryWithFile:error:", filepath, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newLibraryWithSource_options_completionHandler_")
|
|
Device_newLibraryWithSource_options_completionHandler_ :: proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, completionHandler: NewLibraryCompletionHandler) {
|
|
msgSend(nil, self, "newLibraryWithSource:options:completionHandler:", source, options, completionHandler)
|
|
}
|
|
@(objc_type=Device, objc_name="newLibraryWithSource_options_error_")
|
|
Device_newLibraryWithSource_options_error_ :: proc(self: ^Device, source: ^NS.String, options: ^CompileOptions, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newLibraryWithSource:options:error:", source, options, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newLibraryWithURL")
|
|
Device_newLibraryWithURL :: proc(self: ^Device, url: ^NS.URL, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newLibraryWithURL:error:", url, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newRasterizationRateMapWithDescriptor")
|
|
Device_newRasterizationRateMapWithDescriptor :: proc(self: ^Device, descriptor: ^RasterizationRateMapDescriptor) -> ^Device {
|
|
return msgSend(^Device, self, "newRasterizationRateMapWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_completionHandler_")
|
|
Device_newRenderPipelineStateWithDescriptor_completionHandler_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, completionHandler: NewRenderPipelineStateCompletionHandler) {
|
|
msgSend(nil, self, "newRenderPipelineStateWithDescriptor:completionHandler:", descriptor, completionHandler)
|
|
}
|
|
@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_error_")
|
|
Device_newRenderPipelineStateWithDescriptor_error_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:error:", descriptor, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_completionHandler_")
|
|
Device_newRenderPipelineStateWithDescriptor_options_completionHandler_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) {
|
|
msgSend(nil, self, "newRenderPipelineStateWithDescriptor:options:completionHandler:", descriptor, options, completionHandler)
|
|
}
|
|
@(objc_type=Device, objc_name="newRenderPipelineStateWithDescriptor_options_reflection_error_")
|
|
Device_newRenderPipelineStateWithDescriptor_options_reflection_error_ :: proc(self: ^Device, descriptor: ^RenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newRenderPipelineStateWithDescriptor:options:reflection:error:", descriptor, options, reflection, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_completionHandler_")
|
|
Device_newRenderPipelineStateWithTileDescriptor_options_completionHandler_ :: proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, completionHandler: NewRenderPipelineStateWithReflectionCompletionHandler) {
|
|
msgSend(nil, self, "newRenderPipelineStateWithTileDescriptor:options:completionHandler:", descriptor, options, completionHandler)
|
|
}
|
|
@(objc_type=Device, objc_name="newRenderPipelineStateWithTileDescriptor_options_reflection_error_")
|
|
Device_newRenderPipelineStateWithTileDescriptor_options_reflection_error_ :: proc(self: ^Device, descriptor: ^TileRenderPipelineDescriptor, options: PipelineOption, reflection: ^AutoreleasedRenderPipelineReflection, error: ^^NS.Error ) -> ^Device {
|
|
return msgSend(^Device, self, "newRenderPipelineStateWithTileDescriptor:options:reflection:error:", descriptor, options, reflection, error)
|
|
}
|
|
@(objc_type=Device, objc_name="newSamplerStateWithDescriptor")
|
|
Device_newSamplerStateWithDescriptor :: proc(self: ^Device, descriptor: ^SamplerDescriptor) -> ^Device {
|
|
return msgSend(^Device, self, "newSamplerStateWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=Device, objc_name="newSharedEvent")
|
|
Device_newSharedEvent :: proc(self: ^Device) -> ^Device {
|
|
return msgSend(^Device, self, "newSharedEvent")
|
|
}
|
|
@(objc_type=Device, objc_name="newSharedEventWithHandle")
|
|
Device_newSharedEventWithHandle :: proc(self: ^Device, sharedEventHandle: ^SharedEventHandle) -> ^Device {
|
|
return msgSend(^Device, self, "newSharedEventWithHandle:", sharedEventHandle)
|
|
}
|
|
@(objc_type=Device, objc_name="newSharedTextureWithDescriptor")
|
|
Device_newSharedTextureWithDescriptor :: proc(self: ^Device, descriptor: ^TextureDescriptor) -> ^Device {
|
|
return msgSend(^Device, self, "newSharedTextureWithDescriptor:", descriptor)
|
|
}
|
|
@(objc_type=Device, objc_name="newSharedTextureWithHandle")
|
|
Device_newSharedTextureWithHandle :: proc(self: ^Device, sharedHandle: ^SharedTextureHandle) -> ^Device {
|
|
return msgSend(^Device, self, "newSharedTextureWithHandle:", sharedHandle)
|
|
}
|
|
@(objc_type=Device, objc_name="newTextureWithDescriptor")
|
|
Device_newTextureWithDescriptor :: proc(self: ^Device, desc: ^TextureDescriptor) -> ^Device {
|
|
return msgSend(^Device, self, "newTextureWithDescriptor:", desc)
|
|
}
|
|
@(objc_type=Device, objc_name="newTextureWithDescriptor_iosurface_plane_")
|
|
Device_newTextureWithDescriptor_iosurface_plane_ :: proc(self: ^Device, descriptor: ^TextureDescriptor, iosurface: IOSurfaceRef, plane: ^NS.Object) -> ^Device {
|
|
return msgSend(^Device, self, "newTextureWithDescriptor:iosurface:plane:", descriptor, iosurface, plane)
|
|
}
|
|
@(objc_type=Device, objc_name="peerCount")
|
|
Device_peerCount :: proc(self: ^Device) -> u32 {
|
|
return msgSend(u32, self, "peerCount")
|
|
}
|
|
@(objc_type=Device, objc_name="peerGroupID")
|
|
Device_peerGroupID :: proc(self: ^Device) -> u64 {
|
|
return msgSend(u64, self, "peerGroupID")
|
|
}
|
|
@(objc_type=Device, objc_name="peerIndex")
|
|
Device_peerIndex :: proc(self: ^Device) -> u32 {
|
|
return msgSend(u32, self, "peerIndex")
|
|
}
|
|
@(objc_type=Device, objc_name="readWriteTextureSupport")
|
|
Device_readWriteTextureSupport :: proc(self: ^Device) -> ReadWriteTextureTier {
|
|
return msgSend(ReadWriteTextureTier, self, "readWriteTextureSupport")
|
|
}
|
|
@(objc_type=Device, objc_name="recommendedMaxWorkingSetSize")
|
|
Device_recommendedMaxWorkingSetSize :: proc(self: ^Device) -> u64 {
|
|
return msgSend(u64, self, "recommendedMaxWorkingSetSize")
|
|
}
|
|
@(objc_type=Device, objc_name="registryID")
|
|
Device_registryID :: proc(self: ^Device) -> u64 {
|
|
return msgSend(u64, self, "registryID")
|
|
}
|
|
@(objc_type=Device, objc_name="sampleTimestamps")
|
|
Device_sampleTimestamps :: proc(self: ^Device, cpuTimestamp: ^Timestamp, gpuTimestamp: ^Timestamp) {
|
|
msgSend(nil, self, "sampleTimestamps:gpuTimestamp:", cpuTimestamp, gpuTimestamp)
|
|
}
|
|
@(objc_type=Device, objc_name="sparseTileSizeInBytes")
|
|
Device_sparseTileSizeInBytes :: proc(self: ^Device) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "sparseTileSizeInBytes")
|
|
}
|
|
@(objc_type=Device, objc_name="sparseTileSizeWithTextureType")
|
|
Device_sparseTileSizeWithTextureType :: proc(self: ^Device, textureType: TextureType, pixelFormat: PixelFormat, sampleCount: ^NS.Object) -> Size {
|
|
return msgSend(Size, self, "sparseTileSizeWithTextureType:pixelFormat:sampleCount:", textureType, pixelFormat, sampleCount)
|
|
}
|
|
@(objc_type=Device, objc_name="supports32BitFloatFiltering")
|
|
Device_supports32BitFloatFiltering :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "supports32BitFloatFiltering")
|
|
}
|
|
@(objc_type=Device, objc_name="supports32BitMSAA")
|
|
Device_supports32BitMSAA :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "supports32BitMSAA")
|
|
}
|
|
@(objc_type=Device, objc_name="supportsBCTextureCompression")
|
|
Device_supportsBCTextureCompression :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsBCTextureCompression")
|
|
}
|
|
@(objc_type=Device, objc_name="supportsCounterSampling")
|
|
Device_supportsCounterSampling :: proc(self: ^Device, samplingPoint: CounterSamplingPoint) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsCounterSampling:", samplingPoint)
|
|
}
|
|
@(objc_type=Device, objc_name="supportsDynamicLibraries")
|
|
Device_supportsDynamicLibraries :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsDynamicLibraries")
|
|
}
|
|
@(objc_type=Device, objc_name="supportsFamily")
|
|
Device_supportsFamily :: proc(self: ^Device, gpuFamily: GPUFamily) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsFamily:", gpuFamily)
|
|
}
|
|
@(objc_type=Device, objc_name="supportsFeatureSet")
|
|
Device_supportsFeatureSet :: proc(self: ^Device, featureSet: FeatureSet) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsFeatureSet:", featureSet)
|
|
}
|
|
@(objc_type=Device, objc_name="supportsFunctionPointers")
|
|
Device_supportsFunctionPointers :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsFunctionPointers")
|
|
}
|
|
@(objc_type=Device, objc_name="supportsPullModelInterpolation")
|
|
Device_supportsPullModelInterpolation :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsPullModelInterpolation")
|
|
}
|
|
@(objc_type=Device, objc_name="supportsQueryTextureLOD")
|
|
Device_supportsQueryTextureLOD :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsQueryTextureLOD")
|
|
}
|
|
@(objc_type=Device, objc_name="supportsRasterizationRateMapWithLayerCount")
|
|
Device_supportsRasterizationRateMapWithLayerCount :: proc(self: ^Device, layerCount: ^NS.Object) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsRasterizationRateMapWithLayerCount:", layerCount)
|
|
}
|
|
@(objc_type=Device, objc_name="supportsRaytracing")
|
|
Device_supportsRaytracing :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsRaytracing")
|
|
}
|
|
@(objc_type=Device, objc_name="supportsShaderBarycentricCoordinates")
|
|
Device_supportsShaderBarycentricCoordinates :: proc(self: ^Device) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsShaderBarycentricCoordinates")
|
|
}
|
|
@(objc_type=Device, objc_name="supportsTextureSampleCount")
|
|
Device_supportsTextureSampleCount :: proc(self: ^Device, sampleCount: ^NS.Object) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsTextureSampleCount:", sampleCount)
|
|
}
|
|
@(objc_type=Device, objc_name="supportsVertexAmplificationCount")
|
|
Device_supportsVertexAmplificationCount :: proc(self: ^Device, count: ^NS.Object) -> BOOL {
|
|
return msgSend(BOOL, self, "supportsVertexAmplificationCount:", count)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Drawable
|
|
Class Methods:
|
|
Methods:
|
|
addPresentedHandler
|
|
drawableID
|
|
present
|
|
presentAfterMinimumDuration
|
|
presentAtTime
|
|
presentedTime
|
|
*/
|
|
@(objc_class="MTLDrawable")
|
|
Drawable :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Drawable, objc_name="addPresentedHandler")
|
|
Drawable_addPresentedHandler :: proc(self: ^Drawable, block: DrawablePresentedHandler) {
|
|
msgSend(nil, self, "addPresentedHandler:", block)
|
|
}
|
|
@(objc_type=Drawable, objc_name="drawableID")
|
|
Drawable_drawableID :: proc(self: ^Drawable) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "drawableID")
|
|
}
|
|
@(objc_type=Drawable, objc_name="present")
|
|
Drawable_present :: proc(self: ^Drawable) {
|
|
msgSend(nil, self, "present")
|
|
}
|
|
@(objc_type=Drawable, objc_name="presentAfterMinimumDuration")
|
|
Drawable_presentAfterMinimumDuration :: proc(self: ^Drawable, duration: CFTimeInterval) {
|
|
msgSend(nil, self, "presentAfterMinimumDuration:", duration)
|
|
}
|
|
@(objc_type=Drawable, objc_name="presentAtTime")
|
|
Drawable_presentAtTime :: proc(self: ^Drawable, presentationTime: CFTimeInterval) {
|
|
msgSend(nil, self, "presentAtTime:", presentationTime)
|
|
}
|
|
@(objc_type=Drawable, objc_name="presentedTime")
|
|
Drawable_presentedTime :: proc(self: ^Drawable) -> CFTimeInterval {
|
|
return msgSend(CFTimeInterval, self, "presentedTime")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
DynamicLibrary
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
installName
|
|
label
|
|
serializeToURL
|
|
setLabel
|
|
*/
|
|
@(objc_class="MTLDynamicLibrary")
|
|
DynamicLibrary :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=DynamicLibrary, objc_name="device")
|
|
DynamicLibrary_device :: proc(self: ^DynamicLibrary) -> ^DynamicLibrary {
|
|
return msgSend(^DynamicLibrary, self, "device")
|
|
}
|
|
@(objc_type=DynamicLibrary, objc_name="installName")
|
|
DynamicLibrary_installName :: proc(self: ^DynamicLibrary) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "installName")
|
|
}
|
|
@(objc_type=DynamicLibrary, objc_name="label")
|
|
DynamicLibrary_label :: proc(self: ^DynamicLibrary) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=DynamicLibrary, objc_name="serializeToURL")
|
|
DynamicLibrary_serializeToURL :: proc(self: ^DynamicLibrary, url: ^NS.URL, error: ^^NS.Error ) -> BOOL {
|
|
return msgSend(BOOL, self, "serializeToURL:error:", url, error)
|
|
}
|
|
@(objc_type=DynamicLibrary, objc_name="setLabel")
|
|
DynamicLibrary_setLabel :: proc(self: ^DynamicLibrary, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Event
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
label
|
|
setLabel
|
|
*/
|
|
@(objc_class="MTLEvent")
|
|
Event :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Event, objc_name="device")
|
|
Event_device :: proc(self: ^Event) -> ^Event {
|
|
return msgSend(^Event, self, "device")
|
|
}
|
|
@(objc_type=Event, objc_name="label")
|
|
Event_label :: proc(self: ^Event) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=Event, objc_name="setLabel")
|
|
Event_setLabel :: proc(self: ^Event, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Fence
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
label
|
|
setLabel
|
|
*/
|
|
@(objc_class="MTLFence")
|
|
Fence :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Fence, objc_name="device")
|
|
Fence_device :: proc(self: ^Fence) -> ^Fence {
|
|
return msgSend(^Fence, self, "device")
|
|
}
|
|
@(objc_type=Fence, objc_name="label")
|
|
Fence_label :: proc(self: ^Fence) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=Fence, objc_name="setLabel")
|
|
Fence_setLabel :: proc(self: ^Fence, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Function
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
functionConstantsDictionary
|
|
functionType
|
|
label
|
|
name
|
|
newArgumentEncoderWithBufferIndex
|
|
newArgumentEncoderWithBufferIndex
|
|
options
|
|
patchControlPointCount
|
|
patchType
|
|
setLabel
|
|
stageInputAttributes
|
|
vertexAttributes
|
|
*/
|
|
@(objc_class="MTLFunction")
|
|
Function :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Function, objc_name="device")
|
|
Function_device :: proc(self: ^Function) -> ^Function {
|
|
return msgSend(^Function, self, "device")
|
|
}
|
|
@(objc_type=Function, objc_name="functionConstantsDictionary")
|
|
Function_functionConstantsDictionary :: proc(self: ^Function) -> ^NS.Dictionary {
|
|
return msgSend(^NS.Dictionary, self, "functionConstantsDictionary")
|
|
}
|
|
@(objc_type=Function, objc_name="functionType")
|
|
Function_functionType :: proc(self: ^Function) -> FunctionType {
|
|
return msgSend(FunctionType, self, "functionType")
|
|
}
|
|
@(objc_type=Function, objc_name="label")
|
|
Function_label :: proc(self: ^Function) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=Function, objc_name="name")
|
|
Function_name :: proc(self: ^Function) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
@(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex")
|
|
Function_newArgumentEncoderWithBufferIndex :: proc(self: ^Function, bufferIndex: ^NS.Object) -> ^Function {
|
|
return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:", bufferIndex)
|
|
}
|
|
@(objc_type=Function, objc_name="newArgumentEncoderWithBufferIndex_reflection_")
|
|
Function_newArgumentEncoderWithBufferIndex_reflection_ :: proc(self: ^Function, bufferIndex: ^NS.Object, reflection: ^AutoreleasedArgument) -> ^Function {
|
|
return msgSend(^Function, self, "newArgumentEncoderWithBufferIndex:reflection:", bufferIndex, reflection)
|
|
}
|
|
@(objc_type=Function, objc_name="options")
|
|
Function_options :: proc(self: ^Function) -> FunctionOptions {
|
|
return msgSend(FunctionOptions, self, "options")
|
|
}
|
|
@(objc_type=Function, objc_name="patchControlPointCount")
|
|
Function_patchControlPointCount :: proc(self: ^Function) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "patchControlPointCount")
|
|
}
|
|
@(objc_type=Function, objc_name="patchType")
|
|
Function_patchType :: proc(self: ^Function) -> PatchType {
|
|
return msgSend(PatchType, self, "patchType")
|
|
}
|
|
@(objc_type=Function, objc_name="setLabel")
|
|
Function_setLabel :: proc(self: ^Function, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=Function, objc_name="stageInputAttributes")
|
|
Function_stageInputAttributes :: proc(self: ^Function) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "stageInputAttributes")
|
|
}
|
|
@(objc_type=Function, objc_name="vertexAttributes")
|
|
Function_vertexAttributes :: proc(self: ^Function) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "vertexAttributes")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
FunctionHandle
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
functionType
|
|
name
|
|
*/
|
|
@(objc_class="MTLFunctionHandle")
|
|
FunctionHandle :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=FunctionHandle, objc_name="device")
|
|
FunctionHandle_device :: proc(self: ^FunctionHandle) -> ^FunctionHandle {
|
|
return msgSend(^FunctionHandle, self, "device")
|
|
}
|
|
@(objc_type=FunctionHandle, objc_name="functionType")
|
|
FunctionHandle_functionType :: proc(self: ^FunctionHandle) -> FunctionType {
|
|
return msgSend(FunctionType, self, "functionType")
|
|
}
|
|
@(objc_type=FunctionHandle, objc_name="name")
|
|
FunctionHandle_name :: proc(self: ^FunctionHandle) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "name")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
FunctionLog
|
|
Class Methods:
|
|
Methods:
|
|
debugLocation
|
|
encoderLabel
|
|
function
|
|
type
|
|
*/
|
|
@(objc_class="MTLFunctionLog")
|
|
FunctionLog :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=FunctionLog, objc_name="debugLocation")
|
|
FunctionLog_debugLocation :: proc(self: ^FunctionLog) -> ^FunctionLog {
|
|
return msgSend(^FunctionLog, self, "debugLocation")
|
|
}
|
|
@(objc_type=FunctionLog, objc_name="encoderLabel")
|
|
FunctionLog_encoderLabel :: proc(self: ^FunctionLog) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "encoderLabel")
|
|
}
|
|
@(objc_type=FunctionLog, objc_name="function")
|
|
FunctionLog_function :: proc(self: ^FunctionLog) -> ^FunctionLog {
|
|
return msgSend(^FunctionLog, self, "function")
|
|
}
|
|
@(objc_type=FunctionLog, objc_name="type")
|
|
FunctionLog_type :: proc(self: ^FunctionLog) -> FunctionLogType {
|
|
return msgSend(FunctionLogType, self, "type")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
FunctionLogDebugLocation
|
|
Class Methods:
|
|
Methods:
|
|
URL
|
|
column
|
|
functionName
|
|
line
|
|
*/
|
|
@(objc_class="MTLFunctionLogDebugLocation")
|
|
FunctionLogDebugLocation :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=FunctionLogDebugLocation, objc_name="URL")
|
|
FunctionLogDebugLocation_URL :: proc(self: ^FunctionLogDebugLocation) -> ^NS.URL {
|
|
return msgSend(^NS.URL, self, "URL")
|
|
}
|
|
@(objc_type=FunctionLogDebugLocation, objc_name="column")
|
|
FunctionLogDebugLocation_column :: proc(self: ^FunctionLogDebugLocation) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "column")
|
|
}
|
|
@(objc_type=FunctionLogDebugLocation, objc_name="functionName")
|
|
FunctionLogDebugLocation_functionName :: proc(self: ^FunctionLogDebugLocation) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "functionName")
|
|
}
|
|
@(objc_type=FunctionLogDebugLocation, objc_name="line")
|
|
FunctionLogDebugLocation_line :: proc(self: ^FunctionLogDebugLocation) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "line")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Heap
|
|
Class Methods:
|
|
Methods:
|
|
cpuCacheMode
|
|
currentAllocatedSize
|
|
device
|
|
hazardTrackingMode
|
|
label
|
|
maxAvailableSizeWithAlignment
|
|
newBufferWithLength
|
|
newBufferWithLength
|
|
newTextureWithDescriptor
|
|
newTextureWithDescriptor
|
|
resourceOptions
|
|
setLabel
|
|
setPurgeableState
|
|
size
|
|
storageMode
|
|
type
|
|
usedSize
|
|
*/
|
|
@(objc_class="MTLHeap")
|
|
Heap :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Heap, objc_name="cpuCacheMode")
|
|
Heap_cpuCacheMode :: proc(self: ^Heap) -> CPUCacheMode {
|
|
return msgSend(CPUCacheMode, self, "cpuCacheMode")
|
|
}
|
|
@(objc_type=Heap, objc_name="currentAllocatedSize")
|
|
Heap_currentAllocatedSize :: proc(self: ^Heap) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "currentAllocatedSize")
|
|
}
|
|
@(objc_type=Heap, objc_name="device")
|
|
Heap_device :: proc(self: ^Heap) -> ^Heap {
|
|
return msgSend(^Heap, self, "device")
|
|
}
|
|
@(objc_type=Heap, objc_name="hazardTrackingMode")
|
|
Heap_hazardTrackingMode :: proc(self: ^Heap) -> HazardTrackingMode {
|
|
return msgSend(HazardTrackingMode, self, "hazardTrackingMode")
|
|
}
|
|
@(objc_type=Heap, objc_name="label")
|
|
Heap_label :: proc(self: ^Heap) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=Heap, objc_name="maxAvailableSizeWithAlignment")
|
|
Heap_maxAvailableSizeWithAlignment :: proc(self: ^Heap, alignment: ^NS.Object) -> ^Heap {
|
|
return msgSend(^Heap, self, "maxAvailableSizeWithAlignment:", alignment)
|
|
}
|
|
@(objc_type=Heap, objc_name="newBufferWithLength")
|
|
Heap_newBufferWithLength :: proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions) -> ^Heap {
|
|
return msgSend(^Heap, self, "newBufferWithLength:options:", length, options)
|
|
}
|
|
@(objc_type=Heap, objc_name="newBufferWithLength_options_offset_")
|
|
Heap_newBufferWithLength_options_offset_ :: proc(self: ^Heap, length: ^NS.Object, options: ResourceOptions, offset: ^NS.Object) -> ^Heap {
|
|
return msgSend(^Heap, self, "newBufferWithLength:options:offset:", length, options, offset)
|
|
}
|
|
@(objc_type=Heap, objc_name="newTextureWithDescriptor")
|
|
Heap_newTextureWithDescriptor :: proc(self: ^Heap, desc: ^TextureDescriptor) -> ^Heap {
|
|
return msgSend(^Heap, self, "newTextureWithDescriptor:", desc)
|
|
}
|
|
@(objc_type=Heap, objc_name="newTextureWithDescriptor_offset_")
|
|
Heap_newTextureWithDescriptor_offset_ :: proc(self: ^Heap, descriptor: ^TextureDescriptor, offset: ^NS.Object) -> ^Heap {
|
|
return msgSend(^Heap, self, "newTextureWithDescriptor:offset:", descriptor, offset)
|
|
}
|
|
@(objc_type=Heap, objc_name="resourceOptions")
|
|
Heap_resourceOptions :: proc(self: ^Heap) -> ResourceOptions {
|
|
return msgSend(ResourceOptions, self, "resourceOptions")
|
|
}
|
|
@(objc_type=Heap, objc_name="setLabel")
|
|
Heap_setLabel :: proc(self: ^Heap, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=Heap, objc_name="setPurgeableState")
|
|
Heap_setPurgeableState :: proc(self: ^Heap, state: PurgeableState) -> PurgeableState {
|
|
return msgSend(PurgeableState, self, "setPurgeableState:", state)
|
|
}
|
|
@(objc_type=Heap, objc_name="size")
|
|
Heap_size :: proc(self: ^Heap) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "size")
|
|
}
|
|
@(objc_type=Heap, objc_name="storageMode")
|
|
Heap_storageMode :: proc(self: ^Heap) -> StorageMode {
|
|
return msgSend(StorageMode, self, "storageMode")
|
|
}
|
|
@(objc_type=Heap, objc_name="type")
|
|
Heap_type :: proc(self: ^Heap) -> FunctionLogType {
|
|
return msgSend(FunctionLogType, self, "type")
|
|
}
|
|
@(objc_type=Heap, objc_name="usedSize")
|
|
Heap_usedSize :: proc(self: ^Heap) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "usedSize")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
IndirectCommandBuffer
|
|
Class Methods:
|
|
Methods:
|
|
indirectComputeCommandAtIndex
|
|
indirectRenderCommandAtIndex
|
|
resetWithRange
|
|
size
|
|
*/
|
|
@(objc_class="MTLIndirectCommandBuffer")
|
|
IndirectCommandBuffer :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=IndirectCommandBuffer, objc_name="indirectComputeCommandAtIndex")
|
|
IndirectCommandBuffer_indirectComputeCommandAtIndex :: proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer {
|
|
return msgSend(^IndirectCommandBuffer, self, "indirectComputeCommandAtIndex:", commandIndex)
|
|
}
|
|
@(objc_type=IndirectCommandBuffer, objc_name="indirectRenderCommandAtIndex")
|
|
IndirectCommandBuffer_indirectRenderCommandAtIndex :: proc(self: ^IndirectCommandBuffer, commandIndex: ^NS.Object) -> ^IndirectCommandBuffer {
|
|
return msgSend(^IndirectCommandBuffer, self, "indirectRenderCommandAtIndex:", commandIndex)
|
|
}
|
|
@(objc_type=IndirectCommandBuffer, objc_name="resetWithRange")
|
|
IndirectCommandBuffer_resetWithRange :: proc(self: ^IndirectCommandBuffer, range: NS.Range) {
|
|
msgSend(nil, self, "resetWithRange:", range)
|
|
}
|
|
@(objc_type=IndirectCommandBuffer, objc_name="size")
|
|
IndirectCommandBuffer_size :: proc(self: ^IndirectCommandBuffer) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "size")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
IndirectComputeCommand
|
|
Class Methods:
|
|
Methods:
|
|
clearBarrier
|
|
concurrentDispatchThreadgroups
|
|
concurrentDispatchThreads
|
|
reset
|
|
setBarrier
|
|
setComputePipelineState
|
|
setImageblockWidth
|
|
setKernelBuffer
|
|
setStageInRegion
|
|
setThreadgroupMemoryLength
|
|
*/
|
|
@(objc_class="MTLIndirectComputeCommand")
|
|
IndirectComputeCommand :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=IndirectComputeCommand, objc_name="clearBarrier")
|
|
IndirectComputeCommand_clearBarrier :: proc(self: ^IndirectComputeCommand) {
|
|
msgSend(nil, self, "clearBarrier")
|
|
}
|
|
@(objc_type=IndirectComputeCommand, objc_name="concurrentDispatchThreadgroups")
|
|
IndirectComputeCommand_concurrentDispatchThreadgroups :: proc(self: ^IndirectComputeCommand, threadgroupsPerGrid: Size, threadsPerThreadgroup: Size) {
|
|
msgSend(nil, self, "concurrentDispatchThreadgroups:threadsPerThreadgroup:", threadgroupsPerGrid, threadsPerThreadgroup)
|
|
}
|
|
@(objc_type=IndirectComputeCommand, objc_name="concurrentDispatchThreads")
|
|
IndirectComputeCommand_concurrentDispatchThreads :: proc(self: ^IndirectComputeCommand, threadsPerGrid: Size, threadsPerThreadgroup: Size) {
|
|
msgSend(nil, self, "concurrentDispatchThreads:threadsPerThreadgroup:", threadsPerGrid, threadsPerThreadgroup)
|
|
}
|
|
@(objc_type=IndirectComputeCommand, objc_name="reset")
|
|
IndirectComputeCommand_reset :: proc(self: ^IndirectComputeCommand) {
|
|
msgSend(nil, self, "reset")
|
|
}
|
|
@(objc_type=IndirectComputeCommand, objc_name="setBarrier")
|
|
IndirectComputeCommand_setBarrier :: proc(self: ^IndirectComputeCommand) {
|
|
msgSend(nil, self, "setBarrier")
|
|
}
|
|
@(objc_type=IndirectComputeCommand, objc_name="setComputePipelineState")
|
|
IndirectComputeCommand_setComputePipelineState :: proc(self: ^IndirectComputeCommand, pipelineState: ^NS.Object) {
|
|
msgSend(nil, self, "setComputePipelineState:", pipelineState)
|
|
}
|
|
@(objc_type=IndirectComputeCommand, objc_name="setImageblockWidth")
|
|
IndirectComputeCommand_setImageblockWidth :: proc(self: ^IndirectComputeCommand, width: ^NS.Object, height: ^NS.Object) {
|
|
msgSend(nil, self, "setImageblockWidth:height:", width, height)
|
|
}
|
|
@(objc_type=IndirectComputeCommand, objc_name="setKernelBuffer")
|
|
IndirectComputeCommand_setKernelBuffer :: proc(self: ^IndirectComputeCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setKernelBuffer:offset:atIndex:", buffer, offset, index)
|
|
}
|
|
@(objc_type=IndirectComputeCommand, objc_name="setStageInRegion")
|
|
IndirectComputeCommand_setStageInRegion :: proc(self: ^IndirectComputeCommand, region: Region) {
|
|
msgSend(nil, self, "setStageInRegion:", region)
|
|
}
|
|
@(objc_type=IndirectComputeCommand, objc_name="setThreadgroupMemoryLength")
|
|
IndirectComputeCommand_setThreadgroupMemoryLength :: proc(self: ^IndirectComputeCommand, length: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setThreadgroupMemoryLength:atIndex:", length, index)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
IndirectRenderCommand
|
|
Class Methods:
|
|
Methods:
|
|
drawIndexedPatches
|
|
drawIndexedPrimitives
|
|
drawPatches
|
|
drawPrimitives
|
|
reset
|
|
setFragmentBuffer
|
|
setRenderPipelineState
|
|
setVertexBuffer
|
|
*/
|
|
@(objc_class="MTLIndirectRenderCommand")
|
|
IndirectRenderCommand :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=IndirectRenderCommand, objc_name="drawIndexedPatches")
|
|
IndirectRenderCommand_drawIndexedPatches :: proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) {
|
|
msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride)
|
|
}
|
|
@(objc_type=IndirectRenderCommand, objc_name="drawIndexedPrimitives")
|
|
IndirectRenderCommand_drawIndexedPrimitives :: proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) {
|
|
msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance)
|
|
}
|
|
@(objc_type=IndirectRenderCommand, objc_name="drawPatches")
|
|
IndirectRenderCommand_drawPatches :: proc(self: ^IndirectRenderCommand, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) {
|
|
msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride)
|
|
}
|
|
@(objc_type=IndirectRenderCommand, objc_name="drawPrimitives")
|
|
IndirectRenderCommand_drawPrimitives :: proc(self: ^IndirectRenderCommand, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) {
|
|
msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance)
|
|
}
|
|
@(objc_type=IndirectRenderCommand, objc_name="reset")
|
|
IndirectRenderCommand_reset :: proc(self: ^IndirectRenderCommand) {
|
|
msgSend(nil, self, "reset")
|
|
}
|
|
@(objc_type=IndirectRenderCommand, objc_name="setFragmentBuffer")
|
|
IndirectRenderCommand_setFragmentBuffer :: proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index)
|
|
}
|
|
@(objc_type=IndirectRenderCommand, objc_name="setRenderPipelineState")
|
|
IndirectRenderCommand_setRenderPipelineState :: proc(self: ^IndirectRenderCommand, pipelineState: ^NS.Object) {
|
|
msgSend(nil, self, "setRenderPipelineState:", pipelineState)
|
|
}
|
|
@(objc_type=IndirectRenderCommand, objc_name="setVertexBuffer")
|
|
IndirectRenderCommand_setVertexBuffer :: proc(self: ^IndirectRenderCommand, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
IntersectionFunctionTable
|
|
Class Methods:
|
|
Methods:
|
|
setBuffer
|
|
setBuffers
|
|
setFunction
|
|
setFunctions
|
|
setOpaqueTriangleIntersectionFunctionWithSignature
|
|
setOpaqueTriangleIntersectionFunctionWithSignature
|
|
setVisibleFunctionTable
|
|
setVisibleFunctionTables
|
|
*/
|
|
@(objc_class="MTLIntersectionFunctionTable")
|
|
IntersectionFunctionTable :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=IntersectionFunctionTable, objc_name="setBuffer")
|
|
IntersectionFunctionTable_setBuffer :: proc(self: ^IntersectionFunctionTable, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setBuffer:offset:atIndex:", buffer, offset, index)
|
|
}
|
|
@(objc_type=IntersectionFunctionTable, objc_name="setBuffers")
|
|
IntersectionFunctionTable_setBuffers :: proc(self: ^IntersectionFunctionTable, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) {
|
|
msgSend(nil, self, "setBuffers:offsets:withRange:", buffers, offsets, range)
|
|
}
|
|
@(objc_type=IntersectionFunctionTable, objc_name="setFunction")
|
|
IntersectionFunctionTable_setFunction :: proc(self: ^IntersectionFunctionTable, function: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setFunction:atIndex:", function, index)
|
|
}
|
|
@(objc_type=IntersectionFunctionTable, objc_name="setFunctions")
|
|
IntersectionFunctionTable_setFunctions :: proc(self: ^IntersectionFunctionTable, functions: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setFunctions:withRange:", functions, range)
|
|
}
|
|
@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_")
|
|
IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_ :: proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, index: ^NS.Object) {
|
|
msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:", signature, index)
|
|
}
|
|
@(objc_type=IntersectionFunctionTable, objc_name="setOpaqueTriangleIntersectionFunctionWithSignature_withRange_")
|
|
IntersectionFunctionTable_setOpaqueTriangleIntersectionFunctionWithSignature_withRange_ :: proc(self: ^IntersectionFunctionTable, signature: IntersectionFunctionSignature, range: NS.Range) {
|
|
msgSend(nil, self, "setOpaqueTriangleIntersectionFunctionWithSignature:withRange:", signature, range)
|
|
}
|
|
@(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTable")
|
|
IntersectionFunctionTable_setVisibleFunctionTable :: proc(self: ^IntersectionFunctionTable, visibleFunctionTable: ^NS.Object, bufferIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setVisibleFunctionTable:atBufferIndex:", visibleFunctionTable, bufferIndex)
|
|
}
|
|
@(objc_type=IntersectionFunctionTable, objc_name="setVisibleFunctionTables")
|
|
IntersectionFunctionTable_setVisibleFunctionTables :: proc(self: ^IntersectionFunctionTable, visibleFunctionTables: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setVisibleFunctionTables:withBufferRange:", visibleFunctionTables, range)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Library
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
functionNames
|
|
installName
|
|
label
|
|
newFunctionWithDescriptor
|
|
newFunctionWithDescriptor
|
|
newFunctionWithName
|
|
newFunctionWithName
|
|
newFunctionWithName
|
|
newIntersectionFunctionWithDescriptor
|
|
newIntersectionFunctionWithDescriptor
|
|
setLabel
|
|
type
|
|
*/
|
|
@(objc_class="MTLLibrary")
|
|
Library :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Library, objc_name="device")
|
|
Library_device :: proc(self: ^Library) -> ^Library {
|
|
return msgSend(^Library, self, "device")
|
|
}
|
|
@(objc_type=Library, objc_name="functionNames")
|
|
Library_functionNames :: proc(self: ^Library) -> ^NS.Array {
|
|
return msgSend(^NS.Array, self, "functionNames")
|
|
}
|
|
@(objc_type=Library, objc_name="installName")
|
|
Library_installName :: proc(self: ^Library) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "installName")
|
|
}
|
|
@(objc_type=Library, objc_name="label")
|
|
Library_label :: proc(self: ^Library) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=Library, objc_name="newFunctionWithDescriptor_completionHandler_")
|
|
Library_newFunctionWithDescriptor_completionHandler_ :: proc(self: ^Library, descriptor: ^FunctionDescriptor, completionHandler: rawptr) {
|
|
msgSend(nil, self, "newFunctionWithDescriptor:completionHandler:", descriptor, completionHandler)
|
|
}
|
|
@(objc_type=Library, objc_name="newFunctionWithDescriptor_error_")
|
|
Library_newFunctionWithDescriptor_error_ :: proc(self: ^Library, descriptor: ^FunctionDescriptor, error: ^^NS.Error ) -> ^Library {
|
|
return msgSend(^Library, self, "newFunctionWithDescriptor:error:", descriptor, error)
|
|
}
|
|
@(objc_type=Library, objc_name="newFunctionWithName")
|
|
Library_newFunctionWithName :: proc(self: ^Library, functionName: ^NS.String) -> ^Library {
|
|
return msgSend(^Library, self, "newFunctionWithName:", functionName)
|
|
}
|
|
@(objc_type=Library, objc_name="newFunctionWithName_constantValues_completionHandler_")
|
|
Library_newFunctionWithName_constantValues_completionHandler_ :: proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, completionHandler: rawptr) {
|
|
msgSend(nil, self, "newFunctionWithName:constantValues:completionHandler:", name, constantValues, completionHandler)
|
|
}
|
|
@(objc_type=Library, objc_name="newFunctionWithName_constantValues_error_")
|
|
Library_newFunctionWithName_constantValues_error_ :: proc(self: ^Library, name: ^NS.String, constantValues: ^FunctionConstantValues, error: ^^NS.Error ) -> ^Library {
|
|
return msgSend(^Library, self, "newFunctionWithName:constantValues:error:", name, constantValues, error)
|
|
}
|
|
@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_completionHandler_")
|
|
Library_newIntersectionFunctionWithDescriptor_completionHandler_ :: proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, completionHandler: rawptr) {
|
|
msgSend(nil, self, "newIntersectionFunctionWithDescriptor:completionHandler:", descriptor, completionHandler)
|
|
}
|
|
@(objc_type=Library, objc_name="newIntersectionFunctionWithDescriptor_error_")
|
|
Library_newIntersectionFunctionWithDescriptor_error_ :: proc(self: ^Library, descriptor: ^IntersectionFunctionDescriptor, error: ^^NS.Error ) -> ^Library {
|
|
return msgSend(^Library, self, "newIntersectionFunctionWithDescriptor:error:", descriptor, error)
|
|
}
|
|
@(objc_type=Library, objc_name="setLabel")
|
|
Library_setLabel :: proc(self: ^Library, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=Library, objc_name="type")
|
|
Library_type :: proc(self: ^Library) -> LibraryType {
|
|
return msgSend(LibraryType, self, "type")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ParallelRenderCommandEncoder
|
|
Class Methods:
|
|
Methods:
|
|
renderCommandEncoder
|
|
setColorStoreAction
|
|
setColorStoreActionOptions
|
|
setDepthStoreAction
|
|
setDepthStoreActionOptions
|
|
setStencilStoreAction
|
|
setStencilStoreActionOptions
|
|
*/
|
|
@(objc_class="MTLParallelRenderCommandEncoder")
|
|
ParallelRenderCommandEncoder :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=ParallelRenderCommandEncoder, objc_name="renderCommandEncoder")
|
|
ParallelRenderCommandEncoder_renderCommandEncoder :: proc(self: ^ParallelRenderCommandEncoder) -> ^ParallelRenderCommandEncoder {
|
|
return msgSend(^ParallelRenderCommandEncoder, self, "renderCommandEncoder")
|
|
}
|
|
@(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreAction")
|
|
ParallelRenderCommandEncoder_setColorStoreAction :: proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex)
|
|
}
|
|
@(objc_type=ParallelRenderCommandEncoder, objc_name="setColorStoreActionOptions")
|
|
ParallelRenderCommandEncoder_setColorStoreActionOptions :: proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex)
|
|
}
|
|
@(objc_type=ParallelRenderCommandEncoder, objc_name="setDepthStoreAction")
|
|
ParallelRenderCommandEncoder_setDepthStoreAction :: proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) {
|
|
msgSend(nil, self, "setDepthStoreAction:", storeAction)
|
|
}
|
|
@(objc_type=ParallelRenderCommandEncoder, objc_name="setDepthStoreActionOptions")
|
|
ParallelRenderCommandEncoder_setDepthStoreActionOptions :: proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) {
|
|
msgSend(nil, self, "setDepthStoreActionOptions:", storeActionOptions)
|
|
}
|
|
@(objc_type=ParallelRenderCommandEncoder, objc_name="setStencilStoreAction")
|
|
ParallelRenderCommandEncoder_setStencilStoreAction :: proc(self: ^ParallelRenderCommandEncoder, storeAction: StoreAction) {
|
|
msgSend(nil, self, "setStencilStoreAction:", storeAction)
|
|
}
|
|
@(objc_type=ParallelRenderCommandEncoder, objc_name="setStencilStoreActionOptions")
|
|
ParallelRenderCommandEncoder_setStencilStoreActionOptions :: proc(self: ^ParallelRenderCommandEncoder, storeActionOptions: StoreActionOptions) {
|
|
msgSend(nil, self, "setStencilStoreActionOptions:", storeActionOptions)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RasterizationRateMap
|
|
Class Methods:
|
|
Methods:
|
|
copyParameterDataToBuffer
|
|
device
|
|
label
|
|
layerCount
|
|
mapPhysicalToScreenCoordinates
|
|
mapScreenToPhysicalCoordinates
|
|
parameterBufferSizeAndAlign
|
|
physicalGranularity
|
|
physicalSizeForLayer
|
|
screenSize
|
|
*/
|
|
@(objc_class="MTLRasterizationRateMap")
|
|
RasterizationRateMap :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=RasterizationRateMap, objc_name="copyParameterDataToBuffer")
|
|
RasterizationRateMap_copyParameterDataToBuffer :: proc(self: ^RasterizationRateMap, buffer: ^NS.Object, offset: ^NS.Object) {
|
|
msgSend(nil, self, "copyParameterDataToBuffer:offset:", buffer, offset)
|
|
}
|
|
@(objc_type=RasterizationRateMap, objc_name="device")
|
|
RasterizationRateMap_device :: proc(self: ^RasterizationRateMap) -> ^RasterizationRateMap {
|
|
return msgSend(^RasterizationRateMap, self, "device")
|
|
}
|
|
@(objc_type=RasterizationRateMap, objc_name="label")
|
|
RasterizationRateMap_label :: proc(self: ^RasterizationRateMap) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=RasterizationRateMap, objc_name="layerCount")
|
|
RasterizationRateMap_layerCount :: proc(self: ^RasterizationRateMap) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "layerCount")
|
|
}
|
|
@(objc_type=RasterizationRateMap, objc_name="mapPhysicalToScreenCoordinates")
|
|
RasterizationRateMap_mapPhysicalToScreenCoordinates :: proc(self: ^RasterizationRateMap, physicalCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D {
|
|
return msgSend(Coordinate2D, self, "mapPhysicalToScreenCoordinates:forLayer:", physicalCoordinates, layerIndex)
|
|
}
|
|
@(objc_type=RasterizationRateMap, objc_name="mapScreenToPhysicalCoordinates")
|
|
RasterizationRateMap_mapScreenToPhysicalCoordinates :: proc(self: ^RasterizationRateMap, screenCoordinates: Coordinate2D, layerIndex: ^NS.Object) -> Coordinate2D {
|
|
return msgSend(Coordinate2D, self, "mapScreenToPhysicalCoordinates:forLayer:", screenCoordinates, layerIndex)
|
|
}
|
|
@(objc_type=RasterizationRateMap, objc_name="parameterBufferSizeAndAlign")
|
|
RasterizationRateMap_parameterBufferSizeAndAlign :: proc(self: ^RasterizationRateMap) -> SizeAndAlign {
|
|
return msgSend(SizeAndAlign, self, "parameterBufferSizeAndAlign")
|
|
}
|
|
@(objc_type=RasterizationRateMap, objc_name="physicalGranularity")
|
|
RasterizationRateMap_physicalGranularity :: proc(self: ^RasterizationRateMap) -> Size {
|
|
return msgSend(Size, self, "physicalGranularity")
|
|
}
|
|
@(objc_type=RasterizationRateMap, objc_name="physicalSizeForLayer")
|
|
RasterizationRateMap_physicalSizeForLayer :: proc(self: ^RasterizationRateMap, layerIndex: ^NS.Object) -> Size {
|
|
return msgSend(Size, self, "physicalSizeForLayer:", layerIndex)
|
|
}
|
|
@(objc_type=RasterizationRateMap, objc_name="screenSize")
|
|
RasterizationRateMap_screenSize :: proc(self: ^RasterizationRateMap) -> Size {
|
|
return msgSend(Size, self, "screenSize")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderCommandEncoder
|
|
Class Methods:
|
|
Methods:
|
|
dispatchThreadsPerTile
|
|
drawIndexedPatches
|
|
drawIndexedPatches
|
|
drawIndexedPrimitives
|
|
drawIndexedPrimitives
|
|
drawIndexedPrimitives
|
|
drawIndexedPrimitives
|
|
drawPatches
|
|
drawPatches
|
|
drawPrimitives
|
|
drawPrimitives
|
|
drawPrimitives
|
|
drawPrimitives
|
|
executeCommandsInBuffer
|
|
executeCommandsInBuffer
|
|
memoryBarrierWithResources
|
|
memoryBarrierWithScope
|
|
sampleCountersInBuffer
|
|
setBlendColorRed
|
|
setColorStoreAction
|
|
setColorStoreActionOptions
|
|
setCullMode
|
|
setDepthBias
|
|
setDepthClipMode
|
|
setDepthStencilState
|
|
setDepthStoreAction
|
|
setDepthStoreActionOptions
|
|
setFragmentBuffer
|
|
setFragmentBufferOffset
|
|
setFragmentBuffers
|
|
setFragmentBytes
|
|
setFragmentSamplerState
|
|
setFragmentSamplerState
|
|
setFragmentSamplerStates
|
|
setFragmentSamplerStates
|
|
setFragmentTexture
|
|
setFragmentTextures
|
|
setFrontFacingWinding
|
|
setRenderPipelineState
|
|
setScissorRect
|
|
setScissorRects
|
|
setStencilFrontReferenceValue
|
|
setStencilReferenceValue
|
|
setStencilStoreAction
|
|
setStencilStoreActionOptions
|
|
setTessellationFactorBuffer
|
|
setTessellationFactorScale
|
|
setThreadgroupMemoryLength
|
|
setTileBuffer
|
|
setTileBufferOffset
|
|
setTileBuffers
|
|
setTileBytes
|
|
setTileSamplerState
|
|
setTileSamplerState
|
|
setTileSamplerStates
|
|
setTileSamplerStates
|
|
setTileTexture
|
|
setTileTextures
|
|
setTriangleFillMode
|
|
setVertexAmplificationCount
|
|
setVertexBuffer
|
|
setVertexBufferOffset
|
|
setVertexBuffers
|
|
setVertexBytes
|
|
setVertexSamplerState
|
|
setVertexSamplerState
|
|
setVertexSamplerStates
|
|
setVertexSamplerStates
|
|
setVertexTexture
|
|
setVertexTextures
|
|
setViewport
|
|
setViewports
|
|
setVisibilityResultMode
|
|
textureBarrier
|
|
tileHeight
|
|
tileWidth
|
|
updateFence
|
|
useHeap
|
|
useHeap
|
|
useHeaps
|
|
useHeaps
|
|
useResource
|
|
useResource
|
|
useResources
|
|
useResources
|
|
waitForFence
|
|
*/
|
|
@(objc_class="MTLRenderCommandEncoder")
|
|
RenderCommandEncoder :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=RenderCommandEncoder, objc_name="dispatchThreadsPerTile")
|
|
RenderCommandEncoder_dispatchThreadsPerTile :: proc(self: ^RenderCommandEncoder, threadsPerTile: Size) {
|
|
msgSend(nil, self, "dispatchThreadsPerTile:", threadsPerTile)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_")
|
|
RenderCommandEncoder_drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_")
|
|
RenderCommandEncoder_drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, controlPointIndexBuffer: ^NS.Object, controlPointIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) {
|
|
msgSend(nil, self, "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_")
|
|
RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_")
|
|
RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object) {
|
|
msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_")
|
|
RenderCommandEncoder_drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexCount: ^NS.Object, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseVertex: ^NS.Object, baseInstance: ^NS.Object) {
|
|
msgSend(nil, self, "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:", primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_")
|
|
RenderCommandEncoder_drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indexType: IndexType, indexBuffer: ^NS.Object, indexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:", primitiveType, indexType, indexBuffer, indexBufferOffset, indirectBuffer, indirectBufferOffset)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_")
|
|
RenderCommandEncoder_drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:", numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_")
|
|
RenderCommandEncoder_drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_ :: proc(self: ^RenderCommandEncoder, numberOfPatchControlPoints: ^NS.Object, patchStart: ^NS.Object, patchCount: ^NS.Object, patchIndexBuffer: ^NS.Object, patchIndexBufferOffset: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) {
|
|
msgSend(nil, self, "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:", numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_indirectBuffer_indirectBufferOffset_")
|
|
RenderCommandEncoder_drawPrimitives_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "drawPrimitives:indirectBuffer:indirectBufferOffset:", primitiveType, indirectBuffer, indirectBufferOffset)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_")
|
|
RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object) {
|
|
msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:", primitiveType, vertexStart, vertexCount)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_")
|
|
RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object) {
|
|
msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:", primitiveType, vertexStart, vertexCount, instanceCount)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_")
|
|
RenderCommandEncoder_drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_ :: proc(self: ^RenderCommandEncoder, primitiveType: PrimitiveType, vertexStart: ^NS.Object, vertexCount: ^NS.Object, instanceCount: ^NS.Object, baseInstance: ^NS.Object) {
|
|
msgSend(nil, self, "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:", primitiveType, vertexStart, vertexCount, instanceCount, baseInstance)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_")
|
|
RenderCommandEncoder_executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_ :: proc(self: ^RenderCommandEncoder, indirectCommandbuffer: ^NS.Object, indirectRangeBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:", indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="executeCommandsInBuffer_withRange_")
|
|
RenderCommandEncoder_executeCommandsInBuffer_withRange_ :: proc(self: ^RenderCommandEncoder, indirectCommandBuffer: ^NS.Object, executionRange: NS.Range) {
|
|
msgSend(nil, self, "executeCommandsInBuffer:withRange:", indirectCommandBuffer, executionRange)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithResources")
|
|
RenderCommandEncoder_memoryBarrierWithResources :: proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, after: RenderStages, before: RenderStages) {
|
|
msgSend(nil, self, "memoryBarrierWithResources:count:afterStages:beforeStages:", resources, count, after, before)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="memoryBarrierWithScope")
|
|
RenderCommandEncoder_memoryBarrierWithScope :: proc(self: ^RenderCommandEncoder, scope: BarrierScope, after: RenderStages, before: RenderStages) {
|
|
msgSend(nil, self, "memoryBarrierWithScope:afterStages:beforeStages:", scope, after, before)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="sampleCountersInBuffer")
|
|
RenderCommandEncoder_sampleCountersInBuffer :: proc(self: ^RenderCommandEncoder, sampleBuffer: ^NS.Object, sampleIndex: ^NS.Object, barrier: BOOL) {
|
|
msgSend(nil, self, "sampleCountersInBuffer:atSampleIndex:withBarrier:", sampleBuffer, sampleIndex, barrier)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setBlendColorRed")
|
|
RenderCommandEncoder_setBlendColorRed :: proc(self: ^RenderCommandEncoder, red: f32, green: f32, blue: f32, alpha: f32) {
|
|
msgSend(nil, self, "setBlendColorRed:green:blue:alpha:", red, green, blue, alpha)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setColorStoreAction")
|
|
RenderCommandEncoder_setColorStoreAction :: proc(self: ^RenderCommandEncoder, storeAction: StoreAction, colorAttachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setColorStoreAction:atIndex:", storeAction, colorAttachmentIndex)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setColorStoreActionOptions")
|
|
RenderCommandEncoder_setColorStoreActionOptions :: proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions, colorAttachmentIndex: ^NS.Object) {
|
|
msgSend(nil, self, "setColorStoreActionOptions:atIndex:", storeActionOptions, colorAttachmentIndex)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setCullMode")
|
|
RenderCommandEncoder_setCullMode :: proc(self: ^RenderCommandEncoder, cullMode: CullMode) {
|
|
msgSend(nil, self, "setCullMode:", cullMode)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setDepthBias")
|
|
RenderCommandEncoder_setDepthBias :: proc(self: ^RenderCommandEncoder, depthBias: f32, slopeScale: f32, clamp: f32) {
|
|
msgSend(nil, self, "setDepthBias:slopeScale:clamp:", depthBias, slopeScale, clamp)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setDepthClipMode")
|
|
RenderCommandEncoder_setDepthClipMode :: proc(self: ^RenderCommandEncoder, depthClipMode: DepthClipMode) {
|
|
msgSend(nil, self, "setDepthClipMode:", depthClipMode)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setDepthStencilState")
|
|
RenderCommandEncoder_setDepthStencilState :: proc(self: ^RenderCommandEncoder, depthStencilState: ^NS.Object) {
|
|
msgSend(nil, self, "setDepthStencilState:", depthStencilState)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setDepthStoreAction")
|
|
RenderCommandEncoder_setDepthStoreAction :: proc(self: ^RenderCommandEncoder, storeAction: StoreAction) {
|
|
msgSend(nil, self, "setDepthStoreAction:", storeAction)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setDepthStoreActionOptions")
|
|
RenderCommandEncoder_setDepthStoreActionOptions :: proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) {
|
|
msgSend(nil, self, "setDepthStoreActionOptions:", storeActionOptions)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffer")
|
|
RenderCommandEncoder_setFragmentBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setFragmentBuffer:offset:atIndex:", buffer, offset, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentBufferOffset")
|
|
RenderCommandEncoder_setFragmentBufferOffset :: proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setFragmentBufferOffset:atIndex:", offset, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentBuffers")
|
|
RenderCommandEncoder_setFragmentBuffers :: proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) {
|
|
msgSend(nil, self, "setFragmentBuffers:offsets:withRange:", buffers, offsets, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentBytes")
|
|
RenderCommandEncoder_setFragmentBytes :: proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setFragmentBytes:length:atIndex:", bytes, length, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_atIndex_")
|
|
RenderCommandEncoder_setFragmentSamplerState_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setFragmentSamplerState:atIndex:", sampler, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_")
|
|
RenderCommandEncoder_setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) {
|
|
msgSend(nil, self, "setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_")
|
|
RenderCommandEncoder_setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) {
|
|
msgSend(nil, self, "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentSamplerStates_withRange_")
|
|
RenderCommandEncoder_setFragmentSamplerStates_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setFragmentSamplerStates:withRange:", samplers, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentTexture")
|
|
RenderCommandEncoder_setFragmentTexture :: proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setFragmentTexture:atIndex:", texture, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFragmentTextures")
|
|
RenderCommandEncoder_setFragmentTextures :: proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setFragmentTextures:withRange:", textures, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setFrontFacingWinding")
|
|
RenderCommandEncoder_setFrontFacingWinding :: proc(self: ^RenderCommandEncoder, frontFacingWinding: Winding) {
|
|
msgSend(nil, self, "setFrontFacingWinding:", frontFacingWinding)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setRenderPipelineState")
|
|
RenderCommandEncoder_setRenderPipelineState :: proc(self: ^RenderCommandEncoder, pipelineState: ^NS.Object) {
|
|
msgSend(nil, self, "setRenderPipelineState:", pipelineState)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setScissorRect")
|
|
RenderCommandEncoder_setScissorRect :: proc(self: ^RenderCommandEncoder, rect: ScissorRect) {
|
|
msgSend(nil, self, "setScissorRect:", rect)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setScissorRects")
|
|
RenderCommandEncoder_setScissorRects :: proc(self: ^RenderCommandEncoder, scissorRects: ^ScissorRect, count: ^NS.Object) {
|
|
msgSend(nil, self, "setScissorRects:count:", scissorRects, count)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setStencilFrontReferenceValue")
|
|
RenderCommandEncoder_setStencilFrontReferenceValue :: proc(self: ^RenderCommandEncoder, frontReferenceValue: u32, backReferenceValue: u32) {
|
|
msgSend(nil, self, "setStencilFrontReferenceValue:backReferenceValue:", frontReferenceValue, backReferenceValue)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setStencilReferenceValue")
|
|
RenderCommandEncoder_setStencilReferenceValue :: proc(self: ^RenderCommandEncoder, referenceValue: u32) {
|
|
msgSend(nil, self, "setStencilReferenceValue:", referenceValue)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setStencilStoreAction")
|
|
RenderCommandEncoder_setStencilStoreAction :: proc(self: ^RenderCommandEncoder, storeAction: StoreAction) {
|
|
msgSend(nil, self, "setStencilStoreAction:", storeAction)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setStencilStoreActionOptions")
|
|
RenderCommandEncoder_setStencilStoreActionOptions :: proc(self: ^RenderCommandEncoder, storeActionOptions: StoreActionOptions) {
|
|
msgSend(nil, self, "setStencilStoreActionOptions:", storeActionOptions)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorBuffer")
|
|
RenderCommandEncoder_setTessellationFactorBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, instanceStride: ^NS.Object) {
|
|
msgSend(nil, self, "setTessellationFactorBuffer:offset:instanceStride:", buffer, offset, instanceStride)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTessellationFactorScale")
|
|
RenderCommandEncoder_setTessellationFactorScale :: proc(self: ^RenderCommandEncoder, scale: f32) {
|
|
msgSend(nil, self, "setTessellationFactorScale:", scale)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setThreadgroupMemoryLength")
|
|
RenderCommandEncoder_setThreadgroupMemoryLength :: proc(self: ^RenderCommandEncoder, length: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setThreadgroupMemoryLength:offset:atIndex:", length, offset, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileBuffer")
|
|
RenderCommandEncoder_setTileBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setTileBuffer:offset:atIndex:", buffer, offset, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileBufferOffset")
|
|
RenderCommandEncoder_setTileBufferOffset :: proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setTileBufferOffset:atIndex:", offset, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileBuffers")
|
|
RenderCommandEncoder_setTileBuffers :: proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) {
|
|
msgSend(nil, self, "setTileBuffers:offsets:withRange:", buffers, offsets, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileBytes")
|
|
RenderCommandEncoder_setTileBytes :: proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setTileBytes:length:atIndex:", bytes, length, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_atIndex_")
|
|
RenderCommandEncoder_setTileSamplerState_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setTileSamplerState:atIndex:", sampler, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_")
|
|
RenderCommandEncoder_setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) {
|
|
msgSend(nil, self, "setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_")
|
|
RenderCommandEncoder_setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) {
|
|
msgSend(nil, self, "setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileSamplerStates_withRange_")
|
|
RenderCommandEncoder_setTileSamplerStates_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setTileSamplerStates:withRange:", samplers, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileTexture")
|
|
RenderCommandEncoder_setTileTexture :: proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setTileTexture:atIndex:", texture, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTileTextures")
|
|
RenderCommandEncoder_setTileTextures :: proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setTileTextures:withRange:", textures, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setTriangleFillMode")
|
|
RenderCommandEncoder_setTriangleFillMode :: proc(self: ^RenderCommandEncoder, fillMode: TriangleFillMode) {
|
|
msgSend(nil, self, "setTriangleFillMode:", fillMode)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexAmplificationCount")
|
|
RenderCommandEncoder_setVertexAmplificationCount :: proc(self: ^RenderCommandEncoder, count: ^NS.Object, viewMappings: ^VertexAmplificationViewMapping) {
|
|
msgSend(nil, self, "setVertexAmplificationCount:viewMappings:", count, viewMappings)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexBuffer")
|
|
RenderCommandEncoder_setVertexBuffer :: proc(self: ^RenderCommandEncoder, buffer: ^NS.Object, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setVertexBuffer:offset:atIndex:", buffer, offset, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexBufferOffset")
|
|
RenderCommandEncoder_setVertexBufferOffset :: proc(self: ^RenderCommandEncoder, offset: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setVertexBufferOffset:atIndex:", offset, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexBuffers")
|
|
RenderCommandEncoder_setVertexBuffers :: proc(self: ^RenderCommandEncoder, buffers: ^^NS.Object, offsets: NS.Integer, range: NS.Range) {
|
|
msgSend(nil, self, "setVertexBuffers:offsets:withRange:", buffers, offsets, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexBytes")
|
|
RenderCommandEncoder_setVertexBytes :: proc(self: ^RenderCommandEncoder, bytes: rawptr, length: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setVertexBytes:length:atIndex:", bytes, length, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_atIndex_")
|
|
RenderCommandEncoder_setVertexSamplerState_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setVertexSamplerState:atIndex:", sampler, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_")
|
|
RenderCommandEncoder_setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_ :: proc(self: ^RenderCommandEncoder, sampler: ^NS.Object, lodMinClamp: f32, lodMaxClamp: f32, index: ^NS.Object) {
|
|
msgSend(nil, self, "setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:", sampler, lodMinClamp, lodMaxClamp, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_")
|
|
RenderCommandEncoder_setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, lodMinClamps: ^f32, lodMaxClamps: ^f32, range: NS.Range) {
|
|
msgSend(nil, self, "setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:", samplers, lodMinClamps, lodMaxClamps, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexSamplerStates_withRange_")
|
|
RenderCommandEncoder_setVertexSamplerStates_withRange_ :: proc(self: ^RenderCommandEncoder, samplers: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setVertexSamplerStates:withRange:", samplers, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexTexture")
|
|
RenderCommandEncoder_setVertexTexture :: proc(self: ^RenderCommandEncoder, texture: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setVertexTexture:atIndex:", texture, index)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVertexTextures")
|
|
RenderCommandEncoder_setVertexTextures :: proc(self: ^RenderCommandEncoder, textures: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setVertexTextures:withRange:", textures, range)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setViewport")
|
|
RenderCommandEncoder_setViewport :: proc(self: ^RenderCommandEncoder, viewport: Viewport) {
|
|
msgSend(nil, self, "setViewport:", viewport)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setViewports")
|
|
RenderCommandEncoder_setViewports :: proc(self: ^RenderCommandEncoder, viewports: ^Viewport, count: ^NS.Object) {
|
|
msgSend(nil, self, "setViewports:count:", viewports, count)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="setVisibilityResultMode")
|
|
RenderCommandEncoder_setVisibilityResultMode :: proc(self: ^RenderCommandEncoder, mode: VisibilityResultMode, offset: ^NS.Object) {
|
|
msgSend(nil, self, "setVisibilityResultMode:offset:", mode, offset)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="textureBarrier")
|
|
RenderCommandEncoder_textureBarrier :: proc(self: ^RenderCommandEncoder) {
|
|
msgSend(nil, self, "textureBarrier")
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="tileHeight")
|
|
RenderCommandEncoder_tileHeight :: proc(self: ^RenderCommandEncoder) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "tileHeight")
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="tileWidth")
|
|
RenderCommandEncoder_tileWidth :: proc(self: ^RenderCommandEncoder) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "tileWidth")
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="updateFence")
|
|
RenderCommandEncoder_updateFence :: proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) {
|
|
msgSend(nil, self, "updateFence:afterStages:", fence, stages)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="useHeap")
|
|
RenderCommandEncoder_useHeap :: proc(self: ^RenderCommandEncoder, heap: ^NS.Object) {
|
|
msgSend(nil, self, "useHeap:", heap)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="useHeap_stages_")
|
|
RenderCommandEncoder_useHeap_stages_ :: proc(self: ^RenderCommandEncoder, heap: ^NS.Object, stages: RenderStages) {
|
|
msgSend(nil, self, "useHeap:stages:", heap, stages)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="useHeaps")
|
|
RenderCommandEncoder_useHeaps :: proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object) {
|
|
msgSend(nil, self, "useHeaps:count:", heaps, count)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="useHeaps_count_stages_")
|
|
RenderCommandEncoder_useHeaps_count_stages_ :: proc(self: ^RenderCommandEncoder, heaps: ^^NS.Object, count: ^NS.Object, stages: RenderStages) {
|
|
msgSend(nil, self, "useHeaps:count:stages:", heaps, count, stages)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="useResource")
|
|
RenderCommandEncoder_useResource :: proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage) {
|
|
msgSend(nil, self, "useResource:usage:", resource, usage)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="useResource_usage_stages_")
|
|
RenderCommandEncoder_useResource_usage_stages_ :: proc(self: ^RenderCommandEncoder, resource: ^NS.Object, usage: ResourceUsage, stages: RenderStages) {
|
|
msgSend(nil, self, "useResource:usage:stages:", resource, usage, stages)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="useResources")
|
|
RenderCommandEncoder_useResources :: proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage) {
|
|
msgSend(nil, self, "useResources:count:usage:", resources, count, usage)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="useResources_count_usage_stages_")
|
|
RenderCommandEncoder_useResources_count_usage_stages_ :: proc(self: ^RenderCommandEncoder, resources: ^^NS.Object, count: ^NS.Object, usage: ResourceUsage, stages: RenderStages) {
|
|
msgSend(nil, self, "useResources:count:usage:stages:", resources, count, usage, stages)
|
|
}
|
|
@(objc_type=RenderCommandEncoder, objc_name="waitForFence")
|
|
RenderCommandEncoder_waitForFence :: proc(self: ^RenderCommandEncoder, fence: ^NS.Object, stages: RenderStages) {
|
|
msgSend(nil, self, "waitForFence:beforeStages:", fence, stages)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
RenderPipelineState
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
imageblockMemoryLengthForDimensions
|
|
imageblockSampleLength
|
|
label
|
|
maxTotalThreadsPerThreadgroup
|
|
supportIndirectCommandBuffers
|
|
threadgroupSizeMatchesTileSize
|
|
*/
|
|
@(objc_class="MTLRenderPipelineState")
|
|
RenderPipelineState :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=RenderPipelineState, objc_name="device")
|
|
RenderPipelineState_device :: proc(self: ^RenderPipelineState) -> ^RenderPipelineState {
|
|
return msgSend(^RenderPipelineState, self, "device")
|
|
}
|
|
@(objc_type=RenderPipelineState, objc_name="imageblockMemoryLengthForDimensions")
|
|
RenderPipelineState_imageblockMemoryLengthForDimensions :: proc(self: ^RenderPipelineState, imageblockDimensions: Size) -> ^RenderPipelineState {
|
|
return msgSend(^RenderPipelineState, self, "imageblockMemoryLengthForDimensions:", imageblockDimensions)
|
|
}
|
|
@(objc_type=RenderPipelineState, objc_name="imageblockSampleLength")
|
|
RenderPipelineState_imageblockSampleLength :: proc(self: ^RenderPipelineState) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "imageblockSampleLength")
|
|
}
|
|
@(objc_type=RenderPipelineState, objc_name="label")
|
|
RenderPipelineState_label :: proc(self: ^RenderPipelineState) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=RenderPipelineState, objc_name="maxTotalThreadsPerThreadgroup")
|
|
RenderPipelineState_maxTotalThreadsPerThreadgroup :: proc(self: ^RenderPipelineState) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "maxTotalThreadsPerThreadgroup")
|
|
}
|
|
@(objc_type=RenderPipelineState, objc_name="supportIndirectCommandBuffers")
|
|
RenderPipelineState_supportIndirectCommandBuffers :: proc(self: ^RenderPipelineState) -> BOOL {
|
|
return msgSend(BOOL, self, "supportIndirectCommandBuffers")
|
|
}
|
|
@(objc_type=RenderPipelineState, objc_name="threadgroupSizeMatchesTileSize")
|
|
RenderPipelineState_threadgroupSizeMatchesTileSize :: proc(self: ^RenderPipelineState) -> BOOL {
|
|
return msgSend(BOOL, self, "threadgroupSizeMatchesTileSize")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Resource
|
|
Class Methods:
|
|
Methods:
|
|
allocatedSize
|
|
cpuCacheMode
|
|
device
|
|
hazardTrackingMode
|
|
heap
|
|
heapOffset
|
|
isAliasable
|
|
label
|
|
makeAliasable
|
|
resourceOptions
|
|
setLabel
|
|
setPurgeableState
|
|
storageMode
|
|
*/
|
|
@(objc_class="MTLResource")
|
|
Resource :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Resource, objc_name="allocatedSize")
|
|
Resource_allocatedSize :: proc(self: ^Resource) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "allocatedSize")
|
|
}
|
|
@(objc_type=Resource, objc_name="cpuCacheMode")
|
|
Resource_cpuCacheMode :: proc(self: ^Resource) -> CPUCacheMode {
|
|
return msgSend(CPUCacheMode, self, "cpuCacheMode")
|
|
}
|
|
@(objc_type=Resource, objc_name="device")
|
|
Resource_device :: proc(self: ^Resource) -> ^Resource {
|
|
return msgSend(^Resource, self, "device")
|
|
}
|
|
@(objc_type=Resource, objc_name="hazardTrackingMode")
|
|
Resource_hazardTrackingMode :: proc(self: ^Resource) -> HazardTrackingMode {
|
|
return msgSend(HazardTrackingMode, self, "hazardTrackingMode")
|
|
}
|
|
@(objc_type=Resource, objc_name="heap")
|
|
Resource_heap :: proc(self: ^Resource) -> ^Resource {
|
|
return msgSend(^Resource, self, "heap")
|
|
}
|
|
@(objc_type=Resource, objc_name="heapOffset")
|
|
Resource_heapOffset :: proc(self: ^Resource) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "heapOffset")
|
|
}
|
|
@(objc_type=Resource, objc_name="isAliasable")
|
|
Resource_isAliasable :: proc(self: ^Resource) -> BOOL {
|
|
return msgSend(BOOL, self, "isAliasable")
|
|
}
|
|
@(objc_type=Resource, objc_name="label")
|
|
Resource_label :: proc(self: ^Resource) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
@(objc_type=Resource, objc_name="makeAliasable")
|
|
Resource_makeAliasable :: proc(self: ^Resource) {
|
|
msgSend(nil, self, "makeAliasable")
|
|
}
|
|
@(objc_type=Resource, objc_name="resourceOptions")
|
|
Resource_resourceOptions :: proc(self: ^Resource) -> ResourceOptions {
|
|
return msgSend(ResourceOptions, self, "resourceOptions")
|
|
}
|
|
@(objc_type=Resource, objc_name="setLabel")
|
|
Resource_setLabel :: proc(self: ^Resource, label: ^NS.String) {
|
|
msgSend(nil, self, "setLabel:", label)
|
|
}
|
|
@(objc_type=Resource, objc_name="setPurgeableState")
|
|
Resource_setPurgeableState :: proc(self: ^Resource, state: PurgeableState) -> PurgeableState {
|
|
return msgSend(PurgeableState, self, "setPurgeableState:", state)
|
|
}
|
|
@(objc_type=Resource, objc_name="storageMode")
|
|
Resource_storageMode :: proc(self: ^Resource) -> StorageMode {
|
|
return msgSend(StorageMode, self, "storageMode")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
ResourceStateCommandEncoder
|
|
Class Methods:
|
|
Methods:
|
|
updateFence
|
|
updateTextureMapping
|
|
updateTextureMapping
|
|
updateTextureMappings
|
|
waitForFence
|
|
*/
|
|
@(objc_class="MTLResourceStateCommandEncoder")
|
|
ResourceStateCommandEncoder :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=ResourceStateCommandEncoder, objc_name="updateFence")
|
|
ResourceStateCommandEncoder_updateFence :: proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) {
|
|
msgSend(nil, self, "updateFence:", fence)
|
|
}
|
|
@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_")
|
|
ResourceStateCommandEncoder_updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_ :: proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, indirectBuffer: ^NS.Object, indirectBufferOffset: ^NS.Object) {
|
|
msgSend(nil, self, "updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:", texture, mode, indirectBuffer, indirectBufferOffset)
|
|
}
|
|
@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMapping_mode_region_mipLevel_slice_")
|
|
ResourceStateCommandEncoder_updateTextureMapping_mode_region_mipLevel_slice_ :: proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, region: Region, mipLevel: NS.Integer, slice: NS.Integer) {
|
|
msgSend(nil, self, "updateTextureMapping:mode:region:mipLevel:slice:", texture, mode, region, mipLevel, slice)
|
|
}
|
|
@(objc_type=ResourceStateCommandEncoder, objc_name="updateTextureMappings")
|
|
ResourceStateCommandEncoder_updateTextureMappings :: proc(self: ^ResourceStateCommandEncoder, texture: ^NS.Object, mode: SparseTextureMappingMode, regions: ^Region, mipLevels: NS.Integer, slices: NS.Integer, numRegions: ^NS.Object) {
|
|
msgSend(nil, self, "updateTextureMappings:mode:regions:mipLevels:slices:numRegions:", texture, mode, regions, mipLevels, slices, numRegions)
|
|
}
|
|
@(objc_type=ResourceStateCommandEncoder, objc_name="waitForFence")
|
|
ResourceStateCommandEncoder_waitForFence :: proc(self: ^ResourceStateCommandEncoder, fence: ^NS.Object) {
|
|
msgSend(nil, self, "waitForFence:", fence)
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
SamplerState
|
|
Class Methods:
|
|
Methods:
|
|
device
|
|
label
|
|
*/
|
|
@(objc_class="MTLSamplerState")
|
|
SamplerState :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=SamplerState, objc_name="device")
|
|
SamplerState_device :: proc(self: ^SamplerState) -> ^SamplerState {
|
|
return msgSend(^SamplerState, self, "device")
|
|
}
|
|
@(objc_type=SamplerState, objc_name="label")
|
|
SamplerState_label :: proc(self: ^SamplerState) -> ^NS.String {
|
|
return msgSend(^NS.String, self, "label")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
SharedEvent
|
|
Class Methods:
|
|
Methods:
|
|
newSharedEventHandle
|
|
notifyListener
|
|
setSignaledValue
|
|
signaledValue
|
|
*/
|
|
@(objc_class="MTLSharedEvent")
|
|
SharedEvent :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=SharedEvent, objc_name="newSharedEventHandle")
|
|
SharedEvent_newSharedEventHandle :: proc(self: ^SharedEvent) -> ^SharedEventHandle {
|
|
return msgSend(^SharedEventHandle, self, "newSharedEventHandle")
|
|
}
|
|
@(objc_type=SharedEvent, objc_name="notifyListener")
|
|
SharedEvent_notifyListener :: proc(self: ^SharedEvent, listener: ^SharedEventListener, value: u64, block: SharedEventNotificationBlock) {
|
|
msgSend(nil, self, "notifyListener:atValue:block:", listener, value, block)
|
|
}
|
|
@(objc_type=SharedEvent, objc_name="setSignaledValue")
|
|
SharedEvent_setSignaledValue :: proc(self: ^SharedEvent, signaledValue: u64) {
|
|
msgSend(nil, self, "setSignaledValue:", signaledValue)
|
|
}
|
|
@(objc_type=SharedEvent, objc_name="signaledValue")
|
|
SharedEvent_signaledValue :: proc(self: ^SharedEvent) -> u64 {
|
|
return msgSend(u64, self, "signaledValue")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
Texture
|
|
Class Methods:
|
|
Methods:
|
|
allowGPUOptimizedContents
|
|
arrayLength
|
|
buffer
|
|
bufferBytesPerRow
|
|
bufferOffset
|
|
depth
|
|
firstMipmapInTail
|
|
getBytes
|
|
getBytes
|
|
height
|
|
iosurface
|
|
iosurfacePlane
|
|
isFramebufferOnly
|
|
isShareable
|
|
isSparse
|
|
mipmapLevelCount
|
|
newRemoteTextureViewForDevice
|
|
newSharedTextureHandle
|
|
newTextureViewWithPixelFormat
|
|
newTextureViewWithPixelFormat
|
|
newTextureViewWithPixelFormat
|
|
parentRelativeLevel
|
|
parentRelativeSlice
|
|
parentTexture
|
|
pixelFormat
|
|
remoteStorageTexture
|
|
replaceRegion
|
|
replaceRegion
|
|
rootResource
|
|
sampleCount
|
|
swizzle
|
|
tailSizeInBytes
|
|
textureType
|
|
usage
|
|
width
|
|
*/
|
|
@(objc_class="MTLTexture")
|
|
Texture :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=Texture, objc_name="allowGPUOptimizedContents")
|
|
Texture_allowGPUOptimizedContents :: proc(self: ^Texture) -> BOOL {
|
|
return msgSend(BOOL, self, "allowGPUOptimizedContents")
|
|
}
|
|
@(objc_type=Texture, objc_name="arrayLength")
|
|
Texture_arrayLength :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "arrayLength")
|
|
}
|
|
@(objc_type=Texture, objc_name="buffer")
|
|
Texture_buffer :: proc(self: ^Texture) -> ^Texture {
|
|
return msgSend(^Texture, self, "buffer")
|
|
}
|
|
@(objc_type=Texture, objc_name="bufferBytesPerRow")
|
|
Texture_bufferBytesPerRow :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "bufferBytesPerRow")
|
|
}
|
|
@(objc_type=Texture, objc_name="bufferOffset")
|
|
Texture_bufferOffset :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "bufferOffset")
|
|
}
|
|
@(objc_type=Texture, objc_name="depth")
|
|
Texture_depth :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "depth")
|
|
}
|
|
@(objc_type=Texture, objc_name="firstMipmapInTail")
|
|
Texture_firstMipmapInTail :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "firstMipmapInTail")
|
|
}
|
|
@(objc_type=Texture, objc_name="getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_")
|
|
Texture_getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_ :: proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object, region: Region, level: ^NS.Object, slice: ^NS.Object) {
|
|
msgSend(nil, self, "getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:", pixelBytes, bytesPerRow, bytesPerImage, region, level, slice)
|
|
}
|
|
@(objc_type=Texture, objc_name="getBytes_bytesPerRow_fromRegion_mipmapLevel_")
|
|
Texture_getBytes_bytesPerRow_fromRegion_mipmapLevel_ :: proc(self: ^Texture, pixelBytes: rawptr, bytesPerRow: ^NS.Object, region: Region, level: ^NS.Object) {
|
|
msgSend(nil, self, "getBytes:bytesPerRow:fromRegion:mipmapLevel:", pixelBytes, bytesPerRow, region, level)
|
|
}
|
|
@(objc_type=Texture, objc_name="height")
|
|
Texture_height :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "height")
|
|
}
|
|
@(objc_type=Texture, objc_name="iosurface")
|
|
Texture_iosurface :: proc(self: ^Texture) -> IOSurfaceRef {
|
|
return msgSend(IOSurfaceRef, self, "iosurface")
|
|
}
|
|
@(objc_type=Texture, objc_name="iosurfacePlane")
|
|
Texture_iosurfacePlane :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "iosurfacePlane")
|
|
}
|
|
@(objc_type=Texture, objc_name="isFramebufferOnly")
|
|
Texture_isFramebufferOnly :: proc(self: ^Texture) -> BOOL {
|
|
return msgSend(BOOL, self, "isFramebufferOnly")
|
|
}
|
|
@(objc_type=Texture, objc_name="isShareable")
|
|
Texture_isShareable :: proc(self: ^Texture) -> BOOL {
|
|
return msgSend(BOOL, self, "isShareable")
|
|
}
|
|
@(objc_type=Texture, objc_name="isSparse")
|
|
Texture_isSparse :: proc(self: ^Texture) -> BOOL {
|
|
return msgSend(BOOL, self, "isSparse")
|
|
}
|
|
@(objc_type=Texture, objc_name="mipmapLevelCount")
|
|
Texture_mipmapLevelCount :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "mipmapLevelCount")
|
|
}
|
|
@(objc_type=Texture, objc_name="newRemoteTextureViewForDevice")
|
|
Texture_newRemoteTextureViewForDevice :: proc(self: ^Texture, device: ^NS.Object) -> ^Texture {
|
|
return msgSend(^Texture, self, "newRemoteTextureViewForDevice:", device)
|
|
}
|
|
@(objc_type=Texture, objc_name="newSharedTextureHandle")
|
|
Texture_newSharedTextureHandle :: proc(self: ^Texture) -> ^SharedTextureHandle {
|
|
return msgSend(^SharedTextureHandle, self, "newSharedTextureHandle")
|
|
}
|
|
@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat")
|
|
Texture_newTextureViewWithPixelFormat :: proc(self: ^Texture, pixelFormat: PixelFormat) -> ^Texture {
|
|
return msgSend(^Texture, self, "newTextureViewWithPixelFormat:", pixelFormat)
|
|
}
|
|
@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat_textureType_levels_slices_")
|
|
Texture_newTextureViewWithPixelFormat_textureType_levels_slices_ :: proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range) -> ^Texture {
|
|
return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:", pixelFormat, textureType, levelRange, sliceRange)
|
|
}
|
|
@(objc_type=Texture, objc_name="newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_")
|
|
Texture_newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_ :: proc(self: ^Texture, pixelFormat: PixelFormat, textureType: TextureType, levelRange: NS.Range, sliceRange: NS.Range, swizzle: TextureSwizzleChannels) -> ^Texture {
|
|
return msgSend(^Texture, self, "newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:", pixelFormat, textureType, levelRange, sliceRange, swizzle)
|
|
}
|
|
@(objc_type=Texture, objc_name="parentRelativeLevel")
|
|
Texture_parentRelativeLevel :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "parentRelativeLevel")
|
|
}
|
|
@(objc_type=Texture, objc_name="parentRelativeSlice")
|
|
Texture_parentRelativeSlice :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "parentRelativeSlice")
|
|
}
|
|
@(objc_type=Texture, objc_name="parentTexture")
|
|
Texture_parentTexture :: proc(self: ^Texture) -> ^Texture {
|
|
return msgSend(^Texture, self, "parentTexture")
|
|
}
|
|
@(objc_type=Texture, objc_name="pixelFormat")
|
|
Texture_pixelFormat :: proc(self: ^Texture) -> PixelFormat {
|
|
return msgSend(PixelFormat, self, "pixelFormat")
|
|
}
|
|
@(objc_type=Texture, objc_name="remoteStorageTexture")
|
|
Texture_remoteStorageTexture :: proc(self: ^Texture) -> ^Texture {
|
|
return msgSend(^Texture, self, "remoteStorageTexture")
|
|
}
|
|
@(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_")
|
|
Texture_replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_ :: proc(self: ^Texture, region: Region, level: ^NS.Object, slice: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object, bytesPerImage: ^NS.Object) {
|
|
msgSend(nil, self, "replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:", region, level, slice, pixelBytes, bytesPerRow, bytesPerImage)
|
|
}
|
|
@(objc_type=Texture, objc_name="replaceRegion_mipmapLevel_withBytes_bytesPerRow_")
|
|
Texture_replaceRegion_mipmapLevel_withBytes_bytesPerRow_ :: proc(self: ^Texture, region: Region, level: ^NS.Object, pixelBytes: rawptr, bytesPerRow: ^NS.Object) {
|
|
msgSend(nil, self, "replaceRegion:mipmapLevel:withBytes:bytesPerRow:", region, level, pixelBytes, bytesPerRow)
|
|
}
|
|
@(objc_type=Texture, objc_name="rootResource")
|
|
Texture_rootResource :: proc(self: ^Texture) -> ^Texture {
|
|
return msgSend(^Texture, self, "rootResource")
|
|
}
|
|
@(objc_type=Texture, objc_name="sampleCount")
|
|
Texture_sampleCount :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "sampleCount")
|
|
}
|
|
@(objc_type=Texture, objc_name="swizzle")
|
|
Texture_swizzle :: proc(self: ^Texture) -> TextureSwizzleChannels {
|
|
return msgSend(TextureSwizzleChannels, self, "swizzle")
|
|
}
|
|
@(objc_type=Texture, objc_name="tailSizeInBytes")
|
|
Texture_tailSizeInBytes :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "tailSizeInBytes")
|
|
}
|
|
@(objc_type=Texture, objc_name="textureType")
|
|
Texture_textureType :: proc(self: ^Texture) -> TextureType {
|
|
return msgSend(TextureType, self, "textureType")
|
|
}
|
|
@(objc_type=Texture, objc_name="usage")
|
|
Texture_usage :: proc(self: ^Texture) -> TextureUsage {
|
|
return msgSend(TextureUsage, self, "usage")
|
|
}
|
|
@(objc_type=Texture, objc_name="width")
|
|
Texture_width :: proc(self: ^Texture) -> NS.Integer {
|
|
return msgSend(NS.Integer, self, "width")
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
Class:
|
|
VisibleFunctionTable
|
|
Class Methods:
|
|
Methods:
|
|
setFunction
|
|
setFunctions
|
|
*/
|
|
@(objc_class="MTLVisibleFunctionTable")
|
|
VisibleFunctionTable :: struct { using _: NS.Object }
|
|
|
|
@(objc_type=VisibleFunctionTable, objc_name="setFunction")
|
|
VisibleFunctionTable_setFunction :: proc(self: ^VisibleFunctionTable, function: ^NS.Object, index: ^NS.Object) {
|
|
msgSend(nil, self, "setFunction:atIndex:", function, index)
|
|
}
|
|
@(objc_type=VisibleFunctionTable, objc_name="setFunctions")
|
|
VisibleFunctionTable_setFunctions :: proc(self: ^VisibleFunctionTable, functions: ^^NS.Object, range: NS.Range) {
|
|
msgSend(nil, self, "setFunctions:withRange:", functions, range)
|
|
}
|