OSX Metal Vsync

bimbinel

#7855

August 4, 2016

I've been playing around with an OSX platform layer that uses Metal for rendering. I was wondering if there is a way to vsync without using a CVDisplayLink. In OpenGL you can use CGLFlushDrawable to wait on the vsync and I was wondering if there is a similar thing you can do in Metal.

Adrian

#7873

August 6, 2016

Could you post your code? I searched the web for guides on how to use metal but didn't came very far. Would love to see how you did it!

Edited by Adrian on August 6, 2016, 2:40pm

bimbinel

#7880

August 6, 2016

I was only playing around with it so I'm just drawing a full-screen quad at the moment:

static const r32 GlobalQuadVertices[6][4] =
{
    { -1.0f,  -1.0f, 0.0f, 1.0f },
    {  1.0f,  -1.0f, 0.0f, 1.0f },
    { -1.0f,   1.0f, 0.0f, 1.0f },
    
    {  1.0f,  -1.0f, 0.0f, 1.0f },
    { -1.0f,   1.0f, 0.0f, 1.0f },
    {  1.0f,   1.0f, 0.0f, 1.0f }
};
static const r32 GlobalQuadTexCoords[6][2] =
{
    { 0.0f, 0.0f },
    { 1.0f, 0.0f },
    { 0.0f, 1.0f },
    
    { 1.0f, 0.0f },
    { 0.0f, 1.0f },
    { 1.0f, 1.0f }
};

@interface OSXMetalView : NSView
@end

@implementation OSXMetalView
{
@public
    CVDisplayLinkRef	  	    _displayLink;
    dispatch_semaphore_t 	    _renderSemaphore;

	__weak CAMetalLayer 	   *_metalLayer;

	MTLRenderPassDescriptor    *_renderPassDesc;
    id<MTLDevice> 			    _device;
    id<MTLCommandQueue>        _commandQueue;
    id<MTLLibrary>             _shaderLibrary;
    id<MTLRenderPipelineState> _pipelineState;
    id<MTLDepthStencilState>   _depthState;
    id<MTLTexture>  	       _texture;
    id<MTLBuffer>  			   _vertexBuffer;
    id<MTLBuffer>  			   _texCoordBuffer;
    id<CAMetalDrawable> 	   _currentDrawable;

    BOOL 				        _layerSizeDidUpdate;
    char 					   *_pixels;
}

static CVReturn OnDisplayLinkFrame(CVDisplayLinkRef displayLink,
                                     const CVTimeStamp *now,
                                     const CVTimeStamp *outputTime,
                                     CVOptionFlags flagsIn,
                                     CVOptionFlags *flagsOut,
                                     void *displayLinkContext)
{
	OSXMetalView *view = (__bridge OSXMetalView *)displayLinkContext;

	@autoreleasepool
	{
		[view update];
	}

    return kCVReturnSuccess;
}

+ (Class)layerClass
{
    return [CAMetalLayer class];
}

