diff --git a/Source/Core/VideoCommon/CPMemory.h b/Source/Core/VideoCommon/CPMemory.h index 931cb587e5..c82521ebb4 100644 --- a/Source/Core/VideoCommon/CPMemory.h +++ b/Source/Core/VideoCommon/CPMemory.h @@ -317,7 +317,7 @@ union UVAT_group0 // 21:29 BitField<21, 1, TexComponentCount> Tex0CoordElements; BitField<22, 3, ComponentFormat> Tex0CoordFormat; - BitField<25, 5, u32> Tex0Frac; + BitField<25, 5, u8, u32> Tex0Frac; // 30:31 BitField<30, 1, bool, u32> ByteDequant; BitField<31, 1, bool, u32> NormalIndex3; @@ -363,15 +363,15 @@ union UVAT_group1 // 0:8 BitField<0, 1, TexComponentCount> Tex1CoordElements; BitField<1, 3, ComponentFormat> Tex1CoordFormat; - BitField<4, 5, u32> Tex1Frac; + BitField<4, 5, u8, u32> Tex1Frac; // 9:17 BitField<9, 1, TexComponentCount> Tex2CoordElements; BitField<10, 3, ComponentFormat> Tex2CoordFormat; - BitField<13, 5, u32> Tex2Frac; + BitField<13, 5, u8, u32> Tex2Frac; // 18:26 BitField<18, 1, TexComponentCount> Tex3CoordElements; BitField<19, 3, ComponentFormat> Tex3CoordFormat; - BitField<22, 5, u32> Tex3Frac; + BitField<22, 5, u8, u32> Tex3Frac; // 27:30 BitField<27, 1, TexComponentCount> Tex4CoordElements; BitField<28, 3, ComponentFormat> Tex4CoordFormat; @@ -410,19 +410,19 @@ union UVAT_group2 { u32 Hex; // 0:4 - BitField<0, 5, u32> Tex4Frac; + BitField<0, 5, u8, u32> Tex4Frac; // 5:13 BitField<5, 1, TexComponentCount> Tex5CoordElements; BitField<6, 3, ComponentFormat> Tex5CoordFormat; - BitField<9, 5, u32> Tex5Frac; + BitField<9, 5, u8, u32> Tex5Frac; // 14:22 BitField<14, 1, TexComponentCount> Tex6CoordElements; BitField<15, 3, ComponentFormat> Tex6CoordFormat; - BitField<18, 5, u32> Tex6Frac; + BitField<18, 5, u8, u32> Tex6Frac; // 23:31 BitField<23, 1, TexComponentCount> Tex7CoordElements; BitField<24, 3, ComponentFormat> Tex7CoordFormat; - BitField<27, 5, u32> Tex7Frac; + BitField<27, 5, u8, u32> Tex7Frac; }; template <> struct fmt::formatter @@ -450,30 +450,123 @@ struct fmt::formatter } }; -struct ColorAttr +struct VAT { - ColorComponentCount Elements; - ColorFormat Comp; -}; + UVAT_group0 g0; + UVAT_group1 g1; + UVAT_group2 g2; -struct TexAttr -{ - TexComponentCount Elements; - ComponentFormat Format; - u8 Frac; + constexpr ColorComponentCount GetColorElements(size_t idx) const + { + switch (idx) + { + case 0: + return g0.Color0Elements; + case 1: + return g0.Color1Elements; + default: + PanicAlertFmt("Invalid color index {}", idx); + return ColorComponentCount::RGB; + } + } + constexpr ColorFormat GetColorFormat(size_t idx) const + { + switch (idx) + { + case 0: + return g0.Color0Comp; + case 1: + return g0.Color1Comp; + default: + PanicAlertFmt("Invalid color index {}", idx); + return ColorFormat::RGB565; + } + } + constexpr TexComponentCount GetTexElements(size_t idx) const + { + switch (idx) + { + case 0: + return g0.Tex0CoordElements; + case 1: + return g1.Tex1CoordElements; + case 2: + return g1.Tex2CoordElements; + case 3: + return g1.Tex3CoordElements; + case 4: + return g1.Tex4CoordElements; + case 5: + return g2.Tex5CoordElements; + case 6: + return g2.Tex6CoordElements; + case 7: + return g2.Tex7CoordElements; + default: + PanicAlertFmt("Invalid tex coord index {}", idx); + return TexComponentCount::S; + } + } + constexpr ComponentFormat GetTexFormat(size_t idx) const + { + switch (idx) + { + case 0: + return g0.Tex0CoordFormat; + case 1: + return g1.Tex1CoordFormat; + case 2: + return g1.Tex2CoordFormat; + case 3: + return g1.Tex3CoordFormat; + case 4: + return g1.Tex4CoordFormat; + case 5: + return g2.Tex5CoordFormat; + case 6: + return g2.Tex6CoordFormat; + case 7: + return g2.Tex7CoordFormat; + default: + PanicAlertFmt("Invalid tex coord index {}", idx); + return ComponentFormat::UByte; + } + } + constexpr u8 GetTexFrac(size_t idx) const + { + switch (idx) + { + case 0: + return g0.Tex0Frac; + case 1: + return g1.Tex1Frac; + case 2: + return g1.Tex2Frac; + case 3: + return g1.Tex3Frac; + case 4: + return g2.Tex4Frac; + case 5: + return g2.Tex5Frac; + case 6: + return g2.Tex6Frac; + case 7: + return g2.Tex7Frac; + default: + PanicAlertFmt("Invalid tex coord index {}", idx); + return 0; + } + } }; - -struct TVtxAttr +template <> +struct fmt::formatter { - CoordComponentCount PosElements; - ComponentFormat PosFormat; - u8 PosFrac; - NormalComponentCount NormalElements; - ComponentFormat NormalFormat; - ColorAttr color[2]; - TexAttr texCoord[8]; - bool ByteDequant; - u8 NormalIndex3; + constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); } + template + auto format(const VAT& vat, FormatContext& ctx) + { + return format_to(ctx.out(), "{}\n{}\n{}", vat.g0, vat.g1, vat.g2); + } }; // Matrix indices @@ -518,23 +611,6 @@ struct fmt::formatter } }; -struct VAT -{ - UVAT_group0 g0; - UVAT_group1 g1; - UVAT_group2 g2; -}; -template <> -struct fmt::formatter -{ - constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); } - template - auto format(const VAT& vat, FormatContext& ctx) - { - return format_to(ctx.out(), "{}\n{}\n{}", vat.g0, vat.g1, vat.g2); - } -}; - class VertexLoaderBase; // STATE_TO_SAVE diff --git a/Source/Core/VideoCommon/VertexLoader.cpp b/Source/Core/VideoCommon/VertexLoader.cpp index f51b27518f..da8e0d2e05 100644 --- a/Source/Core/VideoCommon/VertexLoader.cpp +++ b/Source/Core/VideoCommon/VertexLoader.cpp @@ -72,15 +72,14 @@ VertexLoader::VertexLoader(const TVtxDesc& vtx_desc, const VAT& vtx_attr) CompileVertexTranslator(); // generate frac factors - m_posScale = 1.0f / (1U << m_VtxAttr.PosFrac); - for (int i = 0; i < 8; i++) - m_tcScale[i] = 1.0f / (1U << m_VtxAttr.texCoord[i].Frac); + m_posScale = 1.0f / (1U << m_VtxAttr.g0.PosFrac); + for (u32 i = 0; i < 8; i++) + m_tcScale[i] = 1.0f / (1U << m_VtxAttr.GetTexFrac(i)); } void VertexLoader::CompileVertexTranslator() { m_VertexSize = 0; - const TVtxAttr& vtx_attr = m_VtxAttr; // Reset pipeline m_numPipelineStages = 0; @@ -154,12 +153,12 @@ void VertexLoader::CompileVertexTranslator() } // Write vertex position loader - WriteCall(VertexLoader_Position::GetFunction(m_VtxDesc.low.Position, m_VtxAttr.PosFormat, - m_VtxAttr.PosElements)); + WriteCall(VertexLoader_Position::GetFunction(m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat, + m_VtxAttr.g0.PosElements)); - m_VertexSize += VertexLoader_Position::GetSize(m_VtxDesc.low.Position, m_VtxAttr.PosFormat, - m_VtxAttr.PosElements); - int pos_elements = m_VtxAttr.PosElements == CoordComponentCount::XY ? 2 : 3; + m_VertexSize += VertexLoader_Position::GetSize(m_VtxDesc.low.Position, m_VtxAttr.g0.PosFormat, + m_VtxAttr.g0.PosElements); + int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3; m_native_vtx_decl.position.components = pos_elements; m_native_vtx_decl.position.enable = true; m_native_vtx_decl.position.offset = nat_offset; @@ -170,22 +169,23 @@ void VertexLoader::CompileVertexTranslator() // Normals if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent) { - m_VertexSize += VertexLoader_Normal::GetSize(m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat, - m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3); + m_VertexSize += + VertexLoader_Normal::GetSize(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, + m_VtxAttr.g0.NormalElements, m_VtxAttr.g0.NormalIndex3); TPipelineFunction pFunc = - VertexLoader_Normal::GetFunction(m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat, - m_VtxAttr.NormalElements, m_VtxAttr.NormalIndex3); + VertexLoader_Normal::GetFunction(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, + m_VtxAttr.g0.NormalElements, m_VtxAttr.g0.NormalIndex3); if (pFunc == nullptr) { PanicAlertFmt("VertexLoader_Normal::GetFunction({} {} {} {}) returned zero!", - m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements, - m_VtxAttr.NormalIndex3); + m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, m_VtxAttr.g0.NormalElements, + m_VtxAttr.g0.NormalIndex3); } WriteCall(pFunc); - for (int i = 0; i < (vtx_attr.NormalElements == NormalComponentCount::NBT ? 3 : 1); i++) + for (int i = 0; i < (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT ? 3 : 1); i++) { m_native_vtx_decl.normals[i].components = 3; m_native_vtx_decl.normals[i].enable = true; @@ -196,7 +196,7 @@ void VertexLoader::CompileVertexTranslator() } components |= VB_HAS_NRM0; - if (m_VtxAttr.NormalElements == NormalComponentCount::NBT) + if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT) components |= VB_HAS_NRM1 | VB_HAS_NRM2; } @@ -206,9 +206,10 @@ void VertexLoader::CompileVertexTranslator() m_native_vtx_decl.colors[i].type = VAR_UNSIGNED_BYTE; m_native_vtx_decl.colors[i].integer = false; - m_VertexSize += VertexLoader_Color::GetSize(m_VtxDesc.low.Color[i], m_VtxAttr.color[i].Comp); + m_VertexSize += + VertexLoader_Color::GetSize(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i)); TPipelineFunction pFunc = - VertexLoader_Color::GetFunction(m_VtxDesc.low.Color[i], m_VtxAttr.color[i].Comp); + VertexLoader_Color::GetFunction(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i)); if (pFunc != nullptr) WriteCall(pFunc); @@ -232,8 +233,8 @@ void VertexLoader::CompileVertexTranslator() m_native_vtx_decl.texcoords[i].integer = false; const auto tc = m_VtxDesc.high.TexCoord[i].Value(); - const auto format = m_VtxAttr.texCoord[i].Format; - const auto elements = m_VtxAttr.texCoord[i].Elements; + const auto format = m_VtxAttr.GetTexFormat(i); + const auto elements = m_VtxAttr.GetTexElements(i); if (tc != VertexComponentFormat::NotPresent) { @@ -257,8 +258,7 @@ void VertexLoader::CompileVertexTranslator() // if texmtx is included, texcoord will always be 3 floats, z will be the texmtx index m_native_vtx_decl.texcoords[i].components = 3; nat_offset += 12; - WriteCall(m_VtxAttr.texCoord[i].Elements == TexComponentCount::ST ? TexMtx_Write_Float : - TexMtx_Write_Float2); + WriteCall(elements == TexComponentCount::ST ? TexMtx_Write_Float : TexMtx_Write_Float2); } else { @@ -272,9 +272,8 @@ void VertexLoader::CompileVertexTranslator() if (tc != VertexComponentFormat::NotPresent) { m_native_vtx_decl.texcoords[i].enable = true; - m_native_vtx_decl.texcoords[i].components = - vtx_attr.texCoord[i].Elements == TexComponentCount::ST ? 2 : 1; - nat_offset += 4 * (vtx_attr.texCoord[i].Elements == TexComponentCount::ST ? 2 : 1); + m_native_vtx_decl.texcoords[i].components = elements == TexComponentCount::ST ? 2 : 1; + nat_offset += 4 * (elements == TexComponentCount::ST ? 2 : 1); } } diff --git a/Source/Core/VideoCommon/VertexLoaderARM64.cpp b/Source/Core/VideoCommon/VertexLoaderARM64.cpp index 9fae16c59e..8dc396b47c 100644 --- a/Source/Core/VideoCommon/VertexLoaderARM64.cpp +++ b/Source/Core/VideoCommon/VertexLoaderARM64.cpp @@ -393,10 +393,11 @@ void VertexLoaderARM64::GenerateVertexLoader() for (size_t i = 0; i < m_VtxDesc.high.TexCoord.Size(); i++) { has_tc |= m_VtxDesc.high.TexCoord[i] != VertexComponentFormat::NotPresent; - has_tc_scale |= !!m_VtxAttr.texCoord[i].Frac; + has_tc_scale |= (m_VtxAttr.GetTexFrac(i) != 0); } - bool need_scale = (m_VtxAttr.ByteDequant && m_VtxAttr.PosFrac) || (has_tc && has_tc_scale) || + bool need_scale = (m_VtxAttr.g0.ByteDequant && m_VtxAttr.g0.PosFrac) || + (has_tc && has_tc_scale) || (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent); AlignCode16(); @@ -444,30 +445,30 @@ void VertexLoaderARM64::GenerateVertexLoader() // Position { - int elem_size = GetElementSize(m_VtxAttr.PosFormat); - int pos_elements = m_VtxAttr.PosElements == CoordComponentCount::XY ? 2 : 3; + int elem_size = GetElementSize(m_VtxAttr.g0.PosFormat); + int pos_elements = m_VtxAttr.g0.PosElements == CoordComponentCount::XY ? 2 : 3; int load_bytes = elem_size * pos_elements; int load_size = GetLoadSize(load_bytes); load_size <<= 3; s32 offset = GetAddressImm(ARRAY_POSITION, m_VtxDesc.low.Position, EncodeRegTo64(scratch1_reg), load_size); - ReadVertex(m_VtxDesc.low.Position, m_VtxAttr.PosFormat, pos_elements, pos_elements, - m_VtxAttr.ByteDequant, m_VtxAttr.PosFrac, &m_native_vtx_decl.position, offset); + 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); } if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent) { static const u8 map[8] = {7, 6, 15, 14}; - const u8 scaling_exponent = map[u32(m_VtxAttr.NormalFormat)]; - const int limit = m_VtxAttr.NormalElements == NormalComponentCount::NBT ? 3 : 1; + const u8 scaling_exponent = map[u32(m_VtxAttr.g0.NormalFormat.Value())]; + const int limit = m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT ? 3 : 1; s32 offset = -1; - for (int i = 0; i < (m_VtxAttr.NormalElements == NormalComponentCount::NBT ? 3 : 1); i++) + for (int i = 0; i < (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT ? 3 : 1); i++) { - if (!i || m_VtxAttr.NormalIndex3) + if (!i || m_VtxAttr.g0.NormalIndex3) { - int elem_size = GetElementSize(m_VtxAttr.NormalFormat); + int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat); int load_bytes = elem_size * 3; int load_size = GetLoadSize(load_bytes); @@ -480,7 +481,7 @@ void VertexLoaderARM64::GenerateVertexLoader() else offset += i * elem_size * 3; } - int bytes_read = ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat, 3, 3, true, + int bytes_read = ReadVertex(m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, true, scaling_exponent, &m_native_vtx_decl.normals[i], offset); if (offset == -1) @@ -490,7 +491,7 @@ void VertexLoaderARM64::GenerateVertexLoader() } m_native_components |= VB_HAS_NRM0; - if (m_VtxAttr.NormalElements == NormalComponentCount::NBT) + if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT) m_native_components |= VB_HAS_NRM1 | VB_HAS_NRM2; } @@ -503,13 +504,13 @@ void VertexLoaderARM64::GenerateVertexLoader() if (m_VtxDesc.low.Color[i] != VertexComponentFormat::NotPresent) { u32 align = 4; - if (m_VtxAttr.color[i].Comp == ColorFormat::RGB565 || - m_VtxAttr.color[i].Comp == ColorFormat::RGBA4444) + if (m_VtxAttr.GetColorFormat(i) == ColorFormat::RGB565 || + m_VtxAttr.GetColorFormat(i) == ColorFormat::RGBA4444) align = 2; s32 offset = GetAddressImm(ARRAY_COLOR0 + int(i), m_VtxDesc.low.Color[i], EncodeRegTo64(scratch1_reg), align); - ReadColor(m_VtxDesc.low.Color[i], m_VtxAttr.color[i].Comp, offset); + ReadColor(m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i), offset); m_native_components |= VB_HAS_COL0 << i; m_native_vtx_decl.colors[i].components = 4; m_native_vtx_decl.colors[i].enable = true; @@ -526,22 +527,22 @@ void VertexLoaderARM64::GenerateVertexLoader() m_native_vtx_decl.texcoords[i].type = VAR_FLOAT; m_native_vtx_decl.texcoords[i].integer = false; - int elements = m_VtxAttr.texCoord[i].Elements == TexComponentCount::S ? 1 : 2; + int elements = m_VtxAttr.GetTexElements(i) == TexComponentCount::S ? 1 : 2; if (m_VtxDesc.high.TexCoord[i] != VertexComponentFormat::NotPresent) { m_native_components |= VB_HAS_UV0 << i; - int elem_size = GetElementSize(m_VtxAttr.texCoord[i].Format); + int elem_size = GetElementSize(m_VtxAttr.GetTexFormat(i)); int load_bytes = elem_size * (elements + 2); int load_size = GetLoadSize(load_bytes); load_size <<= 3; s32 offset = GetAddressImm(ARRAY_TEXCOORD0 + int(i), m_VtxDesc.high.TexCoord[i], EncodeRegTo64(scratch1_reg), load_size); - u8 scaling_exponent = m_VtxAttr.texCoord[i].Frac; - ReadVertex(m_VtxDesc.high.TexCoord[i], m_VtxAttr.texCoord[i].Format, elements, - m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.ByteDequant, scaling_exponent, - &m_native_vtx_decl.texcoords[i], offset); + u8 scaling_exponent = m_VtxAttr.GetTexFrac(i); + ReadVertex(m_VtxDesc.high.TexCoord[i], m_VtxAttr.GetTexFormat(i), elements, + m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.g0.ByteDequant, + scaling_exponent, &m_native_vtx_decl.texcoords[i], offset); } if (m_VtxDesc.low.TexMatIdx[i]) { diff --git a/Source/Core/VideoCommon/VertexLoaderBase.cpp b/Source/Core/VideoCommon/VertexLoaderBase.cpp index 604ad1f04b..6a8c6498c0 100644 --- a/Source/Core/VideoCommon/VertexLoaderBase.cpp +++ b/Source/Core/VideoCommon/VertexLoaderBase.cpp @@ -26,53 +26,6 @@ #include "VideoCommon/VertexLoaderARM64.h" #endif -VertexLoaderBase::VertexLoaderBase(const TVtxDesc& vtx_desc, const VAT& vtx_attr) - : m_VtxDesc{vtx_desc}, m_vat{vtx_attr} -{ - SetVAT(vtx_attr); -} - -void VertexLoaderBase::SetVAT(const VAT& vat) -{ - m_VtxAttr.PosElements = vat.g0.PosElements; - m_VtxAttr.PosFormat = vat.g0.PosFormat; - m_VtxAttr.PosFrac = vat.g0.PosFrac; - m_VtxAttr.NormalElements = vat.g0.NormalElements; - m_VtxAttr.NormalFormat = vat.g0.NormalFormat; - m_VtxAttr.color[0].Elements = vat.g0.Color0Elements; - m_VtxAttr.color[0].Comp = vat.g0.Color0Comp; - m_VtxAttr.color[1].Elements = vat.g0.Color1Elements; - m_VtxAttr.color[1].Comp = vat.g0.Color1Comp; - m_VtxAttr.texCoord[0].Elements = vat.g0.Tex0CoordElements; - m_VtxAttr.texCoord[0].Format = vat.g0.Tex0CoordFormat; - m_VtxAttr.texCoord[0].Frac = vat.g0.Tex0Frac; - m_VtxAttr.ByteDequant = vat.g0.ByteDequant; - m_VtxAttr.NormalIndex3 = vat.g0.NormalIndex3; - - m_VtxAttr.texCoord[1].Elements = vat.g1.Tex1CoordElements; - m_VtxAttr.texCoord[1].Format = vat.g1.Tex1CoordFormat; - m_VtxAttr.texCoord[1].Frac = vat.g1.Tex1Frac; - m_VtxAttr.texCoord[2].Elements = vat.g1.Tex2CoordElements; - m_VtxAttr.texCoord[2].Format = vat.g1.Tex2CoordFormat; - m_VtxAttr.texCoord[2].Frac = vat.g1.Tex2Frac; - m_VtxAttr.texCoord[3].Elements = vat.g1.Tex3CoordElements; - m_VtxAttr.texCoord[3].Format = vat.g1.Tex3CoordFormat; - m_VtxAttr.texCoord[3].Frac = vat.g1.Tex3Frac; - m_VtxAttr.texCoord[4].Elements = vat.g1.Tex4CoordElements; - m_VtxAttr.texCoord[4].Format = vat.g1.Tex4CoordFormat; - - m_VtxAttr.texCoord[4].Frac = vat.g2.Tex4Frac; - m_VtxAttr.texCoord[5].Elements = vat.g2.Tex5CoordElements; - m_VtxAttr.texCoord[5].Format = vat.g2.Tex5CoordFormat; - m_VtxAttr.texCoord[5].Frac = vat.g2.Tex5Frac; - m_VtxAttr.texCoord[6].Elements = vat.g2.Tex6CoordElements; - m_VtxAttr.texCoord[6].Format = vat.g2.Tex6CoordFormat; - m_VtxAttr.texCoord[6].Frac = vat.g2.Tex6Frac; - m_VtxAttr.texCoord[7].Elements = vat.g2.Tex7CoordElements; - m_VtxAttr.texCoord[7].Format = vat.g2.Tex7CoordFormat; - m_VtxAttr.texCoord[7].Frac = vat.g2.Tex7Frac; -}; - // a hacky implementation to compare two vertex loaders class VertexLoaderTester : public VertexLoaderBase { @@ -130,8 +83,8 @@ public: ERROR_LOG_FMT(VIDEO, "The two vertex loaders have loaded different data " "(guru meditation {:#010x}, {:#010x}, {:#010x}, {:#010x}, {:#010x}).", - m_VtxDesc.low.Hex, m_VtxDesc.high.Hex, m_vat.g0.Hex, m_vat.g1.Hex, - m_vat.g2.Hex); + m_VtxDesc.low.Hex, m_VtxDesc.high.Hex, m_VtxAttr.g0.Hex, m_VtxAttr.g1.Hex, + m_VtxAttr.g2.Hex); } memcpy(dst.GetPointer(), buffer_a.data(), count_a * m_native_vtx_decl.stride); diff --git a/Source/Core/VideoCommon/VertexLoaderBase.h b/Source/Core/VideoCommon/VertexLoaderBase.h index cf100fb4c6..bc57d34b4f 100644 --- a/Source/Core/VideoCommon/VertexLoaderBase.h +++ b/Source/Core/VideoCommon/VertexLoaderBase.h @@ -77,11 +77,10 @@ public: int m_numLoadedVertices = 0; protected: - VertexLoaderBase(const TVtxDesc& vtx_desc, const VAT& vtx_attr); - void SetVAT(const VAT& vat); + VertexLoaderBase(const TVtxDesc& vtx_desc, const VAT& vtx_attr) + : m_VtxDesc{vtx_desc}, m_VtxAttr{vtx_attr} {}; // GC vertex format - TVtxAttr m_VtxAttr; // VAT decoded into easy format - TVtxDesc m_VtxDesc; // Not really used currently - or well it is, but could be easily avoided. - VAT m_vat; + const VAT m_VtxAttr; + const TVtxDesc m_VtxDesc; }; diff --git a/Source/Core/VideoCommon/VertexLoaderX64.cpp b/Source/Core/VideoCommon/VertexLoaderX64.cpp index 27ccad71b5..9e1b056b97 100644 --- a/Source/Core/VideoCommon/VertexLoaderX64.cpp +++ b/Source/Core/VideoCommon/VertexLoaderX64.cpp @@ -439,30 +439,30 @@ void VertexLoaderX64::GenerateVertexLoader() } OpArg data = GetVertexAddr(ARRAY_POSITION, m_VtxDesc.low.Position); - int pos_elements = m_VtxAttr.PosElements == CoordComponentCount::XY ? 2 : 3; - ReadVertex(data, m_VtxDesc.low.Position, m_VtxAttr.PosFormat, pos_elements, pos_elements, - m_VtxAttr.ByteDequant, m_VtxAttr.PosFrac, &m_native_vtx_decl.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); if (m_VtxDesc.low.Normal != VertexComponentFormat::NotPresent) { static const u8 map[8] = {7, 6, 15, 14}; - const u8 scaling_exponent = map[u32(m_VtxAttr.NormalFormat)]; - const int limit = m_VtxAttr.NormalElements == NormalComponentCount::NBT ? 3 : 1; + const u8 scaling_exponent = map[u32(m_VtxAttr.g0.NormalFormat.Value())]; + const int limit = m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT ? 3 : 1; for (int i = 0; i < limit; i++) { - if (!i || m_VtxAttr.NormalIndex3) + if (!i || m_VtxAttr.g0.NormalIndex3) { data = GetVertexAddr(ARRAY_NORMAL, m_VtxDesc.low.Normal); - int elem_size = GetElementSize(m_VtxAttr.NormalFormat); + int elem_size = GetElementSize(m_VtxAttr.g0.NormalFormat); data.AddMemOffset(i * elem_size * 3); } - data.AddMemOffset(ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.NormalFormat, 3, 3, true, - scaling_exponent, &m_native_vtx_decl.normals[i])); + data.AddMemOffset(ReadVertex(data, m_VtxDesc.low.Normal, m_VtxAttr.g0.NormalFormat, 3, 3, + true, scaling_exponent, &m_native_vtx_decl.normals[i])); } m_native_components |= VB_HAS_NRM0; - if (m_VtxAttr.NormalElements == NormalComponentCount::NBT) + if (m_VtxAttr.g0.NormalElements == NormalComponentCount::NBT) m_native_components |= VB_HAS_NRM1 | VB_HAS_NRM2; } @@ -471,7 +471,7 @@ void VertexLoaderX64::GenerateVertexLoader() if (m_VtxDesc.low.Color[i] != VertexComponentFormat::NotPresent) { data = GetVertexAddr(ARRAY_COLOR0 + int(i), m_VtxDesc.low.Color[i]); - ReadColor(data, m_VtxDesc.low.Color[i], m_VtxAttr.color[i].Comp); + ReadColor(data, m_VtxDesc.low.Color[i], m_VtxAttr.GetColorFormat(i)); m_native_components |= VB_HAS_COL0 << i; m_native_vtx_decl.colors[i].components = 4; m_native_vtx_decl.colors[i].enable = true; @@ -484,14 +484,14 @@ void VertexLoaderX64::GenerateVertexLoader() for (size_t i = 0; i < m_VtxDesc.high.TexCoord.Size(); i++) { - int elements = m_VtxAttr.texCoord[i].Elements == TexComponentCount::ST ? 2 : 1; + 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]); - u8 scaling_exponent = m_VtxAttr.texCoord[i].Frac; - ReadVertex(data, m_VtxDesc.high.TexCoord[i], m_VtxAttr.texCoord[i].Format, elements, - m_VtxDesc.low.TexMatIdx[i] ? 2 : elements, m_VtxAttr.ByteDequant, scaling_exponent, - &m_native_vtx_decl.texcoords[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, + scaling_exponent, &m_native_vtx_decl.texcoords[i]); m_native_components |= VB_HAS_UV0 << i; } if (m_VtxDesc.low.TexMatIdx[i])