Specialization constants, reverse Z and async PSO implementation. (#9)

* Specialization constant implementation for Vulkan.

* Implement DXIL library linking.

* Implement proper reverse Z & fix motion blur flicker.

* Mirage API mapping.

* Initial work for async PSO.

* Further async PSO work.

* Set pipeline names.

* Handle special layers writing depth.

* Handle bones in shadow pipeline.

* Fix additive mode setting wrong pipeline field.

* Pass models to compilation threads through shared pointers.

* Safety improvements.

* Allow DXIL linking to happen in parallel.

* Display more debug information.

* Queue unique models for compilation immediately.

* Put async PSO debug printing behind a macro.

* Kick off terrain models to pipeline compilation thread the moment they are made.

* Hook a different function to do waiting in.

* Fix pipelines getting dropped.

* Account for ConstTexCoord.

* Fix async PSO accounting for alpha to coverage even when MSAA is off.

* Remove "has bone" specialization constant.

* Sky shader compilation & more debugging helpers.

* Assign names to shaders during loading.

* Fix string symbol definitions.

* Print description of recently compiled render thread pipelines.

* Switch to an enum library that doesn't murder IntelliSense.

* Precompile pipelines for object icons.

* Skip fur pipelines.

* Skip printing info for pipelines compiled during loading.

* Precompile pipelines for Sonic's mouth, motion blur, and forced transparent objects.

* Precompile planar reflection shaders.

* Precompile sparkle shaders in loading screens.

* Precompile fur shader.

* Refactor model traversing to enqueue every single compilation to worker threads.

* Dynamically create pipeline threads depending on hardware concurrency.

* Fix MSAA depth resolve not accounting for reverse Z.

* Integrate smol-v.

* Implement PSO caching.

* Update ShaderRecomp & remove unused function.

UnleashedRecomp/CMakeLists.txt

@@ -79,6 +79,8 @@ set(SWA_UI_CXX_SOURCES
     "ui/window.cpp"
 )
 
+set(SMOLV_SOURCE_DIR "${SWA_THIRDPARTY_ROOT}/ShaderRecomp/thirdparty/smol-v/source")
+
 set(SWA_CXX_SOURCES
     "app.cpp"
     "main.cpp"
@@ -93,6 +95,8 @@ set(SWA_CXX_SOURCES
     ${SWA_HID_CXX_SOURCES}
     ${SWA_PATCHES_CXX_SOURCES}
     ${SWA_UI_CXX_SOURCES}
+
+    "${SMOLV_SOURCE_DIR}/smolv.cpp"
 )
 
 if (WIN32)
@@ -122,6 +126,7 @@ find_package(zstd CONFIG REQUIRED)
 find_package(Stb REQUIRED)
 find_package(unofficial-concurrentqueue REQUIRED)
 find_package(imgui CONFIG REQUIRED)
+find_package(magic_enum CONFIG REQUIRED)
 
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/D3D12)
 add_custom_command(TARGET UnleashedRecomp POST_BUILD
@@ -130,10 +135,13 @@ add_custom_command(TARGET UnleashedRecomp POST_BUILD
    COMMAND_EXPAND_LISTS
 )
 
+file(COPY ${PACKAGE_PREFIX_DIR}/bin/dxil.dll DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
+
 target_link_libraries(UnleashedRecomp PRIVATE
     Microsoft::DirectX-Headers 
     Microsoft::DirectX-Guids 
     Microsoft::DirectX12-Agility
+    Microsoft::DirectXShaderCompiler
     comctl32
     dxgi
     Vulkan::Headers
@@ -154,6 +162,7 @@ target_link_libraries(UnleashedRecomp PRIVATE
     unofficial::concurrentqueue::concurrentqueue
     Synchronization
     imgui::imgui
+    magic_enum::magic_enum
 )
 
 target_include_directories(UnleashedRecomp PRIVATE
@@ -161,6 +170,7 @@ target_include_directories(UnleashedRecomp PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/api
     ${SWA_THIRDPARTY_ROOT}/ddspp 
     ${Stb_INCLUDE_DIR}
+    ${SMOLV_SOURCE_DIR}
 )
 
 target_precompile_headers(UnleashedRecomp PUBLIC ${SWA_PRECOMPILED_HEADERS})

UnleashedRecomp/api/Hedgehog/Base/Container/hhMap.h

@@ -0,0 +1,378 @@
+#pragma once
+
+#include <Hedgehog/Base/System/hhAllocator.h>
+
+namespace hh
+{
+    template<
+        class Key, 
+        class T, 
+        class Compare = std::less<Key>, 
+        class Allocator = Hedgehog::Base::TAllocator<std::pair<const Key, T>>>
+    class map
+    {
+    protected:
+        enum EColor
+        {
+            eColor_Red,
+            eColor_Black
+        };
+
+        struct SNode
+        {
+            using allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<SNode>;
+
+            xpointer<SNode> pLeft;
+            xpointer<SNode> pParent;
+            xpointer<SNode> pRight;
+            std::pair<const Key, T> Value;
+            uint8_t Color;
+            bool IsNil;
+        };
+
+        Compare m_Comp;
+        typename SNode::allocator_type m_Alloc;
+        xpointer<SNode> m_pHead;
+        be<uint32_t> m_Count;
+
+        struct SFindResult
+        {
+            SNode* pParent;
+            bool IsRight;
+            SNode* pBound;
+        };
+
+        bool LowerBoundDuplicate(const SNode* pBound, const Key& in_rKey) const
+        {
+            return !pBound->IsNil && !m_Comp(in_rKey, pBound->Value.first);
+        }
+
+        SFindResult FindLowerBound(const Key& in_rKey) const
+        {
+            SFindResult result{ m_pHead->pParent, true, m_pHead };
+            SNode* pNode = result.pParent;
+
+            while (!pNode->IsNil)
+            {
+                result.pParent = pNode;
+                if (m_Comp(pNode->Value.first, in_rKey))
+                {
+                    result.IsRight = true;
+                    pNode = pNode->pRight;
+                }
+                else
+                {
+                    result.IsRight = false;
+                    result.pBound = pNode;
+                    pNode = pNode->pLeft;
+                }
+            }
+
+            return result;
+        }
+
+        SNode* Find(const Key& in_rKey) const
+        {
+            const SFindResult result = FindLowerBound(in_rKey);
+            return LowerBoundDuplicate(result.pBound, in_rKey) ? result.pBound : m_pHead.get();
+        }
+
+        static SNode* Max(SNode* pNode)
+        {
+            while (!pNode->pRight->IsNil)
+                pNode = pNode->pRight;
+
+            return pNode;
+        }
+
+        static SNode* Min(SNode* pNode)
+        {
+            while (!pNode->pLeft->IsNil)
+                pNode = pNode->pLeft;
+
+            return pNode;
+        }
+
+    public:
+        using key_type = Key;
+        using mapped_type = T;
+        using value_type = std::pair<const Key, T>;
+        using size_type = std::size_t;
+        using difference_type = std::ptrdiff_t;
+        using key_compare = Compare;
+        using allocator_type = Allocator;
+        using reference = value_type&;
+        using const_reference = const value_type&;
+        using pointer = typename std::allocator_traits<Allocator>::pointer;
+        using const_pointer = typename std::allocator_traits<Allocator>::const_pointer;
+
+        class iterator
+        {
+        public:
+            using iterator_category = std::bidirectional_iterator_tag;
+            using value_type = std::pair<const Key, T>;
+            using difference_type = std::ptrdiff_t;
+            using pointer = value_type*;
+            using reference = value_type&;
+
+            iterator(const std::nullptr_t&) = delete;
+            iterator(SNode* pNode) : m_pNode(pNode) {}
+
+            reference operator*() const { return m_pNode->Value; }
+            pointer operator->() const { return &m_pNode->Value; }
+
+            iterator& operator++()
+            {
+                if (m_pNode->pRight->IsNil)
+                {
+                    SNode* pNode;
+                    while (!(pNode = m_pNode->pParent)->IsNil && m_pNode == pNode->pRight)
+                        m_pNode = pNode;
+
+                    m_pNode = pNode;
+                }
+                else
+                {
+                    m_pNode = map::Min(m_pNode->pRight);
+                }
+
+                return *this;
+            }
+
+            iterator operator++(int)
+            {
+                iterator temp(*this);
+                ++(*this);
+                return temp;
+            }
+
+            iterator& operator--()
+            {
+                if (m_pNode->IsNil)
+                {
+                    m_pNode = m_pNode->pRight;
+                }
+                else if (m_pNode->pLeft->IsNil)
+                {
+                    SNode* pNode;
+                    while (!(pNode = m_pNode->pParent)->IsNil && m_pNode == pNode->pLeft)
+                        m_pNode = pNode;
+
+                    if (!m_pNode->IsNil)
+                        m_pNode = pNode;
+                }
+                else
+                {
+                    m_pNode = map::Max(m_pNode->pLeft);
+                }
+
+                return *this;
+            }
+
+            iterator operator--(int)
+            {
+                iterator temp(*this);
+                --(*this);
+                return temp;
+            }
+
+            bool operator==(const iterator& rhs) const { return m_pNode == rhs.m_pNode; }
+            bool operator!=(const iterator& rhs) const { return !(*this == rhs); }
+
+        private:
+            SNode* m_pNode;
+            friend class iterator;
+            friend class map;
+        };
+
+        class const_iterator
+        {
+        public:
+            using iterator_category = std::bidirectional_iterator_tag;
+            using value_type = std::pair<const Key, T>;
+            using difference_type = std::ptrdiff_t;
+            using pointer = const value_type*;
+            using reference = const value_type&;
+
+            const_iterator(const std::nullptr_t&) = delete;
+            const_iterator(SNode* pNode) : m_pNode(pNode) {}
+            const_iterator(const iterator& iterator) : m_pNode(iterator.m_pNode) {}
+
+            reference operator*() const { return m_pNode->Value; }
+            pointer operator->() const { return &m_pNode->Value; }
+
+            const_iterator& operator++()
+            {
+                if (m_pNode->pRight->IsNil)
+                {
+                    SNode* pNode;
+                    while (!(pNode = m_pNode->pParent)->IsNil && m_pNode == pNode->pRight)
+                        m_pNode = pNode;
+
+                    m_pNode = pNode;
+                }
+                else
+                {
+                    m_pNode = map::Min(m_pNode->pRight);
+                }
+
+                return *this;
+            }
+
+            const_iterator operator++(int)
+            {
+                const_iterator temp(*this);
+                ++(*this);
+                return temp;
+            }
+
+            const_iterator& operator--()
+            {
+                if (m_pNode->IsNil)
+                {
+                    m_pNode = m_pNode->pRight;
+                }
+                else if (m_pNode->pLeft->IsNil)
+                {
+                    SNode* pNode;
+                    while (!(pNode = m_pNode->pParent)->IsNil && m_pNode == pNode->pLeft)
+                        m_pNode = pNode;
+
+                    if (!m_pNode->IsNil)
+                        m_pNode = pNode;
+                }
+                else
+                {
+                    m_pNode = map::Max(m_pNode->pLeft);
+                }
+
+                return *this;
+            }
+
+            const_iterator operator--(int)
+            {
+                const_iterator temp(*this);
+                --(*this);
+                return temp;
+            }
+
+            bool operator==(const const_iterator& rhs) const { return m_pNode == rhs.m_pNode; }
+            bool operator!=(const const_iterator& rhs) const { return !(*this == rhs); }
+
+        private:
+            SNode* m_pNode;
+            friend class map;
+        };
+
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    public:
+        allocator_type get_allocator() const
+        {
+            return m_Alloc;
+        }
+
+        T& at(const Key& key)
+        {
+            return Find(key)->Value.second;
+        }
+
+        const T& at(const Key& key) const
+        {
+            return Find(key)->Value.second;
+        }
+
+        iterator begin()
+        {
+            return iterator(m_pHead->pLeft);
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(m_pHead->pLeft);
+        }
+
+        const_iterator cbegin() const
+        {
+            return const_iterator(m_pHead->pLeft);
+        }
+
+        iterator end()
+        {
+            return iterator(m_pHead);
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(m_pHead);
+        }
+
+        const_iterator cend() const
+        {
+            return const_iterator(m_pHead);
+        }
+
+        reverse_iterator rbegin()
+        {
+            return reverse_iterator(end());
+        }
+
+        const_reverse_iterator rbegin() const
+        {
+            return const_reverse_iterator(end());
+        }
+
+        const_reverse_iterator crbegin() const
+        {
+            return const_reverse_iterator(cend());
+        }
+
+        reverse_iterator rend()
+        {
+            return reverse_iterator(begin());
+        }
+
+        const_reverse_iterator rend() const
+        {
+            return const_reverse_iterator(begin());
+        }
+
+        const_reverse_iterator crend() const
+        {
+            return const_reverse_iterator(cbegin());
+        }
+
+        bool empty() const
+        {
+            return m_Count == 0;
+        }
+
+        size_type size() const
+        {
+            return m_Count;
+        }
+
+        size_type max_size() const
+        {
+            return ~0u;
+        }
+
+        size_type count(const Key& key) const
+        {
+            return LowerBoundDuplicate(FindLowerBound(key).pBound, key) ? 1u : 0u;
+        }
+
+        iterator find(const Key& key)
+        {
+            return iterator(Find(key));
+        }
+
+        const_iterator find(const Key& key) const
+        {
+            return const_iterator(Find(key));
+        }
+    };
+
+    static_assert(sizeof(map<int, int>) == 0xC);
+}

UnleashedRecomp/api/Hedgehog/Base/Container/hhVector.h

@@ -0,0 +1,255 @@
+#pragma once
+
+#include <Hedgehog/Base/System/hhAllocator.h>
+
+namespace hh
+{
+    template<typename T, typename Allocator = Hedgehog::Base::TAllocator<T>>
+    class vector
+    {
+    protected:
+        Allocator m_Alloc;
+        xpointer<T> m_pFirst;
+        xpointer<T> m_pLast;
+        xpointer<T> m_pEnd;
+
+    public:
+        using value_type = T;
+        using allocator_type = Allocator;
+        using size_type = std::size_t;
+        using difference_type = std::ptrdiff_t;
+        using reference = value_type&;
+        using const_reference = const value_type&;
+        using pointer = typename std::allocator_traits<Allocator>::pointer;
+        using const_pointer = typename std::allocator_traits<Allocator>::const_pointer;
+
+        class iterator
+        {
+        public:
+            using iterator_category = std::random_access_iterator_tag;
+            using value_type = T;
+            using difference_type = std::ptrdiff_t;
+            using pointer = T*;
+            using reference = T&;
+
+            iterator() : m_pPtr(nullptr) {}
+            iterator(T* p) : m_pPtr(p) {}
+
+            reference operator*() const { return *m_pPtr; }
+            pointer operator->() const { return m_pPtr; }
+
+            iterator& operator++() { ++m_pPtr; return *this; }
+            iterator operator++(int) { iterator tmp = *this; ++(*this); return tmp; }
+
+            iterator& operator--() { --m_pPtr; return *this; }
+            iterator operator--(int) { iterator tmp = *this; --(*this); return tmp; }
+
+            iterator& operator+=(difference_type n) { m_pPtr += n; return *this; }
+            iterator operator+(difference_type n) const { iterator tmp = *this; return tmp += n; }
+            friend iterator operator+(difference_type n, iterator it) { return it + n; }
+
+            iterator& operator-=(difference_type n) { return *this += -n; }
+            iterator operator-(difference_type n) const { iterator tmp = *this; return tmp -= n; }
+            difference_type operator-(const iterator& other) const { return m_pPtr - other.m_pPtr; }
+
+            reference operator[](difference_type n) const { return *(*this + n); }
+
+            bool operator==(const iterator& other) const { return m_pPtr == other.m_pPtr; }
+            bool operator!=(const iterator& other) const { return !(*this == other); }
+            bool operator<(const iterator& other) const { return m_pPtr < other.m_pPtr; }
+            bool operator<=(const iterator& other) const { return !(other < *this); }
+            bool operator>(const iterator& other) const { return other < *this; }
+            bool operator>=(const iterator& other) const { return !(*this < other); }
+
+        private:
+            T* m_pPtr;
+
+            friend class vector;
+            friend class const_iterator;
+        };
+
+        class const_iterator
+        {
+        public:
+            using iterator_category = std::random_access_iterator_tag;
+            using value_type = T;
+            using difference_type = std::ptrdiff_t;
+            using pointer = const T*;
+            using reference = const T&;
+
+            const_iterator() : m_pPtr(nullptr) {}
+            const_iterator(T* p) : m_pPtr(p) {}
+            const_iterator(const iterator& other) : m_pPtr(other.m_pPtr) {}
+
+            reference operator*() const { return *m_pPtr; }
+            pointer operator->() const { return m_pPtr; }
+
+            const_iterator& operator++() { ++m_pPtr; return *this; }
+            const_iterator operator++(int) { const_iterator tmp = *this; ++(*this); return tmp; }
+
+            const_iterator& operator--() { --m_pPtr; return *this; }
+            const_iterator operator--(int) { const_iterator tmp = *this; --(*this); return tmp; }
+
+            const_iterator& operator+=(difference_type n) { m_pPtr += n; return *this; }
+            const_iterator operator+(difference_type n) const { const_iterator tmp = *this; return tmp += n; }
+            friend const_iterator operator+(difference_type n, const_iterator it) { return it + n; }
+
+            const_iterator& operator-=(difference_type n) { return *this += -n; }
+            const_iterator operator-(difference_type n) const { const_iterator tmp = *this; return tmp -= n; }
+            difference_type operator-(const const_iterator& other) const { return m_pPtr - other.m_pPtr; }
+
+            reference operator[](difference_type n) const { return *(*this + n); }
+
+            bool operator==(const const_iterator& other) const { return m_pPtr == other.m_pPtr; }
+            bool operator!=(const const_iterator& other) const { return !(*this == other); }
+            bool operator<(const const_iterator& other) const { return m_pPtr < other.m_pPtr; }
+            bool operator<=(const const_iterator& other) const { return !(other < *this); }
+            bool operator>(const const_iterator& other) const { return other < *this; }
+            bool operator>=(const const_iterator& other) const { return !(*this < other); }
+
+        private:
+            T* m_pPtr;
+            friend class vector;
+        };
+
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+        allocator_type get_allocator() const
+        {
+            return m_Alloc;
+        }
+
+        reference at(size_type pos)
+        {
+            return m_pFirst[pos];
+        }
+
+        const_reference at(size_type pos) const
+        {
+            return m_pFirst[pos];
+        }
+
+        reference operator[](size_type pos)
+        {
+            return m_pFirst[pos];
+        }
+
+        const_reference operator[](size_type pos) const
+        {
+            return m_pFirst[pos];
+        }
+
+        reference front()
+        {
+            return m_pFirst[0];
+        }
+
+        const_reference front() const
+        {
+            return m_pFirst[0];
+        }
+
+        reference back()
+        {
+            return m_pLast[-1];
+        }
+
+        const_reference back() const
+        {
+            return m_pLast[-1];
+        }
+
+        T* data()
+        {
+            return m_pFirst;
+        }
+
+        const T* data() const
+        {
+            return m_pFirst;
+        }
+
+        iterator begin()
+        {
+            return iterator(m_pFirst);
+        }
+
+        const_iterator begin() const
+        {
+            return const_iterator(m_pFirst);
+        }
+
+        const_iterator cbegin() const
+        {
+            return const_iterator(m_pFirst);
+        }
+
+        iterator end()
+        {
+            return iterator(m_pLast);
+        }
+
+        const_iterator end() const
+        {
+            return const_iterator(m_pLast);
+        }
+
+        const_iterator cend() const
+        {
+            return const_iterator(m_pLast);
+        }
+
+        reverse_iterator rbegin()
+        {
+            return reverse_iterator(end());
+        }
+
+        const_reverse_iterator rbegin() const
+        {
+            return const_reverse_iterator(end());
+        }
+
+        const_reverse_iterator crbegin() const
+        {
+            return const_reverse_iterator(cend());
+        }
+
+        reverse_iterator rend()
+        {
+            return reverse_iterator(begin());
+        }
+
+        const_reverse_iterator rend() const
+        {
+            return const_reverse_iterator(begin());
+        }
+
+        const_reverse_iterator crend() const
+        {
+            return const_reverse_iterator(cbegin());
+        }
+
+        bool empty() const
+        {
+            return m_pFirst == m_pLast;
+        }
+
+        size_type size() const
+        {
+            return m_pLast - m_pFirst;
+        }
+
+        size_type max_size() const
+        {
+            return ~0u;
+        }
+
+        size_type capacity() const
+        {
+            return m_pEnd - m_pFirst;
+        }
+    };
+
+    SWA_ASSERT_SIZEOF(vector<int>, 0x10);
+}

UnleashedRecomp/api/Hedgehog/Base/System/hhSymbol.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <SWA.inl>
+
+namespace Hedgehog::Base
+{
+    class CSharedString;
+
+    class CStringSymbol
+    {
+    public:
+        be<uint32_t> m_Index;
+
+        CStringSymbol();
+        CStringSymbol(const char* in_pName);
+        CStringSymbol(const CSharedString& in_rName);
+
+        bool operator==(const CStringSymbol& in_rOther) const;
+        bool operator!=(const CStringSymbol& in_rOther) const;
+        bool operator<(const CStringSymbol& in_rOther) const;
+    };
+
+    SWA_ASSERT_OFFSETOF(CStringSymbol, m_Index, 0);
+    SWA_ASSERT_SIZEOF(CStringSymbol, 4);
+}
+
+#include <Hedgehog/Base/System/hhSymbol.inl>

UnleashedRecomp/api/Hedgehog/Base/System/hhSymbol.inl

@@ -0,0 +1,31 @@
+namespace Hedgehog::Base
+{
+    inline CStringSymbol::CStringSymbol()
+    {
+    }
+
+    inline CStringSymbol::CStringSymbol(const char* in_pName)
+    {
+        GuestToHostFunction<void>(sub_82E014D8, this, in_pName);
+    }   
+    
+    inline CStringSymbol::CStringSymbol(const CSharedString& in_rName)
+    {
+        GuestToHostFunction<void>(sub_82E013B0, this, &in_rName);
+    }
+
+    inline bool CStringSymbol::operator==(const CStringSymbol& in_rOther) const
+    {
+        return m_Index == in_rOther.m_Index;
+    }
+
+    inline bool CStringSymbol::operator!=(const CStringSymbol& in_rOther) const
+    {
+        return m_Index != in_rOther.m_Index;
+    }
+
+    inline bool CStringSymbol::operator<(const CStringSymbol& in_rOther) const
+    {
+        return m_Index < in_rOther.m_Index;
+    }
+}

UnleashedRecomp/api/Hedgehog/Base/Type/detail/hhStringHolder.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "SWA.inl"
+#include <SWA.inl>
 
 namespace Hedgehog::Base
 {
@@ -41,4 +41,4 @@ namespace Hedgehog::Base
     };
 }
 
-#include "Hedgehog/Base/Type/detail/hhStringHolder.inl"
+#include <Hedgehog/Base/Type/detail/hhStringHolder.inl>

UnleashedRecomp/api/Hedgehog/Database/System/hhDatabaseData.h

@@ -1,6 +1,7 @@
 #pragma once
 
-#include "Hedgehog/Base/hhObject.h"
+#include <Hedgehog/Base/hhObject.h>
+#include <Hedgehog/Base/Type/hhSharedString.h>
 
 namespace Hedgehog::Database
 {

UnleashedRecomp/api/Hedgehog/Database/System/hhDatabaseData.inl

@@ -7,7 +7,7 @@ namespace Hedgehog::Database
 
     inline bool CDatabaseData::CheckMadeAll()
     {
-        return true;
+        return GuestToHostFunction<bool>(m_pVftable->m_fpCheckMadeAll, this);
     }
 
     inline bool CDatabaseData::IsMadeOne() const

UnleashedRecomp/api/Hedgehog/MirageCore/Misc/hhVertexDeclarationPtr.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <SWA.inl>
+
+namespace Hedgehog::Mirage
+{
+    class CRenderingInfrastructure;
+
+    class CVertexDeclarationPtr
+    {
+    public:
+        xpointer<void> m_pD3DVertexDeclaration;
+        xpointer<CRenderingInfrastructure> m_pRenderingInfrastructure;
+    };
+
+    SWA_ASSERT_OFFSETOF(CVertexDeclarationPtr, m_pD3DVertexDeclaration, 0x0);
+    SWA_ASSERT_OFFSETOF(CVertexDeclarationPtr, m_pRenderingInfrastructure, 0x4);
+    SWA_ASSERT_SIZEOF(CVertexDeclarationPtr, 0x8);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhMaterialData.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <boost/smart_ptr/shared_ptr.h>
+
+#include <Hedgehog/Base/Container/hhVector.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CMaterialData;
+    class CTexsetData;
+    class CShaderListData;
+    class CParameterFloat4Element;
+    class CParameterInt4Element;
+    class CParameterBoolElement;
+
+    class CMaterialData : public Database::CDatabaseData
+    {
+    public:
+        boost::shared_ptr<CShaderListData> m_spShaderListData;
+        boost::shared_ptr<CTexsetData> m_spTexsetData;
+        hh::vector<boost::shared_ptr<CParameterFloat4Element>> m_Float4Params;
+        hh::vector<boost::shared_ptr<CParameterInt4Element>> m_Int4Params;
+        hh::vector<boost::shared_ptr<CParameterBoolElement>> m_Bool4Params;
+        uint8_t m_AlphaThreshold;
+        bool m_DoubleSided;
+        bool m_Additive;
+    };
+
+    SWA_ASSERT_OFFSETOF(CMaterialData, m_spShaderListData, 0xC);
+    SWA_ASSERT_OFFSETOF(CMaterialData, m_spTexsetData, 0x14);
+    SWA_ASSERT_OFFSETOF(CMaterialData, m_Float4Params, 0x1C);
+    SWA_ASSERT_OFFSETOF(CMaterialData, m_Int4Params, 0x2C);
+    SWA_ASSERT_OFFSETOF(CMaterialData, m_Bool4Params, 0x3C);
+    SWA_ASSERT_OFFSETOF(CMaterialData, m_AlphaThreshold, 0x4C);
+    SWA_ASSERT_OFFSETOF(CMaterialData, m_DoubleSided, 0x4D);
+    SWA_ASSERT_OFFSETOF(CMaterialData, m_Additive, 0x4E);
+    SWA_ASSERT_SIZEOF(CMaterialData, 0x50);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhMeshData.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <boost/smart_ptr/shared_ptr.h>
+
+#include <Hedgehog/Base/Type/hhSharedString.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+#include <Hedgehog/MirageCore/Misc/hhVertexDeclarationPtr.h>
+
+namespace Hedgehog::Mirage
+{
+    class CMaterialData;
+
+    class CMeshData : public Database::CDatabaseData
+    {
+    public:
+        be<uint32_t> m_IndexNum;
+        be<uint32_t> m_VertexNum;
+        be<uint32_t> m_VertexSize;
+        be<uint32_t> m_NodeNum;
+        xpointer<uint8_t> m_pNodeIndices;
+        be<uint32_t> m_VertexOffset;
+        be<uint32_t> m_IndexOffset;
+        xpointer<void> m_pD3DIndexBuffer;
+        xpointer<void> m_pD3DVertexBuffer;
+        CVertexDeclarationPtr m_VertexDeclarationPtr;
+        SWA_INSERT_PADDING(0x4);
+        boost::shared_ptr<CMaterialData> m_spMaterial;
+        SWA_INSERT_PADDING(0xC);
+    };
+    
+    SWA_ASSERT_OFFSETOF(CMeshData, m_IndexNum, 0xC);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_VertexNum, 0x10);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_VertexSize, 0x14);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_NodeNum, 0x18);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_pNodeIndices, 0x1C);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_VertexOffset, 0x20);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_IndexOffset, 0x24);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_pD3DIndexBuffer, 0x28);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_pD3DVertexBuffer, 0x2C);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_VertexDeclarationPtr, 0x30);
+    SWA_ASSERT_OFFSETOF(CMeshData, m_spMaterial, 0x3C);
+    SWA_ASSERT_SIZEOF(CMeshData, 0x50);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhModelData.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <Hedgehog/Base/Container/hhVector.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CNodeGroupModelData;
+    class CMeshData;
+    class CModelNodeData;
+    class CMatrixData;
+    class CAabbData;
+    class CSphereData;
+    class CMorphModelData;
+
+    class CModelData : public Database::CDatabaseData
+    {
+    public:
+        be<uint32_t> m_NodeGroupModelNum;
+        hh::vector<boost::shared_ptr<CNodeGroupModelData>> m_NodeGroupModels;
+        hh::vector<boost::shared_ptr<CMeshData>> m_OpaqueMeshes;
+        hh::vector<boost::shared_ptr<CMeshData>> m_TransparentMeshes;
+        hh::vector<boost::shared_ptr<CMeshData>> m_PunchThroughMeshes;
+        be<uint32_t> m_NodeNum;
+        boost::shared_ptr<uint8_t[]> m_spNodeParentIndices;
+        boost::shared_ptr<CModelNodeData[]> m_spNodes;
+        boost::shared_ptr<CMatrixData[]> m_spNodeMatrices;
+        boost::shared_ptr<CAabbData> m_spAabb;
+        boost::shared_ptr<CSphereData> m_spSphere;
+        hh::vector<boost::shared_ptr<CMorphModelData>> m_MorphModels;
+    };
+
+    SWA_ASSERT_OFFSETOF(CModelData, m_NodeGroupModelNum, 0xC);
+    SWA_ASSERT_OFFSETOF(CModelData, m_NodeGroupModels, 0x10);
+    SWA_ASSERT_OFFSETOF(CModelData, m_OpaqueMeshes, 0x20);
+    SWA_ASSERT_OFFSETOF(CModelData, m_TransparentMeshes, 0x30);
+    SWA_ASSERT_OFFSETOF(CModelData, m_PunchThroughMeshes, 0x40);
+    SWA_ASSERT_OFFSETOF(CModelData, m_NodeNum, 0x50);
+    SWA_ASSERT_OFFSETOF(CModelData, m_spNodeParentIndices, 0x54);
+    SWA_ASSERT_OFFSETOF(CModelData, m_spNodes, 0x5C);
+    SWA_ASSERT_OFFSETOF(CModelData, m_spNodeMatrices, 0x64);
+    SWA_ASSERT_OFFSETOF(CModelData, m_spAabb, 0x6C);
+    SWA_ASSERT_OFFSETOF(CModelData, m_spSphere, 0x74);
+    SWA_ASSERT_OFFSETOF(CModelData, m_MorphModels, 0x7C);
+    SWA_ASSERT_SIZEOF(CModelData, 0x8C);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhNodeGroupModelData.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <Hedgehog/Base/Container/hhVector.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CMeshData;
+
+    class CNodeGroupModelData : public Database::CDatabaseData
+    {
+    public:
+        hh::vector<boost::shared_ptr<CMeshData>> m_OpaqueMeshes;
+        hh::vector<boost::shared_ptr<CMeshData>> m_TransparentMeshes;
+        hh::vector<boost::shared_ptr<CMeshData>> m_PunchThroughMeshes;
+        be<uint32_t> m_SpecialMeshGroupNum;
+        boost::shared_ptr<be<uint32_t>> m_SpecialMeshGroupModes;
+        hh::vector<hh::vector<boost::shared_ptr<CMeshData>>> m_SpecialMeshGroups;
+        Base::CSharedString m_Name;
+    };
+
+    SWA_ASSERT_OFFSETOF(CNodeGroupModelData, m_OpaqueMeshes, 0xC);
+    SWA_ASSERT_OFFSETOF(CNodeGroupModelData, m_TransparentMeshes, 0x1C);
+    SWA_ASSERT_OFFSETOF(CNodeGroupModelData, m_PunchThroughMeshes, 0x2C);
+    SWA_ASSERT_OFFSETOF(CNodeGroupModelData, m_SpecialMeshGroupNum, 0x3C);
+    SWA_ASSERT_OFFSETOF(CNodeGroupModelData, m_SpecialMeshGroupModes, 0x40);
+    SWA_ASSERT_OFFSETOF(CNodeGroupModelData, m_SpecialMeshGroups, 0x48);
+    SWA_ASSERT_OFFSETOF(CNodeGroupModelData, m_Name, 0x58);
+    SWA_ASSERT_SIZEOF(CNodeGroupModelData, 0x5C);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhPixelShaderCodeData.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <boost/smart_ptr/shared_ptr.h>
+
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Base
+{
+    class CCriticalSectionD3D9;
+}
+
+namespace Hedgehog::Mirage
+{
+    class CRenderingInfrastructure;
+
+    class CPixelShaderCodeData : public Database::CDatabaseData
+    {
+    public:
+        xpointer<void> m_pD3DPixelShader;
+        xpointer<uint8_t> m_spFunction;
+        boost::shared_ptr<Base::CCriticalSectionD3D9> m_spCriticalSection;
+        xpointer<CRenderingInfrastructure> m_pRenderingInfrastructure;
+    };
+
+    SWA_ASSERT_OFFSETOF(CPixelShaderCodeData, m_pD3DPixelShader, 0xC);
+    SWA_ASSERT_OFFSETOF(CPixelShaderCodeData, m_spFunction, 0x10);
+    SWA_ASSERT_OFFSETOF(CPixelShaderCodeData, m_spCriticalSection, 0x14);
+    SWA_ASSERT_OFFSETOF(CPixelShaderCodeData, m_pRenderingInfrastructure, 0x1C);
+    SWA_ASSERT_SIZEOF(CPixelShaderCodeData, 0x20);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhPixelShaderData.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <Hedgehog/Base/Container/hhVector.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CPixelShaderCodeData;
+    class CPixelShaderParameterData;
+
+    class CPixelShaderData : public Hedgehog::Database::CDatabaseData
+    {
+    public:
+        boost::shared_ptr<CPixelShaderCodeData> m_spCode;
+        SWA_INSERT_PADDING(0x4);
+        hh::vector<boost::shared_ptr<CPixelShaderParameterData>> m_ParameterList;            
+    };
+
+    SWA_ASSERT_OFFSETOF(CPixelShaderData, m_spCode, 0xC);
+    SWA_ASSERT_OFFSETOF(CPixelShaderData, m_ParameterList, 0x18);
+    SWA_ASSERT_SIZEOF(CPixelShaderData, 0x28);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhShaderListData.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <boost/smart_ptr/shared_ptr.h>
+
+#include <Hedgehog/Base/Container/hhMap.h>
+#include <Hedgehog/Base/System/hhSymbol.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CVertexShaderData;
+    class CPixelShaderData;
+
+    class CVertexShaderPermutationData
+    {
+    public:
+        hh::map<be<uint32_t>, boost::shared_ptr<CVertexShaderData>> m_VertexShaders;
+        be<uint32_t> m_SubPermutations;
+    };
+
+    SWA_ASSERT_OFFSETOF(CVertexShaderPermutationData, m_VertexShaders, 0x0);
+    SWA_ASSERT_OFFSETOF(CVertexShaderPermutationData, m_SubPermutations, 0xC);
+    SWA_ASSERT_SIZEOF(CVertexShaderPermutationData, 0x10);
+
+    class CPixelShaderPermutationData
+    {
+    public:
+        hh::map<Base::CStringSymbol, boost::shared_ptr<CVertexShaderPermutationData>> m_VertexShaderPermutations;
+        hh::map<be<uint32_t>, boost::shared_ptr<CPixelShaderData>> m_PixelShaders;
+        be<uint32_t> m_SubPermutations;
+    };
+
+    SWA_ASSERT_OFFSETOF(CPixelShaderPermutationData, m_VertexShaderPermutations, 0x0);
+    SWA_ASSERT_OFFSETOF(CPixelShaderPermutationData, m_PixelShaders, 0xC);
+    SWA_ASSERT_OFFSETOF(CPixelShaderPermutationData, m_SubPermutations, 0x18);
+    SWA_ASSERT_SIZEOF(CPixelShaderPermutationData, 0x1C);
+
+    class CShaderListData : public Database::CDatabaseData
+    {
+    public:
+        hh::map<Base::CStringSymbol, CPixelShaderPermutationData> m_PixelShaderPermutations;
+    };
+
+    SWA_ASSERT_OFFSETOF(CShaderListData, m_PixelShaderPermutations, 0xC);
+    SWA_ASSERT_SIZEOF(CShaderListData, 0x18);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhTerrainModelData.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <Hedgehog/Base/Container/hhVector.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CSphereData;
+    class CNodeGroupModelData;
+    class CMeshData;
+
+    class CTerrainModelData : public Database::CDatabaseData
+    {
+    public:
+        SWA_INSERT_PADDING(0x4);
+        hh::vector<boost::shared_ptr<CNodeGroupModelData>> m_NodeGroupModels;
+        hh::vector<boost::shared_ptr<CMeshData>> m_OpaqueMeshes;
+        hh::vector<boost::shared_ptr<CMeshData>> m_TransparentMeshes;
+        hh::vector<boost::shared_ptr<CMeshData>> m_PunchThroughMeshes;
+        boost::shared_ptr<CSphereData> m_spSphere;
+    };
+
+    SWA_ASSERT_OFFSETOF(CTerrainModelData, m_NodeGroupModels, 0x10);
+    SWA_ASSERT_OFFSETOF(CTerrainModelData, m_OpaqueMeshes, 0x20);
+    SWA_ASSERT_OFFSETOF(CTerrainModelData, m_TransparentMeshes, 0x30);
+    SWA_ASSERT_OFFSETOF(CTerrainModelData, m_PunchThroughMeshes, 0x40);
+    SWA_ASSERT_OFFSETOF(CTerrainModelData, m_spSphere, 0x50);
+    SWA_ASSERT_SIZEOF(CTerrainModelData, 0x58);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhTexsetData.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <boost/smart_ptr/shared_ptr.h>
+
+#include <Hedgehog/Base/Container/hhVector.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CTextureData;
+
+    class CTexsetData : public Database::CDatabaseData
+    {
+    public:
+        hh::vector<boost::shared_ptr<CTextureData>> m_TextureList;
+        hh::vector<Base::CSharedString> m_TextureNameList;
+        bool m_ConstTexCoord;
+    };
+
+    SWA_ASSERT_OFFSETOF(CTexsetData, m_TextureList, 0xC);
+    SWA_ASSERT_OFFSETOF(CTexsetData, m_TextureNameList, 0x1C);
+    SWA_ASSERT_OFFSETOF(CTexsetData, m_ConstTexCoord, 0x2C);
+    SWA_ASSERT_SIZEOF(CTexsetData, 0x30);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhTextureData.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CTextureData : public Database::CDatabaseData
+    {
+    public:
+        SWA_INSERT_PADDING(0x8);
+        uint8_t m_TexcoordIndex;
+        SWA_INSERT_PADDING(0x1B);
+    };
+
+    SWA_ASSERT_OFFSETOF(CTextureData, m_TexcoordIndex, 0x14);
+    SWA_ASSERT_SIZEOF(CTextureData, 0x30);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhVertexShaderCodeData.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <boost/smart_ptr/shared_ptr.h>
+
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Base
+{
+    class CCriticalSectionD3D9;
+}
+
+namespace Hedgehog::Mirage
+{
+    class CRenderingInfrastructure;
+
+    class CVertexShaderCodeData : public Database::CDatabaseData
+    {
+    public:
+        xpointer<void> m_pD3DVertexShader;
+        xpointer<uint8_t> m_spFunction;
+        boost::shared_ptr<Base::CCriticalSectionD3D9> m_spCriticalSection;
+        xpointer<CRenderingInfrastructure> m_pRenderingInfrastructure;
+    };
+
+    SWA_ASSERT_OFFSETOF(CVertexShaderCodeData, m_pD3DVertexShader, 0xC);
+    SWA_ASSERT_OFFSETOF(CVertexShaderCodeData, m_spFunction, 0x10);
+    SWA_ASSERT_OFFSETOF(CVertexShaderCodeData, m_spCriticalSection, 0x14);
+    SWA_ASSERT_OFFSETOF(CVertexShaderCodeData, m_pRenderingInfrastructure, 0x1C);
+    SWA_ASSERT_SIZEOF(CVertexShaderCodeData, 0x20);
+}

UnleashedRecomp/api/Hedgehog/MirageCore/RenderData/hhVertexShaderData.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <Hedgehog/Base/Container/hhVector.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CVertexShaderCodeData;
+    class CVertexShaderParameterData;
+
+    class CVertexShaderData : public Hedgehog::Database::CDatabaseData
+    {
+    public:
+        boost::shared_ptr<CVertexShaderCodeData> m_spCode;
+        SWA_INSERT_PADDING(0x4);
+        hh::vector<boost::shared_ptr<CVertexShaderParameterData>> m_ParameterList;
+    };
+
+    SWA_ASSERT_OFFSETOF(CVertexShaderData, m_spCode, 0xC);
+    SWA_ASSERT_OFFSETOF(CVertexShaderData, m_ParameterList, 0x18);
+    SWA_ASSERT_SIZEOF(CVertexShaderData, 0x28);
+}