- (id)initWithFrame:(CGRect)frame
{
    self = [super initWithFrame:frame];
    
	if (self)
    {
    	self.wantsLayer = YES;
    	self.layer = _metalLayer = [CAMetalLayer layer];

    	_device = MTLCreateSystemDefaultDevice();
    
    	_metalLayer.device          = _device;
    	_metalLayer.pixelFormat     = MTLPixelFormatBGRA8Unorm;
    
    	_metalLayer.framebufferOnly = YES;

    	_commandQueue = [_device newCommandQueue];
    	if (!_commandQueue) 
    	{
        	printf("ERROR: Couldn't create a command queue.");
        	return nil;
        }

	    NSError *error = nil;

	    _shaderLibrary = [_device newLibraryWithFile: @"shaders.metallib" error:&error];
	    if (!_shaderLibrary) 
	    {
	        printf("ERROR: Failed to load shader library.");
	        return nil;
	    }

	    id<MTLFunction> fragmentProgram = [_shaderLibrary newFunctionWithName:@"TexturedQuadFragment"];
	    if (!fragmentProgram)
	    {
	        printf("ERROR: Couldn't load fragment function from default library.");
	       	return nil;
	    }
	    
	    id<MTLFunction> vertexProgram = [_shaderLibrary newFunctionWithName:@"TexturedQuadVertex"];
	    if (!vertexProgram)
	    {
	        printf("ERROR: Couldn't load vertex function from default library.");
	        return nil;
	    }

	   	MTLRenderPipelineDescriptor *pipelineStateDesc = [MTLRenderPipelineDescriptor new];
	    
	    if (!pipelineStateDesc)
	    {
	        printf("ERROR: Failed creating a pipeline state descriptor!");
	        return nil;
	    }
	    
	    pipelineStateDesc.depthAttachmentPixelFormat      = MTLPixelFormatInvalid;
	    pipelineStateDesc.stencilAttachmentPixelFormat    = MTLPixelFormatInvalid;
	    pipelineStateDesc.colorAttachments[0].pixelFormat = MTLPixelFormatBGRA8Unorm;
	    
	    pipelineStateDesc.sampleCount      = 1;
	    pipelineStateDesc.vertexFunction   = vertexProgram;
	    pipelineStateDesc.fragmentFunction = fragmentProgram;
	    
	    _pipelineState = [_device newRenderPipelineStateWithDescriptor:pipelineStateDesc
	                                                             error:&error];
	    if (!_pipelineState)
	    {
	        printf("ERROR: Failed acquiring pipeline state descriptor.");
	        return nil;
	    }

	   	MTLTextureDescriptor *texDesc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
                                                                                           width:frame.size.width
                                                                                          height:frame.size.height
                                                                                       mipmapped:NO];
    	if (!texDesc)
    	{
        	printf("ERROR: Failed to create texture descriptor.");
        	return nil;
    	}

    	_texture = [_device newTextureWithDescriptor:texDesc];

    	if (!_texture)
    	{
        	printf("ERROR: Failed to create texture.");
        	return nil;    		
    	}

    	_vertexBuffer = [_device newBufferWithBytes:GlobalQuadVertices
                                             length:6 * sizeof(r32) * 4
                                            options:MTLResourceOptionCPUCacheModeDefault];
        if (!_vertexBuffer)
        {
            printf("ERROR: Failed to create quad vertex buffer.");
            return nil;
        }
        _vertexBuffer.label = @"quad vertices";
        
        _texCoordBuffer = [_device newBufferWithBytes:GlobalQuadTexCoords
                                               length:6 * sizeof(r32) * 2
                                              options:MTLResourceOptionCPUCacheModeDefault];
        if (!_texCoordBuffer)
        {
            printf("ERROR: Failed to create 2d texture coordinate buffer.");
            return nil;
        }
        _texCoordBuffer.label = @"quad texcoords";

    	_pixels = (char*)malloc(4 * frame.size.width * frame.size.height);
    	char *pixelIterator = _pixels;

    	for (u32 y = 0; y < frame.size.height; ++y)
    	{
    		for (u32 x = 0; x < frame.size.width; ++x)
    		{
    			*pixelIterator++ = 255;
    			*pixelIterator++ = 0;
    			*pixelIterator++ = 255;
    			*pixelIterator++ = 255;
    		}
    	}

        _renderSemaphore = dispatch_semaphore_create(2);

    	CVReturn cvReturn = CVDisplayLinkCreateWithActiveCGDisplays(&_displayLink);

    	Assert(cvReturn == kCVReturnSuccess);

    	cvReturn = CVDisplayLinkSetOutputCallback(_displayLink, &OnDisplayLinkFrame, (__bridge void *)self);

    	Assert(cvReturn == kCVReturnSuccess);

    	cvReturn = CVDisplayLinkSetCurrentCGDisplay(_displayLink, CGMainDisplayID());

		CVDisplayLinkStart(_displayLink);
    	
    	NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];

    	[notificationCenter addObserver:self
        	                   selector:@selector(windowWillClose:)
            	                   name:NSWindowWillCloseNotification
                	             object:self.window];
    }
    
    return self;
}

- (void)dealloc
{
    if (_displayLink)
    {
        [self stopUpdate];
    }
}

- (void)windowWillClose:(NSNotification*)notification
{
    // Stop the display link when the window is closing because we will
    // not be able to get a drawable, but the display link may continue
    // to fire
    if (notification.object == self.window)
    {
        CVDisplayLinkStop(_displayLink);
    }
}

