diff --git a/src/common/Assert.cpp b/src/common/Assert.cpp index 9d87f4258c..82529667c9 100644 --- a/src/common/Assert.cpp +++ b/src/common/Assert.cpp @@ -16,7 +16,11 @@ #include -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(); } diff --git a/src/common/Assert.h b/src/common/Assert.h index 3c96370d3f..71d730e99b 100644 --- a/src/common/Assert.h +++ b/src/common/Assert.h @@ -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_ diff --git a/src/common/BitSetIterator.h b/src/common/BitSetIterator.h index 48f0e171cd..ba2cc62126 100644 --- a/src/common/BitSetIterator.h +++ b/src/common/BitSetIterator.h @@ -21,7 +21,6 @@ #include #include - // 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 class BitSetIterator final { - public: - BitSetIterator(const std::bitset& bitset); - BitSetIterator(const BitSetIterator& other); - BitSetIterator &operator=(const BitSetIterator& other); + public: + BitSetIterator(const std::bitset& bitset); + BitSetIterator(const BitSetIterator& other); + BitSetIterator& operator=(const BitSetIterator& other); - class Iterator final { - public: - Iterator(const std::bitset& bits); - Iterator& operator++(); + class Iterator final { + public: + Iterator(const std::bitset& bits); + Iterator& operator++(); - bool operator==(const Iterator& other) const; - bool operator!=(const Iterator& other) const; - T operator*() const { return static_cast(mCurrentBit); } + bool operator==(const Iterator& other) const; + bool operator!=(const Iterator& other) const; + T operator*() const { + return static_cast(mCurrentBit); + } - private: - unsigned long getNextBit(); + private: + unsigned long getNextBit(); - static const size_t BitsPerWord = sizeof(uint32_t) * 8; - std::bitset mBits; - unsigned long mCurrentBit; - unsigned long mOffset; - }; + static const size_t BitsPerWord = sizeof(uint32_t) * 8; + std::bitset mBits; + unsigned long mCurrentBit; + unsigned long mOffset; + }; - Iterator begin() const { return Iterator(mBits); } - Iterator end() const { return Iterator(std::bitset(0)); } + Iterator begin() const { + return Iterator(mBits); + } + Iterator end() const { + return Iterator(std::bitset(0)); + } - private: - const std::bitset mBits; + private: + const std::bitset mBits; }; template -BitSetIterator::BitSetIterator(const std::bitset& bitset) - : mBits(bitset) { +BitSetIterator::BitSetIterator(const std::bitset& bitset) : mBits(bitset) { } template -BitSetIterator::BitSetIterator(const BitSetIterator& other) - : mBits(other.mBits) { +BitSetIterator::BitSetIterator(const BitSetIterator& other) : mBits(other.mBits) { } template diff --git a/src/common/Compiler.h b/src/common/Compiler.h index a6d84ae242..ba7aa48d9e 100644 --- a/src/common/Compiler.h +++ b/src/common/Compiler.h @@ -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_ diff --git a/src/common/Constants.h b/src/common/Constants.h index ecd6231aa5..5bf3c41180 100644 --- a/src/common/Constants.h +++ b/src/common/Constants.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_ diff --git a/src/common/DynamicLib.cpp b/src/common/DynamicLib.cpp index 979d486160..74eb3379a7 100644 --- a/src/common/DynamicLib.cpp +++ b/src/common/DynamicLib.cpp @@ -17,11 +17,11 @@ #include "common/Platform.h" #if NXT_PLATFORM_WINDOWS - #include +# include #elif NXT_PLATFORM_POSIX - #include +# include #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(mHandle)); - #elif NXT_PLATFORM_POSIX - dlclose(mHandle); - #else - #error "Unsupported platform for DynamicLib" - #endif +#if NXT_PLATFORM_WINDOWS + FreeLibrary(static_cast(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(GetProcAddress(static_cast(mHandle), procName.c_str())); +#if NXT_PLATFORM_WINDOWS + proc = reinterpret_cast(GetProcAddress(static_cast(mHandle), procName.c_str())); - if (proc == nullptr && error != nullptr) { - *error = "Windows Error: " + std::to_string(GetLastError()); - } - #elif NXT_PLATFORM_POSIX - proc = reinterpret_cast(dlsym(mHandle, procName.c_str())); + if (proc == nullptr && error != nullptr) { + *error = "Windows Error: " + std::to_string(GetLastError()); + } +#elif NXT_PLATFORM_POSIX + proc = reinterpret_cast(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; } diff --git a/src/common/DynamicLib.h b/src/common/DynamicLib.h index 25e52cb84f..66bf4181c5 100644 --- a/src/common/DynamicLib.h +++ b/src/common/DynamicLib.h @@ -21,34 +21,34 @@ #include 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 - bool GetProc(T** proc, const std::string& procName, std::string* error = nullptr) const { - ASSERT(proc != nullptr); - static_assert(std::is_function::value, ""); + template + bool GetProc(T** proc, const std::string& procName, std::string* error = nullptr) const { + ASSERT(proc != nullptr); + static_assert(std::is_function::value, ""); - *proc = reinterpret_cast(GetProc(procName, error)); - return *proc != nullptr; - } + *proc = reinterpret_cast(GetProc(procName, error)); + return *proc != nullptr; + } - private: - void* mHandle = nullptr; + private: + void* mHandle = nullptr; }; -#endif // COMMON_DYNAMICLIB_H_ +#endif // COMMON_DYNAMICLIB_H_ diff --git a/src/common/Math.cpp b/src/common/Math.cpp index 3632630b89..cf3a2a6c23 100644 --- a/src/common/Math.cpp +++ b/src/common/Math.cpp @@ -17,31 +17,31 @@ #include "common/Assert.h" #if defined(NXT_COMPILER_MSVC) - #include +# include #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(__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(__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(__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(__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((reinterpret_cast(ptr) + (alignment - 1)) & ~(alignment - 1)); + return reinterpret_cast((reinterpret_cast(ptr) + (alignment - 1)) & + ~(alignment - 1)); } bool IsAligned(uint32_t value, size_t alignment) { diff --git a/src/common/Math.h b/src/common/Math.h index c71b531987..be5871cef5 100644 --- a/src/common/Math.h +++ b/src/common/Math.h @@ -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 +template T* AlignPtr(T* ptr, size_t alignment) { return reinterpret_cast(AlignVoidPtr(ptr, alignment)); } -template +template const T* AlignPtr(const T* ptr, size_t alignment) { return reinterpret_cast(AlignVoidPtr(const_cast(ptr), alignment)); } -#endif // COMMON_MATH_H_ +#endif // COMMON_MATH_H_ diff --git a/src/common/Platform.h b/src/common/Platform.h index 1c7c8454cb..c1bef68b84 100644 --- a/src/common/Platform.h +++ b/src/common/Platform.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_ diff --git a/src/common/Serial.h b/src/common/Serial.h index d97c7869f0..30a840167a 100644 --- a/src/common/Serial.h +++ b/src/common/Serial.h @@ -19,4 +19,4 @@ using Serial = uint64_t; -#endif // COMMON_SERIAL_H_ +#endif // COMMON_SERIAL_H_ diff --git a/src/common/SerialQueue.h b/src/common/SerialQueue.h index 7edb196f3b..f82f310ea1 100644 --- a/src/common/SerialQueue.h +++ b/src/common/SerialQueue.h @@ -21,101 +21,101 @@ #include #include -template +template class SerialQueue { - private: - using SerialPair = std::pair>; - using Storage = std::vector; - using StorageIterator = typename Storage::iterator; - using ConstStorageIterator = typename Storage::const_iterator; + private: + using SerialPair = std::pair>; + using Storage = std::vector; + 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& values, Serial serial); - void Enqueue(std::vector&& 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& values, Serial serial); + void Enqueue(std::vector&& 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 +template void SerialQueue::Enqueue(const T& value, Serial serial) { NXT_ASSERT(Empty() || mStorage.back().first <= serial); @@ -125,7 +125,7 @@ void SerialQueue::Enqueue(const T& value, Serial serial) { mStorage.back().second.emplace_back(value); } -template +template void SerialQueue::Enqueue(T&& value, Serial serial) { NXT_ASSERT(Empty() || mStorage.back().first <= serial); @@ -135,132 +135,133 @@ void SerialQueue::Enqueue(T&& value, Serial serial) { mStorage.back().second.emplace_back(value); } -template +template void SerialQueue::Enqueue(const std::vector& values, Serial serial) { NXT_ASSERT(values.size() > 0); NXT_ASSERT(Empty() || mStorage.back().first <= serial); mStorage.emplace_back(SerialPair(serial, {values})); } -template +template void SerialQueue::Enqueue(std::vector&& values, Serial serial) { NXT_ASSERT(values.size() > 0); NXT_ASSERT(Empty() || mStorage.back().first <= serial); mStorage.emplace_back(SerialPair(serial, {values})); } -template +template bool SerialQueue::Empty() const { return mStorage.empty(); } -template +template typename SerialQueue::ConstBeginEnd SerialQueue::IterateAll() const { return {mStorage.begin(), mStorage.end()}; } -template +template typename SerialQueue::ConstBeginEnd SerialQueue::IterateUpTo(Serial serial) const { return {mStorage.begin(), FindUpTo(serial)}; } -template +template typename SerialQueue::BeginEnd SerialQueue::IterateAll() { return {mStorage.begin(), mStorage.end()}; } -template +template typename SerialQueue::BeginEnd SerialQueue::IterateUpTo(Serial serial) { return {mStorage.begin(), FindUpTo(serial)}; } -template +template void SerialQueue::Clear() { mStorage.clear(); } -template +template void SerialQueue::ClearUpTo(Serial serial) { mStorage.erase(mStorage.begin(), FindUpTo(serial)); } -template +template Serial SerialQueue::FirstSerial() const { NXT_ASSERT(!Empty()); return mStorage.front().first; } -template +template typename SerialQueue::ConstStorageIterator SerialQueue::FindUpTo(Serial serial) const { auto it = mStorage.begin(); while (it != mStorage.end() && it->first <= serial) { - it ++; + it++; } return it; } -template +template typename SerialQueue::StorageIterator SerialQueue::FindUpTo(Serial serial) { auto it = mStorage.begin(); while (it != mStorage.end() && it->first <= serial) { - it ++; + it++; } return it; } // SerialQueue::BeginEnd -template -SerialQueue::BeginEnd::BeginEnd(typename SerialQueue::StorageIterator start, typename SerialQueue::StorageIterator end) +template +SerialQueue::BeginEnd::BeginEnd(typename SerialQueue::StorageIterator start, + typename SerialQueue::StorageIterator end) : mStartIt(start), mEndIt(end) { } -template +template typename SerialQueue::Iterator SerialQueue::BeginEnd::begin() const { return {mStartIt}; } -template +template typename SerialQueue::Iterator SerialQueue::BeginEnd::end() const { return {mEndIt}; } // SerialQueue::Iterator -template +template SerialQueue::Iterator::Iterator(typename SerialQueue::StorageIterator start) : mStorageIterator(start), mSerialIterator(nullptr) { } -template +template typename SerialQueue::Iterator& SerialQueue::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 +template bool SerialQueue::Iterator::operator==(const typename SerialQueue::Iterator& other) const { return other.mStorageIterator == mStorageIterator && other.mSerialIterator == mSerialIterator; } -template +template bool SerialQueue::Iterator::operator!=(const typename SerialQueue::Iterator& other) const { return !(*this == other); } -template +template T& SerialQueue::Iterator::operator*() const { if (mSerialIterator == nullptr) { return *mStorageIterator->second.begin(); @@ -270,57 +271,60 @@ T& SerialQueue::Iterator::operator*() const { // SerialQueue::ConstBeginEnd -template -SerialQueue::ConstBeginEnd::ConstBeginEnd(typename SerialQueue::ConstStorageIterator start, typename SerialQueue::ConstStorageIterator end) +template +SerialQueue::ConstBeginEnd::ConstBeginEnd(typename SerialQueue::ConstStorageIterator start, + typename SerialQueue::ConstStorageIterator end) : mStartIt(start), mEndIt(end) { } -template +template typename SerialQueue::ConstIterator SerialQueue::ConstBeginEnd::begin() const { return {mStartIt}; } -template +template typename SerialQueue::ConstIterator SerialQueue::ConstBeginEnd::end() const { return {mEndIt}; } // SerialQueue::ConstIterator -template +template SerialQueue::ConstIterator::ConstIterator(typename SerialQueue::ConstStorageIterator start) : mStorageIterator(start), mSerialIterator(nullptr) { } -template +template typename SerialQueue::ConstIterator& SerialQueue::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 -bool SerialQueue::ConstIterator::operator==(const typename SerialQueue::ConstIterator& other) const { +template +bool SerialQueue::ConstIterator::operator==( + const typename SerialQueue::ConstIterator& other) const { return other.mStorageIterator == mStorageIterator && other.mSerialIterator == mSerialIterator; } -template -bool SerialQueue::ConstIterator::operator!=(const typename SerialQueue::ConstIterator& other) const { +template +bool SerialQueue::ConstIterator::operator!=( + const typename SerialQueue::ConstIterator& other) const { return !(*this == other); } -template +template const T& SerialQueue::ConstIterator::operator*() const { if (mSerialIterator == nullptr) { return *mStorageIterator->second.begin(); @@ -328,4 +332,4 @@ const T& SerialQueue::ConstIterator::operator*() const { return *mSerialIterator; } -#endif // COMMON_SERIALQUEUE_H_ +#endif // COMMON_SERIALQUEUE_H_ diff --git a/src/utils/BackendBinding.cpp b/src/utils/BackendBinding.cpp index 1d520b3bb5..60a42fd49b 100644 --- a/src/utils/BackendBinding.cpp +++ b/src/utils/BackendBinding.cpp @@ -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 diff --git a/src/utils/BackendBinding.h b/src/utils/BackendBinding.h index d7328d2c2c..bab8a46888 100644 --- a/src/utils/BackendBinding.h +++ b/src/utils/BackendBinding.h @@ -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_ diff --git a/src/utils/D3D12Binding.cpp b/src/utils/D3D12Binding.cpp index fb10f2857d..174ac25df3 100644 --- a/src/utils/D3D12Binding.cpp +++ b/src/utils/D3D12Binding.cpp @@ -22,27 +22,26 @@ #include "GLFW/glfw3.h" #include "GLFW/glfw3native.h" -#include -#include #include #include +#include +#include #ifdef _DEBUG #include #endif using Microsoft::WRL::ComPtr; -namespace backend { -namespace d3d12 { +namespace backend { namespace d3d12 { void Init(ComPtr d3d12Device, nxtProcTable* procs, nxtDevice* device); ComPtr GetCommandQueue(nxtDevice device); uint64_t GetSerial(const nxtDevice device); void NextSerial(nxtDevice device); - void ExecuteCommandLists(nxtDevice device, std::initializer_list commandLists); + void ExecuteCommandLists(nxtDevice device, + std::initializer_list commandLists); void WaitForSerial(nxtDevice device, uint64_t serial); void OpenCommandList(nxtDevice device, ComPtr* 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 debugController; if (SUCCEEDED(D3D12GetDebugInterface(IID_PPV_ARGS(&debugController)))) { @@ -68,7 +68,8 @@ namespace utils { ComPtr 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(); - impl.userData = new SwapChainImplD3D12(window, procs); - return impl; + public: + static nxtSwapChainImplementation Create(HWND window, const nxtProcTable& procs) { + auto impl = GenerateSwapChainImplementation(); + impl.userData = new SwapChainImplD3D12(window, procs); + return impl; + } + + private: + nxtDevice mBackendDevice = nullptr; + nxtProcTable mProcs = {}; + + static constexpr unsigned int kFrameCount = 2; + + HWND mWindow = 0; + ComPtr mFactory = {}; + ComPtr mCommandQueue = {}; + ComPtr mSwapChain = {}; + ComPtr 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 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 mFactory = {}; - ComPtr mCommandQueue = {}; - ComPtr mSwapChain = {}; - ComPtr 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 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 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 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(&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 mFactory; + ComPtr mHardwareAdapter; + ComPtr 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(&mSwapchainImpl); - } - nxtTextureFormat GetPreferredSwapChainTextureFormat() override { - return NXT_TEXTURE_FORMAT_R8_G8_B8_A8_UNORM; - } - - private: - nxtDevice mBackendDevice = nullptr; - nxtSwapChainImplementation mSwapchainImpl = {}; - nxtProcTable mProcTable = {}; - - // Initialization - ComPtr mFactory; - ComPtr mHardwareAdapter; - ComPtr 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 diff --git a/src/utils/MetalBinding.mm b/src/utils/MetalBinding.mm index f15de5b762..db8a78a93a 100644 --- a/src/utils/MetalBinding.mm +++ b/src/utils/MetalBinding.mm @@ -22,132 +22,130 @@ #include "GLFW/glfw3.h" #include "GLFW/glfw3native.h" -#import #import +#import -namespace backend { -namespace metal { +namespace backend { namespace metal { void Init(id metalDevice, nxtProcTable* procs, nxtDevice* device); void SetNextDrawable(nxtDevice device, id drawable); void Present(nxtDevice device); -} -} +}} namespace utils { class SwapChainImplMTL : SwapChainImpl { - public: - static nxtSwapChainImplementation Create(id nswindow) { - auto impl = GenerateSwapChainImplementation(); - impl.userData = new SwapChainImplMTL(nswindow); - return impl; + public: + static nxtSwapChainImplementation Create(id nswindow) { + auto impl = GenerateSwapChainImplementation(); + impl.userData = new SwapChainImplMTL(nswindow); + return impl; + } + + private: + id mNsWindow = nil; + id mMtlDevice = nil; + id mCommandQueue = nil; + + CAMetalLayer* mLayer = nullptr; + id mCurrentDrawable = nil; + id 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 mMtlDevice = nil; - id mCommandQueue = nil; + NSView* contentView = [mNsWindow contentView]; + [contentView setWantsLayer:YES]; - CAMetalLayer* mLayer = nullptr; - id mCurrentDrawable = nil; - id 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(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 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(mCurrentTexture); - - return NXT_SWAP_CHAIN_NO_ERROR; - } - - nxtSwapChainError Present() { - id 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(&mSwapchainImpl); + uint64_t GetSwapChainImplementation() override { + if (mSwapchainImpl.userData == nullptr) { + mSwapchainImpl = SwapChainImplMTL::Create(glfwGetCocoaWindow(mWindow)); } + return reinterpret_cast(&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 mMetalDevice = nil; - nxtDevice mBackendDevice = nullptr; - nxtSwapChainImplementation mSwapchainImpl = {}; + private: + id mMetalDevice = nil; + nxtDevice mBackendDevice = nullptr; + nxtSwapChainImplementation mSwapchainImpl = {}; }; BackendBinding* CreateMetalBinding() { return new MetalBinding; } - } diff --git a/src/utils/NXTHelpers.cpp b/src/utils/NXTHelpers.cpp index 2080cad73b..41e3d5b94b 100644 --- a/src/utils/NXTHelpers.cpp +++ b/src/utils/NXTHelpers.cpp @@ -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(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(data)); buffer.FreezeUsage(usage); return buffer; } -} +} // namespace utils diff --git a/src/utils/NXTHelpers.h b/src/utils/NXTHelpers.h index 6ccd3ac190..fa9a80cb85 100644 --- a/src/utils/NXTHelpers.h +++ b/src/utils/NXTHelpers.h @@ -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 - nxt::Buffer CreateFrozenBufferFromData(const nxt::Device& device, nxt::BufferUsageBit usage, std::initializer_list data) { - return CreateFrozenBufferFromData(device, data.begin(), uint32_t(sizeof(T) * data.size()), usage); + template + nxt::Buffer CreateFrozenBufferFromData(const nxt::Device& device, + nxt::BufferUsageBit usage, + std::initializer_list data) { + return CreateFrozenBufferFromData(device, data.begin(), uint32_t(sizeof(T) * data.size()), + usage); } -} + +} // namespace utils diff --git a/src/utils/NullBinding.cpp b/src/utils/NullBinding.cpp index aaec0a74dd..9ef44d37eb 100644 --- a/src/utils/NullBinding.cpp +++ b/src/utils/NullBinding.cpp @@ -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 diff --git a/src/utils/OpenGLBinding.cpp b/src/utils/OpenGLBinding.cpp index 5367c711c1..53f6c3bf6f 100644 --- a/src/utils/OpenGLBinding.cpp +++ b/src/utils/OpenGLBinding.cpp @@ -19,130 +19,131 @@ #include "nxt/nxt_wsi.h" #include "utils/SwapChainImpl.h" -#include +// Glad needs to be included before GLFW otherwise it complain that GL.h was already included #include "glad/glad.h" + +#include #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(); - impl.userData = new SwapChainImplGL(window); - return impl; + public: + static nxtSwapChainImplementation Create(GLFWwindow* window) { + auto impl = GenerateSwapChainImplementation(); + 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(static_cast(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(static_cast(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(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(glfwGetProcAddress), + procs, device); - mBackendDevice = *device; - } + mBackendDevice = *device; + } - uint64_t GetSwapChainImplementation() override { - if (mSwapchainImpl.userData == nullptr) { - mSwapchainImpl = SwapChainImplGL::Create(mWindow); - } - return reinterpret_cast(&mSwapchainImpl); + uint64_t GetSwapChainImplementation() override { + if (mSwapchainImpl.userData == nullptr) { + mSwapchainImpl = SwapChainImplGL::Create(mWindow); } + return reinterpret_cast(&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 diff --git a/src/utils/SwapChainImpl.h b/src/utils/SwapChainImpl.h index 1bef573f28..e09d74bf8c 100644 --- a/src/utils/SwapChainImpl.h +++ b/src/utils/SwapChainImpl.h @@ -17,30 +17,29 @@ namespace utils { class SwapChainImpl { - protected: - template - static nxtSwapChainImplementation GenerateSwapChainImplementation() { - nxtSwapChainImplementation impl = {}; - impl.Init = [](void* userData, void* wsiContext) { - auto* ctx = reinterpret_cast(wsiContext); - reinterpret_cast(userData)->Init(ctx); - }; - impl.Destroy = [](void* userData) { - delete reinterpret_cast(userData); - }; - impl.Configure = [](void* userData, nxtTextureFormat format, nxtTextureUsageBit allowedUsage, uint32_t width, uint32_t height) { - return reinterpret_cast(userData)->Configure(format, allowedUsage, width, height); - }; - impl.GetNextTexture = [](void* userData, nxtSwapChainNextTexture* nextTexture) { - return reinterpret_cast(userData)->GetNextTexture( - nextTexture); - }; - impl.Present = [](void* userData) { - return reinterpret_cast(userData)->Present(); - }; - return impl; - } + protected: + template + static nxtSwapChainImplementation GenerateSwapChainImplementation() { + nxtSwapChainImplementation impl = {}; + impl.Init = [](void* userData, void* wsiContext) { + auto* ctx = reinterpret_cast(wsiContext); + reinterpret_cast(userData)->Init(ctx); + }; + impl.Destroy = [](void* userData) { delete reinterpret_cast(userData); }; + impl.Configure = [](void* userData, nxtTextureFormat format, + nxtTextureUsageBit allowedUsage, uint32_t width, uint32_t height) { + return reinterpret_cast(userData)->Configure(format, allowedUsage, width, + height); + }; + impl.GetNextTexture = [](void* userData, nxtSwapChainNextTexture* nextTexture) { + return reinterpret_cast(userData)->GetNextTexture(nextTexture); + }; + impl.Present = [](void* userData) { + return reinterpret_cast(userData)->Present(); + }; + return impl; + } }; -} +} // namespace utils -#endif // UTILS_SWAPCHAINIMPL_H_ +#endif // UTILS_SWAPCHAINIMPL_H_ diff --git a/src/utils/SystemUtils.cpp b/src/utils/SystemUtils.cpp index 153810f742..c7c1d68834 100644 --- a/src/utils/SystemUtils.cpp +++ b/src/utils/SystemUtils.cpp @@ -15,25 +15,25 @@ #include "common/Platform.h" #if defined(NXT_PLATFORM_WINDOWS) - #include +# include #elif defined(NXT_PLATFORM_POSIX) - #include +# include #else - #error "Unsupported platform." +# error "Unsupported platform." #endif namespace utils { - #if defined(NXT_PLATFORM_WINDOWS) - void USleep(unsigned int usecs) { - Sleep(static_cast(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(usecs / 1000)); + } +#elif defined(NXT_PLATFORM_POSIX) + void USleep(unsigned int usecs) { + usleep(usecs); + } +#else +# error "Implement USleep for your platform." +#endif -} +} // namespace utils diff --git a/src/utils/SystemUtils.h b/src/utils/SystemUtils.h index d9df3f1a37..07f29671c7 100644 --- a/src/utils/SystemUtils.h +++ b/src/utils/SystemUtils.h @@ -15,5 +15,4 @@ namespace utils { void USleep(unsigned int usecs); - } diff --git a/src/utils/VulkanBinding.cpp b/src/utils/VulkanBinding.cpp index 3e1f1f735a..e783f412f7 100644 --- a/src/utils/VulkanBinding.cpp +++ b/src/utils/VulkanBinding.cpp @@ -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(); - impl.userData = new SwapChainImplVulkan(window); - return impl; - } + public: + static nxtSwapChainImplementation Create(GLFWwindow* window) { + auto impl = GenerateSwapChainImplementation(); + 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(&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(&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 diff --git a/src/wire/TerribleCommandBuffer.cpp b/src/wire/TerribleCommandBuffer.cpp index e05d7298e3..a8b4a050a1 100644 --- a/src/wire/TerribleCommandBuffer.cpp +++ b/src/wire/TerribleCommandBuffer.cpp @@ -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 diff --git a/src/wire/TerribleCommandBuffer.h b/src/wire/TerribleCommandBuffer.h index 691da0a2f9..b5e1f22339 100644 --- a/src/wire/TerribleCommandBuffer.h +++ b/src/wire/TerribleCommandBuffer.h @@ -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_ diff --git a/src/wire/Wire.h b/src/wire/Wire.h index 02ae84b6dd..64aa8caf45 100644 --- a/src/wire/Wire.h +++ b/src/wire/Wire.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_ diff --git a/src/wire/WireCmd.cpp b/src/wire/WireCmd.cpp index 589a0576b3..95ad094510 100644 --- a/src/wire/WireCmd.cpp +++ b/src/wire/WireCmd.cpp @@ -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 diff --git a/src/wire/WireCmd.h b/src/wire/WireCmd.h index d7cb8c4a68..6ed3a0eda6 100644 --- a/src/wire/WireCmd.h +++ b/src/wire/WireCmd.h @@ -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_