UnleashedRecomp/api/Hedgehog/Sparkle/hhParticleMaterial.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <boost/smart_ptr/shared_ptr.h>
+
+#include <Hedgehog/Base/Container/hhVector.h>
+#include <Hedgehog/Database/System/hhDatabaseData.h>
+
+namespace Hedgehog::Mirage
+{
+    class CShaderListData;
+}
+
+namespace Hedgehog::Sparkle
+{
+    class CParticleMaterial : public Hedgehog::Database::CDatabaseData
+    {
+    public:
+        enum EBlendMode
+        {
+            eBlendMode_Zero,
+            eBlendMode_Typical,
+            eBlendMode_Add,
+            eBlendMode_Subtract
+        };
+
+        hh::vector<boost::anonymous_shared_ptr> m_spFieldC;
+        boost::shared_ptr<Hedgehog::Mirage::CShaderListData> m_spDefaultShaderListData; // BillboardParticle_d[v]
+        boost::shared_ptr<Hedgehog::Mirage::CShaderListData> m_spShaderListData;
+        bool m_Field2C;
+        be<uint32_t> m_BlendMode;
+        be<uint32_t> m_AddressMode;
+        Hedgehog::Base::CSharedString m_MaterialName;
+        Hedgehog::Base::CSharedString m_TextureName;
+        Hedgehog::Base::CSharedString m_DeflectionTextureName;
+        Hedgehog::Base::CSharedString m_ShaderName;
+        be<float> m_Field48;
+        be<float> m_Field4C;
+    };
+
+    SWA_ASSERT_SIZEOF(CParticleMaterial, 0x50);
+}