- (void)update
{
    if (_layerSizeDidUpdate)
    {
        // Set the metal layer to the drawable size in case orientation or size changes.
        CGSize drawableSize = self.bounds.size;

        // Scale drawableSize so that drawable is 1:1 width pixels not 1:1 to points.
        NSScreen* screen = self.window.screen ?: [NSScreen mainScreen];
        drawableSize.width *= screen.backingScaleFactor;
        drawableSize.height *= screen.backingScaleFactor;
        
        _metalLayer.drawableSize = drawableSize;
        
        _layerSizeDidUpdate = NO;
    }
    
    dispatch_semaphore_wait(_renderSemaphore, DISPATCH_TIME_FOREVER);

	if (!_currentDrawable)
	{
    	_currentDrawable = [_metalLayer nextDrawable];
	}

    if (!_currentDrawable)
    {
        printf("ERROR: Failed to get a valid drawable.");
        _renderPassDesc = nil;
    }
    else
    {
	    if (_renderPassDesc == nil)
	    {
	    	_renderPassDesc = [MTLRenderPassDescriptor renderPassDescriptor];
	    }
	    
	    MTLRenderPassColorAttachmentDescriptor *colorAttachment = _renderPassDesc.colorAttachments[0];
	    colorAttachment.texture = _currentDrawable.texture;
	    
	    colorAttachment.loadAction = MTLLoadActionClear;
	    colorAttachment.clearColor = MTLClearColorMake(1.0f, 0.0f, 1.0f, 1.0f);
	    
	    colorAttachment.storeAction = MTLStoreActionStore;
    }

   	MTLRegion region = MTLRegionMake2D(0, 0, self.frame.size.width, self.frame.size.height);
	u32 rowBytes = self.frame.size.width * 4;
    [_texture replaceRegion:region
                mipmapLevel:0
                  withBytes:_pixels
                bytesPerRow:rowBytes];

	id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];

    if (_renderPassDesc)
    {
        id<MTLRenderCommandEncoder> renderEncoder = [commandBuffer renderCommandEncoderWithDescriptor:_renderPassDesc];
        
	    [renderEncoder pushDebugGroup:@"encode quad"];

	    [renderEncoder setFrontFacingWinding:MTLWindingCounterClockwise];	    
	    [renderEncoder setRenderPipelineState:_pipelineState];
	    [renderEncoder setVertexBuffer:_vertexBuffer
	                            offset:0
	                           atIndex:0];
	    [renderEncoder setVertexBuffer:_texCoordBuffer
                        		offset:0
                       		   atIndex:1];
	    [renderEncoder setFragmentTexture:_texture
	                              atIndex:0];
	    [renderEncoder drawPrimitives:MTLPrimitiveTypeTriangle
	                      vertexStart:0
	                      vertexCount:6
	                    instanceCount:1];
	    [renderEncoder endEncoding];

	    [renderEncoder popDebugGroup];
        
        [commandBuffer presentDrawable:_currentDrawable];
    }

	__block dispatch_semaphore_t blockRenderSemaphore = _renderSemaphore;
	[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> cmdBuff){
	    dispatch_semaphore_signal(blockRenderSemaphore);
	}];

	[commandBuffer commit];
    
    _currentDrawable = nil;
}

- (void)stopUpdate
{
    if (_displayLink)
    {
        CVDisplayLinkStop(_displayLink);
        CVDisplayLinkRelease(_displayLink);
    }
}

@end




---- Shader ----

#include <metal_graphics>
#include <metal_geometric>
#include <metal_texture>

using namespace metal;

struct VertexInOut
{
    float4 pos [[position]];
    float2 texCoord [[user(texturecoord)]];
};

vertex VertexInOut TexturedQuadVertex(constant float4         *pos        [[ buffer(0) ]],
                                      constant packed_float2  *texCoords  [[ buffer(1) ]],
                                      uint                     vid        [[ vertex_id ]])
{
    VertexInOut outVertices;
    
    outVertices.pos      = pos[vid];
    outVertices.texCoord = texCoords[vid];
    
    return outVertices;
}

fragment half4 TexturedQuadFragment(VertexInOut      inFrag    [[ stage_in ]],
                                    texture2d<half>  tex2D     [[ texture(0) ]])
{
    constexpr sampler quadSampler;
    half4 color = tex2D.sample(quadSampler, inFrag.texCoord);
    
    return color;
}

The code is based on the Apple samples.

Edited by bimbinel on August 6, 2016, 7:26pm

Adrian

#8107

August 17, 2016

Wow this seems like a lot of stuff. Isn't there a shorter way on blitting a bitmap to the screen with the metal api?

bimbinel

#8108

August 17, 2016

Well you can simplify things by not having an NSView and just passing the metal layer to the window (so most of the code will be moved to main), however, I don't think there is a way to blit a texture without using a shader and drawing something.

Mārtiņš Možeiko

#8111

August 18, 2016

Metal is not meant for blitting pixels from CPU to GPU. Same with modern OpenGL - it will require bunch of code, including uploading data to texture and then drawing texture using GLSL shader. This is expected.

There's really no advantage of using Metal instead of legacy OpenGL (glBegin/glEnd) for just uploading texture and blitting it to screen.

Adrian

#8261

August 26, 2016

Could you point me to some resources on blitting a bitmap to the screen? Wanted to change my code from CoreGraphics to OpenGL to get a little bit in touch with it. Tried to distill it from Jeff Buck's OS X platform layer but there is so much going on and it's hard for me to understand all the code there.

I got some bitmap memory that I simply want to render to the screen using OpenGL.

Mārtiņš Možeiko

#8264

August 26, 2016

HandmadeHero has code for blitting memory to screen using OpenGL.
Take a look at OpenGLDisplayBitmap function in handmade_opengl.cpp file.