mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-06-05 06:03:34 +00:00
Format: src/{common, utils, wire}
This commit is contained in:
parent
a351ce9618
commit
9d01c6c26d
@ -16,7 +16,11 @@
|
||||
|
||||
#include <iostream>
|
||||
|
||||
void HandleAssertionFailure(const char* file, const char* function, int line, const char* condition) {
|
||||
std::cerr << "Assertion failure at " << file << ":" << line << " (" << function << "): " << condition << std::endl;
|
||||
void HandleAssertionFailure(const char* file,
|
||||
const char* function,
|
||||
int line,
|
||||
const char* condition) {
|
||||
std::cerr << "Assertion failure at " << file << ":" << line << " (" << function
|
||||
<< "): " << condition << std::endl;
|
||||
NXT_BREAKPOINT();
|
||||
}
|
||||
|
@ -17,63 +17,64 @@
|
||||
|
||||
#include "common/Compiler.h"
|
||||
|
||||
void HandleAssertionFailure(const char* file, const char* function, int line, const char* condition);
|
||||
// NXT asserts to be used instead of the regular C stdlib assert function (if you don't use assert
|
||||
// yet, you should start now!). In debug ASSERT(condition) will trigger an error, otherwise in
|
||||
// release it does nothing at runtime.
|
||||
//
|
||||
// In case of name clashes (with for example a testing library), you can define the
|
||||
// NXT_SKIP_ASSERT_SHORTHANDS to only define the NXT_ prefixed macros.
|
||||
//
|
||||
// These asserts feature:
|
||||
// - Logging of the error with file, line and function information.
|
||||
// - Breaking in the debugger when an assert is triggered and a debugger is attached.
|
||||
// - Use the assert information to help the compiler optimizer in release builds.
|
||||
|
||||
/*
|
||||
* NXT asserts to be used instead of the regular C stdlib assert function (if you don't
|
||||
* use assert yet, you should start now!). In debug ASSERT(condition) will trigger an error,
|
||||
* otherwise in release it does nothing at runtime.
|
||||
*
|
||||
* In case of name clashes (with for example a testing library), you can define the
|
||||
* NXT_SKIP_ASSERT_SHORTHANDS to only define the NXT_ prefixed macros.
|
||||
*
|
||||
* These asserts feature:
|
||||
* - Logging of the error with file, line and function information.
|
||||
* - Breaking in the debugger when an assert is triggered and a debugger is attached.
|
||||
* - Use the assert information to help the compiler optimizer in release builds.
|
||||
*/
|
||||
|
||||
// MSVC triggers a warning in /W4 for do {} while(0). SDL worked around this by using
|
||||
// // (0,0) and points out that it looks like an owl face.
|
||||
// MSVC triggers a warning in /W4 for do {} while(0). SDL worked around this by using (0,0) and
|
||||
// points out that it looks like an owl face.
|
||||
#if defined(NXT_COMPILER_MSVC)
|
||||
#define NXT_ASSERT_LOOP_CONDITION (0,0)
|
||||
# define NXT_ASSERT_LOOP_CONDITION (0, 0)
|
||||
#else
|
||||
#define NXT_ASSERT_LOOP_CONDITION (0)
|
||||
# define NXT_ASSERT_LOOP_CONDITION (0)
|
||||
#endif
|
||||
|
||||
// NXT_ASSERT_CALLSITE_HELPER generates the actual assert code. In Debug it does what you would
|
||||
// expect of an assert and in release it tries to give hints to make the compiler generate better code.
|
||||
// expect of an assert and in release it tries to give hints to make the compiler generate better
|
||||
// code.
|
||||
#if defined(NXT_ENABLE_ASSERTS)
|
||||
#define NXT_ASSERT_CALLSITE_HELPER(file, func, line, condition) \
|
||||
do { \
|
||||
if (!(condition)) { \
|
||||
# define NXT_ASSERT_CALLSITE_HELPER(file, func, line, condition) \
|
||||
do { \
|
||||
if (!(condition)) { \
|
||||
HandleAssertionFailure(file, func, line, #condition); \
|
||||
} \
|
||||
} while(NXT_ASSERT_LOOP_CONDITION)
|
||||
} \
|
||||
} while (NXT_ASSERT_LOOP_CONDITION)
|
||||
#else
|
||||
#if defined(NXT_COMPILER_MSVC)
|
||||
#define NXT_ASSERT_CALLSITE_HELPER(file, func, line, condition) \
|
||||
__assume(condition)
|
||||
#elif defined(NXT_COMPILER_CLANG) && defined(__builtin_assume)
|
||||
#define NXT_ASSERT_CALLSITE_HELPER(file, func, line, condition) \
|
||||
__builtin_assume(condition)
|
||||
#else
|
||||
#define NXT_ASSERT_CALLSITE_HELPER(file, func, line, condition) \
|
||||
do { \
|
||||
(void) sizeof(condition); \
|
||||
} while(NXT_ASSERT_LOOP_CONDITION)
|
||||
#endif
|
||||
# if defined(NXT_COMPILER_MSVC)
|
||||
# define NXT_ASSERT_CALLSITE_HELPER(file, func, line, condition) __assume(condition)
|
||||
# elif defined(NXT_COMPILER_CLANG) && defined(__builtin_assume)
|
||||
# define NXT_ASSERT_CALLSITE_HELPER(file, func, line, condition) __builtin_assume(condition)
|
||||
# else
|
||||
# define NXT_ASSERT_CALLSITE_HELPER(file, func, line, condition) \
|
||||
do { \
|
||||
(void)sizeof(condition); \
|
||||
} while (NXT_ASSERT_LOOP_CONDITION)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#define NXT_ASSERT(condition) NXT_ASSERT_CALLSITE_HELPER(__FILE__, __func__, __LINE__, condition)
|
||||
#define NXT_UNREACHABLE() \
|
||||
do { \
|
||||
NXT_ASSERT(NXT_ASSERT_LOOP_CONDITION && "Unreachable code hit"); NXT_BUILTIN_UNREACHABLE(); \
|
||||
} while(NXT_ASSERT_LOOP_CONDITION)
|
||||
#define NXT_UNREACHABLE() \
|
||||
do { \
|
||||
NXT_ASSERT(NXT_ASSERT_LOOP_CONDITION && "Unreachable code hit"); \
|
||||
NXT_BUILTIN_UNREACHABLE(); \
|
||||
} while (NXT_ASSERT_LOOP_CONDITION)
|
||||
|
||||
#if !defined(NXT_SKIP_ASSERT_SHORTHANDS)
|
||||
#define ASSERT NXT_ASSERT
|
||||
#define UNREACHABLE NXT_UNREACHABLE
|
||||
# define ASSERT NXT_ASSERT
|
||||
# define UNREACHABLE NXT_UNREACHABLE
|
||||
#endif
|
||||
|
||||
#endif // COMMON_ASSERT_H_
|
||||
void HandleAssertionFailure(const char* file,
|
||||
const char* function,
|
||||
int line,
|
||||
const char* condition);
|
||||
|
||||
#endif // COMMON_ASSERT_H_
|
||||
|
@ -21,7 +21,6 @@
|
||||
#include <bitset>
|
||||
#include <limits>
|
||||
|
||||
|
||||
// This is ANGLE's BitSetIterator class with a customizable return type
|
||||
// TODO(cwallez@chromium.org): it could be optimized, in particular when N <= 64
|
||||
|
||||
@ -33,44 +32,48 @@ T roundUp(const T value, const T alignment) {
|
||||
|
||||
template <size_t N, typename T>
|
||||
class BitSetIterator final {
|
||||
public:
|
||||
BitSetIterator(const std::bitset<N>& bitset);
|
||||
BitSetIterator(const BitSetIterator& other);
|
||||
BitSetIterator &operator=(const BitSetIterator& other);
|
||||
public:
|
||||
BitSetIterator(const std::bitset<N>& bitset);
|
||||
BitSetIterator(const BitSetIterator& other);
|
||||
BitSetIterator& operator=(const BitSetIterator& other);
|
||||
|
||||
class Iterator final {
|
||||
public:
|
||||
Iterator(const std::bitset<N>& bits);
|
||||
Iterator& operator++();
|
||||
class Iterator final {
|
||||
public:
|
||||
Iterator(const std::bitset<N>& bits);
|
||||
Iterator& operator++();
|
||||
|
||||
bool operator==(const Iterator& other) const;
|
||||
bool operator!=(const Iterator& other) const;
|
||||
T operator*() const { return static_cast<T>(mCurrentBit); }
|
||||
bool operator==(const Iterator& other) const;
|
||||
bool operator!=(const Iterator& other) const;
|
||||
T operator*() const {
|
||||
return static_cast<T>(mCurrentBit);
|
||||
}
|
||||
|
||||
private:
|
||||
unsigned long getNextBit();
|
||||
private:
|
||||
unsigned long getNextBit();
|
||||
|
||||
static const size_t BitsPerWord = sizeof(uint32_t) * 8;
|
||||
std::bitset<N> mBits;
|
||||
unsigned long mCurrentBit;
|
||||
unsigned long mOffset;
|
||||
};
|
||||
static const size_t BitsPerWord = sizeof(uint32_t) * 8;
|
||||
std::bitset<N> mBits;
|
||||
unsigned long mCurrentBit;
|
||||
unsigned long mOffset;
|
||||
};
|
||||
|
||||
Iterator begin() const { return Iterator(mBits); }
|
||||
Iterator end() const { return Iterator(std::bitset<N>(0)); }
|
||||
Iterator begin() const {
|
||||
return Iterator(mBits);
|
||||
}
|
||||
Iterator end() const {
|
||||
return Iterator(std::bitset<N>(0));
|
||||
}
|
||||
|
||||
private:
|
||||
const std::bitset<N> mBits;
|
||||
private:
|
||||
const std::bitset<N> mBits;
|
||||
};
|
||||
|
||||
template <size_t N, typename T>
|
||||
BitSetIterator<N, T>::BitSetIterator(const std::bitset<N>& bitset)
|
||||
: mBits(bitset) {
|
||||
BitSetIterator<N, T>::BitSetIterator(const std::bitset<N>& bitset) : mBits(bitset) {
|
||||
}
|
||||
|
||||
template <size_t N, typename T>
|
||||
BitSetIterator<N, T>::BitSetIterator(const BitSetIterator& other)
|
||||
: mBits(other.mBits) {
|
||||
BitSetIterator<N, T>::BitSetIterator(const BitSetIterator& other) : mBits(other.mBits) {
|
||||
}
|
||||
|
||||
template <size_t N, typename T>
|
||||
|
@ -21,32 +21,32 @@
|
||||
// - NXT_BUILTIN_UNREACHABLE(): Hints the compiler that a code path is unreachable
|
||||
|
||||
// Clang and GCC
|
||||
#ifdef __GNUC__
|
||||
#if defined(__clang__)
|
||||
#define NXT_COMPILER_CLANG
|
||||
#else
|
||||
#define NXT_COMPILER_GCC
|
||||
#endif
|
||||
#if defined(__GNUC__)
|
||||
# if defined(__clang__)
|
||||
# define NXT_COMPILER_CLANG
|
||||
# else
|
||||
# define NXT_COMPILER_GCC
|
||||
# endif
|
||||
|
||||
#if defined(__i386__) || defined(__x86_64__)
|
||||
#define NXT_BREAKPOINT() __asm__ __volatile__("int $3\n\t")
|
||||
#else
|
||||
#error "Implement BREAKPOINT on your platform"
|
||||
#endif
|
||||
# if defined(__i386__) || defined(__x86_64__)
|
||||
# define NXT_BREAKPOINT() __asm__ __volatile__("int $3\n\t")
|
||||
# else
|
||||
# error "Implement BREAKPOINT on your platform"
|
||||
# endif
|
||||
|
||||
#define NXT_BUILTIN_UNREACHABLE() __builtin_unreachable()
|
||||
# define NXT_BUILTIN_UNREACHABLE() __builtin_unreachable()
|
||||
|
||||
// MSVC
|
||||
#elif defined(_MSC_VER)
|
||||
#define NXT_COMPILER_MSVC
|
||||
# define NXT_COMPILER_MSVC
|
||||
|
||||
extern void __cdecl __debugbreak(void);
|
||||
#define NXT_BREAKPOINT() __debugbreak()
|
||||
extern void __cdecl __debugbreak(void);
|
||||
# define NXT_BREAKPOINT() __debugbreak()
|
||||
|
||||
#define NXT_BUILTIN_UNREACHABLE() __assume(false)
|
||||
# define NXT_BUILTIN_UNREACHABLE() __assume(false)
|
||||
|
||||
#else
|
||||
#error "Unsupported compiler"
|
||||
# error "Unsupported compiler"
|
||||
#endif
|
||||
|
||||
#endif // COMMON_COMPILER_H_
|
||||
#endif // COMMON_COMPILER_H_
|
||||
|
@ -19,11 +19,12 @@
|
||||
|
||||
static constexpr uint32_t kMaxPushConstants = 32u;
|
||||
static constexpr uint32_t kMaxBindGroups = 4u;
|
||||
static constexpr uint32_t kMaxBindingsPerGroup = 16u; // TODO(cwallez@chromium.org): investigate bindgroup limits
|
||||
// TODO(cwallez@chromium.org): investigate bindgroup limits
|
||||
static constexpr uint32_t kMaxBindingsPerGroup = 16u;
|
||||
static constexpr uint32_t kMaxVertexAttributes = 16u;
|
||||
static constexpr uint32_t kMaxVertexInputs = 16u;
|
||||
static constexpr uint32_t kNumStages = 3;
|
||||
static constexpr uint32_t kMaxColorAttachments = 4u;
|
||||
static constexpr uint32_t kTextureRowPitchAlignment = 256u;
|
||||
|
||||
#endif // COMMON_CONSTANTS_H_
|
||||
#endif // COMMON_CONSTANTS_H_
|
||||
|
@ -17,11 +17,11 @@
|
||||
#include "common/Platform.h"
|
||||
|
||||
#if NXT_PLATFORM_WINDOWS
|
||||
#include <windows.h>
|
||||
# include <windows.h>
|
||||
#elif NXT_PLATFORM_POSIX
|
||||
#include <dlfcn.h>
|
||||
# include <dlfcn.h>
|
||||
#else
|
||||
#error "Unsupported platform for DynamicLib"
|
||||
# error "Unsupported platform for DynamicLib"
|
||||
#endif
|
||||
|
||||
DynamicLib::~DynamicLib() {
|
||||
@ -42,21 +42,21 @@ bool DynamicLib::Valid() const {
|
||||
}
|
||||
|
||||
bool DynamicLib::Open(const std::string& filename, std::string* error) {
|
||||
#if NXT_PLATFORM_WINDOWS
|
||||
mHandle = LoadLibraryA(filename.c_str());
|
||||
#if NXT_PLATFORM_WINDOWS
|
||||
mHandle = LoadLibraryA(filename.c_str());
|
||||
|
||||
if (mHandle == nullptr && error != nullptr) {
|
||||
*error = "Windows Error: " + std::to_string(GetLastError());
|
||||
}
|
||||
#elif NXT_PLATFORM_POSIX
|
||||
mHandle = dlopen(filename.c_str(), RTLD_NOW);
|
||||
if (mHandle == nullptr && error != nullptr) {
|
||||
*error = "Windows Error: " + std::to_string(GetLastError());
|
||||
}
|
||||
#elif NXT_PLATFORM_POSIX
|
||||
mHandle = dlopen(filename.c_str(), RTLD_NOW);
|
||||
|
||||
if (mHandle == nullptr && error != nullptr) {
|
||||
*error = dlerror();
|
||||
}
|
||||
#else
|
||||
#error "Unsupported platform for DynamicLib"
|
||||
#endif
|
||||
if (mHandle == nullptr && error != nullptr) {
|
||||
*error = dlerror();
|
||||
}
|
||||
#else
|
||||
# error "Unsupported platform for DynamicLib"
|
||||
#endif
|
||||
|
||||
return mHandle != nullptr;
|
||||
}
|
||||
@ -66,13 +66,13 @@ void DynamicLib::Close() {
|
||||
return;
|
||||
}
|
||||
|
||||
#if NXT_PLATFORM_WINDOWS
|
||||
FreeLibrary(static_cast<HMODULE>(mHandle));
|
||||
#elif NXT_PLATFORM_POSIX
|
||||
dlclose(mHandle);
|
||||
#else
|
||||
#error "Unsupported platform for DynamicLib"
|
||||
#endif
|
||||
#if NXT_PLATFORM_WINDOWS
|
||||
FreeLibrary(static_cast<HMODULE>(mHandle));
|
||||
#elif NXT_PLATFORM_POSIX
|
||||
dlclose(mHandle);
|
||||
#else
|
||||
# error "Unsupported platform for DynamicLib"
|
||||
#endif
|
||||
|
||||
mHandle = nullptr;
|
||||
}
|
||||
@ -80,21 +80,21 @@ void DynamicLib::Close() {
|
||||
void* DynamicLib::GetProc(const std::string& procName, std::string* error) const {
|
||||
void* proc = nullptr;
|
||||
|
||||
#if NXT_PLATFORM_WINDOWS
|
||||
proc = reinterpret_cast<void*>(GetProcAddress(static_cast<HMODULE>(mHandle), procName.c_str()));
|
||||
#if NXT_PLATFORM_WINDOWS
|
||||
proc = reinterpret_cast<void*>(GetProcAddress(static_cast<HMODULE>(mHandle), procName.c_str()));
|
||||
|
||||
if (proc == nullptr && error != nullptr) {
|
||||
*error = "Windows Error: " + std::to_string(GetLastError());
|
||||
}
|
||||
#elif NXT_PLATFORM_POSIX
|
||||
proc = reinterpret_cast<void*>(dlsym(mHandle, procName.c_str()));
|
||||
if (proc == nullptr && error != nullptr) {
|
||||
*error = "Windows Error: " + std::to_string(GetLastError());
|
||||
}
|
||||
#elif NXT_PLATFORM_POSIX
|
||||
proc = reinterpret_cast<void*>(dlsym(mHandle, procName.c_str()));
|
||||
|
||||
if (proc == nullptr && error != nullptr) {
|
||||
*error = dlerror();
|
||||
}
|
||||
#else
|
||||
#error "Unsupported platform for DynamicLib"
|
||||
#endif
|
||||
if (proc == nullptr && error != nullptr) {
|
||||
*error = dlerror();
|
||||
}
|
||||
#else
|
||||
# error "Unsupported platform for DynamicLib"
|
||||
#endif
|
||||
|
||||
return proc;
|
||||
}
|
||||
|
@ -21,34 +21,34 @@
|
||||
#include <type_traits>
|
||||
|
||||
class DynamicLib {
|
||||
public:
|
||||
DynamicLib() = default;
|
||||
~DynamicLib();
|
||||
public:
|
||||
DynamicLib() = default;
|
||||
~DynamicLib();
|
||||
|
||||
DynamicLib(const DynamicLib&) = delete;
|
||||
DynamicLib& operator=(const DynamicLib&) = delete;
|
||||
DynamicLib(const DynamicLib&) = delete;
|
||||
DynamicLib& operator=(const DynamicLib&) = delete;
|
||||
|
||||
DynamicLib(DynamicLib&& other);
|
||||
DynamicLib& operator=(DynamicLib&& other);
|
||||
DynamicLib(DynamicLib&& other);
|
||||
DynamicLib& operator=(DynamicLib&& other);
|
||||
|
||||
bool Valid() const;
|
||||
bool Valid() const;
|
||||
|
||||
bool Open(const std::string& filename, std::string* error = nullptr);
|
||||
void Close();
|
||||
bool Open(const std::string& filename, std::string* error = nullptr);
|
||||
void Close();
|
||||
|
||||
void* GetProc(const std::string& procName, std::string* error = nullptr) const;
|
||||
void* GetProc(const std::string& procName, std::string* error = nullptr) const;
|
||||
|
||||
template<typename T>
|
||||
bool GetProc(T** proc, const std::string& procName, std::string* error = nullptr) const {
|
||||
ASSERT(proc != nullptr);
|
||||
static_assert(std::is_function<T>::value, "");
|
||||
template <typename T>
|
||||
bool GetProc(T** proc, const std::string& procName, std::string* error = nullptr) const {
|
||||
ASSERT(proc != nullptr);
|
||||
static_assert(std::is_function<T>::value, "");
|
||||
|
||||
*proc = reinterpret_cast<T*>(GetProc(procName, error));
|
||||
return *proc != nullptr;
|
||||
}
|
||||
*proc = reinterpret_cast<T*>(GetProc(procName, error));
|
||||
return *proc != nullptr;
|
||||
}
|
||||
|
||||
private:
|
||||
void* mHandle = nullptr;
|
||||
private:
|
||||
void* mHandle = nullptr;
|
||||
};
|
||||
|
||||
#endif // COMMON_DYNAMICLIB_H_
|
||||
#endif // COMMON_DYNAMICLIB_H_
|
||||
|
@ -17,31 +17,31 @@
|
||||
#include "common/Assert.h"
|
||||
|
||||
#if defined(NXT_COMPILER_MSVC)
|
||||
#include <intrin.h>
|
||||
# include <intrin.h>
|
||||
#endif
|
||||
|
||||
uint32_t ScanForward(uint32_t bits) {
|
||||
ASSERT(bits != 0);
|
||||
#if defined(NXT_COMPILER_MSVC)
|
||||
unsigned long firstBitIndex = 0ul;
|
||||
unsigned char ret = _BitScanForward(&firstBitIndex, bits);
|
||||
ASSERT(ret != 0);
|
||||
return firstBitIndex;
|
||||
#else
|
||||
return static_cast<uint32_t>(__builtin_ctz(bits));
|
||||
#endif
|
||||
#if defined(NXT_COMPILER_MSVC)
|
||||
unsigned long firstBitIndex = 0ul;
|
||||
unsigned char ret = _BitScanForward(&firstBitIndex, bits);
|
||||
ASSERT(ret != 0);
|
||||
return firstBitIndex;
|
||||
#else
|
||||
return static_cast<uint32_t>(__builtin_ctz(bits));
|
||||
#endif
|
||||
}
|
||||
|
||||
uint32_t Log2(uint32_t value) {
|
||||
ASSERT(value != 0);
|
||||
#if defined(NXT_COMPILER_MSVC)
|
||||
unsigned long firstBitIndex = 0ul;
|
||||
unsigned char ret = _BitScanReverse(&firstBitIndex, value);
|
||||
ASSERT(ret != 0);
|
||||
return firstBitIndex;
|
||||
#else
|
||||
return 31 - static_cast<uint32_t>(__builtin_clz(value));
|
||||
#endif
|
||||
#if defined(NXT_COMPILER_MSVC)
|
||||
unsigned long firstBitIndex = 0ul;
|
||||
unsigned char ret = _BitScanReverse(&firstBitIndex, value);
|
||||
ASSERT(ret != 0);
|
||||
return firstBitIndex;
|
||||
#else
|
||||
return 31 - static_cast<uint32_t>(__builtin_clz(value));
|
||||
#endif
|
||||
}
|
||||
|
||||
bool IsPowerOfTwo(size_t n) {
|
||||
@ -58,7 +58,8 @@ bool IsPtrAligned(const void* ptr, size_t alignment) {
|
||||
void* AlignVoidPtr(void* ptr, size_t alignment) {
|
||||
ASSERT(IsPowerOfTwo(alignment));
|
||||
ASSERT(alignment != 0);
|
||||
return reinterpret_cast<void*>((reinterpret_cast<size_t>(ptr) + (alignment - 1)) & ~(alignment - 1));
|
||||
return reinterpret_cast<void*>((reinterpret_cast<size_t>(ptr) + (alignment - 1)) &
|
||||
~(alignment - 1));
|
||||
}
|
||||
|
||||
bool IsAligned(uint32_t value, size_t alignment) {
|
||||
|
@ -28,14 +28,14 @@ void* AlignVoidPtr(void* ptr, size_t alignment);
|
||||
bool IsAligned(uint32_t value, size_t alignment);
|
||||
uint32_t Align(uint32_t value, size_t alignment);
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
T* AlignPtr(T* ptr, size_t alignment) {
|
||||
return reinterpret_cast<T*>(AlignVoidPtr(ptr, alignment));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
const T* AlignPtr(const T* ptr, size_t alignment) {
|
||||
return reinterpret_cast<const T*>(AlignVoidPtr(const_cast<T*>(ptr), alignment));
|
||||
}
|
||||
|
||||
#endif // COMMON_MATH_H_
|
||||
#endif // COMMON_MATH_H_
|
||||
|
@ -16,15 +16,15 @@
|
||||
#define COMMON_PLATFORM_H_
|
||||
|
||||
#if defined(_WIN32) || defined(_WIN64)
|
||||
#define NXT_PLATFORM_WINDOWS 1
|
||||
# define NXT_PLATFORM_WINDOWS 1
|
||||
#elif defined(__linux__)
|
||||
#define NXT_PLATFORM_LINUX 1
|
||||
#define NXT_PLATFORM_POSIX 1
|
||||
# define NXT_PLATFORM_LINUX 1
|
||||
# define NXT_PLATFORM_POSIX 1
|
||||
#elif defined(__APPLE__)
|
||||
#define NXT_PLATFORM_APPLE 1
|
||||
#define NXT_PLATFORM_POSIX 1
|
||||
# define NXT_PLATFORM_APPLE 1
|
||||
# define NXT_PLATFORM_POSIX 1
|
||||
#else
|
||||
#error "Unsupported platform."
|
||||
# error "Unsupported platform."
|
||||
#endif
|
||||
|
||||
#endif // COMMON_PLATFORM_H_
|
||||
#endif // COMMON_PLATFORM_H_
|
||||
|
@ -19,4 +19,4 @@
|
||||
|
||||
using Serial = uint64_t;
|
||||
|
||||
#endif // COMMON_SERIAL_H_
|
||||
#endif // COMMON_SERIAL_H_
|
||||
|
@ -21,101 +21,101 @@
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
class SerialQueue {
|
||||
private:
|
||||
using SerialPair = std::pair<Serial, std::vector<T>>;
|
||||
using Storage = std::vector<SerialPair>;
|
||||
using StorageIterator = typename Storage::iterator;
|
||||
using ConstStorageIterator = typename Storage::const_iterator;
|
||||
private:
|
||||
using SerialPair = std::pair<Serial, std::vector<T>>;
|
||||
using Storage = std::vector<SerialPair>;
|
||||
using StorageIterator = typename Storage::iterator;
|
||||
using ConstStorageIterator = typename Storage::const_iterator;
|
||||
|
||||
public:
|
||||
class Iterator {
|
||||
public:
|
||||
Iterator(StorageIterator start);
|
||||
Iterator& operator++();
|
||||
public:
|
||||
class Iterator {
|
||||
public:
|
||||
Iterator(StorageIterator start);
|
||||
Iterator& operator++();
|
||||
|
||||
bool operator==(const Iterator& other) const;
|
||||
bool operator!=(const Iterator& other) const;
|
||||
T& operator*() const;
|
||||
bool operator==(const Iterator& other) const;
|
||||
bool operator!=(const Iterator& other) const;
|
||||
T& operator*() const;
|
||||
|
||||
private:
|
||||
StorageIterator mStorageIterator;
|
||||
// Special case the mSerialIterator when it should be equal to mStorageIterator.begin()
|
||||
// otherwise we could ask mStorageIterator.begin() when mStorageIterator is mStorage.end()
|
||||
// which is invalid. mStorageIterator.begin() is tagged with a nullptr.
|
||||
T* mSerialIterator;
|
||||
};
|
||||
private:
|
||||
StorageIterator mStorageIterator;
|
||||
// Special case the mSerialIterator when it should be equal to mStorageIterator.begin()
|
||||
// otherwise we could ask mStorageIterator.begin() when mStorageIterator is mStorage.end()
|
||||
// which is invalid. mStorageIterator.begin() is tagged with a nullptr.
|
||||
T* mSerialIterator;
|
||||
};
|
||||
|
||||
class ConstIterator {
|
||||
public:
|
||||
ConstIterator(ConstStorageIterator start);
|
||||
ConstIterator& operator++();
|
||||
class ConstIterator {
|
||||
public:
|
||||
ConstIterator(ConstStorageIterator start);
|
||||
ConstIterator& operator++();
|
||||
|
||||
bool operator==(const ConstIterator& other) const;
|
||||
bool operator!=(const ConstIterator& other) const;
|
||||
const T& operator*() const;
|
||||
bool operator==(const ConstIterator& other) const;
|
||||
bool operator!=(const ConstIterator& other) const;
|
||||
const T& operator*() const;
|
||||
|
||||
private:
|
||||
ConstStorageIterator mStorageIterator;
|
||||
const T* mSerialIterator;
|
||||
};
|
||||
private:
|
||||
ConstStorageIterator mStorageIterator;
|
||||
const T* mSerialIterator;
|
||||
};
|
||||
|
||||
class BeginEnd {
|
||||
public:
|
||||
BeginEnd(StorageIterator start, StorageIterator end);
|
||||
class BeginEnd {
|
||||
public:
|
||||
BeginEnd(StorageIterator start, StorageIterator end);
|
||||
|
||||
Iterator begin() const;
|
||||
Iterator end() const;
|
||||
Iterator begin() const;
|
||||
Iterator end() const;
|
||||
|
||||
private:
|
||||
StorageIterator mStartIt;
|
||||
StorageIterator mEndIt;
|
||||
};
|
||||
private:
|
||||
StorageIterator mStartIt;
|
||||
StorageIterator mEndIt;
|
||||
};
|
||||
|
||||
class ConstBeginEnd {
|
||||
public:
|
||||
ConstBeginEnd(ConstStorageIterator start, ConstStorageIterator end);
|
||||
class ConstBeginEnd {
|
||||
public:
|
||||
ConstBeginEnd(ConstStorageIterator start, ConstStorageIterator end);
|
||||
|
||||
ConstIterator begin() const;
|
||||
ConstIterator end() const;
|
||||
ConstIterator begin() const;
|
||||
ConstIterator end() const;
|
||||
|
||||
private:
|
||||
ConstStorageIterator mStartIt;
|
||||
ConstStorageIterator mEndIt;
|
||||
};
|
||||
private:
|
||||
ConstStorageIterator mStartIt;
|
||||
ConstStorageIterator mEndIt;
|
||||
};
|
||||
|
||||
// The serial must be given in (not strictly) increasing order.
|
||||
void Enqueue(const T& value, Serial serial);
|
||||
void Enqueue(T&& value, Serial serial);
|
||||
void Enqueue(const std::vector<T>& values, Serial serial);
|
||||
void Enqueue(std::vector<T>&& values, Serial serial);
|
||||
// The serial must be given in (not strictly) increasing order.
|
||||
void Enqueue(const T& value, Serial serial);
|
||||
void Enqueue(T&& value, Serial serial);
|
||||
void Enqueue(const std::vector<T>& values, Serial serial);
|
||||
void Enqueue(std::vector<T>&& values, Serial serial);
|
||||
|
||||
bool Empty() const;
|
||||
bool Empty() const;
|
||||
|
||||
// The UpTo variants of Iterate and Clear affect all values associated to a serial
|
||||
// that is smaller OR EQUAL to the given serial. Iterating is done like so:
|
||||
// for (const T& value : queue.IterateAll()) { stuff(T); }
|
||||
ConstBeginEnd IterateAll() const;
|
||||
ConstBeginEnd IterateUpTo(Serial serial) const;
|
||||
BeginEnd IterateAll();
|
||||
BeginEnd IterateUpTo(Serial serial);
|
||||
// The UpTo variants of Iterate and Clear affect all values associated to a serial
|
||||
// that is smaller OR EQUAL to the given serial. Iterating is done like so:
|
||||
// for (const T& value : queue.IterateAll()) { stuff(T); }
|
||||
ConstBeginEnd IterateAll() const;
|
||||
ConstBeginEnd IterateUpTo(Serial serial) const;
|
||||
BeginEnd IterateAll();
|
||||
BeginEnd IterateUpTo(Serial serial);
|
||||
|
||||
void Clear();
|
||||
void ClearUpTo(Serial serial);
|
||||
void Clear();
|
||||
void ClearUpTo(Serial serial);
|
||||
|
||||
Serial FirstSerial() const;
|
||||
Serial FirstSerial() const;
|
||||
|
||||
private:
|
||||
// Returns the first StorageIterator that a serial bigger than serial.
|
||||
ConstStorageIterator FindUpTo(Serial serial) const;
|
||||
StorageIterator FindUpTo(Serial serial);
|
||||
Storage mStorage;
|
||||
private:
|
||||
// Returns the first StorageIterator that a serial bigger than serial.
|
||||
ConstStorageIterator FindUpTo(Serial serial) const;
|
||||
StorageIterator FindUpTo(Serial serial);
|
||||
Storage mStorage;
|
||||
};
|
||||
|
||||
// SerialQueue
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
void SerialQueue<T>::Enqueue(const T& value, Serial serial) {
|
||||
NXT_ASSERT(Empty() || mStorage.back().first <= serial);
|
||||
|
||||
@ -125,7 +125,7 @@ void SerialQueue<T>::Enqueue(const T& value, Serial serial) {
|
||||
mStorage.back().second.emplace_back(value);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
void SerialQueue<T>::Enqueue(T&& value, Serial serial) {
|
||||
NXT_ASSERT(Empty() || mStorage.back().first <= serial);
|
||||
|
||||
@ -135,132 +135,133 @@ void SerialQueue<T>::Enqueue(T&& value, Serial serial) {
|
||||
mStorage.back().second.emplace_back(value);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
void SerialQueue<T>::Enqueue(const std::vector<T>& values, Serial serial) {
|
||||
NXT_ASSERT(values.size() > 0);
|
||||
NXT_ASSERT(Empty() || mStorage.back().first <= serial);
|
||||
mStorage.emplace_back(SerialPair(serial, {values}));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
void SerialQueue<T>::Enqueue(std::vector<T>&& values, Serial serial) {
|
||||
NXT_ASSERT(values.size() > 0);
|
||||
NXT_ASSERT(Empty() || mStorage.back().first <= serial);
|
||||
mStorage.emplace_back(SerialPair(serial, {values}));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
bool SerialQueue<T>::Empty() const {
|
||||
return mStorage.empty();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::ConstBeginEnd SerialQueue<T>::IterateAll() const {
|
||||
return {mStorage.begin(), mStorage.end()};
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::ConstBeginEnd SerialQueue<T>::IterateUpTo(Serial serial) const {
|
||||
return {mStorage.begin(), FindUpTo(serial)};
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::BeginEnd SerialQueue<T>::IterateAll() {
|
||||
return {mStorage.begin(), mStorage.end()};
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::BeginEnd SerialQueue<T>::IterateUpTo(Serial serial) {
|
||||
return {mStorage.begin(), FindUpTo(serial)};
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
void SerialQueue<T>::Clear() {
|
||||
mStorage.clear();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
void SerialQueue<T>::ClearUpTo(Serial serial) {
|
||||
mStorage.erase(mStorage.begin(), FindUpTo(serial));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
Serial SerialQueue<T>::FirstSerial() const {
|
||||
NXT_ASSERT(!Empty());
|
||||
return mStorage.front().first;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::ConstStorageIterator SerialQueue<T>::FindUpTo(Serial serial) const {
|
||||
auto it = mStorage.begin();
|
||||
while (it != mStorage.end() && it->first <= serial) {
|
||||
it ++;
|
||||
it++;
|
||||
}
|
||||
return it;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::StorageIterator SerialQueue<T>::FindUpTo(Serial serial) {
|
||||
auto it = mStorage.begin();
|
||||
while (it != mStorage.end() && it->first <= serial) {
|
||||
it ++;
|
||||
it++;
|
||||
}
|
||||
return it;
|
||||
}
|
||||
|
||||
// SerialQueue::BeginEnd
|
||||
|
||||
template<typename T>
|
||||
SerialQueue<T>::BeginEnd::BeginEnd(typename SerialQueue<T>::StorageIterator start, typename SerialQueue<T>::StorageIterator end)
|
||||
template <typename T>
|
||||
SerialQueue<T>::BeginEnd::BeginEnd(typename SerialQueue<T>::StorageIterator start,
|
||||
typename SerialQueue<T>::StorageIterator end)
|
||||
: mStartIt(start), mEndIt(end) {
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::Iterator SerialQueue<T>::BeginEnd::begin() const {
|
||||
return {mStartIt};
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::Iterator SerialQueue<T>::BeginEnd::end() const {
|
||||
return {mEndIt};
|
||||
}
|
||||
|
||||
// SerialQueue::Iterator
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
SerialQueue<T>::Iterator::Iterator(typename SerialQueue<T>::StorageIterator start)
|
||||
: mStorageIterator(start), mSerialIterator(nullptr) {
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::Iterator& SerialQueue<T>::Iterator::operator++() {
|
||||
T* vectorData = mStorageIterator->second.data();
|
||||
|
||||
if (mSerialIterator == nullptr) {
|
||||
mSerialIterator = vectorData + 1;
|
||||
} else {
|
||||
mSerialIterator ++;
|
||||
mSerialIterator++;
|
||||
}
|
||||
|
||||
if (mSerialIterator >= vectorData + mStorageIterator->second.size()) {
|
||||
mSerialIterator = nullptr;
|
||||
mStorageIterator ++;
|
||||
mStorageIterator++;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
bool SerialQueue<T>::Iterator::operator==(const typename SerialQueue<T>::Iterator& other) const {
|
||||
return other.mStorageIterator == mStorageIterator && other.mSerialIterator == mSerialIterator;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
bool SerialQueue<T>::Iterator::operator!=(const typename SerialQueue<T>::Iterator& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
T& SerialQueue<T>::Iterator::operator*() const {
|
||||
if (mSerialIterator == nullptr) {
|
||||
return *mStorageIterator->second.begin();
|
||||
@ -270,57 +271,60 @@ T& SerialQueue<T>::Iterator::operator*() const {
|
||||
|
||||
// SerialQueue::ConstBeginEnd
|
||||
|
||||
template<typename T>
|
||||
SerialQueue<T>::ConstBeginEnd::ConstBeginEnd(typename SerialQueue<T>::ConstStorageIterator start, typename SerialQueue<T>::ConstStorageIterator end)
|
||||
template <typename T>
|
||||
SerialQueue<T>::ConstBeginEnd::ConstBeginEnd(typename SerialQueue<T>::ConstStorageIterator start,
|
||||
typename SerialQueue<T>::ConstStorageIterator end)
|
||||
: mStartIt(start), mEndIt(end) {
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::ConstIterator SerialQueue<T>::ConstBeginEnd::begin() const {
|
||||
return {mStartIt};
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::ConstIterator SerialQueue<T>::ConstBeginEnd::end() const {
|
||||
return {mEndIt};
|
||||
}
|
||||
|
||||
// SerialQueue::ConstIterator
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
SerialQueue<T>::ConstIterator::ConstIterator(typename SerialQueue<T>::ConstStorageIterator start)
|
||||
: mStorageIterator(start), mSerialIterator(nullptr) {
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
typename SerialQueue<T>::ConstIterator& SerialQueue<T>::ConstIterator::operator++() {
|
||||
const T* vectorData = mStorageIterator->second.data();
|
||||
|
||||
if (mSerialIterator == nullptr) {
|
||||
mSerialIterator = vectorData + 1;
|
||||
} else {
|
||||
mSerialIterator ++;
|
||||
mSerialIterator++;
|
||||
}
|
||||
|
||||
if (mSerialIterator >= vectorData + mStorageIterator->second.size()) {
|
||||
mSerialIterator = nullptr;
|
||||
mStorageIterator ++;
|
||||
mStorageIterator++;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool SerialQueue<T>::ConstIterator::operator==(const typename SerialQueue<T>::ConstIterator& other) const {
|
||||
template <typename T>
|
||||
bool SerialQueue<T>::ConstIterator::operator==(
|
||||
const typename SerialQueue<T>::ConstIterator& other) const {
|
||||
return other.mStorageIterator == mStorageIterator && other.mSerialIterator == mSerialIterator;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool SerialQueue<T>::ConstIterator::operator!=(const typename SerialQueue<T>::ConstIterator& other) const {
|
||||
template <typename T>
|
||||
bool SerialQueue<T>::ConstIterator::operator!=(
|
||||
const typename SerialQueue<T>::ConstIterator& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template <typename T>
|
||||
const T& SerialQueue<T>::ConstIterator::operator*() const {
|
||||
if (mSerialIterator == nullptr) {
|
||||
return *mStorageIterator->second.begin();
|
||||
@ -328,4 +332,4 @@ const T& SerialQueue<T>::ConstIterator::operator*() const {
|
||||
return *mSerialIterator;
|
||||
}
|
||||
|
||||
#endif // COMMON_SERIALQUEUE_H_
|
||||
#endif // COMMON_SERIALQUEUE_H_
|
||||
|
@ -18,21 +18,21 @@
|
||||
|
||||
namespace utils {
|
||||
|
||||
#if defined(NXT_ENABLE_BACKEND_D3D12)
|
||||
BackendBinding* CreateD3D12Binding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_METAL)
|
||||
BackendBinding* CreateMetalBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_NULL)
|
||||
BackendBinding* CreateNullBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_OPENGL)
|
||||
BackendBinding* CreateOpenGLBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_VULKAN)
|
||||
BackendBinding* CreateVulkanBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_D3D12)
|
||||
BackendBinding* CreateD3D12Binding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_METAL)
|
||||
BackendBinding* CreateMetalBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_NULL)
|
||||
BackendBinding* CreateNullBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_OPENGL)
|
||||
BackendBinding* CreateOpenGLBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_VULKAN)
|
||||
BackendBinding* CreateVulkanBinding();
|
||||
#endif
|
||||
|
||||
void BackendBinding::SetWindow(GLFWwindow* window) {
|
||||
mWindow = window;
|
||||
@ -40,34 +40,34 @@ namespace utils {
|
||||
|
||||
BackendBinding* CreateBinding(BackendType type) {
|
||||
switch (type) {
|
||||
#if defined(NXT_ENABLE_BACKEND_D3D12)
|
||||
case BackendType::D3D12:
|
||||
return CreateD3D12Binding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_D3D12)
|
||||
case BackendType::D3D12:
|
||||
return CreateD3D12Binding();
|
||||
#endif
|
||||
|
||||
#if defined(NXT_ENABLE_BACKEND_METAL)
|
||||
case BackendType::Metal:
|
||||
return CreateMetalBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_METAL)
|
||||
case BackendType::Metal:
|
||||
return CreateMetalBinding();
|
||||
#endif
|
||||
|
||||
#if defined(NXT_ENABLE_BACKEND_NULL)
|
||||
case BackendType::Null:
|
||||
return CreateNullBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_NULL)
|
||||
case BackendType::Null:
|
||||
return CreateNullBinding();
|
||||
#endif
|
||||
|
||||
#if defined(NXT_ENABLE_BACKEND_OPENGL)
|
||||
case BackendType::OpenGL:
|
||||
return CreateOpenGLBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_OPENGL)
|
||||
case BackendType::OpenGL:
|
||||
return CreateOpenGLBinding();
|
||||
#endif
|
||||
|
||||
#if defined(NXT_ENABLE_BACKEND_VULKAN)
|
||||
case BackendType::Vulkan:
|
||||
return CreateVulkanBinding();
|
||||
#endif
|
||||
#if defined(NXT_ENABLE_BACKEND_VULKAN)
|
||||
case BackendType::Vulkan:
|
||||
return CreateVulkanBinding();
|
||||
#endif
|
||||
|
||||
default:
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace utils
|
||||
|
@ -32,21 +32,22 @@ namespace utils {
|
||||
};
|
||||
|
||||
class BackendBinding {
|
||||
public:
|
||||
virtual ~BackendBinding() = default;
|
||||
public:
|
||||
virtual ~BackendBinding() = default;
|
||||
|
||||
virtual void SetupGLFWWindowHints() = 0;
|
||||
virtual void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) = 0;
|
||||
virtual uint64_t GetSwapChainImplementation() = 0;
|
||||
virtual nxtTextureFormat GetPreferredSwapChainTextureFormat() = 0;
|
||||
virtual void SetupGLFWWindowHints() = 0;
|
||||
virtual void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) = 0;
|
||||
virtual uint64_t GetSwapChainImplementation() = 0;
|
||||
virtual nxtTextureFormat GetPreferredSwapChainTextureFormat() = 0;
|
||||
|
||||
void SetWindow(GLFWwindow* window);
|
||||
void SetWindow(GLFWwindow* window);
|
||||
|
||||
protected:
|
||||
GLFWwindow* mWindow = nullptr;
|
||||
protected:
|
||||
GLFWwindow* mWindow = nullptr;
|
||||
};
|
||||
|
||||
BackendBinding* CreateBinding(BackendType type);
|
||||
}
|
||||
|
||||
#endif // UTILS_BACKENDBINDING_H_
|
||||
} // namespace utils
|
||||
|
||||
#endif // UTILS_BACKENDBINDING_H_
|
||||
|
@ -22,27 +22,26 @@
|
||||
#include "GLFW/glfw3.h"
|
||||
#include "GLFW/glfw3native.h"
|
||||
|
||||
#include <initializer_list>
|
||||
#include <wrl.h>
|
||||
#include <d3d12.h>
|
||||
#include <dxgi1_4.h>
|
||||
#include <wrl.h>
|
||||
#include <initializer_list>
|
||||
#ifdef _DEBUG
|
||||
#include <dxgidebug.h>
|
||||
#endif
|
||||
|
||||
using Microsoft::WRL::ComPtr;
|
||||
|
||||
namespace backend {
|
||||
namespace d3d12 {
|
||||
namespace backend { namespace d3d12 {
|
||||
void Init(ComPtr<ID3D12Device> d3d12Device, nxtProcTable* procs, nxtDevice* device);
|
||||
ComPtr<ID3D12CommandQueue> GetCommandQueue(nxtDevice device);
|
||||
uint64_t GetSerial(const nxtDevice device);
|
||||
void NextSerial(nxtDevice device);
|
||||
void ExecuteCommandLists(nxtDevice device, std::initializer_list<ID3D12CommandList*> commandLists);
|
||||
void ExecuteCommandLists(nxtDevice device,
|
||||
std::initializer_list<ID3D12CommandList*> commandLists);
|
||||
void WaitForSerial(nxtDevice device, uint64_t serial);
|
||||
void OpenCommandList(nxtDevice device, ComPtr<ID3D12GraphicsCommandList>* commandList);
|
||||
}
|
||||
}
|
||||
}} // namespace backend::d3d12
|
||||
|
||||
namespace utils {
|
||||
namespace {
|
||||
@ -56,7 +55,8 @@ namespace utils {
|
||||
uint32_t dxgiFactoryFlags = 0;
|
||||
#ifdef _DEBUG
|
||||
// Enable the debug layer (requires the Graphics Tools "optional feature").
|
||||
// NOTE: Enabling the debug layer after device creation will invalidate the active device.
|
||||
// NOTE: Enabling the debug layer after device creation will invalidate the active
|
||||
// device.
|
||||
{
|
||||
ComPtr<ID3D12Debug> debugController;
|
||||
if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController)))) {
|
||||
@ -68,7 +68,8 @@ namespace utils {
|
||||
|
||||
ComPtr<IDXGIDebug1> dxgiDebug;
|
||||
if (SUCCEEDED(DXGIGetDebugInterface1(0, IID_PPV_ARGS(&dxgiDebug)))) {
|
||||
dxgiDebug->ReportLiveObjects(DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_FLAGS(DXGI_DEBUG_RLO_ALL));
|
||||
dxgiDebug->ReportLiveObjects(DXGI_DEBUG_ALL,
|
||||
DXGI_DEBUG_RLO_FLAGS(DXGI_DEBUG_RLO_ALL));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@ -101,7 +102,8 @@ namespace utils {
|
||||
resourceState |= D3D12_RESOURCE_STATE_COPY_DEST;
|
||||
}
|
||||
if (usage & NXT_TEXTURE_USAGE_BIT_SAMPLED) {
|
||||
resourceState |= (D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE | D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
|
||||
resourceState |= (D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE |
|
||||
D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
|
||||
}
|
||||
if (usage & NXT_TEXTURE_USAGE_BIT_STORAGE) {
|
||||
resourceState |= D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
|
||||
@ -112,204 +114,205 @@ namespace utils {
|
||||
|
||||
return resourceState;
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
|
||||
class SwapChainImplD3D12 : SwapChainImpl {
|
||||
public:
|
||||
static nxtSwapChainImplementation Create(HWND window, const nxtProcTable& procs) {
|
||||
auto impl = GenerateSwapChainImplementation<SwapChainImplD3D12, nxtWSIContextD3D12>();
|
||||
impl.userData = new SwapChainImplD3D12(window, procs);
|
||||
return impl;
|
||||
public:
|
||||
static nxtSwapChainImplementation Create(HWND window, const nxtProcTable& procs) {
|
||||
auto impl = GenerateSwapChainImplementation<SwapChainImplD3D12, nxtWSIContextD3D12>();
|
||||
impl.userData = new SwapChainImplD3D12(window, procs);
|
||||
return impl;
|
||||
}
|
||||
|
||||
private:
|
||||
nxtDevice mBackendDevice = nullptr;
|
||||
nxtProcTable mProcs = {};
|
||||
|
||||
static constexpr unsigned int kFrameCount = 2;
|
||||
|
||||
HWND mWindow = 0;
|
||||
ComPtr<IDXGIFactory4> mFactory = {};
|
||||
ComPtr<ID3D12CommandQueue> mCommandQueue = {};
|
||||
ComPtr<IDXGISwapChain3> mSwapChain = {};
|
||||
ComPtr<ID3D12Resource> mRenderTargetResources[kFrameCount] = {};
|
||||
|
||||
// Frame synchronization. Updated every frame
|
||||
uint32_t mRenderTargetIndex = 0;
|
||||
uint32_t mPreviousRenderTargetIndex = 0;
|
||||
uint64_t mLastSerialRenderTargetWasUsed[kFrameCount] = {};
|
||||
|
||||
D3D12_RESOURCE_STATES mRenderTargetResourceState;
|
||||
|
||||
SwapChainImplD3D12(HWND window, nxtProcTable procs)
|
||||
: mWindow(window), mProcs(procs), mFactory(CreateFactory()) {
|
||||
}
|
||||
|
||||
~SwapChainImplD3D12() {
|
||||
}
|
||||
|
||||
// For GenerateSwapChainImplementation
|
||||
friend class SwapChainImpl;
|
||||
|
||||
void Init(nxtWSIContextD3D12* ctx) {
|
||||
mBackendDevice = ctx->device;
|
||||
mCommandQueue = backend::d3d12::GetCommandQueue(mBackendDevice);
|
||||
}
|
||||
|
||||
nxtSwapChainError Configure(nxtTextureFormat format,
|
||||
nxtTextureUsageBit allowedUsage,
|
||||
uint32_t width,
|
||||
uint32_t height) {
|
||||
if (format != NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM) {
|
||||
return "unsupported format";
|
||||
}
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
|
||||
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
|
||||
swapChainDesc.Width = width;
|
||||
swapChainDesc.Height = height;
|
||||
swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
swapChainDesc.BufferUsage = D3D12SwapChainBufferUsage(allowedUsage);
|
||||
swapChainDesc.BufferCount = kFrameCount;
|
||||
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
|
||||
swapChainDesc.SampleDesc.Count = 1;
|
||||
swapChainDesc.SampleDesc.Quality = 0;
|
||||
|
||||
ComPtr<IDXGISwapChain1> swapChain1;
|
||||
ASSERT_SUCCESS(mFactory->CreateSwapChainForHwnd(
|
||||
mCommandQueue.Get(), mWindow, &swapChainDesc, nullptr, nullptr, &swapChain1));
|
||||
ASSERT_SUCCESS(swapChain1.As(&mSwapChain));
|
||||
|
||||
for (uint32_t n = 0; n < kFrameCount; ++n) {
|
||||
ASSERT_SUCCESS(mSwapChain->GetBuffer(n, IID_PPV_ARGS(&mRenderTargetResources[n])));
|
||||
}
|
||||
|
||||
private:
|
||||
nxtDevice mBackendDevice = nullptr;
|
||||
nxtProcTable mProcs = {};
|
||||
// Get the initial render target and arbitrarily choose a "previous" render target
|
||||
// that's different
|
||||
mPreviousRenderTargetIndex = mRenderTargetIndex =
|
||||
mSwapChain->GetCurrentBackBufferIndex();
|
||||
mPreviousRenderTargetIndex = mRenderTargetIndex == 0 ? 1 : 0;
|
||||
|
||||
static constexpr unsigned int kFrameCount = 2;
|
||||
|
||||
HWND mWindow = 0;
|
||||
ComPtr<IDXGIFactory4> mFactory = {};
|
||||
ComPtr<ID3D12CommandQueue> mCommandQueue = {};
|
||||
ComPtr<IDXGISwapChain3> mSwapChain = {};
|
||||
ComPtr<ID3D12Resource> mRenderTargetResources[kFrameCount] = {};
|
||||
|
||||
// Frame synchronization. Updated every frame
|
||||
uint32_t mRenderTargetIndex = 0;
|
||||
uint32_t mPreviousRenderTargetIndex = 0;
|
||||
uint64_t mLastSerialRenderTargetWasUsed[kFrameCount] = {};
|
||||
|
||||
D3D12_RESOURCE_STATES mRenderTargetResourceState;
|
||||
|
||||
SwapChainImplD3D12(HWND window, nxtProcTable procs)
|
||||
: mWindow(window), mProcs(procs), mFactory(CreateFactory()) {
|
||||
// Initial the serial for all render targets
|
||||
const uint64_t initialSerial = backend::d3d12::GetSerial(mBackendDevice);
|
||||
for (uint32_t n = 0; n < kFrameCount; ++n) {
|
||||
mLastSerialRenderTargetWasUsed[n] = initialSerial;
|
||||
}
|
||||
|
||||
~SwapChainImplD3D12() {
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture* nextTexture) {
|
||||
nextTexture->texture = mRenderTargetResources[mRenderTargetIndex].Get();
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError Present() {
|
||||
// Current frame already transitioned to Present by the application, but
|
||||
// we need to flush the D3D12 backend's pending transitions.
|
||||
mProcs.deviceTick(mBackendDevice);
|
||||
|
||||
ASSERT_SUCCESS(mSwapChain->Present(1, 0));
|
||||
|
||||
// Transition last frame's render target back to being a render target
|
||||
if (mRenderTargetResourceState != D3D12_RESOURCE_STATE_PRESENT) {
|
||||
ComPtr<ID3D12GraphicsCommandList> commandList = {};
|
||||
backend::d3d12::OpenCommandList(mBackendDevice, &commandList);
|
||||
|
||||
D3D12_RESOURCE_BARRIER resourceBarrier;
|
||||
resourceBarrier.Transition.pResource =
|
||||
mRenderTargetResources[mPreviousRenderTargetIndex].Get();
|
||||
resourceBarrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
|
||||
resourceBarrier.Transition.StateAfter = mRenderTargetResourceState;
|
||||
resourceBarrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
|
||||
resourceBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
|
||||
resourceBarrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
|
||||
commandList->ResourceBarrier(1, &resourceBarrier);
|
||||
ASSERT_SUCCESS(commandList->Close());
|
||||
backend::d3d12::ExecuteCommandLists(mBackendDevice, {commandList.Get()});
|
||||
}
|
||||
|
||||
// For GenerateSwapChainImplementation
|
||||
friend class SwapChainImpl;
|
||||
backend::d3d12::NextSerial(mBackendDevice);
|
||||
|
||||
void Init(nxtWSIContextD3D12* ctx) {
|
||||
mBackendDevice = ctx->device;
|
||||
mCommandQueue = backend::d3d12::GetCommandQueue(mBackendDevice);
|
||||
}
|
||||
mPreviousRenderTargetIndex = mRenderTargetIndex;
|
||||
mRenderTargetIndex = mSwapChain->GetCurrentBackBufferIndex();
|
||||
|
||||
nxtSwapChainError Configure(nxtTextureFormat format, nxtTextureUsageBit allowedUsage,
|
||||
uint32_t width, uint32_t height) {
|
||||
if (format != NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM) {
|
||||
return "unsupported format";
|
||||
}
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
// If the next render target is not ready to be rendered yet, wait until it is ready.
|
||||
// If the last completed serial is less than the last requested serial for this render
|
||||
// target, then the commands previously executed on this render target have not yet
|
||||
// completed
|
||||
backend::d3d12::WaitForSerial(mBackendDevice,
|
||||
mLastSerialRenderTargetWasUsed[mRenderTargetIndex]);
|
||||
|
||||
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
|
||||
swapChainDesc.Width = width;
|
||||
swapChainDesc.Height = height;
|
||||
swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
swapChainDesc.BufferUsage = D3D12SwapChainBufferUsage(allowedUsage);
|
||||
swapChainDesc.BufferCount = kFrameCount;
|
||||
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
|
||||
swapChainDesc.SampleDesc.Count = 1;
|
||||
swapChainDesc.SampleDesc.Quality = 0;
|
||||
mLastSerialRenderTargetWasUsed[mRenderTargetIndex] =
|
||||
backend::d3d12::GetSerial(mBackendDevice);
|
||||
|
||||
ComPtr<IDXGISwapChain1> swapChain1;
|
||||
ASSERT_SUCCESS(mFactory->CreateSwapChainForHwnd(
|
||||
mCommandQueue.Get(),
|
||||
mWindow,
|
||||
&swapChainDesc,
|
||||
nullptr,
|
||||
nullptr,
|
||||
&swapChain1
|
||||
));
|
||||
ASSERT_SUCCESS(swapChain1.As(&mSwapChain));
|
||||
|
||||
for (uint32_t n = 0; n < kFrameCount; ++n) {
|
||||
ASSERT_SUCCESS(mSwapChain->GetBuffer(n, IID_PPV_ARGS(&mRenderTargetResources[n])));
|
||||
}
|
||||
|
||||
// Get the initial render target and arbitrarily choose a "previous" render target that's different
|
||||
mPreviousRenderTargetIndex = mRenderTargetIndex = mSwapChain->GetCurrentBackBufferIndex();
|
||||
mPreviousRenderTargetIndex = mRenderTargetIndex == 0 ? 1 : 0;
|
||||
|
||||
// Initial the serial for all render targets
|
||||
const uint64_t initialSerial = backend::d3d12::GetSerial(mBackendDevice);
|
||||
for (uint32_t n = 0; n < kFrameCount; ++n) {
|
||||
mLastSerialRenderTargetWasUsed[n] = initialSerial;
|
||||
}
|
||||
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture* nextTexture) {
|
||||
nextTexture->texture = mRenderTargetResources[mRenderTargetIndex].Get();
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError Present() {
|
||||
// Current frame already transitioned to Present by the application, but
|
||||
// we need to flush the D3D12 backend's pending transitions.
|
||||
mProcs.deviceTick(mBackendDevice);
|
||||
|
||||
ASSERT_SUCCESS(mSwapChain->Present(1, 0));
|
||||
|
||||
// Transition last frame's render target back to being a render target
|
||||
if (mRenderTargetResourceState != D3D12_RESOURCE_STATE_PRESENT) {
|
||||
ComPtr<ID3D12GraphicsCommandList> commandList = {};
|
||||
backend::d3d12::OpenCommandList(mBackendDevice, &commandList);
|
||||
|
||||
D3D12_RESOURCE_BARRIER resourceBarrier;
|
||||
resourceBarrier.Transition.pResource = mRenderTargetResources[mPreviousRenderTargetIndex].Get();
|
||||
resourceBarrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
|
||||
resourceBarrier.Transition.StateAfter = mRenderTargetResourceState;
|
||||
resourceBarrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
|
||||
resourceBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
|
||||
resourceBarrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
|
||||
commandList->ResourceBarrier(1, &resourceBarrier);
|
||||
ASSERT_SUCCESS(commandList->Close());
|
||||
backend::d3d12::ExecuteCommandLists(mBackendDevice, { commandList.Get() });
|
||||
}
|
||||
|
||||
backend::d3d12::NextSerial(mBackendDevice);
|
||||
|
||||
mPreviousRenderTargetIndex = mRenderTargetIndex;
|
||||
mRenderTargetIndex = mSwapChain->GetCurrentBackBufferIndex();
|
||||
|
||||
// If the next render target is not ready to be rendered yet, wait until it is ready.
|
||||
// If the last completed serial is less than the last requested serial for this render target,
|
||||
// then the commands previously executed on this render target have not yet completed
|
||||
backend::d3d12::WaitForSerial(mBackendDevice, mLastSerialRenderTargetWasUsed[mRenderTargetIndex]);
|
||||
|
||||
mLastSerialRenderTargetWasUsed[mRenderTargetIndex] = backend::d3d12::GetSerial(mBackendDevice);
|
||||
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
};
|
||||
|
||||
class D3D12Binding : public BackendBinding {
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
||||
}
|
||||
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
mFactory = CreateFactory();
|
||||
ASSERT(GetHardwareAdapter(mFactory.Get(), &mHardwareAdapter));
|
||||
ASSERT_SUCCESS(D3D12CreateDevice(mHardwareAdapter.Get(), D3D_FEATURE_LEVEL_11_0,
|
||||
IID_PPV_ARGS(&mD3d12Device)));
|
||||
|
||||
backend::d3d12::Init(mD3d12Device, procs, device);
|
||||
mBackendDevice = *device;
|
||||
mProcTable = *procs;
|
||||
}
|
||||
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
if (mSwapchainImpl.userData == nullptr) {
|
||||
HWND win32Window = glfwGetWin32Window(mWindow);
|
||||
mSwapchainImpl = SwapChainImplD3D12::Create(win32Window, mProcTable);
|
||||
}
|
||||
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
|
||||
}
|
||||
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
mFactory = CreateFactory();
|
||||
ASSERT(GetHardwareAdapter(mFactory.Get(), &mHardwareAdapter));
|
||||
ASSERT_SUCCESS(D3D12CreateDevice(
|
||||
mHardwareAdapter.Get(),
|
||||
D3D_FEATURE_LEVEL_11_0,
|
||||
IID_PPV_ARGS(&mD3d12Device)
|
||||
));
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
|
||||
}
|
||||
|
||||
backend::d3d12::Init(mD3d12Device, procs, device);
|
||||
mBackendDevice = *device;
|
||||
mProcTable = *procs;
|
||||
}
|
||||
private:
|
||||
nxtDevice mBackendDevice = nullptr;
|
||||
nxtSwapChainImplementation mSwapchainImpl = {};
|
||||
nxtProcTable mProcTable = {};
|
||||
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
if (mSwapchainImpl.userData == nullptr) {
|
||||
HWND win32Window = glfwGetWin32Window(mWindow);
|
||||
mSwapchainImpl = SwapChainImplD3D12::Create(win32Window, mProcTable);
|
||||
// Initialization
|
||||
ComPtr<IDXGIFactory4> mFactory;
|
||||
ComPtr<IDXGIAdapter1> mHardwareAdapter;
|
||||
ComPtr<ID3D12Device> mD3d12Device;
|
||||
|
||||
static bool GetHardwareAdapter(IDXGIFactory4* factory, IDXGIAdapter1** hardwareAdapter) {
|
||||
*hardwareAdapter = nullptr;
|
||||
for (uint32_t adapterIndex = 0;; ++adapterIndex) {
|
||||
IDXGIAdapter1* adapter = nullptr;
|
||||
if (factory->EnumAdapters1(adapterIndex, &adapter) == DXGI_ERROR_NOT_FOUND) {
|
||||
break; // No more adapters to enumerate.
|
||||
}
|
||||
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
|
||||
}
|
||||
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
|
||||
}
|
||||
|
||||
private:
|
||||
nxtDevice mBackendDevice = nullptr;
|
||||
nxtSwapChainImplementation mSwapchainImpl = {};
|
||||
nxtProcTable mProcTable = {};
|
||||
|
||||
// Initialization
|
||||
ComPtr<IDXGIFactory4> mFactory;
|
||||
ComPtr<IDXGIAdapter1> mHardwareAdapter;
|
||||
ComPtr<ID3D12Device> mD3d12Device;
|
||||
|
||||
static bool GetHardwareAdapter(IDXGIFactory4* factory, IDXGIAdapter1** hardwareAdapter) {
|
||||
*hardwareAdapter = nullptr;
|
||||
for (uint32_t adapterIndex = 0; ; ++adapterIndex) {
|
||||
IDXGIAdapter1* adapter = nullptr;
|
||||
if (factory->EnumAdapters1(adapterIndex, &adapter) == DXGI_ERROR_NOT_FOUND) {
|
||||
break; // No more adapters to enumerate.
|
||||
}
|
||||
|
||||
// Check to see if the adapter supports Direct3D 12, but don't create the actual device yet.
|
||||
if (SUCCEEDED(D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_11_0, _uuidof(ID3D12Device), nullptr))) {
|
||||
*hardwareAdapter = adapter;
|
||||
return true;
|
||||
}
|
||||
adapter->Release();
|
||||
// Check to see if the adapter supports Direct3D 12, but don't create the actual
|
||||
// device yet.
|
||||
if (SUCCEEDED(D3D12CreateDevice(adapter, D3D_FEATURE_LEVEL_11_0,
|
||||
_uuidof(ID3D12Device), nullptr))) {
|
||||
*hardwareAdapter = adapter;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
adapter->Release();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
BackendBinding* CreateD3D12Binding() {
|
||||
return new D3D12Binding;
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace utils
|
||||
|
@ -22,132 +22,130 @@
|
||||
#include "GLFW/glfw3.h"
|
||||
#include "GLFW/glfw3native.h"
|
||||
|
||||
#import <QuartzCore/CAMetalLayer.h>
|
||||
#import <Metal/Metal.h>
|
||||
#import <QuartzCore/CAMetalLayer.h>
|
||||
|
||||
namespace backend {
|
||||
namespace metal {
|
||||
namespace backend { namespace metal {
|
||||
void Init(id<MTLDevice> metalDevice, nxtProcTable* procs, nxtDevice* device);
|
||||
void SetNextDrawable(nxtDevice device, id<CAMetalDrawable> drawable);
|
||||
void Present(nxtDevice device);
|
||||
}
|
||||
}
|
||||
}}
|
||||
|
||||
namespace utils {
|
||||
class SwapChainImplMTL : SwapChainImpl {
|
||||
public:
|
||||
static nxtSwapChainImplementation Create(id nswindow) {
|
||||
auto impl = GenerateSwapChainImplementation<SwapChainImplMTL, nxtWSIContextMetal>();
|
||||
impl.userData = new SwapChainImplMTL(nswindow);
|
||||
return impl;
|
||||
public:
|
||||
static nxtSwapChainImplementation Create(id nswindow) {
|
||||
auto impl = GenerateSwapChainImplementation<SwapChainImplMTL, nxtWSIContextMetal>();
|
||||
impl.userData = new SwapChainImplMTL(nswindow);
|
||||
return impl;
|
||||
}
|
||||
|
||||
private:
|
||||
id mNsWindow = nil;
|
||||
id<MTLDevice> mMtlDevice = nil;
|
||||
id<MTLCommandQueue> mCommandQueue = nil;
|
||||
|
||||
CAMetalLayer* mLayer = nullptr;
|
||||
id<CAMetalDrawable> mCurrentDrawable = nil;
|
||||
id<MTLTexture> mCurrentTexture = nil;
|
||||
|
||||
SwapChainImplMTL(id nsWindow) : mNsWindow(nsWindow) {
|
||||
}
|
||||
|
||||
~SwapChainImplMTL() {
|
||||
[mCurrentTexture release];
|
||||
[mCurrentDrawable release];
|
||||
}
|
||||
|
||||
// For GenerateSwapChainImplementation
|
||||
friend class SwapChainImpl;
|
||||
|
||||
void Init(nxtWSIContextMetal* ctx) {
|
||||
mMtlDevice = ctx->device;
|
||||
mCommandQueue = [mMtlDevice newCommandQueue];
|
||||
}
|
||||
|
||||
nxtSwapChainError Configure(nxtTextureFormat format,
|
||||
nxtTextureUsageBit,
|
||||
uint32_t width,
|
||||
uint32_t height) {
|
||||
if (format != NXT_TEXTURE_FORMAT_B8_G8_R8_A8_UNORM) {
|
||||
return "unsupported format";
|
||||
}
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
|
||||
private:
|
||||
id mNsWindow = nil;
|
||||
id<MTLDevice> mMtlDevice = nil;
|
||||
id<MTLCommandQueue> mCommandQueue = nil;
|
||||
NSView* contentView = [mNsWindow contentView];
|
||||
[contentView setWantsLayer:YES];
|
||||
|
||||
CAMetalLayer* mLayer = nullptr;
|
||||
id<CAMetalDrawable> mCurrentDrawable = nil;
|
||||
id<MTLTexture> mCurrentTexture = nil;
|
||||
CGSize size = {};
|
||||
size.width = width;
|
||||
size.height = height;
|
||||
|
||||
SwapChainImplMTL(id nsWindow)
|
||||
: mNsWindow(nsWindow) {
|
||||
}
|
||||
mLayer = [CAMetalLayer layer];
|
||||
[mLayer setDevice:mMtlDevice];
|
||||
[mLayer setPixelFormat:MTLPixelFormatBGRA8Unorm];
|
||||
[mLayer setFramebufferOnly:YES];
|
||||
[mLayer setDrawableSize:size];
|
||||
|
||||
~SwapChainImplMTL() {
|
||||
[mCurrentTexture release];
|
||||
[mCurrentDrawable release];
|
||||
}
|
||||
[contentView setLayer:mLayer];
|
||||
|
||||
// For GenerateSwapChainImplementation
|
||||
friend class SwapChainImpl;
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
void Init(nxtWSIContextMetal* ctx) {
|
||||
mMtlDevice = ctx->device;
|
||||
mCommandQueue = [mMtlDevice newCommandQueue];
|
||||
}
|
||||
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture* nextTexture) {
|
||||
[mCurrentDrawable release];
|
||||
mCurrentDrawable = [mLayer nextDrawable];
|
||||
[mCurrentDrawable retain];
|
||||
|
||||
nxtSwapChainError Configure(nxtTextureFormat format, nxtTextureUsageBit,
|
||||
uint32_t width, uint32_t height) {
|
||||
if (format != NXT_TEXTURE_FORMAT_B8_G8_R8_A8_UNORM) {
|
||||
return "unsupported format";
|
||||
}
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
[mCurrentTexture release];
|
||||
mCurrentTexture = mCurrentDrawable.texture;
|
||||
[mCurrentTexture retain];
|
||||
|
||||
NSView* contentView = [mNsWindow contentView];
|
||||
[contentView setWantsLayer: YES];
|
||||
nextTexture->texture = reinterpret_cast<void*>(mCurrentTexture);
|
||||
|
||||
CGSize size = {};
|
||||
size.width = width;
|
||||
size.height = height;
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
mLayer = [CAMetalLayer layer];
|
||||
[mLayer setDevice: mMtlDevice];
|
||||
[mLayer setPixelFormat: MTLPixelFormatBGRA8Unorm];
|
||||
[mLayer setFramebufferOnly: YES];
|
||||
[mLayer setDrawableSize: size];
|
||||
nxtSwapChainError Present() {
|
||||
id<MTLCommandBuffer> commandBuffer = [mCommandQueue commandBuffer];
|
||||
[commandBuffer presentDrawable:mCurrentDrawable];
|
||||
[commandBuffer commit];
|
||||
|
||||
[contentView setLayer: mLayer];
|
||||
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture* nextTexture) {
|
||||
[mCurrentDrawable release];
|
||||
mCurrentDrawable = [mLayer nextDrawable];
|
||||
[mCurrentDrawable retain];
|
||||
|
||||
[mCurrentTexture release];
|
||||
mCurrentTexture = mCurrentDrawable.texture;
|
||||
[mCurrentTexture retain];
|
||||
|
||||
nextTexture->texture = reinterpret_cast<void*>(mCurrentTexture);
|
||||
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError Present() {
|
||||
id<MTLCommandBuffer> commandBuffer = [mCommandQueue commandBuffer];
|
||||
[commandBuffer presentDrawable: mCurrentDrawable];
|
||||
[commandBuffer commit];
|
||||
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
};
|
||||
|
||||
class MetalBinding : public BackendBinding {
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
||||
}
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
mMetalDevice = MTLCreateSystemDefaultDevice();
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
|
||||
}
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
mMetalDevice = MTLCreateSystemDefaultDevice();
|
||||
|
||||
backend::metal::Init(mMetalDevice, procs, device);
|
||||
mBackendDevice = *device;
|
||||
}
|
||||
backend::metal::Init(mMetalDevice, procs, device);
|
||||
mBackendDevice = *device;
|
||||
}
|
||||
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
if (mSwapchainImpl.userData == nullptr) {
|
||||
mSwapchainImpl = SwapChainImplMTL::Create(glfwGetCocoaWindow(mWindow));
|
||||
}
|
||||
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
if (mSwapchainImpl.userData == nullptr) {
|
||||
mSwapchainImpl = SwapChainImplMTL::Create(glfwGetCocoaWindow(mWindow));
|
||||
}
|
||||
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
|
||||
}
|
||||
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_B8_G8_R8_A8_UNORM;
|
||||
}
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_B8_G8_R8_A8_UNORM;
|
||||
}
|
||||
|
||||
private:
|
||||
id<MTLDevice> mMetalDevice = nil;
|
||||
nxtDevice mBackendDevice = nullptr;
|
||||
nxtSwapChainImplementation mSwapchainImpl = {};
|
||||
private:
|
||||
id<MTLDevice> mMetalDevice = nil;
|
||||
nxtDevice mBackendDevice = nullptr;
|
||||
nxtSwapChainImplementation mSwapchainImpl = {};
|
||||
};
|
||||
|
||||
BackendBinding* CreateMetalBinding() {
|
||||
return new MetalBinding;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -25,7 +25,9 @@
|
||||
|
||||
namespace utils {
|
||||
|
||||
void FillShaderModuleBuilder(const nxt::ShaderModuleBuilder& builder, nxt::ShaderStage stage, const char* source) {
|
||||
void FillShaderModuleBuilder(const nxt::ShaderModuleBuilder& builder,
|
||||
nxt::ShaderStage stage,
|
||||
const char* source) {
|
||||
shaderc::Compiler compiler;
|
||||
shaderc::CompileOptions options;
|
||||
|
||||
@ -60,7 +62,8 @@ namespace utils {
|
||||
|
||||
#ifdef DUMP_SPIRV_ASSEMBLY
|
||||
{
|
||||
auto resultAsm = compiler.CompileGlslToSpvAssembly(source, strlen(source), kind, "myshader?", options);
|
||||
auto resultAsm = compiler.CompileGlslToSpvAssembly(source, strlen(source), kind,
|
||||
"myshader?", options);
|
||||
size_t sizeAsm = (resultAsm.cend() - resultAsm.cbegin());
|
||||
|
||||
char* buffer = reinterpret_cast<char*>(malloc(sizeAsm + 1));
|
||||
@ -86,21 +89,26 @@ namespace utils {
|
||||
#endif
|
||||
}
|
||||
|
||||
nxt::ShaderModule CreateShaderModule(const nxt::Device& device, nxt::ShaderStage stage, const char* source) {
|
||||
nxt::ShaderModule CreateShaderModule(const nxt::Device& device,
|
||||
nxt::ShaderStage stage,
|
||||
const char* source) {
|
||||
nxt::ShaderModuleBuilder builder = device.CreateShaderModuleBuilder();
|
||||
FillShaderModuleBuilder(builder, stage, source);
|
||||
return builder.GetResult();
|
||||
}
|
||||
|
||||
nxt::Buffer CreateFrozenBufferFromData(const nxt::Device& device, const void* data, uint32_t size, nxt::BufferUsageBit usage) {
|
||||
nxt::Buffer CreateFrozenBufferFromData(const nxt::Device& device,
|
||||
const void* data,
|
||||
uint32_t size,
|
||||
nxt::BufferUsageBit usage) {
|
||||
nxt::Buffer buffer = device.CreateBufferBuilder()
|
||||
.SetAllowedUsage(nxt::BufferUsageBit::TransferDst | usage)
|
||||
.SetInitialUsage(nxt::BufferUsageBit::TransferDst)
|
||||
.SetSize(size)
|
||||
.GetResult();
|
||||
.SetAllowedUsage(nxt::BufferUsageBit::TransferDst | usage)
|
||||
.SetInitialUsage(nxt::BufferUsageBit::TransferDst)
|
||||
.SetSize(size)
|
||||
.GetResult();
|
||||
buffer.SetSubData(0, size / sizeof(uint32_t), reinterpret_cast<const uint32_t*>(data));
|
||||
buffer.FreezeUsage(usage);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace utils
|
||||
|
@ -18,12 +18,23 @@
|
||||
|
||||
namespace utils {
|
||||
|
||||
void FillShaderModuleBuilder(const nxt::ShaderModuleBuilder& builder, nxt::ShaderStage stage, const char* source);
|
||||
nxt::ShaderModule CreateShaderModule(const nxt::Device& device, nxt::ShaderStage stage, const char* source);
|
||||
nxt::Buffer CreateFrozenBufferFromData(const nxt::Device& device, const void* data, uint32_t size, nxt::BufferUsageBit usage);
|
||||
void FillShaderModuleBuilder(const nxt::ShaderModuleBuilder& builder,
|
||||
nxt::ShaderStage stage,
|
||||
const char* source);
|
||||
nxt::ShaderModule CreateShaderModule(const nxt::Device& device,
|
||||
nxt::ShaderStage stage,
|
||||
const char* source);
|
||||
nxt::Buffer CreateFrozenBufferFromData(const nxt::Device& device,
|
||||
const void* data,
|
||||
uint32_t size,
|
||||
nxt::BufferUsageBit usage);
|
||||
|
||||
template<typename T>
|
||||
nxt::Buffer CreateFrozenBufferFromData(const nxt::Device& device, nxt::BufferUsageBit usage, std::initializer_list<T> data) {
|
||||
return CreateFrozenBufferFromData(device, data.begin(), uint32_t(sizeof(T) * data.size()), usage);
|
||||
template <typename T>
|
||||
nxt::Buffer CreateFrozenBufferFromData(const nxt::Device& device,
|
||||
nxt::BufferUsageBit usage,
|
||||
std::initializer_list<T> data) {
|
||||
return CreateFrozenBufferFromData(device, data.begin(), uint32_t(sizeof(T) * data.size()),
|
||||
usage);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace utils
|
||||
|
@ -14,32 +14,29 @@
|
||||
|
||||
#include "utils/BackendBinding.h"
|
||||
|
||||
namespace backend {
|
||||
namespace null {
|
||||
void Init(nxtProcTable* procs, nxtDevice* device);
|
||||
}
|
||||
}
|
||||
namespace backend { namespace null {
|
||||
void Init(nxtProcTable* procs, nxtDevice* device);
|
||||
}} // namespace backend::null
|
||||
|
||||
namespace utils {
|
||||
|
||||
class NullBinding : public BackendBinding {
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
}
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
backend::null::Init(procs, device);
|
||||
}
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
return 0;
|
||||
}
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
|
||||
}
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
}
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
backend::null::Init(procs, device);
|
||||
}
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
return 0;
|
||||
}
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
BackendBinding* CreateNullBinding() {
|
||||
return new NullBinding;
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace utils
|
||||
|
@ -19,130 +19,131 @@
|
||||
#include "nxt/nxt_wsi.h"
|
||||
#include "utils/SwapChainImpl.h"
|
||||
|
||||
#include <cstdio>
|
||||
// Glad needs to be included before GLFW otherwise it complain that GL.h was already included
|
||||
#include "glad/glad.h"
|
||||
|
||||
#include <cstdio>
|
||||
#include "GLFW/glfw3.h"
|
||||
|
||||
namespace backend {
|
||||
namespace opengl {
|
||||
void Init(void* (*getProc)(const char*), nxtProcTable* procs, nxtDevice* device);
|
||||
}
|
||||
}
|
||||
namespace backend { namespace opengl {
|
||||
void Init(void* (*getProc)(const char*), nxtProcTable* procs, nxtDevice* device);
|
||||
}} // namespace backend::opengl
|
||||
|
||||
namespace utils {
|
||||
class SwapChainImplGL : SwapChainImpl {
|
||||
public:
|
||||
static nxtSwapChainImplementation Create(GLFWwindow* window) {
|
||||
auto impl = GenerateSwapChainImplementation<SwapChainImplGL, nxtWSIContextGL>();
|
||||
impl.userData = new SwapChainImplGL(window);
|
||||
return impl;
|
||||
public:
|
||||
static nxtSwapChainImplementation Create(GLFWwindow* window) {
|
||||
auto impl = GenerateSwapChainImplementation<SwapChainImplGL, nxtWSIContextGL>();
|
||||
impl.userData = new SwapChainImplGL(window);
|
||||
return impl;
|
||||
}
|
||||
|
||||
private:
|
||||
GLFWwindow* mWindow = nullptr;
|
||||
uint32_t mWidth = 0;
|
||||
uint32_t mHeight = 0;
|
||||
GLuint mBackFBO = 0;
|
||||
GLuint mBackTexture = 0;
|
||||
|
||||
SwapChainImplGL(GLFWwindow* window) : mWindow(window) {
|
||||
}
|
||||
|
||||
~SwapChainImplGL() {
|
||||
glDeleteTextures(1, &mBackTexture);
|
||||
glDeleteFramebuffers(1, &mBackFBO);
|
||||
}
|
||||
|
||||
// For GenerateSwapChainImplementation
|
||||
friend class SwapChainImpl;
|
||||
|
||||
void Init(nxtWSIContextGL*) {
|
||||
glGenTextures(1, &mBackTexture);
|
||||
glBindTexture(GL_TEXTURE_2D, mBackTexture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
|
||||
glGenFramebuffers(1, &mBackFBO);
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, mBackFBO);
|
||||
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
|
||||
mBackTexture, 0);
|
||||
}
|
||||
|
||||
nxtSwapChainError Configure(nxtTextureFormat format,
|
||||
nxtTextureUsageBit,
|
||||
uint32_t width,
|
||||
uint32_t height) {
|
||||
if (format != NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM) {
|
||||
return "unsupported format";
|
||||
}
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
mWidth = width;
|
||||
mHeight = height;
|
||||
|
||||
private:
|
||||
GLFWwindow* mWindow = nullptr;
|
||||
uint32_t mWidth = 0;
|
||||
uint32_t mHeight = 0;
|
||||
GLuint mBackFBO = 0;
|
||||
GLuint mBackTexture = 0;
|
||||
glBindTexture(GL_TEXTURE_2D, mBackTexture);
|
||||
// Reallocate the texture
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
|
||||
nullptr);
|
||||
|
||||
SwapChainImplGL(GLFWwindow* window)
|
||||
: mWindow(window) {
|
||||
}
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
~SwapChainImplGL() {
|
||||
glDeleteTextures(1, &mBackTexture);
|
||||
glDeleteFramebuffers(1, &mBackFBO);
|
||||
}
|
||||
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture* nextTexture) {
|
||||
nextTexture->texture = reinterpret_cast<void*>(static_cast<size_t>(mBackTexture));
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
// For GenerateSwapChainImplementation
|
||||
friend class SwapChainImpl;
|
||||
nxtSwapChainError Present() {
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, mBackFBO);
|
||||
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
||||
glBlitFramebuffer(0, 0, mWidth, mHeight, 0, 0, mWidth, mHeight, GL_COLOR_BUFFER_BIT,
|
||||
GL_NEAREST);
|
||||
glfwSwapBuffers(mWindow);
|
||||
|
||||
void Init(nxtWSIContextGL*) {
|
||||
glGenTextures(1, &mBackTexture);
|
||||
glBindTexture(GL_TEXTURE_2D, mBackTexture);
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, 0,
|
||||
GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
|
||||
glGenFramebuffers(1, &mBackFBO);
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, mBackFBO);
|
||||
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
|
||||
GL_TEXTURE_2D, mBackTexture, 0);
|
||||
}
|
||||
|
||||
nxtSwapChainError Configure(nxtTextureFormat format, nxtTextureUsageBit,
|
||||
uint32_t width, uint32_t height) {
|
||||
if (format != NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM) {
|
||||
return "unsupported format";
|
||||
}
|
||||
ASSERT(width > 0);
|
||||
ASSERT(height > 0);
|
||||
mWidth = width;
|
||||
mHeight = height;
|
||||
|
||||
glBindTexture(GL_TEXTURE_2D, mBackTexture);
|
||||
// Reallocate the texture
|
||||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0,
|
||||
GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
|
||||
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture* nextTexture) {
|
||||
nextTexture->texture = reinterpret_cast<void*>(static_cast<size_t>(mBackTexture));
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError Present() {
|
||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, mBackFBO);
|
||||
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
|
||||
glBlitFramebuffer(0, 0, mWidth, mHeight, 0, 0, mWidth, mHeight,
|
||||
GL_COLOR_BUFFER_BIT, GL_NEAREST);
|
||||
glfwSwapBuffers(mWindow);
|
||||
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
};
|
||||
|
||||
class OpenGLBinding : public BackendBinding {
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
#if defined(NXT_PLATFORM_APPLE)
|
||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
|
||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
|
||||
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
|
||||
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
||||
#else
|
||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
|
||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
|
||||
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
|
||||
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
||||
#endif
|
||||
}
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
glfwMakeContextCurrent(mWindow);
|
||||
backend::opengl::Init(reinterpret_cast<void*(*)(const char*)>(glfwGetProcAddress), procs, device);
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
#if defined(NXT_PLATFORM_APPLE)
|
||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
|
||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
|
||||
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
|
||||
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
||||
#else
|
||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
|
||||
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
|
||||
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
|
||||
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
||||
#endif
|
||||
}
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
glfwMakeContextCurrent(mWindow);
|
||||
backend::opengl::Init(reinterpret_cast<void* (*)(const char*)>(glfwGetProcAddress),
|
||||
procs, device);
|
||||
|
||||
mBackendDevice = *device;
|
||||
}
|
||||
mBackendDevice = *device;
|
||||
}
|
||||
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
if (mSwapchainImpl.userData == nullptr) {
|
||||
mSwapchainImpl = SwapChainImplGL::Create(mWindow);
|
||||
}
|
||||
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
if (mSwapchainImpl.userData == nullptr) {
|
||||
mSwapchainImpl = SwapChainImplGL::Create(mWindow);
|
||||
}
|
||||
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
|
||||
}
|
||||
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
|
||||
}
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
|
||||
}
|
||||
|
||||
private:
|
||||
nxtDevice mBackendDevice = nullptr;
|
||||
nxtSwapChainImplementation mSwapchainImpl = {};
|
||||
private:
|
||||
nxtDevice mBackendDevice = nullptr;
|
||||
nxtSwapChainImplementation mSwapchainImpl = {};
|
||||
};
|
||||
|
||||
BackendBinding* CreateOpenGLBinding() {
|
||||
return new OpenGLBinding;
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace utils
|
||||
|
@ -17,30 +17,29 @@
|
||||
|
||||
namespace utils {
|
||||
class SwapChainImpl {
|
||||
protected:
|
||||
template<class TImpl, typename TWSIContext>
|
||||
static nxtSwapChainImplementation GenerateSwapChainImplementation() {
|
||||
nxtSwapChainImplementation impl = {};
|
||||
impl.Init = [](void* userData, void* wsiContext) {
|
||||
auto* ctx = reinterpret_cast<TWSIContext*>(wsiContext);
|
||||
reinterpret_cast<TImpl*>(userData)->Init(ctx);
|
||||
};
|
||||
impl.Destroy = [](void* userData) {
|
||||
delete reinterpret_cast<TImpl*>(userData);
|
||||
};
|
||||
impl.Configure = [](void* userData, nxtTextureFormat format, nxtTextureUsageBit allowedUsage, uint32_t width, uint32_t height) {
|
||||
return reinterpret_cast<TImpl*>(userData)->Configure(format, allowedUsage, width, height);
|
||||
};
|
||||
impl.GetNextTexture = [](void* userData, nxtSwapChainNextTexture* nextTexture) {
|
||||
return reinterpret_cast<TImpl*>(userData)->GetNextTexture(
|
||||
nextTexture);
|
||||
};
|
||||
impl.Present = [](void* userData) {
|
||||
return reinterpret_cast<TImpl*>(userData)->Present();
|
||||
};
|
||||
return impl;
|
||||
}
|
||||
protected:
|
||||
template <class TImpl, typename TWSIContext>
|
||||
static nxtSwapChainImplementation GenerateSwapChainImplementation() {
|
||||
nxtSwapChainImplementation impl = {};
|
||||
impl.Init = [](void* userData, void* wsiContext) {
|
||||
auto* ctx = reinterpret_cast<TWSIContext*>(wsiContext);
|
||||
reinterpret_cast<TImpl*>(userData)->Init(ctx);
|
||||
};
|
||||
impl.Destroy = [](void* userData) { delete reinterpret_cast<TImpl*>(userData); };
|
||||
impl.Configure = [](void* userData, nxtTextureFormat format,
|
||||
nxtTextureUsageBit allowedUsage, uint32_t width, uint32_t height) {
|
||||
return reinterpret_cast<TImpl*>(userData)->Configure(format, allowedUsage, width,
|
||||
height);
|
||||
};
|
||||
impl.GetNextTexture = [](void* userData, nxtSwapChainNextTexture* nextTexture) {
|
||||
return reinterpret_cast<TImpl*>(userData)->GetNextTexture(nextTexture);
|
||||
};
|
||||
impl.Present = [](void* userData) {
|
||||
return reinterpret_cast<TImpl*>(userData)->Present();
|
||||
};
|
||||
return impl;
|
||||
}
|
||||
};
|
||||
}
|
||||
} // namespace utils
|
||||
|
||||
#endif // UTILS_SWAPCHAINIMPL_H_
|
||||
#endif // UTILS_SWAPCHAINIMPL_H_
|
||||
|
@ -15,25 +15,25 @@
|
||||
#include "common/Platform.h"
|
||||
|
||||
#if defined(NXT_PLATFORM_WINDOWS)
|
||||
#include <Windows.h>
|
||||
# include <Windows.h>
|
||||
#elif defined(NXT_PLATFORM_POSIX)
|
||||
#include <unistd.h>
|
||||
# include <unistd.h>
|
||||
#else
|
||||
#error "Unsupported platform."
|
||||
# error "Unsupported platform."
|
||||
#endif
|
||||
|
||||
namespace utils {
|
||||
|
||||
#if defined(NXT_PLATFORM_WINDOWS)
|
||||
void USleep(unsigned int usecs) {
|
||||
Sleep(static_cast<DWORD>(usecs / 1000));
|
||||
}
|
||||
#elif defined(NXT_PLATFORM_POSIX)
|
||||
void USleep(unsigned int usecs) {
|
||||
usleep(usecs);
|
||||
}
|
||||
#else
|
||||
#error "Implement USleep for your platform."
|
||||
#endif
|
||||
#if defined(NXT_PLATFORM_WINDOWS)
|
||||
void USleep(unsigned int usecs) {
|
||||
Sleep(static_cast<DWORD>(usecs / 1000));
|
||||
}
|
||||
#elif defined(NXT_PLATFORM_POSIX)
|
||||
void USleep(unsigned int usecs) {
|
||||
usleep(usecs);
|
||||
}
|
||||
#else
|
||||
# error "Implement USleep for your platform."
|
||||
#endif
|
||||
|
||||
}
|
||||
} // namespace utils
|
||||
|
@ -15,5 +15,4 @@
|
||||
namespace utils {
|
||||
|
||||
void USleep(unsigned int usecs);
|
||||
|
||||
}
|
||||
|
@ -17,75 +17,71 @@
|
||||
#include "nxt/nxt_wsi.h"
|
||||
#include "utils/SwapChainImpl.h"
|
||||
|
||||
namespace backend {
|
||||
namespace vulkan {
|
||||
void Init(nxtProcTable* procs, nxtDevice* device);
|
||||
}
|
||||
}
|
||||
namespace backend { namespace vulkan {
|
||||
void Init(nxtProcTable* procs, nxtDevice* device);
|
||||
}} // namespace backend::vulkan
|
||||
|
||||
namespace utils {
|
||||
|
||||
class SwapChainImplVulkan : SwapChainImpl {
|
||||
public:
|
||||
static nxtSwapChainImplementation Create(GLFWwindow* window) {
|
||||
auto impl = GenerateSwapChainImplementation<SwapChainImplVulkan, nxtWSIContextVulkan>();
|
||||
impl.userData = new SwapChainImplVulkan(window);
|
||||
return impl;
|
||||
}
|
||||
public:
|
||||
static nxtSwapChainImplementation Create(GLFWwindow* window) {
|
||||
auto impl = GenerateSwapChainImplementation<SwapChainImplVulkan, nxtWSIContextVulkan>();
|
||||
impl.userData = new SwapChainImplVulkan(window);
|
||||
return impl;
|
||||
}
|
||||
|
||||
private:
|
||||
GLFWwindow* window = nullptr;
|
||||
private:
|
||||
GLFWwindow* window = nullptr;
|
||||
|
||||
SwapChainImplVulkan(GLFWwindow* window)
|
||||
: window(window) {
|
||||
}
|
||||
SwapChainImplVulkan(GLFWwindow* window) : window(window) {
|
||||
}
|
||||
|
||||
~SwapChainImplVulkan() {
|
||||
}
|
||||
~SwapChainImplVulkan() {
|
||||
}
|
||||
|
||||
// For GenerateSwapChainImplementation
|
||||
friend class SwapChainImpl;
|
||||
// For GenerateSwapChainImplementation
|
||||
friend class SwapChainImpl;
|
||||
|
||||
void Init(nxtWSIContextVulkan*) {
|
||||
}
|
||||
void Init(nxtWSIContextVulkan*) {
|
||||
}
|
||||
|
||||
nxtSwapChainError Configure(nxtTextureFormat, nxtTextureUsageBit, uint32_t, uint32_t) {
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
nxtSwapChainError Configure(nxtTextureFormat, nxtTextureUsageBit, uint32_t, uint32_t) {
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture*) {
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
nxtSwapChainError GetNextTexture(nxtSwapChainNextTexture*) {
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
|
||||
nxtSwapChainError Present() {
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
nxtSwapChainError Present() {
|
||||
return NXT_SWAP_CHAIN_NO_ERROR;
|
||||
}
|
||||
};
|
||||
|
||||
class VulkanBinding : public BackendBinding {
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
}
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
backend::vulkan::Init(procs, device);
|
||||
}
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
if (mSwapchainImpl.userData == nullptr) {
|
||||
mSwapchainImpl = SwapChainImplVulkan::Create(mWindow);
|
||||
}
|
||||
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
|
||||
}
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
|
||||
public:
|
||||
void SetupGLFWWindowHints() override {
|
||||
}
|
||||
void GetProcAndDevice(nxtProcTable* procs, nxtDevice* device) override {
|
||||
backend::vulkan::Init(procs, device);
|
||||
}
|
||||
uint64_t GetSwapChainImplementation() override {
|
||||
if (mSwapchainImpl.userData == nullptr) {
|
||||
mSwapchainImpl = SwapChainImplVulkan::Create(mWindow);
|
||||
}
|
||||
return reinterpret_cast<uint64_t>(&mSwapchainImpl);
|
||||
}
|
||||
nxtTextureFormat GetPreferredSwapChainTextureFormat() override {
|
||||
return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM;
|
||||
}
|
||||
|
||||
private:
|
||||
nxtSwapChainImplementation mSwapchainImpl = {};
|
||||
private:
|
||||
nxtSwapChainImplementation mSwapchainImpl = {};
|
||||
};
|
||||
|
||||
|
||||
BackendBinding* CreateVulkanBinding() {
|
||||
return new VulkanBinding;
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace utils
|
||||
|
@ -14,8 +14,7 @@
|
||||
|
||||
#include "wire/TerribleCommandBuffer.h"
|
||||
|
||||
namespace nxt {
|
||||
namespace wire {
|
||||
namespace nxt { namespace wire {
|
||||
|
||||
TerribleCommandBuffer::TerribleCommandBuffer() {
|
||||
}
|
||||
@ -48,5 +47,4 @@ namespace wire {
|
||||
mOffset = 0;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}} // namespace nxt::wire
|
||||
|
@ -19,11 +19,10 @@
|
||||
|
||||
#include "wire/Wire.h"
|
||||
|
||||
namespace nxt {
|
||||
namespace wire {
|
||||
namespace nxt { namespace wire {
|
||||
|
||||
class TerribleCommandBuffer : public CommandSerializer {
|
||||
public:
|
||||
class TerribleCommandBuffer : public CommandSerializer {
|
||||
public:
|
||||
TerribleCommandBuffer();
|
||||
TerribleCommandBuffer(CommandHandler* handler);
|
||||
|
||||
@ -32,13 +31,12 @@ class TerribleCommandBuffer : public CommandSerializer {
|
||||
void* GetCmdSpace(size_t size) override;
|
||||
void Flush() override;
|
||||
|
||||
private:
|
||||
private:
|
||||
CommandHandler* mHandler = nullptr;
|
||||
size_t mOffset = 0;
|
||||
uint8_t mBuffer[10000000];
|
||||
};
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
}} // namespace nxt::wire
|
||||
|
||||
#endif // WIRE_TERRIBLE_COMMAND_BUFFER_H_
|
||||
#endif // WIRE_TERRIBLE_COMMAND_BUFFER_H_
|
||||
|
@ -19,26 +19,28 @@
|
||||
|
||||
#include "nxt/nxt.h"
|
||||
|
||||
namespace nxt {
|
||||
namespace wire {
|
||||
namespace nxt { namespace wire {
|
||||
|
||||
class CommandSerializer {
|
||||
public:
|
||||
virtual ~CommandSerializer() = default;
|
||||
virtual void* GetCmdSpace(size_t size) = 0;
|
||||
virtual void Flush() = 0;
|
||||
public:
|
||||
virtual ~CommandSerializer() = default;
|
||||
virtual void* GetCmdSpace(size_t size) = 0;
|
||||
virtual void Flush() = 0;
|
||||
};
|
||||
|
||||
class CommandHandler {
|
||||
public:
|
||||
virtual ~CommandHandler() = default;
|
||||
virtual const uint8_t* HandleCommands(const uint8_t* commands, size_t size) = 0;
|
||||
public:
|
||||
virtual ~CommandHandler() = default;
|
||||
virtual const uint8_t* HandleCommands(const uint8_t* commands, size_t size) = 0;
|
||||
};
|
||||
|
||||
CommandHandler* NewClientDevice(nxtProcTable* procs, nxtDevice* device, CommandSerializer* serializer);
|
||||
CommandHandler* NewServerCommandHandler(nxtDevice device, const nxtProcTable& procs, CommandSerializer* serializer);
|
||||
CommandHandler* NewClientDevice(nxtProcTable* procs,
|
||||
nxtDevice* device,
|
||||
CommandSerializer* serializer);
|
||||
CommandHandler* NewServerCommandHandler(nxtDevice device,
|
||||
const nxtProcTable& procs,
|
||||
CommandSerializer* serializer);
|
||||
|
||||
}
|
||||
}
|
||||
}} // namespace nxt::wire
|
||||
|
||||
#endif // WIRE_WIRE_H_
|
||||
#endif // WIRE_WIRE_H_
|
||||
|
@ -14,8 +14,7 @@
|
||||
|
||||
#include "wire/WireCmd.h"
|
||||
|
||||
namespace nxt {
|
||||
namespace wire {
|
||||
namespace nxt { namespace wire {
|
||||
|
||||
size_t ReturnDeviceErrorCallbackCmd::GetRequiredSize() const {
|
||||
return sizeof(*this) + messageStrlen + 1;
|
||||
@ -45,5 +44,4 @@ namespace wire {
|
||||
return this + 1;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}} // namespace nxt::wire
|
||||
|
@ -17,8 +17,7 @@
|
||||
|
||||
#include "wire/WireCmd_autogen.h"
|
||||
|
||||
namespace nxt {
|
||||
namespace wire {
|
||||
namespace nxt { namespace wire {
|
||||
|
||||
struct ReturnDeviceErrorCallbackCmd {
|
||||
wire::ReturnWireCmd commandId = ReturnWireCmd::DeviceErrorCallback;
|
||||
@ -55,7 +54,6 @@ namespace wire {
|
||||
const void* GetData() const;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
}} // namespace nxt::wire
|
||||
|
||||
#endif // WIRE_WIRECMD_H_
|
||||
#endif // WIRE_WIRECMD_H_
|
||||
|
Loading…
x
Reference in New Issue
Block a user