summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/3rdparty/mtlpp/mtlpp.hpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/3rdparty/mtlpp/mtlpp.hpp')
-rw-r--r--3rdparty/bgfx/3rdparty/mtlpp/mtlpp.hpp2706
1 files changed, 2706 insertions, 0 deletions
diff --git a/3rdparty/bgfx/3rdparty/mtlpp/mtlpp.hpp b/3rdparty/bgfx/3rdparty/mtlpp/mtlpp.hpp
new file mode 100644
index 00000000000..d7f304b6c0b
--- /dev/null
+++ b/3rdparty/bgfx/3rdparty/mtlpp/mtlpp.hpp
@@ -0,0 +1,2706 @@
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+#pragma once
+
+//////////////////////////////////////
+// FILE: defines.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+#include <stdint.h>
+#include <assert.h>
+#include <functional>
+
+#ifndef __has_feature
+# define __has_feature(x) 0
+#endif
+
+#ifndef MTLPP_CONFIG_RVALUE_REFERENCES
+# define MTLPP_CONFIG_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
+#endif
+
+#ifndef MTLPP_CONFIG_VALIDATE
+# define MTLPP_CONFIG_VALIDATE 1
+#endif
+
+#ifndef MTLPP_CONFIG_USE_AVAILABILITY
+# define MTLPP_CONFIG_USE_AVAILABILITY 0
+#endif
+
+#if MTLPP_CONFIG_USE_AVAILABILITY
+# if __has_feature(attribute_availability_with_version_underscores) || (__has_feature(attribute_availability_with_message) && __clang__ && __clang_major__ >= 7)
+# include <CoreFoundation/CFAvailability.h>
+# define MTLPP_AVAILABLE(mac, ios) CF_AVAILABLE(mac, ios)
+# define MTLPP_AVAILABLE_MAC(mac) CF_AVAILABLE_MAC(mac)
+# define MTLPP_AVAILABLE_IOS(ios) CF_AVAILABLE_IOS(ios)
+# define MTLPP_AVAILABLE_TVOS(tvos)
+# define MTLPP_DEPRECATED(macIntro, macDep, iosIntro, iosDep) CF_DEPRECATED(macIntro, macDep, iosIntro, iosDep)
+# define MTLPP_DEPRECATED_MAC(macIntro, macDep) CF_DEPRECATED_MAC(macIntro, macDep)
+# define MTLPP_DEPRECATED_IOS(iosIntro, iosDep) CF_DEPRECATED_IOS(iosIntro, iosDep)
+# endif
+#endif
+
+#ifndef MTLPP_AVAILABLE
+# define MTLPP_AVAILABLE(mac, ios)
+# define MTLPP_AVAILABLE_MAC(mac)
+# define MTLPP_AVAILABLE_IOS(ios)
+# define MTLPP_AVAILABLE_TVOS(tvos)
+# define MTLPP_DEPRECATED(macIntro, macDep, iosIntro, iosDep)
+# define MTLPP_DEPRECATED_MAC(macIntro, macDep)
+# define MTLPP_DEPRECATED_IOS(iosIntro, iosDep)
+#endif
+
+#ifndef __DARWIN_ALIAS_STARTING_MAC___MAC_10_11
+# define __DARWIN_ALIAS_STARTING_MAC___MAC_10_11(x)
+#endif
+#ifndef __DARWIN_ALIAS_STARTING_MAC___MAC_10_12
+# define __DARWIN_ALIAS_STARTING_MAC___MAC_10_12(x)
+#endif
+#ifndef __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_0
+# define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_8_0(x)
+#endif
+#ifndef __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_0
+# define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_9_0(x)
+#endif
+#ifndef __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_0
+# define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_10_0(x)
+#endif
+
+#define MTLPP_IS_AVAILABLE_MAC(mac) (0 __DARWIN_ALIAS_STARTING_MAC___MAC_##mac( || 1 ))
+#define MTLPP_IS_AVAILABLE_IOS(ios) (0 __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_##ios( || 1 ))
+#define MTLPP_IS_AVAILABLE(mac, ios) (MTLPP_IS_AVAILABLE_MAC(mac) || MTLPP_IS_AVAILABLE_IOS(ios))
+
+
+//////////////////////////////////////
+// FILE: ns.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+
+namespace ns
+{
+ struct Handle
+ {
+ const void* ptr;
+ };
+
+ class Object
+ {
+ public:
+ inline const void* GetPtr() const { return m_ptr; }
+
+ inline operator bool() const { return m_ptr != nullptr; }
+
+ protected:
+ Object();
+ Object(const Handle& handle);
+ Object(const Object& rhs);
+#if MTLPP_CONFIG_RVALUE_REFERENCES
+ Object(Object&& rhs);
+#endif
+ virtual ~Object();
+
+ Object& operator=(const Object& rhs);
+#if MTLPP_CONFIG_RVALUE_REFERENCES
+ Object& operator=(Object&& rhs);
+#endif
+
+ inline void Validate() const
+ {
+#if MTLPP_CONFIG_VALIDATE
+ assert(m_ptr);
+#endif
+ }
+
+ const void* m_ptr = nullptr;
+ };
+
+ struct Range
+ {
+ inline Range(uint32_t location, uint32_t length) :
+ Location(location),
+ Length(length)
+ { }
+
+ uint32_t Location;
+ uint32_t Length;
+ };
+
+ class ArrayBase : public Object
+ {
+ public:
+ ArrayBase() { }
+ ArrayBase(const Handle& handle) : Object(handle) { }
+
+ const uint32_t GetSize() const;
+
+ protected:
+ void* GetItem(uint32_t index) const;
+ };
+
+ template<typename T>
+ class Array : public ArrayBase
+ {
+ public:
+ Array() { }
+ Array(const Handle& handle) : ArrayBase(handle) { }
+
+ const T operator[](uint32_t index) const
+ {
+ return Handle{ GetItem(index) };
+ }
+
+ T operator[](uint32_t index)
+ {
+ return Handle{ GetItem(index) };
+ }
+ };
+
+ class DictionaryBase : public Object
+ {
+ public:
+ DictionaryBase() { }
+ DictionaryBase(const Handle& handle) : Object(handle) { }
+
+ protected:
+
+ };
+
+ template<typename KeyT, typename ValueT>
+ class Dictionary : public DictionaryBase
+ {
+ public:
+ Dictionary() { }
+ Dictionary(const Handle& handle) : DictionaryBase(handle) { }
+ };
+
+ class String : public Object
+ {
+ public:
+ String() { }
+ String(const Handle& handle) : Object(handle) { }
+ String(const char* cstr);
+
+ const char* GetCStr() const;
+ uint32_t GetLength() const;
+ };
+
+ class Error : public Object
+ {
+ public:
+ Error();
+ Error(const Handle& handle) : Object(handle) { }
+
+ String GetDomain() const;
+ uint32_t GetCode() const;
+ //@property (readonly, copy) NSDictionary *userInfo;
+ String GetLocalizedDescription() const;
+ String GetLocalizedFailureReason() const;
+ String GetLocalizedRecoverySuggestion() const;
+ String GetLocalizedRecoveryOptions() const;
+ //@property (nullable, readonly, strong) id recoveryAttempter;
+ String GetHelpAnchor() const;
+ };
+}
+
+//////////////////////////////////////
+// FILE: command_encoder.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+
+namespace mtlpp
+{
+ class Device;
+
+ class CommandEncoder : public ns::Object
+ {
+ public:
+ CommandEncoder() { }
+ CommandEncoder(const ns::Handle& handle) : ns::Object(handle) { }
+
+ Device GetDevice() const;
+ ns::String GetLabel() const;
+
+ void SetLabel(const ns::String& label);
+
+ void EndEncoding();
+ void InsertDebugSignpost(const ns::String& string);
+ void PushDebugGroup(const ns::String& string);
+ void PopDebugGroup();
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: pixel_format.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+
+namespace mtlpp
+{
+ enum class PixelFormat
+ {
+ Invalid = 0,
+
+ A8Unorm = 1,
+
+ R8Unorm = 10,
+ R8Unorm_sRGB MTLPP_AVAILABLE_IOS(8_0) = 11,
+
+ R8Snorm = 12,
+ R8Uint = 13,
+ R8Sint = 14,
+
+ R16Unorm = 20,
+ R16Snorm = 22,
+ R16Uint = 23,
+ R16Sint = 24,
+ R16Float = 25,
+
+ RG8Unorm = 30,
+ RG8Unorm_sRGB MTLPP_AVAILABLE_IOS(8_0) = 31,
+ RG8Snorm = 32,
+ RG8Uint = 33,
+ RG8Sint = 34,
+
+ B5G6R5Unorm MTLPP_AVAILABLE_IOS(8_0) = 40,
+ A1BGR5Unorm MTLPP_AVAILABLE_IOS(8_0) = 41,
+ ABGR4Unorm MTLPP_AVAILABLE_IOS(8_0) = 42,
+ BGR5A1Unorm MTLPP_AVAILABLE_IOS(8_0) = 43,
+
+ R32Uint = 53,
+ R32Sint = 54,
+ R32Float = 55,
+
+ RG16Unorm = 60,
+ RG16Snorm = 62,
+ RG16Uint = 63,
+ RG16Sint = 64,
+ RG16Float = 65,
+
+ RGBA8Unorm = 70,
+ RGBA8Unorm_sRGB = 71,
+ RGBA8Snorm = 72,
+ RGBA8Uint = 73,
+ RGBA8Sint = 74,
+
+ BGRA8Unorm = 80,
+ BGRA8Unorm_sRGB = 81,
+
+ RGB10A2Unorm = 90,
+ RGB10A2Uint = 91,
+
+ RG11B10Float = 92,
+ RGB9E5Float = 93,
+
+ BGR10_XR MTLPP_AVAILABLE_IOS(10_0) = 554,
+ BGR10_XR_sRGB MTLPP_AVAILABLE_IOS(10_0) = 555,
+
+
+ RG32Uint = 103,
+ RG32Sint = 104,
+ RG32Float = 105,
+
+ RGBA16Unorm = 110,
+ RGBA16Snorm = 112,
+ RGBA16Uint = 113,
+ RGBA16Sint = 114,
+ RGBA16Float = 115,
+
+ BGRA10_XR MTLPP_AVAILABLE_IOS(10_0) = 552,
+ BGRA10_XR_sRGB MTLPP_AVAILABLE_IOS(10_0) = 553,
+
+ RGBA32Uint = 123,
+ RGBA32Sint = 124,
+ RGBA32Float = 125,
+
+ BC1_RGBA MTLPP_AVAILABLE_MAC(10_11) = 130,
+ BC1_RGBA_sRGB MTLPP_AVAILABLE_MAC(10_11) = 131,
+ BC2_RGBA MTLPP_AVAILABLE_MAC(10_11) = 132,
+ BC2_RGBA_sRGB MTLPP_AVAILABLE_MAC(10_11) = 133,
+ BC3_RGBA MTLPP_AVAILABLE_MAC(10_11) = 134,
+ BC3_RGBA_sRGB MTLPP_AVAILABLE_MAC(10_11) = 135,
+
+ BC4_RUnorm MTLPP_AVAILABLE_MAC(10_11) = 140,
+ BC4_RSnorm MTLPP_AVAILABLE_MAC(10_11) = 141,
+ BC5_RGUnorm MTLPP_AVAILABLE_MAC(10_11) = 142,
+ BC5_RGSnorm MTLPP_AVAILABLE_MAC(10_11) = 143,
+
+ BC6H_RGBFloat MTLPP_AVAILABLE_MAC(10_11) = 150,
+ BC6H_RGBUfloat MTLPP_AVAILABLE_MAC(10_11) = 151,
+ BC7_RGBAUnorm MTLPP_AVAILABLE_MAC(10_11) = 152,
+ BC7_RGBAUnorm_sRGB MTLPP_AVAILABLE_MAC(10_11) = 153,
+
+ PVRTC_RGB_2BPP MTLPP_AVAILABLE_IOS(8_0) = 160,
+ PVRTC_RGB_2BPP_sRGB MTLPP_AVAILABLE_IOS(8_0) = 161,
+ PVRTC_RGB_4BPP MTLPP_AVAILABLE_IOS(8_0) = 162,
+ PVRTC_RGB_4BPP_sRGB MTLPP_AVAILABLE_IOS(8_0) = 163,
+ PVRTC_RGBA_2BPP MTLPP_AVAILABLE_IOS(8_0) = 164,
+ PVRTC_RGBA_2BPP_sRGB MTLPP_AVAILABLE_IOS(8_0) = 165,
+ PVRTC_RGBA_4BPP MTLPP_AVAILABLE_IOS(8_0) = 166,
+ PVRTC_RGBA_4BPP_sRGB MTLPP_AVAILABLE_IOS(8_0) = 167,
+
+ EAC_R11Unorm MTLPP_AVAILABLE_IOS(8_0) = 170,
+ EAC_R11Snorm MTLPP_AVAILABLE_IOS(8_0) = 172,
+ EAC_RG11Unorm MTLPP_AVAILABLE_IOS(8_0) = 174,
+ EAC_RG11Snorm MTLPP_AVAILABLE_IOS(8_0) = 176,
+ EAC_RGBA8 MTLPP_AVAILABLE_IOS(8_0) = 178,
+ EAC_RGBA8_sRGB MTLPP_AVAILABLE_IOS(8_0) = 179,
+
+ ETC2_RGB8 MTLPP_AVAILABLE_IOS(8_0) = 180,
+ ETC2_RGB8_sRGB MTLPP_AVAILABLE_IOS(8_0) = 181,
+ ETC2_RGB8A1 MTLPP_AVAILABLE_IOS(8_0) = 182,
+ ETC2_RGB8A1_sRGB MTLPP_AVAILABLE_IOS(8_0) = 183,
+
+ ASTC_4x4_sRGB MTLPP_AVAILABLE_IOS(8_0) = 186,
+ ASTC_5x4_sRGB MTLPP_AVAILABLE_IOS(8_0) = 187,
+ ASTC_5x5_sRGB MTLPP_AVAILABLE_IOS(8_0) = 188,
+ ASTC_6x5_sRGB MTLPP_AVAILABLE_IOS(8_0) = 189,
+ ASTC_6x6_sRGB MTLPP_AVAILABLE_IOS(8_0) = 190,
+ ASTC_8x5_sRGB MTLPP_AVAILABLE_IOS(8_0) = 192,
+ ASTC_8x6_sRGB MTLPP_AVAILABLE_IOS(8_0) = 193,
+ ASTC_8x8_sRGB MTLPP_AVAILABLE_IOS(8_0) = 194,
+ ASTC_10x5_sRGB MTLPP_AVAILABLE_IOS(8_0) = 195,
+ ASTC_10x6_sRGB MTLPP_AVAILABLE_IOS(8_0) = 196,
+ ASTC_10x8_sRGB MTLPP_AVAILABLE_IOS(8_0) = 197,
+ ASTC_10x10_sRGB MTLPP_AVAILABLE_IOS(8_0) = 198,
+ ASTC_12x10_sRGB MTLPP_AVAILABLE_IOS(8_0) = 199,
+ ASTC_12x12_sRGB MTLPP_AVAILABLE_IOS(8_0) = 200,
+
+ ASTC_4x4_LDR MTLPP_AVAILABLE_IOS(8_0) = 204,
+ ASTC_5x4_LDR MTLPP_AVAILABLE_IOS(8_0) = 205,
+ ASTC_5x5_LDR MTLPP_AVAILABLE_IOS(8_0) = 206,
+ ASTC_6x5_LDR MTLPP_AVAILABLE_IOS(8_0) = 207,
+ ASTC_6x6_LDR MTLPP_AVAILABLE_IOS(8_0) = 208,
+ ASTC_8x5_LDR MTLPP_AVAILABLE_IOS(8_0) = 210,
+ ASTC_8x6_LDR MTLPP_AVAILABLE_IOS(8_0) = 211,
+ ASTC_8x8_LDR MTLPP_AVAILABLE_IOS(8_0) = 212,
+ ASTC_10x5_LDR MTLPP_AVAILABLE_IOS(8_0) = 213,
+ ASTC_10x6_LDR MTLPP_AVAILABLE_IOS(8_0) = 214,
+ ASTC_10x8_LDR MTLPP_AVAILABLE_IOS(8_0) = 215,
+ ASTC_10x10_LDR MTLPP_AVAILABLE_IOS(8_0) = 216,
+ ASTC_12x10_LDR MTLPP_AVAILABLE_IOS(8_0) = 217,
+ ASTC_12x12_LDR MTLPP_AVAILABLE_IOS(8_0) = 218,
+
+ GBGR422 = 240,
+
+ BGRG422 = 241,
+
+ Depth16Unorm MTLPP_AVAILABLE_MAC(10_12) = 250,
+ Depth32Float = 252,
+
+ Stencil8 = 253,
+
+ Depth24Unorm_Stencil8 MTLPP_AVAILABLE_MAC(10_11) = 255,
+ Depth32Float_Stencil8 MTLPP_AVAILABLE(10_11, 9_0) = 260,
+
+ X32_Stencil8 MTLPP_AVAILABLE(10_12, 10_0) = 261,
+ X24_Stencil8 MTLPP_AVAILABLE_MAC(10_12) = 262,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+
+//////////////////////////////////////
+// FILE: resource.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+
+namespace mtlpp
+{
+ class Heap;
+
+ static const uint32_t ResourceCpuCacheModeShift = 0;
+ static const uint32_t ResourceStorageModeShift = 4;
+ static const uint32_t ResourceHazardTrackingModeShift = 8;
+
+ enum class PurgeableState
+ {
+ KeepCurrent = 1,
+ NonVolatile = 2,
+ Volatile = 3,
+ Empty = 4,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class CpuCacheMode
+ {
+ DefaultCache = 0,
+ WriteCombined = 1,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class StorageMode
+ {
+ Shared = 0,
+ Managed MTLPP_AVAILABLE(10_11, NA) = 1,
+ Private = 2,
+ Memoryless MTLPP_AVAILABLE(NA, 10_0) = 3,
+ }
+ MTLPP_AVAILABLE(10_11, 9_0);
+
+ enum class ResourceOptions
+ {
+ CpuCacheModeDefaultCache = uint32_t(CpuCacheMode::DefaultCache) << ResourceCpuCacheModeShift,
+ CpuCacheModeWriteCombined = uint32_t(CpuCacheMode::WriteCombined) << ResourceCpuCacheModeShift,
+
+ StorageModeShared MTLPP_AVAILABLE(10_11, 9_0) = uint32_t(StorageMode::Shared) << ResourceStorageModeShift,
+ StorageModeManaged MTLPP_AVAILABLE(10_11, NA) = uint32_t(StorageMode::Managed) << ResourceStorageModeShift,
+ StorageModePrivate MTLPP_AVAILABLE(10_11, 9_0) = uint32_t(StorageMode::Private) << ResourceStorageModeShift,
+ StorageModeMemoryless MTLPP_AVAILABLE(NA, 10_0) = uint32_t(StorageMode::Memoryless) << ResourceStorageModeShift,
+
+ HazardTrackingModeUntracked MTLPP_AVAILABLE(NA, 10_0) = 0x1 << ResourceHazardTrackingModeShift,
+
+ OptionCPUCacheModeDefault = CpuCacheModeDefaultCache,
+ OptionCPUCacheModeWriteCombined = CpuCacheModeWriteCombined,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class Resource : public ns::Object
+ {
+ public:
+ Resource() { }
+ Resource(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const;
+ CpuCacheMode GetCpuCacheMode() const;
+ StorageMode GetStorageMode() const MTLPP_AVAILABLE(10_11, 9_0);
+ Heap GetHeap() const MTLPP_AVAILABLE(NA, 10_0);
+ bool IsAliasable() const MTLPP_AVAILABLE(NA, 10_0);
+
+ void SetLabel(const ns::String& label);
+
+ PurgeableState SetPurgeableState(PurgeableState state);
+ void MakeAliasable() const MTLPP_AVAILABLE(NA, 10_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: buffer.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "pixel_format.hpp"
+// #include "resource.hpp"
+
+namespace mtlpp
+{
+ class Texture;
+ class TextureDescriptor;
+
+ class Buffer : public Resource
+ {
+ public:
+ Buffer() { }
+ Buffer(const ns::Handle& handle) : Resource(handle) { }
+
+ uint32_t GetLength() const;
+ void* GetContents();
+ void DidModify(const ns::Range& range) MTLPP_AVAILABLE_MAC(10_11);
+ Texture NewTexture(const TextureDescriptor& descriptor, uint32_t offset, uint32_t bytesPerRow) MTLPP_AVAILABLE_IOS(8_0);
+ void AddDebugMarker(const ns::String& marker, const ns::Range& range) MTLPP_AVAILABLE(10_12, 10_0);
+ void RemoveAllDebugMarkers() MTLPP_AVAILABLE(10_12, 10_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: types.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+
+namespace mtlpp
+{
+ struct Origin
+ {
+ inline Origin(uint32_t x, uint32_t y, uint32_t z) :
+ X(x),
+ Y(y),
+ Z(z)
+ { }
+
+ uint32_t X;
+ uint32_t Y;
+ uint32_t Z;
+ };
+
+ struct Size
+ {
+ inline Size(uint32_t width, uint32_t height, uint32_t depth) :
+ Width(width),
+ Height(height),
+ Depth(depth)
+ { }
+
+ uint32_t Width;
+ uint32_t Height;
+ uint32_t Depth;
+ };
+
+ struct Region
+ {
+ inline Region(uint32_t x, uint32_t width) :
+ Origin(x, 0, 0),
+ Size(width, 1, 1)
+ { }
+
+ inline Region(uint32_t x, uint32_t y, uint32_t width, uint32_t height) :
+ Origin(x, y, 0),
+ Size(width, height, 1)
+ { }
+
+ inline Region(uint32_t x, uint32_t y, uint32_t z, uint32_t width, uint32_t height, uint32_t depth) :
+ Origin(x, y, z),
+ Size(width, height, depth)
+ { }
+
+ Origin Origin;
+ Size Size;
+ };
+}
+
+//////////////////////////////////////
+// FILE: texture.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "resource.hpp"
+// #include "buffer.hpp"
+// #include "types.hpp"
+
+namespace mtlpp
+{
+ enum class TextureType
+ {
+ Texture1D = 0,
+ Texture1DArray = 1,
+ Texture2D = 2,
+ Texture2DArray = 3,
+ Texture2DMultisample = 4,
+ TextureCube = 5,
+ TextureCubeArray MTLPP_AVAILABLE_MAC(10_11) = 6,
+ Texture3D = 7,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class TextureUsage
+ {
+ Unknown = 0x0000,
+ ShaderRead = 0x0001,
+ ShaderWrite = 0x0002,
+ RenderTarget = 0x0004,
+ PixelFormatView = 0x0010,
+ }
+ MTLPP_AVAILABLE(10_11, 9_0);
+
+
+ class TextureDescriptor : public ns::Object
+ {
+ public:
+ TextureDescriptor();
+ TextureDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ static TextureDescriptor Texture2DDescriptor(PixelFormat pixelFormat, uint32_t width, uint32_t height, bool mipmapped);
+ static TextureDescriptor TextureCubeDescriptor(PixelFormat pixelFormat, uint32_t size, bool mipmapped);
+
+ TextureType GetTextureType() const;
+ PixelFormat GetPixelFormat() const;
+ uint32_t GetWidth() const;
+ uint32_t GetHeight() const;
+ uint32_t GetDepth() const;
+ uint32_t GetMipmapLevelCount() const;
+ uint32_t GetSampleCount() const;
+ uint32_t GetArrayLength() const;
+ ResourceOptions GetResourceOptions() const;
+ CpuCacheMode GetCpuCacheMode() const MTLPP_AVAILABLE(10_11, 9_0);
+ StorageMode GetStorageMode() const MTLPP_AVAILABLE(10_11, 9_0);
+ TextureUsage GetUsage() const MTLPP_AVAILABLE(10_11, 9_0);
+
+ void SetTextureType(TextureType textureType);
+ void SetPixelFormat(PixelFormat pixelFormat);
+ void SetWidth(uint32_t width);
+ void SetHeight(uint32_t height);
+ void SetDepth(uint32_t depth);
+ void SetMipmapLevelCount(uint32_t mipmapLevelCount);
+ void SetSampleCount(uint32_t sampleCount);
+ void SetArrayLength(uint32_t arrayLength);
+ void SetResourceOptions(ResourceOptions resourceOptions);
+ void SetCpuCacheMode(CpuCacheMode cpuCacheMode) MTLPP_AVAILABLE(10_11, 9_0);
+ void SetStorageMode(StorageMode storageMode) MTLPP_AVAILABLE(10_11, 9_0);
+ void SetUsage(TextureUsage usage) MTLPP_AVAILABLE(10_11, 9_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class Texture : public Resource
+ {
+ public:
+ Texture() { }
+ Texture(const ns::Handle& handle) : Resource(handle) { }
+
+ Resource GetRootResource() const MTLPP_DEPRECATED(10_11, 10_12, 8_0, 10_0);
+ Texture GetParentTexture() const MTLPP_AVAILABLE(10_11, 9_0);
+ uint32_t GetParentRelativeLevel() const MTLPP_AVAILABLE(10_11, 9_0);
+ uint32_t GetParentRelativeSlice() const MTLPP_AVAILABLE(10_11, 9_0);
+ Buffer GetBuffer() const MTLPP_AVAILABLE(10_12, 9_0);
+ uint32_t GetBufferOffset() const MTLPP_AVAILABLE(10_12, 9_0);
+ uint32_t GetBufferBytesPerRow() const MTLPP_AVAILABLE(10_12, 9_0);
+ //IOSurfaceRef GetIOSurface() const;
+ uint32_t GetIOSurfacePlane() const MTLPP_AVAILABLE_MAC(10_11);
+ TextureType GetTextureType() const;
+ PixelFormat GetPixelFormat() const;
+ uint32_t GetWidth() const;
+ uint32_t GetHeight() const;
+ uint32_t GetDepth() const;
+ uint32_t GetMipmapLevelCount() const;
+ uint32_t GetSampleCount() const;
+ uint32_t GetArrayLength() const;
+ TextureUsage GetUsage() const;
+ bool IsFrameBufferOnly() const;
+
+ void GetBytes(void* pixelBytes, uint32_t bytesPerRow, uint32_t bytesPerImage, const Region& fromRegion, uint32_t mipmapLevel, uint32_t slice);
+ void Replace(const Region& region, uint32_t mipmapLevel, uint32_t slice, void* pixelBytes, uint32_t bytesPerRow, uint32_t bytesPerImage);
+ void GetBytes(void* pixelBytes, uint32_t bytesPerRow, const Region& fromRegion, uint32_t mipmapLevel);
+ void Replace(const Region& region, uint32_t mipmapLevel, void* pixelBytes, uint32_t bytesPerRow);
+ Texture NewTextureView(PixelFormat pixelFormat);
+ Texture NewTextureView(PixelFormat pixelFormat, TextureType textureType, const ns::Range& mipmapLevelRange, const ns::Range& sliceRange);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: argument.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "texture.hpp"
+
+namespace mtlpp
+{
+ class StructType;
+ class ArrayType;
+
+ enum class DataType
+ {
+ None = 0,
+
+ Struct = 1,
+ Array = 2,
+
+ Float = 3,
+ Float2 = 4,
+ Float3 = 5,
+ Float4 = 6,
+
+ Float2x2 = 7,
+ Float2x3 = 8,
+ Float2x4 = 9,
+
+ Float3x2 = 10,
+ Float3x3 = 11,
+ Float3x4 = 12,
+
+ Float4x2 = 13,
+ Float4x3 = 14,
+ Float4x4 = 15,
+
+ Half = 16,
+ Half2 = 17,
+ Half3 = 18,
+ Half4 = 19,
+
+ Half2x2 = 20,
+ Half2x3 = 21,
+ Half2x4 = 22,
+
+ Half3x2 = 23,
+ Half3x3 = 24,
+ Half3x4 = 25,
+
+ Half4x2 = 26,
+ Half4x3 = 27,
+ Half4x4 = 28,
+
+ Int = 29,
+ Int2 = 30,
+ Int3 = 31,
+ Int4 = 32,
+
+ UInt = 33,
+ UInt2 = 34,
+ UInt3 = 35,
+ UInt4 = 36,
+
+ Short = 37,
+ Short2 = 38,
+ Short3 = 39,
+ Short4 = 40,
+
+ UShort = 41,
+ UShort2 = 42,
+ UShort3 = 43,
+ UShort4 = 44,
+
+ Char = 45,
+ Char2 = 46,
+ Char3 = 47,
+ Char4 = 48,
+
+ UChar = 49,
+ UChar2 = 50,
+ UChar3 = 51,
+ UChar4 = 52,
+
+ Bool = 53,
+ Bool2 = 54,
+ Bool3 = 55,
+ Bool4 = 56,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class ArgumentType
+ {
+ Buffer = 0,
+ ThreadgroupMemory = 1,
+ Texture = 2,
+ Sampler = 3,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class ArgumentAccess
+ {
+ ReadOnly = 0,
+ ReadWrite = 1,
+ WriteOnly = 2,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class StructMember : public ns::Object
+ {
+ public:
+ StructMember();
+ StructMember(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetName() const;
+ uint32_t GetOffset() const;
+ DataType GetDataType() const;
+
+ StructType GetStructType() const;
+ ArrayType GetArrayType() const;
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class StructType : public ns::Object
+ {
+ public:
+ StructType();
+ StructType(const ns::Handle& handle) : ns::Object(handle) { }
+
+ const ns::Array<StructMember> GetMembers() const;
+ StructMember GetMember(const ns::String& name) const;
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class ArrayType : public ns::Object
+ {
+ public:
+ ArrayType();
+ ArrayType(const ns::Handle& handle) : ns::Object(handle) { }
+
+ uint32_t GetArrayLength() const;
+ DataType GetElementType() const;
+ uint32_t GetStride() const;
+ StructType GetElementStructType() const;
+ ArrayType GetElementArrayType() const;
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class Argument : public ns::Object
+ {
+ public:
+ Argument();
+ Argument(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetName() const;
+ ArgumentType GetType() const;
+ ArgumentAccess GetAccess() const;
+ uint32_t GetIndex() const;
+
+ bool IsActive() const;
+
+ uint32_t GetBufferAlignment() const;
+ uint32_t GetBufferDataSize() const;
+ DataType GetBufferDataType() const;
+ StructType GetBufferStructType() const;
+
+ uint32_t GetThreadgroupMemoryAlignment() const;
+ uint32_t GetThreadgroupMemoryDataSize() const;
+
+ TextureType GetTextureType() const;
+ DataType GetTextureDataType() const;
+
+ bool IsDepthTexture() const MTLPP_AVAILABLE(10_12, 10_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+
+//////////////////////////////////////
+// FILE: library.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+// #include "argument.hpp"
+
+namespace mtlpp
+{
+ class Device;
+ class FunctionConstantValues;
+
+ enum class PatchType
+ {
+ None = 0,
+ Triangle = 1,
+ Quad = 2,
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ class VertexAttribute : public ns::Object
+ {
+ public:
+ VertexAttribute();
+ VertexAttribute(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetName() const;
+ uint32_t GetAttributeIndex() const;
+ DataType GetAttributeType() const MTLPP_AVAILABLE(10_11, 8_3);
+ bool IsActive() const;
+ bool IsPatchData() const MTLPP_AVAILABLE(10_12, 10_0);
+ bool IsPatchControlPointData() const MTLPP_AVAILABLE(10_12, 10_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class Attribute : public ns::Object
+ {
+ public:
+ Attribute();
+ Attribute(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetName() const;
+ uint32_t GetAttributeIndex() const;
+ DataType GetAttributeType() const MTLPP_AVAILABLE(10_11, 8_3);
+ bool IsActive() const;
+ bool IsPatchData() const MTLPP_AVAILABLE(10_12, 10_0);
+ bool IsPatchControlPointData() const MTLPP_AVAILABLE(10_12, 10_0);
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ enum class FunctionType
+ {
+ TypeVertex = 1,
+ TypeFragment = 2,
+ TypeKernel = 3,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class FunctionConstant : public ns::Object
+ {
+ public:
+ FunctionConstant();
+ FunctionConstant(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetName() const;
+ DataType GetType() const;
+ uint32_t GetIndex() const;
+ bool IsRequired() const;
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ class Function : public ns::Object
+ {
+ public:
+ Function(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const MTLPP_AVAILABLE(10_12, 10_0);
+ Device GetDevice() const;
+ FunctionType GetFunctionType() const;
+ PatchType GetPatchType() const MTLPP_AVAILABLE(10_12, 10_0);
+ int32_t GetPatchControlPointCount() const MTLPP_AVAILABLE(10_12, 10_0);
+ const ns::Array<VertexAttribute> GetVertexAttributes() const;
+ const ns::Array<Attribute> GetStageInputAttributes() const MTLPP_AVAILABLE(10_12, 10_0);
+ ns::String GetName() const;
+ ns::Dictionary<ns::String, FunctionConstant> GetFunctionConstants() const MTLPP_AVAILABLE(10_12, 10_0);
+
+ void SetLabel(const ns::String& label) MTLPP_AVAILABLE(10_12, 10_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class LanguageVersion
+ {
+ Version1_0 MTLPP_AVAILABLE(NA, 9_0) = (1 << 16),
+ Version1_1 MTLPP_AVAILABLE(10_11, 9_0) = (1 << 16) + 1,
+ Version1_2 MTLPP_AVAILABLE(10_12, 10_0) = (1 << 16) + 2,
+ }
+ MTLPP_AVAILABLE(10_11, 9_0);
+
+ class CompileOptions : public ns::Object
+ {
+ public:
+ CompileOptions();
+ CompileOptions(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::Dictionary<ns::String, ns::String> GetPreprocessorMacros() const;
+ bool IsFastMathEnabled() const;
+ LanguageVersion GetLanguageVersion() const MTLPP_AVAILABLE(10_11, 9_0);
+
+ void SetFastMathEnabled(bool fastMathEnabled);
+ void SetFastMathEnabled(LanguageVersion languageVersion);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class LibraryError
+ {
+ Unsupported = 1,
+ Internal = 2,
+ CompileFailure = 3,
+ CompileWarning = 4,
+ FunctionNotFound MTLPP_AVAILABLE(10_12, 10_0) = 5,
+ FileNotFound MTLPP_AVAILABLE(10_12, 10_0) = 6,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class RenderPipelineError
+ {
+ Internal = 1,
+ Unsupported = 2,
+ InvalidInput = 3,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class Library : public ns::Object
+ {
+ public:
+ Library() { }
+ Library(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const;
+ Device GetDevice() const;
+ ns::Array<ns::String> GetFunctionNames() const;
+
+ void SetLabel(const ns::String& label);
+
+ Function NewFunction(const ns::String& functionName);
+ Function NewFunction(const ns::String& functionName, const FunctionConstantValues& constantValues, ns::Error* error) MTLPP_AVAILABLE(10_12, 10_0);
+ void NewFunction(const ns::String& functionName, const FunctionConstantValues& constantValues, std::function<void(const Function&, const ns::Error&)> completionHandler) MTLPP_AVAILABLE(10_12, 10_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: device.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "types.hpp"
+// #include "pixel_format.hpp"
+// #include "resource.hpp"
+// #include "library.hpp"
+
+namespace mtlpp
+{
+ class CommandQueue;
+ class Device;
+ class Buffer;
+ class DepthStencilState;
+ class Function;
+ class Library;
+ class Texture;
+ class SamplerState;
+ class RenderPipelineState;
+ class ComputePipelineState;
+ class Heap;
+ class Fence;
+
+ class SamplerDescriptor;
+ class RenderPipelineColorAttachmentDescriptor;
+ class DepthStencilDescriptor;
+ class TextureDescriptor;
+ class CompileOptions;
+ class RenderPipelineDescriptor;
+ class RenderPassDescriptor;
+ class RenderPipelineReflection;
+ class ComputePipelineDescriptor;
+ class ComputePipelineReflection;
+ class CommandQueueDescriptor;
+ class HeapDescriptor;
+
+ enum class FeatureSet
+ {
+ iOS_GPUFamily1_v1 MTLPP_AVAILABLE_IOS(8_0) = 0,
+ iOS_GPUFamily2_v1 MTLPP_AVAILABLE_IOS(8_0) = 1,
+
+ iOS_GPUFamily1_v2 MTLPP_AVAILABLE_IOS(8_0) = 2,
+ iOS_GPUFamily2_v2 MTLPP_AVAILABLE_IOS(8_0) = 3,
+ iOS_GPUFamily3_v1 MTLPP_AVAILABLE_IOS(9_0) = 4,
+
+ iOS_GPUFamily1_v3 MTLPP_AVAILABLE_IOS(10_0) = 5,
+ iOS_GPUFamily2_v3 MTLPP_AVAILABLE_IOS(10_0) = 6,
+ iOS_GPUFamily3_v2 MTLPP_AVAILABLE_IOS(10_0) = 7,
+
+ OSX_GPUFamily1_v1 MTLPP_AVAILABLE_MAC(8_0) = 10000,
+
+ OSX_GPUFamily1_v2 MTLPP_AVAILABLE_MAC(10_12) = 10001,
+ OSX_ReadWriteTextureTier2 MTLPP_AVAILABLE_MAC(10_12) = 10002,
+
+ tvOS_GPUFamily1_v1 MTLPP_AVAILABLE_TVOS(9_0) = 30000,
+
+ tvOS_GPUFamily1_v2 MTLPP_AVAILABLE_TVOS(10_0) = 30001,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class PipelineOption
+ {
+ None = 0,
+ ArgumentInfo = 1 << 0,
+ BufferTypeInfo = 1 << 1,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ struct SizeAndAlign
+ {
+ uint32_t Size;
+ uint32_t Align;
+ };
+
+ class Device : public ns::Object
+ {
+ public:
+ Device() { }
+ Device(const ns::Handle& handle) : ns::Object(handle) { }
+
+ static Device CreateSystemDefaultDevice() MTLPP_AVAILABLE(10_11, 8_0);
+ static ns::Array<Device> CopyAllDevices() MTLPP_AVAILABLE(10_11, NA);
+
+ ns::String GetName() const;
+ Size GetMaxThreadsPerThreadgroup() const MTLPP_AVAILABLE(10_11, 9_0);
+ bool IsLowPower() const MTLPP_AVAILABLE_MAC(10_11);
+ bool IsHeadless() const MTLPP_AVAILABLE_MAC(10_11);
+ uint64_t GetRecommendedMaxWorkingSetSize() const MTLPP_AVAILABLE_MAC(10_12);
+ bool IsDepth24Stencil8PixelFormatSupported() const MTLPP_AVAILABLE_MAC(10_11);
+
+ CommandQueue NewCommandQueue();
+ CommandQueue NewCommandQueue(uint32_t maxCommandBufferCount);
+ SizeAndAlign HeapTextureSizeAndAlign(const TextureDescriptor& desc) MTLPP_AVAILABLE(NA, 10_0);
+ SizeAndAlign HeapBufferSizeAndAlign(uint32_t length, ResourceOptions options) MTLPP_AVAILABLE(NA, 10_0);
+ Heap NewHeap(const HeapDescriptor& descriptor) MTLPP_AVAILABLE(NA, 10_0);
+ Buffer NewBuffer(uint32_t length, ResourceOptions options);
+ Buffer NewBuffer(const void* pointer, uint32_t length, ResourceOptions options);
+ Buffer NewBuffer(void* pointer, uint32_t length, ResourceOptions options, std::function<void (void* pointer, uint32_t length)> deallocator);
+ DepthStencilState NewDepthStencilState(const DepthStencilDescriptor& descriptor);
+ Texture NewTexture(const TextureDescriptor& descriptor);
+ //- (id <MTLTexture>)newTextureWithDescriptor:(MTLTextureDescriptor *)descriptor iosurface:(IOSurfaceRef)iosurface plane:(NSUInteger)plane NS_AVAILABLE_MAC(10_11);
+ SamplerState NewSamplerState(const SamplerDescriptor& descriptor);
+ Library NewDefaultLibrary();
+ //- (nullable id <MTLLibrary>)newDefaultLibraryWithBundle:(NSBundle *)bundle error:(__autoreleasing NSError **)error NS_AVAILABLE(10_12, 10_0);
+ Library NewLibrary(const ns::String& filepath, ns::Error* error);
+ Library NewLibrary(const char* source, const CompileOptions& options, ns::Error* error);
+ void NewLibrary(const char* source, const CompileOptions& options, std::function<void(const Library&, const ns::Error&)> completionHandler);
+ RenderPipelineState NewRenderPipelineState(const RenderPipelineDescriptor& descriptor, ns::Error* error);
+ RenderPipelineState NewRenderPipelineState(const RenderPipelineDescriptor& descriptor, PipelineOption options, RenderPipelineReflection* outReflection, ns::Error* error);
+ void NewRenderPipelineState(const RenderPipelineDescriptor& descriptor, std::function<void(const RenderPipelineState&, const ns::Error&)> completionHandler);
+ void NewRenderPipelineState(const RenderPipelineDescriptor& descriptor, PipelineOption options, std::function<void(const RenderPipelineState&, const RenderPipelineReflection&, const ns::Error&)> completionHandler);
+ ComputePipelineState NewComputePipelineState(const Function& computeFunction, ns::Error* error);
+ ComputePipelineState NewComputePipelineState(const Function& computeFunction, PipelineOption options, ComputePipelineReflection& outReflection, ns::Error* error);
+ void NewComputePipelineState(const Function& computeFunction, std::function<void(const ComputePipelineState&, const ns::Error&)> completionHandler);
+ void NewComputePipelineState(const Function& computeFunction, PipelineOption options, std::function<void(const ComputePipelineState&, const ComputePipelineReflection&, const ns::Error&)> completionHandler);
+ ComputePipelineState NewComputePipelineState(const ComputePipelineDescriptor& descriptor, PipelineOption options, ComputePipelineReflection* outReflection, ns::Error* error);
+ void NewComputePipelineState(const ComputePipelineDescriptor& descriptor, PipelineOption options, std::function<void(const ComputePipelineState&, const ComputePipelineReflection&, const ns::Error&)> completionHandler) MTLPP_AVAILABLE(10_11, 9_0);
+ Fence NewFence() MTLPP_AVAILABLE(NA, 10_0);
+ bool SupportsFeatureSet(FeatureSet featureSet) const;
+ bool SupportsTextureSampleCount(uint32_t sampleCount) const MTLPP_AVAILABLE(10_11, 9_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: fence.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+// #include "device.hpp"
+
+
+namespace mtlpp
+{
+ class Fence : public ns::Object
+ {
+ public:
+ Fence(const ns::Handle& handle) : ns::Object(handle) { }
+
+ Texture GetDevice() const;
+ ns::String GetLabel() const;
+
+ void SetLabel(const ns::String& label);
+ }
+ MTLPP_AVAILABLE(NA, 10_0);
+}
+
+//////////////////////////////////////
+// FILE: blit_command_encoder.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "command_encoder.hpp"
+// #include "buffer.hpp"
+// #include "texture.hpp"
+// #include "fence.hpp"
+
+namespace mtlpp
+{
+ enum class BlitOption
+ {
+ None = 0,
+ DepthFromDepthStencil = 1 << 0,
+ StencilFromDepthStencil = 1 << 1,
+ RowLinearPVRTC MTLPP_AVAILABLE_IOS(9_0) = 1 << 2,
+ }
+ MTLPP_AVAILABLE(10_11, 9_0);
+
+ class BlitCommandEncoder : public ns::Object
+ {
+ public:
+ BlitCommandEncoder() { }
+ BlitCommandEncoder(const ns::Handle& handle) : ns::Object(handle) { }
+
+ void Synchronize(const Resource& resource) MTLPP_AVAILABLE_MAC(10_11);
+ void Synchronize(const Texture& texture, uint32_t slice, uint32_t level) MTLPP_AVAILABLE_MAC(10_11);
+ void Copy(const Texture& sourceTexture, uint32_t sourceSlice, uint32_t sourceLevel, const Origin& sourceOrigin, const Size& sourceSize, const Texture& destinationTexture, uint32_t destinationSlice, uint32_t destinationLevel, const Origin& destinationOrigin);
+ void Copy(const Buffer& sourceBuffer, uint32_t sourceOffset, uint32_t sourceBytesPerRow, uint32_t sourceBytesPerImage, const Size& sourceSize, const Texture& destinationTexture, uint32_t destinationSlice, uint32_t destinationLevel, const Origin& destinationOrigin);
+ void Copy(const Buffer& sourceBuffer, uint32_t sourceOffset, uint32_t sourceBytesPerRow, uint32_t sourceBytesPerImage, const Size& sourceSize, const Texture& destinationTexture, uint32_t destinationSlice, uint32_t destinationLevel, const Origin& destinationOrigin, BlitOption options);
+ void Copy(const Texture& sourceTexture, uint32_t sourceSlice, uint32_t sourceLevel, const Origin& sourceOrigin, const Size& sourceSize, const Buffer& destinationBuffer, uint32_t destinationOffset, uint32_t destinationBytesPerRow, uint32_t destinationBytesPerImage);
+ void Copy(const Texture& sourceTexture, uint32_t sourceSlice, uint32_t sourceLevel, const Origin& sourceOrigin, const Size& sourceSize, const Buffer& destinationBuffer, uint32_t destinationOffset, uint32_t destinationBytesPerRow, uint32_t destinationBytesPerImage, BlitOption options);
+ void Copy(const Buffer& sourceBuffer, uint32_t soruceOffset, const Buffer& destinationBuffer, uint32_t destinationOffset, uint32_t size);
+ void GenerateMipmaps(const Texture& texture);
+ void Fill(const Buffer& buffer, const ns::Range& range, uint8_t value);
+ void UpdateFence(const Fence& fence) MTLPP_AVAILABLE_IOS(10_0);
+ void WaitForFence(const Fence& fence) MTLPP_AVAILABLE_IOS(10_0);
+ };
+}
+
+//////////////////////////////////////
+// FILE: command_buffer.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+
+namespace mtlpp
+{
+ class Device;
+ class CommandQueue;
+ class BlitCommandEncoder;
+ class RenderCommandEncoder;
+ class ParallelRenderCommandEncoder;
+ class ComputeCommandEncoder;
+ class CommandQueue;
+ class Drawable;
+ class RenderPassDescriptor;
+
+ enum class CommandBufferStatus
+ {
+ NotEnqueued = 0,
+ Enqueued = 1,
+ Committed = 2,
+ Scheduled = 3,
+ Completed = 4,
+ Error = 5,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class CommandBufferError
+ {
+ None = 0,
+ Internal = 1,
+ Timeout = 2,
+ PageFault = 3,
+ Blacklisted = 4,
+ NotPermitted = 7,
+ OutOfMemory = 8,
+ InvalidResource = 9,
+ Memoryless MTLPP_AVAILABLE_IOS(10_0) = 10,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class CommandBuffer : public ns::Object
+ {
+ public:
+ CommandBuffer() { }
+ CommandBuffer(const ns::Handle& handle) : ns::Object(handle) { }
+
+ Device GetDevice() const;
+ CommandQueue GetCommandQueue() const;
+ bool GetRetainedReferences() const;
+ ns::String GetLabel() const;
+ CommandBufferStatus GetStatus() const;
+ ns::Error GetError() const;
+
+ void SetLabel(const ns::String& label);
+
+ void Enqueue();
+ void Commit();
+ void AddScheduledHandler(std::function<void(const CommandBuffer&)> handler);
+ void AddCompletedHandler(std::function<void(const CommandBuffer&)> handler);
+ void Present(const Drawable& drawable);
+ void Present(const Drawable& drawable, double presentationTime);
+ void WaitUntilScheduled();
+ void WaitUntilCompleted();
+ BlitCommandEncoder BlitCommandEncoder();
+ RenderCommandEncoder RenderCommandEncoder(const RenderPassDescriptor& renderPassDescriptor);
+ ComputeCommandEncoder ComputeCommandEncoder();
+ ParallelRenderCommandEncoder ParallelRenderCommandEncoder(const RenderPassDescriptor& renderPassDescriptor);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: compute_command_encoder.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+// #include "command_encoder.hpp"
+// #include "texture.hpp"
+// #include "command_buffer.hpp"
+// #include "fence.hpp"
+
+namespace mtlpp
+{
+ class ComputeCommandEncoder : public CommandEncoder
+ {
+ public:
+ ComputeCommandEncoder() { }
+ ComputeCommandEncoder(const ns::Handle& handle) : CommandEncoder(handle) { }
+
+ void SetComputePipelineState(const ComputePipelineState& state);
+ void SetBytes(const void* data, uint32_t length, uint32_t index);
+ void SetBuffer(const Buffer& buffer, uint32_t offset, uint32_t index);
+ void SetBufferOffset(uint32_t offset, uint32_t index) MTLPP_AVAILABLE(10_11, 8_3);
+ void SetBuffers(const Buffer* buffers, const uint32_t* offsets, const ns::Range& range);
+ void SetTexture(const Texture& texture, uint32_t index);
+ void SetTextures(const Texture* textures, const ns::Range& range);
+ void SetSamplerState(const SamplerState& sampler, uint32_t index);
+ void SetSamplerStates(const SamplerState* samplers, const ns::Range& range);
+ void SetSamplerState(const SamplerState& sampler, float lodMinClamp, float lodMaxClamp, uint32_t index);
+ void SetSamplerStates(const SamplerState* samplers, const float* lodMinClamps, const float* lodMaxClamps, const ns::Range& range);
+ void SetThreadgroupMemory(uint32_t length, uint32_t index);
+ void SetStageInRegion(const Region& region) MTLPP_AVAILABLE(10_12, 10_0);
+ void DispatchThreadgroups(const Size& threadgroupsPerGrid, const Size& threadsPerThreadgroup);
+ void DispatchThreadgroupsWithIndirectBuffer(const Buffer& indirectBuffer, uint32_t indirectBufferOffset, const Size& threadsPerThreadgroup);
+ void UpdateFence(const Fence& fence) MTLPP_AVAILABLE_IOS(10_0);
+ void WaitForFence(const Fence& fence) MTLPP_AVAILABLE_IOS(10_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: command_queue.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+
+namespace mtlpp
+{
+ class Device;
+ class CommandBuffer;
+
+ class CommandQueue : public ns::Object
+ {
+ public:
+ CommandQueue() { }
+ CommandQueue(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const;
+ Device GetDevice() const;
+
+ void SetLabel(const ns::String& label);
+
+ class CommandBuffer CommandBufferWithUnretainedReferences();
+ class CommandBuffer CommandBuffer();
+ void InsertDebugCaptureBoundary();
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: depth_stencil.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+// #include "device.hpp"
+
+namespace mtlpp
+{
+ enum class CompareFunction
+ {
+ Never = 0,
+ Less = 1,
+ Equal = 2,
+ LessEqual = 3,
+ Greater = 4,
+ NotEqual = 5,
+ GreaterEqual = 6,
+ Always = 7,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class StencilOperation
+ {
+ Keep = 0,
+ Zero = 1,
+ Replace = 2,
+ IncrementClamp = 3,
+ DecrementClamp = 4,
+ Invert = 5,
+ IncrementWrap = 6,
+ DecrementWrap = 7,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class StencilDescriptor : public ns::Object
+ {
+ public:
+ StencilDescriptor();
+ StencilDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ CompareFunction GetStencilCompareFunction() const;
+ StencilOperation GetStencilFailureOperation() const;
+ StencilOperation GetDepthFailureOperation() const;
+ StencilOperation GetDepthStencilPassOperation() const;
+ uint32_t GetReadMask() const;
+ uint32_t GetWriteMask() const;
+
+ void SetStencilCompareFunction(CompareFunction stencilCompareFunction);
+ void SetStencilFailureOperation(StencilOperation stencilFailureOperation);
+ void SetDepthFailureOperation(StencilOperation depthFailureOperation);
+ void SetDepthStencilPassOperation(StencilOperation depthStencilPassOperation);
+ void SetReadMask(uint32_t readMask);
+ void SetWriteMask(uint32_t writeMask);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class DepthStencilDescriptor : public ns::Object
+ {
+ public:
+ DepthStencilDescriptor();
+ DepthStencilDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ CompareFunction GetDepthCompareFunction() const;
+ bool IsDepthWriteEnabled() const;
+ StencilDescriptor GetFrontFaceStencil() const;
+ StencilDescriptor GetBackFaceStencil() const;
+ ns::String GetLabel() const;
+
+ void SetDepthCompareFunction(CompareFunction depthCompareFunction) const;
+ void SetDepthWriteEnabled(bool depthWriteEnabled) const;
+ void SetFrontFaceStencil(const StencilDescriptor& frontFaceStencil) const;
+ void SetBackFaceStencil(const StencilDescriptor& backFaceStencil) const;
+ void SetLabel(const ns::String& label) const;
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class DepthStencilState : public ns::Object
+ {
+ public:
+ DepthStencilState() { }
+ DepthStencilState(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const;
+ Device GetDevice() const;
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: drawable.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+
+namespace mtlpp
+{
+ class Drawable : public ns::Object
+ {
+ public:
+ Drawable() { }
+ Drawable(const ns::Handle& handle) : ns::Object(handle) { }
+
+ void Present();
+ void Present(double presentationTime);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+
+//////////////////////////////////////
+// FILE: render_pass.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+
+namespace mtlpp
+{
+ class Texture;
+ class Buffer;
+
+ enum class LoadAction
+ {
+ DontCare = 0,
+ Load = 1,
+ Clear = 2,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class StoreAction
+ {
+ DontCare = 0,
+ Store = 1,
+ MultisampleResolve = 2,
+ StoreAndMultisampleResolve MTLPP_AVAILABLE(10_12,10_0) = 3,
+ Unknown MTLPP_AVAILABLE(10_12,10_0) = 4,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class MultisampleDepthResolveFilter
+ {
+ Sample0 = 0,
+ Min = 1,
+ Max = 2,
+ }
+ MTLPP_AVAILABLE_IOS(9_0);
+
+ struct ClearColor
+ {
+ ClearColor(double red, double green, double blue, double alpha) :
+ Red(red),
+ Green(green),
+ Blue(blue),
+ Alpha(alpha) { }
+
+ double Red;
+ double Green;
+ double Blue;
+ double Alpha;
+ };
+
+ class RenderPassAttachmentDescriptor : public ns::Object
+ {
+ public:
+ RenderPassAttachmentDescriptor();
+ RenderPassAttachmentDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ Texture GetTexture() const;
+ uint32_t GetLevel() const;
+ uint32_t GetSlice() const;
+ uint32_t GetDepthPlane() const;
+ Texture GetResolveTexture() const;
+ uint32_t GetResolveLevel() const;
+ uint32_t GetResolveSlice() const;
+ uint32_t GetResolveDepthPlane() const;
+ LoadAction GetLoadAction() const;
+ StoreAction GetStoreAction() const;
+
+ void SetTexture(const Texture& texture);
+ void SetLevel(uint32_t level);
+ void SetSlice(uint32_t slice);
+ void SetDepthPlane(uint32_t depthPlane);
+ void SetResolveTexture(const Texture& texture);
+ void SetResolveLevel(uint32_t resolveLevel);
+ void SetResolveSlice(uint32_t resolveSlice);
+ void SetResolveDepthPlane(uint32_t resolveDepthPlane);
+ void SetLoadAction(LoadAction loadAction);
+ void SetStoreAction(StoreAction storeAction);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class RenderPassColorAttachmentDescriptor : public RenderPassAttachmentDescriptor
+ {
+ public:
+ RenderPassColorAttachmentDescriptor();
+ RenderPassColorAttachmentDescriptor(const ns::Handle& handle) : RenderPassAttachmentDescriptor(handle) { }
+
+ ClearColor GetClearColor() const;
+
+ void SetClearColor(const ClearColor& clearColor);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class RenderPassDepthAttachmentDescriptor : public RenderPassAttachmentDescriptor
+ {
+ public:
+ RenderPassDepthAttachmentDescriptor();
+ RenderPassDepthAttachmentDescriptor(const ns::Handle& handle) : RenderPassAttachmentDescriptor(handle) { }
+
+ double GetClearDepth() const;
+ MultisampleDepthResolveFilter GetDepthResolveFilter() const MTLPP_AVAILABLE_IOS(9_0);
+
+ void SetClearDepth(double clearDepth);
+ void SetDepthResolveFilter(MultisampleDepthResolveFilter depthResolveFilter) MTLPP_AVAILABLE_IOS(9_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class RenderPassStencilAttachmentDescriptor : public RenderPassAttachmentDescriptor
+ {
+ public:
+ RenderPassStencilAttachmentDescriptor();
+ RenderPassStencilAttachmentDescriptor(const ns::Handle& handle) : RenderPassAttachmentDescriptor(handle) { }
+
+ uint32_t GetClearStencil() const;
+
+ void SetClearStencil(uint32_t clearStencil);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class RenderPassDescriptor : public ns::Object
+ {
+ public:
+ RenderPassDescriptor();
+ RenderPassDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::Array<RenderPassColorAttachmentDescriptor> GetColorAttachments() const;
+ RenderPassDepthAttachmentDescriptor GetDepthAttachment() const;
+ RenderPassStencilAttachmentDescriptor GetStencilAttachment() const;
+ Buffer GetVisibilityResultBuffer() const;
+ uint32_t GetRenderTargetArrayLength() const MTLPP_AVAILABLE_MAC(10_11);
+
+ void SetDepthAttachment(const RenderPassDepthAttachmentDescriptor& depthAttachment);
+ void SetStencilAttachment(const RenderPassStencilAttachmentDescriptor& stencilAttachment);
+ void SetVisibilityResultBuffer(const Buffer& visibilityResultBuffer);
+ void SetRenderTargetArrayLength(uint32_t renderTargetArrayLength) MTLPP_AVAILABLE_MAC(10_11);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: stage_input_output_descriptor.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "device.hpp"
+
+namespace mtlpp
+{
+ enum class AttributeFormat
+ {
+ Invalid = 0,
+
+ UChar2 = 1,
+ UChar3 = 2,
+ UChar4 = 3,
+
+ Char2 = 4,
+ Char3 = 5,
+ Char4 = 6,
+
+ UChar2Normalized = 7,
+ UChar3Normalized = 8,
+ UChar4Normalized = 9,
+
+ Char2Normalized = 10,
+ Char3Normalized = 11,
+ Char4Normalized = 12,
+
+ UShort2 = 13,
+ UShort3 = 14,
+ UShort4 = 15,
+
+ Short2 = 16,
+ Short3 = 17,
+ Short4 = 18,
+
+ UShort2Normalized = 19,
+ UShort3Normalized = 20,
+ UShort4Normalized = 21,
+
+ Short2Normalized = 22,
+ Short3Normalized = 23,
+ Short4Normalized = 24,
+
+ Half2 = 25,
+ Half3 = 26,
+ Half4 = 27,
+
+ Float = 28,
+ Float2 = 29,
+ Float3 = 30,
+ Float4 = 31,
+
+ Int = 32,
+ Int2 = 33,
+ Int3 = 34,
+ Int4 = 35,
+
+ UInt = 36,
+ UInt2 = 37,
+ UInt3 = 38,
+ UInt4 = 39,
+
+ Int1010102Normalized = 40,
+ UInt1010102Normalized = 41,
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ enum class IndexType
+ {
+ UInt16 = 0,
+ UInt32 = 1,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+
+ enum class StepFunction
+ {
+ Constant = 0,
+
+ PerVertex = 1,
+ PerInstance = 2,
+ PerPatch MTLPP_AVAILABLE(10_12, 10_0) = 3,
+ PerPatchControlPoint MTLPP_AVAILABLE(10_12, 10_0) = 4,
+
+ ThreadPositionInGridX = 5,
+ ThreadPositionInGridY = 6,
+ ThreadPositionInGridXIndexed = 7,
+ ThreadPositionInGridYIndexed = 8,
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ class BufferLayoutDescriptor : public ns::Object
+ {
+ public:
+ BufferLayoutDescriptor();
+ BufferLayoutDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ uint32_t GetStride() const;
+ StepFunction GetStepFunction() const;
+ uint32_t GetStepRate() const;
+
+ void SetStride(uint32_t stride);
+ void SetStepFunction(StepFunction stepFunction);
+ void SetStepRate(uint32_t stepRate);
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ class AttributeDescriptor : public ns::Object
+ {
+ public:
+ AttributeDescriptor();
+ AttributeDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ AttributeFormat GetFormat() const;
+ uint32_t GetOffset() const;
+ uint32_t GetBufferIndex() const;
+
+ void SetFormat(AttributeFormat format);
+ void SetOffset(uint32_t offset);
+ void SetBufferIndex(uint32_t bufferIndex);
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ class StageInputOutputDescriptor : public ns::Object
+ {
+ public:
+ StageInputOutputDescriptor();
+ StageInputOutputDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+
+ ns::Array<BufferLayoutDescriptor> GetLayouts() const;
+ ns::Array<AttributeDescriptor> GetAttributes() const;
+ IndexType GetIndexType() const;
+ uint32_t GetIndexBufferIndex() const;
+
+ void SetIndexType(IndexType indexType);
+ void SetIndexBufferIndex(uint32_t indexBufferIndex);
+
+ void Reset();
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+}
+
+//////////////////////////////////////
+// FILE: compute_pipeline.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "device.hpp"
+// #include "argument.hpp"
+// #include "stage_input_output_descriptor.hpp"
+
+namespace mtlpp
+{
+ class ComputePipelineReflection : public ns::Object
+ {
+ public:
+ ComputePipelineReflection();
+ ComputePipelineReflection(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::Array<Argument> GetArguments() const;
+ }
+ MTLPP_AVAILABLE(10_11, 9_0);
+
+ class ComputePipelineDescriptor : public ns::Object
+ {
+ public:
+ ComputePipelineDescriptor();
+ ComputePipelineDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const;
+ Function GetComputeFunction() const;
+ bool GetThreadGroupSizeIsMultipleOfThreadExecutionWidth() const;
+ StageInputOutputDescriptor GetStageInputDescriptor() const MTLPP_AVAILABLE(10_12, 10_0);
+
+ void SetLabel(const ns::String& label);
+ void SetComputeFunction(const Function& function);
+ void SetThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool value);
+ void SetStageInputDescriptor(const StageInputOutputDescriptor& stageInputDescriptor) const MTLPP_AVAILABLE(10_12, 10_0);
+
+ void Reset();
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class ComputePipelineState : public ns::Object
+ {
+ public:
+ ComputePipelineState() { }
+ ComputePipelineState(const ns::Handle& handle) : ns::Object(handle) { }
+
+ Device GetDevice() const;
+ uint32_t GetMaxTotalThreadsPerThreadgroup() const;
+ uint32_t GetThreadExecutionWidth() const;
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: render_command_encoder.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "command_encoder.hpp"
+// #include "command_buffer.hpp"
+// #include "render_pass.hpp"
+// #include "fence.hpp"
+// #include "stage_input_output_descriptor.hpp"
+
+namespace mtlpp
+{
+ enum class PrimitiveType
+ {
+ Point = 0,
+ Line = 1,
+ LineStrip = 2,
+ Triangle = 3,
+ TriangleStrip = 4,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class VisibilityResultMode
+ {
+ Disabled = 0,
+ Boolean = 1,
+ Counting MTLPP_AVAILABLE(10_11, 9_0) = 2,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ struct ScissorRect
+ {
+ uint32_t X;
+ uint32_t Y;
+ uint32_t Width;
+ uint32_t Height;
+ };
+
+ struct Viewport
+ {
+ double OriginX;
+ double OriginY;
+ double Width;
+ double Height;
+ double ZNear;
+ double ZFar;
+ };
+
+ enum class CullMode
+ {
+ None = 0,
+ Front = 1,
+ Back = 2,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class Winding
+ {
+ Clockwise = 0,
+ CounterClockwise = 1,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class DepthClipMode
+ {
+ Clip = 0,
+ Clamp = 1,
+ }
+ MTLPP_AVAILABLE(10_11, 9_0);
+
+ enum class TriangleFillMode
+ {
+ Fill = 0,
+ Lines = 1,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ struct DrawPrimitivesIndirectArguments
+ {
+ uint32_t VertexCount;
+ uint32_t InstanceCount;
+ uint32_t VertexStart;
+ uint32_t BaseInstance;
+ };
+
+ struct DrawIndexedPrimitivesIndirectArguments
+ {
+ uint32_t IndexCount;
+ uint32_t InstanceCount;
+ uint32_t IndexStart;
+ int32_t BaseVertex;
+ uint32_t BaseInstance;
+ };
+
+ struct DrawPatchIndirectArguments
+ {
+ uint32_t PatchCount;
+ uint32_t InstanceCount;
+ uint32_t PatchStart;
+ uint32_t BaseInstance;
+ };
+
+ struct QuadTessellationFactorsHalf
+ {
+ uint16_t EdgeTessellationFactor[4];
+ uint16_t InsideTessellationFactor[2];
+ };
+
+ struct riangleTessellationFactorsHalf
+ {
+ uint16_t EdgeTessellationFactor[3];
+ uint16_t InsideTessellationFactor;
+ };
+
+ enum class RenderStages
+ {
+ Vertex = (1 << 0),
+ Fragment = (1 << 1),
+ }
+ MTLPP_AVAILABLE_IOS(10_0);
+
+
+ class RenderCommandEncoder : public CommandEncoder
+ {
+ public:
+ RenderCommandEncoder() { }
+ RenderCommandEncoder(const ns::Handle& handle) : CommandEncoder(handle) { }
+
+ void SetRenderPipelineState(const RenderPipelineState& pipelineState);
+ void SetVertexData(const void* bytes, uint32_t length, uint32_t index) MTLPP_AVAILABLE(10_11, 8_3);
+ void SetVertexBuffer(const Buffer& buffer, uint32_t offset, uint32_t index);
+ void SetVertexBufferOffset(uint32_t offset, uint32_t index) MTLPP_AVAILABLE(10_11, 8_3);
+ void SetVertexBuffers(const Buffer* buffers, const uint32_t* offsets, const ns::Range& range);
+ void SetVertexTexture(const Texture& texture, uint32_t index);
+ void SetVertexTextures(const Texture* textures, const ns::Range& range);
+ void SetVertexSamplerState(const SamplerState& sampler, uint32_t index);
+ void SetVertexSamplerStates(const SamplerState* samplers, const ns::Range& range);
+ void SetVertexSamplerState(const SamplerState& sampler, float lodMinClamp, float lodMaxClamp, uint32_t index);
+ void SetVertexSamplerStates(const SamplerState* samplers, const float* lodMinClamps, const float* lodMaxClamps, const ns::Range& range);
+ void SetViewport(const Viewport& viewport);
+ void SetFrontFacingWinding(Winding frontFacingWinding);
+ void SetCullMode(CullMode cullMode);
+ void SetDepthClipMode(DepthClipMode depthClipMode) MTLPP_AVAILABLE(10_11, NA);
+ void SetDepthBias(float depthBias, float slopeScale, float clamp);
+ void SetScissorRect(const ScissorRect& rect);
+ void SetTriangleFillMode(TriangleFillMode fillMode);
+ void SetFragmentData(const void* bytes, uint32_t length, uint32_t index);
+ void SetFragmentBuffer(const Buffer& buffer, uint32_t offset, uint32_t index);
+ void SetFragmentBufferOffset(uint32_t offset, uint32_t index) MTLPP_AVAILABLE(10_11, 8_3);
+ void SetFragmentBuffers(const Buffer* buffers, const uint32_t* offsets, const ns::Range& range);
+ void SetFragmentTexture(const Texture& texture, uint32_t index);
+ void SetFragmentTextures(const Texture* textures, const ns::Range& range);
+ void SetFragmentSamplerState(const SamplerState& sampler, uint32_t index);
+ void SetFragmentSamplerStates(const SamplerState* samplers, const ns::Range& range);
+ void SetFragmentSamplerState(const SamplerState& sampler, float lodMinClamp, float lodMaxClamp, uint32_t index);
+ void SetFragmentSamplerStates(const SamplerState* samplers, const float* lodMinClamps, const float* lodMaxClamps, const ns::Range& range);
+ void SetBlendColor(float red, float green, float blue, float alpha);
+ void SetDepthStencilState(const DepthStencilState& depthStencilState);
+ void SetStencilReferenceValue(uint32_t referenceValue);
+ void SetStencilReferenceValue(uint32_t frontReferenceValue, uint32_t backReferenceValue);
+ void SetVisibilityResultMode(VisibilityResultMode mode, uint32_t offset);
+ void SetColorStoreAction(StoreAction storeAction, uint32_t colorAttachmentIndex) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetDepthStoreAction(StoreAction storeAction) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetStencilStoreAction(StoreAction storeAction) MTLPP_AVAILABLE(10_12, 10_0);
+ void Draw(PrimitiveType primitiveType, uint32_t vertexStart, uint32_t vertexCount);
+ void Draw(PrimitiveType primitiveType, uint32_t vertexStart, uint32_t vertexCount, uint32_t instanceCount) MTLPP_AVAILABLE(10_11, 9_0);
+ void Draw(PrimitiveType primitiveType, uint32_t vertexStart, uint32_t vertexCount, uint32_t instanceCount, uint32_t baseInstance) MTLPP_AVAILABLE(10_11, 9_0);
+ void Draw(PrimitiveType primitiveType, Buffer indirectBuffer, uint32_t indirectBufferOffset);
+ void DrawIndexed(PrimitiveType primitiveType, uint32_t indexCount, IndexType indexType, const Buffer& indexBuffer, uint32_t indexBufferOffset);
+ void DrawIndexed(PrimitiveType primitiveType, uint32_t indexCount, IndexType indexType, const Buffer& indexBuffer, uint32_t indexBufferOffset, uint32_t instanceCount) MTLPP_AVAILABLE(10_11, 9_0);
+ void DrawIndexed(PrimitiveType primitiveType, uint32_t indexCount, IndexType indexType, const Buffer& indexBuffer, uint32_t indexBufferOffset, uint32_t instanceCount, uint32_t baseVertex, uint32_t baseInstance) MTLPP_AVAILABLE(10_11, 9_0);
+ void DrawIndexed(PrimitiveType primitiveType, IndexType indexType, const Buffer& indexBuffer, uint32_t indexBufferOffset, const Buffer& indirectBuffer, uint32_t indirectBufferOffset);
+ void TextureBarrier() MTLPP_AVAILABLE_MAC(10_11);
+ void UpdateFence(const Fence& fence, RenderStages afterStages) MTLPP_AVAILABLE_IOS(10_0);
+ void WaitForFence(const Fence& fence, RenderStages beforeStages) MTLPP_AVAILABLE_IOS(10_0);
+ void SetTessellationFactorBuffer(const Buffer& buffer, uint32_t offset, uint32_t instanceStride) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetTessellationFactorScale(float scale) MTLPP_AVAILABLE(10_12, 10_0);
+ void DrawPatches(uint32_t numberOfPatchControlPoints, uint32_t patchStart, uint32_t patchCount, const Buffer& patchIndexBuffer, uint32_t patchIndexBufferOffset, uint32_t instanceCount, uint32_t baseInstance) MTLPP_AVAILABLE(10_12, 10_0);
+ void DrawPatches(uint32_t numberOfPatchControlPoints, const Buffer& patchIndexBuffer, uint32_t patchIndexBufferOffset, const Buffer& indirectBuffer, uint32_t indirectBufferOffset) MTLPP_AVAILABLE(10_12, NA);
+ void DrawIndexedPatches(uint32_t numberOfPatchControlPoints, uint32_t patchStart, uint32_t patchCount, const Buffer& patchIndexBuffer, uint32_t patchIndexBufferOffset, const Buffer& controlPointIndexBuffer, uint32_t controlPointIndexBufferOffset, uint32_t instanceCount, uint32_t baseInstance) MTLPP_AVAILABLE(10_12, 10_0);
+ void DrawIndexedPatches(uint32_t numberOfPatchControlPoints, const Buffer& patchIndexBuffer, uint32_t patchIndexBufferOffset, const Buffer& controlPointIndexBuffer, uint32_t controlPointIndexBufferOffset, const Buffer& indirectBuffer, uint32_t indirectBufferOffset) MTLPP_AVAILABLE(10_12, NA);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+
+//////////////////////////////////////
+// FILE: function_constant_values.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+// #include "argument.hpp"
+
+namespace mtlpp
+{
+ class FunctionConstantValues : public ns::Object
+ {
+ public:
+ FunctionConstantValues();
+ FunctionConstantValues(const ns::Handle& handle) : ns::Object(handle) { }
+
+ void SetConstantValue(const void* value, DataType type, uint32_t index);
+ void SetConstantValue(const void* value, DataType type, const ns::String& name);
+ void SetConstantValues(const void* value, DataType type, const ns::Range& range);
+
+ void Reset();
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+}
+
+//////////////////////////////////////
+// FILE: render_pipeline.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "device.hpp"
+// #include "render_command_encoder.hpp"
+// #include "render_pass.hpp"
+// #include "pixel_format.hpp"
+// #include "argument.hpp"
+// #include "function_constant_values.hpp"
+
+namespace mtlpp
+{
+ class VertexDescriptor;
+
+ enum class BlendFactor
+ {
+ Zero = 0,
+ One = 1,
+ SourceColor = 2,
+ OneMinusSourceColor = 3,
+ SourceAlpha = 4,
+ OneMinusSourceAlpha = 5,
+ DestinationColor = 6,
+ OneMinusDestinationColor = 7,
+ DestinationAlpha = 8,
+ OneMinusDestinationAlpha = 9,
+ SourceAlphaSaturated = 10,
+ BlendColor = 11,
+ OneMinusBlendColor = 12,
+ BlendAlpha = 13,
+ OneMinusBlendAlpha = 14,
+ Source1Color MTLPP_AVAILABLE_MAC(10_12) = 15,
+ OneMinusSource1Color MTLPP_AVAILABLE_MAC(10_12) = 16,
+ Source1Alpha MTLPP_AVAILABLE_MAC(10_12) = 17,
+ OneMinusSource1Alpha MTLPP_AVAILABLE_MAC(10_12) = 18,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class BlendOperation
+ {
+ Add = 0,
+ Subtract = 1,
+ ReverseSubtract = 2,
+ Min = 3,
+ Max = 4,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class ColorWriteMask
+ {
+ None = 0,
+ Red = 0x1 << 3,
+ Green = 0x1 << 2,
+ Blue = 0x1 << 1,
+ Alpha = 0x1 << 0,
+ All = 0xf
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class PrimitiveTopologyClass
+ {
+ Unspecified = 0,
+ Point = 1,
+ Line = 2,
+ Triangle = 3,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class TessellationPartitionMode
+ {
+ ModePow2 = 0,
+ ModeInteger = 1,
+ ModeFractionalOdd = 2,
+ ModeFractionalEven = 3,
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ enum class TessellationFactorStepFunction
+ {
+ Constant = 0,
+ PerPatch = 1,
+ PerInstance = 2,
+ PerPatchAndPerInstance = 3,
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ enum class TessellationFactorFormat
+ {
+ Half = 0,
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ enum class TessellationControlPointIndexType
+ {
+ None = 0,
+ UInt16 = 1,
+ UInt32 = 2,
+ }
+ MTLPP_AVAILABLE(10_12, 10_0);
+
+ class RenderPipelineColorAttachmentDescriptor : public ns::Object
+ {
+ public:
+ RenderPipelineColorAttachmentDescriptor();
+ RenderPipelineColorAttachmentDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ PixelFormat GetPixelFormat() const;
+ bool IsBlendingEnabled() const;
+ BlendFactor GetSourceRgbBlendFactor() const;
+ BlendFactor GetDestinationRgbBlendFactor() const;
+ BlendOperation GetRgbBlendOperation() const;
+ BlendFactor GetSourceAlphaBlendFactor() const;
+ BlendFactor GetDestinationAlphaBlendFactor() const;
+ BlendOperation GetAlphaBlendOperation() const;
+ ColorWriteMask GetWriteMask() const;
+
+ void SetPixelFormat(PixelFormat pixelFormat);
+ void SetBlendingEnabled(bool blendingEnabled);
+ void SetSourceRgbBlendFactor(BlendFactor sourceRgbBlendFactor);
+ void SetDestinationRgbBlendFactor(BlendFactor destinationRgbBlendFactor);
+ void SetRgbBlendOperation(BlendOperation rgbBlendOperation);
+ void SetSourceAlphaBlendFactor(BlendFactor sourceAlphaBlendFactor);
+ void SetDestinationAlphaBlendFactor(BlendFactor destinationAlphaBlendFactor);
+ void SetAlphaBlendOperation(BlendOperation alphaBlendOperation);
+ void SetWriteMask(ColorWriteMask writeMask);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class RenderPipelineReflection : public ns::Object
+ {
+ public:
+ RenderPipelineReflection();
+ RenderPipelineReflection(const ns::Handle& handle) : ns::Object(handle) { }
+
+ const ns::Array<Argument> GetVertexArguments() const;
+ const ns::Array<Argument> GetFragmentArguments() const;
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class RenderPipelineDescriptor : public ns::Object
+ {
+ public:
+ RenderPipelineDescriptor();
+ RenderPipelineDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const;
+ Function GetVertexFunction() const;
+ Function GetFragmentFunction() const;
+ VertexDescriptor GetVertexDescriptor() const;
+ uint32_t GetSampleCount() const;
+ bool IsAlphaToCoverageEnabled() const;
+ bool IsAlphaToOneEnabled() const;
+ bool IsRasterizationEnabled() const;
+ ns::Array<RenderPipelineColorAttachmentDescriptor> GetColorAttachments() const;
+ PixelFormat GetDepthAttachmentPixelFormat() const;
+ PixelFormat GetStencilAttachmentPixelFormat() const;
+ PrimitiveTopologyClass GetInputPrimitiveTopology() const MTLPP_AVAILABLE_MAC(10_11);
+ TessellationPartitionMode GetTessellationPartitionMode() const MTLPP_AVAILABLE(10_12, 10_0);
+ uint32_t GetMaxTessellationFactor() const MTLPP_AVAILABLE(10_12, 10_0);
+ bool IsTessellationFactorScaleEnabled() const MTLPP_AVAILABLE(10_12, 10_0);
+ TessellationFactorFormat GetTessellationFactorFormat() const MTLPP_AVAILABLE(10_12, 10_0);
+ TessellationControlPointIndexType GetTessellationControlPointIndexType() const MTLPP_AVAILABLE(10_12, 10_0);
+ TessellationFactorStepFunction GetTessellationFactorStepFunction() const MTLPP_AVAILABLE(10_12, 10_0);
+ Winding GetTessellationOutputWindingOrder() const MTLPP_AVAILABLE(10_12, 10_0);
+
+
+ void SetLabel(const ns::String& label);
+ void SetVertexFunction(const Function& vertexFunction);
+ void SetFragmentFunction(const Function& fragmentFunction);
+ void SetVertexDescriptor(const VertexDescriptor& vertexDescriptor);
+ void SetSampleCount(uint32_t sampleCount);
+ void SetAlphaToCoverageEnabled(bool alphaToCoverageEnabled);
+ void SetAlphaToOneEnabled(bool alphaToOneEnabled);
+ void SetRasterizationEnabled(bool rasterizationEnabled);
+ void SetDepthAttachmentPixelFormat(PixelFormat depthAttachmentPixelFormat);
+ void SetStencilAttachmentPixelFormat(PixelFormat stencilAttachmentPixelFormat);
+ void SetInputPrimitiveTopology(PrimitiveTopologyClass inputPrimitiveTopology) MTLPP_AVAILABLE_MAC(10_11);
+ void SetTessellationPartitionMode(TessellationPartitionMode tessellationPartitionMode) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetMaxTessellationFactor(uint32_t maxTessellationFactor) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetTessellationFactorScaleEnabled(bool tessellationFactorScaleEnabled) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetTessellationFactorFormat(TessellationFactorFormat tessellationFactorFormat) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetTessellationControlPointIndexType(TessellationControlPointIndexType tessellationControlPointIndexType) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetTessellationFactorStepFunction(TessellationFactorStepFunction tessellationFactorStepFunction) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetTessellationOutputWindingOrder(Winding tessellationOutputWindingOrder) MTLPP_AVAILABLE(10_12, 10_0);
+
+ void Reset();
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class RenderPipelineState : public ns::Object
+ {
+ public:
+ RenderPipelineState() { }
+ RenderPipelineState(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const;
+ Device GetDevice() const;
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: vertex_descriptor.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+
+namespace mtlpp
+{
+ enum class VertexFormat
+ {
+ Invalid = 0,
+
+ UChar2 = 1,
+ UChar3 = 2,
+ UChar4 = 3,
+
+ Char2 = 4,
+ Char3 = 5,
+ Char4 = 6,
+
+ UChar2Normalized = 7,
+ UChar3Normalized = 8,
+ UChar4Normalized = 9,
+
+ Char2Normalized = 10,
+ Char3Normalized = 11,
+ Char4Normalized = 12,
+
+ UShort2 = 13,
+ UShort3 = 14,
+ UShort4 = 15,
+
+ Short2 = 16,
+ Short3 = 17,
+ Short4 = 18,
+
+ UShort2Normalized = 19,
+ UShort3Normalized = 20,
+ UShort4Normalized = 21,
+
+ Short2Normalized = 22,
+ Short3Normalized = 23,
+ Short4Normalized = 24,
+
+ Half2 = 25,
+ Half3 = 26,
+ Half4 = 27,
+
+ Float = 28,
+ Float2 = 29,
+ Float3 = 30,
+ Float4 = 31,
+
+ Int = 32,
+ Int2 = 33,
+ Int3 = 34,
+ Int4 = 35,
+
+ UInt = 36,
+ UInt2 = 37,
+ UInt3 = 38,
+ UInt4 = 39,
+
+ Int1010102Normalized = 40,
+ UInt1010102Normalized = 41,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class VertexStepFunction
+ {
+ Constant = 0,
+ PerVertex = 1,
+ PerInstance = 2,
+ PerPatch MTLPP_AVAILABLE(10_12, 10_0) = 3,
+ PerPatchControlPoint MTLPP_AVAILABLE(10_12, 10_0) = 4,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class VertexBufferLayoutDescriptor : public ns::Object
+ {
+ public:
+ VertexBufferLayoutDescriptor();
+ VertexBufferLayoutDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ uint32_t GetStride() const;
+ VertexStepFunction GetStepFunction() const;
+ uint32_t GetStepRate() const;
+
+ void SetStride(uint32_t stride);
+ void SetStepFunction(VertexStepFunction stepFunction);
+ void SetStepRate(uint32_t stepRate);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class VertexAttributeDescriptor : public ns::Object
+ {
+ public:
+ VertexAttributeDescriptor();
+ VertexAttributeDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ VertexFormat GetFormat() const;
+ uint32_t GetOffset() const;
+ uint32_t GetBufferIndex() const;
+
+ void SetFormat(VertexFormat format);
+ void SetOffset(uint32_t offset);
+ void SetBufferIndex(uint32_t bufferIndex);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class VertexDescriptor : public ns::Object
+ {
+ public:
+ VertexDescriptor();
+ VertexDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::Array<VertexBufferLayoutDescriptor> GetLayouts() const;
+ ns::Array<VertexAttributeDescriptor> GetAttributes() const;
+
+ void Reset();
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+//////////////////////////////////////
+// FILE: parallel_render_command_encoder.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+// #include "render_pass.hpp"
+// #include "command_encoder.hpp"
+
+namespace mtlpp
+{
+ class RenderCommandEncoder;
+
+ class ParallelRenderCommandEncoder : public ns::Object
+ {
+ public:
+ ParallelRenderCommandEncoder() { }
+ ParallelRenderCommandEncoder(const ns::Handle& handle) : ns::Object(handle) { }
+
+ RenderCommandEncoder GetRenderCommandEncoder();
+
+ void SetColorStoreAction(StoreAction storeAction, uint32_t colorAttachmentIndex) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetDepthStoreAction(StoreAction storeAction) MTLPP_AVAILABLE(10_12, 10_0);
+ void SetStencilStoreAction(StoreAction storeAction) MTLPP_AVAILABLE(10_12, 10_0);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+
+//////////////////////////////////////
+// FILE: sampler.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "depth_stencil.hpp"
+// #include "device.hpp"
+
+namespace mtlpp
+{
+ enum class SamplerMinMagFilter
+ {
+ Nearest = 0,
+ Linear = 1,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class SamplerMipFilter
+ {
+ NotMipmapped = 0,
+ Nearest = 1,
+ Linear = 2,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class SamplerAddressMode
+ {
+ ClampToEdge = 0,
+ MirrorClampToEdge MTLPP_AVAILABLE_MAC(10_11) = 1,
+ Repeat = 2,
+ MirrorRepeat = 3,
+ ClampToZero = 4,
+ ClampToBorderColor MTLPP_AVAILABLE_MAC(10_12) = 5,
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ enum class SamplerBorderColor
+ {
+ TransparentBlack = 0, // {0,0,0,0}
+ OpaqueBlack = 1, // {0,0,0,1}
+ OpaqueWhite = 2, // {1,1,1,1}
+ };
+
+ class SamplerDescriptor : public ns::Object
+ {
+ public:
+ SamplerDescriptor();
+ SamplerDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ SamplerMinMagFilter GetMinFilter() const;
+ SamplerMinMagFilter GetMagFilter() const;
+ SamplerMipFilter GetMipFilter() const;
+ uint32_t GetMaxAnisotropy() const;
+ SamplerAddressMode GetSAddressMode() const;
+ SamplerAddressMode GetTAddressMode() const;
+ SamplerAddressMode GetRAddressMode() const;
+ SamplerBorderColor GetBorderColor() const MTLPP_AVAILABLE_MAC(10_12);
+ bool IsNormalizedCoordinates() const;
+ float GetLodMinClamp() const;
+ float GetLodMaxClamp() const;
+ CompareFunction GetCompareFunction() const MTLPP_AVAILABLE(10_11, 9_0);
+ ns::String GetLabel() const;
+
+ void SetMinFilter(SamplerMinMagFilter minFilter);
+ void SetMagFilter(SamplerMinMagFilter magFilter);
+ void SetMipFilter(SamplerMipFilter mipFilter);
+ void SetMaxAnisotropy(uint32_t maxAnisotropy);
+ void SetSAddressMode(SamplerAddressMode sAddressMode);
+ void SetTAddressMode(SamplerAddressMode tAddressMode);
+ void SetRAddressMode(SamplerAddressMode rAddressMode);
+ void SetBorderColor(SamplerBorderColor borderColor) MTLPP_AVAILABLE_MAC(10_12);
+ void SetNormalizedCoordinates(bool normalizedCoordinates);
+ void SetLodMinClamp(float lodMinClamp);
+ void SetLodMaxClamp(float lodMaxClamp);
+ void SetCompareFunction(CompareFunction compareFunction) MTLPP_AVAILABLE(10_11, 9_0);
+ void SetLabel(const ns::String& label);
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+
+ class SamplerState : public ns::Object
+ {
+ public:
+ SamplerState() { }
+ SamplerState(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const;
+ Device GetDevice() const;
+ }
+ MTLPP_AVAILABLE(10_11, 8_0);
+}
+
+
+//////////////////////////////////////
+// FILE: heap.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "ns.hpp"
+// #include "device.hpp"
+// #include "resource.hpp"
+// #include "buffer.hpp"
+// #include "texture.hpp"
+// #include "types.hpp"
+
+namespace mtlpp
+{
+ class HeapDescriptor : public ns::Object
+ {
+ public:
+ HeapDescriptor(const ns::Handle& handle) : ns::Object(handle) { }
+
+ uint32_t GetSize() const;
+ StorageMode GetStorageMode() const;
+ CpuCacheMode GetCpuCacheMode() const;
+
+ void SetSize(uint32_t size) const;
+ void SetStorageMode(StorageMode storageMode) const;
+ void SetCpuCacheMode(CpuCacheMode cpuCacheMode) const;
+ }
+ MTLPP_AVAILABLE(NA, 10_0);
+
+ class Heap : public ns::Object
+ {
+ public:
+ Heap(const ns::Handle& handle) : ns::Object(handle) { }
+
+ ns::String GetLabel() const;
+ Device GetDevice() const;
+ StorageMode GetStorageMode() const;
+ CpuCacheMode GetCpuCacheMode() const;
+ uint32_t GetSize() const;
+ uint32_t GetUsedSize() const;
+
+ void SetLabel(const ns::String& label);
+
+ uint32_t MaxAvailableSizeWithAlignment(uint32_t alignment);
+ Buffer NewBuffer(uint32_t length, ResourceOptions options);
+ Texture NewTexture(const TextureDescriptor& desc);
+ PurgeableState SetPurgeableState(PurgeableState state);
+ }
+ MTLPP_AVAILABLE(NA, 10_0);
+}
+
+//////////////////////////////////////
+// FILE: mtlpp.hpp
+//////////////////////////////////////
+/*
+ * Copyright 2016 Nikolay Aleksiev. All rights reserved.
+ * License: https://github.com/naleksiev/mtlpp/blob/master/LICENSE
+ */
+
+// #pragma once
+
+// #include "defines.hpp"
+// #include "blit_command_encoder.hpp"
+// #include "buffer.hpp"
+// #include "command_buffer.hpp"
+// #include "compute_command_encoder.hpp"
+// #include "command_queue.hpp"
+// #include "device.hpp"
+// #include "depth_stencil.hpp"
+// #include "drawable.hpp"
+// #include "render_pass.hpp"
+// #include "compute_pipeline.hpp"
+// #include "library.hpp"
+// #include "pixel_format.hpp"
+// #include "render_pipeline.hpp"
+// #include "vertex_descriptor.hpp"
+// #include "parallel_render_command_encoder.hpp"
+// #include "render_command_encoder.hpp"
+// #include "sampler.hpp"
+// #include "texture.hpp"
+// #include "heap.hpp"
+