UnleashedRecomp/api/SWA.h

@@ -15,7 +15,10 @@
 #include "CSD/Manager/csdmSceneObserver.h"
 #include "CSD/Manager/csdmSubjectBase.h"
 #include "CSD/Platform/csdTexList.h"
+#include "Hedgehog/Base/Container/hhMap.h"
+#include "Hedgehog/Base/Container/hhVector.h"
 #include "Hedgehog/Base/System/hhAllocator.h"
+#include "Hedgehog/Base/System/hhSymbol.h"
 #include "Hedgehog/Base/Thread/hhHolder.h"
 #include "Hedgehog/Base/Thread/hhHolderBase.h"
 #include "Hedgehog/Base/Thread/hhSynchronizedObject.h"
@@ -25,7 +28,21 @@
 #include "Hedgehog/Base/hhObject.h"
 #include "Hedgehog/Database/System/hhDatabaseData.h"
 #include "Hedgehog/Math/Vector2.h"
+#include "Hedgehog/MirageCore/Misc/hhVertexDeclarationPtr.h"
+#include "Hedgehog/MirageCore/RenderData/hhMaterialData.h"
+#include "Hedgehog/MirageCore/RenderData/hhMeshData.h"
+#include "Hedgehog/MirageCore/RenderData/hhModelData.h"
+#include "Hedgehog/MirageCore/RenderData/hhNodeGroupModelData.h"
+#include "Hedgehog/MirageCore/RenderData/hhPixelShaderCodeData.h"
+#include "Hedgehog/MirageCore/RenderData/hhPixelShaderData.h"
+#include "Hedgehog/MirageCore/RenderData/hhShaderListData.h"
+#include "Hedgehog/MirageCore/RenderData/hhTerrainModelData.h"
+#include "Hedgehog/MirageCore/RenderData/hhTexsetData.h"
+#include "Hedgehog/MirageCore/RenderData/hhTextureData.h"
+#include "Hedgehog/MirageCore/RenderData/hhVertexShaderCodeData.h"
+#include "Hedgehog/MirageCore/RenderData/hhVertexShaderData.h"
 #include "Hedgehog/MirageCore/Renderable/hhRenderable.h"
