qt-everywhere-src-5.14.1/qtdeclarative/examples/quick/scenegraph/rendernode/metalrenderer.mm - orbit - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2019 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the examples of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:BSD$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
 ** and conditions see https://www.qt.io/terms-conditions. For further
 ** information use the contact form at https://www.qt.io/contact-us.
 **
 ** BSD License Usage
 ** Alternatively, you may use this file under the terms of the BSD license
 ** as follows:
 **
 ** "Redistribution and use in source and binary forms, with or without
 ** modification, are permitted provided that the following conditions are
 ** met:
 **   * Redistributions of source code must retain the above copyright
 **     notice, this list of conditions and the following disclaimer.
 **   * Redistributions in binary form must reproduce the above copyright
 **     notice, this list of conditions and the following disclaimer in
 **     the documentation and/or other materials provided with the
 **     distribution.
 **   * Neither the name of The Qt Company Ltd nor the names of its
 **     contributors may be used to endorse or promote products derived
 **     from this software without specific prior written permission.
 **
 **
 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "metalrenderer.h"
 #include <QQuickItem>
 #include <QQuickWindow>

 #include <Metal/Metal.h>

 using FuncAndLib = QPair<id<MTLFunction>, id<MTLLibrary> >;

 const int MAX_FRAMES_IN_FLIGHT = 3;

 struct {
     id<MTLDevice> dev = nil;
     QByteArray vsSource;
     FuncAndLib vs;
     QByteArray fsSource;
     FuncAndLib fs;
     id<MTLBuffer> vbuf[MAX_FRAMES_IN_FLIGHT];
     id<MTLBuffer> ubuf[MAX_FRAMES_IN_FLIGHT];
     id<MTLDepthStencilState> stencilEnabledDsState = nil;
     id<MTLRenderPipelineState> pipeline = nil;
 } g;

 static FuncAndLib compileShaderFromSource(const QByteArray &src, const QByteArray &entryPoint)
 {
     FuncAndLib fl;

     NSString *srcstr = [NSString stringWithUTF8String: src.constData()];
     MTLCompileOptions *opts = [[MTLCompileOptions alloc] init];
     opts.languageVersion = MTLLanguageVersion1_2;
     NSError *err = nil;
     fl.second = [g.dev newLibraryWithSource: srcstr options: opts error: &err];
     [opts release];
     // srcstr is autoreleased

     if (err) {
         const QString msg = QString::fromNSString(err.localizedDescription);
         qFatal("%s", qPrintable(msg));
         return fl;
     }

     NSString *name = [NSString stringWithUTF8String: entryPoint.constData()];
     fl.first = [fl.second newFunctionWithName: name];
     [name release];

     return fl;
 }

 const int VERTEX_SIZE = 6 * sizeof(float);

 static float colors[] = {
     1.0f, 0.0f, 0.0f,
     0.0f, 1.0f, 0.0f,
     0.0f, 0.0f, 1.0f
 };

 void MetalRenderNodeResourceBuilder::build()
 {
     if (!g.dev) {
         QSGRendererInterface *rif = m_window->rendererInterface();
         Q_ASSERT(rif->graphicsApi() == QSGRendererInterface::MetalRhi);

         g.dev = (id<MTLDevice>) rif->getResource(m_window, QSGRendererInterface::DeviceResource);
         Q_ASSERT(g.dev);
     }

     if (g.vsSource.isEmpty()) {
         const QString filename = QLatin1String(":/scenegraph/rendernode/metalshader.vert");
         QFile f(filename);
         if (!f.open(QIODevice::ReadOnly | QIODevice::Text))
             qFatal("Failed to read shader %s", qPrintable(filename));
         g.vsSource = f.readAll();
         g.vs = compileShaderFromSource(g.vsSource, QByteArrayLiteral("main0"));
     }

     if (g.fsSource.isEmpty()) {
         const QString filename = QLatin1String(":/scenegraph/rendernode/metalshader.frag");
         QFile f(filename);
         if (!f.open(QIODevice::ReadOnly | QIODevice::Text))
             qFatal("Failed to read shader %s", qPrintable(filename));
         g.fsSource = f.readAll();
         g.fs = compileShaderFromSource(g.fsSource, QByteArrayLiteral("main0"));
     }

     const int framesInFlight = m_window->graphicsStateInfo().framesInFlight;

     // For simplicity's sake we use shared mode (something like host visible +
     // host coherent) for everything.

     for (int i = 0; i < framesInFlight; ++i) {
         // Have multiple versions for vertex too since we'll just memcpy new
         // vertices based on item width and height on every render(). This could
         // be optimized further however.
         if (!g.vbuf[i]) {
             g.vbuf[i] = [g.dev newBufferWithLength: VERTEX_SIZE + sizeof(colors) options: MTLResourceStorageModeShared];
             char *p = (char *) [g.vbuf[i] contents];
             memcpy(p + VERTEX_SIZE, colors, sizeof(colors));
         }

         if (!g.ubuf[i])
             g.ubuf[i] = [g.dev newBufferWithLength: 256 options: MTLResourceStorageModeShared];
     }

     if (!g.stencilEnabledDsState) {
         MTLDepthStencilDescriptor *dsDesc = [[MTLDepthStencilDescriptor alloc] init];
         dsDesc.frontFaceStencil = [[MTLStencilDescriptor alloc] init];
         dsDesc.frontFaceStencil.stencilFailureOperation = MTLStencilOperationKeep;
         dsDesc.frontFaceStencil.depthFailureOperation = MTLStencilOperationKeep;
         dsDesc.frontFaceStencil.depthStencilPassOperation = MTLStencilOperationKeep;
         dsDesc.frontFaceStencil.stencilCompareFunction = MTLCompareFunctionEqual;
         dsDesc.frontFaceStencil.readMask = 0xFF;
         dsDesc.frontFaceStencil.writeMask = 0xFF;

         dsDesc.backFaceStencil = [[MTLStencilDescriptor alloc] init];
         dsDesc.backFaceStencil.stencilFailureOperation = MTLStencilOperationKeep;
         dsDesc.backFaceStencil.depthFailureOperation = MTLStencilOperationKeep;
         dsDesc.backFaceStencil.depthStencilPassOperation = MTLStencilOperationKeep;
         dsDesc.backFaceStencil.stencilCompareFunction = MTLCompareFunctionEqual;
         dsDesc.backFaceStencil.readMask = 0xFF;
         dsDesc.backFaceStencil.writeMask = 0xFF;

         g.stencilEnabledDsState = [g.dev newDepthStencilStateWithDescriptor: dsDesc];
         [dsDesc release];
     }

     if (!g.pipeline) {
         MTLVertexDescriptor *inputLayout = [MTLVertexDescriptor vertexDescriptor];
         inputLayout.attributes[0].format = MTLVertexFormatFloat2;
         inputLayout.attributes[0].offset = 0;
         inputLayout.attributes[0].bufferIndex = 1; // ubuf is 0, vbuf is 1 and 2
         inputLayout.attributes[1].format = MTLVertexFormatFloat3;
         inputLayout.attributes[1].offset = 0;
         inputLayout.attributes[1].bufferIndex = 2;
         inputLayout.layouts[1].stride = 2 * sizeof(float);
         inputLayout.layouts[2].stride = 3 * sizeof(float);

         MTLRenderPipelineDescriptor *rpDesc = [[MTLRenderPipelineDescriptor alloc] init];
         rpDesc.vertexDescriptor = inputLayout;

         rpDesc.vertexFunction = g.vs.first;
         rpDesc.fragmentFunction = g.fs.first;

         rpDesc.colorAttachments[0].pixelFormat = MTLPixelFormatBGRA8Unorm;
         rpDesc.colorAttachments[0].blendingEnabled = true;
         rpDesc.colorAttachments[0].sourceRGBBlendFactor = MTLBlendFactorOne;
         rpDesc.colorAttachments[0].sourceAlphaBlendFactor = MTLBlendFactorOne;
         rpDesc.colorAttachments[0].destinationRGBBlendFactor = MTLBlendFactorOneMinusSourceAlpha;
         rpDesc.colorAttachments[0].destinationAlphaBlendFactor = MTLBlendFactorOneMinusSourceAlpha;

         if (g.dev.depth24Stencil8PixelFormatSupported) {
             rpDesc.depthAttachmentPixelFormat = MTLPixelFormatDepth24Unorm_Stencil8;
             rpDesc.stencilAttachmentPixelFormat = MTLPixelFormatDepth24Unorm_Stencil8;
         } else {
             rpDesc.depthAttachmentPixelFormat = MTLPixelFormatDepth32Float_Stencil8;
             rpDesc.stencilAttachmentPixelFormat = MTLPixelFormatDepth32Float_Stencil8;
         }

         NSError *err = nil;
         g.pipeline = [g.dev newRenderPipelineStateWithDescriptor: rpDesc error: &err];
         if (!g.pipeline) {
             const QString msg = QString::fromNSString(err.localizedDescription);
             qFatal("Failed to create render pipeline state: %s", qPrintable(msg));
         }
         [rpDesc release];
     }
 }

 MetalRenderNode::MetalRenderNode()
 {
     g.vs.first = g.fs.first = nil;
     g.vs.second = g.fs.second = nil;

     for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
         g.vbuf[i] = nil;
         g.ubuf[i] = nil;
     }
 }

 MetalRenderNode::~MetalRenderNode()
 {
     releaseResources();
 }

 void MetalRenderNode::releaseResources()
 {
     [g.stencilEnabledDsState release];
     g.stencilEnabledDsState = nil;

     [g.pipeline release];
     g.pipeline = nil;

     [g.vs.first release];
     [g.vs.second release];

     [g.fs.first release];
     [g.fs.second release];

     g.vs.first = g.fs.first = nil;
     g.vs.second = g.fs.second = nil;

     for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
         [g.vbuf[i] release];
         g.vbuf[i] = nil;
         [g.ubuf[i] release];
         g.ubuf[i] = nil;
     }
 }

 void MetalRenderNode::render(const RenderState *state)
 {
     Q_ASSERT(m_window);
     const QQuickWindow::GraphicsStateInfo &stateInfo(m_window->graphicsStateInfo());
     id<MTLBuffer> vbuf = g.vbuf[stateInfo.currentFrameSlot];
     id<MTLBuffer> ubuf = g.ubuf[stateInfo.currentFrameSlot];

     QPointF p0(m_width - 1, m_height - 1);
     QPointF p1(0, 0);
     QPointF p2(0, m_height - 1);

     float vertices[6] = { float(p0.x()), float(p0.y()),
                           float(p1.x()), float(p1.y()),
                           float(p2.x()), float(p2.y()) };
     char *p = (char *) [vbuf contents];
     memcpy(p, vertices, VERTEX_SIZE);

     const QMatrix4x4 mvp = *state->projectionMatrix() * *matrix();
     const float opacity = inheritedOpacity();

     p = (char *) [ubuf contents];
     memcpy(p, mvp.constData(), 64);
     memcpy(p + 64, &opacity, 4);

     QSGRendererInterface *rif = m_window->rendererInterface();
     id<MTLRenderCommandEncoder> encoder = (id<MTLRenderCommandEncoder>) rif->getResource(
                 m_window, QSGRendererInterface::CommandEncoderResource);
     Q_ASSERT(encoder);

     [encoder setVertexBuffer: vbuf offset: 0 atIndex: 1];
     [encoder setVertexBuffer: vbuf offset: VERTEX_SIZE atIndex: 2];

     [encoder setVertexBuffer: ubuf offset: 0 atIndex: 0];
     [encoder setFragmentBuffer: ubuf offset: 0 atIndex: 0];

     // Clip support.
     if (state->scissorEnabled()) {
         const QRect r = state->scissorRect(); // bottom-up
         MTLScissorRect s;
         s.x = r.x();
         s.y = m_outputHeight - (r.y() + r.height());
         s.width = r.width();
         s.height = r.height();
         [encoder setScissorRect: s];
     }
     if (state->stencilEnabled()) {
         [encoder setDepthStencilState: g.stencilEnabledDsState];
         [encoder setStencilReferenceValue: state->stencilValue()];
     }

     [encoder setRenderPipelineState: g.pipeline];
     [encoder drawPrimitives: MTLPrimitiveTypeTriangle vertexStart: 0 vertexCount: 3 instanceCount: 1 baseInstance: 0];
 }

 QSGRenderNode::StateFlags MetalRenderNode::changedStates() const
 {
     return BlendState | ScissorState | StencilState;
 }

 QSGRenderNode::RenderingFlags MetalRenderNode::flags() const
 {
     return BoundedRectRendering | DepthAwareRendering;
 }

 QRectF MetalRenderNode::rect() const
 {
     return QRect(0, 0, m_width, m_height);
 }

 void MetalRenderNode::sync(QQuickItem *item)
 {
     m_window = item->window();
     m_width = item->width();
     m_height = item->height();
     m_outputHeight = m_window->height() * m_window->effectiveDevicePixelRatio();
 }
	/****************************************************************************
	**
	** Copyright (C) 2019 The Qt Company Ltd.
	** Contact: https://www.qt.io/licensing/
	**
	** This file is part of the examples of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:BSD$
	** Commercial License Usage
	** Licensees holding valid commercial Qt licenses may use this file in
	** accordance with the commercial license agreement provided with the
	** Software or, alternatively, in accordance with the terms contained in
	** a written agreement between you and The Qt Company. For licensing terms
	** and conditions see https://www.qt.io/terms-conditions. For further
	** information use the contact form at https://www.qt.io/contact-us.
	**
	** BSD License Usage
	** Alternatively, you may use this file under the terms of the BSD license
	** as follows:
	**
	** "Redistribution and use in source and binary forms, with or without
	** modification, are permitted provided that the following conditions are
	** met:
	** * Redistributions of source code must retain the above copyright
	** notice, this list of conditions and the following disclaimer.
	** * Redistributions in binary form must reproduce the above copyright
	** notice, this list of conditions and the following disclaimer in
	** the documentation and/or other materials provided with the
	** distribution.
	** * Neither the name of The Qt Company Ltd nor the names of its
	** contributors may be used to endorse or promote products derived
	** from this software without specific prior written permission.
	**
	**
	** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include "metalrenderer.h"
	#include <QQuickItem>
	#include <QQuickWindow>

	#include <Metal/Metal.h>

	using FuncAndLib = QPair<id<MTLFunction>, id<MTLLibrary> >;

	const int MAX_FRAMES_IN_FLIGHT = 3;

	struct {
	id<MTLDevice> dev = nil;
	QByteArray vsSource;
	FuncAndLib vs;
	QByteArray fsSource;
	FuncAndLib fs;
	id<MTLBuffer> vbuf[MAX_FRAMES_IN_FLIGHT];
	id<MTLBuffer> ubuf[MAX_FRAMES_IN_FLIGHT];
	id<MTLDepthStencilState> stencilEnabledDsState = nil;
	id<MTLRenderPipelineState> pipeline = nil;
	} g;

	static FuncAndLib compileShaderFromSource(const QByteArray &src, const QByteArray &entryPoint)
	{
	FuncAndLib fl;

	NSString *srcstr = [NSString stringWithUTF8String: src.constData()];
	MTLCompileOptions *opts = [[MTLCompileOptions alloc] init];
	opts.languageVersion = MTLLanguageVersion1_2;
	NSError *err = nil;
	fl.second = [g.dev newLibraryWithSource: srcstr options: opts error: &err];
	[opts release];
	// srcstr is autoreleased

	if (err) {
	const QString msg = QString::fromNSString(err.localizedDescription);
	qFatal("%s", qPrintable(msg));
	return fl;
	}

	NSString *name = [NSString stringWithUTF8String: entryPoint.constData()];
	fl.first = [fl.second newFunctionWithName: name];
	[name release];

	return fl;
	}

	const int VERTEX_SIZE = 6 * sizeof(float);

	static float colors[] = {
	1.0f, 0.0f, 0.0f,
	0.0f, 1.0f, 0.0f,
	0.0f, 0.0f, 1.0f
	};

	void MetalRenderNodeResourceBuilder::build()
	{
	if (!g.dev) {
	QSGRendererInterface *rif = m_window->rendererInterface();
	Q_ASSERT(rif->graphicsApi() == QSGRendererInterface::MetalRhi);

	g.dev = (id<MTLDevice>) rif->getResource(m_window, QSGRendererInterface::DeviceResource);
	Q_ASSERT(g.dev);
	}

	if (g.vsSource.isEmpty()) {
	const QString filename = QLatin1String(":/scenegraph/rendernode/metalshader.vert");
	QFile f(filename);
	if (!f.open(QIODevice::ReadOnly \| QIODevice::Text))
	qFatal("Failed to read shader %s", qPrintable(filename));
	g.vsSource = f.readAll();
	g.vs = compileShaderFromSource(g.vsSource, QByteArrayLiteral("main0"));
	}

	if (g.fsSource.isEmpty()) {
	const QString filename = QLatin1String(":/scenegraph/rendernode/metalshader.frag");
	QFile f(filename);
	if (!f.open(QIODevice::ReadOnly \| QIODevice::Text))
	qFatal("Failed to read shader %s", qPrintable(filename));
	g.fsSource = f.readAll();
	g.fs = compileShaderFromSource(g.fsSource, QByteArrayLiteral("main0"));
	}

	const int framesInFlight = m_window->graphicsStateInfo().framesInFlight;

	// For simplicity's sake we use shared mode (something like host visible +
	// host coherent) for everything.

	for (int i = 0; i < framesInFlight; ++i) {
	// Have multiple versions for vertex too since we'll just memcpy new
	// vertices based on item width and height on every render(). This could
	// be optimized further however.
	if (!g.vbuf[i]) {
	g.vbuf[i] = [g.dev newBufferWithLength: VERTEX_SIZE + sizeof(colors) options: MTLResourceStorageModeShared];
	char p = (char ) [g.vbuf[i] contents];
	memcpy(p + VERTEX_SIZE, colors, sizeof(colors));
	}

	if (!g.ubuf[i])
	g.ubuf[i] = [g.dev newBufferWithLength: 256 options: MTLResourceStorageModeShared];
	}

	if (!g.stencilEnabledDsState) {
	MTLDepthStencilDescriptor *dsDesc = [[MTLDepthStencilDescriptor alloc] init];
	dsDesc.frontFaceStencil = [[MTLStencilDescriptor alloc] init];
	dsDesc.frontFaceStencil.stencilFailureOperation = MTLStencilOperationKeep;
	dsDesc.frontFaceStencil.depthFailureOperation = MTLStencilOperationKeep;
	dsDesc.frontFaceStencil.depthStencilPassOperation = MTLStencilOperationKeep;
	dsDesc.frontFaceStencil.stencilCompareFunction = MTLCompareFunctionEqual;
	dsDesc.frontFaceStencil.readMask = 0xFF;
	dsDesc.frontFaceStencil.writeMask = 0xFF;

	dsDesc.backFaceStencil = [[MTLStencilDescriptor alloc] init];
	dsDesc.backFaceStencil.stencilFailureOperation = MTLStencilOperationKeep;
	dsDesc.backFaceStencil.depthFailureOperation = MTLStencilOperationKeep;
	dsDesc.backFaceStencil.depthStencilPassOperation = MTLStencilOperationKeep;
	dsDesc.backFaceStencil.stencilCompareFunction = MTLCompareFunctionEqual;
	dsDesc.backFaceStencil.readMask = 0xFF;
	dsDesc.backFaceStencil.writeMask = 0xFF;

	g.stencilEnabledDsState = [g.dev newDepthStencilStateWithDescriptor: dsDesc];
	[dsDesc release];
	}

	if (!g.pipeline) {
	MTLVertexDescriptor *inputLayout = [MTLVertexDescriptor vertexDescriptor];
	inputLayout.attributes[0].format = MTLVertexFormatFloat2;
	inputLayout.attributes[0].offset = 0;
	inputLayout.attributes[0].bufferIndex = 1; // ubuf is 0, vbuf is 1 and 2
	inputLayout.attributes[1].format = MTLVertexFormatFloat3;
	inputLayout.attributes[1].offset = 0;
	inputLayout.attributes[1].bufferIndex = 2;
	inputLayout.layouts[1].stride = 2 * sizeof(float);
	inputLayout.layouts[2].stride = 3 * sizeof(float);

	MTLRenderPipelineDescriptor *rpDesc = [[MTLRenderPipelineDescriptor alloc] init];
	rpDesc.vertexDescriptor = inputLayout;

	rpDesc.vertexFunction = g.vs.first;
	rpDesc.fragmentFunction = g.fs.first;

	rpDesc.colorAttachments[0].pixelFormat = MTLPixelFormatBGRA8Unorm;
	rpDesc.colorAttachments[0].blendingEnabled = true;
	rpDesc.colorAttachments[0].sourceRGBBlendFactor = MTLBlendFactorOne;
	rpDesc.colorAttachments[0].sourceAlphaBlendFactor = MTLBlendFactorOne;
	rpDesc.colorAttachments[0].destinationRGBBlendFactor = MTLBlendFactorOneMinusSourceAlpha;
	rpDesc.colorAttachments[0].destinationAlphaBlendFactor = MTLBlendFactorOneMinusSourceAlpha;

	if (g.dev.depth24Stencil8PixelFormatSupported) {
	rpDesc.depthAttachmentPixelFormat = MTLPixelFormatDepth24Unorm_Stencil8;
	rpDesc.stencilAttachmentPixelFormat = MTLPixelFormatDepth24Unorm_Stencil8;
	} else {
	rpDesc.depthAttachmentPixelFormat = MTLPixelFormatDepth32Float_Stencil8;
	rpDesc.stencilAttachmentPixelFormat = MTLPixelFormatDepth32Float_Stencil8;
	}

	NSError *err = nil;
	g.pipeline = [g.dev newRenderPipelineStateWithDescriptor: rpDesc error: &err];
	if (!g.pipeline) {
	const QString msg = QString::fromNSString(err.localizedDescription);
	qFatal("Failed to create render pipeline state: %s", qPrintable(msg));
	}
	[rpDesc release];
	}
	}

	MetalRenderNode::MetalRenderNode()
	{
	g.vs.first = g.fs.first = nil;
	g.vs.second = g.fs.second = nil;

	for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
	g.vbuf[i] = nil;
	g.ubuf[i] = nil;
	}
	}

	MetalRenderNode::~MetalRenderNode()
	{
	releaseResources();
	}

	void MetalRenderNode::releaseResources()
	{
	[g.stencilEnabledDsState release];
	g.stencilEnabledDsState = nil;

	[g.pipeline release];
	g.pipeline = nil;

	[g.vs.first release];
	[g.vs.second release];

	[g.fs.first release];
	[g.fs.second release];

	g.vs.first = g.fs.first = nil;
	g.vs.second = g.fs.second = nil;

	for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; ++i) {
	[g.vbuf[i] release];
	g.vbuf[i] = nil;
	[g.ubuf[i] release];
	g.ubuf[i] = nil;
	}
	}

	void MetalRenderNode::render(const RenderState *state)
	{
	Q_ASSERT(m_window);
	const QQuickWindow::GraphicsStateInfo &stateInfo(m_window->graphicsStateInfo());
	id<MTLBuffer> vbuf = g.vbuf[stateInfo.currentFrameSlot];
	id<MTLBuffer> ubuf = g.ubuf[stateInfo.currentFrameSlot];

	QPointF p0(m_width - 1, m_height - 1);
	QPointF p1(0, 0);
	QPointF p2(0, m_height - 1);

	float vertices[6] = { float(p0.x()), float(p0.y()),
	float(p1.x()), float(p1.y()),
	float(p2.x()), float(p2.y()) };
	char p = (char ) [vbuf contents];
	memcpy(p, vertices, VERTEX_SIZE);

	const QMatrix4x4 mvp = state->projectionMatrix() *matrix();
	const float opacity = inheritedOpacity();

	p = (char *) [ubuf contents];
	memcpy(p, mvp.constData(), 64);
	memcpy(p + 64, &opacity, 4);

	QSGRendererInterface *rif = m_window->rendererInterface();
	id<MTLRenderCommandEncoder> encoder = (id<MTLRenderCommandEncoder>) rif->getResource(
	m_window, QSGRendererInterface::CommandEncoderResource);
	Q_ASSERT(encoder);

	[encoder setVertexBuffer: vbuf offset: 0 atIndex: 1];
	[encoder setVertexBuffer: vbuf offset: VERTEX_SIZE atIndex: 2];

	[encoder setVertexBuffer: ubuf offset: 0 atIndex: 0];
	[encoder setFragmentBuffer: ubuf offset: 0 atIndex: 0];

	// Clip support.
	if (state->scissorEnabled()) {
	const QRect r = state->scissorRect(); // bottom-up
	MTLScissorRect s;
	s.x = r.x();
	s.y = m_outputHeight - (r.y() + r.height());
	s.width = r.width();
	s.height = r.height();
	[encoder setScissorRect: s];
	}
	if (state->stencilEnabled()) {
	[encoder setDepthStencilState: g.stencilEnabledDsState];
	[encoder setStencilReferenceValue: state->stencilValue()];
	}

	[encoder setRenderPipelineState: g.pipeline];
	[encoder drawPrimitives: MTLPrimitiveTypeTriangle vertexStart: 0 vertexCount: 3 instanceCount: 1 baseInstance: 0];
	}

	QSGRenderNode::StateFlags MetalRenderNode::changedStates() const
	{
	return BlendState \| ScissorState \| StencilState;
	}

	QSGRenderNode::RenderingFlags MetalRenderNode::flags() const
	{
	return BoundedRectRendering \| DepthAwareRendering;
	}

	QRectF MetalRenderNode::rect() const
	{
	return QRect(0, 0, m_width, m_height);
	}

	void MetalRenderNode::sync(QQuickItem *item)
	{
	m_window = item->window();
	m_width = item->width();
	m_height = item->height();
	m_outputHeight = m_window->height() * m_window->effectiveDevicePixelRatio();
	}