whisper-large-v3-mlx
/
lib
/python3.11
/site-packages
/mlx
/include
/metal_cpp
/Metal
/MTLHeaderBridge.hpp
//------------------------------------------------------------------------------------------------------------------------------------------------------------- | |
// | |
// Metal/MTLHeaderBridge.hpp | |
// | |
// Copyright 2020-2023 Apple Inc. | |
// | |
// Licensed under the Apache License, Version 2.0 (the "License"); | |
// you may not use this file except in compliance with the License. | |
// You may obtain a copy of the License at | |
// | |
// http://www.apache.org/licenses/LICENSE-2.0 | |
// | |
// Unless required by applicable law or agreed to in writing, software | |
// distributed under the License is distributed on an "AS IS" BASIS, | |
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
// See the License for the specific language governing permissions and | |
// limitations under the License. | |
// | |
//------------------------------------------------------------------------------------------------------------------------------------------------------------- | |
namespace MTL::Private::Class | |
{ | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureBoundingBoxGeometryDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureCurveGeometryDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureGeometryDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureMotionCurveGeometryDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureMotionTriangleGeometryDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructurePassDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureTriangleGeometryDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLArchitecture); | |
_MTL_PRIVATE_DEF_CLS(MTLArgument); | |
_MTL_PRIVATE_DEF_CLS(MTLArgumentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLArrayType); | |
_MTL_PRIVATE_DEF_CLS(MTLAttribute); | |
_MTL_PRIVATE_DEF_CLS(MTLAttributeDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLAttributeDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLBinaryArchiveDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLBlitPassDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLBlitPassSampleBufferAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLBlitPassSampleBufferAttachmentDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLBufferLayoutDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLBufferLayoutDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLCaptureDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLCaptureManager); | |
_MTL_PRIVATE_DEF_CLS(MTLCommandBufferDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLCompileOptions); | |
_MTL_PRIVATE_DEF_CLS(MTLComputePassDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLComputePassSampleBufferAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLComputePassSampleBufferAttachmentDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLComputePipelineDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLComputePipelineReflection); | |
_MTL_PRIVATE_DEF_CLS(MTLCounterSampleBufferDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLDepthStencilDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLFunctionConstant); | |
_MTL_PRIVATE_DEF_CLS(MTLFunctionConstantValues); | |
_MTL_PRIVATE_DEF_CLS(MTLFunctionDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingAttributeAlwaysInline); | |
_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingFunctionNode); | |
_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingGraph); | |
_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingInputNode); | |
_MTL_PRIVATE_DEF_CLS(MTLHeapDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLIOCommandQueueDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLIndirectCommandBufferDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLIndirectInstanceAccelerationStructureDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLInstanceAccelerationStructureDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLIntersectionFunctionDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLIntersectionFunctionTableDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLLinkedFunctions); | |
_MTL_PRIVATE_DEF_CLS(MTLMeshRenderPipelineDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLMotionKeyframeData); | |
_MTL_PRIVATE_DEF_CLS(MTLPipelineBufferDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLPipelineBufferDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLPointerType); | |
_MTL_PRIVATE_DEF_CLS(MTLPrimitiveAccelerationStructureDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateLayerArray); | |
_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateLayerDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateMapDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateSampleArray); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPassAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPassColorAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPassColorAttachmentDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPassDepthAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPassDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPassSampleBufferAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPassSampleBufferAttachmentDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPassStencilAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineColorAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineColorAttachmentDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineFunctionsDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineReflection); | |
_MTL_PRIVATE_DEF_CLS(MTLResourceStatePassDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLSamplerDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLSharedEventHandle); | |
_MTL_PRIVATE_DEF_CLS(MTLSharedEventListener); | |
_MTL_PRIVATE_DEF_CLS(MTLSharedTextureHandle); | |
_MTL_PRIVATE_DEF_CLS(MTLStageInputOutputDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLStencilDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLStitchedLibraryDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLStructMember); | |
_MTL_PRIVATE_DEF_CLS(MTLStructType); | |
_MTL_PRIVATE_DEF_CLS(MTLTextureDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLTextureReferenceType); | |
_MTL_PRIVATE_DEF_CLS(MTLTileRenderPipelineColorAttachmentDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLTileRenderPipelineColorAttachmentDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLTileRenderPipelineDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLType); | |
_MTL_PRIVATE_DEF_CLS(MTLVertexAttribute); | |
_MTL_PRIVATE_DEF_CLS(MTLVertexAttributeDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLVertexAttributeDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLVertexBufferLayoutDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLVertexBufferLayoutDescriptorArray); | |
_MTL_PRIVATE_DEF_CLS(MTLVertexDescriptor); | |
_MTL_PRIVATE_DEF_CLS(MTLVisibleFunctionTableDescriptor); | |
} | |
namespace MTL::Private::Protocol | |
{ | |
_MTL_PRIVATE_DEF_PRO(MTLAccelerationStructure); | |
_MTL_PRIVATE_DEF_PRO(MTLAccelerationStructureCommandEncoder); | |
_MTL_PRIVATE_DEF_PRO(MTLArgumentEncoder); | |
_MTL_PRIVATE_DEF_PRO(MTLBinaryArchive); | |
_MTL_PRIVATE_DEF_PRO(MTLBinding); | |
_MTL_PRIVATE_DEF_PRO(MTLBlitCommandEncoder); | |
_MTL_PRIVATE_DEF_PRO(MTLBuffer); | |
_MTL_PRIVATE_DEF_PRO(MTLBufferBinding); | |
_MTL_PRIVATE_DEF_PRO(MTLCommandBuffer); | |
_MTL_PRIVATE_DEF_PRO(MTLCommandBufferEncoderInfo); | |
_MTL_PRIVATE_DEF_PRO(MTLCommandEncoder); | |
_MTL_PRIVATE_DEF_PRO(MTLCommandQueue); | |
_MTL_PRIVATE_DEF_PRO(MTLComputeCommandEncoder); | |
_MTL_PRIVATE_DEF_PRO(MTLComputePipelineState); | |
_MTL_PRIVATE_DEF_PRO(MTLCounter); | |
_MTL_PRIVATE_DEF_PRO(MTLCounterSampleBuffer); | |
_MTL_PRIVATE_DEF_PRO(MTLCounterSet); | |
_MTL_PRIVATE_DEF_PRO(MTLDepthStencilState); | |
_MTL_PRIVATE_DEF_PRO(MTLDevice); | |
_MTL_PRIVATE_DEF_PRO(MTLDrawable); | |
_MTL_PRIVATE_DEF_PRO(MTLDynamicLibrary); | |
_MTL_PRIVATE_DEF_PRO(MTLEvent); | |
_MTL_PRIVATE_DEF_PRO(MTLFence); | |
_MTL_PRIVATE_DEF_PRO(MTLFunction); | |
_MTL_PRIVATE_DEF_PRO(MTLFunctionHandle); | |
_MTL_PRIVATE_DEF_PRO(MTLFunctionLog); | |
_MTL_PRIVATE_DEF_PRO(MTLFunctionLogDebugLocation); | |
_MTL_PRIVATE_DEF_PRO(MTLFunctionStitchingAttribute); | |
_MTL_PRIVATE_DEF_PRO(MTLFunctionStitchingNode); | |
_MTL_PRIVATE_DEF_PRO(MTLHeap); | |
_MTL_PRIVATE_DEF_PRO(MTLIOCommandBuffer); | |
_MTL_PRIVATE_DEF_PRO(MTLIOCommandQueue); | |
_MTL_PRIVATE_DEF_PRO(MTLIOFileHandle); | |
_MTL_PRIVATE_DEF_PRO(MTLIOScratchBuffer); | |
_MTL_PRIVATE_DEF_PRO(MTLIOScratchBufferAllocator); | |
_MTL_PRIVATE_DEF_PRO(MTLIndirectCommandBuffer); | |
_MTL_PRIVATE_DEF_PRO(MTLIndirectComputeCommand); | |
_MTL_PRIVATE_DEF_PRO(MTLIndirectRenderCommand); | |
_MTL_PRIVATE_DEF_PRO(MTLIntersectionFunctionTable); | |
_MTL_PRIVATE_DEF_PRO(MTLLibrary); | |
_MTL_PRIVATE_DEF_PRO(MTLLogContainer); | |
_MTL_PRIVATE_DEF_PRO(MTLObjectPayloadBinding); | |
_MTL_PRIVATE_DEF_PRO(MTLParallelRenderCommandEncoder); | |
_MTL_PRIVATE_DEF_PRO(MTLRasterizationRateMap); | |
_MTL_PRIVATE_DEF_PRO(MTLRenderCommandEncoder); | |
_MTL_PRIVATE_DEF_PRO(MTLRenderPipelineState); | |
_MTL_PRIVATE_DEF_PRO(MTLResource); | |
_MTL_PRIVATE_DEF_PRO(MTLResourceStateCommandEncoder); | |
_MTL_PRIVATE_DEF_PRO(MTLSamplerState); | |
_MTL_PRIVATE_DEF_PRO(MTLSharedEvent); | |
_MTL_PRIVATE_DEF_PRO(MTLTexture); | |
_MTL_PRIVATE_DEF_PRO(MTLTextureBinding); | |
_MTL_PRIVATE_DEF_PRO(MTLThreadgroupBinding); | |
_MTL_PRIVATE_DEF_PRO(MTLVisibleFunctionTable); | |
} | |
namespace MTL::Private::Selector | |
{ | |
_MTL_PRIVATE_DEF_SEL(GPUEndTime, | |
"GPUEndTime"); | |
_MTL_PRIVATE_DEF_SEL(GPUStartTime, | |
"GPUStartTime"); | |
_MTL_PRIVATE_DEF_SEL(URL, | |
"URL"); | |
_MTL_PRIVATE_DEF_SEL(accelerationStructureCommandEncoder, | |
"accelerationStructureCommandEncoder"); | |
_MTL_PRIVATE_DEF_SEL(accelerationStructureCommandEncoderWithDescriptor_, | |
"accelerationStructureCommandEncoderWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(accelerationStructurePassDescriptor, | |
"accelerationStructurePassDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(accelerationStructureSizesWithDescriptor_, | |
"accelerationStructureSizesWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(access, | |
"access"); | |
_MTL_PRIVATE_DEF_SEL(addBarrier, | |
"addBarrier"); | |
_MTL_PRIVATE_DEF_SEL(addCompletedHandler_, | |
"addCompletedHandler:"); | |
_MTL_PRIVATE_DEF_SEL(addComputePipelineFunctionsWithDescriptor_error_, | |
"addComputePipelineFunctionsWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(addDebugMarker_range_, | |
"addDebugMarker:range:"); | |
_MTL_PRIVATE_DEF_SEL(addFunctionWithDescriptor_library_error_, | |
"addFunctionWithDescriptor:library:error:"); | |
_MTL_PRIVATE_DEF_SEL(addPresentedHandler_, | |
"addPresentedHandler:"); | |
_MTL_PRIVATE_DEF_SEL(addRenderPipelineFunctionsWithDescriptor_error_, | |
"addRenderPipelineFunctionsWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(addScheduledHandler_, | |
"addScheduledHandler:"); | |
_MTL_PRIVATE_DEF_SEL(addTileRenderPipelineFunctionsWithDescriptor_error_, | |
"addTileRenderPipelineFunctionsWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(alignment, | |
"alignment"); | |
_MTL_PRIVATE_DEF_SEL(allocatedSize, | |
"allocatedSize"); | |
_MTL_PRIVATE_DEF_SEL(allowDuplicateIntersectionFunctionInvocation, | |
"allowDuplicateIntersectionFunctionInvocation"); | |
_MTL_PRIVATE_DEF_SEL(allowGPUOptimizedContents, | |
"allowGPUOptimizedContents"); | |
_MTL_PRIVATE_DEF_SEL(allowReferencingUndefinedSymbols, | |
"allowReferencingUndefinedSymbols"); | |
_MTL_PRIVATE_DEF_SEL(alphaBlendOperation, | |
"alphaBlendOperation"); | |
_MTL_PRIVATE_DEF_SEL(architecture, | |
"architecture"); | |
_MTL_PRIVATE_DEF_SEL(areBarycentricCoordsSupported, | |
"areBarycentricCoordsSupported"); | |
_MTL_PRIVATE_DEF_SEL(areProgrammableSamplePositionsSupported, | |
"areProgrammableSamplePositionsSupported"); | |
_MTL_PRIVATE_DEF_SEL(areRasterOrderGroupsSupported, | |
"areRasterOrderGroupsSupported"); | |
_MTL_PRIVATE_DEF_SEL(argumentBuffersSupport, | |
"argumentBuffersSupport"); | |
_MTL_PRIVATE_DEF_SEL(argumentDescriptor, | |
"argumentDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(argumentIndex, | |
"argumentIndex"); | |
_MTL_PRIVATE_DEF_SEL(argumentIndexStride, | |
"argumentIndexStride"); | |
_MTL_PRIVATE_DEF_SEL(arguments, | |
"arguments"); | |
_MTL_PRIVATE_DEF_SEL(arrayLength, | |
"arrayLength"); | |
_MTL_PRIVATE_DEF_SEL(arrayType, | |
"arrayType"); | |
_MTL_PRIVATE_DEF_SEL(attributeIndex, | |
"attributeIndex"); | |
_MTL_PRIVATE_DEF_SEL(attributeType, | |
"attributeType"); | |
_MTL_PRIVATE_DEF_SEL(attributes, | |
"attributes"); | |
_MTL_PRIVATE_DEF_SEL(backFaceStencil, | |
"backFaceStencil"); | |
_MTL_PRIVATE_DEF_SEL(binaryArchives, | |
"binaryArchives"); | |
_MTL_PRIVATE_DEF_SEL(binaryFunctions, | |
"binaryFunctions"); | |
_MTL_PRIVATE_DEF_SEL(bindings, | |
"bindings"); | |
_MTL_PRIVATE_DEF_SEL(blitCommandEncoder, | |
"blitCommandEncoder"); | |
_MTL_PRIVATE_DEF_SEL(blitCommandEncoderWithDescriptor_, | |
"blitCommandEncoderWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(blitPassDescriptor, | |
"blitPassDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(borderColor, | |
"borderColor"); | |
_MTL_PRIVATE_DEF_SEL(boundingBoxBuffer, | |
"boundingBoxBuffer"); | |
_MTL_PRIVATE_DEF_SEL(boundingBoxBufferOffset, | |
"boundingBoxBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(boundingBoxBuffers, | |
"boundingBoxBuffers"); | |
_MTL_PRIVATE_DEF_SEL(boundingBoxCount, | |
"boundingBoxCount"); | |
_MTL_PRIVATE_DEF_SEL(boundingBoxStride, | |
"boundingBoxStride"); | |
_MTL_PRIVATE_DEF_SEL(buffer, | |
"buffer"); | |
_MTL_PRIVATE_DEF_SEL(bufferAlignment, | |
"bufferAlignment"); | |
_MTL_PRIVATE_DEF_SEL(bufferBytesPerRow, | |
"bufferBytesPerRow"); | |
_MTL_PRIVATE_DEF_SEL(bufferDataSize, | |
"bufferDataSize"); | |
_MTL_PRIVATE_DEF_SEL(bufferDataType, | |
"bufferDataType"); | |
_MTL_PRIVATE_DEF_SEL(bufferIndex, | |
"bufferIndex"); | |
_MTL_PRIVATE_DEF_SEL(bufferOffset, | |
"bufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(bufferPointerType, | |
"bufferPointerType"); | |
_MTL_PRIVATE_DEF_SEL(bufferStructType, | |
"bufferStructType"); | |
_MTL_PRIVATE_DEF_SEL(buffers, | |
"buffers"); | |
_MTL_PRIVATE_DEF_SEL(buildAccelerationStructure_descriptor_scratchBuffer_scratchBufferOffset_, | |
"buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(captureObject, | |
"captureObject"); | |
_MTL_PRIVATE_DEF_SEL(clearBarrier, | |
"clearBarrier"); | |
_MTL_PRIVATE_DEF_SEL(clearColor, | |
"clearColor"); | |
_MTL_PRIVATE_DEF_SEL(clearDepth, | |
"clearDepth"); | |
_MTL_PRIVATE_DEF_SEL(clearStencil, | |
"clearStencil"); | |
_MTL_PRIVATE_DEF_SEL(colorAttachments, | |
"colorAttachments"); | |
_MTL_PRIVATE_DEF_SEL(column, | |
"column"); | |
_MTL_PRIVATE_DEF_SEL(commandBuffer, | |
"commandBuffer"); | |
_MTL_PRIVATE_DEF_SEL(commandBufferWithDescriptor_, | |
"commandBufferWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(commandBufferWithUnretainedReferences, | |
"commandBufferWithUnretainedReferences"); | |
_MTL_PRIVATE_DEF_SEL(commandQueue, | |
"commandQueue"); | |
_MTL_PRIVATE_DEF_SEL(commandTypes, | |
"commandTypes"); | |
_MTL_PRIVATE_DEF_SEL(commit, | |
"commit"); | |
_MTL_PRIVATE_DEF_SEL(compareFunction, | |
"compareFunction"); | |
_MTL_PRIVATE_DEF_SEL(compileSymbolVisibility, | |
"compileSymbolVisibility"); | |
_MTL_PRIVATE_DEF_SEL(compressionType, | |
"compressionType"); | |
_MTL_PRIVATE_DEF_SEL(computeCommandEncoder, | |
"computeCommandEncoder"); | |
_MTL_PRIVATE_DEF_SEL(computeCommandEncoderWithDescriptor_, | |
"computeCommandEncoderWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(computeCommandEncoderWithDispatchType_, | |
"computeCommandEncoderWithDispatchType:"); | |
_MTL_PRIVATE_DEF_SEL(computeFunction, | |
"computeFunction"); | |
_MTL_PRIVATE_DEF_SEL(computePassDescriptor, | |
"computePassDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(concurrentDispatchThreadgroups_threadsPerThreadgroup_, | |
"concurrentDispatchThreadgroups:threadsPerThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(concurrentDispatchThreads_threadsPerThreadgroup_, | |
"concurrentDispatchThreads:threadsPerThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(constantBlockAlignment, | |
"constantBlockAlignment"); | |
_MTL_PRIVATE_DEF_SEL(constantDataAtIndex_, | |
"constantDataAtIndex:"); | |
_MTL_PRIVATE_DEF_SEL(constantValues, | |
"constantValues"); | |
_MTL_PRIVATE_DEF_SEL(contents, | |
"contents"); | |
_MTL_PRIVATE_DEF_SEL(controlDependencies, | |
"controlDependencies"); | |
_MTL_PRIVATE_DEF_SEL(controlPointBuffer, | |
"controlPointBuffer"); | |
_MTL_PRIVATE_DEF_SEL(controlPointBufferOffset, | |
"controlPointBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(controlPointBuffers, | |
"controlPointBuffers"); | |
_MTL_PRIVATE_DEF_SEL(controlPointCount, | |
"controlPointCount"); | |
_MTL_PRIVATE_DEF_SEL(controlPointFormat, | |
"controlPointFormat"); | |
_MTL_PRIVATE_DEF_SEL(controlPointStride, | |
"controlPointStride"); | |
_MTL_PRIVATE_DEF_SEL(convertSparsePixelRegions_toTileRegions_withTileSize_alignmentMode_numRegions_, | |
"convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:"); | |
_MTL_PRIVATE_DEF_SEL(convertSparseTileRegions_toPixelRegions_withTileSize_numRegions_, | |
"convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:"); | |
_MTL_PRIVATE_DEF_SEL(copyAccelerationStructure_toAccelerationStructure_, | |
"copyAccelerationStructure:toAccelerationStructure:"); | |
_MTL_PRIVATE_DEF_SEL(copyAndCompactAccelerationStructure_toAccelerationStructure_, | |
"copyAndCompactAccelerationStructure:toAccelerationStructure:"); | |
_MTL_PRIVATE_DEF_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_, | |
"copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:"); | |
_MTL_PRIVATE_DEF_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_, | |
"copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:"); | |
_MTL_PRIVATE_DEF_SEL(copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_, | |
"copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:"); | |
_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_, | |
"copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:"); | |
_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_, | |
"copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:"); | |
_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_, | |
"copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:"); | |
_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_, | |
"copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:"); | |
_MTL_PRIVATE_DEF_SEL(copyFromTexture_toTexture_, | |
"copyFromTexture:toTexture:"); | |
_MTL_PRIVATE_DEF_SEL(copyIndirectCommandBuffer_sourceRange_destination_destinationIndex_, | |
"copyIndirectCommandBuffer:sourceRange:destination:destinationIndex:"); | |
_MTL_PRIVATE_DEF_SEL(copyParameterDataToBuffer_offset_, | |
"copyParameterDataToBuffer:offset:"); | |
_MTL_PRIVATE_DEF_SEL(copyStatusToBuffer_offset_, | |
"copyStatusToBuffer:offset:"); | |
_MTL_PRIVATE_DEF_SEL(counterSet, | |
"counterSet"); | |
_MTL_PRIVATE_DEF_SEL(counterSets, | |
"counterSets"); | |
_MTL_PRIVATE_DEF_SEL(counters, | |
"counters"); | |
_MTL_PRIVATE_DEF_SEL(cpuCacheMode, | |
"cpuCacheMode"); | |
_MTL_PRIVATE_DEF_SEL(currentAllocatedSize, | |
"currentAllocatedSize"); | |
_MTL_PRIVATE_DEF_SEL(curveBasis, | |
"curveBasis"); | |
_MTL_PRIVATE_DEF_SEL(curveType, | |
"curveType"); | |
_MTL_PRIVATE_DEF_SEL(data, | |
"data"); | |
_MTL_PRIVATE_DEF_SEL(dataSize, | |
"dataSize"); | |
_MTL_PRIVATE_DEF_SEL(dataType, | |
"dataType"); | |
_MTL_PRIVATE_DEF_SEL(dealloc, | |
"dealloc"); | |
_MTL_PRIVATE_DEF_SEL(debugLocation, | |
"debugLocation"); | |
_MTL_PRIVATE_DEF_SEL(debugSignposts, | |
"debugSignposts"); | |
_MTL_PRIVATE_DEF_SEL(defaultCaptureScope, | |
"defaultCaptureScope"); | |
_MTL_PRIVATE_DEF_SEL(defaultRasterSampleCount, | |
"defaultRasterSampleCount"); | |
_MTL_PRIVATE_DEF_SEL(depth, | |
"depth"); | |
_MTL_PRIVATE_DEF_SEL(depthAttachment, | |
"depthAttachment"); | |
_MTL_PRIVATE_DEF_SEL(depthAttachmentPixelFormat, | |
"depthAttachmentPixelFormat"); | |
_MTL_PRIVATE_DEF_SEL(depthCompareFunction, | |
"depthCompareFunction"); | |
_MTL_PRIVATE_DEF_SEL(depthFailureOperation, | |
"depthFailureOperation"); | |
_MTL_PRIVATE_DEF_SEL(depthPlane, | |
"depthPlane"); | |
_MTL_PRIVATE_DEF_SEL(depthResolveFilter, | |
"depthResolveFilter"); | |
_MTL_PRIVATE_DEF_SEL(depthStencilPassOperation, | |
"depthStencilPassOperation"); | |
_MTL_PRIVATE_DEF_SEL(descriptor, | |
"descriptor"); | |
_MTL_PRIVATE_DEF_SEL(destination, | |
"destination"); | |
_MTL_PRIVATE_DEF_SEL(destinationAlphaBlendFactor, | |
"destinationAlphaBlendFactor"); | |
_MTL_PRIVATE_DEF_SEL(destinationRGBBlendFactor, | |
"destinationRGBBlendFactor"); | |
_MTL_PRIVATE_DEF_SEL(device, | |
"device"); | |
_MTL_PRIVATE_DEF_SEL(didModifyRange_, | |
"didModifyRange:"); | |
_MTL_PRIVATE_DEF_SEL(dispatchQueue, | |
"dispatchQueue"); | |
_MTL_PRIVATE_DEF_SEL(dispatchThreadgroups_threadsPerThreadgroup_, | |
"dispatchThreadgroups:threadsPerThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(dispatchThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerThreadgroup_, | |
"dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(dispatchThreads_threadsPerThreadgroup_, | |
"dispatchThreads:threadsPerThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(dispatchThreadsPerTile_, | |
"dispatchThreadsPerTile:"); | |
_MTL_PRIVATE_DEF_SEL(dispatchType, | |
"dispatchType"); | |
_MTL_PRIVATE_DEF_SEL(drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_, | |
"drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_, | |
"drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:"); | |
_MTL_PRIVATE_DEF_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_, | |
"drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:"); | |
_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_, | |
"drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_, | |
"drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:"); | |
_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_, | |
"drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:"); | |
_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_, | |
"drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_, | |
"drawMeshThreadgroups:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(drawMeshThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_, | |
"drawMeshThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_, | |
"drawMeshThreads:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_, | |
"drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_, | |
"drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:"); | |
_MTL_PRIVATE_DEF_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_, | |
"drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:"); | |
_MTL_PRIVATE_DEF_SEL(drawPrimitives_indirectBuffer_indirectBufferOffset_, | |
"drawPrimitives:indirectBuffer:indirectBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(drawPrimitives_vertexStart_vertexCount_, | |
"drawPrimitives:vertexStart:vertexCount:"); | |
_MTL_PRIVATE_DEF_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_, | |
"drawPrimitives:vertexStart:vertexCount:instanceCount:"); | |
_MTL_PRIVATE_DEF_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_, | |
"drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:"); | |
_MTL_PRIVATE_DEF_SEL(drawableID, | |
"drawableID"); | |
_MTL_PRIVATE_DEF_SEL(elementArrayType, | |
"elementArrayType"); | |
_MTL_PRIVATE_DEF_SEL(elementIsArgumentBuffer, | |
"elementIsArgumentBuffer"); | |
_MTL_PRIVATE_DEF_SEL(elementPointerType, | |
"elementPointerType"); | |
_MTL_PRIVATE_DEF_SEL(elementStructType, | |
"elementStructType"); | |
_MTL_PRIVATE_DEF_SEL(elementTextureReferenceType, | |
"elementTextureReferenceType"); | |
_MTL_PRIVATE_DEF_SEL(elementType, | |
"elementType"); | |
_MTL_PRIVATE_DEF_SEL(encodeSignalEvent_value_, | |
"encodeSignalEvent:value:"); | |
_MTL_PRIVATE_DEF_SEL(encodeWaitForEvent_value_, | |
"encodeWaitForEvent:value:"); | |
_MTL_PRIVATE_DEF_SEL(encodedLength, | |
"encodedLength"); | |
_MTL_PRIVATE_DEF_SEL(encoderLabel, | |
"encoderLabel"); | |
_MTL_PRIVATE_DEF_SEL(curveEndCaps, | |
"curveEndCaps"); | |
_MTL_PRIVATE_DEF_SEL(endEncoding, | |
"endEncoding"); | |
_MTL_PRIVATE_DEF_SEL(endOfEncoderSampleIndex, | |
"endOfEncoderSampleIndex"); | |
_MTL_PRIVATE_DEF_SEL(endOfFragmentSampleIndex, | |
"endOfFragmentSampleIndex"); | |
_MTL_PRIVATE_DEF_SEL(endOfVertexSampleIndex, | |
"endOfVertexSampleIndex"); | |
_MTL_PRIVATE_DEF_SEL(enqueue, | |
"enqueue"); | |
_MTL_PRIVATE_DEF_SEL(enqueueBarrier, | |
"enqueueBarrier"); | |
_MTL_PRIVATE_DEF_SEL(error, | |
"error"); | |
_MTL_PRIVATE_DEF_SEL(errorOptions, | |
"errorOptions"); | |
_MTL_PRIVATE_DEF_SEL(errorState, | |
"errorState"); | |
_MTL_PRIVATE_DEF_SEL(executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_, | |
"executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(executeCommandsInBuffer_withRange_, | |
"executeCommandsInBuffer:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(fastMathEnabled, | |
"fastMathEnabled"); | |
_MTL_PRIVATE_DEF_SEL(fillBuffer_range_value_, | |
"fillBuffer:range:value:"); | |
_MTL_PRIVATE_DEF_SEL(firstMipmapInTail, | |
"firstMipmapInTail"); | |
_MTL_PRIVATE_DEF_SEL(format, | |
"format"); | |
_MTL_PRIVATE_DEF_SEL(fragmentAdditionalBinaryFunctions, | |
"fragmentAdditionalBinaryFunctions"); | |
_MTL_PRIVATE_DEF_SEL(fragmentArguments, | |
"fragmentArguments"); | |
_MTL_PRIVATE_DEF_SEL(fragmentBindings, | |
"fragmentBindings"); | |
_MTL_PRIVATE_DEF_SEL(fragmentBuffers, | |
"fragmentBuffers"); | |
_MTL_PRIVATE_DEF_SEL(fragmentFunction, | |
"fragmentFunction"); | |
_MTL_PRIVATE_DEF_SEL(fragmentLinkedFunctions, | |
"fragmentLinkedFunctions"); | |
_MTL_PRIVATE_DEF_SEL(fragmentPreloadedLibraries, | |
"fragmentPreloadedLibraries"); | |
_MTL_PRIVATE_DEF_SEL(frontFaceStencil, | |
"frontFaceStencil"); | |
_MTL_PRIVATE_DEF_SEL(function, | |
"function"); | |
_MTL_PRIVATE_DEF_SEL(functionConstantsDictionary, | |
"functionConstantsDictionary"); | |
_MTL_PRIVATE_DEF_SEL(functionCount, | |
"functionCount"); | |
_MTL_PRIVATE_DEF_SEL(functionDescriptor, | |
"functionDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(functionGraphs, | |
"functionGraphs"); | |
_MTL_PRIVATE_DEF_SEL(functionHandleWithFunction_, | |
"functionHandleWithFunction:"); | |
_MTL_PRIVATE_DEF_SEL(functionHandleWithFunction_stage_, | |
"functionHandleWithFunction:stage:"); | |
_MTL_PRIVATE_DEF_SEL(functionName, | |
"functionName"); | |
_MTL_PRIVATE_DEF_SEL(functionNames, | |
"functionNames"); | |
_MTL_PRIVATE_DEF_SEL(functionType, | |
"functionType"); | |
_MTL_PRIVATE_DEF_SEL(functions, | |
"functions"); | |
_MTL_PRIVATE_DEF_SEL(generateMipmapsForTexture_, | |
"generateMipmapsForTexture:"); | |
_MTL_PRIVATE_DEF_SEL(geometryDescriptors, | |
"geometryDescriptors"); | |
_MTL_PRIVATE_DEF_SEL(getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_, | |
"getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:"); | |
_MTL_PRIVATE_DEF_SEL(getBytes_bytesPerRow_fromRegion_mipmapLevel_, | |
"getBytes:bytesPerRow:fromRegion:mipmapLevel:"); | |
_MTL_PRIVATE_DEF_SEL(getDefaultSamplePositions_count_, | |
"getDefaultSamplePositions:count:"); | |
_MTL_PRIVATE_DEF_SEL(getSamplePositions_count_, | |
"getSamplePositions:count:"); | |
_MTL_PRIVATE_DEF_SEL(getTextureAccessCounters_region_mipLevel_slice_resetCounters_countersBuffer_countersBufferOffset_, | |
"getTextureAccessCounters:region:mipLevel:slice:resetCounters:countersBuffer:countersBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(gpuAddress, | |
"gpuAddress"); | |
_MTL_PRIVATE_DEF_SEL(gpuResourceID, | |
"gpuResourceID"); | |
_MTL_PRIVATE_DEF_SEL(groups, | |
"groups"); | |
_MTL_PRIVATE_DEF_SEL(hasUnifiedMemory, | |
"hasUnifiedMemory"); | |
_MTL_PRIVATE_DEF_SEL(hazardTrackingMode, | |
"hazardTrackingMode"); | |
_MTL_PRIVATE_DEF_SEL(heap, | |
"heap"); | |
_MTL_PRIVATE_DEF_SEL(heapAccelerationStructureSizeAndAlignWithDescriptor_, | |
"heapAccelerationStructureSizeAndAlignWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(heapAccelerationStructureSizeAndAlignWithSize_, | |
"heapAccelerationStructureSizeAndAlignWithSize:"); | |
_MTL_PRIVATE_DEF_SEL(heapBufferSizeAndAlignWithLength_options_, | |
"heapBufferSizeAndAlignWithLength:options:"); | |
_MTL_PRIVATE_DEF_SEL(heapOffset, | |
"heapOffset"); | |
_MTL_PRIVATE_DEF_SEL(heapTextureSizeAndAlignWithDescriptor_, | |
"heapTextureSizeAndAlignWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(height, | |
"height"); | |
_MTL_PRIVATE_DEF_SEL(horizontal, | |
"horizontal"); | |
_MTL_PRIVATE_DEF_SEL(horizontalSampleStorage, | |
"horizontalSampleStorage"); | |
_MTL_PRIVATE_DEF_SEL(imageblockMemoryLengthForDimensions_, | |
"imageblockMemoryLengthForDimensions:"); | |
_MTL_PRIVATE_DEF_SEL(imageblockSampleLength, | |
"imageblockSampleLength"); | |
_MTL_PRIVATE_DEF_SEL(index, | |
"index"); | |
_MTL_PRIVATE_DEF_SEL(indexBuffer, | |
"indexBuffer"); | |
_MTL_PRIVATE_DEF_SEL(indexBufferIndex, | |
"indexBufferIndex"); | |
_MTL_PRIVATE_DEF_SEL(indexBufferOffset, | |
"indexBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(indexType, | |
"indexType"); | |
_MTL_PRIVATE_DEF_SEL(indirectComputeCommandAtIndex_, | |
"indirectComputeCommandAtIndex:"); | |
_MTL_PRIVATE_DEF_SEL(indirectRenderCommandAtIndex_, | |
"indirectRenderCommandAtIndex:"); | |
_MTL_PRIVATE_DEF_SEL(inheritBuffers, | |
"inheritBuffers"); | |
_MTL_PRIVATE_DEF_SEL(inheritPipelineState, | |
"inheritPipelineState"); | |
_MTL_PRIVATE_DEF_SEL(init, | |
"init"); | |
_MTL_PRIVATE_DEF_SEL(initWithArgumentIndex_, | |
"initWithArgumentIndex:"); | |
_MTL_PRIVATE_DEF_SEL(initWithDispatchQueue_, | |
"initWithDispatchQueue:"); | |
_MTL_PRIVATE_DEF_SEL(initWithFunctionName_nodes_outputNode_attributes_, | |
"initWithFunctionName:nodes:outputNode:attributes:"); | |
_MTL_PRIVATE_DEF_SEL(initWithName_arguments_controlDependencies_, | |
"initWithName:arguments:controlDependencies:"); | |
_MTL_PRIVATE_DEF_SEL(initWithSampleCount_, | |
"initWithSampleCount:"); | |
_MTL_PRIVATE_DEF_SEL(initWithSampleCount_horizontal_vertical_, | |
"initWithSampleCount:horizontal:vertical:"); | |
_MTL_PRIVATE_DEF_SEL(inputPrimitiveTopology, | |
"inputPrimitiveTopology"); | |
_MTL_PRIVATE_DEF_SEL(insertDebugCaptureBoundary, | |
"insertDebugCaptureBoundary"); | |
_MTL_PRIVATE_DEF_SEL(insertDebugSignpost_, | |
"insertDebugSignpost:"); | |
_MTL_PRIVATE_DEF_SEL(insertLibraries, | |
"insertLibraries"); | |
_MTL_PRIVATE_DEF_SEL(installName, | |
"installName"); | |
_MTL_PRIVATE_DEF_SEL(instanceCount, | |
"instanceCount"); | |
_MTL_PRIVATE_DEF_SEL(instanceCountBuffer, | |
"instanceCountBuffer"); | |
_MTL_PRIVATE_DEF_SEL(instanceCountBufferOffset, | |
"instanceCountBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(instanceDescriptorBuffer, | |
"instanceDescriptorBuffer"); | |
_MTL_PRIVATE_DEF_SEL(instanceDescriptorBufferOffset, | |
"instanceDescriptorBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(instanceDescriptorStride, | |
"instanceDescriptorStride"); | |
_MTL_PRIVATE_DEF_SEL(instanceDescriptorType, | |
"instanceDescriptorType"); | |
_MTL_PRIVATE_DEF_SEL(instancedAccelerationStructures, | |
"instancedAccelerationStructures"); | |
_MTL_PRIVATE_DEF_SEL(intersectionFunctionTableDescriptor, | |
"intersectionFunctionTableDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(intersectionFunctionTableOffset, | |
"intersectionFunctionTableOffset"); | |
_MTL_PRIVATE_DEF_SEL(iosurface, | |
"iosurface"); | |
_MTL_PRIVATE_DEF_SEL(iosurfacePlane, | |
"iosurfacePlane"); | |
_MTL_PRIVATE_DEF_SEL(isActive, | |
"isActive"); | |
_MTL_PRIVATE_DEF_SEL(isAliasable, | |
"isAliasable"); | |
_MTL_PRIVATE_DEF_SEL(isAlphaToCoverageEnabled, | |
"isAlphaToCoverageEnabled"); | |
_MTL_PRIVATE_DEF_SEL(isAlphaToOneEnabled, | |
"isAlphaToOneEnabled"); | |
_MTL_PRIVATE_DEF_SEL(isArgument, | |
"isArgument"); | |
_MTL_PRIVATE_DEF_SEL(isBlendingEnabled, | |
"isBlendingEnabled"); | |
_MTL_PRIVATE_DEF_SEL(isCapturing, | |
"isCapturing"); | |
_MTL_PRIVATE_DEF_SEL(isDepth24Stencil8PixelFormatSupported, | |
"isDepth24Stencil8PixelFormatSupported"); | |
_MTL_PRIVATE_DEF_SEL(isDepthTexture, | |
"isDepthTexture"); | |
_MTL_PRIVATE_DEF_SEL(isDepthWriteEnabled, | |
"isDepthWriteEnabled"); | |
_MTL_PRIVATE_DEF_SEL(isFramebufferOnly, | |
"isFramebufferOnly"); | |
_MTL_PRIVATE_DEF_SEL(isHeadless, | |
"isHeadless"); | |
_MTL_PRIVATE_DEF_SEL(isLowPower, | |
"isLowPower"); | |
_MTL_PRIVATE_DEF_SEL(isPatchControlPointData, | |
"isPatchControlPointData"); | |
_MTL_PRIVATE_DEF_SEL(isPatchData, | |
"isPatchData"); | |
_MTL_PRIVATE_DEF_SEL(isRasterizationEnabled, | |
"isRasterizationEnabled"); | |
_MTL_PRIVATE_DEF_SEL(isRemovable, | |
"isRemovable"); | |
_MTL_PRIVATE_DEF_SEL(isShareable, | |
"isShareable"); | |
_MTL_PRIVATE_DEF_SEL(isSparse, | |
"isSparse"); | |
_MTL_PRIVATE_DEF_SEL(isTessellationFactorScaleEnabled, | |
"isTessellationFactorScaleEnabled"); | |
_MTL_PRIVATE_DEF_SEL(isUsed, | |
"isUsed"); | |
_MTL_PRIVATE_DEF_SEL(kernelEndTime, | |
"kernelEndTime"); | |
_MTL_PRIVATE_DEF_SEL(kernelStartTime, | |
"kernelStartTime"); | |
_MTL_PRIVATE_DEF_SEL(label, | |
"label"); | |
_MTL_PRIVATE_DEF_SEL(languageVersion, | |
"languageVersion"); | |
_MTL_PRIVATE_DEF_SEL(layerAtIndex_, | |
"layerAtIndex:"); | |
_MTL_PRIVATE_DEF_SEL(layerCount, | |
"layerCount"); | |
_MTL_PRIVATE_DEF_SEL(layers, | |
"layers"); | |
_MTL_PRIVATE_DEF_SEL(layouts, | |
"layouts"); | |
_MTL_PRIVATE_DEF_SEL(length, | |
"length"); | |
_MTL_PRIVATE_DEF_SEL(level, | |
"level"); | |
_MTL_PRIVATE_DEF_SEL(libraries, | |
"libraries"); | |
_MTL_PRIVATE_DEF_SEL(libraryType, | |
"libraryType"); | |
_MTL_PRIVATE_DEF_SEL(line, | |
"line"); | |
_MTL_PRIVATE_DEF_SEL(linkedFunctions, | |
"linkedFunctions"); | |
_MTL_PRIVATE_DEF_SEL(loadAction, | |
"loadAction"); | |
_MTL_PRIVATE_DEF_SEL(loadBuffer_offset_size_sourceHandle_sourceHandleOffset_, | |
"loadBuffer:offset:size:sourceHandle:sourceHandleOffset:"); | |
_MTL_PRIVATE_DEF_SEL(loadBytes_size_sourceHandle_sourceHandleOffset_, | |
"loadBytes:size:sourceHandle:sourceHandleOffset:"); | |
_MTL_PRIVATE_DEF_SEL(loadTexture_slice_level_size_sourceBytesPerRow_sourceBytesPerImage_destinationOrigin_sourceHandle_sourceHandleOffset_, | |
"loadTexture:slice:level:size:sourceBytesPerRow:sourceBytesPerImage:destinationOrigin:sourceHandle:sourceHandleOffset:"); | |
_MTL_PRIVATE_DEF_SEL(location, | |
"location"); | |
_MTL_PRIVATE_DEF_SEL(locationNumber, | |
"locationNumber"); | |
_MTL_PRIVATE_DEF_SEL(lodAverage, | |
"lodAverage"); | |
_MTL_PRIVATE_DEF_SEL(lodMaxClamp, | |
"lodMaxClamp"); | |
_MTL_PRIVATE_DEF_SEL(lodMinClamp, | |
"lodMinClamp"); | |
_MTL_PRIVATE_DEF_SEL(logs, | |
"logs"); | |
_MTL_PRIVATE_DEF_SEL(magFilter, | |
"magFilter"); | |
_MTL_PRIVATE_DEF_SEL(makeAliasable, | |
"makeAliasable"); | |
_MTL_PRIVATE_DEF_SEL(mapPhysicalToScreenCoordinates_forLayer_, | |
"mapPhysicalToScreenCoordinates:forLayer:"); | |
_MTL_PRIVATE_DEF_SEL(mapScreenToPhysicalCoordinates_forLayer_, | |
"mapScreenToPhysicalCoordinates:forLayer:"); | |
_MTL_PRIVATE_DEF_SEL(maxAnisotropy, | |
"maxAnisotropy"); | |
_MTL_PRIVATE_DEF_SEL(maxArgumentBufferSamplerCount, | |
"maxArgumentBufferSamplerCount"); | |
_MTL_PRIVATE_DEF_SEL(maxAvailableSizeWithAlignment_, | |
"maxAvailableSizeWithAlignment:"); | |
_MTL_PRIVATE_DEF_SEL(maxBufferLength, | |
"maxBufferLength"); | |
_MTL_PRIVATE_DEF_SEL(maxCallStackDepth, | |
"maxCallStackDepth"); | |
_MTL_PRIVATE_DEF_SEL(maxCommandBufferCount, | |
"maxCommandBufferCount"); | |
_MTL_PRIVATE_DEF_SEL(maxCommandsInFlight, | |
"maxCommandsInFlight"); | |
_MTL_PRIVATE_DEF_SEL(maxFragmentBufferBindCount, | |
"maxFragmentBufferBindCount"); | |
_MTL_PRIVATE_DEF_SEL(maxFragmentCallStackDepth, | |
"maxFragmentCallStackDepth"); | |
_MTL_PRIVATE_DEF_SEL(maxInstanceCount, | |
"maxInstanceCount"); | |
_MTL_PRIVATE_DEF_SEL(maxKernelBufferBindCount, | |
"maxKernelBufferBindCount"); | |
_MTL_PRIVATE_DEF_SEL(maxKernelThreadgroupMemoryBindCount, | |
"maxKernelThreadgroupMemoryBindCount"); | |
_MTL_PRIVATE_DEF_SEL(maxMotionTransformCount, | |
"maxMotionTransformCount"); | |
_MTL_PRIVATE_DEF_SEL(maxSampleCount, | |
"maxSampleCount"); | |
_MTL_PRIVATE_DEF_SEL(maxTessellationFactor, | |
"maxTessellationFactor"); | |
_MTL_PRIVATE_DEF_SEL(maxThreadgroupMemoryLength, | |
"maxThreadgroupMemoryLength"); | |
_MTL_PRIVATE_DEF_SEL(maxThreadsPerThreadgroup, | |
"maxThreadsPerThreadgroup"); | |
_MTL_PRIVATE_DEF_SEL(maxTotalThreadgroupsPerMeshGrid, | |
"maxTotalThreadgroupsPerMeshGrid"); | |
_MTL_PRIVATE_DEF_SEL(maxTotalThreadsPerMeshThreadgroup, | |
"maxTotalThreadsPerMeshThreadgroup"); | |
_MTL_PRIVATE_DEF_SEL(maxTotalThreadsPerObjectThreadgroup, | |
"maxTotalThreadsPerObjectThreadgroup"); | |
_MTL_PRIVATE_DEF_SEL(maxTotalThreadsPerThreadgroup, | |
"maxTotalThreadsPerThreadgroup"); | |
_MTL_PRIVATE_DEF_SEL(maxTransferRate, | |
"maxTransferRate"); | |
_MTL_PRIVATE_DEF_SEL(maxVertexAmplificationCount, | |
"maxVertexAmplificationCount"); | |
_MTL_PRIVATE_DEF_SEL(maxVertexBufferBindCount, | |
"maxVertexBufferBindCount"); | |
_MTL_PRIVATE_DEF_SEL(maxVertexCallStackDepth, | |
"maxVertexCallStackDepth"); | |
_MTL_PRIVATE_DEF_SEL(maximumConcurrentCompilationTaskCount, | |
"maximumConcurrentCompilationTaskCount"); | |
_MTL_PRIVATE_DEF_SEL(memberByName_, | |
"memberByName:"); | |
_MTL_PRIVATE_DEF_SEL(members, | |
"members"); | |
_MTL_PRIVATE_DEF_SEL(memoryBarrierWithResources_count_, | |
"memoryBarrierWithResources:count:"); | |
_MTL_PRIVATE_DEF_SEL(memoryBarrierWithResources_count_afterStages_beforeStages_, | |
"memoryBarrierWithResources:count:afterStages:beforeStages:"); | |
_MTL_PRIVATE_DEF_SEL(memoryBarrierWithScope_, | |
"memoryBarrierWithScope:"); | |
_MTL_PRIVATE_DEF_SEL(memoryBarrierWithScope_afterStages_beforeStages_, | |
"memoryBarrierWithScope:afterStages:beforeStages:"); | |
_MTL_PRIVATE_DEF_SEL(meshBindings, | |
"meshBindings"); | |
_MTL_PRIVATE_DEF_SEL(meshBuffers, | |
"meshBuffers"); | |
_MTL_PRIVATE_DEF_SEL(meshFunction, | |
"meshFunction"); | |
_MTL_PRIVATE_DEF_SEL(meshLinkedFunctions, | |
"meshLinkedFunctions"); | |
_MTL_PRIVATE_DEF_SEL(meshThreadExecutionWidth, | |
"meshThreadExecutionWidth"); | |
_MTL_PRIVATE_DEF_SEL(meshThreadgroupSizeIsMultipleOfThreadExecutionWidth, | |
"meshThreadgroupSizeIsMultipleOfThreadExecutionWidth"); | |
_MTL_PRIVATE_DEF_SEL(minFilter, | |
"minFilter"); | |
_MTL_PRIVATE_DEF_SEL(minimumLinearTextureAlignmentForPixelFormat_, | |
"minimumLinearTextureAlignmentForPixelFormat:"); | |
_MTL_PRIVATE_DEF_SEL(minimumTextureBufferAlignmentForPixelFormat_, | |
"minimumTextureBufferAlignmentForPixelFormat:"); | |
_MTL_PRIVATE_DEF_SEL(mipFilter, | |
"mipFilter"); | |
_MTL_PRIVATE_DEF_SEL(mipmapLevelCount, | |
"mipmapLevelCount"); | |
_MTL_PRIVATE_DEF_SEL(motionEndBorderMode, | |
"motionEndBorderMode"); | |
_MTL_PRIVATE_DEF_SEL(motionEndTime, | |
"motionEndTime"); | |
_MTL_PRIVATE_DEF_SEL(motionKeyframeCount, | |
"motionKeyframeCount"); | |
_MTL_PRIVATE_DEF_SEL(motionStartBorderMode, | |
"motionStartBorderMode"); | |
_MTL_PRIVATE_DEF_SEL(motionStartTime, | |
"motionStartTime"); | |
_MTL_PRIVATE_DEF_SEL(motionTransformBuffer, | |
"motionTransformBuffer"); | |
_MTL_PRIVATE_DEF_SEL(motionTransformBufferOffset, | |
"motionTransformBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(motionTransformCount, | |
"motionTransformCount"); | |
_MTL_PRIVATE_DEF_SEL(motionTransformCountBuffer, | |
"motionTransformCountBuffer"); | |
_MTL_PRIVATE_DEF_SEL(motionTransformCountBufferOffset, | |
"motionTransformCountBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(moveTextureMappingsFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_, | |
"moveTextureMappingsFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:"); | |
_MTL_PRIVATE_DEF_SEL(mutability, | |
"mutability"); | |
_MTL_PRIVATE_DEF_SEL(name, | |
"name"); | |
_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithDescriptor_, | |
"newAccelerationStructureWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithDescriptor_offset_, | |
"newAccelerationStructureWithDescriptor:offset:"); | |
_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithSize_, | |
"newAccelerationStructureWithSize:"); | |
_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithSize_offset_, | |
"newAccelerationStructureWithSize:offset:"); | |
_MTL_PRIVATE_DEF_SEL(newArgumentEncoderForBufferAtIndex_, | |
"newArgumentEncoderForBufferAtIndex:"); | |
_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithArguments_, | |
"newArgumentEncoderWithArguments:"); | |
_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithBufferBinding_, | |
"newArgumentEncoderWithBufferBinding:"); | |
_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithBufferIndex_, | |
"newArgumentEncoderWithBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithBufferIndex_reflection_, | |
"newArgumentEncoderWithBufferIndex:reflection:"); | |
_MTL_PRIVATE_DEF_SEL(newBinaryArchiveWithDescriptor_error_, | |
"newBinaryArchiveWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(newBufferWithBytes_length_options_, | |
"newBufferWithBytes:length:options:"); | |
_MTL_PRIVATE_DEF_SEL(newBufferWithBytesNoCopy_length_options_deallocator_, | |
"newBufferWithBytesNoCopy:length:options:deallocator:"); | |
_MTL_PRIVATE_DEF_SEL(newBufferWithLength_options_, | |
"newBufferWithLength:options:"); | |
_MTL_PRIVATE_DEF_SEL(newBufferWithLength_options_offset_, | |
"newBufferWithLength:options:offset:"); | |
_MTL_PRIVATE_DEF_SEL(newCaptureScopeWithCommandQueue_, | |
"newCaptureScopeWithCommandQueue:"); | |
_MTL_PRIVATE_DEF_SEL(newCaptureScopeWithDevice_, | |
"newCaptureScopeWithDevice:"); | |
_MTL_PRIVATE_DEF_SEL(newCommandQueue, | |
"newCommandQueue"); | |
_MTL_PRIVATE_DEF_SEL(newCommandQueueWithMaxCommandBufferCount_, | |
"newCommandQueueWithMaxCommandBufferCount:"); | |
_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithAdditionalBinaryFunctions_error_, | |
"newComputePipelineStateWithAdditionalBinaryFunctions:error:"); | |
_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_options_completionHandler_, | |
"newComputePipelineStateWithDescriptor:options:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_options_reflection_error_, | |
"newComputePipelineStateWithDescriptor:options:reflection:error:"); | |
_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_completionHandler_, | |
"newComputePipelineStateWithFunction:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_error_, | |
"newComputePipelineStateWithFunction:error:"); | |
_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_options_completionHandler_, | |
"newComputePipelineStateWithFunction:options:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_options_reflection_error_, | |
"newComputePipelineStateWithFunction:options:reflection:error:"); | |
_MTL_PRIVATE_DEF_SEL(newCounterSampleBufferWithDescriptor_error_, | |
"newCounterSampleBufferWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(newDefaultLibrary, | |
"newDefaultLibrary"); | |
_MTL_PRIVATE_DEF_SEL(newDefaultLibraryWithBundle_error_, | |
"newDefaultLibraryWithBundle:error:"); | |
_MTL_PRIVATE_DEF_SEL(newDepthStencilStateWithDescriptor_, | |
"newDepthStencilStateWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(newDynamicLibrary_error_, | |
"newDynamicLibrary:error:"); | |
_MTL_PRIVATE_DEF_SEL(newDynamicLibraryWithURL_error_, | |
"newDynamicLibraryWithURL:error:"); | |
_MTL_PRIVATE_DEF_SEL(newEvent, | |
"newEvent"); | |
_MTL_PRIVATE_DEF_SEL(newFence, | |
"newFence"); | |
_MTL_PRIVATE_DEF_SEL(newFunctionWithDescriptor_completionHandler_, | |
"newFunctionWithDescriptor:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newFunctionWithDescriptor_error_, | |
"newFunctionWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(newFunctionWithName_, | |
"newFunctionWithName:"); | |
_MTL_PRIVATE_DEF_SEL(newFunctionWithName_constantValues_completionHandler_, | |
"newFunctionWithName:constantValues:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newFunctionWithName_constantValues_error_, | |
"newFunctionWithName:constantValues:error:"); | |
_MTL_PRIVATE_DEF_SEL(newHeapWithDescriptor_, | |
"newHeapWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(newIOCommandQueueWithDescriptor_error_, | |
"newIOCommandQueueWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(newIOFileHandleWithURL_compressionMethod_error_, | |
"newIOFileHandleWithURL:compressionMethod:error:"); | |
_MTL_PRIVATE_DEF_SEL(newIOFileHandleWithURL_error_, | |
"newIOFileHandleWithURL:error:"); | |
_MTL_PRIVATE_DEF_SEL(newIOHandleWithURL_compressionMethod_error_, | |
"newIOHandleWithURL:compressionMethod:error:"); | |
_MTL_PRIVATE_DEF_SEL(newIOHandleWithURL_error_, | |
"newIOHandleWithURL:error:"); | |
_MTL_PRIVATE_DEF_SEL(newIndirectCommandBufferWithDescriptor_maxCommandCount_options_, | |
"newIndirectCommandBufferWithDescriptor:maxCommandCount:options:"); | |
_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionTableWithDescriptor_, | |
"newIntersectionFunctionTableWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionTableWithDescriptor_stage_, | |
"newIntersectionFunctionTableWithDescriptor:stage:"); | |
_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionWithDescriptor_completionHandler_, | |
"newIntersectionFunctionWithDescriptor:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionWithDescriptor_error_, | |
"newIntersectionFunctionWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(newLibraryWithData_error_, | |
"newLibraryWithData:error:"); | |
_MTL_PRIVATE_DEF_SEL(newLibraryWithFile_error_, | |
"newLibraryWithFile:error:"); | |
_MTL_PRIVATE_DEF_SEL(newLibraryWithSource_options_completionHandler_, | |
"newLibraryWithSource:options:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newLibraryWithSource_options_error_, | |
"newLibraryWithSource:options:error:"); | |
_MTL_PRIVATE_DEF_SEL(newLibraryWithStitchedDescriptor_completionHandler_, | |
"newLibraryWithStitchedDescriptor:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newLibraryWithStitchedDescriptor_error_, | |
"newLibraryWithStitchedDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(newLibraryWithURL_error_, | |
"newLibraryWithURL:error:"); | |
_MTL_PRIVATE_DEF_SEL(newRasterizationRateMapWithDescriptor_, | |
"newRasterizationRateMapWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(newRemoteBufferViewForDevice_, | |
"newRemoteBufferViewForDevice:"); | |
_MTL_PRIVATE_DEF_SEL(newRemoteTextureViewForDevice_, | |
"newRemoteTextureViewForDevice:"); | |
_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithAdditionalBinaryFunctions_error_, | |
"newRenderPipelineStateWithAdditionalBinaryFunctions:error:"); | |
_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_completionHandler_, | |
"newRenderPipelineStateWithDescriptor:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_error_, | |
"newRenderPipelineStateWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_options_completionHandler_, | |
"newRenderPipelineStateWithDescriptor:options:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_options_reflection_error_, | |
"newRenderPipelineStateWithDescriptor:options:reflection:error:"); | |
_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithMeshDescriptor_options_completionHandler_, | |
"newRenderPipelineStateWithMeshDescriptor:options:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithMeshDescriptor_options_reflection_error_, | |
"newRenderPipelineStateWithMeshDescriptor:options:reflection:error:"); | |
_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithTileDescriptor_options_completionHandler_, | |
"newRenderPipelineStateWithTileDescriptor:options:completionHandler:"); | |
_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithTileDescriptor_options_reflection_error_, | |
"newRenderPipelineStateWithTileDescriptor:options:reflection:error:"); | |
_MTL_PRIVATE_DEF_SEL(newSamplerStateWithDescriptor_, | |
"newSamplerStateWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(newScratchBufferWithMinimumSize_, | |
"newScratchBufferWithMinimumSize:"); | |
_MTL_PRIVATE_DEF_SEL(newSharedEvent, | |
"newSharedEvent"); | |
_MTL_PRIVATE_DEF_SEL(newSharedEventHandle, | |
"newSharedEventHandle"); | |
_MTL_PRIVATE_DEF_SEL(newSharedEventWithHandle_, | |
"newSharedEventWithHandle:"); | |
_MTL_PRIVATE_DEF_SEL(newSharedTextureHandle, | |
"newSharedTextureHandle"); | |
_MTL_PRIVATE_DEF_SEL(newSharedTextureWithDescriptor_, | |
"newSharedTextureWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(newSharedTextureWithHandle_, | |
"newSharedTextureWithHandle:"); | |
_MTL_PRIVATE_DEF_SEL(newTextureViewWithPixelFormat_, | |
"newTextureViewWithPixelFormat:"); | |
_MTL_PRIVATE_DEF_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_, | |
"newTextureViewWithPixelFormat:textureType:levels:slices:"); | |
_MTL_PRIVATE_DEF_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_, | |
"newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:"); | |
_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_, | |
"newTextureWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_iosurface_plane_, | |
"newTextureWithDescriptor:iosurface:plane:"); | |
_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_offset_, | |
"newTextureWithDescriptor:offset:"); | |
_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_offset_bytesPerRow_, | |
"newTextureWithDescriptor:offset:bytesPerRow:"); | |
_MTL_PRIVATE_DEF_SEL(newVisibleFunctionTableWithDescriptor_, | |
"newVisibleFunctionTableWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(newVisibleFunctionTableWithDescriptor_stage_, | |
"newVisibleFunctionTableWithDescriptor:stage:"); | |
_MTL_PRIVATE_DEF_SEL(nodes, | |
"nodes"); | |
_MTL_PRIVATE_DEF_SEL(normalizedCoordinates, | |
"normalizedCoordinates"); | |
_MTL_PRIVATE_DEF_SEL(notifyListener_atValue_block_, | |
"notifyListener:atValue:block:"); | |
_MTL_PRIVATE_DEF_SEL(objectAtIndexedSubscript_, | |
"objectAtIndexedSubscript:"); | |
_MTL_PRIVATE_DEF_SEL(objectBindings, | |
"objectBindings"); | |
_MTL_PRIVATE_DEF_SEL(objectBuffers, | |
"objectBuffers"); | |
_MTL_PRIVATE_DEF_SEL(objectFunction, | |
"objectFunction"); | |
_MTL_PRIVATE_DEF_SEL(objectLinkedFunctions, | |
"objectLinkedFunctions"); | |
_MTL_PRIVATE_DEF_SEL(objectPayloadAlignment, | |
"objectPayloadAlignment"); | |
_MTL_PRIVATE_DEF_SEL(objectPayloadDataSize, | |
"objectPayloadDataSize"); | |
_MTL_PRIVATE_DEF_SEL(objectThreadExecutionWidth, | |
"objectThreadExecutionWidth"); | |
_MTL_PRIVATE_DEF_SEL(objectThreadgroupSizeIsMultipleOfThreadExecutionWidth, | |
"objectThreadgroupSizeIsMultipleOfThreadExecutionWidth"); | |
_MTL_PRIVATE_DEF_SEL(offset, | |
"offset"); | |
_MTL_PRIVATE_DEF_SEL(opaque, | |
"opaque"); | |
_MTL_PRIVATE_DEF_SEL(optimizationLevel, | |
"optimizationLevel"); | |
_MTL_PRIVATE_DEF_SEL(optimizeContentsForCPUAccess_, | |
"optimizeContentsForCPUAccess:"); | |
_MTL_PRIVATE_DEF_SEL(optimizeContentsForCPUAccess_slice_level_, | |
"optimizeContentsForCPUAccess:slice:level:"); | |
_MTL_PRIVATE_DEF_SEL(optimizeContentsForGPUAccess_, | |
"optimizeContentsForGPUAccess:"); | |
_MTL_PRIVATE_DEF_SEL(optimizeContentsForGPUAccess_slice_level_, | |
"optimizeContentsForGPUAccess:slice:level:"); | |
_MTL_PRIVATE_DEF_SEL(optimizeIndirectCommandBuffer_withRange_, | |
"optimizeIndirectCommandBuffer:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(options, | |
"options"); | |
_MTL_PRIVATE_DEF_SEL(outputNode, | |
"outputNode"); | |
_MTL_PRIVATE_DEF_SEL(outputURL, | |
"outputURL"); | |
_MTL_PRIVATE_DEF_SEL(parallelRenderCommandEncoderWithDescriptor_, | |
"parallelRenderCommandEncoderWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(parameterBufferSizeAndAlign, | |
"parameterBufferSizeAndAlign"); | |
_MTL_PRIVATE_DEF_SEL(parentRelativeLevel, | |
"parentRelativeLevel"); | |
_MTL_PRIVATE_DEF_SEL(parentRelativeSlice, | |
"parentRelativeSlice"); | |
_MTL_PRIVATE_DEF_SEL(parentTexture, | |
"parentTexture"); | |
_MTL_PRIVATE_DEF_SEL(patchControlPointCount, | |
"patchControlPointCount"); | |
_MTL_PRIVATE_DEF_SEL(patchType, | |
"patchType"); | |
_MTL_PRIVATE_DEF_SEL(payloadMemoryLength, | |
"payloadMemoryLength"); | |
_MTL_PRIVATE_DEF_SEL(peerCount, | |
"peerCount"); | |
_MTL_PRIVATE_DEF_SEL(peerGroupID, | |
"peerGroupID"); | |
_MTL_PRIVATE_DEF_SEL(peerIndex, | |
"peerIndex"); | |
_MTL_PRIVATE_DEF_SEL(physicalGranularity, | |
"physicalGranularity"); | |
_MTL_PRIVATE_DEF_SEL(physicalSizeForLayer_, | |
"physicalSizeForLayer:"); | |
_MTL_PRIVATE_DEF_SEL(pixelFormat, | |
"pixelFormat"); | |
_MTL_PRIVATE_DEF_SEL(pointerType, | |
"pointerType"); | |
_MTL_PRIVATE_DEF_SEL(popDebugGroup, | |
"popDebugGroup"); | |
_MTL_PRIVATE_DEF_SEL(preloadedLibraries, | |
"preloadedLibraries"); | |
_MTL_PRIVATE_DEF_SEL(preprocessorMacros, | |
"preprocessorMacros"); | |
_MTL_PRIVATE_DEF_SEL(present, | |
"present"); | |
_MTL_PRIVATE_DEF_SEL(presentAfterMinimumDuration_, | |
"presentAfterMinimumDuration:"); | |
_MTL_PRIVATE_DEF_SEL(presentAtTime_, | |
"presentAtTime:"); | |
_MTL_PRIVATE_DEF_SEL(presentDrawable_, | |
"presentDrawable:"); | |
_MTL_PRIVATE_DEF_SEL(presentDrawable_afterMinimumDuration_, | |
"presentDrawable:afterMinimumDuration:"); | |
_MTL_PRIVATE_DEF_SEL(presentDrawable_atTime_, | |
"presentDrawable:atTime:"); | |
_MTL_PRIVATE_DEF_SEL(presentedTime, | |
"presentedTime"); | |
_MTL_PRIVATE_DEF_SEL(preserveInvariance, | |
"preserveInvariance"); | |
_MTL_PRIVATE_DEF_SEL(primitiveDataBuffer, | |
"primitiveDataBuffer"); | |
_MTL_PRIVATE_DEF_SEL(primitiveDataBufferOffset, | |
"primitiveDataBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(primitiveDataElementSize, | |
"primitiveDataElementSize"); | |
_MTL_PRIVATE_DEF_SEL(primitiveDataStride, | |
"primitiveDataStride"); | |
_MTL_PRIVATE_DEF_SEL(priority, | |
"priority"); | |
_MTL_PRIVATE_DEF_SEL(privateFunctions, | |
"privateFunctions"); | |
_MTL_PRIVATE_DEF_SEL(pushDebugGroup_, | |
"pushDebugGroup:"); | |
_MTL_PRIVATE_DEF_SEL(rAddressMode, | |
"rAddressMode"); | |
_MTL_PRIVATE_DEF_SEL(radiusBuffer, | |
"radiusBuffer"); | |
_MTL_PRIVATE_DEF_SEL(radiusBufferOffset, | |
"radiusBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(radiusBuffers, | |
"radiusBuffers"); | |
_MTL_PRIVATE_DEF_SEL(radiusFormat, | |
"radiusFormat"); | |
_MTL_PRIVATE_DEF_SEL(radiusStride, | |
"radiusStride"); | |
_MTL_PRIVATE_DEF_SEL(rasterSampleCount, | |
"rasterSampleCount"); | |
_MTL_PRIVATE_DEF_SEL(rasterizationRateMap, | |
"rasterizationRateMap"); | |
_MTL_PRIVATE_DEF_SEL(rasterizationRateMapDescriptorWithScreenSize_, | |
"rasterizationRateMapDescriptorWithScreenSize:"); | |
_MTL_PRIVATE_DEF_SEL(rasterizationRateMapDescriptorWithScreenSize_layer_, | |
"rasterizationRateMapDescriptorWithScreenSize:layer:"); | |
_MTL_PRIVATE_DEF_SEL(rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_, | |
"rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:"); | |
_MTL_PRIVATE_DEF_SEL(readMask, | |
"readMask"); | |
_MTL_PRIVATE_DEF_SEL(readWriteTextureSupport, | |
"readWriteTextureSupport"); | |
_MTL_PRIVATE_DEF_SEL(recommendedMaxWorkingSetSize, | |
"recommendedMaxWorkingSetSize"); | |
_MTL_PRIVATE_DEF_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_, | |
"refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_options_, | |
"refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:options:"); | |
_MTL_PRIVATE_DEF_SEL(registryID, | |
"registryID"); | |
_MTL_PRIVATE_DEF_SEL(remoteStorageBuffer, | |
"remoteStorageBuffer"); | |
_MTL_PRIVATE_DEF_SEL(remoteStorageTexture, | |
"remoteStorageTexture"); | |
_MTL_PRIVATE_DEF_SEL(removeAllDebugMarkers, | |
"removeAllDebugMarkers"); | |
_MTL_PRIVATE_DEF_SEL(renderCommandEncoder, | |
"renderCommandEncoder"); | |
_MTL_PRIVATE_DEF_SEL(renderCommandEncoderWithDescriptor_, | |
"renderCommandEncoderWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(renderPassDescriptor, | |
"renderPassDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(renderTargetArrayLength, | |
"renderTargetArrayLength"); | |
_MTL_PRIVATE_DEF_SEL(renderTargetHeight, | |
"renderTargetHeight"); | |
_MTL_PRIVATE_DEF_SEL(renderTargetWidth, | |
"renderTargetWidth"); | |
_MTL_PRIVATE_DEF_SEL(replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_, | |
"replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:"); | |
_MTL_PRIVATE_DEF_SEL(replaceRegion_mipmapLevel_withBytes_bytesPerRow_, | |
"replaceRegion:mipmapLevel:withBytes:bytesPerRow:"); | |
_MTL_PRIVATE_DEF_SEL(required, | |
"required"); | |
_MTL_PRIVATE_DEF_SEL(reset, | |
"reset"); | |
_MTL_PRIVATE_DEF_SEL(resetCommandsInBuffer_withRange_, | |
"resetCommandsInBuffer:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(resetTextureAccessCounters_region_mipLevel_slice_, | |
"resetTextureAccessCounters:region:mipLevel:slice:"); | |
_MTL_PRIVATE_DEF_SEL(resetWithRange_, | |
"resetWithRange:"); | |
_MTL_PRIVATE_DEF_SEL(resolveCounterRange_, | |
"resolveCounterRange:"); | |
_MTL_PRIVATE_DEF_SEL(resolveCounters_inRange_destinationBuffer_destinationOffset_, | |
"resolveCounters:inRange:destinationBuffer:destinationOffset:"); | |
_MTL_PRIVATE_DEF_SEL(resolveDepthPlane, | |
"resolveDepthPlane"); | |
_MTL_PRIVATE_DEF_SEL(resolveLevel, | |
"resolveLevel"); | |
_MTL_PRIVATE_DEF_SEL(resolveSlice, | |
"resolveSlice"); | |
_MTL_PRIVATE_DEF_SEL(resolveTexture, | |
"resolveTexture"); | |
_MTL_PRIVATE_DEF_SEL(resourceOptions, | |
"resourceOptions"); | |
_MTL_PRIVATE_DEF_SEL(resourceStateCommandEncoder, | |
"resourceStateCommandEncoder"); | |
_MTL_PRIVATE_DEF_SEL(resourceStateCommandEncoderWithDescriptor_, | |
"resourceStateCommandEncoderWithDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(resourceStatePassDescriptor, | |
"resourceStatePassDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(retainedReferences, | |
"retainedReferences"); | |
_MTL_PRIVATE_DEF_SEL(rgbBlendOperation, | |
"rgbBlendOperation"); | |
_MTL_PRIVATE_DEF_SEL(rootResource, | |
"rootResource"); | |
_MTL_PRIVATE_DEF_SEL(sAddressMode, | |
"sAddressMode"); | |
_MTL_PRIVATE_DEF_SEL(sampleBuffer, | |
"sampleBuffer"); | |
_MTL_PRIVATE_DEF_SEL(sampleBufferAttachments, | |
"sampleBufferAttachments"); | |
_MTL_PRIVATE_DEF_SEL(sampleCount, | |
"sampleCount"); | |
_MTL_PRIVATE_DEF_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_, | |
"sampleCountersInBuffer:atSampleIndex:withBarrier:"); | |
_MTL_PRIVATE_DEF_SEL(sampleTimestamps_gpuTimestamp_, | |
"sampleTimestamps:gpuTimestamp:"); | |
_MTL_PRIVATE_DEF_SEL(scratchBufferAllocator, | |
"scratchBufferAllocator"); | |
_MTL_PRIVATE_DEF_SEL(screenSize, | |
"screenSize"); | |
_MTL_PRIVATE_DEF_SEL(segmentControlPointCount, | |
"segmentControlPointCount"); | |
_MTL_PRIVATE_DEF_SEL(segmentCount, | |
"segmentCount"); | |
_MTL_PRIVATE_DEF_SEL(serializeToURL_error_, | |
"serializeToURL:error:"); | |
_MTL_PRIVATE_DEF_SEL(setAccelerationStructure_atBufferIndex_, | |
"setAccelerationStructure:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setAccelerationStructure_atIndex_, | |
"setAccelerationStructure:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setAccess_, | |
"setAccess:"); | |
_MTL_PRIVATE_DEF_SEL(setAllowDuplicateIntersectionFunctionInvocation_, | |
"setAllowDuplicateIntersectionFunctionInvocation:"); | |
_MTL_PRIVATE_DEF_SEL(setAllowGPUOptimizedContents_, | |
"setAllowGPUOptimizedContents:"); | |
_MTL_PRIVATE_DEF_SEL(setAllowReferencingUndefinedSymbols_, | |
"setAllowReferencingUndefinedSymbols:"); | |
_MTL_PRIVATE_DEF_SEL(setAlphaBlendOperation_, | |
"setAlphaBlendOperation:"); | |
_MTL_PRIVATE_DEF_SEL(setAlphaToCoverageEnabled_, | |
"setAlphaToCoverageEnabled:"); | |
_MTL_PRIVATE_DEF_SEL(setAlphaToOneEnabled_, | |
"setAlphaToOneEnabled:"); | |
_MTL_PRIVATE_DEF_SEL(setArgumentBuffer_offset_, | |
"setArgumentBuffer:offset:"); | |
_MTL_PRIVATE_DEF_SEL(setArgumentBuffer_startOffset_arrayElement_, | |
"setArgumentBuffer:startOffset:arrayElement:"); | |
_MTL_PRIVATE_DEF_SEL(setArgumentIndex_, | |
"setArgumentIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setArguments_, | |
"setArguments:"); | |
_MTL_PRIVATE_DEF_SEL(setArrayLength_, | |
"setArrayLength:"); | |
_MTL_PRIVATE_DEF_SEL(setAttributes_, | |
"setAttributes:"); | |
_MTL_PRIVATE_DEF_SEL(setBackFaceStencil_, | |
"setBackFaceStencil:"); | |
_MTL_PRIVATE_DEF_SEL(setBarrier, | |
"setBarrier"); | |
_MTL_PRIVATE_DEF_SEL(setBinaryArchives_, | |
"setBinaryArchives:"); | |
_MTL_PRIVATE_DEF_SEL(setBinaryFunctions_, | |
"setBinaryFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setBlendColorRed_green_blue_alpha_, | |
"setBlendColorRed:green:blue:alpha:"); | |
_MTL_PRIVATE_DEF_SEL(setBlendingEnabled_, | |
"setBlendingEnabled:"); | |
_MTL_PRIVATE_DEF_SEL(setBorderColor_, | |
"setBorderColor:"); | |
_MTL_PRIVATE_DEF_SEL(setBoundingBoxBuffer_, | |
"setBoundingBoxBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setBoundingBoxBufferOffset_, | |
"setBoundingBoxBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setBoundingBoxBuffers_, | |
"setBoundingBoxBuffers:"); | |
_MTL_PRIVATE_DEF_SEL(setBoundingBoxCount_, | |
"setBoundingBoxCount:"); | |
_MTL_PRIVATE_DEF_SEL(setBoundingBoxStride_, | |
"setBoundingBoxStride:"); | |
_MTL_PRIVATE_DEF_SEL(setBuffer_, | |
"setBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setBuffer_offset_atIndex_, | |
"setBuffer:offset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setBuffer_offset_attributeStride_atIndex_, | |
"setBuffer:offset:attributeStride:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setBufferIndex_, | |
"setBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setBufferOffset_atIndex_, | |
"setBufferOffset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setBufferOffset_attributeStride_atIndex_, | |
"setBufferOffset:attributeStride:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setBuffers_offsets_attributeStrides_withRange_, | |
"setBuffers:offsets:attributeStrides:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setBuffers_offsets_withRange_, | |
"setBuffers:offsets:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setBytes_length_atIndex_, | |
"setBytes:length:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setBytes_length_attributeStride_atIndex_, | |
"setBytes:length:attributeStride:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setCaptureObject_, | |
"setCaptureObject:"); | |
_MTL_PRIVATE_DEF_SEL(setClearColor_, | |
"setClearColor:"); | |
_MTL_PRIVATE_DEF_SEL(setClearDepth_, | |
"setClearDepth:"); | |
_MTL_PRIVATE_DEF_SEL(setClearStencil_, | |
"setClearStencil:"); | |
_MTL_PRIVATE_DEF_SEL(setColorStoreAction_atIndex_, | |
"setColorStoreAction:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setColorStoreActionOptions_atIndex_, | |
"setColorStoreActionOptions:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setCommandTypes_, | |
"setCommandTypes:"); | |
_MTL_PRIVATE_DEF_SEL(setCompareFunction_, | |
"setCompareFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setCompileSymbolVisibility_, | |
"setCompileSymbolVisibility:"); | |
_MTL_PRIVATE_DEF_SEL(setCompressionType_, | |
"setCompressionType:"); | |
_MTL_PRIVATE_DEF_SEL(setComputeFunction_, | |
"setComputeFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setComputePipelineState_, | |
"setComputePipelineState:"); | |
_MTL_PRIVATE_DEF_SEL(setComputePipelineState_atIndex_, | |
"setComputePipelineState:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setComputePipelineStates_withRange_, | |
"setComputePipelineStates:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setConstantBlockAlignment_, | |
"setConstantBlockAlignment:"); | |
_MTL_PRIVATE_DEF_SEL(setConstantValue_type_atIndex_, | |
"setConstantValue:type:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setConstantValue_type_withName_, | |
"setConstantValue:type:withName:"); | |
_MTL_PRIVATE_DEF_SEL(setConstantValues_, | |
"setConstantValues:"); | |
_MTL_PRIVATE_DEF_SEL(setConstantValues_type_withRange_, | |
"setConstantValues:type:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setControlDependencies_, | |
"setControlDependencies:"); | |
_MTL_PRIVATE_DEF_SEL(setControlPointBuffer_, | |
"setControlPointBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setControlPointBufferOffset_, | |
"setControlPointBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setControlPointBuffers_, | |
"setControlPointBuffers:"); | |
_MTL_PRIVATE_DEF_SEL(setControlPointCount_, | |
"setControlPointCount:"); | |
_MTL_PRIVATE_DEF_SEL(setControlPointFormat_, | |
"setControlPointFormat:"); | |
_MTL_PRIVATE_DEF_SEL(setControlPointStride_, | |
"setControlPointStride:"); | |
_MTL_PRIVATE_DEF_SEL(setCounterSet_, | |
"setCounterSet:"); | |
_MTL_PRIVATE_DEF_SEL(setCpuCacheMode_, | |
"setCpuCacheMode:"); | |
_MTL_PRIVATE_DEF_SEL(setCullMode_, | |
"setCullMode:"); | |
_MTL_PRIVATE_DEF_SEL(setCurveBasis_, | |
"setCurveBasis:"); | |
_MTL_PRIVATE_DEF_SEL(setCurveType_, | |
"setCurveType:"); | |
_MTL_PRIVATE_DEF_SEL(setDataType_, | |
"setDataType:"); | |
_MTL_PRIVATE_DEF_SEL(setDefaultCaptureScope_, | |
"setDefaultCaptureScope:"); | |
_MTL_PRIVATE_DEF_SEL(setDefaultRasterSampleCount_, | |
"setDefaultRasterSampleCount:"); | |
_MTL_PRIVATE_DEF_SEL(setDepth_, | |
"setDepth:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthAttachment_, | |
"setDepthAttachment:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthAttachmentPixelFormat_, | |
"setDepthAttachmentPixelFormat:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthBias_slopeScale_clamp_, | |
"setDepthBias:slopeScale:clamp:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthClipMode_, | |
"setDepthClipMode:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthCompareFunction_, | |
"setDepthCompareFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthFailureOperation_, | |
"setDepthFailureOperation:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthPlane_, | |
"setDepthPlane:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthResolveFilter_, | |
"setDepthResolveFilter:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthStencilPassOperation_, | |
"setDepthStencilPassOperation:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthStencilState_, | |
"setDepthStencilState:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthStoreAction_, | |
"setDepthStoreAction:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthStoreActionOptions_, | |
"setDepthStoreActionOptions:"); | |
_MTL_PRIVATE_DEF_SEL(setDepthWriteEnabled_, | |
"setDepthWriteEnabled:"); | |
_MTL_PRIVATE_DEF_SEL(setDestination_, | |
"setDestination:"); | |
_MTL_PRIVATE_DEF_SEL(setDestinationAlphaBlendFactor_, | |
"setDestinationAlphaBlendFactor:"); | |
_MTL_PRIVATE_DEF_SEL(setDestinationRGBBlendFactor_, | |
"setDestinationRGBBlendFactor:"); | |
_MTL_PRIVATE_DEF_SEL(setDispatchType_, | |
"setDispatchType:"); | |
_MTL_PRIVATE_DEF_SEL(setCurveEndCaps_, | |
"setCurveEndCaps:"); | |
_MTL_PRIVATE_DEF_SEL(setEndOfEncoderSampleIndex_, | |
"setEndOfEncoderSampleIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setEndOfFragmentSampleIndex_, | |
"setEndOfFragmentSampleIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setEndOfVertexSampleIndex_, | |
"setEndOfVertexSampleIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setErrorOptions_, | |
"setErrorOptions:"); | |
_MTL_PRIVATE_DEF_SEL(setFastMathEnabled_, | |
"setFastMathEnabled:"); | |
_MTL_PRIVATE_DEF_SEL(setFormat_, | |
"setFormat:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentAccelerationStructure_atBufferIndex_, | |
"setFragmentAccelerationStructure:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentAdditionalBinaryFunctions_, | |
"setFragmentAdditionalBinaryFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentBuffer_offset_atIndex_, | |
"setFragmentBuffer:offset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentBufferOffset_atIndex_, | |
"setFragmentBufferOffset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentBuffers_offsets_withRange_, | |
"setFragmentBuffers:offsets:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentBytes_length_atIndex_, | |
"setFragmentBytes:length:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentFunction_, | |
"setFragmentFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentIntersectionFunctionTable_atBufferIndex_, | |
"setFragmentIntersectionFunctionTable:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentIntersectionFunctionTables_withBufferRange_, | |
"setFragmentIntersectionFunctionTables:withBufferRange:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentLinkedFunctions_, | |
"setFragmentLinkedFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentPreloadedLibraries_, | |
"setFragmentPreloadedLibraries:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentSamplerState_atIndex_, | |
"setFragmentSamplerState:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_, | |
"setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_, | |
"setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentSamplerStates_withRange_, | |
"setFragmentSamplerStates:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentTexture_atIndex_, | |
"setFragmentTexture:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentTextures_withRange_, | |
"setFragmentTextures:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentVisibleFunctionTable_atBufferIndex_, | |
"setFragmentVisibleFunctionTable:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFragmentVisibleFunctionTables_withBufferRange_, | |
"setFragmentVisibleFunctionTables:withBufferRange:"); | |
_MTL_PRIVATE_DEF_SEL(setFrontFaceStencil_, | |
"setFrontFaceStencil:"); | |
_MTL_PRIVATE_DEF_SEL(setFrontFacingWinding_, | |
"setFrontFacingWinding:"); | |
_MTL_PRIVATE_DEF_SEL(setFunction_atIndex_, | |
"setFunction:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setFunctionCount_, | |
"setFunctionCount:"); | |
_MTL_PRIVATE_DEF_SEL(setFunctionGraphs_, | |
"setFunctionGraphs:"); | |
_MTL_PRIVATE_DEF_SEL(setFunctionName_, | |
"setFunctionName:"); | |
_MTL_PRIVATE_DEF_SEL(setFunctions_, | |
"setFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setFunctions_withRange_, | |
"setFunctions:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setGeometryDescriptors_, | |
"setGeometryDescriptors:"); | |
_MTL_PRIVATE_DEF_SEL(setGroups_, | |
"setGroups:"); | |
_MTL_PRIVATE_DEF_SEL(setHazardTrackingMode_, | |
"setHazardTrackingMode:"); | |
_MTL_PRIVATE_DEF_SEL(setHeight_, | |
"setHeight:"); | |
_MTL_PRIVATE_DEF_SEL(setImageblockSampleLength_, | |
"setImageblockSampleLength:"); | |
_MTL_PRIVATE_DEF_SEL(setImageblockWidth_height_, | |
"setImageblockWidth:height:"); | |
_MTL_PRIVATE_DEF_SEL(setIndex_, | |
"setIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setIndexBuffer_, | |
"setIndexBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setIndexBufferIndex_, | |
"setIndexBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setIndexBufferOffset_, | |
"setIndexBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setIndexType_, | |
"setIndexType:"); | |
_MTL_PRIVATE_DEF_SEL(setIndirectCommandBuffer_atIndex_, | |
"setIndirectCommandBuffer:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setIndirectCommandBuffers_withRange_, | |
"setIndirectCommandBuffers:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setInheritBuffers_, | |
"setInheritBuffers:"); | |
_MTL_PRIVATE_DEF_SEL(setInheritPipelineState_, | |
"setInheritPipelineState:"); | |
_MTL_PRIVATE_DEF_SEL(setInputPrimitiveTopology_, | |
"setInputPrimitiveTopology:"); | |
_MTL_PRIVATE_DEF_SEL(setInsertLibraries_, | |
"setInsertLibraries:"); | |
_MTL_PRIVATE_DEF_SEL(setInstallName_, | |
"setInstallName:"); | |
_MTL_PRIVATE_DEF_SEL(setInstanceCount_, | |
"setInstanceCount:"); | |
_MTL_PRIVATE_DEF_SEL(setInstanceCountBuffer_, | |
"setInstanceCountBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setInstanceCountBufferOffset_, | |
"setInstanceCountBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorBuffer_, | |
"setInstanceDescriptorBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorBufferOffset_, | |
"setInstanceDescriptorBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorStride_, | |
"setInstanceDescriptorStride:"); | |
_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorType_, | |
"setInstanceDescriptorType:"); | |
_MTL_PRIVATE_DEF_SEL(setInstancedAccelerationStructures_, | |
"setInstancedAccelerationStructures:"); | |
_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTable_atBufferIndex_, | |
"setIntersectionFunctionTable:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTable_atIndex_, | |
"setIntersectionFunctionTable:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTableOffset_, | |
"setIntersectionFunctionTableOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTables_withBufferRange_, | |
"setIntersectionFunctionTables:withBufferRange:"); | |
_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTables_withRange_, | |
"setIntersectionFunctionTables:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setKernelBuffer_offset_atIndex_, | |
"setKernelBuffer:offset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setKernelBuffer_offset_attributeStride_atIndex_, | |
"setKernelBuffer:offset:attributeStride:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setLabel_, | |
"setLabel:"); | |
_MTL_PRIVATE_DEF_SEL(setLanguageVersion_, | |
"setLanguageVersion:"); | |
_MTL_PRIVATE_DEF_SEL(setLayer_atIndex_, | |
"setLayer:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setLevel_, | |
"setLevel:"); | |
_MTL_PRIVATE_DEF_SEL(setLibraries_, | |
"setLibraries:"); | |
_MTL_PRIVATE_DEF_SEL(setLibraryType_, | |
"setLibraryType:"); | |
_MTL_PRIVATE_DEF_SEL(setLinkedFunctions_, | |
"setLinkedFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setLoadAction_, | |
"setLoadAction:"); | |
_MTL_PRIVATE_DEF_SEL(setLodAverage_, | |
"setLodAverage:"); | |
_MTL_PRIVATE_DEF_SEL(setLodMaxClamp_, | |
"setLodMaxClamp:"); | |
_MTL_PRIVATE_DEF_SEL(setLodMinClamp_, | |
"setLodMinClamp:"); | |
_MTL_PRIVATE_DEF_SEL(setMagFilter_, | |
"setMagFilter:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxAnisotropy_, | |
"setMaxAnisotropy:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxCallStackDepth_, | |
"setMaxCallStackDepth:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxCommandBufferCount_, | |
"setMaxCommandBufferCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxCommandsInFlight_, | |
"setMaxCommandsInFlight:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxFragmentBufferBindCount_, | |
"setMaxFragmentBufferBindCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxFragmentCallStackDepth_, | |
"setMaxFragmentCallStackDepth:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxInstanceCount_, | |
"setMaxInstanceCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxKernelBufferBindCount_, | |
"setMaxKernelBufferBindCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxKernelThreadgroupMemoryBindCount_, | |
"setMaxKernelThreadgroupMemoryBindCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxMotionTransformCount_, | |
"setMaxMotionTransformCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxTessellationFactor_, | |
"setMaxTessellationFactor:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadgroupsPerMeshGrid_, | |
"setMaxTotalThreadgroupsPerMeshGrid:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadsPerMeshThreadgroup_, | |
"setMaxTotalThreadsPerMeshThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadsPerObjectThreadgroup_, | |
"setMaxTotalThreadsPerObjectThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadsPerThreadgroup_, | |
"setMaxTotalThreadsPerThreadgroup:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxVertexAmplificationCount_, | |
"setMaxVertexAmplificationCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxVertexBufferBindCount_, | |
"setMaxVertexBufferBindCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMaxVertexCallStackDepth_, | |
"setMaxVertexCallStackDepth:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshBuffer_offset_atIndex_, | |
"setMeshBuffer:offset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshBufferOffset_atIndex_, | |
"setMeshBufferOffset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshBuffers_offsets_withRange_, | |
"setMeshBuffers:offsets:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshBytes_length_atIndex_, | |
"setMeshBytes:length:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshFunction_, | |
"setMeshFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshLinkedFunctions_, | |
"setMeshLinkedFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshSamplerState_atIndex_, | |
"setMeshSamplerState:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshSamplerState_lodMinClamp_lodMaxClamp_atIndex_, | |
"setMeshSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshSamplerStates_lodMinClamps_lodMaxClamps_withRange_, | |
"setMeshSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshSamplerStates_withRange_, | |
"setMeshSamplerStates:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshTexture_atIndex_, | |
"setMeshTexture:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshTextures_withRange_, | |
"setMeshTextures:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth_, | |
"setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth:"); | |
_MTL_PRIVATE_DEF_SEL(setMinFilter_, | |
"setMinFilter:"); | |
_MTL_PRIVATE_DEF_SEL(setMipFilter_, | |
"setMipFilter:"); | |
_MTL_PRIVATE_DEF_SEL(setMipmapLevelCount_, | |
"setMipmapLevelCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionEndBorderMode_, | |
"setMotionEndBorderMode:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionEndTime_, | |
"setMotionEndTime:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionKeyframeCount_, | |
"setMotionKeyframeCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionStartBorderMode_, | |
"setMotionStartBorderMode:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionStartTime_, | |
"setMotionStartTime:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionTransformBuffer_, | |
"setMotionTransformBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionTransformBufferOffset_, | |
"setMotionTransformBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionTransformCount_, | |
"setMotionTransformCount:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionTransformCountBuffer_, | |
"setMotionTransformCountBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setMotionTransformCountBufferOffset_, | |
"setMotionTransformCountBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setMutability_, | |
"setMutability:"); | |
_MTL_PRIVATE_DEF_SEL(setName_, | |
"setName:"); | |
_MTL_PRIVATE_DEF_SEL(setNodes_, | |
"setNodes:"); | |
_MTL_PRIVATE_DEF_SEL(setNormalizedCoordinates_, | |
"setNormalizedCoordinates:"); | |
_MTL_PRIVATE_DEF_SEL(setObject_atIndexedSubscript_, | |
"setObject:atIndexedSubscript:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectBuffer_offset_atIndex_, | |
"setObjectBuffer:offset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectBufferOffset_atIndex_, | |
"setObjectBufferOffset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectBuffers_offsets_withRange_, | |
"setObjectBuffers:offsets:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectBytes_length_atIndex_, | |
"setObjectBytes:length:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectFunction_, | |
"setObjectFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectLinkedFunctions_, | |
"setObjectLinkedFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectSamplerState_atIndex_, | |
"setObjectSamplerState:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectSamplerState_lodMinClamp_lodMaxClamp_atIndex_, | |
"setObjectSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectSamplerStates_lodMinClamps_lodMaxClamps_withRange_, | |
"setObjectSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectSamplerStates_withRange_, | |
"setObjectSamplerStates:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectTexture_atIndex_, | |
"setObjectTexture:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectTextures_withRange_, | |
"setObjectTextures:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectThreadgroupMemoryLength_atIndex_, | |
"setObjectThreadgroupMemoryLength:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth_, | |
"setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth:"); | |
_MTL_PRIVATE_DEF_SEL(setOffset_, | |
"setOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setOpaque_, | |
"setOpaque:"); | |
_MTL_PRIVATE_DEF_SEL(setOpaqueCurveIntersectionFunctionWithSignature_atIndex_, | |
"setOpaqueCurveIntersectionFunctionWithSignature:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setOpaqueCurveIntersectionFunctionWithSignature_withRange_, | |
"setOpaqueCurveIntersectionFunctionWithSignature:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_, | |
"setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_withRange_, | |
"setOpaqueTriangleIntersectionFunctionWithSignature:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setOptimizationLevel_, | |
"setOptimizationLevel:"); | |
_MTL_PRIVATE_DEF_SEL(setOptions_, | |
"setOptions:"); | |
_MTL_PRIVATE_DEF_SEL(setOutputNode_, | |
"setOutputNode:"); | |
_MTL_PRIVATE_DEF_SEL(setOutputURL_, | |
"setOutputURL:"); | |
_MTL_PRIVATE_DEF_SEL(setPayloadMemoryLength_, | |
"setPayloadMemoryLength:"); | |
_MTL_PRIVATE_DEF_SEL(setPixelFormat_, | |
"setPixelFormat:"); | |
_MTL_PRIVATE_DEF_SEL(setPreloadedLibraries_, | |
"setPreloadedLibraries:"); | |
_MTL_PRIVATE_DEF_SEL(setPreprocessorMacros_, | |
"setPreprocessorMacros:"); | |
_MTL_PRIVATE_DEF_SEL(setPreserveInvariance_, | |
"setPreserveInvariance:"); | |
_MTL_PRIVATE_DEF_SEL(setPrimitiveDataBuffer_, | |
"setPrimitiveDataBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setPrimitiveDataBufferOffset_, | |
"setPrimitiveDataBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setPrimitiveDataElementSize_, | |
"setPrimitiveDataElementSize:"); | |
_MTL_PRIVATE_DEF_SEL(setPrimitiveDataStride_, | |
"setPrimitiveDataStride:"); | |
_MTL_PRIVATE_DEF_SEL(setPriority_, | |
"setPriority:"); | |
_MTL_PRIVATE_DEF_SEL(setPrivateFunctions_, | |
"setPrivateFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setPurgeableState_, | |
"setPurgeableState:"); | |
_MTL_PRIVATE_DEF_SEL(setRAddressMode_, | |
"setRAddressMode:"); | |
_MTL_PRIVATE_DEF_SEL(setRadiusBuffer_, | |
"setRadiusBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setRadiusBufferOffset_, | |
"setRadiusBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setRadiusBuffers_, | |
"setRadiusBuffers:"); | |
_MTL_PRIVATE_DEF_SEL(setRadiusFormat_, | |
"setRadiusFormat:"); | |
_MTL_PRIVATE_DEF_SEL(setRadiusStride_, | |
"setRadiusStride:"); | |
_MTL_PRIVATE_DEF_SEL(setRasterSampleCount_, | |
"setRasterSampleCount:"); | |
_MTL_PRIVATE_DEF_SEL(setRasterizationEnabled_, | |
"setRasterizationEnabled:"); | |
_MTL_PRIVATE_DEF_SEL(setRasterizationRateMap_, | |
"setRasterizationRateMap:"); | |
_MTL_PRIVATE_DEF_SEL(setReadMask_, | |
"setReadMask:"); | |
_MTL_PRIVATE_DEF_SEL(setRenderPipelineState_, | |
"setRenderPipelineState:"); | |
_MTL_PRIVATE_DEF_SEL(setRenderPipelineState_atIndex_, | |
"setRenderPipelineState:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setRenderPipelineStates_withRange_, | |
"setRenderPipelineStates:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setRenderTargetArrayLength_, | |
"setRenderTargetArrayLength:"); | |
_MTL_PRIVATE_DEF_SEL(setRenderTargetHeight_, | |
"setRenderTargetHeight:"); | |
_MTL_PRIVATE_DEF_SEL(setRenderTargetWidth_, | |
"setRenderTargetWidth:"); | |
_MTL_PRIVATE_DEF_SEL(setResolveDepthPlane_, | |
"setResolveDepthPlane:"); | |
_MTL_PRIVATE_DEF_SEL(setResolveLevel_, | |
"setResolveLevel:"); | |
_MTL_PRIVATE_DEF_SEL(setResolveSlice_, | |
"setResolveSlice:"); | |
_MTL_PRIVATE_DEF_SEL(setResolveTexture_, | |
"setResolveTexture:"); | |
_MTL_PRIVATE_DEF_SEL(setResourceOptions_, | |
"setResourceOptions:"); | |
_MTL_PRIVATE_DEF_SEL(setRetainedReferences_, | |
"setRetainedReferences:"); | |
_MTL_PRIVATE_DEF_SEL(setRgbBlendOperation_, | |
"setRgbBlendOperation:"); | |
_MTL_PRIVATE_DEF_SEL(setSAddressMode_, | |
"setSAddressMode:"); | |
_MTL_PRIVATE_DEF_SEL(setSampleBuffer_, | |
"setSampleBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setSampleCount_, | |
"setSampleCount:"); | |
_MTL_PRIVATE_DEF_SEL(setSamplePositions_count_, | |
"setSamplePositions:count:"); | |
_MTL_PRIVATE_DEF_SEL(setSamplerState_atIndex_, | |
"setSamplerState:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setSamplerState_lodMinClamp_lodMaxClamp_atIndex_, | |
"setSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setSamplerStates_lodMinClamps_lodMaxClamps_withRange_, | |
"setSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setSamplerStates_withRange_, | |
"setSamplerStates:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setScissorRect_, | |
"setScissorRect:"); | |
_MTL_PRIVATE_DEF_SEL(setScissorRects_count_, | |
"setScissorRects:count:"); | |
_MTL_PRIVATE_DEF_SEL(setScratchBufferAllocator_, | |
"setScratchBufferAllocator:"); | |
_MTL_PRIVATE_DEF_SEL(setScreenSize_, | |
"setScreenSize:"); | |
_MTL_PRIVATE_DEF_SEL(setSegmentControlPointCount_, | |
"setSegmentControlPointCount:"); | |
_MTL_PRIVATE_DEF_SEL(setSegmentCount_, | |
"setSegmentCount:"); | |
_MTL_PRIVATE_DEF_SEL(setShouldMaximizeConcurrentCompilation_, | |
"setShouldMaximizeConcurrentCompilation:"); | |
_MTL_PRIVATE_DEF_SEL(setSignaledValue_, | |
"setSignaledValue:"); | |
_MTL_PRIVATE_DEF_SEL(setSize_, | |
"setSize:"); | |
_MTL_PRIVATE_DEF_SEL(setSlice_, | |
"setSlice:"); | |
_MTL_PRIVATE_DEF_SEL(setSourceAlphaBlendFactor_, | |
"setSourceAlphaBlendFactor:"); | |
_MTL_PRIVATE_DEF_SEL(setSourceRGBBlendFactor_, | |
"setSourceRGBBlendFactor:"); | |
_MTL_PRIVATE_DEF_SEL(setSparsePageSize_, | |
"setSparsePageSize:"); | |
_MTL_PRIVATE_DEF_SEL(setSpecializedName_, | |
"setSpecializedName:"); | |
_MTL_PRIVATE_DEF_SEL(setStageInRegion_, | |
"setStageInRegion:"); | |
_MTL_PRIVATE_DEF_SEL(setStageInRegionWithIndirectBuffer_indirectBufferOffset_, | |
"setStageInRegionWithIndirectBuffer:indirectBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setStageInputDescriptor_, | |
"setStageInputDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(setStartOfEncoderSampleIndex_, | |
"setStartOfEncoderSampleIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setStartOfFragmentSampleIndex_, | |
"setStartOfFragmentSampleIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setStartOfVertexSampleIndex_, | |
"setStartOfVertexSampleIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setStencilAttachment_, | |
"setStencilAttachment:"); | |
_MTL_PRIVATE_DEF_SEL(setStencilAttachmentPixelFormat_, | |
"setStencilAttachmentPixelFormat:"); | |
_MTL_PRIVATE_DEF_SEL(setStencilCompareFunction_, | |
"setStencilCompareFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setStencilFailureOperation_, | |
"setStencilFailureOperation:"); | |
_MTL_PRIVATE_DEF_SEL(setStencilFrontReferenceValue_backReferenceValue_, | |
"setStencilFrontReferenceValue:backReferenceValue:"); | |
_MTL_PRIVATE_DEF_SEL(setStencilReferenceValue_, | |
"setStencilReferenceValue:"); | |
_MTL_PRIVATE_DEF_SEL(setStencilResolveFilter_, | |
"setStencilResolveFilter:"); | |
_MTL_PRIVATE_DEF_SEL(setStencilStoreAction_, | |
"setStencilStoreAction:"); | |
_MTL_PRIVATE_DEF_SEL(setStencilStoreActionOptions_, | |
"setStencilStoreActionOptions:"); | |
_MTL_PRIVATE_DEF_SEL(setStepFunction_, | |
"setStepFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setStepRate_, | |
"setStepRate:"); | |
_MTL_PRIVATE_DEF_SEL(setStorageMode_, | |
"setStorageMode:"); | |
_MTL_PRIVATE_DEF_SEL(setStoreAction_, | |
"setStoreAction:"); | |
_MTL_PRIVATE_DEF_SEL(setStoreActionOptions_, | |
"setStoreActionOptions:"); | |
_MTL_PRIVATE_DEF_SEL(setStride_, | |
"setStride:"); | |
_MTL_PRIVATE_DEF_SEL(setSupportAddingBinaryFunctions_, | |
"setSupportAddingBinaryFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setSupportAddingFragmentBinaryFunctions_, | |
"setSupportAddingFragmentBinaryFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setSupportAddingVertexBinaryFunctions_, | |
"setSupportAddingVertexBinaryFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setSupportArgumentBuffers_, | |
"setSupportArgumentBuffers:"); | |
_MTL_PRIVATE_DEF_SEL(setSupportDynamicAttributeStride_, | |
"setSupportDynamicAttributeStride:"); | |
_MTL_PRIVATE_DEF_SEL(setSupportIndirectCommandBuffers_, | |
"setSupportIndirectCommandBuffers:"); | |
_MTL_PRIVATE_DEF_SEL(setSupportRayTracing_, | |
"setSupportRayTracing:"); | |
_MTL_PRIVATE_DEF_SEL(setSwizzle_, | |
"setSwizzle:"); | |
_MTL_PRIVATE_DEF_SEL(setTAddressMode_, | |
"setTAddressMode:"); | |
_MTL_PRIVATE_DEF_SEL(setTessellationControlPointIndexType_, | |
"setTessellationControlPointIndexType:"); | |
_MTL_PRIVATE_DEF_SEL(setTessellationFactorBuffer_offset_instanceStride_, | |
"setTessellationFactorBuffer:offset:instanceStride:"); | |
_MTL_PRIVATE_DEF_SEL(setTessellationFactorFormat_, | |
"setTessellationFactorFormat:"); | |
_MTL_PRIVATE_DEF_SEL(setTessellationFactorScale_, | |
"setTessellationFactorScale:"); | |
_MTL_PRIVATE_DEF_SEL(setTessellationFactorScaleEnabled_, | |
"setTessellationFactorScaleEnabled:"); | |
_MTL_PRIVATE_DEF_SEL(setTessellationFactorStepFunction_, | |
"setTessellationFactorStepFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setTessellationOutputWindingOrder_, | |
"setTessellationOutputWindingOrder:"); | |
_MTL_PRIVATE_DEF_SEL(setTessellationPartitionMode_, | |
"setTessellationPartitionMode:"); | |
_MTL_PRIVATE_DEF_SEL(setTexture_, | |
"setTexture:"); | |
_MTL_PRIVATE_DEF_SEL(setTexture_atIndex_, | |
"setTexture:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTextureType_, | |
"setTextureType:"); | |
_MTL_PRIVATE_DEF_SEL(setTextures_withRange_, | |
"setTextures:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setThreadGroupSizeIsMultipleOfThreadExecutionWidth_, | |
"setThreadGroupSizeIsMultipleOfThreadExecutionWidth:"); | |
_MTL_PRIVATE_DEF_SEL(setThreadgroupMemoryLength_, | |
"setThreadgroupMemoryLength:"); | |
_MTL_PRIVATE_DEF_SEL(setThreadgroupMemoryLength_atIndex_, | |
"setThreadgroupMemoryLength:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setThreadgroupMemoryLength_offset_atIndex_, | |
"setThreadgroupMemoryLength:offset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setThreadgroupSizeMatchesTileSize_, | |
"setThreadgroupSizeMatchesTileSize:"); | |
_MTL_PRIVATE_DEF_SEL(setTileAccelerationStructure_atBufferIndex_, | |
"setTileAccelerationStructure:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTileAdditionalBinaryFunctions_, | |
"setTileAdditionalBinaryFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setTileBuffer_offset_atIndex_, | |
"setTileBuffer:offset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTileBufferOffset_atIndex_, | |
"setTileBufferOffset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTileBuffers_offsets_withRange_, | |
"setTileBuffers:offsets:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setTileBytes_length_atIndex_, | |
"setTileBytes:length:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTileFunction_, | |
"setTileFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setTileHeight_, | |
"setTileHeight:"); | |
_MTL_PRIVATE_DEF_SEL(setTileIntersectionFunctionTable_atBufferIndex_, | |
"setTileIntersectionFunctionTable:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTileIntersectionFunctionTables_withBufferRange_, | |
"setTileIntersectionFunctionTables:withBufferRange:"); | |
_MTL_PRIVATE_DEF_SEL(setTileSamplerState_atIndex_, | |
"setTileSamplerState:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_, | |
"setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_, | |
"setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setTileSamplerStates_withRange_, | |
"setTileSamplerStates:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setTileTexture_atIndex_, | |
"setTileTexture:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTileTextures_withRange_, | |
"setTileTextures:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setTileVisibleFunctionTable_atBufferIndex_, | |
"setTileVisibleFunctionTable:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setTileVisibleFunctionTables_withBufferRange_, | |
"setTileVisibleFunctionTables:withBufferRange:"); | |
_MTL_PRIVATE_DEF_SEL(setTileWidth_, | |
"setTileWidth:"); | |
_MTL_PRIVATE_DEF_SEL(setTransformationMatrixBuffer_, | |
"setTransformationMatrixBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setTransformationMatrixBufferOffset_, | |
"setTransformationMatrixBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setTriangleCount_, | |
"setTriangleCount:"); | |
_MTL_PRIVATE_DEF_SEL(setTriangleFillMode_, | |
"setTriangleFillMode:"); | |
_MTL_PRIVATE_DEF_SEL(setType_, | |
"setType:"); | |
_MTL_PRIVATE_DEF_SEL(setUrl_, | |
"setUrl:"); | |
_MTL_PRIVATE_DEF_SEL(setUsage_, | |
"setUsage:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexAccelerationStructure_atBufferIndex_, | |
"setVertexAccelerationStructure:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexAdditionalBinaryFunctions_, | |
"setVertexAdditionalBinaryFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexAmplificationCount_viewMappings_, | |
"setVertexAmplificationCount:viewMappings:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBuffer_, | |
"setVertexBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBuffer_offset_atIndex_, | |
"setVertexBuffer:offset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBuffer_offset_attributeStride_atIndex_, | |
"setVertexBuffer:offset:attributeStride:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBufferOffset_, | |
"setVertexBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBufferOffset_atIndex_, | |
"setVertexBufferOffset:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBufferOffset_attributeStride_atIndex_, | |
"setVertexBufferOffset:attributeStride:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBuffers_, | |
"setVertexBuffers:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBuffers_offsets_attributeStrides_withRange_, | |
"setVertexBuffers:offsets:attributeStrides:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBuffers_offsets_withRange_, | |
"setVertexBuffers:offsets:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBytes_length_atIndex_, | |
"setVertexBytes:length:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexBytes_length_attributeStride_atIndex_, | |
"setVertexBytes:length:attributeStride:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexDescriptor_, | |
"setVertexDescriptor:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexFormat_, | |
"setVertexFormat:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexFunction_, | |
"setVertexFunction:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexIntersectionFunctionTable_atBufferIndex_, | |
"setVertexIntersectionFunctionTable:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexIntersectionFunctionTables_withBufferRange_, | |
"setVertexIntersectionFunctionTables:withBufferRange:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexLinkedFunctions_, | |
"setVertexLinkedFunctions:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexPreloadedLibraries_, | |
"setVertexPreloadedLibraries:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexSamplerState_atIndex_, | |
"setVertexSamplerState:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_, | |
"setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_, | |
"setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexSamplerStates_withRange_, | |
"setVertexSamplerStates:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexStride_, | |
"setVertexStride:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexTexture_atIndex_, | |
"setVertexTexture:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexTextures_withRange_, | |
"setVertexTextures:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexVisibleFunctionTable_atBufferIndex_, | |
"setVertexVisibleFunctionTable:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVertexVisibleFunctionTables_withBufferRange_, | |
"setVertexVisibleFunctionTables:withBufferRange:"); | |
_MTL_PRIVATE_DEF_SEL(setViewport_, | |
"setViewport:"); | |
_MTL_PRIVATE_DEF_SEL(setViewports_count_, | |
"setViewports:count:"); | |
_MTL_PRIVATE_DEF_SEL(setVisibilityResultBuffer_, | |
"setVisibilityResultBuffer:"); | |
_MTL_PRIVATE_DEF_SEL(setVisibilityResultMode_offset_, | |
"setVisibilityResultMode:offset:"); | |
_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTable_atBufferIndex_, | |
"setVisibleFunctionTable:atBufferIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTable_atIndex_, | |
"setVisibleFunctionTable:atIndex:"); | |
_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTables_withBufferRange_, | |
"setVisibleFunctionTables:withBufferRange:"); | |
_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTables_withRange_, | |
"setVisibleFunctionTables:withRange:"); | |
_MTL_PRIVATE_DEF_SEL(setWidth_, | |
"setWidth:"); | |
_MTL_PRIVATE_DEF_SEL(setWriteMask_, | |
"setWriteMask:"); | |
_MTL_PRIVATE_DEF_SEL(sharedCaptureManager, | |
"sharedCaptureManager"); | |
_MTL_PRIVATE_DEF_SEL(shouldMaximizeConcurrentCompilation, | |
"shouldMaximizeConcurrentCompilation"); | |
_MTL_PRIVATE_DEF_SEL(signalEvent_value_, | |
"signalEvent:value:"); | |
_MTL_PRIVATE_DEF_SEL(signaledValue, | |
"signaledValue"); | |
_MTL_PRIVATE_DEF_SEL(size, | |
"size"); | |
_MTL_PRIVATE_DEF_SEL(slice, | |
"slice"); | |
_MTL_PRIVATE_DEF_SEL(sourceAlphaBlendFactor, | |
"sourceAlphaBlendFactor"); | |
_MTL_PRIVATE_DEF_SEL(sourceRGBBlendFactor, | |
"sourceRGBBlendFactor"); | |
_MTL_PRIVATE_DEF_SEL(sparsePageSize, | |
"sparsePageSize"); | |
_MTL_PRIVATE_DEF_SEL(sparseTileSizeInBytes, | |
"sparseTileSizeInBytes"); | |
_MTL_PRIVATE_DEF_SEL(sparseTileSizeInBytesForSparsePageSize_, | |
"sparseTileSizeInBytesForSparsePageSize:"); | |
_MTL_PRIVATE_DEF_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_, | |
"sparseTileSizeWithTextureType:pixelFormat:sampleCount:"); | |
_MTL_PRIVATE_DEF_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_sparsePageSize_, | |
"sparseTileSizeWithTextureType:pixelFormat:sampleCount:sparsePageSize:"); | |
_MTL_PRIVATE_DEF_SEL(specializedName, | |
"specializedName"); | |
_MTL_PRIVATE_DEF_SEL(stageInputAttributes, | |
"stageInputAttributes"); | |
_MTL_PRIVATE_DEF_SEL(stageInputDescriptor, | |
"stageInputDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(stageInputOutputDescriptor, | |
"stageInputOutputDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(startCaptureWithCommandQueue_, | |
"startCaptureWithCommandQueue:"); | |
_MTL_PRIVATE_DEF_SEL(startCaptureWithDescriptor_error_, | |
"startCaptureWithDescriptor:error:"); | |
_MTL_PRIVATE_DEF_SEL(startCaptureWithDevice_, | |
"startCaptureWithDevice:"); | |
_MTL_PRIVATE_DEF_SEL(startCaptureWithScope_, | |
"startCaptureWithScope:"); | |
_MTL_PRIVATE_DEF_SEL(startOfEncoderSampleIndex, | |
"startOfEncoderSampleIndex"); | |
_MTL_PRIVATE_DEF_SEL(startOfFragmentSampleIndex, | |
"startOfFragmentSampleIndex"); | |
_MTL_PRIVATE_DEF_SEL(startOfVertexSampleIndex, | |
"startOfVertexSampleIndex"); | |
_MTL_PRIVATE_DEF_SEL(staticThreadgroupMemoryLength, | |
"staticThreadgroupMemoryLength"); | |
_MTL_PRIVATE_DEF_SEL(status, | |
"status"); | |
_MTL_PRIVATE_DEF_SEL(stencilAttachment, | |
"stencilAttachment"); | |
_MTL_PRIVATE_DEF_SEL(stencilAttachmentPixelFormat, | |
"stencilAttachmentPixelFormat"); | |
_MTL_PRIVATE_DEF_SEL(stencilCompareFunction, | |
"stencilCompareFunction"); | |
_MTL_PRIVATE_DEF_SEL(stencilFailureOperation, | |
"stencilFailureOperation"); | |
_MTL_PRIVATE_DEF_SEL(stencilResolveFilter, | |
"stencilResolveFilter"); | |
_MTL_PRIVATE_DEF_SEL(stepFunction, | |
"stepFunction"); | |
_MTL_PRIVATE_DEF_SEL(stepRate, | |
"stepRate"); | |
_MTL_PRIVATE_DEF_SEL(stopCapture, | |
"stopCapture"); | |
_MTL_PRIVATE_DEF_SEL(storageMode, | |
"storageMode"); | |
_MTL_PRIVATE_DEF_SEL(storeAction, | |
"storeAction"); | |
_MTL_PRIVATE_DEF_SEL(storeActionOptions, | |
"storeActionOptions"); | |
_MTL_PRIVATE_DEF_SEL(stride, | |
"stride"); | |
_MTL_PRIVATE_DEF_SEL(structType, | |
"structType"); | |
_MTL_PRIVATE_DEF_SEL(supportAddingBinaryFunctions, | |
"supportAddingBinaryFunctions"); | |
_MTL_PRIVATE_DEF_SEL(supportAddingFragmentBinaryFunctions, | |
"supportAddingFragmentBinaryFunctions"); | |
_MTL_PRIVATE_DEF_SEL(supportAddingVertexBinaryFunctions, | |
"supportAddingVertexBinaryFunctions"); | |
_MTL_PRIVATE_DEF_SEL(supportArgumentBuffers, | |
"supportArgumentBuffers"); | |
_MTL_PRIVATE_DEF_SEL(supportDynamicAttributeStride, | |
"supportDynamicAttributeStride"); | |
_MTL_PRIVATE_DEF_SEL(supportIndirectCommandBuffers, | |
"supportIndirectCommandBuffers"); | |
_MTL_PRIVATE_DEF_SEL(supportRayTracing, | |
"supportRayTracing"); | |
_MTL_PRIVATE_DEF_SEL(supports32BitFloatFiltering, | |
"supports32BitFloatFiltering"); | |
_MTL_PRIVATE_DEF_SEL(supports32BitMSAA, | |
"supports32BitMSAA"); | |
_MTL_PRIVATE_DEF_SEL(supportsBCTextureCompression, | |
"supportsBCTextureCompression"); | |
_MTL_PRIVATE_DEF_SEL(supportsCounterSampling_, | |
"supportsCounterSampling:"); | |
_MTL_PRIVATE_DEF_SEL(supportsDestination_, | |
"supportsDestination:"); | |
_MTL_PRIVATE_DEF_SEL(supportsDynamicLibraries, | |
"supportsDynamicLibraries"); | |
_MTL_PRIVATE_DEF_SEL(supportsFamily_, | |
"supportsFamily:"); | |
_MTL_PRIVATE_DEF_SEL(supportsFeatureSet_, | |
"supportsFeatureSet:"); | |
_MTL_PRIVATE_DEF_SEL(supportsFunctionPointers, | |
"supportsFunctionPointers"); | |
_MTL_PRIVATE_DEF_SEL(supportsFunctionPointersFromRender, | |
"supportsFunctionPointersFromRender"); | |
_MTL_PRIVATE_DEF_SEL(supportsPrimitiveMotionBlur, | |
"supportsPrimitiveMotionBlur"); | |
_MTL_PRIVATE_DEF_SEL(supportsPullModelInterpolation, | |
"supportsPullModelInterpolation"); | |
_MTL_PRIVATE_DEF_SEL(supportsQueryTextureLOD, | |
"supportsQueryTextureLOD"); | |
_MTL_PRIVATE_DEF_SEL(supportsRasterizationRateMapWithLayerCount_, | |
"supportsRasterizationRateMapWithLayerCount:"); | |
_MTL_PRIVATE_DEF_SEL(supportsRaytracing, | |
"supportsRaytracing"); | |
_MTL_PRIVATE_DEF_SEL(supportsRaytracingFromRender, | |
"supportsRaytracingFromRender"); | |
_MTL_PRIVATE_DEF_SEL(supportsRenderDynamicLibraries, | |
"supportsRenderDynamicLibraries"); | |
_MTL_PRIVATE_DEF_SEL(supportsShaderBarycentricCoordinates, | |
"supportsShaderBarycentricCoordinates"); | |
_MTL_PRIVATE_DEF_SEL(supportsTextureSampleCount_, | |
"supportsTextureSampleCount:"); | |
_MTL_PRIVATE_DEF_SEL(supportsVertexAmplificationCount_, | |
"supportsVertexAmplificationCount:"); | |
_MTL_PRIVATE_DEF_SEL(swizzle, | |
"swizzle"); | |
_MTL_PRIVATE_DEF_SEL(synchronizeResource_, | |
"synchronizeResource:"); | |
_MTL_PRIVATE_DEF_SEL(synchronizeTexture_slice_level_, | |
"synchronizeTexture:slice:level:"); | |
_MTL_PRIVATE_DEF_SEL(tAddressMode, | |
"tAddressMode"); | |
_MTL_PRIVATE_DEF_SEL(tailSizeInBytes, | |
"tailSizeInBytes"); | |
_MTL_PRIVATE_DEF_SEL(tessellationControlPointIndexType, | |
"tessellationControlPointIndexType"); | |
_MTL_PRIVATE_DEF_SEL(tessellationFactorFormat, | |
"tessellationFactorFormat"); | |
_MTL_PRIVATE_DEF_SEL(tessellationFactorStepFunction, | |
"tessellationFactorStepFunction"); | |
_MTL_PRIVATE_DEF_SEL(tessellationOutputWindingOrder, | |
"tessellationOutputWindingOrder"); | |
_MTL_PRIVATE_DEF_SEL(tessellationPartitionMode, | |
"tessellationPartitionMode"); | |
_MTL_PRIVATE_DEF_SEL(texture, | |
"texture"); | |
_MTL_PRIVATE_DEF_SEL(texture2DDescriptorWithPixelFormat_width_height_mipmapped_, | |
"texture2DDescriptorWithPixelFormat:width:height:mipmapped:"); | |
_MTL_PRIVATE_DEF_SEL(textureBarrier, | |
"textureBarrier"); | |
_MTL_PRIVATE_DEF_SEL(textureBufferDescriptorWithPixelFormat_width_resourceOptions_usage_, | |
"textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:"); | |
_MTL_PRIVATE_DEF_SEL(textureCubeDescriptorWithPixelFormat_size_mipmapped_, | |
"textureCubeDescriptorWithPixelFormat:size:mipmapped:"); | |
_MTL_PRIVATE_DEF_SEL(textureDataType, | |
"textureDataType"); | |
_MTL_PRIVATE_DEF_SEL(textureReferenceType, | |
"textureReferenceType"); | |
_MTL_PRIVATE_DEF_SEL(textureType, | |
"textureType"); | |
_MTL_PRIVATE_DEF_SEL(threadExecutionWidth, | |
"threadExecutionWidth"); | |
_MTL_PRIVATE_DEF_SEL(threadGroupSizeIsMultipleOfThreadExecutionWidth, | |
"threadGroupSizeIsMultipleOfThreadExecutionWidth"); | |
_MTL_PRIVATE_DEF_SEL(threadgroupMemoryAlignment, | |
"threadgroupMemoryAlignment"); | |
_MTL_PRIVATE_DEF_SEL(threadgroupMemoryDataSize, | |
"threadgroupMemoryDataSize"); | |
_MTL_PRIVATE_DEF_SEL(threadgroupMemoryLength, | |
"threadgroupMemoryLength"); | |
_MTL_PRIVATE_DEF_SEL(threadgroupSizeMatchesTileSize, | |
"threadgroupSizeMatchesTileSize"); | |
_MTL_PRIVATE_DEF_SEL(tileAdditionalBinaryFunctions, | |
"tileAdditionalBinaryFunctions"); | |
_MTL_PRIVATE_DEF_SEL(tileArguments, | |
"tileArguments"); | |
_MTL_PRIVATE_DEF_SEL(tileBindings, | |
"tileBindings"); | |
_MTL_PRIVATE_DEF_SEL(tileBuffers, | |
"tileBuffers"); | |
_MTL_PRIVATE_DEF_SEL(tileFunction, | |
"tileFunction"); | |
_MTL_PRIVATE_DEF_SEL(tileHeight, | |
"tileHeight"); | |
_MTL_PRIVATE_DEF_SEL(tileWidth, | |
"tileWidth"); | |
_MTL_PRIVATE_DEF_SEL(transformationMatrixBuffer, | |
"transformationMatrixBuffer"); | |
_MTL_PRIVATE_DEF_SEL(transformationMatrixBufferOffset, | |
"transformationMatrixBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(triangleCount, | |
"triangleCount"); | |
_MTL_PRIVATE_DEF_SEL(tryCancel, | |
"tryCancel"); | |
_MTL_PRIVATE_DEF_SEL(type, | |
"type"); | |
_MTL_PRIVATE_DEF_SEL(updateFence_, | |
"updateFence:"); | |
_MTL_PRIVATE_DEF_SEL(updateFence_afterStages_, | |
"updateFence:afterStages:"); | |
_MTL_PRIVATE_DEF_SEL(updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_, | |
"updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:"); | |
_MTL_PRIVATE_DEF_SEL(updateTextureMapping_mode_region_mipLevel_slice_, | |
"updateTextureMapping:mode:region:mipLevel:slice:"); | |
_MTL_PRIVATE_DEF_SEL(updateTextureMappings_mode_regions_mipLevels_slices_numRegions_, | |
"updateTextureMappings:mode:regions:mipLevels:slices:numRegions:"); | |
_MTL_PRIVATE_DEF_SEL(url, | |
"url"); | |
_MTL_PRIVATE_DEF_SEL(usage, | |
"usage"); | |
_MTL_PRIVATE_DEF_SEL(useHeap_, | |
"useHeap:"); | |
_MTL_PRIVATE_DEF_SEL(useHeap_stages_, | |
"useHeap:stages:"); | |
_MTL_PRIVATE_DEF_SEL(useHeaps_count_, | |
"useHeaps:count:"); | |
_MTL_PRIVATE_DEF_SEL(useHeaps_count_stages_, | |
"useHeaps:count:stages:"); | |
_MTL_PRIVATE_DEF_SEL(useResource_usage_, | |
"useResource:usage:"); | |
_MTL_PRIVATE_DEF_SEL(useResource_usage_stages_, | |
"useResource:usage:stages:"); | |
_MTL_PRIVATE_DEF_SEL(useResources_count_usage_, | |
"useResources:count:usage:"); | |
_MTL_PRIVATE_DEF_SEL(useResources_count_usage_stages_, | |
"useResources:count:usage:stages:"); | |
_MTL_PRIVATE_DEF_SEL(usedSize, | |
"usedSize"); | |
_MTL_PRIVATE_DEF_SEL(vertexAdditionalBinaryFunctions, | |
"vertexAdditionalBinaryFunctions"); | |
_MTL_PRIVATE_DEF_SEL(vertexArguments, | |
"vertexArguments"); | |
_MTL_PRIVATE_DEF_SEL(vertexAttributes, | |
"vertexAttributes"); | |
_MTL_PRIVATE_DEF_SEL(vertexBindings, | |
"vertexBindings"); | |
_MTL_PRIVATE_DEF_SEL(vertexBuffer, | |
"vertexBuffer"); | |
_MTL_PRIVATE_DEF_SEL(vertexBufferOffset, | |
"vertexBufferOffset"); | |
_MTL_PRIVATE_DEF_SEL(vertexBuffers, | |
"vertexBuffers"); | |
_MTL_PRIVATE_DEF_SEL(vertexDescriptor, | |
"vertexDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(vertexFormat, | |
"vertexFormat"); | |
_MTL_PRIVATE_DEF_SEL(vertexFunction, | |
"vertexFunction"); | |
_MTL_PRIVATE_DEF_SEL(vertexLinkedFunctions, | |
"vertexLinkedFunctions"); | |
_MTL_PRIVATE_DEF_SEL(vertexPreloadedLibraries, | |
"vertexPreloadedLibraries"); | |
_MTL_PRIVATE_DEF_SEL(vertexStride, | |
"vertexStride"); | |
_MTL_PRIVATE_DEF_SEL(vertical, | |
"vertical"); | |
_MTL_PRIVATE_DEF_SEL(verticalSampleStorage, | |
"verticalSampleStorage"); | |
_MTL_PRIVATE_DEF_SEL(visibilityResultBuffer, | |
"visibilityResultBuffer"); | |
_MTL_PRIVATE_DEF_SEL(visibleFunctionTableDescriptor, | |
"visibleFunctionTableDescriptor"); | |
_MTL_PRIVATE_DEF_SEL(waitForEvent_value_, | |
"waitForEvent:value:"); | |
_MTL_PRIVATE_DEF_SEL(waitForFence_, | |
"waitForFence:"); | |
_MTL_PRIVATE_DEF_SEL(waitForFence_beforeStages_, | |
"waitForFence:beforeStages:"); | |
_MTL_PRIVATE_DEF_SEL(waitUntilCompleted, | |
"waitUntilCompleted"); | |
_MTL_PRIVATE_DEF_SEL(waitUntilScheduled, | |
"waitUntilScheduled"); | |
_MTL_PRIVATE_DEF_SEL(width, | |
"width"); | |
_MTL_PRIVATE_DEF_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_, | |
"writeCompactedAccelerationStructureSize:toBuffer:offset:"); | |
_MTL_PRIVATE_DEF_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_sizeDataType_, | |
"writeCompactedAccelerationStructureSize:toBuffer:offset:sizeDataType:"); | |
_MTL_PRIVATE_DEF_SEL(writeMask, | |
"writeMask"); | |
} | |