protected INativeObject GetINativeInstance(Type t)
{
var ctor = t.GetConstructor(Type.EmptyTypes);
if ((ctor != null) && !ctor.IsAbstract)
{
return(ctor.Invoke(null) as INativeObject);
}
if (!NativeObjectInterfaceType.IsAssignableFrom(t))
{
throw new ArgumentException("t");
}
switch (t.Name)
{
case "CFAllocator":
return(CFAllocator.SystemDefault);
case "CFArray":
return(Runtime.GetINativeObject <CFArray> (new NSArray().Handle, false));
case "CFBundle":
var bundles = CFBundle.GetAll();
if (bundles.Length > 0)
{
return(bundles [0]);
}
else
{
throw new InvalidOperationException(string.Format("Could not create the new instance for type {0}.", t.Name));
}
case "CFNotificationCenter":
return(CFNotificationCenter.Darwin);
case "CFReadStream":
case "CFStream":
CFReadStream readStream;
CFWriteStream writeStream;
CFStream.CreatePairWithSocketToHost("www.google.com", 80, out readStream, out writeStream);
return(readStream);
case "CFWriteStream":
CFStream.CreatePairWithSocketToHost("www.google.com", 80, out readStream, out writeStream);
return(writeStream);
case "CFUrl":
return(CFUrl.FromFile("/etc"));
case "CFPropertyList":
return(CFPropertyList.FromData(NSData.FromString("<string>data</string>")).PropertyList);
case "DispatchData":
return(DispatchData.FromByteBuffer(new byte [] { 1, 2, 3, 4 }));
case "AudioFile":
var path = Path.GetFullPath("1.caf");
var af = AudioFile.Open(CFUrl.FromFile(path), AudioFilePermission.Read, AudioFileType.CAF);
return(af);
case "CFHTTPMessage":
return(CFHTTPMessage.CreateEmpty(false));
case "CFMutableString":
return(new CFMutableString("xamarin"));
case "CGBitmapContext":
byte[] data = new byte [400];
using (CGColorSpace space = CGColorSpace.CreateDeviceRGB()) {
return(new CGBitmapContext(data, 10, 10, 8, 40, space, CGBitmapFlags.PremultipliedLast));
}
case "CGContextPDF":
var filename = Environment.GetFolderPath(Environment.SpecialFolder.CommonDocuments) + "/t.pdf";
using (var url = new NSUrl(filename))
return(new CGContextPDF(url));
case "CGColorConversionInfo":
var cci = new GColorConversionInfoTriple()
{
Space = CGColorSpace.CreateGenericRgb(),
Intent = CGColorRenderingIntent.Default,
Transform = CGColorConversionInfoTransformType.ApplySpace
};
return(new CGColorConversionInfo((NSDictionary)null, cci, cci, cci));
case "CGDataConsumer":
using (NSMutableData destData = new NSMutableData()) {
return(new CGDataConsumer(destData));
}
case "CGDataProvider":
#if __MACCATALYST__
filename = Path.Combine("Contents", "Resources", "xamarin1.png");
#else
filename = "xamarin1.png";
#endif
return(new CGDataProvider(filename));
case "CGFont":
return(CGFont.CreateWithFontName("Courier New"));
case "CGPattern":
return(new CGPattern(
new RectangleF(0, 0, 16, 16),
CGAffineTransform.MakeIdentity(),
16, 16,
CGPatternTiling.NoDistortion,
true,
(cgc) => {}));
case "CMBufferQueue":
return(CMBufferQueue.CreateUnsorted(2));
case "CTFont":
CTFontDescriptorAttributes fda = new CTFontDescriptorAttributes()
{
FamilyName = "Courier",
StyleName = "Bold",
Size = 16.0f
};
using (var fd = new CTFontDescriptor(fda))
return(new CTFont(fd, 10));
case "CTFontCollection":
return(new CTFontCollection(new CTFontCollectionOptions()));
case "CTFontDescriptor":
fda = new CTFontDescriptorAttributes();
return(new CTFontDescriptor(fda));
case "CTTextTab":
return(new CTTextTab(CTTextAlignment.Left, 2));
case "CTTypesetter":
return(new CTTypesetter(new NSAttributedString("Hello, world",
new CTStringAttributes()
{
ForegroundColorFromContext = true,
Font = new CTFont("ArialMT", 24)
})));
case "CTFrame":
var framesetter = new CTFramesetter(new NSAttributedString("Hello, world",
new CTStringAttributes()
{
ForegroundColorFromContext = true,
Font = new CTFont("ArialMT", 24)
}));
var bPath = UIBezierPath.FromRect(new RectangleF(0, 0, 3, 3));
return(framesetter.GetFrame(new NSRange(0, 0), bPath.CGPath, null));
case "CTFramesetter":
return(new CTFramesetter(new NSAttributedString("Hello, world",
new CTStringAttributes()
{
ForegroundColorFromContext = true,
Font = new CTFont("ArialMT", 24)
})));
case "CTGlyphInfo":
return(new CTGlyphInfo("copyright", new CTFont("ArialMY", 24), "Foo"));
case "CTLine":
return(new CTLine(new NSAttributedString("Hello, world",
new CTStringAttributes()
{
ForegroundColorFromContext = true,
Font = new CTFont("ArialMT", 24)
})));
#if __MACCATALYST__ || __MACOS__
case "CGEvent":
return(new CGEvent((CGEventSource)null));
case "CGEventSource":
return(new CGEventSource(CGEventSourceStateID.CombinedSession));
#endif
case "CGImageDestination":
var storage = new NSMutableData();
return(CGImageDestination.Create(new CGDataConsumer(storage), "public.png", 1));
case "CGImageMetadataTag":
using (NSString name = new NSString("tagName"))
using (var value = new NSString("value"))
return(new CGImageMetadataTag(CGImageMetadataTagNamespaces.Exif, CGImageMetadataTagPrefixes.Exif, name, CGImageMetadataType.Default, value));
case "CGImageSource":
#if __MACCATALYST__
filename = Path.Combine("Contents", "Resources", "xamarin1.png");
#else
filename = "xamarin1.png";
#endif
return(CGImageSource.FromUrl(NSUrl.FromFilename(filename)));
case "SecPolicy":
return(SecPolicy.CreateSslPolicy(false, null));
case "SecIdentity":
using (var options = NSDictionary.FromObjectAndKey(new NSString("farscape"), SecImportExport.Passphrase)) {
NSDictionary[] array;
var result = SecImportExport.ImportPkcs12(farscape_pfx, options, out array);
if (result != SecStatusCode.Success)
{
throw new InvalidOperationException(string.Format("Could not create the new instance for type {0} due to {1}.", t.Name, result));
}
return(Runtime.GetINativeObject <SecIdentity> (array [0].LowlevelObjectForKey(SecImportExport.Identity.Handle), false));
}
case "SecTrust":
X509Certificate x = new X509Certificate(mail_google_com);
using (var policy = SecPolicy.CreateSslPolicy(true, "mail.google.com"))
return(new SecTrust(x, policy));
case "SslContext":
return(new SslContext(SslProtocolSide.Client, SslConnectionType.Stream));
case "UIFontFeature":
return(new UIFontFeature(CTFontFeatureNumberSpacing.Selector.ProportionalNumbers));
case "NetworkReachability":
return(new NetworkReachability(IPAddress.Loopback, null));
case "VTCompressionSession":
case "VTSession":
return(VTCompressionSession.Create(1024, 768, CMVideoCodecType.H264, (sourceFrame, status, flags, buffer) => { }, null, (CVPixelBufferAttributes)null));
case "VTFrameSilo":
return(VTFrameSilo.Create());
case "VTMultiPassStorage":
return(VTMultiPassStorage.Create());
case "CFString":
return(new CFString("test"));
case "DispatchBlock":
return(new DispatchBlock(() => { }));
case "DispatchQueue":
return(new DispatchQueue("com.example.subsystem.taskXYZ"));
case "DispatchGroup":
return(DispatchGroup.Create());
case "CGColorSpace":
return(CGColorSpace.CreateDeviceCmyk());
case "CGGradient":
CGColor[] cArray = { UIColor.Black.CGColor, UIColor.Clear.CGColor, UIColor.Blue.CGColor };
return(new CGGradient(null, cArray));
case "CGImage":
#if __MACCATALYST__
filename = Path.Combine("Contents", "Resources", "xamarin1.png");
#else
filename = "xamarin1.png";
#endif
using (var dp = new CGDataProvider(filename))
return(CGImage.FromPNG(dp, null, false, CGColorRenderingIntent.Default));
case "CGColor":
return(UIColor.Black.CGColor);
case "CMClock":
return(CMClock.HostTimeClock);
case "CMTimebase":
return(new CMTimebase(CMClock.HostTimeClock));
case "CVPixelBufferPool":
return(new CVPixelBufferPool(
new CVPixelBufferPoolSettings(),
new CVPixelBufferAttributes(CVPixelFormatType.CV24RGB, 100, 50)
));
case "SecCertificate":
using (var cdata = NSData.FromArray(mail_google_com))
return(new SecCertificate(cdata));
case "SecCertificate2":
using (var cdata = NSData.FromArray(mail_google_com))
return(new SecCertificate2(new SecCertificate(cdata)));
case "SecTrust2":
X509Certificate x2 = new X509Certificate(mail_google_com);
using (var policy = SecPolicy.CreateSslPolicy(true, "mail.google.com"))
return(new SecTrust2(new SecTrust(x2, policy)));
case "SecIdentity2":
using (var options = NSDictionary.FromObjectAndKey(new NSString("farscape"), SecImportExport.Passphrase)) {
NSDictionary[] array;
var result = SecImportExport.ImportPkcs12(farscape_pfx, options, out array);
if (result != SecStatusCode.Success)
{
throw new InvalidOperationException(string.Format("Could not create the new instance for type {0} due to {1}.", t.Name, result));
}
return(new SecIdentity2(Runtime.GetINativeObject <SecIdentity> (array [0].LowlevelObjectForKey(SecImportExport.Identity.Handle), false)));
}
case "SecKey":
SecKey private_key;
SecKey public_key;
using (var record = new SecRecord(SecKind.Key)) {
record.KeyType = SecKeyType.RSA;
record.KeySizeInBits = 512; // it's not a performance test :)
SecKey.GenerateKeyPair(record.ToDictionary(), out public_key, out private_key);
return(private_key);
}
case "SecAccessControl":
return(new SecAccessControl(SecAccessible.WhenPasscodeSetThisDeviceOnly));
#if __MACCATALYST__
case "Authorization":
return(Security.Authorization.Create(AuthorizationFlags.Defaults));
#endif
default:
throw new InvalidOperationException(string.Format("Could not create the new instance for type {0}.", t.Name));
}
}
public void ReturnReleaseTest()
{
// This test tries to exercise all the Metal API that has a
// ReturnRelease attribute. To test that the attribute does the
// right thing: run the test app using instruments, run the test
// several times by tapping on it, and do a heap mark between each
// test. Then verify that there's at least one heap shot with 0
// memory increase, which means that nothing is leaking.
var device = MTLDevice.SystemDefault;
IntPtr buffer_mem;
int buffer_length;
bool freed;
byte [] buffer_bytes;
// Apple claims that "Indirect command buffers" are available with MTLGPUFamilyCommon2, but it crashes on at least one machine.
// Log what the current device supports, just to have it in the log.
foreach (MTLFeatureSet fs in Enum.GetValues(typeof(MTLFeatureSet)))
{
Console.WriteLine($"This device supports feature set: {fs}: {device.SupportsFeatureSet (fs)}");
}
if (TestRuntime.CheckXcodeVersion(11, 0))
{
foreach (MTLGpuFamily gf in Enum.GetValues(typeof(MTLGpuFamily)))
{
Console.WriteLine($"This device supports Gpu family: {gf}: {device.SupportsFamily (gf)}");
}
}
#if __MACOS__
string metal_code = File.ReadAllText(Path.Combine(NSBundle.MainBundle.ResourcePath, "metal-sample.metal"));
string metallib_path = Path.Combine(NSBundle.MainBundle.ResourcePath, "default.metallib");
string fragmentshader_path = Path.Combine(NSBundle.MainBundle.ResourcePath, "fragmentShader.metallib");
#else
string metal_code = File.ReadAllText(Path.Combine(NSBundle.MainBundle.BundlePath, "metal-sample.metal"));
string metallib_path = Path.Combine(NSBundle.MainBundle.BundlePath, "default.metallib");
string fragmentshader_path = Path.Combine(NSBundle.MainBundle.BundlePath, "fragmentShader.metallib");
if (Runtime.Arch == Arch.SIMULATOR)
{
Assert.Ignore("Metal isn't available in the simulator");
}
#endif
using (var hd = new MTLHeapDescriptor()) {
hd.CpuCacheMode = MTLCpuCacheMode.DefaultCache;
hd.StorageMode = MTLStorageMode.Private;
using (var txt = MTLTextureDescriptor.CreateTexture2DDescriptor(MTLPixelFormat.RGBA8Unorm, 40, 40, false)) {
var sa = device.GetHeapTextureSizeAndAlign(txt);
hd.Size = sa.Size;
using (var heap = device.CreateHeap(hd)) {
Assert.IsNotNull(heap, $"NonNullHeap");
}
}
}
using (var queue = device.CreateCommandQueue()) {
Assert.IsNotNull(queue, "Queue: NonNull 1");
}
#if __MACOS__
if (TestRuntime.CheckXcodeVersion(10, 0) && device.SupportsFeatureSet(MTLFeatureSet.macOS_GPUFamily2_v1))
{
using (var descriptor = MTLTextureDescriptor.CreateTexture2DDescriptor(MTLPixelFormat.RGBA8Unorm, 64, 64, false)) {
descriptor.StorageMode = MTLStorageMode.Private;
using (var texture = device.CreateSharedTexture(descriptor)) {
Assert.IsNotNull(texture, "CreateSharedTexture (MTLTextureDescriptor): NonNull");
using (var handle = texture.CreateSharedTextureHandle())
using (var shared = device.CreateSharedTexture(handle))
Assert.IsNotNull(texture, "CreateSharedTexture (MTLSharedTextureHandle): NonNull");
}
}
}
#endif
using (var queue = device.CreateCommandQueue(10)) {
Assert.IsNotNull(queue, "Queue: NonNull 2");
}
using (var buffer = device.CreateBuffer(1024, MTLResourceOptions.CpuCacheModeDefault)) {
Assert.IsNotNull(buffer, "CreateBuffer: NonNull 1");
}
buffer_mem = AllocPageAligned(1, out buffer_length);
using (var buffer = device.CreateBuffer(buffer_mem, (nuint)buffer_length, MTLResourceOptions.CpuCacheModeDefault)) {
Assert.IsNotNull(buffer, "CreateBuffer: NonNull 2");
}
FreePageAligned(buffer_mem, buffer_length);
buffer_bytes = new byte [getpagesize()];
using (var buffer = device.CreateBuffer(buffer_bytes, MTLResourceOptions.CpuCacheModeDefault)) {
Assert.IsNotNull(buffer, "CreateBuffer: NonNull 3");
}
buffer_mem = AllocPageAligned(1, out buffer_length);
freed = false;
#if __MACOS__
var resourceOptions7 = MTLResourceOptions.StorageModeManaged;
#else
var resourceOptions7 = MTLResourceOptions.CpuCacheModeDefault;
#endif
using (var buffer = device.CreateBufferNoCopy(buffer_mem, (nuint)buffer_length, resourceOptions7, (pointer, length) => { FreePageAligned(pointer, (int)length); freed = true; })) {
Assert.IsNotNull(buffer, "CreateBufferNoCopy: NonNull 1");
}
Assert.IsTrue(freed, "CreateBufferNoCopy: Freed 1");
using (var descriptor = new MTLDepthStencilDescriptor())
using (var dss = device.CreateDepthStencilState(descriptor)) {
Assert.IsNotNull(dss, "CreateDepthStencilState: NonNull 1");
}
using (var descriptor = MTLTextureDescriptor.CreateTexture2DDescriptor(MTLPixelFormat.RGBA8Unorm, 64, 64, false)) {
using (var texture = device.CreateTexture(descriptor))
Assert.NotNull(texture, "CreateTexture: NonNull 1");
using (var surface = new IOSurface.IOSurface(new IOSurface.IOSurfaceOptions {
Width = 64,
Height = 64,
BytesPerElement = 4,
})) {
using (var texture = device.CreateTexture(descriptor, surface, 0))
Assert.NotNull(texture, "CreateTexture: NonNull 2");
}
}
using (var descriptor = new MTLSamplerDescriptor())
using (var sampler = device.CreateSamplerState(descriptor))
Assert.IsNotNull(sampler, "CreateSamplerState: NonNull 1");
using (var library = device.CreateDefaultLibrary())
Assert.IsNotNull(library, "CreateDefaultLibrary: NonNull 1");
using (var library = device.CreateLibrary(metallib_path, out var error)) {
Assert.IsNotNull(library, "CreateLibrary: NonNull 1");
Assert.IsNull(error, "CreateLibrary: NonNull error 1");
}
using (var data = DispatchData.FromByteBuffer(File.ReadAllBytes(metallib_path)))
using (var library = device.CreateLibrary(data, out var error)) {
Assert.IsNotNull(library, "CreateLibrary: NonNull 2");
Assert.IsNull(error, "CreateLibrary: NonNull error 2");
}
using (var compile_options = new MTLCompileOptions())
using (var library = device.CreateLibrary(metal_code, compile_options, out var error)) {
Assert.IsNotNull(library, "CreateLibrary: NonNull 3");
Assert.IsNull(error, "CreateLibrary: NonNull error 3");
}
using (var compile_options = new MTLCompileOptions()) {
device.CreateLibrary(metal_code, compile_options, (library, error) => {
Assert.IsNotNull(library, "CreateLibrary: NonNull 4");
Assert.IsNull(error, "CreateLibrary: NonNull error 4");
});
}
using (var library = device.CreateDefaultLibrary(NSBundle.MainBundle, out var error)) {
Assert.IsNotNull(library, "CreateDefaultLibrary: NonNull 2");
Assert.IsNull(error, "CreateDefaultLibrary: NonNull error 2");
}
using (var descriptor = new MTLRenderPipelineDescriptor())
using (var library = device.CreateDefaultLibrary())
using (var func = library.CreateFunction("vertexShader")) {
descriptor.VertexFunction = func;
descriptor.ColorAttachments [0].PixelFormat = MTLPixelFormat.BGRA8Unorm_sRGB;
using (var rps = device.CreateRenderPipelineState(descriptor, out var error)) {
Assert.IsNotNull(rps, "CreateRenderPipelineState: NonNull 1");
Assert.IsNull(error, "CreateRenderPipelineState: NonNull error 1");
}
}
using (var descriptor = new MTLRenderPipelineDescriptor())
using (var library = device.CreateDefaultLibrary())
using (var func = library.CreateFunction("vertexShader")) {
descriptor.VertexFunction = func;
descriptor.ColorAttachments [0].PixelFormat = MTLPixelFormat.BGRA8Unorm_sRGB;
using (var rps = device.CreateRenderPipelineState(descriptor, MTLPipelineOption.BufferTypeInfo, out var reflection, out var error)) {
Assert.IsNotNull(rps, "CreateRenderPipelineState: NonNull 2");
Assert.IsNull(error, "CreateRenderPipelineState: NonNull error 2");
Assert.IsNotNull(reflection, "CreateRenderPipelineState: NonNull reflection 2");
}
}
using (var library = device.CreateDefaultLibrary())
using (var func = library.CreateFunction("grayscaleKernel"))
using (var cps = device.CreateComputePipelineState(func, MTLPipelineOption.ArgumentInfo, out var reflection, out var error)) {
Assert.IsNotNull(cps, "CreateComputePipelineState: NonNull 1");
Assert.IsNull(error, "CreateComputePipelineState: NonNull error 1");
Assert.IsNotNull(reflection, "CreateComputePipelineState: NonNull reflection 1");
}
using (var library = device.CreateDefaultLibrary())
using (var func = library.CreateFunction("grayscaleKernel"))
using (var cps = device.CreateComputePipelineState(func, out var error)) {
Assert.IsNotNull(cps, "CreateComputePipelineState: NonNull 2");
Assert.IsNull(error, "CreateComputePipelineState: NonNull error 2");
}
using (var descriptor = new MTLComputePipelineDescriptor())
using (var library = device.CreateDefaultLibrary())
using (var func = library.CreateFunction("grayscaleKernel")) {
descriptor.ComputeFunction = func;
using (var cps = device.CreateComputePipelineState(descriptor, MTLPipelineOption.BufferTypeInfo, out var reflection, out var error)) {
Assert.IsNotNull(cps, "CreateComputePipelineState: NonNull 3");
Assert.IsNull(error, "CreateComputePipelineState: NonNull error 3");
Assert.IsNotNull(reflection, "CreateComputePipelineState: NonNull reflection 3");
}
}
using (var fence = device.CreateFence()) {
Assert.IsNotNull(fence, "CreateFence 1: NonNull");
}
var url = "file://" + metallib_path;
url = url.Replace(" ", "%20"); // url encode!
using (var library = device.CreateLibrary(new NSUrl(url), out var error)) {
// Looks like creating a library with a url always fails: https://forums.developer.apple.com/thread/110416
Assert.IsNull(library, "CreateLibrary (NSUrl, NSError): Null");
Assert.IsNotNull(error, "CreateLibrary (NSUrl, NSError): NonNull error");
}
using (var library = device.CreateArgumentEncoder(new MTLArgumentDescriptor [] { new MTLArgumentDescriptor()
{
DataType = MTLDataType.Int
} })) {
Assert.IsNotNull(library, "CreateArgumentEncoder (MTLArgumentDescriptor[]): NonNull");
}
// Apple's charts say that "Indirect command buffers" are supported with MTLGpuFamilyCommon2
var supportsIndirectCommandBuffers = TestRuntime.CheckXcodeVersion(11, 0) && device.SupportsFamily(MTLGpuFamily.Common2);
#if __MACOS__
// but something's not quite right somewhere, so on macOS verify that the device supports a bit more than what Apple says.
supportsIndirectCommandBuffers &= device.SupportsFeatureSet(MTLFeatureSet.macOS_GPUFamily2_v1);
#endif
if (supportsIndirectCommandBuffers)
{
using (var descriptor = new MTLIndirectCommandBufferDescriptor()) {
using (var library = device.CreateIndirectCommandBuffer(descriptor, 1, MTLResourceOptions.CpuCacheModeDefault)) {
Assert.IsNotNull(library, "CreateIndirectCommandBuffer: NonNull");
}
}
using (var evt = device.CreateEvent()) {
Assert.IsNotNull(evt, "CreateEvent: NonNull");
}
using (var evt = device.CreateSharedEvent()) {
Assert.IsNotNull(evt, "CreateSharedEvent: NonNull");
}
using (var evt1 = device.CreateSharedEvent())
using (var evt_handle = evt1.CreateSharedEventHandle())
using (var evt = device.CreateSharedEvent(evt_handle)) {
Assert.IsNotNull(evt, "CreateSharedEvent (MTLSharedEventHandle): NonNull");
}
}
using (var descriptor = new MTLRenderPipelineDescriptor())
using (var library = device.CreateDefaultLibrary())
using (var func = library.CreateFunction("vertexShader")) {
descriptor.VertexFunction = func;
descriptor.ColorAttachments [0].PixelFormat = MTLPixelFormat.BGRA8Unorm_sRGB;
using (var rps = device.CreateRenderPipelineState(descriptor, MTLPipelineOption.ArgumentInfo, out var reflection, out var error)) {
Assert.IsNotNull(rps, "CreateRenderPipelineState (MTLTileRenderPipelineDescriptor, MTLPipelineOption, MTLRenderPipelineReflection, NSError): NonNull");
Assert.IsNull(error, "CreateRenderPipelineState (MTLTileRenderPipelineDescriptor, MTLPipelineOption, MTLRenderPipelineReflection, NSError: NonNull error");
Assert.IsNotNull(reflection, "CreateRenderPipelineState (MTLTileRenderPipelineDescriptor, MTLPipelineOption, MTLRenderPipelineReflection, NSError): NonNull reflection");
}
}
using (var buffer = device.CreateBuffer(1024, MTLResourceOptions.CpuCacheModeDefault))
using (var descriptor = new MTLTextureDescriptor())
using (var texture = buffer.CreateTexture(descriptor, 0, 256)) {
Assert.IsNotNull(buffer, "MTLBuffer.CreateTexture (MTLTextureDescriptor, nuint, nuint): NonNull");
}
using (var descriptor = MTLTextureDescriptor.CreateTexture2DDescriptor(MTLPixelFormat.RGBA8Unorm, 64, 64, false))
using (var texture = device.CreateTexture(descriptor)) {
using (var view = texture.CreateTextureView(MTLPixelFormat.RGBA8Unorm)) {
Assert.IsNotNull(view, "MTLTexture.CreateTextureView (MTLPixelFormat): nonnull");
}
using (var view = texture.CreateTextureView(MTLPixelFormat.RGBA8Unorm, MTLTextureType.k2D, new NSRange(0, 1), new NSRange(0, 1))) {
Assert.IsNotNull(view, "MTLTexture.CreateTextureView (MTLPixelFormat, MTLTextureType, NSRange, NSRange): nonnull");
}
}
using (var library = device.CreateLibrary(fragmentshader_path, out var error))
using (var func = library.CreateFunction("fragmentShader2")) {
using (var enc = func.CreateArgumentEncoder(0)) {
Assert.IsNotNull(enc, "MTLFunction.CreateArgumentEncoder (nuint): NonNull");
}
using (var enc = func.CreateArgumentEncoder(0, out var reflection)) {
Assert.IsNotNull(enc, "MTLFunction.CreateArgumentEncoder (nuint, MTLArgument): NonNull");
Assert.IsNotNull(reflection, "MTLFunction.CreateArgumentEncoder (nuint, MTLArgument): NonNull reflection");
}
}
using (var library = device.CreateDefaultLibrary()) {
using (var func = library.CreateFunction("grayscaleKernel")) {
Assert.IsNotNull(func, "CreateFunction (string): nonnull");
}
if (TestRuntime.CheckXcodeVersion(9, 0)) // MTLFunctionConstantValues didn't have a default ctor until Xcode 9.
{
using (var constants = new MTLFunctionConstantValues())
using (var func = library.CreateFunction("grayscaleKernel", constants, out var error)) {
Assert.IsNotNull(func, "CreateFunction (string, MTLFunctionConstantValues, NSError): nonnull");
Assert.IsNull(error, "CreateFunction (string, MTLFunctionConstantValues, NSError): null error");
}
}
}
using (var hd = new MTLHeapDescriptor()) {
hd.CpuCacheMode = MTLCpuCacheMode.DefaultCache;
hd.StorageMode = MTLStorageMode.Private;
using (var txt = MTLTextureDescriptor.CreateTexture2DDescriptor(MTLPixelFormat.RGBA8Unorm, 40, 40, false)) {
var sa = device.GetHeapTextureSizeAndAlign(txt);
hd.Size = sa.Size;
using (var heap = device.CreateHeap(hd))
using (var buffer = heap.CreateBuffer(1024, MTLResourceOptions.StorageModePrivate)) {
Assert.IsNotNull(buffer, "MTLHeap.CreateBuffer (nuint, MTLResourceOptions): nonnull");
}
}
}
using (var hd = new MTLHeapDescriptor()) {
hd.CpuCacheMode = MTLCpuCacheMode.DefaultCache;
#if __MACOS__
hd.StorageMode = MTLStorageMode.Private;
#else
hd.StorageMode = MTLStorageMode.Shared;
#endif
using (var txt = MTLTextureDescriptor.CreateTexture2DDescriptor(MTLPixelFormat.RGBA8Unorm, 40, 40, false)) {
var sa = device.GetHeapTextureSizeAndAlign(txt);
hd.Size = sa.Size;
using (var heap = device.CreateHeap(hd)) {
#if __MACOS__
txt.StorageMode = MTLStorageMode.Private;
#endif
using (var texture = heap.CreateTexture(txt)) {
Assert.IsNotNull(texture, "MTLHeap.CreateTexture (MTLTextureDescriptor): nonnull");
}
}
}
}
using (var scope = MTLCaptureManager.Shared.CreateNewCaptureScope(device)) {
Assert.IsNotNull(scope, "MTLCaptureManager.CreateNewCaptureScope (MTLDevice): nonnull");
}
using (var queue = device.CreateCommandQueue())
using (var scope = MTLCaptureManager.Shared.CreateNewCaptureScope(queue)) {
Assert.IsNotNull(scope, "MTLCaptureManager.CreateNewCaptureScope (MTLCommandQueue): nonnull");
}
TestRuntime.AssertXcodeVersion(10, 0);
using (var evt = device.CreateSharedEvent())
using (var shared = evt.CreateSharedEventHandle()) {
Assert.IsNotNull(shared, "MTLSharedEvent.CreateSharedEvent: NonNull");
}
}