alysbrooks-public » games » isometric-park-fna

Location: alysbrooks-public/games/isometric-park-fna/FNA/src/FNAPlatform/MetalDevice.cs - annotation

Show More
Commit Description:
Tidy code.
Commit Description:
Tidy code.
References:
r290:dfcb041e5452 default
File last commit:
r0:e33f209de7e5 default
Show/Diff file:
Action:
FNA/src/FNAPlatform/MetalDevice.cs
4698 lines | 107.4 KiB | text/x-csharp | CSharpLexer
History | Source | Raw | Download
alys
Early working version (including all dependencies, lol).
 r0 #region License
/* FNA - XNA4 Reimplementation for Desktop Platforms
* Copyright 2009-2020 Ethan Lee and the MonoGame Team
*
* Released under the Microsoft Public License.
* See LICENSE for details.
*/
#endregion
#region Using Statements
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using SDL2;
#endregion
namespace Microsoft.Xna.Framework.Graphics
{
internal partial class MetalDevice : IGLDevice
{
#region Metal Texture Container Class
private class MetalTexture : IGLTexture
{
public IntPtr Handle
{
get;
private set;
}
public bool HasMipmaps
{
get;
private set;
}
public int Width
{
get;
private set;
}
public int Height
{
get;
private set;
}
public bool IsPrivate
{
get;
private set;
}
public SurfaceFormat Format;
public TextureAddressMode WrapS;
public TextureAddressMode WrapT;
public TextureAddressMode WrapR;
public TextureFilter Filter;
public float Anisotropy;
public int MaxMipmapLevel;
public float LODBias;
public MetalTexture(
IntPtr handle,
int width,
int height,
SurfaceFormat format,
int levelCount,
bool isPrivate
) {
Handle = handle;
Width = width;
Height = height;
Format = format;
HasMipmaps = levelCount > 1;
IsPrivate = isPrivate;
WrapS = TextureAddressMode.Wrap;
WrapT = TextureAddressMode.Wrap;
WrapR = TextureAddressMode.Wrap;
Filter = TextureFilter.Linear;
Anisotropy = 4.0f;
MaxMipmapLevel = 0;
LODBias = 0.0f;
}
private MetalTexture()
{
Handle = IntPtr.Zero;
}
public static readonly MetalTexture NullTexture = new MetalTexture();
public void Dispose()
{
objc_release(Handle);
Handle = IntPtr.Zero;
}
}
#endregion
#region Metal Renderbuffer Container Class
private class MetalRenderbuffer : IGLRenderbuffer
{
public IntPtr Handle
{
get;
private set;
}
public IntPtr MultiSampleHandle
{
get;
private set;
}
public MTLPixelFormat PixelFormat
{
get;
private set;
}
public int MultiSampleCount
{
get;
private set;
}
public MetalRenderbuffer(
IntPtr handle,
MTLPixelFormat pixelFormat,
int multiSampleCount,
IntPtr multiSampleHandle
) {
Handle = handle;
PixelFormat = pixelFormat;
MultiSampleCount = multiSampleCount;
MultiSampleHandle = multiSampleHandle;
}
public void Dispose()
{
if (MultiSampleHandle == IntPtr.Zero)
{
objc_release(Handle);
Handle = IntPtr.Zero;
}
else
{
objc_release(MultiSampleHandle);
MultiSampleHandle = IntPtr.Zero;
/* Don't release the regular Handle since
* it's owned by the associated IGLTexture.
*/
Handle = IntPtr.Zero;
}
}
}
#endregion
#region Metal Buffer Container Class
private class MetalBuffer : IGLBuffer
{
public IntPtr Handle
{
get;
private set;
}
public IntPtr Contents
{
get;
private set;
}
public IntPtr BufferSize
{
get;
private set;
}
public int InternalOffset
{
get;
private set;
}
private MetalDevice device;
private IntPtr mtlDevice = IntPtr.Zero;
private int internalBufferSize = 0;
private int prevDataLength = 0;
private int prevInternalOffset;
private BufferUsage usage;
private bool boundThisFrame;
public MetalBuffer(
MetalDevice device,
bool dynamic,
BufferUsage usage,
IntPtr bufferSize
) {
this.device = device;
this.mtlDevice = device.device;
this.usage = usage;
BufferSize = bufferSize;
internalBufferSize = (int) bufferSize;
CreateBackingBuffer(-1);
}
private void CreateBackingBuffer(int prevSize)
{
IntPtr oldBuffer = Handle;
IntPtr oldContents = Contents;
Handle = mtlNewBufferWithLength(
mtlDevice,
internalBufferSize,
usage == BufferUsage.WriteOnly ?
MTLResourceOptions.CPUCacheModeWriteCombined :
MTLResourceOptions.CPUCacheModeDefaultCache
);
Contents = mtlGetBufferContentsPtr(Handle);
// Copy over data from old buffer
if (oldBuffer != IntPtr.Zero)
{
SDL.SDL_memcpy(
Contents,
oldContents,
(IntPtr) prevSize
);
objc_release(oldBuffer);
}
}
public void SetData(
int offsetInBytes,
IntPtr data,
int dataLength,
SetDataOptions options
) {
if (options == SetDataOptions.None && boundThisFrame)
{
device.Stall();
boundThisFrame = true;
}
else if (options == SetDataOptions.Discard && boundThisFrame)
{
InternalOffset += (int) BufferSize;
if (InternalOffset + dataLength > internalBufferSize)
{
// Expand!
int prevSize = internalBufferSize;
internalBufferSize *= 2;
CreateBackingBuffer(prevSize);
}
}
// Copy previous contents, if needed
if (prevInternalOffset != InternalOffset && dataLength < (int) BufferSize)
{
SDL.SDL_memcpy(
Contents + InternalOffset,
Contents + prevInternalOffset,
BufferSize
);
}
// Copy the data into the buffer
SDL.SDL_memcpy(
Contents + InternalOffset + offsetInBytes,
data,
(IntPtr) dataLength
);
prevInternalOffset = InternalOffset;
prevDataLength = (int) BufferSize;
}
public void SetData(
int offsetInBytes,
IntPtr data,
int dataLength
) {
InternalOffset += prevDataLength;
if (InternalOffset + dataLength > internalBufferSize)
{
// Expand!
int prevSize = internalBufferSize;
internalBufferSize = Math.Max(
internalBufferSize * 2,
internalBufferSize + dataLength
);
CreateBackingBuffer(prevSize);
}
// Copy the data into the buffer
SDL.SDL_memcpy(
Contents + InternalOffset,
data + offsetInBytes,
(IntPtr) dataLength
);
prevDataLength = dataLength;
}
public void Bound()
{
boundThisFrame = true;
}
public void Reset()
{
InternalOffset = 0;
boundThisFrame = false;
prevDataLength = 0;
}
public void Dispose()
{
objc_release(Handle);
Handle = IntPtr.Zero;
}
}
#endregion
#region Metal Effect Container Class
private class MetalEffect : IGLEffect
{
public IntPtr EffectData
{
get;
private set;
}
public IntPtr MTLEffectData
{
get;
private set;
}
public MetalEffect(IntPtr effect, IntPtr mtlEffect)
{
EffectData = effect;
MTLEffectData = mtlEffect;
}
}
#endregion
#region Metal Query Container Class
private class MetalQuery : IGLQuery
{
public IntPtr Handle
{
get;
private set;
}
public MetalQuery(IntPtr handle)
{
Handle = handle;
}
public void Dispose()
{
objc_release(Handle);
Handle = IntPtr.Zero;
}
}
#endregion
#region Blending State Variables
private Color blendColor = Color.Transparent;
public Color BlendFactor
{
get
{
return blendColor;
}
set
{
if (value != blendColor)
{
blendColor = value;
SetEncoderBlendColor();
}
}
}
private int multisampleMask = -1; // AKA 0xFFFFFFFF
public int MultiSampleMask
{
get
{
return multisampleMask;
}
set
{
multisampleMask = value;
// FIXME: Metal does not support multisample masks. Workarounds...?
}
}
#endregion
#region Stencil State Variables
private int stencilRef = 0;
public int ReferenceStencil
{
get
{
return stencilRef;
}
set
{
if (value != stencilRef)
{
stencilRef = value;
SetEncoderStencilReferenceValue();
}
}
}
#endregion
#region Rasterizer State Variables
private bool scissorTestEnable = false;
private CullMode cullFrontFace = CullMode.None;
private FillMode fillMode = FillMode.Solid;
private float depthBias = 0.0f;
private float slopeScaleDepthBias = 0.0f;
private bool multiSampleEnable = true;
#endregion
#region Viewport State Variables
private Rectangle scissorRectangle = new Rectangle();
private Rectangle viewport = new Rectangle();
private float depthRangeMin = 0.0f;
private float depthRangeMax = 1.0f;
/* Used for resetting scissor rectangle */
private int currentAttachmentWidth;
private int currentAttachmentHeight;
#endregion
#region Sampler State Variables
private MetalTexture[] Textures;
private IntPtr[] Samplers;
private bool[] textureNeedsUpdate;
private bool[] samplerNeedsUpdate;
#endregion
#region Depth Stencil State Variables
private DepthStencilState depthStencilState;
private IntPtr defaultDepthStencilState; // MTLDepthStencilState*
private IntPtr ldDepthStencilState; // MTLDepthStencilState*
private MTLPixelFormat D16Format;
private MTLPixelFormat D24Format;
private MTLPixelFormat D24S8Format;
#endregion
#region Buffer Binding Cache Variables
private List<MetalBuffer> Buffers = new List<MetalBuffer>();
private MetalBuffer userVertexBuffer = null;
private MetalBuffer userIndexBuffer = null;
private int userVertexStride = 0;
// Some vertex declarations may have overlapping attributes :/
private bool[,] attrUse = new bool[(int) MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_TOTAL, 16];
#endregion
#region Render Target Cache Variables
private readonly IntPtr[] currentAttachments;
private readonly MTLPixelFormat[] currentColorFormats;
private readonly IntPtr[] currentMSAttachments;
private readonly CubeMapFace[] currentAttachmentSlices;
private IntPtr currentDepthStencilBuffer;
private DepthFormat currentDepthFormat;
private int currentSampleCount;
#endregion
#region Clear Cache Variables
private Vector4 clearColor = new Vector4(0, 0, 0, 0);
private float clearDepth = 1.0f;
private int clearStencil = 0;
private bool shouldClearColor = false;
private bool shouldClearDepth = false;
private bool shouldClearStencil = false;
#endregion
#region Private Metal State Variables
private IntPtr view; // SDL_MetalView*
private IntPtr layer; // CAMetalLayer*
private IntPtr device; // MTLDevice*
private IntPtr queue; // MTLCommandQueue*
private IntPtr commandBuffer; // MTLCommandBuffer*
private IntPtr renderCommandEncoder; // MTLRenderCommandEncoder*
private IntPtr currentVertexDescriptor; // MTLVertexDescriptor*
private IntPtr currentVisibilityBuffer; // MTLBuffer*
private bool needNewRenderPass;
#endregion
#region Operating System Variables
private bool isMac;
#endregion
#region Frame Tracking Variables
/* FIXME:
* In theory, double- or even triple-buffering could
* significantly help performance by reducing CPU idle
* time. The trade-off is that buffer synchronization
* becomes much more complicated and error-prone.
*
* I've attempted a few implementations of multi-
* buffering, but they all had serious issues and
* typically performed worse than single buffering.
*
* I'm leaving these variables here in case any brave
* souls want to attempt a multi-buffer implementation.
* This could be a huge win for performance, but it'll
* take someone smarter than me to figure this out. ;)
*
* -caleb
*/
private const int MAX_FRAMES_IN_FLIGHT = 1;
private Queue<IntPtr> committedCommandBuffers = new Queue<IntPtr>();
private bool frameInProgress = false;
#endregion
#region Objective-C Memory Management Variables
private IntPtr pool; // NSAutoreleasePool*
#endregion
#region Faux-Backbuffer Variables
public IGLBackbuffer Backbuffer
{
get;
private set;
}
private MTLSamplerMinMagFilter backbufferScaleMode;
// Cached data for rendering the faux-backbuffer
private Rectangle fauxBackbufferDestBounds;
private IntPtr fauxBackbufferDrawBuffer;
private IntPtr fauxBackbufferRenderPipeline;
private IntPtr fauxBackbufferSamplerState;
private bool fauxBackbufferSizeChanged;
#endregion
#region Metal Device Capabilities
public bool SupportsDxt1
{
get;
private set;
}
public bool SupportsS3tc
{
get;
private set;
}
public bool SupportsHardwareInstancing
{
get
{
return true;
}
}
public bool SupportsNoOverwrite
{
get
{
return true;
}
}
public int MaxTextureSlots
{
get
{
return 16;
}
}
public int MaxMultiSampleCount
{
get;
private set;
}
private bool supportsOcclusionQueries;
#endregion
#region Private State Object Caches
private Dictionary<ulong, IntPtr> VertexDescriptorCache =
new Dictionary<ulong, IntPtr>();
private Dictionary<PipelineHash, IntPtr> PipelineStateCache =
new Dictionary<PipelineHash, IntPtr>();
private Dictionary<StateHash, IntPtr> DepthStencilStateCache =
new Dictionary<StateHash, IntPtr>();
private Dictionary<StateHash, IntPtr> SamplerStateCache =
new Dictionary<StateHash, IntPtr>();
private List<MetalTexture> transientTextures =
new List<MetalTexture>();
#endregion
#region Private Render Pipeline State Variables
private BlendState blendState;
private IntPtr ldPipelineState = IntPtr.Zero;
#endregion
#region Private Buffer Binding Cache
private const int MAX_BOUND_VERTEX_BUFFERS = 16;
private IntPtr ldVertUniformBuffer = IntPtr.Zero;
private IntPtr ldFragUniformBuffer = IntPtr.Zero;
private int ldVertUniformOffset = 0;
private int ldFragUniformOffset = 0;
private IntPtr[] ldVertexBuffers;
private int[] ldVertexBufferOffsets;
#endregion
#region Private MojoShader Interop
private IntPtr currentEffect = IntPtr.Zero;
private IntPtr currentTechnique = IntPtr.Zero;
private uint currentPass = 0;
private IntPtr prevEffect = IntPtr.Zero;
private MojoShader.MOJOSHADER_mtlShaderState shaderState = new MojoShader.MOJOSHADER_mtlShaderState();
private MojoShader.MOJOSHADER_mtlShaderState prevShaderState;
#endregion
#region Public Constructor
public MetalDevice(PresentationParameters presentationParameters)
{
device = MTLCreateSystemDefaultDevice();
queue = mtlNewCommandQueue(device);
// Create the Metal view
view = SDL.SDL_Metal_CreateView(
presentationParameters.DeviceWindowHandle
);
// Get the layer from the view
layer = mtlGetLayer(view);
// Set up the CAMetalLayer
mtlSetLayerDevice(layer, device);
mtlSetLayerFramebufferOnly(layer, true);
mtlSetLayerMagnificationFilter(layer, UTF8ToNSString("nearest"));
// Log GLDevice info
FNALoggerEXT.LogInfo("IGLDevice: MetalDevice");
FNALoggerEXT.LogInfo("Device Name: " + mtlGetDeviceName(device));
FNALoggerEXT.LogInfo("MojoShader Profile: metal");
// Some users might want pixely upscaling...
backbufferScaleMode = Environment.GetEnvironmentVariable(
"FNA_GRAPHICS_BACKBUFFER_SCALE_NEAREST"
) == "1" ? MTLSamplerMinMagFilter.Nearest : MTLSamplerMinMagFilter.Linear;
// Set device properties
isMac = SDL.SDL_GetPlatform().Equals("Mac OS X");
SupportsS3tc = SupportsDxt1 = isMac;
MaxMultiSampleCount = mtlSupportsSampleCount(device, 8) ? 8 : 4;
supportsOcclusionQueries = isMac || HasModernAppleGPU();
// Determine supported depth formats
D16Format = MTLPixelFormat.Depth32Float;
D24Format = MTLPixelFormat.Depth32Float;
D24S8Format = MTLPixelFormat.Depth32Float_Stencil8;
if (isMac)
{
bool supportsD24S8 = mtlSupportsDepth24Stencil8(device);
if (supportsD24S8)
{
D24S8Format = MTLPixelFormat.Depth24Unorm_Stencil8;
// Gross, but at least it's a unorm format! -caleb
D24Format = MTLPixelFormat.Depth24Unorm_Stencil8;
D16Format = MTLPixelFormat.Depth24Unorm_Stencil8;
}
// Depth16Unorm requires macOS 10.12+
if (OperatingSystemAtLeast(10, 12, 0))
{
D16Format = MTLPixelFormat.Depth16Unorm;
}
}
else
{
// Depth16Unorm requires iOS 13+
if (OperatingSystemAtLeast(13, 0, 0))
{
D16Format = MTLPixelFormat.Depth16Unorm;
}
}
// Add fallbacks for missing texture formats on macOS
if (isMac)
{
XNAToMTL.TextureFormat[(int) SurfaceFormat.Bgr565]
= MTLPixelFormat.BGRA8Unorm;
XNAToMTL.TextureFormat[(int) SurfaceFormat.Bgra5551]
= MTLPixelFormat.BGRA8Unorm;
XNAToMTL.TextureFormat[(int) SurfaceFormat.Bgra4444]
= MTLPixelFormat.BGRA8Unorm;
}
// Initialize texture and sampler collections
Textures = new MetalTexture[MaxTextureSlots];
Samplers = new IntPtr[MaxTextureSlots];
for (int i = 0; i < MaxTextureSlots; i += 1)
{
Textures[i] = MetalTexture.NullTexture;
Samplers[i] = IntPtr.Zero;
}
textureNeedsUpdate = new bool[MaxTextureSlots];
samplerNeedsUpdate = new bool[MaxTextureSlots];
// Initialize attachment arrays
int numAttachments = GraphicsDevice.MAX_RENDERTARGET_BINDINGS;
currentAttachments = new IntPtr[numAttachments];
currentColorFormats = new MTLPixelFormat[numAttachments];
currentMSAttachments = new IntPtr[numAttachments];
currentAttachmentSlices = new CubeMapFace[numAttachments];
// Initialize vertex buffer cache
ldVertexBuffers = new IntPtr[MAX_BOUND_VERTEX_BUFFERS];
ldVertexBufferOffsets = new int[MAX_BOUND_VERTEX_BUFFERS];
// Create a default depth stencil state
IntPtr defDS = mtlNewDepthStencilDescriptor();
defaultDepthStencilState = mtlNewDepthStencilStateWithDescriptor(device, defDS);
objc_release(defDS);
// Create and setup the faux-backbuffer
InitializeFauxBackbuffer(presentationParameters);
}
#endregion
#region Dispose Method
public void Dispose()
{
// Stop rendering
EndPass();
// Release vertex descriptors
foreach (IntPtr vdesc in VertexDescriptorCache.Values)
{
objc_release(vdesc);
}
VertexDescriptorCache.Clear();
VertexDescriptorCache = null;
// Release depth stencil states
foreach (IntPtr ds in DepthStencilStateCache.Values)
{
objc_release(ds);
}
DepthStencilStateCache.Clear();
DepthStencilStateCache = null;
// Release pipeline states
foreach (IntPtr pso in PipelineStateCache.Values)
{
objc_release(pso);
}
PipelineStateCache.Clear();
PipelineStateCache = null;
// Release sampler states
foreach (IntPtr ss in SamplerStateCache.Values)
{
objc_release(ss);
}
SamplerStateCache.Clear();
SamplerStateCache = null;
// Release transient textures
foreach (MetalTexture tex in transientTextures)
{
objc_release(tex.Handle);
}
transientTextures.Clear();
transientTextures = null;
// Dispose the backbuffer
(Backbuffer as MetalBackbuffer).Dispose();
// Destroy the view
SDL.SDL_Metal_DestroyView(view);
}
#endregion
#region GetDrawableSize Methods
public static void GetDrawableSize(
IntPtr layer,
out int w,
out int h
) {
CGSize size = mtlGetDrawableSize(layer);
w = (int) size.width;
h = (int) size.height;
}
public static void GetDrawableSizeFromView(
IntPtr view,
out int w,
out int h
) {
GetDrawableSize(mtlGetLayer(view), out w, out h);
}
#endregion
#region Window Backbuffer Reset Method
public void ResetBackbuffer(PresentationParameters presentationParameters)
{
Backbuffer.ResetFramebuffer(presentationParameters);
}
#endregion
#region BeginFrame Method
public void BeginFrame()
{
if (frameInProgress) return;
// Wait for command buffers to complete...
while (committedCommandBuffers.Count >= MAX_FRAMES_IN_FLIGHT)
{
IntPtr cmdbuf = committedCommandBuffers.Dequeue();
mtlCommandBufferWaitUntilCompleted(cmdbuf);
objc_release(cmdbuf);
}
// The cycle begins anew!
frameInProgress = true;
pool = objc_autoreleasePoolPush();
commandBuffer = mtlMakeCommandBuffer(queue);
}
#endregion
#region Window SwapBuffers Method
public void SwapBuffers(
Rectangle? sourceRectangle,
Rectangle? destinationRectangle,
IntPtr overrideWindowHandle
) {
/* Just in case Present() is called
* before any rendering happens...
*/
BeginFrame();
// Bind the backbuffer and finalize rendering
SetRenderTargets(null, null, DepthFormat.None);
EndPass();
// Determine the regions to present
int srcX, srcY, srcW, srcH;
int dstX, dstY, dstW, dstH;
if (sourceRectangle.HasValue)
{
srcX = sourceRectangle.Value.X;
srcY = sourceRectangle.Value.Y;
srcW = sourceRectangle.Value.Width;
srcH = sourceRectangle.Value.Height;
}
else
{
srcX = 0;
srcY = 0;
srcW = Backbuffer.Width;
srcH = Backbuffer.Height;
}
if (destinationRectangle.HasValue)
{
dstX = destinationRectangle.Value.X;
dstY = destinationRectangle.Value.Y;
dstW = destinationRectangle.Value.Width;
dstH = destinationRectangle.Value.Height;
}
else
{
dstX = 0;
dstY = 0;
GetDrawableSize(
layer,
out dstW,
out dstH
);
}
// Get the next drawable
IntPtr drawable = mtlNextDrawable(layer);
// "Blit" the backbuffer to the drawable
BlitFramebuffer(
currentAttachments[0],
new Rectangle(srcX, srcY, srcW, srcH),
mtlGetTextureFromDrawable(drawable),
new Rectangle(dstX, dstY, dstW, dstH)
);
// Commit the command buffer for presentation
mtlPresentDrawable(commandBuffer, drawable);
mtlCommitCommandBuffer(commandBuffer);
// Enqueue the command buffer for tracking
objc_retain(commandBuffer);
committedCommandBuffers.Enqueue(commandBuffer);
commandBuffer = IntPtr.Zero;
// Release allocations from the past frame
objc_autoreleasePoolPop(pool);
// Reset buffers
for (int i = 0; i < Buffers.Count; i += 1)
{
Buffers[i].Reset();
}
MojoShader.MOJOSHADER_mtlEndFrame();
// We're done here.
frameInProgress = false;
}
private void BlitFramebuffer(
IntPtr srcTex,
Rectangle srcRect,
IntPtr dstTex,
Rectangle dstRect
) {
if ( srcRect.Width == 0 ||
srcRect.Height == 0 ||
dstRect.Width == 0 ||
dstRect.Height == 0 )
{
// Enjoy that bright red window!
return;
}
// Update cached vertex buffer if needed
if (fauxBackbufferDestBounds != dstRect || fauxBackbufferSizeChanged)
{
fauxBackbufferDestBounds = dstRect;
fauxBackbufferSizeChanged = false;
// Scale the coordinates to (-1, 1)
int dw, dh;
GetDrawableSize(layer, out dw, out dh);
float sx = -1 + (dstRect.X / (float) dw);
float sy = -1 + (dstRect.Y / (float) dh);
float sw = (dstRect.Width / (float) dw) * 2;
float sh = (dstRect.Height / (float) dh) * 2;
// Update the vertex buffer contents
float[] data = new float[]
{
sx, sy, 0, 0,
sx + sw, sy, 1, 0,
sx + sw, sy + sh, 1, 1,
sx, sy + sh, 0, 1
};
GCHandle handle = GCHandle.Alloc(data, GCHandleType.Pinned);
SDL.SDL_memcpy(
mtlGetBufferContentsPtr(fauxBackbufferDrawBuffer),
handle.AddrOfPinnedObject(),
(IntPtr) (16 * sizeof(float))
);
handle.Free();
}
// Render the source texture to the destination texture
IntPtr backbufferRenderPass = mtlMakeRenderPassDescriptor();
mtlSetAttachmentTexture(
mtlGetColorAttachment(backbufferRenderPass, 0),
dstTex
);
IntPtr rce = mtlMakeRenderCommandEncoder(
commandBuffer,
backbufferRenderPass
);
mtlSetRenderPipelineState(rce, fauxBackbufferRenderPipeline);
mtlSetVertexBuffer(rce, fauxBackbufferDrawBuffer, 0, 0);
mtlSetFragmentTexture(rce, srcTex, 0);
mtlSetFragmentSamplerState(rce, fauxBackbufferSamplerState, 0);
mtlDrawIndexedPrimitives(
rce,
MTLPrimitiveType.Triangle,
6,
MTLIndexType.UInt16,
fauxBackbufferDrawBuffer,
16 * sizeof(float),
1
);
mtlEndEncoding(rce);
}
#endregion
#region Render Command Encoder Methods
private void EndPass()
{
if (renderCommandEncoder != IntPtr.Zero)
{
mtlEndEncoding(renderCommandEncoder);
renderCommandEncoder = IntPtr.Zero;
}
}
private void UpdateRenderPass()
{
if (!needNewRenderPass) return;
/* Normally the frame begins in BeginDraw(),
* but some games perform drawing outside
* of the Draw method (e.g. initializing
* render targets in LoadContent). This call
* ensures that we catch any unexpected draws.
* -caleb
*/
BeginFrame();
// Wrap up rendering with the old encoder
EndPass();
// Generate the descriptor
IntPtr passDesc = mtlMakeRenderPassDescriptor();
// Bind color attachments
for (int i = 0; i < currentAttachments.Length; i += 1)
{
if (currentAttachments[i] == IntPtr.Zero)
{
continue;
}
IntPtr colorAttachment = mtlGetColorAttachment(passDesc, i);
mtlSetAttachmentTexture(
colorAttachment,
currentAttachments[i]
);
mtlSetAttachmentSlice(
colorAttachment,
(int) currentAttachmentSlices[i]
);
// Multisample?
if (currentSampleCount > 0)
{
mtlSetAttachmentTexture(
colorAttachment,
currentMSAttachments[i]
);
mtlSetAttachmentSlice(
colorAttachment,
0
);
mtlSetAttachmentResolveTexture(
colorAttachment,
currentAttachments[i]
);
mtlSetAttachmentStoreAction(
colorAttachment,
MTLStoreAction.MultisampleResolve
);
mtlSetAttachmentResolveSlice(
colorAttachment,
(int) currentAttachmentSlices[i]
);
}
// Clear color
if (shouldClearColor)
{
mtlSetAttachmentLoadAction(
colorAttachment,
MTLLoadAction.Clear
);
mtlSetColorAttachmentClearColor(
colorAttachment,
clearColor.X,
clearColor.Y,
clearColor.Z,
clearColor.W
);
}
else
{
mtlSetAttachmentLoadAction(
colorAttachment,
MTLLoadAction.Load
);
}
}
// Bind depth attachment
if (currentDepthFormat != DepthFormat.None)
{
IntPtr depthAttachment = mtlGetDepthAttachment(passDesc);
mtlSetAttachmentTexture(
depthAttachment,
currentDepthStencilBuffer
);
mtlSetAttachmentStoreAction(
depthAttachment,
MTLStoreAction.Store
);
// Clear?
if (shouldClearDepth)
{
mtlSetAttachmentLoadAction(
depthAttachment,
MTLLoadAction.Clear
);
mtlSetDepthAttachmentClearDepth(
depthAttachment,
clearDepth
);
}
else
{
mtlSetAttachmentLoadAction(
depthAttachment,
MTLLoadAction.Load
);
}
}
// Bind stencil buffer
if (currentDepthFormat == DepthFormat.Depth24Stencil8)
{
IntPtr stencilAttachment = mtlGetStencilAttachment(passDesc);
mtlSetAttachmentTexture(
stencilAttachment,
currentDepthStencilBuffer
);
mtlSetAttachmentStoreAction(
stencilAttachment,
MTLStoreAction.Store
);
// Clear?
if (shouldClearStencil)
{
mtlSetAttachmentLoadAction(
stencilAttachment,
MTLLoadAction.Clear
);
mtlSetStencilAttachmentClearStencil(
stencilAttachment,
clearStencil
);
}
else
{
mtlSetAttachmentLoadAction(
stencilAttachment,
MTLLoadAction.Load
);
}
}
// Get attachment size
currentAttachmentWidth = (int) mtlGetTextureWidth(
currentAttachments[0]
);
currentAttachmentHeight = (int) mtlGetTextureHeight(
currentAttachments[0]
);
// Attach the visibility buffer, if needed
if (currentVisibilityBuffer != IntPtr.Zero)
{
mtlSetVisibilityResultBuffer(
passDesc,
currentVisibilityBuffer
);
}
// Make a new encoder
renderCommandEncoder = mtlMakeRenderCommandEncoder(
commandBuffer,
passDesc
);
// Reset the flags
needNewRenderPass = false;
shouldClearColor = false;
shouldClearDepth = false;
shouldClearStencil = false;
// Apply the dynamic state
SetEncoderViewport();
SetEncoderScissorRect();
SetEncoderBlendColor();
SetEncoderStencilReferenceValue();
SetEncoderCullMode();
SetEncoderFillMode();
SetEncoderDepthBias();
// Start visibility buffer counting
if (currentVisibilityBuffer != IntPtr.Zero)
{
mtlSetVisibilityResultMode(
renderCommandEncoder,
MTLVisibilityResultMode.Counting,
0
);
}
// Reset the bindings
for (int i = 0; i < MaxTextureSlots; i += 1)
{
if (Textures[i] != MetalTexture.NullTexture)
{
textureNeedsUpdate[i] = true;
}
if (Samplers[i] != IntPtr.Zero)
{
samplerNeedsUpdate[i] = true;
}
}
ldDepthStencilState = IntPtr.Zero;
ldFragUniformBuffer = IntPtr.Zero;
ldFragUniformOffset = 0;
ldVertUniformBuffer = IntPtr.Zero;
ldVertUniformOffset = 0;
ldPipelineState = IntPtr.Zero;
for (int i = 0; i < MAX_BOUND_VERTEX_BUFFERS; i += 1)
{
ldVertexBuffers[i] = IntPtr.Zero;
ldVertexBufferOffsets[i] = 0;
}
}
private void SetEncoderStencilReferenceValue()
{
if (renderCommandEncoder != IntPtr.Zero && !needNewRenderPass)
{
mtlSetStencilReferenceValue(
renderCommandEncoder,
(uint) stencilRef
);
}
}
private void SetEncoderBlendColor()
{
if (renderCommandEncoder != IntPtr.Zero && !needNewRenderPass)
{
mtlSetBlendColor(
renderCommandEncoder,
blendColor.R / 255f,
blendColor.G / 255f,
blendColor.B / 255f,
blendColor.A / 255f
);
}
}
private void SetEncoderViewport()
{
if (renderCommandEncoder != IntPtr.Zero && !needNewRenderPass)
{
mtlSetViewport(
renderCommandEncoder,
viewport.X,
viewport.Y,
viewport.Width,
viewport.Height,
(double) depthRangeMin,
(double) depthRangeMax
);
}
}
private void SetEncoderCullMode()
{
if (renderCommandEncoder != IntPtr.Zero && !needNewRenderPass)
{
mtlSetCullMode(
renderCommandEncoder,
XNAToMTL.CullingEnabled[(int) cullFrontFace]
);
}
}
private void SetEncoderFillMode()
{
if (renderCommandEncoder != IntPtr.Zero && !needNewRenderPass)
{
mtlSetTriangleFillMode(
renderCommandEncoder,
XNAToMTL.FillMode[(int) fillMode]
);
}
}
private void SetEncoderDepthBias()
{
if (renderCommandEncoder != IntPtr.Zero && !needNewRenderPass)
{
mtlSetDepthBias(
renderCommandEncoder,
depthBias,
slopeScaleDepthBias,
0.0f // no clamp
);
}
}
private void SetEncoderScissorRect()
{
if (renderCommandEncoder != IntPtr.Zero && !needNewRenderPass)
{
if (!scissorTestEnable)
{
// Set to the default scissor rect
mtlSetScissorRect(
renderCommandEncoder,
0,
0,
currentAttachmentWidth,
currentAttachmentHeight
);
}
else
{
mtlSetScissorRect(
renderCommandEncoder,
scissorRectangle.X,
scissorRectangle.Y,
scissorRectangle.Width,
scissorRectangle.Height
);
}
}
}
#endregion
#region Metal Object Disposal Wrappers
public void AddDisposeEffect(IGLEffect effect)
{
DeleteEffect(effect);
}
public void AddDisposeIndexBuffer(IGLBuffer buffer)
{
DeleteBuffer(buffer);
}
public void AddDisposeQuery(IGLQuery query)
{
DeleteQuery(query);
}
public void AddDisposeRenderbuffer(IGLRenderbuffer renderbuffer)
{
DeleteRenderbuffer(renderbuffer);
}
public void AddDisposeTexture(IGLTexture texture)
{
DeleteTexture(texture);
}
public void AddDisposeVertexBuffer(IGLBuffer buffer)
{
DeleteBuffer(buffer);
}
#endregion
#region Pipeline Stall Method
private void Stall()
{
EndPass();
mtlCommitCommandBuffer(commandBuffer);
mtlCommandBufferWaitUntilCompleted(commandBuffer);
commandBuffer = mtlMakeCommandBuffer(queue);
needNewRenderPass = true;
committedCommandBuffers.Clear();
for (int i = 0; i < Buffers.Count; i += 1)
{
Buffers[i].Reset();
}
}
#endregion
#region String Marker Method
public void SetStringMarker(string text)
{
#if DEBUG
if (renderCommandEncoder != IntPtr.Zero)
{
mtlInsertDebugSignpost(renderCommandEncoder, text);
}
#endif
}
#endregion
#region Drawing Methods
public void DrawIndexedPrimitives(
PrimitiveType primitiveType,
int baseVertex,
int minVertexIndex,
int numVertices,
int startIndex,
int primitiveCount,
IGLBuffer indices,
IndexElementSize indexElementSize
) {
MetalBuffer indexBuffer = indices as MetalBuffer;
indexBuffer.Bound();
int totalIndexOffset = (
(startIndex * XNAToMTL.IndexSize[(int) indexElementSize]) +
indexBuffer.InternalOffset
);
mtlDrawIndexedPrimitives(
renderCommandEncoder,
XNAToMTL.Primitive[(int) primitiveType],
XNAToMTL.PrimitiveVerts(primitiveType, primitiveCount),
XNAToMTL.IndexType[(int) indexElementSize],
indexBuffer.Handle,
totalIndexOffset,
1
);
}
public void DrawInstancedPrimitives(
PrimitiveType primitiveType,
int baseVertex,
int minVertexIndex,
int numVertices,
int startIndex,
int primitiveCount,
int instanceCount,
IGLBuffer indices,
IndexElementSize indexElementSize
) {
MetalBuffer indexBuffer = indices as MetalBuffer;
indexBuffer.Bound();
int totalIndexOffset = (
(startIndex * XNAToMTL.IndexSize[(int) indexElementSize]) +
indexBuffer.InternalOffset
);
mtlDrawIndexedPrimitives(
renderCommandEncoder,
XNAToMTL.Primitive[(int) primitiveType],
XNAToMTL.PrimitiveVerts(primitiveType, primitiveCount),
XNAToMTL.IndexType[(int) indexElementSize],
indexBuffer.Handle,
totalIndexOffset,
instanceCount
);
}
public void DrawPrimitives(
PrimitiveType primitiveType,
int vertexStart,
int primitiveCount
) {
mtlDrawPrimitives(
renderCommandEncoder,
XNAToMTL.Primitive[(int) primitiveType],
vertexStart,
XNAToMTL.PrimitiveVerts(primitiveType, primitiveCount)
);
}
private void BindUserVertexBuffer(
IntPtr vertexData,
int vertexCount,
int vertexOffset
) {
// Update the buffer contents
int len = vertexCount * userVertexStride;
if (userVertexBuffer == null)
{
userVertexBuffer = new MetalBuffer(
this,
true,
BufferUsage.WriteOnly,
(IntPtr) len
);
Buffers.Add(userVertexBuffer);
}
userVertexBuffer.SetData(
vertexOffset * userVertexStride,
vertexData,
len
);
// Bind the buffer
int offset = userVertexBuffer.InternalOffset;
IntPtr handle = userVertexBuffer.Handle;
if (ldVertexBuffers[0] != handle)
{
mtlSetVertexBuffer(
renderCommandEncoder,
handle,
offset,
0
);
ldVertexBuffers[0] = handle;
ldVertexBufferOffsets[0] = offset;
}
else if (ldVertexBufferOffsets[0] != offset)
{
mtlSetVertexBufferOffset(
renderCommandEncoder,
offset,
0
);
ldVertexBufferOffsets[0] = offset;
}
}
public void DrawUserIndexedPrimitives(
PrimitiveType primitiveType,
IntPtr vertexData,
int vertexOffset,
int numVertices,
IntPtr indexData,
int indexOffset,
IndexElementSize indexElementSize,
int primitiveCount
) {
// Bind the vertex buffer
BindUserVertexBuffer(
vertexData,
numVertices,
vertexOffset
);
// Prepare the index buffer
int numIndices = XNAToMTL.PrimitiveVerts(
primitiveType,
primitiveCount
);
int indexSize = XNAToMTL.IndexSize[(int) indexElementSize];
int len = (int) numIndices * indexSize;
if (userIndexBuffer == null)
{
userIndexBuffer = new MetalBuffer(
this,
true,
BufferUsage.WriteOnly,
(IntPtr) len
);
Buffers.Add(userIndexBuffer);
}
userIndexBuffer.SetData(
indexOffset * indexSize,
indexData,
len
);
// Draw!
mtlDrawIndexedPrimitives(
renderCommandEncoder,
XNAToMTL.Primitive[(int) primitiveType],
numIndices,
XNAToMTL.IndexType[(int) indexElementSize],
userIndexBuffer.Handle,
userIndexBuffer.InternalOffset,
1
);
}
public void DrawUserPrimitives(
PrimitiveType primitiveType,
IntPtr vertexData,
int vertexOffset,
int primitiveCount
) {
// Bind the vertex buffer
int numVerts = XNAToMTL.PrimitiveVerts(
primitiveType,
primitiveCount
);
BindUserVertexBuffer(
vertexData,
numVerts,
vertexOffset
);
// Draw!
mtlDrawPrimitives(
renderCommandEncoder,
XNAToMTL.Primitive[(int) primitiveType],
0,
numVerts
);
}
#endregion
#region State Management Methods
public void SetPresentationInterval(PresentInterval interval)
{
// Toggling vsync is only supported on macOS 10.13+
if (!RespondsToSelector(layer, selDisplaySyncEnabled))
{
FNALoggerEXT.LogWarn(
"Cannot set presentation interval! " +
"Only vsync is supported."
);
return;
}
if (interval == PresentInterval.Default || interval == PresentInterval.One)
{
mtlSetDisplaySyncEnabled(layer, true);
}
else if (interval == PresentInterval.Immediate)
{
mtlSetDisplaySyncEnabled(layer, false);
}
else if (interval == PresentInterval.Two)
{
/* FIXME:
* There is no built-in support for
* present-every-other-frame in Metal.
* We could work around this, but do
* any games actually use this mode...?
* -caleb
*/
mtlSetDisplaySyncEnabled(layer, true);
}
else
{
throw new NotSupportedException("Unrecognized PresentInterval!");
}
}
public void SetViewport(Viewport vp)
{
if ( vp.Bounds != viewport ||
vp.MinDepth != depthRangeMin ||
vp.MaxDepth != depthRangeMax )
{
viewport = vp.Bounds;
depthRangeMin = vp.MinDepth;
depthRangeMax = vp.MaxDepth;
SetEncoderViewport(); // Dynamic state!
}
}
public void SetScissorRect(Rectangle scissorRect)
{
if (scissorRectangle != scissorRect)
{
scissorRectangle = scissorRect;
SetEncoderScissorRect(); // Dynamic state!
}
}
public void ApplyRasterizerState(RasterizerState rasterizerState)
{
if (rasterizerState.ScissorTestEnable != scissorTestEnable)
{
scissorTestEnable = rasterizerState.ScissorTestEnable;
SetEncoderScissorRect(); // Dynamic state!
}
if (rasterizerState.CullMode != cullFrontFace)
{
cullFrontFace = rasterizerState.CullMode;
SetEncoderCullMode(); // Dynamic state!
}
if (rasterizerState.FillMode != fillMode)
{
fillMode = rasterizerState.FillMode;
SetEncoderFillMode(); // Dynamic state!
}
float realDepthBias = rasterizerState.DepthBias;
realDepthBias *= XNAToMTL.DepthBiasScale(
GetDepthFormat(currentDepthFormat)
);
if ( realDepthBias != depthBias ||
rasterizerState.SlopeScaleDepthBias != slopeScaleDepthBias )
{
depthBias = realDepthBias;
slopeScaleDepthBias = rasterizerState.SlopeScaleDepthBias;
SetEncoderDepthBias(); // Dynamic state!
}
if (rasterizerState.MultiSampleAntiAlias != multiSampleEnable)
{
multiSampleEnable = rasterizerState.MultiSampleAntiAlias;
// FIXME: Metal does not support toggling MSAA. Workarounds...?
}
}
public void VerifySampler(int index, Texture texture, SamplerState sampler)
{
if (texture == null)
{
if (Textures[index] != MetalTexture.NullTexture)
{
Textures[index] = MetalTexture.NullTexture;
textureNeedsUpdate[index] = true;
}
if (Samplers[index] == IntPtr.Zero)
{
/* Some shaders require non-null samplers
* even if they aren't actually used.
* -caleb
*/
Samplers[index] = FetchSamplerState(sampler, false);
samplerNeedsUpdate[index] = true;
}
return;
}
MetalTexture tex = texture.texture as MetalTexture;
if ( tex == Textures[index] &&
sampler.AddressU == tex.WrapS &&
sampler.AddressV == tex.WrapT &&
sampler.AddressW == tex.WrapR &&
sampler.Filter == tex.Filter &&
sampler.MaxAnisotropy == tex.Anisotropy &&
sampler.MaxMipLevel == tex.MaxMipmapLevel &&
sampler.MipMapLevelOfDetailBias == tex.LODBias )
{
// Nothing's changing, forget it.
return;
}
// Bind the correct texture
if (tex != Textures[index])
{
Textures[index] = tex;
textureNeedsUpdate[index] = true;
}
// Update the texture sampler info
tex.WrapS = sampler.AddressU;
tex.WrapT = sampler.AddressV;
tex.WrapR = sampler.AddressW;
tex.Filter = sampler.Filter;
tex.Anisotropy = sampler.MaxAnisotropy;
tex.MaxMipmapLevel = sampler.MaxMipLevel;
tex.LODBias = sampler.MipMapLevelOfDetailBias;
// Update the sampler state, if needed
IntPtr ss = FetchSamplerState(sampler, tex.HasMipmaps);
if (ss != Samplers[index])
{
Samplers[index] = ss;
samplerNeedsUpdate[index] = true;
}
}
public void SetBlendState(BlendState blendState)
{
this.blendState = blendState;
BlendFactor = blendState.BlendFactor; // Dynamic state!
}
public void SetDepthStencilState(DepthStencilState depthStencilState)
{
this.depthStencilState = depthStencilState;
ReferenceStencil = depthStencilState.ReferenceStencil; // Dynamic state!
}
#endregion
#region State Creation/Retrieval Methods
private struct PipelineHash : IEquatable<PipelineHash>
{
readonly ulong a;
readonly ulong b;
readonly ulong c;
readonly ulong d;
public PipelineHash(
ulong vertexShader,
ulong fragmentShader,
ulong vertexDescriptor,
MTLPixelFormat[] formats,
DepthFormat depthFormat,
int sampleCount,
BlendState blendState
) {
this.a = vertexShader;
this.b = fragmentShader;
this.c = vertexDescriptor;
unchecked
{
this.d = (
((ulong) blendState.GetHashCode() << 32) |
((ulong) sampleCount << 22) |
((ulong) depthFormat << 20) |
((ulong) HashFormat(formats[3]) << 15) |
((ulong) HashFormat(formats[2]) << 10) |
((ulong) HashFormat(formats[1]) << 5) |
((ulong) HashFormat(formats[0]))
);
}
}
private static uint HashFormat(MTLPixelFormat format)
{
switch (format)
{
case MTLPixelFormat.Invalid:
return 0;
case MTLPixelFormat.R16Float:
return 1;
case MTLPixelFormat.R32Float:
return 2;
case MTLPixelFormat.RG16Float:
return 3;
case MTLPixelFormat.RG16Snorm:
return 4;
case MTLPixelFormat.RG16Unorm:
return 5;
case MTLPixelFormat.RG32Float:
return 6;
case MTLPixelFormat.RG8Snorm:
return 7;
case MTLPixelFormat.RGB10A2Unorm:
return 8;
case MTLPixelFormat.RGBA16Float:
return 9;
case MTLPixelFormat.RGBA16Unorm:
return 10;
case MTLPixelFormat.RGBA32Float:
return 11;
case MTLPixelFormat.RGBA8Unorm:
return 12;
case MTLPixelFormat.A8Unorm:
return 13;
case MTLPixelFormat.ABGR4Unorm:
return 14;
case MTLPixelFormat.B5G6R5Unorm:
return 15;
case MTLPixelFormat.BC1_RGBA:
return 16;
case MTLPixelFormat.BC2_RGBA:
return 17;
case MTLPixelFormat.BC3_RGBA:
return 18;
case MTLPixelFormat.BGR5A1Unorm:
return 19;
case MTLPixelFormat.BGRA8Unorm:
return 20;
}
throw new NotSupportedException();
}
public override int GetHashCode()
{
unchecked
{
int i1 = (int) (a ^ (a >> 32));
int i2 = (int) (b ^ (b >> 32));
int i3 = (int) (c ^ (c >> 32));
int i4 = (int) (d ^ (d >> 32));
return i1 + i2 + i3 + i4;
}
}
public bool Equals(PipelineHash other)
{
return (
a == other.a &&
b == other.b &&
c == other.c &&
d == other.d
);
}
public override bool Equals(object obj)
{
if (obj == null || obj.GetType() != GetType())
{
return false;
}
PipelineHash hash = (PipelineHash) obj;
return (
a == hash.a &&
b == hash.b &&
c == hash.c &&
d == hash.d
);
}
}
private IntPtr FetchRenderPipeline()
{
// Can we just reuse an existing pipeline?
PipelineHash hash = new PipelineHash(
(ulong) shaderState.vertexShader,
(ulong) shaderState.fragmentShader,
(ulong) currentVertexDescriptor,
currentColorFormats,
currentDepthFormat,
currentSampleCount,
blendState
);
IntPtr pipeline = IntPtr.Zero;
if (PipelineStateCache.TryGetValue(hash, out pipeline))
{
// We have this state already cached!
return pipeline;
}
// We have to make a new pipeline...
IntPtr pipelineDesc = mtlNewRenderPipelineDescriptor();
IntPtr vertHandle = MojoShader.MOJOSHADER_mtlGetFunctionHandle(
shaderState.vertexShader
);
IntPtr fragHandle = MojoShader.MOJOSHADER_mtlGetFunctionHandle(
shaderState.fragmentShader
);
mtlSetPipelineVertexFunction(
pipelineDesc,
vertHandle
);
mtlSetPipelineFragmentFunction(
pipelineDesc,
fragHandle
);
mtlSetPipelineVertexDescriptor(
pipelineDesc,
currentVertexDescriptor
);
mtlSetDepthAttachmentPixelFormat(
pipelineDesc,
GetDepthFormat(currentDepthFormat)
);
if (currentDepthFormat == DepthFormat.Depth24Stencil8)
{
mtlSetStencilAttachmentPixelFormat(
pipelineDesc,
GetDepthFormat(currentDepthFormat)
);
}
mtlSetPipelineSampleCount(
pipelineDesc,
Math.Max(1, currentSampleCount)
);
// Apply the blend state
bool alphaBlendEnable = !(
blendState.ColorSourceBlend == Blend.One &&
blendState.ColorDestinationBlend == Blend.Zero &&
blendState.AlphaSourceBlend == Blend.One &&
blendState.AlphaDestinationBlend == Blend.Zero
);
for (int i = 0; i < currentAttachments.Length; i += 1)
{
if (currentAttachments[i] == IntPtr.Zero)
{
// There's no attachment bound at this index.
continue;
}
IntPtr colorAttachment = mtlGetColorAttachment(
pipelineDesc,
i
);
mtlSetAttachmentPixelFormat(
colorAttachment,
currentColorFormats[i]
);
mtlSetAttachmentBlendingEnabled(
colorAttachment,
alphaBlendEnable
);
if (alphaBlendEnable)
{
mtlSetAttachmentSourceRGBBlendFactor(
colorAttachment,
XNAToMTL.BlendMode[
(int) blendState.ColorSourceBlend
]
);
mtlSetAttachmentDestinationRGBBlendFactor(
colorAttachment,
XNAToMTL.BlendMode[
(int) blendState.ColorDestinationBlend
]
);
mtlSetAttachmentSourceAlphaBlendFactor(
colorAttachment,
XNAToMTL.BlendMode[
(int) blendState.AlphaSourceBlend
]
);
mtlSetAttachmentDestinationAlphaBlendFactor(
colorAttachment,
XNAToMTL.BlendMode[
(int) blendState.AlphaDestinationBlend
]
);
mtlSetAttachmentRGBBlendOperation(
colorAttachment,
XNAToMTL.BlendOperation[
(int) blendState.ColorBlendFunction
]
);
mtlSetAttachmentAlphaBlendOperation(
colorAttachment,
XNAToMTL.BlendOperation[
(int) blendState.AlphaBlendFunction
]
);
}
/* FIXME: So how exactly do we factor in
* COLORWRITEENABLE for buffer 0? Do we just assume that
* the default is just buffer 0, and all other calls
* update the other write masks?
*/
if (i == 0)
{
mtlSetAttachmentWriteMask(
colorAttachment,
XNAToMTL.ColorWriteMask(blendState.ColorWriteChannels)
);
}
else if (i == 1)
{
mtlSetAttachmentWriteMask(
mtlGetColorAttachment(pipelineDesc, 1),
XNAToMTL.ColorWriteMask(blendState.ColorWriteChannels1)
);
}
else if (i == 2)
{
mtlSetAttachmentWriteMask(
mtlGetColorAttachment(pipelineDesc, 2),
XNAToMTL.ColorWriteMask(blendState.ColorWriteChannels2)
);
}
else if (i == 3)
{
mtlSetAttachmentWriteMask(
mtlGetColorAttachment(pipelineDesc, 3),
XNAToMTL.ColorWriteMask(blendState.ColorWriteChannels3)
);
}
}
// Bake the render pipeline!
IntPtr pipelineState = mtlNewRenderPipelineStateWithDescriptor(
device,
pipelineDesc
);
PipelineStateCache[hash] = pipelineState;
// Clean up
objc_release(pipelineDesc);
objc_release(vertHandle);
objc_release(fragHandle);
// Return the pipeline!
return pipelineState;
}
private IntPtr FetchDepthStencilState()
{
/* Just use the default depth-stencil state
* if depth and stencil testing are disabled,
* or if there is no bound depth attachment.
* This wards off Metal validation errors.
* -caleb
*/
bool zEnable = depthStencilState.DepthBufferEnable;
bool sEnable = depthStencilState.StencilEnable;
bool zFormat = (currentDepthFormat != DepthFormat.None);
if ((!zEnable && !sEnable) || (!zFormat))
{
return defaultDepthStencilState;
}
// Can we just reuse an existing state?
StateHash hash = PipelineCache.GetDepthStencilHash(depthStencilState);
IntPtr state = IntPtr.Zero;
if (DepthStencilStateCache.TryGetValue(hash, out state))
{
// This state has already been cached!
return state;
}
// We have to make a new DepthStencilState...
IntPtr dsDesc = mtlNewDepthStencilDescriptor();
if (zEnable)
{
mtlSetDepthCompareFunction(
dsDesc,
XNAToMTL.CompareFunc[(int) depthStencilState.DepthBufferFunction]
);
mtlSetDepthWriteEnabled(
dsDesc,
depthStencilState.DepthBufferWriteEnable
);
}
// Create stencil descriptors
IntPtr front = IntPtr.Zero;
IntPtr back = IntPtr.Zero;
if (sEnable)
{
front = mtlNewStencilDescriptor();
mtlSetStencilFailureOperation(
front,
XNAToMTL.StencilOp[(int) depthStencilState.StencilFail]
);
mtlSetDepthFailureOperation(
front,
XNAToMTL.StencilOp[(int) depthStencilState.StencilDepthBufferFail]
);
mtlSetDepthStencilPassOperation(
front,
XNAToMTL.StencilOp[(int) depthStencilState.StencilPass]
);
mtlSetStencilCompareFunction(
front,
XNAToMTL.CompareFunc[(int) depthStencilState.StencilFunction]
);
mtlSetStencilReadMask(
front,
(uint) depthStencilState.StencilMask
);
mtlSetStencilWriteMask(
front,
(uint) depthStencilState.StencilWriteMask
);
if (!depthStencilState.TwoSidedStencilMode)
{
back = front;
}
}
if (front != back)
{
back = mtlNewStencilDescriptor();
mtlSetStencilFailureOperation(
back,
XNAToMTL.StencilOp[(int) depthStencilState.CounterClockwiseStencilFail]
);
mtlSetDepthFailureOperation(
back,
XNAToMTL.StencilOp[(int) depthStencilState.CounterClockwiseStencilDepthBufferFail]
);
mtlSetDepthStencilPassOperation(
back,
XNAToMTL.StencilOp[(int) depthStencilState.CounterClockwiseStencilPass]
);
mtlSetStencilCompareFunction(
back,
XNAToMTL.CompareFunc[(int) depthStencilState.CounterClockwiseStencilFunction]
);
mtlSetStencilReadMask(
back,
(uint) depthStencilState.StencilMask
);
mtlSetStencilWriteMask(
back,
(uint) depthStencilState.StencilWriteMask
);
}
mtlSetFrontFaceStencil(
dsDesc,
front
);
mtlSetBackFaceStencil(
dsDesc,
back
);
// Bake the state!
state = mtlNewDepthStencilStateWithDescriptor(
device,
dsDesc
);
DepthStencilStateCache[hash] = state;
// Clean up
objc_release(dsDesc);
// Return the state!
return state;
}
private IntPtr FetchSamplerState(SamplerState samplerState, bool hasMipmaps)
{
// Can we just reuse an existing state?
StateHash hash = PipelineCache.GetSamplerHash(samplerState);
IntPtr state = IntPtr.Zero;
if (SamplerStateCache.TryGetValue(hash, out state))
{
// The value is already cached!
return state;
}
// We have to make a new sampler state...
IntPtr samplerDesc = mtlNewSamplerDescriptor();
mtlSetSampler_sAddressMode(
samplerDesc,
XNAToMTL.Wrap[(int) samplerState.AddressU]
);
mtlSetSampler_tAddressMode(
samplerDesc,
XNAToMTL.Wrap[(int) samplerState.AddressV]
);
mtlSetSampler_rAddressMode(
samplerDesc,
XNAToMTL.Wrap[(int) samplerState.AddressW]
);
mtlSetSamplerMagFilter(
samplerDesc,
XNAToMTL.MagFilter[(int) samplerState.Filter]
);
mtlSetSamplerMinFilter(
samplerDesc,
XNAToMTL.MinFilter[(int) samplerState.Filter]
);
if (hasMipmaps)
{
mtlSetSamplerMipFilter(
samplerDesc,
XNAToMTL.MipFilter[(int) samplerState.Filter]
);
}
mtlSetSamplerLodMinClamp(
samplerDesc,
samplerState.MaxMipLevel
);
mtlSetSamplerMaxAnisotropy(
samplerDesc,
(samplerState.Filter == TextureFilter.Anisotropic) ?
Math.Max(1, samplerState.MaxAnisotropy) :
1
);
/* FIXME:
* The only way to set lod bias in metal is via the MSL
* bias() function in a shader. So we can't do:
*
* mtlSetSamplerLodBias(
* samplerDesc,
* samplerState.MipMapLevelOfDetailBias
* );
*
* What should we do instead?
*
* -caleb
*/
// Bake the sampler state!
state = mtlNewSamplerStateWithDescriptor(
device,
samplerDesc
);
SamplerStateCache[hash] = state;
// Clean up
objc_release(samplerDesc);
// Return the sampler state!
return state;
}
private IntPtr FetchVertexDescriptor(
VertexBufferBinding[] bindings,
int numBindings
) {
// Can we just reuse an existing descriptor?
ulong hash = PipelineCache.GetVertexBindingHash(
bindings,
numBindings,
(ulong) shaderState.vertexShader
);
IntPtr descriptor;
if (VertexDescriptorCache.TryGetValue(hash, out descriptor))
{
// The value is already cached!
return descriptor;
}
// We have to make a new vertex descriptor...
descriptor = mtlMakeVertexDescriptor();
objc_retain(descriptor);
/* There's this weird case where you can have overlapping
* vertex usage/index combinations. It seems like the first
* attrib gets priority, so whenever a duplicate attribute
* exists, give it the next available index. If that fails, we
* have to crash :/
* -flibit
*/
Array.Clear(attrUse, 0, attrUse.Length);
for (int i = 0; i < numBindings; i += 1)
{
// Describe vertex attributes
VertexDeclaration vertexDeclaration = bindings[i].VertexBuffer.VertexDeclaration;
foreach (VertexElement element in vertexDeclaration.elements)
{
int usage = (int) element.VertexElementUsage;
int index = element.UsageIndex;
if (attrUse[usage, index])
{
index = -1;
for (int j = 0; j < 16; j += 1)
{
if (!attrUse[usage, j])
{
index = j;
break;
}
}
if (index < 0)
{
throw new InvalidOperationException("Vertex usage collision!");
}
}
attrUse[usage, index] = true;
int attribLoc = MojoShader.MOJOSHADER_mtlGetVertexAttribLocation(
shaderState.vertexShader,
XNAToMTL.VertexAttribUsage[usage],
index
);
if (attribLoc == -1)
{
// Stream not in use!
continue;
}
IntPtr attrib = mtlGetVertexAttributeDescriptor(
descriptor,
attribLoc
);
mtlSetVertexAttributeFormat(
attrib,
XNAToMTL.VertexAttribType[(int) element.VertexElementFormat]
);
mtlSetVertexAttributeOffset(
attrib,
element.Offset
);
mtlSetVertexAttributeBufferIndex(
attrib,
i
);
}
// Describe vertex buffer layout
IntPtr layout = mtlGetVertexBufferLayoutDescriptor(
descriptor,
i
);
mtlSetVertexBufferLayoutStride(
layout,
vertexDeclaration.VertexStride
);
if (bindings[i].InstanceFrequency > 0)
{
mtlSetVertexBufferLayoutStepFunction(
layout,
MTLVertexStepFunction.PerInstance
);
mtlSetVertexBufferLayoutStepRate(
layout,
bindings[i].InstanceFrequency
);
}
}
VertexDescriptorCache[hash] = descriptor;
return descriptor;
}
private IntPtr FetchVertexDescriptor(
VertexDeclaration vertexDeclaration,
int vertexOffset
) {
// Can we just reuse an existing descriptor?
ulong hash = PipelineCache.GetVertexDeclarationHash(
vertexDeclaration,
(ulong) shaderState.vertexShader
);
IntPtr descriptor;
if (VertexDescriptorCache.TryGetValue(hash, out descriptor))
{
// The value is already cached!
return descriptor;
}
// We have to make a new vertex descriptor...
descriptor = mtlMakeVertexDescriptor();
objc_retain(descriptor);
/* There's this weird case where you can have overlapping
* vertex usage/index combinations. It seems like the first
* attrib gets priority, so whenever a duplicate attribute
* exists, give it the next available index. If that fails, we
* have to crash :/
* -flibit
*/
Array.Clear(attrUse, 0, attrUse.Length);
foreach (VertexElement element in vertexDeclaration.elements)
{
int usage = (int) element.VertexElementUsage;
int index = element.UsageIndex;
if (attrUse[usage, index])
{
index = -1;
for (int j = 0; j < 16; j += 1)
{
if (!attrUse[usage, j])
{
index = j;
break;
}
}
if (index < 0)
{
throw new InvalidOperationException("Vertex usage collision!");
}
}
attrUse[usage, index] = true;
int attribLoc = MojoShader.MOJOSHADER_mtlGetVertexAttribLocation(
shaderState.vertexShader,
XNAToMTL.VertexAttribUsage[usage],
index
);
if (attribLoc == -1)
{
// Stream not in use!
continue;
}
IntPtr attrib = mtlGetVertexAttributeDescriptor(
descriptor,
attribLoc
);
mtlSetVertexAttributeFormat(
attrib,
XNAToMTL.VertexAttribType[(int) element.VertexElementFormat]
);
mtlSetVertexAttributeOffset(
attrib,
element.Offset
);
mtlSetVertexAttributeBufferIndex(
attrib,
0
);
}
// Describe vertex buffer layout
IntPtr layout = mtlGetVertexBufferLayoutDescriptor(
descriptor,
0
);
mtlSetVertexBufferLayoutStride(
layout,
vertexDeclaration.VertexStride
);
VertexDescriptorCache[hash] = descriptor;
return descriptor;
}
private IntPtr FetchTransientTexture(MetalTexture fromTexture)
{
// Can we just reuse an existing texture?
for (int i = 0; i < transientTextures.Count; i += 1)
{
MetalTexture tex = transientTextures[i];
if ( tex.Format == fromTexture.Format &&
tex.Width == fromTexture.Width &&
tex.Height == fromTexture.Height &&
tex.HasMipmaps == fromTexture.HasMipmaps )
{
mtlSetPurgeableState(
tex.Handle,
MTLPurgeableState.NonVolatile
);
return tex.Handle;
}
}
// We have to make a new texture...
IntPtr texDesc = mtlMakeTexture2DDescriptor(
XNAToMTL.TextureFormat[(int) fromTexture.Format],
fromTexture.Width,
fromTexture.Height,
fromTexture.HasMipmaps
);
MetalTexture ret = new MetalTexture(
mtlNewTextureWithDescriptor(device, texDesc),
fromTexture.Width,
fromTexture.Height,
fromTexture.Format,
fromTexture.HasMipmaps ? 2 : 0,
false
);
transientTextures.Add(ret);
return ret.Handle;
}
#endregion
#region DepthFormat Conversion Method
private MTLPixelFormat GetDepthFormat(DepthFormat format)
{
switch (format)
{
case DepthFormat.Depth16: return D16Format;
case DepthFormat.Depth24: return D24Format;
case DepthFormat.Depth24Stencil8: return D24S8Format;
default: return MTLPixelFormat.Invalid;
}
}
#endregion
#region Effect Methods
public IGLEffect CreateEffect(byte[] effectCode)
{
IntPtr effect = IntPtr.Zero;
IntPtr mtlEffect = IntPtr.Zero;
effect = MojoShader.MOJOSHADER_parseEffect(
"metal",
effectCode,
(uint) effectCode.Length,
null,
0,
null,
0,
null,
null,
IntPtr.Zero
);
#if DEBUG
unsafe
{
MojoShader.MOJOSHADER_effect *effectPtr = (MojoShader.MOJOSHADER_effect*) effect;
MojoShader.MOJOSHADER_error* err = (MojoShader.MOJOSHADER_error*) effectPtr->errors;
for (int i = 0; i < effectPtr->error_count; i += 1)
{
// From the SDL2# LPToUtf8StringMarshaler
byte* endPtr = (byte*) err[i].error;
while (*endPtr != 0)
{
endPtr++;
}
byte[] bytes = new byte[endPtr - (byte*) err[i].error];
Marshal.Copy(err[i].error, bytes, 0, bytes.Length);
FNALoggerEXT.LogError(
"MOJOSHADER_parseEffect Error: " +
System.Text.Encoding.UTF8.GetString(bytes)
);
}
}
#endif
mtlEffect = MojoShader.MOJOSHADER_mtlCompileEffect(
effect,
device,
MAX_FRAMES_IN_FLIGHT
);
if (mtlEffect == IntPtr.Zero)
{
throw new InvalidOperationException(
MojoShader.MOJOSHADER_mtlGetError()
);
}
return new MetalEffect(effect, mtlEffect);
}
private void DeleteEffect(IGLEffect effect)
{
IntPtr mtlEffectData = (effect as MetalEffect).MTLEffectData;
if (mtlEffectData == currentEffect)
{
MojoShader.MOJOSHADER_mtlEffectEndPass(currentEffect);
MojoShader.MOJOSHADER_mtlEffectEnd(
currentEffect,
ref shaderState
);
currentEffect = IntPtr.Zero;
currentTechnique = IntPtr.Zero;
currentPass = 0;
shaderState = new MojoShader.MOJOSHADER_mtlShaderState();
}
MojoShader.MOJOSHADER_mtlDeleteEffect(mtlEffectData);
MojoShader.MOJOSHADER_freeEffect(effect.EffectData);
}
public IGLEffect CloneEffect(IGLEffect cloneSource)
{
IntPtr effect = IntPtr.Zero;
IntPtr mtlEffect = IntPtr.Zero;
effect = MojoShader.MOJOSHADER_cloneEffect(cloneSource.EffectData);
mtlEffect = MojoShader.MOJOSHADER_mtlCompileEffect(
effect,
device,
1
);
if (mtlEffect == IntPtr.Zero)
{
throw new InvalidOperationException(
MojoShader.MOJOSHADER_mtlGetError()
);
}
return new MetalEffect(effect, mtlEffect);
}
public void ApplyEffect(
IGLEffect effect,
IntPtr technique,
uint pass,
IntPtr stateChanges
) {
/* If a frame isn't already in progress,
* wait until one begins to avoid overwriting
* the previous frame's uniform buffers.
*/
BeginFrame();
IntPtr mtlEffectData = (effect as MetalEffect).MTLEffectData;
if (mtlEffectData == currentEffect)
{
if (technique == currentTechnique && pass == currentPass)
{
MojoShader.MOJOSHADER_mtlEffectCommitChanges(
currentEffect,
ref shaderState
);
return;
}
MojoShader.MOJOSHADER_mtlEffectEndPass(currentEffect);
MojoShader.MOJOSHADER_mtlEffectBeginPass(
currentEffect,
pass,
ref shaderState
);
currentTechnique = technique;
currentPass = pass;
return;
}
else if (currentEffect != IntPtr.Zero)
{
MojoShader.MOJOSHADER_mtlEffectEndPass(currentEffect);
MojoShader.MOJOSHADER_mtlEffectEnd(
currentEffect,
ref shaderState
);
}
uint whatever;
MojoShader.MOJOSHADER_mtlEffectBegin(
mtlEffectData,
out whatever,
0,
stateChanges
);
MojoShader.MOJOSHADER_mtlEffectBeginPass(
mtlEffectData,
pass,
ref shaderState
);
currentEffect = mtlEffectData;
currentTechnique = technique;
currentPass = pass;
}
public void BeginPassRestore(IGLEffect effect, IntPtr stateChanges)
{
/* If a frame isn't already in progress,
* wait until one begins to avoid overwriting
* the previous frame's uniform buffers.
*/
BeginFrame();
// Store the current data
prevEffect = currentEffect;
prevShaderState = shaderState;
IntPtr mtlEffectData = (effect as MetalEffect).MTLEffectData;
uint whatever;
MojoShader.MOJOSHADER_mtlEffectBegin(
mtlEffectData,
out whatever,
1,
stateChanges
);
MojoShader.MOJOSHADER_mtlEffectBeginPass(
mtlEffectData,
0,
ref shaderState
);
currentEffect = mtlEffectData;
}
public void EndPassRestore(IGLEffect effect)
{
IntPtr mtlEffectData = (effect as MetalEffect).MTLEffectData;
MojoShader.MOJOSHADER_mtlEffectEndPass(mtlEffectData);
MojoShader.MOJOSHADER_mtlEffectEnd(
mtlEffectData,
ref shaderState
);
// Restore the old data
shaderState = prevShaderState;
currentEffect = prevEffect;
}
#endregion
#region Resource Binding Method
private void BindResources()
{
// Bind textures and their sampler states
for (int i = 0; i < Textures.Length; i += 1)
{
if (textureNeedsUpdate[i])
{
mtlSetFragmentTexture(
renderCommandEncoder,
Textures[i].Handle,
i
);
textureNeedsUpdate[i] = false;
}
if (samplerNeedsUpdate[i])
{
mtlSetFragmentSamplerState(
renderCommandEncoder,
Samplers[i],
i
);
samplerNeedsUpdate[i] = false;
}
}
// Bind the uniform buffers
const int UNIFORM_REG = 16; // In MojoShader output it's always 16
IntPtr vUniform = shaderState.vertexUniformBuffer;
int vOff = shaderState.vertexUniformOffset;
if (vUniform != ldVertUniformBuffer)
{
mtlSetVertexBuffer(
renderCommandEncoder,
vUniform,
vOff,
UNIFORM_REG
);
ldVertUniformBuffer = vUniform;
ldVertUniformOffset = vOff;
}
else if (vOff != ldVertUniformOffset)
{
mtlSetVertexBufferOffset(
renderCommandEncoder,
vOff,
UNIFORM_REG
);
ldVertUniformOffset = vOff;
}
IntPtr fUniform = shaderState.fragmentUniformBuffer;
int fOff = shaderState.fragmentUniformOffset;
if (fUniform != ldFragUniformBuffer)
{
mtlSetFragmentBuffer(
renderCommandEncoder,
fUniform,
fOff,
UNIFORM_REG
);
ldFragUniformBuffer = fUniform;
ldFragUniformOffset = fOff;
}
else if (fOff != ldFragUniformOffset)
{
mtlSetFragmentBufferOffset(
renderCommandEncoder,
fOff,
UNIFORM_REG
);
ldFragUniformOffset = fOff;
}
// Bind the depth-stencil state
IntPtr depthStencilState = FetchDepthStencilState();
if (depthStencilState != ldDepthStencilState)
{
mtlSetDepthStencilState(
renderCommandEncoder,
depthStencilState
);
ldDepthStencilState = depthStencilState;
}
// Finally, bind the pipeline state
IntPtr pipelineState = FetchRenderPipeline();
if (pipelineState != ldPipelineState)
{
mtlSetRenderPipelineState(
renderCommandEncoder,
pipelineState
);
ldPipelineState = pipelineState;
}
}
#endregion
#region ApplyVertexAttributes Methods
public void ApplyVertexAttributes(
VertexBufferBinding[] bindings,
int numBindings,
bool bindingsUpdated,
int baseVertex
) {
// Translate the bindings array into a descriptor
currentVertexDescriptor = FetchVertexDescriptor(
bindings,
numBindings
);
// Prepare for rendering
UpdateRenderPass();
BindResources();
// Bind the vertex buffers
for (int i = 0; i < bindings.Length; i += 1)
{
VertexBuffer vertexBuffer = bindings[i].VertexBuffer;
if (vertexBuffer != null)
{
int stride = bindings[i].VertexBuffer.VertexDeclaration.VertexStride;
int offset = (
((bindings[i].VertexOffset + baseVertex) * stride) +
(vertexBuffer.buffer as MetalBuffer).InternalOffset
);
IntPtr handle = (vertexBuffer.buffer as MetalBuffer).Handle;
(vertexBuffer.buffer as MetalBuffer).Bound();
if (ldVertexBuffers[i] != handle)
{
mtlSetVertexBuffer(
renderCommandEncoder,
handle,
offset,
i
);
ldVertexBuffers[i] = handle;
ldVertexBufferOffsets[i] = offset;
}
else if (ldVertexBufferOffsets[i] != offset)
{
mtlSetVertexBufferOffset(
renderCommandEncoder,
offset,
i
);
ldVertexBufferOffsets[i] = offset;
}
}
}
}
public void ApplyVertexAttributes(
VertexDeclaration vertexDeclaration,
IntPtr ptr,
int vertexOffset
) {
// Translate the declaration into a descriptor
currentVertexDescriptor = FetchVertexDescriptor(
vertexDeclaration,
vertexOffset
);
userVertexStride = vertexDeclaration.VertexStride;
// Prepare for rendering
UpdateRenderPass();
BindResources();
// The rest happens in DrawUser[Indexed]Primitives.
}
#endregion
#region GenBuffers Methods
public IGLBuffer GenIndexBuffer(
bool dynamic,
BufferUsage usage,
int indexCount,
IndexElementSize indexElementSize
) {
int elementSize = XNAToMTL.IndexSize[(int) indexElementSize];
MetalBuffer newbuf = new MetalBuffer(
this,
dynamic,
usage,
(IntPtr) (indexCount * elementSize)
);
Buffers.Add(newbuf);
return newbuf;
}
public IGLBuffer GenVertexBuffer(
bool dynamic,
BufferUsage usage,
int vertexCount,
int vertexStride
) {
MetalBuffer newbuf = new MetalBuffer(
this,
dynamic,
usage,
(IntPtr) (vertexCount * vertexStride)
);
Buffers.Add(newbuf);
return newbuf;
}
#endregion
#region Renderbuffer Methods
public IGLRenderbuffer GenRenderbuffer(
int width,
int height,
SurfaceFormat format,
int multiSampleCount,
IGLTexture texture
) {
MTLPixelFormat pixelFormat = XNAToMTL.TextureFormat[(int) format];
int sampleCount = GetCompatibleSampleCount(multiSampleCount);
// Generate a multisample texture
IntPtr desc = mtlMakeTexture2DDescriptor(
pixelFormat,
width,
height,
false
);
mtlSetStorageMode(
desc,
MTLStorageMode.Private
);
mtlSetTextureUsage(
desc,
MTLTextureUsage.RenderTarget
);
mtlSetTextureType(
desc,
MTLTextureType.Multisample2D
);
mtlSetTextureSampleCount(
desc,
sampleCount
);
IntPtr multisampleTexture = mtlNewTextureWithDescriptor(
device,
desc
);
// We're done!
return new MetalRenderbuffer(
(texture as MetalTexture).Handle,
pixelFormat,
sampleCount,
multisampleTexture
);
}
public IGLRenderbuffer GenRenderbuffer(
int width,
int height,
DepthFormat format,
int multiSampleCount
) {
MTLPixelFormat pixelFormat = GetDepthFormat(format);
int sampleCount = GetCompatibleSampleCount(multiSampleCount);
// Generate a depth texture
IntPtr desc = mtlMakeTexture2DDescriptor(
pixelFormat,
width,
height,
false
);
mtlSetStorageMode(
desc,
MTLStorageMode.Private
);
mtlSetTextureUsage(
desc,
MTLTextureUsage.RenderTarget
);
if (multiSampleCount > 0)
{
mtlSetTextureType(
desc,
MTLTextureType.Multisample2D
);
mtlSetTextureSampleCount(
desc,
sampleCount
);
}
IntPtr handle = mtlNewTextureWithDescriptor(
device,
desc
);
// We're done!
return new MetalRenderbuffer(
handle,
pixelFormat,
sampleCount,
IntPtr.Zero
);
}
private void DeleteRenderbuffer(IGLRenderbuffer renderbuffer)
{
MetalRenderbuffer rb = renderbuffer as MetalRenderbuffer;
bool isDepthStencil = rb.MultiSampleHandle == IntPtr.Zero;
if (isDepthStencil)
{
if (rb.Handle == currentDepthStencilBuffer)
{
currentDepthStencilBuffer = IntPtr.Zero;
}
}
else
{
for (int i = 0; i < currentAttachments.Length; i += 1)
{
if (rb.MultiSampleHandle == currentMSAttachments[i])
{
currentMSAttachments[i] = IntPtr.Zero;
}
}
}
rb.Dispose();
}
#endregion
#region SetBufferData Methods
public void SetIndexBufferData(
IGLBuffer buffer,
int offsetInBytes,
IntPtr data,
int dataLength,
SetDataOptions options
) {
(buffer as MetalBuffer).SetData(
offsetInBytes,
data,
dataLength,
options
);
}
public void SetVertexBufferData(
IGLBuffer buffer,
int offsetInBytes,
IntPtr data,
int dataLength,
SetDataOptions options
) {
(buffer as MetalBuffer).SetData(
offsetInBytes,
data,
dataLength,
options
);
}
#endregion
#region GetBufferData Methods
public void GetIndexBufferData(
IGLBuffer buffer,
int offsetInBytes,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes
) {
SDL.SDL_memcpy(
data + (startIndex * elementSizeInBytes),
(buffer as MetalBuffer).Contents + offsetInBytes,
(IntPtr) (elementCount * elementSizeInBytes)
);
}
public void GetVertexBufferData(
IGLBuffer buffer,
int offsetInBytes,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes,
int vertexStride
) {
IntPtr cpy;
bool useStagingBuffer = elementSizeInBytes < vertexStride;
if (useStagingBuffer)
{
cpy = Marshal.AllocHGlobal(elementCount * vertexStride);
}
else
{
cpy = data + (startIndex * elementSizeInBytes);
}
SDL.SDL_memcpy(
cpy,
(buffer as MetalBuffer).Contents + offsetInBytes,
(IntPtr) (elementCount * vertexStride)
);
if (useStagingBuffer)
{
IntPtr src = cpy;
IntPtr dst = data + (startIndex * elementSizeInBytes);
for (int i = 0; i < elementCount; i += 1)
{
SDL.SDL_memcpy(dst, src, (IntPtr) elementSizeInBytes);
dst += elementSizeInBytes;
src += vertexStride;
}
Marshal.FreeHGlobal(cpy);
}
}
#endregion
#region DeleteBuffer Methods
private void DeleteBuffer(IGLBuffer buffer)
{
Buffers.Remove(buffer as MetalBuffer);
(buffer as MetalBuffer).Dispose();
}
#endregion
#region CreateTexture Methods
public IGLTexture CreateTexture2D(
SurfaceFormat format,
int width,
int height,
int levelCount,
bool isRenderTarget
) {
IntPtr texDesc = mtlMakeTexture2DDescriptor(
XNAToMTL.TextureFormat[(int) format],
width,
height,
levelCount > 1
);
if (isRenderTarget)
{
mtlSetStorageMode(
texDesc,
MTLStorageMode.Private
);
mtlSetTextureUsage(
texDesc,
MTLTextureUsage.RenderTarget | MTLTextureUsage.ShaderRead
);
}
return new MetalTexture(
mtlNewTextureWithDescriptor(device, texDesc),
width,
height,
format,
levelCount,
isRenderTarget
);
}
public IGLTexture CreateTexture3D(
SurfaceFormat format,
int width,
int height,
int depth,
int levelCount
) {
IntPtr texDesc = mtlMakeTexture2DDescriptor(
XNAToMTL.TextureFormat[(int) format],
width,
height,
levelCount > 1
);
// Make it 3D!
mtlSetTextureDepth(texDesc, depth);
mtlSetTextureType(texDesc, MTLTextureType.Texture3D);
return new MetalTexture(
mtlNewTextureWithDescriptor(device, texDesc),
width,
height,
format,
levelCount,
false
);
}
public IGLTexture CreateTextureCube(
SurfaceFormat format,
int size,
int levelCount,
bool isRenderTarget
) {
IntPtr texDesc = mtlMakeTextureCubeDescriptor(
XNAToMTL.TextureFormat[(int) format],
size,
levelCount > 1
);
if (isRenderTarget)
{
mtlSetStorageMode(
texDesc,
MTLStorageMode.Private
);
mtlSetTextureUsage(
texDesc,
MTLTextureUsage.RenderTarget | MTLTextureUsage.ShaderRead
);
}
return new MetalTexture(
mtlNewTextureWithDescriptor(device, texDesc),
size,
size,
format,
levelCount,
isRenderTarget
);
}
#endregion
#region DeleteTexture Method
private void DeleteTexture(IGLTexture texture)
{
MetalTexture tex = texture as MetalTexture;
for (int i = 0; i < currentAttachments.Length; i += 1)
{
if (tex.Handle == currentAttachments[i])
{
currentAttachments[i] = IntPtr.Zero;
}
}
for (int i = 0; i < Textures.Length; i += 1)
{
if (tex.Handle == Textures[i].Handle)
{
Textures[i] = MetalTexture.NullTexture;
textureNeedsUpdate[i] = true;
}
}
tex.Dispose();
}
#endregion
#region Texture Data Helper Methods
private int BytesPerRow(int width, SurfaceFormat format)
{
int blocksPerRow = width;
if ( format == SurfaceFormat.Dxt1 ||
format == SurfaceFormat.Dxt3 ||
format == SurfaceFormat.Dxt5 )
{
blocksPerRow = (width + 3) / 4;
}
return blocksPerRow * Texture.GetFormatSize(format);
}
private int BytesPerImage(int width, int height, SurfaceFormat format)
{
int blocksPerRow = width;
int blocksPerColumn = height;
int formatSize = Texture.GetFormatSize(format);
if ( format == SurfaceFormat.Dxt1 ||
format == SurfaceFormat.Dxt3 ||
format == SurfaceFormat.Dxt5 )
{
blocksPerRow = (width + 3) / 4;
blocksPerColumn = (height + 3) / 4;
}
return blocksPerRow * blocksPerColumn * formatSize;
}
private int GetCompatibleSampleCount(int sampleCount)
{
/* If the device does not support the requested
* multisample count, halve it until we find a
* value that is supported.
*/
while (sampleCount > 0 && !mtlSupportsSampleCount(device, sampleCount))
{
sampleCount = MathHelper.ClosestMSAAPower(
sampleCount / 2
);
}
return sampleCount;
}
#endregion
#region SetTextureData Methods
public void SetTextureData2D(
IGLTexture texture,
SurfaceFormat format,
int x,
int y,
int w,
int h,
int level,
IntPtr data,
int dataLength
) {
MetalTexture tex = texture as MetalTexture;
IntPtr handle = tex.Handle;
MTLOrigin origin = new MTLOrigin(x, y, 0);
MTLSize size = new MTLSize(w, h, 1);
if (tex.IsPrivate)
{
// We need an active command buffer
BeginFrame();
// Fetch a CPU-accessible texture
handle = FetchTransientTexture(tex);
}
// Write the data
mtlReplaceRegion(
handle,
new MTLRegion(origin, size),
level,
0,
data,
BytesPerRow(w, format),
0
);
// Blit the temp texture to the actual texture
if (tex.IsPrivate)
{
// End the render pass
EndPass();
// Blit!
IntPtr blit = mtlMakeBlitCommandEncoder(commandBuffer);
mtlBlitTextureToTexture(
blit,
handle,
0,
level,
origin,
size,
tex.Handle,
0,
level,
origin
);
// Submit the blit command to the GPU and wait...
mtlEndEncoding(blit);
Stall();
// We're done with the temp texture
mtlSetPurgeableState(
handle,
MTLPurgeableState.Empty
);
}
}
public void SetTextureDataYUV(Texture2D[] textures, IntPtr ptr)
{
for (int i = 0; i < 3; i += 1)
{
Texture2D tex = textures[i];
MTLRegion region = new MTLRegion(
MTLOrigin.Zero,
new MTLSize(tex.Width, tex.Height, 1)
);
mtlReplaceRegion(
(tex.texture as MetalTexture).Handle,
region,
0,
0,
ptr,
tex.Width,
0
);
ptr += tex.Width * tex.Height;
}
}
public void SetTextureData3D(
IGLTexture texture,
SurfaceFormat format,
int level,
int left,
int top,
int right,
int bottom,
int front,
int back,
IntPtr data,
int dataLength
) {
int w = right - left;
int h = bottom - top;
int d = back - front;
MTLRegion region = new MTLRegion(
new MTLOrigin(left, top, front),
new MTLSize(w, h, d)
);
mtlReplaceRegion(
(texture as MetalTexture).Handle,
region,
level,
0,
data,
BytesPerRow(w, format),
BytesPerImage(w, h, format)
);
}
public void SetTextureDataCube(
IGLTexture texture,
SurfaceFormat format,
int xOffset,
int yOffset,
int width,
int height,
CubeMapFace cubeMapFace,
int level,
IntPtr data,
int dataLength
) {
MetalTexture tex = texture as MetalTexture;
IntPtr handle = tex.Handle;
MTLOrigin origin = new MTLOrigin(xOffset, yOffset, 0);
MTLSize size = new MTLSize(width, height, 1);
int slice = (int) cubeMapFace;
if (tex.IsPrivate)
{
// We need an active command buffer
BeginFrame();
// Fetch a CPU-accessible texture
handle = FetchTransientTexture(tex);
// Transient textures have no slices
slice = 0;
}
// Write the data
mtlReplaceRegion(
handle,
new MTLRegion(origin, size),
level,
slice,
data,
BytesPerRow(width, format),
0
);
// Blit the temp texture to the actual texture
if (tex.IsPrivate)
{
// End the render pass
EndPass();
// Blit!
IntPtr blit = mtlMakeBlitCommandEncoder(commandBuffer);
mtlBlitTextureToTexture(
blit,
handle,
slice,
level,
origin,
size,
tex.Handle,
slice,
level,
origin
);
// Submit the blit command to the GPU and wait...
mtlEndEncoding(blit);
Stall();
// We're done with the temp texture
mtlSetPurgeableState(
handle,
MTLPurgeableState.Empty
);
}
}
#endregion
#region GetTextureData Methods
public void GetTextureData2D(
IGLTexture texture,
SurfaceFormat format,
int width,
int height,
int level,
int subX,
int subY,
int subW,
int subH,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes
) {
MetalTexture tex = texture as MetalTexture;
IntPtr handle = tex.Handle;
MTLSize size = new MTLSize(subW, subH, 1);
MTLOrigin origin = new MTLOrigin(subX, subY, 0);
if (tex.IsPrivate)
{
// We need an active command buffer
BeginFrame();
// Fetch a CPU-accessible texture
handle = FetchTransientTexture(tex);
// End the render pass
EndPass();
// Blit the actual texture to a CPU-accessible texture
IntPtr blit = mtlMakeBlitCommandEncoder(commandBuffer);
mtlBlitTextureToTexture(
blit,
tex.Handle,
0,
level,
origin,
size,
handle,
0,
level,
origin
);
// Managed resources require explicit synchronization
if (isMac)
{
mtlSynchronizeResource(blit, handle);
}
// Submit the blit command to the GPU and wait...
mtlEndEncoding(blit);
Stall();
}
mtlGetTextureBytes(
handle,
data,
BytesPerRow(subW, format),
0,
new MTLRegion(origin, size),
level,
0
);
if (tex.IsPrivate)
{
// We're done with the temp texture
mtlSetPurgeableState(
handle,
MTLPurgeableState.Empty
);
}
}
public void GetTextureData3D(
IGLTexture texture,
SurfaceFormat format,
int left,
int top,
int front,
int right,
int bottom,
int back,
int level,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes
) {
int w = right - left;
int h = bottom - top;
int d = back - front;
MTLRegion region = new MTLRegion(
new MTLOrigin(left, top, front),
new MTLSize(w, h, d)
);
mtlGetTextureBytes(
(texture as MetalTexture).Handle,
data,
BytesPerRow(w, format),
BytesPerImage(w, h, format),
region,
level,
0
);
}
public void GetTextureDataCube(
IGLTexture texture,
SurfaceFormat format,
int size,
CubeMapFace cubeMapFace,
int level,
int subX,
int subY,
int subW,
int subH,
IntPtr data,
int startIndex,
int elementCount,
int elementSizeInBytes
) {
MetalTexture tex = texture as MetalTexture;
IntPtr handle = tex.Handle;
MTLSize regionSize = new MTLSize(subW, subH, 1);
MTLOrigin origin = new MTLOrigin(subX, subY, 0);
int slice = (int) cubeMapFace;
if (tex.IsPrivate)
{
// We need an active command buffer
BeginFrame();
// Fetch a CPU-accessible texture
handle = FetchTransientTexture(tex);
// Transient textures have no slices
slice = 0;
// End the render pass
EndPass();
// Blit the actual texture to a CPU-accessible texture
IntPtr blit = mtlMakeBlitCommandEncoder(commandBuffer);
mtlBlitTextureToTexture(
blit,
tex.Handle,
(int) cubeMapFace,
level,
origin,
regionSize,
handle,
slice,
level,
origin
);
// Managed resources require explicit synchronization
if (isMac)
{
mtlSynchronizeResource(blit, handle);
}
// Submit the blit command to the GPU and wait...
mtlEndEncoding(blit);
Stall();
}
mtlGetTextureBytes(
handle,
data,
BytesPerRow(subW, format),
0,
new MTLRegion(origin, regionSize),
level,
slice
);
if (tex.IsPrivate)
{
// We're done with the temp texture
mtlSetPurgeableState(
handle,
MTLPurgeableState.Empty
);
}
}
#endregion
#region ReadBackbuffer Method
public void ReadBackbuffer(
IntPtr data,
int dataLen,
int startIndex,
int elementCount,
int elementSizeInBytes,
int subX,
int subY,
int subW,
int subH
) {
/* FIXME: Right now we're expecting one of the following:
* - byte[]
* - int[]
* - uint[]
* - Color[]
* Anything else will freak out because we're using
* color backbuffers. Maybe check this out when adding
* support for more backbuffer types!
* -flibit
*/
if (startIndex > 0 || elementCount != (dataLen / elementSizeInBytes))
{
throw new NotImplementedException(
"ReadBackbuffer startIndex/elementCount"
);
}
GetTextureData2D(
(Backbuffer as MetalBackbuffer).Texture,
SurfaceFormat.Color,
Backbuffer.Width,
Backbuffer.Height,
0,
subX,
subY,
subW,
subH,
data,
0,
dataLen,
1
);
}
#endregion
#region RenderTarget->Texture Method
public void ResolveTarget(RenderTargetBinding target)
{
// The target is resolved at the end of each render pass.
// If the target has mipmaps, regenerate them now
if (target.RenderTarget.LevelCount > 1)
{
EndPass();
IntPtr blit = mtlMakeBlitCommandEncoder(commandBuffer);
mtlGenerateMipmapsForTexture(
blit,
(target.RenderTarget.texture as MetalTexture).Handle
);
mtlEndEncoding(blit);
needNewRenderPass = true;
}
}
#endregion
#region Clear Method
public void Clear(
ClearOptions options,
Vector4 color,
float depth,
int stencil
) {
bool clearTarget = (options & ClearOptions.Target) == ClearOptions.Target;
bool clearDepth = (options & ClearOptions.DepthBuffer) == ClearOptions.DepthBuffer;
bool clearStencil = (options & ClearOptions.Stencil) == ClearOptions.Stencil;
if (clearTarget)
{
clearColor = color;
shouldClearColor = true;
}
if (clearDepth)
{
this.clearDepth = depth;
shouldClearDepth = true;
}
if (clearStencil)
{
this.clearStencil = stencil;
shouldClearStencil = true;
}
needNewRenderPass |= clearTarget | clearDepth | clearStencil;
}
#endregion
#region SetRenderTargets Methods
public void SetRenderTargets(
RenderTargetBinding[] renderTargets,
IGLRenderbuffer renderbuffer,
DepthFormat depthFormat
) {
// Perform any pending clears before switching render targets
if (shouldClearColor || shouldClearDepth || shouldClearStencil)
{
UpdateRenderPass();
}
// Force an update to the render pass
needNewRenderPass = true;
// Bind the correct framebuffer
ResetAttachments();
if (renderTargets == null)
{
BindBackbuffer();
return;
}
// Update color buffers
int i;
for (i = 0; i < renderTargets.Length; i += 1)
{
IRenderTarget rt = renderTargets[i].RenderTarget as IRenderTarget;
currentAttachmentSlices[i] = renderTargets[i].CubeMapFace;
if (rt.ColorBuffer != null)
{
MetalRenderbuffer rb = rt.ColorBuffer as MetalRenderbuffer;
currentAttachments[i] = rb.Handle;
currentColorFormats[i] = rb.PixelFormat;
currentSampleCount = rb.MultiSampleCount;
currentMSAttachments[i] = rb.MultiSampleHandle;
}
else
{
MetalTexture tex = renderTargets[i].RenderTarget.texture as MetalTexture;
currentAttachments[i] = tex.Handle;
currentColorFormats[i] = XNAToMTL.TextureFormat[(int) tex.Format];
currentSampleCount = 0;
}
}
// Update depth stencil buffer
IntPtr handle = IntPtr.Zero;
if (renderbuffer != null)
{
handle = (renderbuffer as MetalRenderbuffer).Handle;
}
currentDepthStencilBuffer = handle;
currentDepthFormat = (
(currentDepthStencilBuffer == IntPtr.Zero) ?
DepthFormat.None :
depthFormat
);
}
private void ResetAttachments()
{
for (int i = 0; i < currentAttachments.Length; i += 1)
{
currentAttachments[i] = IntPtr.Zero;
currentColorFormats[i] = MTLPixelFormat.Invalid;
currentMSAttachments[i] = IntPtr.Zero;
currentAttachmentSlices[i] = (CubeMapFace) 0;
}
currentDepthStencilBuffer = IntPtr.Zero;
currentDepthFormat = DepthFormat.None;
currentSampleCount = 0;
}
private void BindBackbuffer()
{
MetalBackbuffer bb = Backbuffer as MetalBackbuffer;
currentAttachments[0] = bb.ColorBuffer;
currentColorFormats[0] = bb.PixelFormat;
currentDepthStencilBuffer = bb.DepthStencilBuffer;
currentDepthFormat = bb.DepthFormat;
currentSampleCount = bb.MultiSampleCount;
currentMSAttachments[0] = bb.MultiSampleColorBuffer;
currentAttachmentSlices[0] = (CubeMapFace) 0;
}
#endregion
#region Query Object Methods
public IGLQuery CreateQuery()
{
if (!supportsOcclusionQueries)
{
throw new NotSupportedException(
"Occlusion queries are not supported on this device!"
);
}
IntPtr buf = mtlNewBufferWithLength(device, sizeof(ulong), 0);
return new MetalQuery(buf);
}
private void DeleteQuery(IGLQuery query)
{
(query as MetalQuery).Dispose();
}
public void QueryBegin(IGLQuery query)
{
// Stop the current pass
EndPass();
// Attach the visibility buffer to a new render pass
currentVisibilityBuffer = (query as MetalQuery).Handle;
needNewRenderPass = true;
}
public bool QueryComplete(IGLQuery query)
{
/* FIXME:
* There's no easy way to check for completion
* of the query. The only accurate way would be
* to monitor the completion of the command buffer
* associated with each query, but that gets tricky
* since we can't use completion callbacks.
* (Thank Objective-C and its stupid "block" lambdas.)
*
* Futhermore, I don't know how visibility queries
* work across command buffers, in the event of a
* stalled buffer overwrite or something similar.
*
* The below code is obviously wrong, but it happens
* to work for the Lens Flare XNA sample. Maybe it'll
* work for your game too?
*
* (Although if you're making a new game with FNA,
* you really shouldn't be using queries anyway...)
*
* -caleb
*/
return true;
}
public void QueryEnd(IGLQuery query)
{
if (renderCommandEncoder != IntPtr.Zero)
{
// Stop counting.
mtlSetVisibilityResultMode(
renderCommandEncoder,
MTLVisibilityResultMode.Disabled,
0
);
}
currentVisibilityBuffer = IntPtr.Zero;
}
public int QueryPixelCount(IGLQuery query)
{
IntPtr contents = mtlGetBufferContentsPtr(
(query as MetalQuery).Handle
);
ulong result;
unsafe
{
result = *((ulong *) contents);
}
return (int) result;
}
#endregion
#region XNA->GL Enum Conversion Class
private static class XNAToMTL
{
public static readonly MTLPixelFormat[] TextureFormat = new MTLPixelFormat[]
{
MTLPixelFormat.RGBA8Unorm, // SurfaceFormat.Color
MTLPixelFormat.B5G6R5Unorm, // SurfaceFormat.Bgr565
MTLPixelFormat.BGR5A1Unorm, // SurfaceFormat.Bgra5551
MTLPixelFormat.ABGR4Unorm, // SurfaceFormat.Bgra4444
MTLPixelFormat.BC1_RGBA, // SurfaceFormat.Dxt1
MTLPixelFormat.BC2_RGBA, // SurfaceFormat.Dxt3
MTLPixelFormat.BC3_RGBA, // SurfaceFormat.Dxt5
MTLPixelFormat.RG8Snorm, // SurfaceFormat.NormalizedByte2
MTLPixelFormat.RG16Snorm, // SurfaceFormat.NormalizedByte4
MTLPixelFormat.RGB10A2Unorm, // SurfaceFormat.Rgba1010102
MTLPixelFormat.RG16Unorm, // SurfaceFormat.Rg32
MTLPixelFormat.RGBA16Unorm, // SurfaceFormat.Rgba64
MTLPixelFormat.A8Unorm, // SurfaceFormat.Alpha8
MTLPixelFormat.R32Float, // SurfaceFormat.Single
MTLPixelFormat.RG32Float, // SurfaceFormat.Vector2
MTLPixelFormat.RGBA32Float, // SurfaceFormat.Vector4
MTLPixelFormat.R16Float, // SurfaceFormat.HalfSingle
MTLPixelFormat.RG16Float, // SurfaceFormat.HalfVector2
MTLPixelFormat.RGBA16Float, // SurfaceFormat.HalfVector4
MTLPixelFormat.RGBA16Float, // SurfaceFormat.HdrBlendable
MTLPixelFormat.BGRA8Unorm // SurfaceFormat.ColorBgraEXT
};
public static readonly MojoShader.MOJOSHADER_usage[] VertexAttribUsage = new MojoShader.MOJOSHADER_usage[]
{
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_POSITION, // VertexElementUsage.Position
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_COLOR, // VertexElementUsage.Color
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_TEXCOORD, // VertexElementUsage.TextureCoordinate
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_NORMAL, // VertexElementUsage.Normal
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_BINORMAL, // VertexElementUsage.Binormal
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_TANGENT, // VertexElementUsage.Tangent
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_BLENDINDICES, // VertexElementUsage.BlendIndices
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_BLENDWEIGHT, // VertexElementUsage.BlendWeight
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_DEPTH, // VertexElementUsage.Depth
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_FOG, // VertexElementUsage.Fog
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_POINTSIZE, // VertexElementUsage.PointSize
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_SAMPLE, // VertexElementUsage.Sample
MojoShader.MOJOSHADER_usage.MOJOSHADER_USAGE_TESSFACTOR // VertexElementUsage.TessellateFactor
};
public static readonly MTLVertexFormat[] VertexAttribType = new MTLVertexFormat[]
{
MTLVertexFormat.Float, // VertexElementFormat.Single
MTLVertexFormat.Float2, // VertexElementFormat.Vector2
MTLVertexFormat.Float3, // VertexElementFormat.Vector3
MTLVertexFormat.Float4, // VertexElementFormat.Vector4
MTLVertexFormat.UChar4Normalized, // VertexElementFormat.Color
MTLVertexFormat.UChar4, // VertexElementFormat.Byte4
MTLVertexFormat.Short2, // VertexElementFormat.Short2
MTLVertexFormat.Short4, // VertexElementFormat.Short4
MTLVertexFormat.Short2Normalized, // VertexElementFormat.NormalizedShort2
MTLVertexFormat.Short4Normalized, // VertexElementFormat.NormalizedShort4
MTLVertexFormat.Half2, // VertexElementFormat.HalfVector2
MTLVertexFormat.Half4 // VertexElementFormat.HalfVector4
};
public static readonly MTLIndexType[] IndexType = new MTLIndexType[]
{
MTLIndexType.UInt16, // IndexElementSize.SixteenBits
MTLIndexType.UInt32 // IndexElementSize.ThirtyTwoBits
};
public static readonly int[] IndexSize = new int[]
{
2, // IndexElementSize.SixteenBits
4 // IndexElementSize.ThirtyTwoBits
};
public static readonly MTLBlendFactor[] BlendMode = new MTLBlendFactor[]
{
MTLBlendFactor.One, // Blend.One
MTLBlendFactor.Zero, // Blend.Zero
MTLBlendFactor.SourceColor, // Blend.SourceColor
MTLBlendFactor.OneMinusSourceColor, // Blend.InverseSourceColor
MTLBlendFactor.SourceAlpha, // Blend.SourceAlpha
MTLBlendFactor.OneMinusSourceAlpha, // Blend.InverseSourceAlpha
MTLBlendFactor.DestinationColor, // Blend.DestinationColor
MTLBlendFactor.OneMinusDestinationColor,// Blend.InverseDestinationColor
MTLBlendFactor.DestinationAlpha, // Blend.DestinationAlpha
MTLBlendFactor.OneMinusDestinationAlpha,// Blend.InverseDestinationAlpha
MTLBlendFactor.BlendColor, // Blend.BlendFactor
MTLBlendFactor.OneMinusBlendColor, // Blend.InverseBlendFactor
MTLBlendFactor.SourceAlphaSaturated // Blend.SourceAlphaSaturation
};
public static readonly MTLBlendOperation[] BlendOperation = new MTLBlendOperation[]
{
MTLBlendOperation.Add, // BlendFunction.Add
MTLBlendOperation.Subtract, // BlendFunction.Subtract
MTLBlendOperation.ReverseSubtract, // BlendFunction.ReverseSubtract
MTLBlendOperation.Max, // BlendFunction.Max
MTLBlendOperation.Min // BlendFunction.Min
};
public static int ColorWriteMask(ColorWriteChannels channels)
{
if (channels == ColorWriteChannels.None)
{
return 0x0;
}
if (channels == ColorWriteChannels.All)
{
return 0xf;
}
int ret = 0;
if ((channels & ColorWriteChannels.Red) != 0)
{
ret |= (0x1 << 3);
}
if ((channels & ColorWriteChannels.Green) != 0)
{
ret |= (0x1 << 2);
}
if ((channels & ColorWriteChannels.Blue) != 0)
{
ret |= (0x1 << 1);
}
if ((channels & ColorWriteChannels.Alpha) != 0)
{
ret |= (0x1 << 0);
}
return ret;
}
public static readonly MTLCompareFunction[] CompareFunc = new MTLCompareFunction[]
{
MTLCompareFunction.Always, // CompareFunction.Always
MTLCompareFunction.Never, // CompareFunction.Never
MTLCompareFunction.Less, // CompareFunction.Less
MTLCompareFunction.LessEqual, // CompareFunction.LessEqual
MTLCompareFunction.Equal, // CompareFunction.Equal
MTLCompareFunction.GreaterEqual,// CompareFunction.GreaterEqual
MTLCompareFunction.Greater, // CompareFunction.Greater
MTLCompareFunction.NotEqual // CompareFunction.NotEqual
};
public static readonly MTLStencilOperation[] StencilOp = new MTLStencilOperation[]
{
MTLStencilOperation.Keep, // StencilOperation.Keep
MTLStencilOperation.Zero, // StencilOperation.Zero
MTLStencilOperation.Replace, // StencilOperation.Replace
MTLStencilOperation.IncrementWrap, // StencilOperation.Increment
MTLStencilOperation.DecrementWrap, // StencilOperation.Decrement
MTLStencilOperation.IncrementClamp, // StencilOperation.IncrementSaturation
MTLStencilOperation.DecrementClamp, // StencilOperation.DecrementSaturation
MTLStencilOperation.Invert // StencilOperation.Invert
};
public static readonly MTLTriangleFillMode[] FillMode = new MTLTriangleFillMode[]
{
MTLTriangleFillMode.Fill, // FillMode.Solid
MTLTriangleFillMode.Lines // FillMode.WireFrame
};
public static float DepthBiasScale(MTLPixelFormat format)
{
switch (format)
{
case MTLPixelFormat.Depth16Unorm:
return (float) ((1 << 16) - 1);
case MTLPixelFormat.Depth24Unorm_Stencil8:
return (float) ((1 << 24) - 1);
case MTLPixelFormat.Depth32Float:
case MTLPixelFormat.Depth32Float_Stencil8:
return (float) ((1 << 23) - 1);
}
return 0.0f;
}
public static readonly MTLCullMode[] CullingEnabled = new MTLCullMode[]
{
MTLCullMode.None, // CullMode.None
MTLCullMode.Front, // CullMode.CullClockwiseFace
MTLCullMode.Back // CullMode.CullCounterClockwiseFace
};
public static readonly MTLSamplerAddressMode[] Wrap = new MTLSamplerAddressMode[]
{
MTLSamplerAddressMode.Repeat, // TextureAddressMode.Wrap
MTLSamplerAddressMode.ClampToEdge, // TextureAddressMode.Clamp
MTLSamplerAddressMode.MirrorRepeat // TextureAddressMode.Mirror
};
public static readonly MTLSamplerMinMagFilter[] MagFilter = new MTLSamplerMinMagFilter[]
{
MTLSamplerMinMagFilter.Linear, // TextureFilter.Linear
MTLSamplerMinMagFilter.Nearest, // TextureFilter.Point
MTLSamplerMinMagFilter.Linear, // TextureFilter.Anisotropic
MTLSamplerMinMagFilter.Linear, // TextureFilter.LinearMipPoint
MTLSamplerMinMagFilter.Nearest, // TextureFilter.PointMipLinear
MTLSamplerMinMagFilter.Nearest, // TextureFilter.MinLinearMagPointMipLinear
MTLSamplerMinMagFilter.Nearest, // TextureFilter.MinLinearMagPointMipPoint
MTLSamplerMinMagFilter.Linear, // TextureFilter.MinPointMagLinearMipLinear
MTLSamplerMinMagFilter.Linear // TextureFilter.MinPointMagLinearMipPoint
};
public static readonly MTLSamplerMipFilter[] MipFilter = new MTLSamplerMipFilter[]
{
MTLSamplerMipFilter.Linear, // TextureFilter.Linear
MTLSamplerMipFilter.Nearest, // TextureFilter.Point
MTLSamplerMipFilter.Linear, // TextureFilter.Anisotropic
MTLSamplerMipFilter.Nearest, // TextureFilter.LinearMipPoint
MTLSamplerMipFilter.Linear, // TextureFilter.PointMipLinear
MTLSamplerMipFilter.Linear, // TextureFilter.MinLinearMagPointMipLinear
MTLSamplerMipFilter.Nearest, // TextureFilter.MinLinearMagPointMipPoint
MTLSamplerMipFilter.Linear, // TextureFilter.MinPointMagLinearMipLinear
MTLSamplerMipFilter.Nearest // TextureFilter.MinPointMagLinearMipPoint
};
public static readonly MTLSamplerMinMagFilter[] MinFilter = new MTLSamplerMinMagFilter[]
{
MTLSamplerMinMagFilter.Linear, // TextureFilter.Linear
MTLSamplerMinMagFilter.Nearest, // TextureFilter.Point
MTLSamplerMinMagFilter.Linear, // TextureFilter.Anisotropic
MTLSamplerMinMagFilter.Linear, // TextureFilter.LinearMipPoint
MTLSamplerMinMagFilter.Nearest, // TextureFilter.PointMipLinear
MTLSamplerMinMagFilter.Linear, // TextureFilter.MinLinearMagPointMipLinear
MTLSamplerMinMagFilter.Linear, // TextureFilter.MinLinearMagPointMipPoint
MTLSamplerMinMagFilter.Nearest, // TextureFilter.MinPointMagLinearMipLinear
MTLSamplerMinMagFilter.Nearest // TextureFilter.MinPointMagLinearMipPoint
};
public static readonly MTLPrimitiveType[] Primitive = new MTLPrimitiveType[]
{
MTLPrimitiveType.Triangle, // PrimitiveType.TriangleList
MTLPrimitiveType.TriangleStrip, // PrimitiveType.TriangleStrip
MTLPrimitiveType.Line, // PrimitiveType.LineList
MTLPrimitiveType.LineStrip, // PrimitiveType.LineStrip
MTLPrimitiveType.Point // PrimitiveType.PointListEXT
};
public static int PrimitiveVerts(PrimitiveType primitiveType, int primitiveCount)
{
switch (primitiveType)
{
case PrimitiveType.TriangleList:
return primitiveCount * 3;
case PrimitiveType.TriangleStrip:
return primitiveCount + 2;
case PrimitiveType.LineList:
return primitiveCount * 2;
case PrimitiveType.LineStrip:
return primitiveCount + 1;
case PrimitiveType.PointListEXT:
return primitiveCount;
}
throw new NotSupportedException();
}
}
#endregion
#region The Faux-Backbuffer
private class MetalBackbuffer : IGLBackbuffer
{
public int Width
{
get;
private set;
}
public int Height
{
get;
private set;
}
public MTLPixelFormat PixelFormat
{
get;
private set;
}
public DepthFormat DepthFormat
{
get;
private set;
}
public int MultiSampleCount
{
get;
private set;
}
public MetalTexture Texture
{
get;
private set;
}
public IntPtr ColorBuffer = IntPtr.Zero;
public IntPtr MultiSampleColorBuffer = IntPtr.Zero;
public IntPtr DepthStencilBuffer = IntPtr.Zero;
private MetalDevice mtlDevice;
public MetalBackbuffer(
MetalDevice device,
PresentationParameters presentationParameters
) {
mtlDevice = device;
PixelFormat = MTLPixelFormat.RGBA8Unorm;
/* Set these now to prevent a changed event in Create!
* The rest will be set and don't have checks anywhere.
* -flibit
*/
Width = presentationParameters.BackBufferWidth;
Height = presentationParameters.BackBufferHeight;
}
public void Dispose()
{
objc_release(ColorBuffer);
ColorBuffer = IntPtr.Zero;
objc_release(MultiSampleColorBuffer);
MultiSampleColorBuffer = IntPtr.Zero;
objc_release(DepthStencilBuffer);
DepthStencilBuffer = IntPtr.Zero;
}
public void ResetFramebuffer(
PresentationParameters presentationParameters
) {
// Just destroy and recreate from scratch
Dispose();
CreateFramebuffer(presentationParameters);
}
public void CreateFramebuffer(
PresentationParameters presentationParameters
) {
// Update the backbuffer size
int newWidth = presentationParameters.BackBufferWidth;
int newHeight = presentationParameters.BackBufferHeight;
if (Width != newWidth || Height != newHeight)
{
mtlDevice.fauxBackbufferSizeChanged = true;
}
Width = newWidth;
Height = newHeight;
// Update other presentation parameters
DepthFormat = presentationParameters.DepthStencilFormat;
MultiSampleCount = mtlDevice.GetCompatibleSampleCount(
presentationParameters.MultiSampleCount
);
// Update color buffer to the new resolution.
IntPtr colorBufferDesc = mtlMakeTexture2DDescriptor(
PixelFormat,
Width,
Height,
false
);
mtlSetStorageMode(
colorBufferDesc,
MTLStorageMode.Private
);
mtlSetTextureUsage(
colorBufferDesc,
MTLTextureUsage.RenderTarget | MTLTextureUsage.ShaderRead
);
ColorBuffer = mtlNewTextureWithDescriptor(
mtlDevice.device,
colorBufferDesc
);
if (MultiSampleCount > 0)
{
mtlSetTextureType(
colorBufferDesc,
MTLTextureType.Multisample2D
);
mtlSetTextureSampleCount(
colorBufferDesc,
MultiSampleCount
);
mtlSetTextureUsage(
colorBufferDesc,
MTLTextureUsage.RenderTarget
);
MultiSampleColorBuffer = mtlNewTextureWithDescriptor(
mtlDevice.device,
colorBufferDesc
);
}
// Update the depth/stencil buffer, if applicable
if (DepthFormat != DepthFormat.None)
{
IntPtr depthStencilBufferDesc = mtlMakeTexture2DDescriptor(
mtlDevice.GetDepthFormat(DepthFormat),
Width,
Height,
false
);
mtlSetStorageMode(
depthStencilBufferDesc,
MTLStorageMode.Private
);
mtlSetTextureUsage(
depthStencilBufferDesc,
MTLTextureUsage.RenderTarget
);
if (MultiSampleCount > 0)
{
mtlSetTextureType(
depthStencilBufferDesc,
MTLTextureType.Multisample2D
);
mtlSetTextureSampleCount(
depthStencilBufferDesc,
MultiSampleCount
);
}
DepthStencilBuffer = mtlNewTextureWithDescriptor(
mtlDevice.device,
depthStencilBufferDesc
);
}
// Update the Texture representation
Texture = new MetalTexture(
ColorBuffer,
Width,
Height,
SurfaceFormat.Color,
1,
true
);
// This is the default render target
mtlDevice.SetRenderTargets(null, null, DepthFormat.None);
}
}
private void InitializeFauxBackbuffer(
PresentationParameters presentationParameters
) {
MetalBackbuffer mtlBackbuffer = new MetalBackbuffer(
this,
presentationParameters
);
Backbuffer = mtlBackbuffer;
mtlBackbuffer.CreateFramebuffer(presentationParameters);
/* Create a combined vertex/index buffer
* for rendering the faux-backbuffer.
*/
fauxBackbufferDrawBuffer = mtlNewBufferWithLength(
device,
(16 * sizeof(float)) + (6 * sizeof(ushort)),
MTLResourceOptions.CPUCacheModeWriteCombined
);
ushort[] indices = new ushort[]
{
0, 1, 3,
1, 2, 3
};
GCHandle indicesPinned = GCHandle.Alloc(indices, GCHandleType.Pinned);
SDL.SDL_memcpy(
mtlGetBufferContentsPtr(fauxBackbufferDrawBuffer) + (16 * sizeof(float)),
indicesPinned.AddrOfPinnedObject(),
(IntPtr) (6 * sizeof(ushort))
);
indicesPinned.Free();
// Create vertex and fragment shaders for the faux-backbuffer pipeline
string shaderSource =
@"
#include <metal_stdlib>
using namespace metal;
struct VertexIn {
packed_float2 position;
packed_float2 texCoord;
};
struct VertexOut {
float4 position [[ position ]];
float2 texCoord;
};
vertex VertexOut
vertexShader(
uint vertexID [[ vertex_id ]],
constant VertexIn *vertexArray [[ buffer(0) ]]
) {
VertexOut out;
out.position = float4(vertexArray[vertexID].position, 0.0, 1.0);
out.position.y *= -1;
out.texCoord = vertexArray[vertexID].texCoord;
return out;
}
fragment float4
fragmentShader(
VertexOut in [[stage_in]],
texture2d<half> colorTexture [[ texture(0) ]],
sampler s0 [[sampler(0)]]
) {
const half4 colorSample = colorTexture.sample(s0, in.texCoord);
return float4(colorSample);
}
";
IntPtr nsShaderSource = UTF8ToNSString(shaderSource);
IntPtr nsVertexShader = UTF8ToNSString("vertexShader");
IntPtr nsFragmentShader = UTF8ToNSString("fragmentShader");
IntPtr library = mtlNewLibraryWithSource(
device,
nsShaderSource,
IntPtr.Zero
);
IntPtr vertexFunc = mtlNewFunctionWithName(
library,
nsVertexShader
);
IntPtr fragFunc = mtlNewFunctionWithName(
library,
nsFragmentShader
);
objc_release(nsShaderSource);
objc_release(nsVertexShader);
objc_release(nsFragmentShader);
// Create a sampler state
IntPtr samplerDescriptor = mtlNewSamplerDescriptor();
mtlSetSamplerMinFilter(samplerDescriptor, backbufferScaleMode);
mtlSetSamplerMagFilter(samplerDescriptor, backbufferScaleMode);
fauxBackbufferSamplerState = mtlNewSamplerStateWithDescriptor(
device,
samplerDescriptor
);
objc_release(samplerDescriptor);
// Create a render pipeline for rendering the backbuffer
IntPtr pipelineDesc = mtlNewRenderPipelineDescriptor();
mtlSetPipelineVertexFunction(pipelineDesc, vertexFunc);
mtlSetPipelineFragmentFunction(pipelineDesc, fragFunc);
mtlSetAttachmentPixelFormat(
mtlGetColorAttachment(pipelineDesc, 0),
mtlGetLayerPixelFormat(layer)
);
fauxBackbufferRenderPipeline = mtlNewRenderPipelineStateWithDescriptor(
device,
pipelineDesc
);
objc_release(pipelineDesc);
objc_release(vertexFunc);
objc_release(fragFunc);
}
#endregion
}
}