From 1914087998bc296208355dc4b1b2553430b081b2 Mon Sep 17 00:00:00 2001 From: Pokechu22 Date: Sun, 20 Jun 2021 13:47:57 -0700 Subject: [PATCH] Create and use CPArray enum class --- Source/Core/Core/FifoPlayer/FifoAnalyzer.cpp | 12 ++-- Source/Core/Core/FifoPlayer/FifoAnalyzer.h | 6 +- .../Core/FifoPlayer/FifoRecordAnalyzer.cpp | 16 +++--- .../Core/Core/FifoPlayer/FifoRecordAnalyzer.h | 6 +- Source/Core/DolphinQt/FIFO/FIFOAnalyzer.cpp | 16 +++--- Source/Core/VideoCommon/CPMemory.cpp | 10 ++-- Source/Core/VideoCommon/CPMemory.h | 55 +++++++++++++------ Source/Core/VideoCommon/OpcodeDecoding.cpp | 6 +- Source/Core/VideoCommon/VertexLoaderARM64.cpp | 26 +++++---- Source/Core/VideoCommon/VertexLoaderARM64.h | 6 +- .../Core/VideoCommon/VertexLoaderManager.cpp | 39 ++++++++----- Source/Core/VideoCommon/VertexLoaderManager.h | 3 +- Source/Core/VideoCommon/VertexLoaderX64.cpp | 17 +++--- Source/Core/VideoCommon/VertexLoaderX64.h | 3 +- .../Core/VideoCommon/VertexLoader_Color.cpp | 26 ++++----- .../Core/VideoCommon/VertexLoader_Normal.cpp | 10 ++-- .../VideoCommon/VertexLoader_Position.cpp | 4 +- .../VideoCommon/VertexLoader_TextCoord.cpp | 4 +- Source/Core/VideoCommon/XFMemory.h | 4 +- Source/Core/VideoCommon/XFStructs.cpp | 14 ++--- Source/Core/VideoCommon/XFStructs.h | 2 +- .../VideoCommon/VertexLoaderTest.cpp | 12 ++-- 22 files changed, 171 insertions(+), 126 deletions(-) diff --git a/Source/Core/Core/FifoPlayer/FifoAnalyzer.cpp b/Source/Core/Core/FifoPlayer/FifoAnalyzer.cpp index a2103bd8a8..ca9ed3574d 100644 --- a/Source/Core/Core/FifoPlayer/FifoAnalyzer.cpp +++ b/Source/Core/Core/FifoPlayer/FifoAnalyzer.cpp @@ -190,11 +190,11 @@ u32 AnalyzeCommand(const u8* data, DecodeMode mode) { s_DrawingObject = false; - int array = 0xc + (cmd - static_cast(Opcode::GX_LOAD_INDX_A)) / 8; + CPArray array = static_cast(0xc + (cmd - static_cast(Opcode::GX_LOAD_INDX_A)) / 8); u32 value = ReadFifo32(data); if (mode == DecodeMode::Record) - FifoRecordAnalyzer::ProcessLoadIndexedXf(value, array); + FifoRecordAnalyzer::ProcessLoadIndexedXf(array, value); break; } @@ -238,8 +238,8 @@ u32 AnalyzeCommand(const u8* data, DecodeMode mode) { for (size_t i = 0; i < offsets.size(); ++i) { - FifoRecordAnalyzer::WriteVertexArray(static_cast(i), data + offsets[i], vertexSize, - numVertices); + FifoRecordAnalyzer::WriteVertexArray(static_cast(i), data + offsets[i], + vertexSize, numVertices); } } @@ -284,11 +284,11 @@ void LoadCPReg(u32 subCmd, u32 value, CPMemory& cpMem) break; case ARRAY_BASE: - cpMem.arrayBases[subCmd & CP_ARRAY_MASK] = value; + cpMem.arrayBases[static_cast(subCmd & CP_ARRAY_MASK)] = value; break; case ARRAY_STRIDE: - cpMem.arrayStrides[subCmd & CP_ARRAY_MASK] = value & 0xFF; + cpMem.arrayStrides[static_cast(subCmd & CP_ARRAY_MASK)] = value & 0xFF; break; } } diff --git a/Source/Core/Core/FifoPlayer/FifoAnalyzer.h b/Source/Core/Core/FifoPlayer/FifoAnalyzer.h index 4e167cbc9f..e9604ce918 100644 --- a/Source/Core/Core/FifoPlayer/FifoAnalyzer.h +++ b/Source/Core/Core/FifoPlayer/FifoAnalyzer.h @@ -6,6 +6,8 @@ #include #include "Common/CommonTypes.h" +#include "Common/EnumMap.h" + #include "VideoCommon/CPMemory.h" namespace FifoAnalyzer @@ -22,8 +24,8 @@ struct CPMemory { TVtxDesc vtxDesc; std::array vtxAttr; - std::array arrayBases{}; - std::array arrayStrides{}; + Common::EnumMap arrayBases{}; + Common::EnumMap arrayStrides{}; }; void LoadCPReg(u32 subCmd, u32 value, CPMemory& cpMem); diff --git a/Source/Core/Core/FifoPlayer/FifoRecordAnalyzer.cpp b/Source/Core/Core/FifoPlayer/FifoRecordAnalyzer.cpp index 1f9adcc54c..4ada443fcf 100644 --- a/Source/Core/Core/FifoPlayer/FifoRecordAnalyzer.cpp +++ b/Source/Core/Core/FifoPlayer/FifoRecordAnalyzer.cpp @@ -30,7 +30,7 @@ void FifoRecordAnalyzer::Initialize(const u32* cpMem) std::copy(strides_start, strides_end, s_CpMem.arrayStrides.begin()); } -void FifoRecordAnalyzer::ProcessLoadIndexedXf(u32 val, int array) +void FifoRecordAnalyzer::ProcessLoadIndexedXf(CPArray array, u32 val) { int index = val >> 16; int size = ((val >> 12) & 0xF) + 1; @@ -40,19 +40,19 @@ void FifoRecordAnalyzer::ProcessLoadIndexedXf(u32 val, int array) FifoRecorder::GetInstance().UseMemory(address, size * 4, MemoryUpdate::XF_DATA); } -void FifoRecordAnalyzer::WriteVertexArray(int arrayIndex, const u8* vertexData, int vertexSize, +void FifoRecordAnalyzer::WriteVertexArray(CPArray arrayIndex, const u8* vertexData, int vertexSize, int numVertices) { // Skip if not indexed array VertexComponentFormat arrayType; - if (arrayIndex == ARRAY_POSITION) + if (arrayIndex == CPArray::Position) arrayType = s_CpMem.vtxDesc.low.Position; - else if (arrayIndex == ARRAY_NORMAL) + else if (arrayIndex == CPArray::Normal) arrayType = s_CpMem.vtxDesc.low.Normal; - else if (arrayIndex >= ARRAY_COLOR0 && arrayIndex < ARRAY_COLOR0 + NUM_COLOR_ARRAYS) - arrayType = s_CpMem.vtxDesc.low.Color[arrayIndex - ARRAY_COLOR0]; - else if (arrayIndex >= ARRAY_TEXCOORD0 && arrayIndex < ARRAY_TEXCOORD0 + NUM_TEXCOORD_ARRAYS) - arrayType = s_CpMem.vtxDesc.high.TexCoord[arrayIndex - ARRAY_TEXCOORD0]; + else if (arrayIndex >= CPArray::Color0 && arrayIndex <= CPArray::Color1) + arrayType = s_CpMem.vtxDesc.low.Color[u8(arrayIndex) - u8(CPArray::Color0)]; + else if (arrayIndex >= CPArray::TexCoord0 && arrayIndex <= CPArray::TexCoord7) + arrayType = s_CpMem.vtxDesc.high.TexCoord[u8(arrayIndex) - u8(CPArray::TexCoord0)]; else { PanicAlertFmt("Invalid arrayIndex {}", arrayIndex); diff --git a/Source/Core/Core/FifoPlayer/FifoRecordAnalyzer.h b/Source/Core/Core/FifoPlayer/FifoRecordAnalyzer.h index 8c3bd00a86..d1ac21c09b 100644 --- a/Source/Core/Core/FifoPlayer/FifoRecordAnalyzer.h +++ b/Source/Core/Core/FifoPlayer/FifoRecordAnalyzer.h @@ -5,11 +5,13 @@ #include "Common/CommonTypes.h" +enum class CPArray : u8; + namespace FifoRecordAnalyzer { // Must call this before analyzing Fifo commands with FifoAnalyzer::AnalyzeCommand() void Initialize(const u32* cpMem); -void ProcessLoadIndexedXf(u32 val, int array); -void WriteVertexArray(int arrayIndex, const u8* vertexData, int vertexSize, int numVertices); +void ProcessLoadIndexedXf(CPArray array, u32 val); +void WriteVertexArray(CPArray arrayIndex, const u8* vertexData, int vertexSize, int numVertices); } // namespace FifoRecordAnalyzer diff --git a/Source/Core/DolphinQt/FIFO/FIFOAnalyzer.cpp b/Source/Core/DolphinQt/FIFO/FIFOAnalyzer.cpp index 21a4572d38..73ba823ec1 100644 --- a/Source/Core/DolphinQt/FIFO/FIFOAnalyzer.cpp +++ b/Source/Core/DolphinQt/FIFO/FIFOAnalyzer.cpp @@ -287,7 +287,7 @@ void FIFOAnalyzer::UpdateDetails() case Opcode::GX_LOAD_INDX_A: { const auto [desc, written] = - GetXFIndexedLoadInfo(ARRAY_XF_A, Common::swap32(&object[object_offset])); + GetXFIndexedLoadInfo(CPArray::XF_A, Common::swap32(&object[object_offset])); object_offset += 4; new_label = QStringLiteral("LOAD INDX A %1").arg(QString::fromStdString(desc)); } @@ -295,7 +295,7 @@ void FIFOAnalyzer::UpdateDetails() case Opcode::GX_LOAD_INDX_B: { const auto [desc, written] = - GetXFIndexedLoadInfo(ARRAY_XF_B, Common::swap32(&object[object_offset])); + GetXFIndexedLoadInfo(CPArray::XF_B, Common::swap32(&object[object_offset])); object_offset += 4; new_label = QStringLiteral("LOAD INDX B %1").arg(QString::fromStdString(desc)); } @@ -303,7 +303,7 @@ void FIFOAnalyzer::UpdateDetails() case Opcode::GX_LOAD_INDX_C: { const auto [desc, written] = - GetXFIndexedLoadInfo(ARRAY_XF_C, Common::swap32(&object[object_offset])); + GetXFIndexedLoadInfo(CPArray::XF_C, Common::swap32(&object[object_offset])); object_offset += 4; new_label = QStringLiteral("LOAD INDX C %1").arg(QString::fromStdString(desc)); } @@ -311,7 +311,7 @@ void FIFOAnalyzer::UpdateDetails() case Opcode::GX_LOAD_INDX_D: { const auto [desc, written] = - GetXFIndexedLoadInfo(ARRAY_XF_D, Common::swap32(&object[object_offset])); + GetXFIndexedLoadInfo(CPArray::XF_D, Common::swap32(&object[object_offset])); object_offset += 4; new_label = QStringLiteral("LOAD INDX D %1").arg(QString::fromStdString(desc)); } @@ -619,7 +619,7 @@ void FIFOAnalyzer::UpdateDescription() } else if (opcode == Opcode::GX_LOAD_INDX_A) { - const auto [desc, written] = GetXFIndexedLoadInfo(ARRAY_XF_A, Common::swap32(cmddata + 1)); + const auto [desc, written] = GetXFIndexedLoadInfo(CPArray::XF_A, Common::swap32(cmddata + 1)); text = QString::fromStdString(desc); text += QLatin1Char{'\n'}; @@ -629,7 +629,7 @@ void FIFOAnalyzer::UpdateDescription() } else if (opcode == Opcode::GX_LOAD_INDX_B) { - const auto [desc, written] = GetXFIndexedLoadInfo(ARRAY_XF_B, Common::swap32(cmddata + 1)); + const auto [desc, written] = GetXFIndexedLoadInfo(CPArray::XF_B, Common::swap32(cmddata + 1)); text = QString::fromStdString(desc); text += QLatin1Char{'\n'}; @@ -641,7 +641,7 @@ void FIFOAnalyzer::UpdateDescription() } else if (opcode == Opcode::GX_LOAD_INDX_C) { - const auto [desc, written] = GetXFIndexedLoadInfo(ARRAY_XF_C, Common::swap32(cmddata + 1)); + const auto [desc, written] = GetXFIndexedLoadInfo(CPArray::XF_C, Common::swap32(cmddata + 1)); text = QString::fromStdString(desc); text += QLatin1Char{'\n'}; @@ -652,7 +652,7 @@ void FIFOAnalyzer::UpdateDescription() } else if (opcode == Opcode::GX_LOAD_INDX_D) { - const auto [desc, written] = GetXFIndexedLoadInfo(ARRAY_XF_D, Common::swap32(cmddata + 1)); + const auto [desc, written] = GetXFIndexedLoadInfo(CPArray::XF_D, Common::swap32(cmddata + 1)); text = QString::fromStdString(desc); text += QLatin1Char{'\n'}; diff --git a/Source/Core/VideoCommon/CPMemory.cpp b/Source/Core/VideoCommon/CPMemory.cpp index 1184e10ca3..afa354b4e4 100644 --- a/Source/Core/VideoCommon/CPMemory.cpp +++ b/Source/Core/VideoCommon/CPMemory.cpp @@ -62,11 +62,13 @@ std::pair GetCPRegInfo(u8 cmd, u32 value) return std::make_pair(fmt::format("CP_VAT_REG_C - Format {}", cmd & CP_VAT_MASK), fmt::to_string(UVAT_group2{.Hex = value})); case ARRAY_BASE: - return std::make_pair(fmt::format("ARRAY_BASE Array {}", cmd & CP_ARRAY_MASK), - fmt::format("Base address {:08x}", value)); + return std::make_pair( + fmt::format("ARRAY_BASE Array {}", static_cast(cmd & CP_ARRAY_MASK)), + fmt::format("Base address {:08x}", value)); case ARRAY_STRIDE: - return std::make_pair(fmt::format("ARRAY_STRIDE Array {}", cmd - ARRAY_STRIDE), - fmt::format("Stride {:02x}", value & 0xff)); + return std::make_pair( + fmt::format("ARRAY_STRIDE Array {}", static_cast(cmd & CP_ARRAY_MASK)), + fmt::format("Stride {:02x}", value & 0xff)); default: return std::make_pair(fmt::format("Invalid CP register {:02x} = {:08x}", cmd, value), ""); } diff --git a/Source/Core/VideoCommon/CPMemory.h b/Source/Core/VideoCommon/CPMemory.h index 81d0316cec..1a937d15c9 100644 --- a/Source/Core/VideoCommon/CPMemory.h +++ b/Source/Core/VideoCommon/CPMemory.h @@ -11,6 +11,7 @@ #include "Common/BitSet.h" #include "Common/CommonTypes.h" #include "Common/EnumFormatter.h" +#include "Common/EnumMap.h" #include "Common/MsgHandler.h" enum @@ -53,24 +54,46 @@ enum }; // Vertex array numbers -enum +enum class CPArray : u8 { - ARRAY_POSITION = 0, - ARRAY_NORMAL = 1, - ARRAY_COLOR0 = 2, - NUM_COLOR_ARRAYS = 2, - ARRAY_TEXCOORD0 = 4, - NUM_TEXCOORD_ARRAYS = 8, + Position = 0, + Normal = 1, - ARRAY_XF_A = 12, // Usually used for position matrices - ARRAY_XF_B = 13, // Usually used for normal matrices - ARRAY_XF_C = 14, // Usually used for tex coord matrices - ARRAY_XF_D = 15, // Usually used for light objects + Color0 = 2, + Color1 = 3, - // Number of arrays related to vertex components (position, normal, color, tex coord) - // Excludes the 4 arrays used for indexed XF loads - NUM_VERTEX_COMPONENT_ARRAYS = 12, + TexCoord0 = 4, + TexCoord1 = 5, + TexCoord2 = 6, + TexCoord3 = 7, + TexCoord4 = 8, + TexCoord5 = 9, + TexCoord6 = 10, + TexCoord7 = 11, + + XF_A = 12, // Usually used for position matrices + XF_B = 13, // Usually used for normal matrices + XF_C = 14, // Usually used for tex coord matrices + XF_D = 15, // Usually used for light objects }; +template <> +struct fmt::formatter : EnumFormatter +{ + static constexpr array_type names = {"Position", "Normal", "Color 0", "Color 1", + "Tex Coord 0", "Tex Coord 1", "Tex Coord 2", "Tex Coord 3", + "Tex Coord 4", "Tex Coord 5", "Tex Coord 6", "Tex Coord 7", + "XF A", "XF B", "XF C", "XF D"}; + formatter() : EnumFormatter(names) {} +}; +// Intended for offsetting from Color0/TexCoord0 +constexpr CPArray operator+(CPArray array, u8 offset) +{ + return static_cast(static_cast(array) + offset); +} + +// Number of arrays related to vertex components (position, normal, color, tex coord) +// Excludes the 4 arrays used for indexed XF loads +constexpr u8 NUM_VERTEX_COMPONENT_ARRAYS = 12; // Vertex components enum class VertexComponentFormat @@ -607,8 +630,8 @@ class VertexLoaderBase; // STATE_TO_SAVE struct CPState final { - u32 array_bases[CP_NUM_ARRAYS]{}; - u32 array_strides[CP_NUM_ARRAYS]{}; + Common::EnumMap array_bases; + Common::EnumMap array_strides; TMatrixIndexA matrix_index_a{}; TMatrixIndexB matrix_index_b{}; TVtxDesc vtx_desc; diff --git a/Source/Core/VideoCommon/OpcodeDecoding.cpp b/Source/Core/VideoCommon/OpcodeDecoding.cpp index 362afd6a7a..be879ddfbc 100644 --- a/Source/Core/VideoCommon/OpcodeDecoding.cpp +++ b/Source/Core/VideoCommon/OpcodeDecoding.cpp @@ -166,12 +166,12 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list) // GX_LOAD_INDX_B (40) -> 0xD // GX_LOAD_INDX_C (48) -> 0xE // GX_LOAD_INDX_D (56) -> 0xF - const int ref_array = (cmd_byte / 8) + 8; + const auto array = static_cast((cmd_byte / 8) + 8); if constexpr (is_preprocess) - PreprocessIndexedXF(src.Read(), ref_array); + PreprocessIndexedXF(array, src.Read()); else - LoadIndexedXF(src.Read(), ref_array); + LoadIndexedXF(array, src.Read()); } break; diff --git a/Source/Core/VideoCommon/VertexLoaderARM64.cpp b/Source/Core/VideoCommon/VertexLoaderARM64.cpp index 71fc9e054c..6663e6c8ae 100644 --- a/Source/Core/VideoCommon/VertexLoaderARM64.cpp +++ b/Source/Core/VideoCommon/VertexLoaderARM64.cpp @@ -6,6 +6,7 @@ #include #include "Common/CommonTypes.h" +#include "VideoCommon/CPMemory.h" #include "VideoCommon/DataReader.h" #include "VideoCommon/VertexLoaderManager.h" @@ -59,7 +60,7 @@ VertexLoaderARM64::VertexLoaderARM64(const TVtxDesc& vtx_desc, const VAT& vtx_at WriteProtect(); } -void VertexLoaderARM64::GetVertexAddr(int array, VertexComponentFormat attribute, ARM64Reg reg) +void VertexLoaderARM64::GetVertexAddr(CPArray array, VertexComponentFormat attribute, ARM64Reg reg) { if (IsIndexed(attribute)) { @@ -95,7 +96,7 @@ void VertexLoaderARM64::GetVertexAddr(int array, VertexComponentFormat attribute REV16(scratch1_reg, scratch1_reg); } - if (array == ARRAY_POSITION) + if (array == CPArray::Position) { EOR(scratch2_reg, scratch1_reg, attribute == VertexComponentFormat::Index8 ? LogicalImm(0xFF, 32) : @@ -103,17 +104,18 @@ void VertexLoaderARM64::GetVertexAddr(int array, VertexComponentFormat attribute m_skip_vertex = CBZ(scratch2_reg); } - LDR(IndexType::Unsigned, scratch2_reg, stride_reg, array * 4); + LDR(IndexType::Unsigned, scratch2_reg, stride_reg, static_cast(array) * 4); MUL(scratch1_reg, scratch1_reg, scratch2_reg); - LDR(IndexType::Unsigned, EncodeRegTo64(scratch2_reg), arraybase_reg, array * 8); + LDR(IndexType::Unsigned, EncodeRegTo64(scratch2_reg), arraybase_reg, + static_cast(array) * 8); ADD(EncodeRegTo64(reg), EncodeRegTo64(scratch1_reg), EncodeRegTo64(scratch2_reg)); } else ADD(reg, src_reg, m_src_ofs); } -s32 VertexLoaderARM64::GetAddressImm(int array, VertexComponentFormat attribute, +s32 VertexLoaderARM64::GetAddressImm(CPArray array, VertexComponentFormat attribute, Arm64Gen::ARM64Reg reg, u32 align) { if (IsIndexed(attribute) || (m_src_ofs > 255 && (m_src_ofs & (align - 1)))) @@ -448,8 +450,8 @@ void VertexLoaderARM64::GenerateVertexLoader() int load_size = GetLoadSize(load_bytes); load_size <<= 3; - s32 offset = GetAddressImm(ARRAY_POSITION, m_VtxDesc.low.Position, EncodeRegTo64(scratch1_reg), - load_size); + s32 offset = GetAddressImm(CPArray::Position, m_VtxDesc.low.Position, + EncodeRegTo64(scratch1_reg), load_size); ReadVertex(m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat, pos_elements, pos_elements, m_VtxAttr.g0.ByteDequant, m_VtxAttr.g0.PosFrac, &m_native_vtx_decl.position, offset); } @@ -470,7 +472,7 @@ void VertexLoaderARM64::GenerateVertexLoader() int load_bytes = elem_size * 3; int load_size = GetLoadSize(load_bytes); - offset = GetAddressImm(ARRAY_NORMAL, m_VtxDesc.low.Normal, EncodeRegTo64(scratch1_reg), + offset = GetAddressImm(CPArray::Normal, m_VtxDesc.low.Normal, EncodeRegTo64(scratch1_reg), load_size << 3); if (offset == -1) @@ -488,7 +490,7 @@ void VertexLoaderARM64::GenerateVertexLoader() } } - for (size_t i = 0; i < m_VtxDesc.low.Color.Size(); i++) + for (u8 i = 0; i < m_VtxDesc.low.Color.Size(); i++) { m_native_vtx_decl.colors[i].components = 4; m_native_vtx_decl.colors[i].type = VAR_UNSIGNED_BYTE; @@ -501,7 +503,7 @@ void VertexLoaderARM64::GenerateVertexLoader() m_VtxAttr.GetColorFormat(i) == ColorFormat::RGBA4444) align = 2; - s32 offset = GetAddressImm(ARRAY_COLOR0 + int(i), m_VtxDesc.low.Color[i], + s32 offset = GetAddressImm(CPArray::Color0 + i, m_VtxDesc.low.Color[i], EncodeRegTo64(scratch1_reg), align); ReadColor(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i), offset); m_native_vtx_decl.colors[i].components = 4; @@ -513,7 +515,7 @@ void VertexLoaderARM64::GenerateVertexLoader() } } - for (size_t i = 0; i < m_VtxDesc.high.TexCoord.Size(); i++) + for (u8 i = 0; i < m_VtxDesc.high.TexCoord.Size(); i++) { m_native_vtx_decl.texcoords[i].offset = m_dst_ofs; m_native_vtx_decl.texcoords[i].type = VAR_FLOAT; @@ -527,7 +529,7 @@ void VertexLoaderARM64::GenerateVertexLoader() int load_size = GetLoadSize(load_bytes); load_size <<= 3; - s32 offset = GetAddressImm(ARRAY_TEXCOORD0 + int(i), m_VtxDesc.high.TexCoord[i], + s32 offset = GetAddressImm(CPArray::TexCoord0 + i, m_VtxDesc.high.TexCoord[i], EncodeRegTo64(scratch1_reg), load_size); u8 scaling_exponent = m_VtxAttr.GetTexFrac(i); ReadVertex(m_VtxDesc.high.TexCoord[i], m_VtxAttr.GetTexFormat(i), elements, diff --git a/Source/Core/VideoCommon/VertexLoaderARM64.h b/Source/Core/VideoCommon/VertexLoaderARM64.h index a2190a6965..eccf3f0ad8 100644 --- a/Source/Core/VideoCommon/VertexLoaderARM64.h +++ b/Source/Core/VideoCommon/VertexLoaderARM64.h @@ -11,6 +11,7 @@ class DataReader; enum class VertexComponentFormat; enum class ComponentFormat; enum class ColorFormat; +enum class CPArray : u8; class VertexLoaderARM64 : public VertexLoaderBase, public Arm64Gen::ARM64CodeBlock { @@ -25,8 +26,9 @@ private: u32 m_dst_ofs = 0; Arm64Gen::FixupBranch m_skip_vertex; Arm64Gen::ARM64FloatEmitter m_float_emit; - void GetVertexAddr(int array, VertexComponentFormat attribute, Arm64Gen::ARM64Reg reg); - s32 GetAddressImm(int array, VertexComponentFormat attribute, Arm64Gen::ARM64Reg reg, u32 align); + void GetVertexAddr(CPArray array, VertexComponentFormat attribute, Arm64Gen::ARM64Reg reg); + s32 GetAddressImm(CPArray array, VertexComponentFormat attribute, Arm64Gen::ARM64Reg reg, + u32 align); int ReadVertex(VertexComponentFormat attribute, ComponentFormat format, int count_in, int count_out, bool dequantize, u8 scaling_exponent, AttributeFormat* native_format, s32 offset = -1); diff --git a/Source/Core/VideoCommon/VertexLoaderManager.cpp b/Source/Core/VideoCommon/VertexLoaderManager.cpp index b794c5dfc0..e2475d666f 100644 --- a/Source/Core/VideoCommon/VertexLoaderManager.cpp +++ b/Source/Core/VideoCommon/VertexLoaderManager.cpp @@ -14,6 +14,7 @@ #include "Common/Assert.h" #include "Common/CommonTypes.h" +#include "Common/EnumMap.h" #include "Common/Logging/Log.h" #include "Core/DolphinAnalytics.h" @@ -48,7 +49,14 @@ static std::mutex s_vertex_loader_map_lock; static VertexLoaderMap s_vertex_loader_map; // TODO - change into array of pointers. Keep a map of all seen so far. -u8* cached_arraybases[NUM_VERTEX_COMPONENT_ARRAYS]; +Common::EnumMap cached_arraybases; + +BitSet8 g_main_vat_dirty; +BitSet8 g_preprocess_vat_dirty; +bool g_bases_dirty; // Main only +u8 g_current_vat; // Main only +std::array g_main_vertex_loaders; +std::array g_preprocess_vertex_loaders; void Init() { @@ -80,24 +88,25 @@ void UpdateVertexArrayPointers() // 12 through 15 are used for loading data into xfmem. // We also only update the array base if the vertex description states we are going to use it. if (IsIndexed(g_main_cp_state.vtx_desc.low.Position)) - cached_arraybases[ARRAY_POSITION] = - Memory::GetPointer(g_main_cp_state.array_bases[ARRAY_POSITION]); + cached_arraybases[CPArray::Position] = + Memory::GetPointer(g_main_cp_state.array_bases[CPArray::Position]); if (IsIndexed(g_main_cp_state.vtx_desc.low.Normal)) - cached_arraybases[ARRAY_NORMAL] = Memory::GetPointer(g_main_cp_state.array_bases[ARRAY_NORMAL]); + cached_arraybases[CPArray::Normal] = + Memory::GetPointer(g_main_cp_state.array_bases[CPArray::Normal]); - for (size_t i = 0; i < g_main_cp_state.vtx_desc.low.Color.Size(); i++) + for (u8 i = 0; i < g_main_cp_state.vtx_desc.low.Color.Size(); i++) { if (IsIndexed(g_main_cp_state.vtx_desc.low.Color[i])) - cached_arraybases[ARRAY_COLOR0 + i] = - Memory::GetPointer(g_main_cp_state.array_bases[ARRAY_COLOR0 + i]); + cached_arraybases[CPArray::Color0 + i] = + Memory::GetPointer(g_main_cp_state.array_bases[CPArray::Color0 + i]); } - for (size_t i = 0; i < g_main_cp_state.vtx_desc.high.TexCoord.Size(); i++) + for (u8 i = 0; i < g_main_cp_state.vtx_desc.high.TexCoord.Size(); i++) { if (IsIndexed(g_main_cp_state.vtx_desc.high.TexCoord[i])) - cached_arraybases[ARRAY_TEXCOORD0 + i] = - Memory::GetPointer(g_main_cp_state.array_bases[ARRAY_TEXCOORD0 + i]); + cached_arraybases[CPArray::TexCoord0 + i] = + Memory::GetPointer(g_main_cp_state.array_bases[CPArray::TexCoord0 + i]); } g_main_cp_state.bases_dirty = false; @@ -398,13 +407,13 @@ void LoadCPReg(u32 sub_cmd, u32 value, bool is_preprocess) // Pointers to vertex arrays in GC RAM case ARRAY_BASE: - state->array_bases[sub_cmd & CP_ARRAY_MASK] = + state->array_bases[static_cast(sub_cmd & CP_ARRAY_MASK)] = value & CommandProcessor::GetPhysicalAddressMask(); state->bases_dirty = true; break; case ARRAY_STRIDE: - state->array_strides[sub_cmd & CP_ARRAY_MASK] = value & 0xFF; + state->array_strides[static_cast(sub_cmd & CP_ARRAY_MASK)] = value & 0xFF; break; default: @@ -427,9 +436,9 @@ void FillCPMemoryArray(u32* memory) memory[CP_VAT_REG_C + i] = g_main_cp_state.vtx_attr[i].g2.Hex; } - for (int i = 0; i < CP_NUM_ARRAYS; ++i) + for (u8 i = 0; i < CP_NUM_ARRAYS; ++i) { - memory[ARRAY_BASE + i] = g_main_cp_state.array_bases[i]; - memory[ARRAY_STRIDE + i] = g_main_cp_state.array_strides[i]; + memory[ARRAY_BASE + i] = g_main_cp_state.array_bases[static_cast(i)]; + memory[ARRAY_STRIDE + i] = g_main_cp_state.array_strides[static_cast(i)]; } } diff --git a/Source/Core/VideoCommon/VertexLoaderManager.h b/Source/Core/VideoCommon/VertexLoaderManager.h index bd9066c5bb..4eeae12742 100644 --- a/Source/Core/VideoCommon/VertexLoaderManager.h +++ b/Source/Core/VideoCommon/VertexLoaderManager.h @@ -8,6 +8,7 @@ #include #include "Common/CommonTypes.h" +#include "Common/EnumMap.h" #include "VideoCommon/CPMemory.h" class DataReader; @@ -46,7 +47,7 @@ int RunVertices(int vtx_attr_group, OpcodeDecoder::Primitive primitive, int coun NativeVertexFormat* GetCurrentVertexFormat(); // Resolved pointers to array bases. Used by vertex loaders. -extern u8* cached_arraybases[NUM_VERTEX_COMPONENT_ARRAYS]; +extern Common::EnumMap cached_arraybases; void UpdateVertexArrayPointers(); // Position cache for zfreeze (3 vertices, 4 floats each to allow SIMD overwrite). diff --git a/Source/Core/VideoCommon/VertexLoaderX64.cpp b/Source/Core/VideoCommon/VertexLoaderX64.cpp index b204e131d7..4022863e59 100644 --- a/Source/Core/VideoCommon/VertexLoaderX64.cpp +++ b/Source/Core/VideoCommon/VertexLoaderX64.cpp @@ -15,6 +15,7 @@ #include "Common/JitRegister.h" #include "Common/x64ABI.h" #include "Common/x64Emitter.h" +#include "VideoCommon/CPMemory.h" #include "VideoCommon/DataReader.h" #include "VideoCommon/VertexLoaderManager.h" @@ -54,7 +55,7 @@ VertexLoaderX64::VertexLoaderX64(const TVtxDesc& vtx_desc, const VAT& vtx_att) JitRegister::Register(region, GetCodePtr(), name.c_str()); } -OpArg VertexLoaderX64::GetVertexAddr(int array, VertexComponentFormat attribute) +OpArg VertexLoaderX64::GetVertexAddr(CPArray array, VertexComponentFormat attribute) { OpArg data = MDisp(src_reg, m_src_ofs); if (IsIndexed(attribute)) @@ -62,7 +63,7 @@ OpArg VertexLoaderX64::GetVertexAddr(int array, VertexComponentFormat attribute) int bits = attribute == VertexComponentFormat::Index8 ? 8 : 16; LoadAndSwap(bits, scratch1, data); m_src_ofs += bits / 8; - if (array == ARRAY_POSITION) + if (array == CPArray::Position) { CMP(bits, R(scratch1), Imm8(-1)); m_skip_vertex = J_CC(CC_E, true); @@ -433,7 +434,7 @@ void VertexLoaderX64::GenerateVertexLoader() texmatidx_ofs[i] = m_src_ofs++; } - OpArg data = GetVertexAddr(ARRAY_POSITION, m_VtxDesc.low.Position); + OpArg data = GetVertexAddr(CPArray::Position, m_VtxDesc.low.Position); int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3; ReadVertex(data, m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat, pos_elements, pos_elements, m_VtxAttr.g0.ByteDequant, m_VtxAttr.g0.PosFrac, &m_native_vtx_decl.position); @@ -448,7 +449,7 @@ void VertexLoaderX64::GenerateVertexLoader() { if (!i || m_VtxAttr.g0.NormalIndex3) { - data = GetVertexAddr(ARRAY_NORMAL, m_VtxDesc.low.Normal); + data = GetVertexAddr(CPArray::Normal, m_VtxDesc.low.Normal); int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat); data.AddMemOffset(i * elem_size * 3); } @@ -457,11 +458,11 @@ void VertexLoaderX64::GenerateVertexLoader() } } - for (size_t i = 0; i < m_VtxDesc.low.Color.Size(); i++) + for (u8 i = 0; i < m_VtxDesc.low.Color.Size(); i++) { if (m_VtxDesc.low.Color[i] != VertexComponentFormat::NotPresent) { - data = GetVertexAddr(ARRAY_COLOR0 + int(i), m_VtxDesc.low.Color[i]); + data = GetVertexAddr(CPArray::Color0 + i, m_VtxDesc.low.Color[i]); ReadColor(data, m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i)); m_native_vtx_decl.colors[i].components = 4; m_native_vtx_decl.colors[i].enable = true; @@ -472,12 +473,12 @@ void VertexLoaderX64::GenerateVertexLoader() } } - for (size_t i = 0; i < m_VtxDesc.high.TexCoord.Size(); i++) + for (u8 i = 0; i < m_VtxDesc.high.TexCoord.Size(); i++) { int elements = m_VtxAttr.GetTexElements(i) == TexComponentCount::ST ? 2 : 1; if (m_VtxDesc.high.TexCoord[i] != VertexComponentFormat::NotPresent) { - data = GetVertexAddr(ARRAY_TEXCOORD0 + int(i), m_VtxDesc.high.TexCoord[i]); + data = GetVertexAddr(CPArray::TexCoord0 + i, m_VtxDesc.high.TexCoord[i]); u8 scaling_exponent = m_VtxAttr.GetTexFrac(i); ReadVertex(data, m_VtxDesc.high.TexCoord[i], m_VtxAttr.GetTexFormat(i), elements, m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.g0.ByteDequant, diff --git a/Source/Core/VideoCommon/VertexLoaderX64.h b/Source/Core/VideoCommon/VertexLoaderX64.h index 8a3fd5aa6b..6a0cf7b785 100644 --- a/Source/Core/VideoCommon/VertexLoaderX64.h +++ b/Source/Core/VideoCommon/VertexLoaderX64.h @@ -10,6 +10,7 @@ enum class VertexComponentFormat; enum class ComponentFormat; enum class ColorFormat; +enum class CPArray : u8; class VertexLoaderX64 : public VertexLoaderBase, public Gen::X64CodeBlock { @@ -23,7 +24,7 @@ private: u32 m_src_ofs = 0; u32 m_dst_ofs = 0; Gen::FixupBranch m_skip_vertex; - Gen::OpArg GetVertexAddr(int array, VertexComponentFormat attribute); + Gen::OpArg GetVertexAddr(CPArray array, VertexComponentFormat attribute); int ReadVertex(Gen::OpArg data, VertexComponentFormat attribute, ComponentFormat format, int count_in, int count_out, bool dequantize, u8 scaling_exponent, AttributeFormat* native_format); diff --git a/Source/Core/VideoCommon/VertexLoader_Color.cpp b/Source/Core/VideoCommon/VertexLoader_Color.cpp index 4e71889bbd..36939557b8 100644 --- a/Source/Core/VideoCommon/VertexLoader_Color.cpp +++ b/Source/Core/VideoCommon/VertexLoader_Color.cpp @@ -79,8 +79,8 @@ void Color_ReadIndex_16b_565(VertexLoader* loader) { const auto index = DataRead(); const u8* const address = - VertexLoaderManager::cached_arraybases[ARRAY_COLOR0 + loader->m_colIndex] + - (index * g_main_cp_state.array_strides[ARRAY_COLOR0 + loader->m_colIndex]); + VertexLoaderManager::cached_arraybases[CPArray::Color0 + loader->m_colIndex] + + (index * g_main_cp_state.array_strides[CPArray::Color0 + loader->m_colIndex]); u16 value; std::memcpy(&value, address, sizeof(u16)); @@ -92,8 +92,8 @@ template void Color_ReadIndex_24b_888(VertexLoader* loader) { const auto index = DataRead(); - const u8* address = VertexLoaderManager::cached_arraybases[ARRAY_COLOR0 + loader->m_colIndex] + - (index * g_main_cp_state.array_strides[ARRAY_COLOR0 + loader->m_colIndex]); + const u8* address = VertexLoaderManager::cached_arraybases[CPArray::Color0 + loader->m_colIndex] + + (index * g_main_cp_state.array_strides[CPArray::Color0 + loader->m_colIndex]); SetCol(loader, Read24(address)); } @@ -101,18 +101,18 @@ template void Color_ReadIndex_32b_888x(VertexLoader* loader) { const auto index = DataRead(); - const u8* address = VertexLoaderManager::cached_arraybases[ARRAY_COLOR0 + loader->m_colIndex] + - (index * g_main_cp_state.array_strides[ARRAY_COLOR0 + loader->m_colIndex]); + const u8* address = VertexLoaderManager::cached_arraybases[CPArray::Color0 + loader->m_colIndex] + + (index * g_main_cp_state.array_strides[CPArray::Color0 + loader->m_colIndex]); SetCol(loader, Read24(address)); } template void Color_ReadIndex_16b_4444(VertexLoader* loader) { - auto const index = DataRead(); + const auto index = DataRead(); const u8* const address = - VertexLoaderManager::cached_arraybases[ARRAY_COLOR0 + loader->m_colIndex] + - (index * g_main_cp_state.array_strides[ARRAY_COLOR0 + loader->m_colIndex]); + VertexLoaderManager::cached_arraybases[CPArray::Color0 + loader->m_colIndex] + + (index * g_main_cp_state.array_strides[CPArray::Color0 + loader->m_colIndex]); u16 value; std::memcpy(&value, address, sizeof(u16)); @@ -124,8 +124,8 @@ template void Color_ReadIndex_24b_6666(VertexLoader* loader) { const auto index = DataRead(); - const u8* data = VertexLoaderManager::cached_arraybases[ARRAY_COLOR0 + loader->m_colIndex] + - (index * g_main_cp_state.array_strides[ARRAY_COLOR0 + loader->m_colIndex]) - 1; + const u8* data = VertexLoaderManager::cached_arraybases[CPArray::Color0 + loader->m_colIndex] + + (index * g_main_cp_state.array_strides[CPArray::Color0 + loader->m_colIndex]) - 1; const u32 val = Common::swap32(data); SetCol6666(loader, val); } @@ -134,8 +134,8 @@ template void Color_ReadIndex_32b_8888(VertexLoader* loader) { const auto index = DataRead(); - const u8* address = VertexLoaderManager::cached_arraybases[ARRAY_COLOR0 + loader->m_colIndex] + - (index * g_main_cp_state.array_strides[ARRAY_COLOR0 + loader->m_colIndex]); + const u8* address = VertexLoaderManager::cached_arraybases[CPArray::Color0 + loader->m_colIndex] + + (index * g_main_cp_state.array_strides[CPArray::Color0 + loader->m_colIndex]); SetCol(loader, Read32(address)); } diff --git a/Source/Core/VideoCommon/VertexLoader_Normal.cpp b/Source/Core/VideoCommon/VertexLoader_Normal.cpp index f19f27eda3..254bcacff3 100644 --- a/Source/Core/VideoCommon/VertexLoader_Normal.cpp +++ b/Source/Core/VideoCommon/VertexLoader_Normal.cpp @@ -59,7 +59,7 @@ struct Normal_Direct { static void function([[maybe_unused]] VertexLoader* loader) { - auto const source = reinterpret_cast(DataGetPosition()); + const auto source = reinterpret_cast(DataGetPosition()); ReadIndirect(source); DataSkip(); } @@ -72,10 +72,10 @@ void Normal_Index_Offset() { static_assert(std::is_unsigned_v, "Only unsigned I is sane!"); - auto const index = DataRead(); - auto const data = reinterpret_cast( - VertexLoaderManager::cached_arraybases[ARRAY_NORMAL] + - (index * g_main_cp_state.array_strides[ARRAY_NORMAL]) + sizeof(T) * 3 * Offset); + const auto index = DataRead(); + const auto data = reinterpret_cast( + VertexLoaderManager::cached_arraybases[CPArray::Normal] + + (index * g_main_cp_state.array_strides[CPArray::Normal]) + sizeof(T) * 3 * Offset); ReadIndirect(data); } diff --git a/Source/Core/VideoCommon/VertexLoader_Position.cpp b/Source/Core/VideoCommon/VertexLoader_Position.cpp index 37b15de53c..0fe8e7ba72 100644 --- a/Source/Core/VideoCommon/VertexLoader_Position.cpp +++ b/Source/Core/VideoCommon/VertexLoader_Position.cpp @@ -60,8 +60,8 @@ void Pos_ReadIndex(VertexLoader* loader) const auto index = DataRead(); loader->m_vertexSkip = index == std::numeric_limits::max(); const auto data = - reinterpret_cast(VertexLoaderManager::cached_arraybases[ARRAY_POSITION] + - (index * g_main_cp_state.array_strides[ARRAY_POSITION])); + reinterpret_cast(VertexLoaderManager::cached_arraybases[CPArray::Position] + + (index * g_main_cp_state.array_strides[CPArray::Position])); const auto scale = loader->m_posScale; DataReader dst(g_vertex_manager_write_ptr, nullptr); diff --git a/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp b/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp index f5741f6423..89891df5a8 100644 --- a/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp +++ b/Source/Core/VideoCommon/VertexLoader_TextCoord.cpp @@ -55,8 +55,8 @@ void TexCoord_ReadIndex(VertexLoader* loader) const auto index = DataRead(); const auto data = reinterpret_cast( - VertexLoaderManager::cached_arraybases[ARRAY_TEXCOORD0 + loader->m_tcIndex] + - (index * g_main_cp_state.array_strides[ARRAY_TEXCOORD0 + loader->m_tcIndex])); + VertexLoaderManager::cached_arraybases[CPArray::TexCoord0 + loader->m_tcIndex] + + (index * g_main_cp_state.array_strides[CPArray::TexCoord0 + loader->m_tcIndex])); const auto scale = loader->m_tcScale[loader->m_tcIndex]; DataReader dst(g_vertex_manager_write_ptr, nullptr); diff --git a/Source/Core/VideoCommon/XFMemory.h b/Source/Core/VideoCommon/XFMemory.h index 2a44497ec7..32c5dbb607 100644 --- a/Source/Core/VideoCommon/XFMemory.h +++ b/Source/Core/VideoCommon/XFMemory.h @@ -459,5 +459,5 @@ static_assert(sizeof(XFMemory) == sizeof(u32) * 0x1058); extern XFMemory xfmem; void LoadXFReg(u32 transferSize, u32 address, DataReader src); -void LoadIndexedXF(u32 val, int array); -void PreprocessIndexedXF(u32 val, int refarray); +void LoadIndexedXF(CPArray array, u32 val); +void PreprocessIndexedXF(CPArray array, u32 val); diff --git a/Source/Core/VideoCommon/XFStructs.cpp b/Source/Core/VideoCommon/XFStructs.cpp index ebf9e8efab..c31b8cbb54 100644 --- a/Source/Core/VideoCommon/XFStructs.cpp +++ b/Source/Core/VideoCommon/XFStructs.cpp @@ -274,7 +274,7 @@ constexpr std::tuple ExtractIndexedXF(u32 val) } // TODO - verify that it is correct. Seems to work, though. -void LoadIndexedXF(u32 val, int refarray) +void LoadIndexedXF(CPArray array, u32 val) { const auto [index, address, size] = ExtractIndexedXF(val); // load stuff from array to address in xf mem @@ -287,8 +287,8 @@ void LoadIndexedXF(u32 val, int refarray) } else { - newData = (u32*)Memory::GetPointer(g_main_cp_state.array_bases[refarray] + - g_main_cp_state.array_strides[refarray] * index); + newData = (u32*)Memory::GetPointer(g_main_cp_state.array_bases[array] + + g_main_cp_state.array_strides[array] * index); } bool changed = false; for (u32 i = 0; i < size; ++i) @@ -307,12 +307,12 @@ void LoadIndexedXF(u32 val, int refarray) } } -void PreprocessIndexedXF(u32 val, int refarray) +void PreprocessIndexedXF(CPArray array, u32 val) { const auto [index, address, size] = ExtractIndexedXF(val); - const u8* new_data = Memory::GetPointer(g_preprocess_cp_state.array_bases[refarray] + - g_preprocess_cp_state.array_strides[refarray] * index); + const u8* new_data = Memory::GetPointer(g_preprocess_cp_state.array_bases[array] + + g_preprocess_cp_state.array_strides[array] * index); const size_t buf_size = size * sizeof(u32); Fifo::PushFifoAuxBuffer(new_data, buf_size); @@ -655,7 +655,7 @@ std::pair GetXFTransferInfo(const u8* data) return std::make_pair(fmt::to_string(name), fmt::to_string(desc)); } -std::pair GetXFIndexedLoadInfo(u8 array, u32 value) +std::pair GetXFIndexedLoadInfo(CPArray array, u32 value) { const auto [index, address, size] = ExtractIndexedXF(value); diff --git a/Source/Core/VideoCommon/XFStructs.h b/Source/Core/VideoCommon/XFStructs.h index 8f839baf97..7e1cc2c49f 100644 --- a/Source/Core/VideoCommon/XFStructs.h +++ b/Source/Core/VideoCommon/XFStructs.h @@ -12,4 +12,4 @@ std::pair GetXFRegInfo(u32 address, u32 value); std::string GetXFMemName(u32 address); std::string GetXFMemDescription(u32 address, u32 value); std::pair GetXFTransferInfo(const u8* data); -std::pair GetXFIndexedLoadInfo(u8 array, u32 value); +std::pair GetXFIndexedLoadInfo(CPArray array, u32 value); diff --git a/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp b/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp index 81b3e5ee53..e72fe28c29 100644 --- a/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp +++ b/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp @@ -174,8 +174,8 @@ TEST_P(VertexLoaderParamTest, PositionAll) Input(i); else Input(i); - VertexLoaderManager::cached_arraybases[ARRAY_POSITION] = m_src.GetPointer(); - g_main_cp_state.array_strides[ARRAY_POSITION] = elem_count * elem_size; + VertexLoaderManager::cached_arraybases[CPArray::Position] = m_src.GetPointer(); + g_main_cp_state.array_strides[CPArray::Position] = elem_count * elem_size; } CreateAndCheckSizes(input_size, elem_count * sizeof(float)); for (float value : values) @@ -243,8 +243,8 @@ TEST_F(VertexLoaderTest, PositionIndex16FloatXY) CreateAndCheckSizes(sizeof(u16), 2 * sizeof(float)); Input(1); Input(0); - VertexLoaderManager::cached_arraybases[ARRAY_POSITION] = m_src.GetPointer(); - g_main_cp_state.array_strides[ARRAY_POSITION] = sizeof(float); // ;) + VertexLoaderManager::cached_arraybases[CPArray::Position] = m_src.GetPointer(); + g_main_cp_state.array_strides[CPArray::Position] = sizeof(float); // ;) Input(1.f); Input(2.f); Input(3.f); @@ -357,8 +357,8 @@ TEST_F(VertexLoaderTest, LargeFloatVertexSpeed) for (int i = 0; i < NUM_VERTEX_COMPONENT_ARRAYS; i++) { - VertexLoaderManager::cached_arraybases[i] = m_src.GetPointer(); - g_main_cp_state.array_strides[i] = 129; + VertexLoaderManager::cached_arraybases[static_cast(i)] = m_src.GetPointer(); + g_main_cp_state.array_strides[static_cast(i)] = 129; } // This test is only done 100x in a row since it's ~20x slower using the