+#include "Hedgehog/Sparkle/hhParticleMaterial.h"
 #include "Hedgehog/Universe/Engine/hhMessageActor.h"
 #include "Hedgehog/Universe/Engine/hhMessageProcess.h"
 #include "Hedgehog/Universe/Engine/hhUpdateInfo.h"

UnleashedRecomp/api/boost/smart_ptr/shared_ptr.h

@@ -69,7 +69,12 @@ namespace boost
 
             uint32_t use_count() const
             {
-                return use_count_;
+                return std::byteswap(static_cast<uint32_t const volatile &>(use_count_.value));
+            }
+
+            bool unique() const
+            {
+                return use_count() == 1;
             }
         };
 
@@ -150,6 +155,16 @@ namespace boost
             return *this;
         }
 
+        shared_ptr& operator=(std::nullptr_t)
+        {
+            release();
+            
+            px = NULL;
+            pn = NULL;
+
+            return *this;
+        }
+
         T* get() const { return px; }
 
         detail::sp_dereference<T> operator*() const { assert(px); return *px; }
@@ -158,6 +173,7 @@ namespace boost
         explicit operator bool() const { return px != nullptr; }
 
         size_t use_count() const { return pn ? pn->use_count() : 0; }
+        bool unique() const { return !pn || pn->unique(); }
     };
 
     using anonymous_shared_ptr = shared_ptr<void>;

