mirrors/bgfx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c6d99b4809
bgfx/3rdparty/mtlpp/mtlpp.hpp
Branimir Karadžić 1aad048a56 Added mtlpp.
2016-11-17 00:06:02 -08:00

2707 lines
94 KiB
C++
Raw Blame History

/*
* 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"
Reference in New Issue View Git Blame Copy Permalink