UnleashedRecomp/gpu/cache/pipeline_state_cache.h

@@ -0,0 +1,65 @@
+{ reinterpret_cast<GuestShader*>(0x135289E4F64C6EEA),reinterpret_cast<GuestShader*>(0x6B812461EA74928D),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x8,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x135289E4F64C6EEA),reinterpret_cast<GuestShader*>(0x7C6A695E4296FA3B),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x135289E4F64C6EEA),reinterpret_cast<GuestShader*>(0xC20BFEE4B086F5EF),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x8,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x1D29E1386144A506),reinterpret_cast<GuestShader*>(0x22CDDA5C6346A97),reinterpret_cast<GuestVertexDeclaration*>(0x5A2395E29F93DA3C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_FAN,{ 32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0x36DB3B40FA419EF6),reinterpret_cast<GuestShader*>(0x3BF885B6A8263F78),reinterpret_cast<GuestVertexDeclaration*>(0xFFFDDC62D86892F1),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_LIST,{ 32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0x36DB3B40FA419EF6),reinterpret_cast<GuestShader*>(0x3BF885B6A8263F78),reinterpret_cast<GuestVertexDeclaration*>(0xFFFDDC62D86892F1),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0x681C97662BFE9150),reinterpret_cast<GuestShader*>(0xDC635C4E7013864E),reinterpret_cast<GuestVertexDeclaration*>(0x6196BF64CB935CA5),false,true,false,RenderBlend::ONE,RenderBlend::ONE,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0x681E682667303C76),reinterpret_cast<GuestShader*>(0x38771885AC644B5),reinterpret_cast<GuestVertexDeclaration*>(0xC64D046063DE2F63),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::ONE,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0x681E682667303C76),reinterpret_cast<GuestShader*>(0x604349CBF72CCF8C),reinterpret_cast<GuestVertexDeclaration*>(0xC64D046063DE2F63),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::ONE,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x132D2F2079D74CB3),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x198E2B57B47DAF53),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16_FLOAT,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x3016DA5F348C87A7),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16_FLOAT,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x3016DA5F348C87A7),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x3016DA5F348C87A7),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x4294510C775F4EE8),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x48BE63A8F5F1C78A),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16_FLOAT,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x50700665A5F55DFE),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x605C1E349CC4CAAB),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x65325B9C7DA3DB04),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x67064E6EA39B439E),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x7D9F06B0E048B75D),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x891B8684FB17752B),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0x9FA5AACB5B14A226),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0xC47F2F91BA2A5D86),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x6DE86503F8AA38E2),reinterpret_cast<GuestShader*>(0xFB79F59782376846),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x720D6E5EDA78433B),reinterpret_cast<GuestShader*>(0x96EACBACDE1AAFAA),reinterpret_cast<GuestVertexDeclaration*>(0xA81F28FA43A9B511),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::ONE,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 36,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0x7C34DB46DEEFB0C2),reinterpret_cast<GuestShader*>(0xDBD8B29544AC9277),reinterpret_cast<GuestVertexDeclaration*>(0xB22B7B7B968141C6),false,false,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x7CC3A0B01523741B),reinterpret_cast<GuestShader*>(0x315BB80DAE685834),reinterpret_cast<GuestVertexDeclaration*>(0xB22B7B7B968141C6),false,false,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x86FE3502D5EC24AA),reinterpret_cast<GuestShader*>(0x68FCC0B90EBC457B),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x86FE3502D5EC24AA),reinterpret_cast<GuestShader*>(0x94A71CC9B94E3101),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16_FLOAT,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x88F67387B88F932F),reinterpret_cast<GuestShader*>(0x49101E452DF2FE98),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0x8A459F1CE0E957D3),reinterpret_cast<GuestShader*>(0x5D7ACAE543747185),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::ONE,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0x8E4BB23465BD909E),reinterpret_cast<GuestShader*>(0x0),reinterpret_cast<GuestVertexDeclaration*>(0xFFFDDC62D86892F1),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS_EQUAL,false,RenderBlendOperation::ADD,1,33554,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x0,RenderPrimitiveTopology::TRIANGLE_LIST,{ 32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::UNKNOWN,RenderFormat::D32_FLOAT,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x8E4BB23465BD909E),reinterpret_cast<GuestShader*>(0x0),reinterpret_cast<GuestVertexDeclaration*>(0xFFFDDC62D86892F1),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS_EQUAL,false,RenderBlendOperation::ADD,1,33554,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x0,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::UNKNOWN,RenderFormat::D32_FLOAT,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0x66578F29004F8FD0),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0x6B9732B4CD7E7740),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0x6C50210CBDA8A23A),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ONE,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0x6C50210CBDA8A23A),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0x6C50210CBDA8A23A),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16_FLOAT,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0x6C50210CBDA8A23A),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0x6C50210CBDA8A23A),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0x6C50210CBDA8A23A),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0x92940FDD115733E1),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0xA305C47ED9FB58CF),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::ALWAYS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x0,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::UNKNOWN,RenderFormat::D32_FLOAT,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0xD44C189D5067922E),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0x965929BAA69F0AE),reinterpret_cast<GuestShader*>(0xD736237D80908063),reinterpret_cast<GuestVertexDeclaration*>(0xD452411D3FB80A0D),false,false,false,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::LESS,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R8G8B8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0xA3CD49F172D99214),reinterpret_cast<GuestShader*>(0xD5EA32DB758EF0B8),reinterpret_cast<GuestVertexDeclaration*>(0x7F12180DC3A24B53),true,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 32,24,4,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x14 },
+{ reinterpret_cast<GuestShader*>(0xA3FD368C62079765),reinterpret_cast<GuestShader*>(0xE8E3FF65F2356201),reinterpret_cast<GuestVertexDeclaration*>(0xB22B7B7B968141C6),false,false,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0xA3FD368C62079765),reinterpret_cast<GuestShader*>(0xE8E3FF65F2356201),reinterpret_cast<GuestVertexDeclaration*>(0xB22B7B7B968141C6),false,false,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::LESS,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x0 },
+{ reinterpret_cast<GuestShader*>(0xA4CF0215A03D9571),reinterpret_cast<GuestShader*>(0xA3A659F1590CC180),reinterpret_cast<GuestVertexDeclaration*>(0x5A2395E29F93DA3C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_FAN,{ 32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0xB1086A4947A797DE),reinterpret_cast<GuestShader*>(0x996F5A774A646D92),reinterpret_cast<GuestVertexDeclaration*>(0x6FAE71C7134074A4),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x4 },
+{ reinterpret_cast<GuestShader*>(0xB1086A4947A797DE),reinterpret_cast<GuestShader*>(0x996F5A774A646D92),reinterpret_cast<GuestVertexDeclaration*>(0x6FAE71C7134074A4),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x4 },
+{ reinterpret_cast<GuestShader*>(0xB1086A4947A797DE),reinterpret_cast<GuestShader*>(0x996F5A774A646D92),reinterpret_cast<GuestVertexDeclaration*>(0x6FAE71C7134074A4),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::ONE,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x4 },
+{ reinterpret_cast<GuestShader*>(0xB1EA909C660122A7),reinterpret_cast<GuestShader*>(0xC96708D6F26CC6D9),reinterpret_cast<GuestVertexDeclaration*>(0x84BACD816D86543C),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0xB4CAFC034A37C8A8),reinterpret_cast<GuestShader*>(0x31173204A896098A),reinterpret_cast<GuestVertexDeclaration*>(0x5A22D93C543DF925),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x4 },
+{ reinterpret_cast<GuestShader*>(0xB4CAFC034A37C8A8),reinterpret_cast<GuestShader*>(0x31173204A896098A),reinterpret_cast<GuestVertexDeclaration*>(0x5A22D93C543DF925),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x4 },
+{ reinterpret_cast<GuestShader*>(0xB4CAFC034A37C8A8),reinterpret_cast<GuestShader*>(0x31173204A896098A),reinterpret_cast<GuestVertexDeclaration*>(0x5A22D93C543DF925),false,true,false,RenderBlend::SRC_ALPHA,RenderBlend::ONE,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::B8G8R8A8_UNORM,RenderFormat::UNKNOWN,1,false,0x4 },
+{ reinterpret_cast<GuestShader*>(0xBBD01C46D72EDC37),reinterpret_cast<GuestShader*>(0x4E1399E5E0E40511),reinterpret_cast<GuestVertexDeclaration*>(0xE6B3B3D286909AB9),true,true,false,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,true,RenderBlendOperation::ADD,0,0,RenderBlend::SRC_ALPHA,RenderBlend::INV_SRC_ALPHA,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 32,24,4,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x10 },
+{ reinterpret_cast<GuestShader*>(0xBDA992649419F2DD),reinterpret_cast<GuestShader*>(0x5A4CFA9D29441E0),reinterpret_cast<GuestVertexDeclaration*>(0x25B8F9D92644DAE0),true,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,24,4,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0xBDA992649419F2DD),reinterpret_cast<GuestShader*>(0x5A4CFA9D29441E0),reinterpret_cast<GuestVertexDeclaration*>(0x25B8F9D92644DAE0),true,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,24,4,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
+{ reinterpret_cast<GuestShader*>(0xCF28F33974EC44F6),reinterpret_cast<GuestShader*>(0xD5EA32DB758EF0B8),reinterpret_cast<GuestVertexDeclaration*>(0x7F12180DC3A24B53),true,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 32,24,4,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x14 },
+{ reinterpret_cast<GuestShader*>(0xD6EA5D49CB1F965C),reinterpret_cast<GuestShader*>(0x2FE1A3913EF3EE8A),reinterpret_cast<GuestVertexDeclaration*>(0x25B8F9D92644DAE0),true,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,24,4,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
+{ reinterpret_cast<GuestShader*>(0xD6EA5D49CB1F965C),reinterpret_cast<GuestShader*>(0x53EF4B071D1B59D3),reinterpret_cast<GuestVertexDeclaration*>(0x25B8F9D92644DAE0),true,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 44,24,4,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x15 },
+{ reinterpret_cast<GuestShader*>(0xD738D79626374EBE),reinterpret_cast<GuestShader*>(0xAAE40F54746EB116),reinterpret_cast<GuestVertexDeclaration*>(0xB7BBCC93738C9DE4),false,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::BACK,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0x0,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::UNKNOWN,RenderFormat::D32_FLOAT,1,false,0x11 },
+{ reinterpret_cast<GuestShader*>(0xFF5A2C4C81AA6FDF),reinterpret_cast<GuestShader*>(0xE105CB09EA634E60),reinterpret_cast<GuestVertexDeclaration*>(0x7F12180DC3A24B53),true,true,true,RenderBlend::ONE,RenderBlend::ZERO,RenderCullMode::NONE,RenderComparisonFunction::GREATER_EQUAL,false,RenderBlendOperation::ADD,0,0,RenderBlend::ONE,RenderBlend::ZERO,RenderBlendOperation::ADD,0xF,RenderPrimitiveTopology::TRIANGLE_STRIP,{ 32,24,4,0,0,0,0,0,0,0,0,0,0,0,0,0 },RenderFormat::R16G16B16A16_FLOAT,RenderFormat::D32_FLOAT,1,false,0x14 },

UnleashedRecomp/gpu/cache/vertex_declaration_cache.h

@@ -0,0 +1,14 @@
+g_vertexElements_25B8F9D92644DAE0,
+g_vertexElements_5A22D93C543DF925,
+g_vertexElements_5A2395E29F93DA3C,
+g_vertexElements_6196BF64CB935CA5,
+g_vertexElements_6FAE71C7134074A4,
+g_vertexElements_7F12180DC3A24B53,
+g_vertexElements_84BACD816D86543C,
+g_vertexElements_A81F28FA43A9B511,
+g_vertexElements_B22B7B7B968141C6,
+g_vertexElements_B7BBCC93738C9DE4,
+g_vertexElements_C64D046063DE2F63,
+g_vertexElements_D452411D3FB80A0D,
+g_vertexElements_E6B3B3D286909AB9,
+g_vertexElements_FFFDDC62D86892F1,

UnleashedRecomp/gpu/cache/vertex_element_cache.h

@@ -0,0 +1,14 @@
+static uint8_t g_vertexElements_25B8F9D92644DAE0[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2A,0x21,0x90,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x2A,0x21,0x90,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x2A,0x21,0x90,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x2C,0x23,0x5F,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x1C,0x0,0x2C,0x23,0x5F,0x0,0x5,0x1,0x0,0x0,0x0,0x0,0x20,0x0,0x1A,0x20,0x86,0x0,0xA,0x0,0x0,0x0,0x0,0x0,0x24,0x0,0x1A,0x22,0x86,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x28,0x0,0x1A,0x20,0x86,0x0,0x1,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x5,0x4,0x0,0x0,0x1,0x0,0xC,0x0,0x2C,0x21,0x59,0x0,0x5,0x5,0x0,0x0,0x1,0x0,0x10,0x0,0x2C,0x21,0x59,0x0,0x5,0x6,0x0,0x0,0x1,0x0,0x14,0x0,0x18,0x28,0x86,0x0,0xA,0x1,0x0,0x0,0x2,0x0,0x0,0x0,0x2C,0x82,0xA1,0x0,0x0,0x1,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_5A22D93C543DF925[] = {0x0,0x0,0x0,0x0,0x0,0x2C,0x23,0xA5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x18,0x28,0x86,0x0,0xA,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_5A2395E29F93DA3C[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2A,0x23,0xB9,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_6196BF64CB935CA5[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x18,0x28,0x86,0x0,0xA,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_6FAE71C7134074A4[] = {0x0,0x0,0x0,0x0,0x0,0x2C,0x23,0xA5,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x18,0x28,0x86,0x0,0xA,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_7F12180DC3A24B53[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2A,0x23,0xB9,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x5,0x1,0x0,0x0,0x1,0x0,0xC,0x0,0x1A,0x22,0x86,0x0,0x5,0x2,0x0,0x0,0x1,0x0,0x10,0x0,0x2C,0x21,0x59,0x0,0x5,0x3,0x0,0x0,0x1,0x0,0x14,0x0,0x18,0x28,0x86,0x0,0xA,0x1,0x0,0x0,0x2,0x0,0x0,0x0,0x2C,0x82,0xA1,0x0,0x0,0x1,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_84BACD816D86543C[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2A,0x23,0xB9,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x2A,0x23,0xB9,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x24,0x0,0x2A,0x23,0xB9,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x30,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x38,0x0,0x2C,0x23,0xA5,0x0,0x5,0x1,0x0,0x0,0x0,0x0,0x40,0x0,0x2C,0x23,0xA5,0x0,0x5,0x2,0x0,0x0,0x0,0x0,0x48,0x0,0x2C,0x23,0xA5,0x0,0x5,0x3,0x0,0x0,0x0,0x0,0x50,0x0,0x1A,0x23,0xA6,0x0,0xA,0x0,0x0,0x0,0x0,0x0,0x60,0x0,0x1A,0x23,0x86,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x64,0x0,0x1A,0x20,0x86,0x0,0x1,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_A81F28FA43A9B511[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2A,0x23,0xB9,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x18,0x28,0x86,0x0,0xA,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_B22B7B7B968141C6[] = {0x0,0x0,0x0,0x0,0x0,0x1A,0x23,0xA6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x18,0x28,0x86,0x0,0xA,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_B7BBCC93738C9DE4[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x1A,0x22,0x86,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x1A,0x20,0x86,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x2A,0x21,0x90,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x2A,0x21,0x90,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x1C,0x0,0x2A,0x21,0x90,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x2C,0x23,0x5F,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x24,0x0,0x1A,0x20,0x86,0x0,0xA,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_C64D046063DE2F63[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x1A,0x22,0x86,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x1A,0x20,0x86,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x2A,0x21,0x90,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x2A,0x21,0x90,0x0,0x6,0x0,0x0,0x0,0x0,0x0,0x1C,0x0,0x2A,0x21,0x90,0x0,0x7,0x0,0x0,0x0,0x0,0x0,0x20,0x0,0x2C,0x23,0x5F,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x24,0x0,0x2C,0x23,0x5F,0x0,0x5,0x1,0x0,0x0,0x0,0x0,0x28,0x0,0x1A,0x20,0x86,0x0,0xA,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_D452411D3FB80A0D[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_E6B3B3D286909AB9[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2A,0x23,0xB9,0x0,0x3,0x0,0x0,0x0,0x0,0x0,0x18,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x5,0x1,0x0,0x0,0x1,0x0,0xC,0x0,0x1A,0x22,0x86,0x0,0x5,0x2,0x0,0x0,0x1,0x0,0x10,0x0,0x2C,0x83,0xA4,0x0,0x5,0x3,0x0,0x0,0x1,0x0,0x14,0x0,0x18,0x28,0x86,0x0,0xA,0x1,0x0,0x0,0x2,0x0,0x0,0x0,0x2C,0x82,0xA1,0x0,0x0,0x1,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0x0,};
+static uint8_t g_vertexElements_FFFDDC62D86892F1[] = {0x0,0x0,0x0,0x0,0x0,0x2A,0x23,0xB9,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xC,0x0,0x2C,0x23,0xA5,0x0,0x5,0x0,0x0,0x0,0x0,0x0,0x14,0x0,0x2A,0x23,0xB9,0x0,0x3,0x0,0x0,0x0,0xFF,0x0,0x0,0xFF,0xFF,0xFF,0xFF,0x0,0x0,0x0,0xC9,};

UnleashedRecomp/gpu/rhi/rt64_d3d12.cpp

@@ -2672,6 +2672,10 @@ namespace RT64 {
         }
     }
 
+    void D3D12ComputePipeline::setName(const std::string& name) const {
+        setObjectName(d3d, name);
+    }
+
     RenderPipelineProgram D3D12ComputePipeline::getProgram(const std::string &name) const {
         assert(false && "Compute pipelines can't retrieve shader programs.");
         return RenderPipelineProgram();
@@ -2791,6 +2795,10 @@ namespace RT64 {
         }
     }
 
+    void D3D12GraphicsPipeline::setName(const std::string& name) const {
+        setObjectName(d3d, name);
+    }
+
     RenderPipelineProgram D3D12GraphicsPipeline::getProgram(const std::string &name) const {
         assert(false && "Graphics pipelines can't retrieve shader programs.");
         return RenderPipelineProgram();
@@ -3011,6 +3019,10 @@ namespace RT64 {
         }
     }
 
+    void D3D12RaytracingPipeline::setName(const std::string& name) const {
+        setObjectName(stateObject, name);
+    }
+
     RenderPipelineProgram D3D12RaytracingPipeline::getProgram(const std::string &name) const {
         auto it = nameProgramMap.find(name);
         assert((it != nameProgramMap.end()) && "Program must exist in the PSO.");

UnleashedRecomp/gpu/rhi/rt64_d3d12.h

@@ -355,6 +355,7 @@ namespace RT64 {
 
         D3D12ComputePipeline(D3D12Device *device, const RenderComputePipelineDesc &desc);
         ~D3D12ComputePipeline() override;
+        virtual void setName(const std::string& name) const override;
         virtual RenderPipelineProgram getProgram(const std::string &name) const override;
     };
 
@@ -365,6 +366,7 @@ namespace RT64 {
 
         D3D12GraphicsPipeline(D3D12Device *device, const RenderGraphicsPipelineDesc &desc);
         ~D3D12GraphicsPipeline() override;
+        virtual void setName(const std::string& name) const override;
         virtual RenderPipelineProgram getProgram(const std::string &name) const override;
     };
 
@@ -377,6 +379,7 @@ namespace RT64 {
 
         D3D12RaytracingPipeline(D3D12Device *device, const RenderRaytracingPipelineDesc &desc, const RenderPipeline *previousPipeline);
         ~D3D12RaytracingPipeline() override;
+        virtual void setName(const std::string& name) const override;
         virtual RenderPipelineProgram getProgram(const std::string &name) const override;
     };
 

UnleashedRecomp/gpu/rhi/rt64_render_interface.h

@@ -53,6 +53,7 @@ namespace RT64 {
 
     struct RenderPipeline {
         virtual ~RenderPipeline() { }
+        virtual void setName(const std::string& name) const = 0;
         virtual RenderPipelineProgram getProgram(const std::string &name) const = 0;
     };
 

UnleashedRecomp/gpu/rhi/rt64_vulkan.cpp

@@ -1316,6 +1316,10 @@ namespace RT64 {
         }
     }
 
+    void VulkanComputePipeline::setName(const std::string& name) const {
+        setObjectName(device->vk, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, uint64_t(vk), name);
+    }
+
     RenderPipelineProgram VulkanComputePipeline::getProgram(const std::string &name) const {
         assert(false && "Compute pipelines can't retrieve shader programs.");
         return RenderPipelineProgram();
@@ -1552,6 +1556,10 @@ namespace RT64 {
         }
     }
 
+    void VulkanGraphicsPipeline::setName(const std::string& name) const {
+        setObjectName(device->vk, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, uint64_t(vk), name);
+    }
+
     RenderPipelineProgram VulkanGraphicsPipeline::getProgram(const std::string &name) const {
         assert(false && "Graphics pipelines can't retrieve shader programs.");
         return RenderPipelineProgram();
@@ -1752,6 +1760,10 @@ namespace RT64 {
         }
     }
 
+    void VulkanRaytracingPipeline::setName(const std::string& name) const {
+        setObjectName(device->vk, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, uint64_t(vk), name);
+    }
+
     RenderPipelineProgram VulkanRaytracingPipeline::getProgram(const std::string &name) const {
         auto it = nameProgramMap.find(name);
         assert((it != nameProgramMap.end()) && "Program must exist in the PSO.");

UnleashedRecomp/gpu/rhi/rt64_vulkan.h

@@ -158,6 +158,7 @@ namespace RT64 {
 
         VulkanComputePipeline(VulkanDevice *device, const RenderComputePipelineDesc &desc);
         ~VulkanComputePipeline() override;
+        void setName(const std::string& name) const override;
         RenderPipelineProgram getProgram(const std::string &name) const override;
     };
 
@@ -167,6 +168,7 @@ namespace RT64 {
 
         VulkanGraphicsPipeline(VulkanDevice *device, const RenderGraphicsPipelineDesc &desc);
         ~VulkanGraphicsPipeline() override;
+        void setName(const std::string& name) const override;
         RenderPipelineProgram getProgram(const std::string &name) const override;
         static VkRenderPass createRenderPass(VulkanDevice *device, const VkFormat *renderTargetFormat, uint32_t renderTargetCount, VkFormat depthTargetFormat, VkSampleCountFlagBits sampleCount);
     };
@@ -179,6 +181,7 @@ namespace RT64 {
 
         VulkanRaytracingPipeline(VulkanDevice *device, const RenderRaytracingPipelineDesc &desc, const RenderPipeline *previousPipeline);
         ~VulkanRaytracingPipeline() override;
+        void setName(const std::string& name) const override;
         RenderPipelineProgram getProgram(const std::string &name) const override;
     };
 

UnleashedRecomp/gpu/shader/gamma_correction_ps.hlsl

@@ -1,4 +1,4 @@
-#include "../../../thirdparty/ShaderRecomp/ShaderRecomp/shader_common.hlsli"
+#include "../../../thirdparty/ShaderRecomp/ShaderRecomp/shader_common.h"
 
 #ifdef __spirv__
 

UnleashedRecomp/gpu/shader/movie_common.hlsli

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../../../thirdparty/ShaderRecomp/ShaderRecomp/shader_common.hlsli"
+#include "../../../thirdparty/ShaderRecomp/ShaderRecomp/shader_common.h"
 
 #ifdef __spirv__
 

UnleashedRecomp/gpu/shader/resolve_msaa_depth.hlsli

@@ -14,7 +14,7 @@ float main(in float4 position : SV_Position) : SV_Depth
     float result = g_Texture2DMSDescriptorHeap[g_PushConstants.ResourceDescriptorIndex].Load(int2(position.xy), 0);
     
     [unroll] for (int i = 1; i < SAMPLE_COUNT; i++)
-        result = max(result, g_Texture2DMSDescriptorHeap[g_PushConstants.ResourceDescriptorIndex].Load(int2(position.xy), i));
+        result = min(result, g_Texture2DMSDescriptorHeap[g_PushConstants.ResourceDescriptorIndex].Load(int2(position.xy), i));
 
     return result;
 }

UnleashedRecomp/gpu/video.h

@@ -1,5 +1,8 @@
 #pragma once
 
+//#define ASYNC_PSO_DEBUG
+#define PSO_CACHING
+
 #include "rhi/rt64_render_interface.h"
 
 #define D3DCLEAR_TARGET  0x1
@@ -78,6 +81,19 @@ struct GuestResource
             incrementedValue = std::byteswap(std::byteswap(originalValue) + 1);
         } while (InterlockedCompareExchange(reinterpret_cast<LONG*>(&refCount), incrementedValue, originalValue) != originalValue);
     }
+
+    void Release()
+    {
+        uint32_t originalValue, decrementedValue;
+        do
+        {
+            originalValue = refCount.value;
+            decrementedValue = std::byteswap(std::byteswap(originalValue) - 1);
+        } while (InterlockedCompareExchange(reinterpret_cast<LONG*>(&refCount), decrementedValue, originalValue) != originalValue);
+
+        // Normally we are supposed to release here, so only use this
+        // function when you know you won't be the one destructing it.
+    }
 };
 
 enum GuestFormat
@@ -226,27 +242,32 @@ struct GuestVertexElement
     uint8_t padding;
 };
 
-enum InputLayoutFlags
+#define D3DDECL_END() { 255, 0, 0xFFFFFFFF, 0, 0, 0 }
-{
-    INPUT_LAYOUT_FLAG_HAS_R11G11B10_NORMAL = 1 << 0,
-    INPUT_LAYOUT_FLAG_HAS_BONE_WEIGHTS = 1 << 1
-};
 
 struct GuestVertexDeclaration : GuestResource
 {
+    XXH64_hash_t hash = 0;
     std::unique_ptr<RenderInputElement[]> inputElements;
     std::unique_ptr<GuestVertexElement[]> vertexElements;
     uint32_t inputElementCount = 0;
     uint32_t vertexElementCount = 0;
     uint32_t swappedTexcoords = 0;
-    uint32_t inputLayoutFlags = 0;
+    bool hasR11G11B10Normal = false;
     uint32_t indexVertexStream = 0;
 };
 
 // VertexShader/PixelShader
 struct GuestShader : GuestResource
 {
+    Mutex mutex;
     std::unique_ptr<RenderShader> shader;
+    struct ShaderCacheEntry* shaderCacheEntry = nullptr;
+    ankerl::unordered_dense::map<uint32_t, std::unique_ptr<RenderShader>> linkedShaders;
+    std::vector<ComPtr<IDxcBlob>> shaderBlobs;
+    ComPtr<IDxcBlobEncoding> libraryBlob;
+#ifdef ASYNC_PSO_DEBUG
+    const char* name = "<unknown>";
+#endif
 };
 
 struct GuestViewport

UnleashedRecomp/natvis.natvis

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+    <Type Name="be&lt;*&gt;">
+        <DisplayString>{get()}</DisplayString>
+        <Expand>
+          <Item Name="Value">get()</Item>
+        </Expand>
+    </Type>
+    <Type Name="xpointer&lt;*&gt;">
+        <DisplayString>{get()}</DisplayString>
+        <Expand>
+          <Item Name="Value">get()</Item>
+        </Expand>
+    </Type>
+    <Type Name="boost::shared_ptr&lt;*&gt;">
+        <DisplayString>{get()}</DisplayString>
+        <Expand>
+          <Item Name="Value">get()</Item>
+        </Expand>
+    </Type>
+</AutoVisualizer>

UnleashedRecomp/stdafx.h

@@ -3,6 +3,7 @@
 #define NOMINMAX
 
 #include <windows.h>
+#include <dxcapi.h>
 #include <ShlObj_core.h>
 #include <algorithm>
 #include <mutex>
@@ -28,6 +29,11 @@
 #include <imgui_impl_sdl2.h>
 #include <o1heap.h>
 #include <cstddef>
+#include <wrl/client.h>
+#include <smolv.h>
+#include <print>
+
+using Microsoft::WRL::ComPtr;
 
 #include "framework.h"
 #include "mutex.h"

UnleashedRecomp/ui/window.cpp

@@ -10,6 +10,9 @@ int Window_OnSDLEvent(void*, SDL_Event* event)
     if (ImGui::GetIO().BackendPlatformUserData != nullptr)
         ImGui_ImplSDL2_ProcessEvent(event);
 
+    for (auto listener : Window::s_eventListeners)
+        listener->OnSDLEvent(event);
+
     switch (event->type)
     {
         case SDL_QUIT:
@@ -114,9 +117,6 @@ int Window_OnSDLEvent(void*, SDL_Event* event)
         }
     }
 
-    for (auto listener : Window::s_eventListeners)
-        listener->OnSDLEvent(event);
-
     return 0;
 }
 

UnleashedRecompLib/CMakeLists.txt

@@ -26,7 +26,7 @@ add_custom_command(
 )
 
 set(SHADER_RECOMP_ROOT "${SWA_THIRDPARTY_ROOT}/ShaderRecomp/ShaderRecomp")
-set(SHADER_RECOMP_INCLUDE "${SHADER_RECOMP_ROOT}/shader_common.hlsli")
+set(SHADER_RECOMP_INCLUDE "${SHADER_RECOMP_ROOT}/shader_common.h")
 
 target_compile_definitions(ShaderRecomp PRIVATE 
     SHADER_RECOMP_INPUT=\"${CMAKE_CURRENT_SOURCE_DIR}/private\" 

UnleashedRecompLib/config/SWA.toml

@@ -422,3 +422,28 @@ registers = ["r7"]
 name = "LoadingScreenSpeedFixMidAsmHook"
 address = 0x824DAB60
 registers = ["r4"]
+
+[[midasm_hook]]
+name = "MotionBlurPrevInvViewProjectionMidAsmHook"
+address = 0x82BA9E7C
+registers = ["r10"]
+
+[[midasm_hook]]
+name = "GetDatabaseDataMidAsmHook"
+address = 0x82E38688 # Model
+registers = ["r1", "r31"]
+
+[[midasm_hook]]
+name = "GetDatabaseDataMidAsmHook"
+address = 0x82E39650 # Terrain Model
+registers = ["r1", "r31"]
+
+[[midasm_hook]]
+name = "GetDatabaseDataMidAsmHook"
+address = 0x827D614C # Particle Material Binary
+registers = ["r1", "r29"]
+
+[[midasm_hook]]
+name = "GetDatabaseDataMidAsmHook"
+address = 0x827D6018 # Particle Material XML
+registers = ["r1", "r30"]

UnleashedRecompLib/shader/shader_cache.h

@@ -7,7 +7,8 @@ struct ShaderCacheEntry
     const uint32_t dxilSize;
     const uint32_t spirvOffset;
     const uint32_t spirvSize;
-    void* userData;
+    const uint32_t specConstantsMask;
+    struct GuestShader* guestShader;
 };
 
 extern ShaderCacheEntry g_shaderCacheEntries[];

thirdparty/ShaderRecomp

@@ -1 +1 @@
-Subproject commit 30f598604767602e3afce56b947e99dba2b51211
+Subproject commit f936ed2212d8291439003eb0c0d8edc0ecafd24d

vcpkg.json

@@ -19,6 +19,7 @@
         {
             "name": "imgui",
             "features": [ "sdl2-binding" ]
-        }
+        },
+        "magic-enum"
     ]
 }