The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-01-09 15:49:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #11066 from K0bin/vertex-size-opt

Browse Source 
Optimize GetVertexSize
This commit is contained in:
JMC47 2022-09-15 14:25:32 -04:00 committed by GitHub
commit 32fba6dbd8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 311 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
Source/Core/VideoCommon/VertexLoaderBase.cpp
View File

@ -12,6 +12,7 @@
#include <fmt/format.h> #include <fmt/format.h>
#include "Common/Assert.h" #include "Common/Assert.h"
#include "Common/BitSet.h"
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "Common/Logging/Log.h" #include "Common/Logging/Log.h"
#include "Common/MsgHandler.h" #include "Common/MsgHandler.h"
@ -96,45 +97,33 @@ private:
std::vector<u8> buffer_b; std::vector<u8> buffer_b;
}; };
template <class Function> u32 VertexLoaderBase::GetVertexSize(const TVtxDesc& vtx_desc, const VAT& vtx_attr)
static void GetComponentSizes(const TVtxDesc& vtx_desc, const VAT& vtx_attr, Function f)
{ {
if (vtx_desc.low.PosMatIdx) u32 size = 0;
f(1);
for (auto texmtxidx : vtx_desc.low.TexMatIdx) // Each enabled TexMatIdx adds one byte, as does PosMatIdx
{ size += Common::CountSetBits(vtx_desc.low.Hex & 0x1FF);
if (texmtxidx)
f(1);
}
const u32 pos_size = VertexLoader_Position::GetSize(vtx_desc.low.Position, vtx_attr.g0.PosFormat, const u32 pos_size = VertexLoader_Position::GetSize(vtx_desc.low.Position, vtx_attr.g0.PosFormat,
vtx_attr.g0.PosElements); vtx_attr.g0.PosElements);
if (pos_size != 0) size += pos_size;
f(pos_size);
const u32 norm_size = const u32 norm_size =
VertexLoader_Normal::GetSize(vtx_desc.low.Normal, vtx_attr.g0.NormalFormat, VertexLoader_Normal::GetSize(vtx_desc.low.Normal, vtx_attr.g0.NormalFormat,
vtx_attr.g0.NormalElements, vtx_attr.g0.NormalIndex3); vtx_attr.g0.NormalElements, vtx_attr.g0.NormalIndex3);
if (norm_size != 0) size += norm_size;
f(norm_size);
for (u32 i = 0; i < vtx_desc.low.Color.Size(); i++) for (u32 i = 0; i < vtx_desc.low.Color.Size(); i++)
{ {
const u32 color_size = const u32 color_size =
VertexLoader_Color::GetSize(vtx_desc.low.Color[i], vtx_attr.GetColorFormat(i)); VertexLoader_Color::GetSize(vtx_desc.low.Color[i], vtx_attr.GetColorFormat(i));
if (color_size != 0) size += color_size;
f(color_size);
} }
for (u32 i = 0; i < vtx_desc.high.TexCoord.Size(); i++) for (u32 i = 0; i < vtx_desc.high.TexCoord.Size(); i++)
{ {
const u32 tc_size = VertexLoader_TextCoord::GetSize( const u32 tc_size = VertexLoader_TextCoord::GetSize(
vtx_desc.high.TexCoord[i], vtx_attr.GetTexFormat(i), vtx_attr.GetTexElements(i)); vtx_desc.high.TexCoord[i], vtx_attr.GetTexFormat(i), vtx_attr.GetTexElements(i));
if (tc_size != 0) size += tc_size;
f(tc_size);
} }
}
u32 VertexLoaderBase::GetVertexSize(const TVtxDesc& vtx_desc, const VAT& vtx_attr)
{
u32 size = 0;
GetComponentSizes(vtx_desc, vtx_attr, [&size](u32 s) { size += s; });
return size; return size;
} }
@ -168,14 +157,6 @@ u32 VertexLoaderBase::GetVertexComponents(const TVtxDesc& vtx_desc, const VAT& v
return components; return components;
} }
std::vector<u32> VertexLoaderBase::GetVertexComponentSizes(const TVtxDesc& vtx_desc,
const VAT& vtx_attr)
{
std::vector<u32> sizes;
GetComponentSizes(vtx_desc, vtx_attr, [&sizes](u32 s) { sizes.push_back(s); });
return sizes;
}
std::unique_ptr<VertexLoaderBase> VertexLoaderBase::CreateVertexLoader(const TVtxDesc& vtx_desc, std::unique_ptr<VertexLoaderBase> VertexLoaderBase::CreateVertexLoader(const TVtxDesc& vtx_desc,
const VAT& vtx_attr) const VAT& vtx_attr)
{ {

1
Source/Core/VideoCommon/VertexLoaderBase.h
View File

@ -62,7 +62,6 @@ class VertexLoaderBase
public: public:
static u32 GetVertexSize(const TVtxDesc& vtx_desc, const VAT& vtx_attr); static u32 GetVertexSize(const TVtxDesc& vtx_desc, const VAT& vtx_attr);
static u32 GetVertexComponents(const TVtxDesc& vtx_desc, const VAT& vtx_attr); static u32 GetVertexComponents(const TVtxDesc& vtx_desc, const VAT& vtx_attr);
static std::vector<u32> GetVertexComponentSizes(const TVtxDesc& vtx_desc, const VAT& vtx_attr);
static std::unique_ptr<VertexLoaderBase> CreateVertexLoader(const TVtxDesc& vtx_desc, static std::unique_ptr<VertexLoaderBase> CreateVertexLoader(const TVtxDesc& vtx_desc,
const VAT& vtx_attr); const VAT& vtx_attr);
virtual ~VertexLoaderBase() {} virtual ~VertexLoaderBase() {}

16
Source/Core/VideoCommon/VertexLoader_Color.cpp
View File

@ -205,24 +205,8 @@ constexpr Table<TPipelineFunction> s_table_read_color = {
Color_ReadIndex_32b_8888<u16>}), Color_ReadIndex_32b_8888<u16>}),
}; };
constexpr Table<u32> s_table_read_color_vertex_size = {
g({0u, 0u, 0u, 0u, 0u, 0u}),
g({2u, 3u, 4u, 2u, 3u, 4u}),
g({1u, 1u, 1u, 1u, 1u, 1u}),
g({2u, 2u, 2u, 2u, 2u, 2u}),
};
} // Anonymous namespace } // Anonymous namespace
u32 VertexLoader_Color::GetSize(VertexComponentFormat type, ColorFormat format)
{
if (format > ColorFormat::RGBA8888)
{
PanicAlertFmt("Invalid color format {}", format);
return 0;
}
return s_table_read_color_vertex_size[type][format];
}
TPipelineFunction VertexLoader_Color::GetFunction(VertexComponentFormat type, ColorFormat format) TPipelineFunction VertexLoader_Color::GetFunction(VertexComponentFormat type, ColorFormat format)
{ {
if (format > ColorFormat::RGBA8888) if (format > ColorFormat::RGBA8888)

38
Source/Core/VideoCommon/VertexLoader_Color.h
View File

@ -4,14 +4,44 @@
#pragma once #pragma once
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "VideoCommon/VertexLoader.h" #include "Common/EnumMap.h"
#include "Common/Inline.h"
enum class VertexComponentFormat; #include "VideoCommon/CPMemory.h"
enum class ColorFormat; #include "VideoCommon/VertexLoader.h"
class VertexLoader_Color class VertexLoader_Color
{ {
public: public:
static u32 GetSize(VertexComponentFormat type, ColorFormat format); static DOLPHIN_FORCE_INLINE u32 GetSize(VertexComponentFormat type, ColorFormat format)
{
if (format > ColorFormat::RGBA8888)
{
PanicAlertFmt("Invalid color format {}", format);
return 0;
}
return s_table_size[type][format];
}
static TPipelineFunction GetFunction(VertexComponentFormat type, ColorFormat format); static TPipelineFunction GetFunction(VertexComponentFormat type, ColorFormat format);
private:
template <typename T, auto last_member>
using EnumMap = typename Common::EnumMap<T, last_member>;
using SizeTable = EnumMap<EnumMap<u32, ColorFormat::RGBA8888>, VertexComponentFormat::Index16>;
static constexpr SizeTable s_table_size = []() consteval
{
SizeTable table{};
using VCF = VertexComponentFormat;
table[VCF::Direct] = {2u, 3u, 4u, 2u, 3u, 4u};
table[VCF::Index8] = {1u, 1u, 1u, 1u, 1u, 1u};
table[VCF::Index16] = {2u, 2u, 2u, 2u, 2u, 2u};
return table;
}
();
}; };

187
Source/Core/VideoCommon/VertexLoader_Normal.cpp
View File

@ -63,20 +63,15 @@ void ReadIndirect(VertexLoader* loader, const T* data)
} }
template <typename T, u32 N> template <typename T, u32 N>
struct Normal_Direct void Normal_ReadDirect(VertexLoader* loader)
{ {
static void function(VertexLoader* loader) const auto source = reinterpret_cast<const T*>(DataGetPosition());
{ ReadIndirect<T, N * 3>(loader, source);
const auto source = reinterpret_cast<const T*>(DataGetPosition()); DataSkip<N * 3 * sizeof(T)>();
ReadIndirect<T, N * 3>(loader, source); }
DataSkip<N * 3 * sizeof(T)>();
}
static constexpr u32 size = sizeof(T) * N * 3;
};
template <typename I, typename T, u32 N, u32 Offset> template <typename I, typename T, u32 N, u32 Offset>
void Normal_Index_Offset(VertexLoader* loader) void Normal_ReadIndex_Offset(VertexLoader* loader)
{ {
static_assert(std::is_unsigned_v<I>, "Only unsigned I is sane!"); static_assert(std::is_unsigned_v<I>, "Only unsigned I is sane!");
@ -88,46 +83,26 @@ void Normal_Index_Offset(VertexLoader* loader)
} }
template <typename I, typename T, u32 N> template <typename I, typename T, u32 N>
struct Normal_Index void Normal_ReadIndex(VertexLoader* loader)
{ {
static void function(VertexLoader* loader) { Normal_Index_Offset<I, T, N, 0>(loader); } Normal_ReadIndex_Offset<I, T, N, 0>(loader);
static constexpr u32 size = sizeof(I); }
};
template <typename I, typename T> template <typename I, typename T>
struct Normal_Index_Indices3 void Normal_ReadIndex_Indices3(VertexLoader* loader)
{ {
static void function(VertexLoader* loader) Normal_ReadIndex_Offset<I, T, 1, 0>(loader);
{ Normal_ReadIndex_Offset<I, T, 1, 1>(loader);
Normal_Index_Offset<I, T, 1, 0>(loader); Normal_ReadIndex_Offset<I, T, 1, 2>(loader);
Normal_Index_Offset<I, T, 1, 1>(loader); }
Normal_Index_Offset<I, T, 1, 2>(loader);
}
static constexpr u32 size = sizeof(I) * 3;
};
struct Set
{
template <typename T>
constexpr Set& operator=(const T&)
{
gc_size = T::size;
function = T::function;
return *this;
}
u32 gc_size;
TPipelineFunction function;
};
using Common::EnumMap; using Common::EnumMap;
using Formats = EnumMap<Set, ComponentFormat::Float>; using Formats = EnumMap<TPipelineFunction, ComponentFormat::Float>;
using Elements = EnumMap<Formats, NormalComponentCount::NTB>; using Elements = EnumMap<Formats, NormalComponentCount::NTB>;
using Indices = std::array<Elements, 2>; using Indices = std::array<Elements, 2>;
using Types = EnumMap<Indices, VertexComponentFormat::Index16>; using Types = EnumMap<Indices, VertexComponentFormat::Index16>;
constexpr Types InitializeTable() consteval Types InitializeTable()
{ {
Types table{}; Types table{};
@ -135,90 +110,84 @@ constexpr Types InitializeTable()
using NCC = NormalComponentCount; using NCC = NormalComponentCount;
using FMT = ComponentFormat; using FMT = ComponentFormat;
table[VCF::Direct][false][NCC::N][FMT::UByte] = Normal_Direct<u8, 1>(); table[VCF::Direct][false][NCC::N][FMT::UByte] = Normal_ReadDirect<u8, 1>;
table[VCF::Direct][false][NCC::N][FMT::Byte] = Normal_Direct<s8, 1>(); table[VCF::Direct][false][NCC::N][FMT::Byte] = Normal_ReadDirect<s8, 1>;
table[VCF::Direct][false][NCC::N][FMT::UShort] = Normal_Direct<u16, 1>(); table[VCF::Direct][false][NCC::N][FMT::UShort] = Normal_ReadDirect<u16, 1>;
table[VCF::Direct][false][NCC::N][FMT::Short] = Normal_Direct<s16, 1>(); table[VCF::Direct][false][NCC::N][FMT::Short] = Normal_ReadDirect<s16, 1>;
table[VCF::Direct][false][NCC::N][FMT::Float] = Normal_Direct<float, 1>(); table[VCF::Direct][false][NCC::N][FMT::Float] = Normal_ReadDirect<float, 1>;
table[VCF::Direct][false][NCC::NTB][FMT::UByte] = Normal_Direct<u8, 3>(); table[VCF::Direct][false][NCC::NTB][FMT::UByte] = Normal_ReadDirect<u8, 3>;
table[VCF::Direct][false][NCC::NTB][FMT::Byte] = Normal_Direct<s8, 3>(); table[VCF::Direct][false][NCC::NTB][FMT::Byte] = Normal_ReadDirect<s8, 3>;
table[VCF::Direct][false][NCC::NTB][FMT::UShort] = Normal_Direct<u16, 3>(); table[VCF::Direct][false][NCC::NTB][FMT::UShort] = Normal_ReadDirect<u16, 3>;
table[VCF::Direct][false][NCC::NTB][FMT::Short] = Normal_Direct<s16, 3>(); table[VCF::Direct][false][NCC::NTB][FMT::Short] = Normal_ReadDirect<s16, 3>;
table[VCF::Direct][false][NCC::NTB][FMT::Float] = Normal_Direct<float, 3>(); table[VCF::Direct][false][NCC::NTB][FMT::Float] = Normal_ReadDirect<float, 3>;
// Same as above, since there are no indices // Same as above, since there are no indices
table[VCF::Direct][true][NCC::N][FMT::UByte] = Normal_Direct<u8, 1>(); table[VCF::Direct][true][NCC::N][FMT::UByte] = Normal_ReadDirect<u8, 1>;
table[VCF::Direct][true][NCC::N][FMT::Byte] = Normal_Direct<s8, 1>(); table[VCF::Direct][true][NCC::N][FMT::Byte] = Normal_ReadDirect<s8, 1>;
table[VCF::Direct][true][NCC::N][FMT::UShort] = Normal_Direct<u16, 1>(); table[VCF::Direct][true][NCC::N][FMT::UShort] = Normal_ReadDirect<u16, 1>;
table[VCF::Direct][true][NCC::N][FMT::Short] = Normal_Direct<s16, 1>(); table[VCF::Direct][true][NCC::N][FMT::Short] = Normal_ReadDirect<s16, 1>;
table[VCF::Direct][true][NCC::N][FMT::Float] = Normal_Direct<float, 1>(); table[VCF::Direct][true][NCC::N][FMT::Float] = Normal_ReadDirect<float, 1>;
table[VCF::Direct][true][NCC::NTB][FMT::UByte] = Normal_Direct<u8, 3>(); table[VCF::Direct][true][NCC::NTB][FMT::UByte] = Normal_ReadDirect<u8, 3>;
table[VCF::Direct][true][NCC::NTB][FMT::Byte] = Normal_Direct<s8, 3>(); table[VCF::Direct][true][NCC::NTB][FMT::Byte] = Normal_ReadDirect<s8, 3>;
table[VCF::Direct][true][NCC::NTB][FMT::UShort] = Normal_Direct<u16, 3>(); table[VCF::Direct][true][NCC::NTB][FMT::UShort] = Normal_ReadDirect<u16, 3>;
table[VCF::Direct][true][NCC::NTB][FMT::Short] = Normal_Direct<s16, 3>(); table[VCF::Direct][true][NCC::NTB][FMT::Short] = Normal_ReadDirect<s16, 3>;
table[VCF::Direct][true][NCC::NTB][FMT::Float] = Normal_Direct<float, 3>(); table[VCF::Direct][true][NCC::NTB][FMT::Float] = Normal_ReadDirect<float, 3>;
table[VCF::Index8][false][NCC::N][FMT::UByte] = Normal_Index<u8, u8, 1>(); table[VCF::Index8][false][NCC::N][FMT::UByte] = Normal_ReadIndex<u8, u8, 1>;
table[VCF::Index8][false][NCC::N][FMT::Byte] = Normal_Index<u8, s8, 1>(); table[VCF::Index8][false][NCC::N][FMT::Byte] = Normal_ReadIndex<u8, s8, 1>;
table[VCF::Index8][false][NCC::N][FMT::UShort] = Normal_Index<u8, u16, 1>(); table[VCF::Index8][false][NCC::N][FMT::UShort] = Normal_ReadIndex<u8, u16, 1>;
table[VCF::Index8][false][NCC::N][FMT::Short] = Normal_Index<u8, s16, 1>(); table[VCF::Index8][false][NCC::N][FMT::Short] = Normal_ReadIndex<u8, s16, 1>;
table[VCF::Index8][false][NCC::N][FMT::Float] = Normal_Index<u8, float, 1>(); table[VCF::Index8][false][NCC::N][FMT::Float] = Normal_ReadIndex<u8, float, 1>;
table[VCF::Index8][false][NCC::NTB][FMT::UByte] = Normal_Index<u8, u8, 3>(); table[VCF::Index8][false][NCC::NTB][FMT::UByte] = Normal_ReadIndex<u8, u8, 3>;
table[VCF::Index8][false][NCC::NTB][FMT::Byte] = Normal_Index<u8, s8, 3>(); table[VCF::Index8][false][NCC::NTB][FMT::Byte] = Normal_ReadIndex<u8, s8, 3>;
table[VCF::Index8][false][NCC::NTB][FMT::UShort] = Normal_Index<u8, u16, 3>(); table[VCF::Index8][false][NCC::NTB][FMT::UShort] = Normal_ReadIndex<u8, u16, 3>;
table[VCF::Index8][false][NCC::NTB][FMT::Short] = Normal_Index<u8, s16, 3>(); table[VCF::Index8][false][NCC::NTB][FMT::Short] = Normal_ReadIndex<u8, s16, 3>;
table[VCF::Index8][false][NCC::NTB][FMT::Float] = Normal_Index<u8, float, 3>(); table[VCF::Index8][false][NCC::NTB][FMT::Float] = Normal_ReadIndex<u8, float, 3>;
// Same for NormalComponentCount::N; differs for NTB // Same for NormalComponentCount::N; differs for NTB
table[VCF::Index8][true][NCC::N][FMT::UByte] = Normal_Index<u8, u8, 1>(); table[VCF::Index8][true][NCC::N][FMT::UByte] = Normal_ReadIndex<u8, u8, 1>;
table[VCF::Index8][true][NCC::N][FMT::Byte] = Normal_Index<u8, s8, 1>(); table[VCF::Index8][true][NCC::N][FMT::Byte] = Normal_ReadIndex<u8, s8, 1>;
table[VCF::Index8][true][NCC::N][FMT::UShort] = Normal_Index<u8, u16, 1>(); table[VCF::Index8][true][NCC::N][FMT::UShort] = Normal_ReadIndex<u8, u16, 1>;
table[VCF::Index8][true][NCC::N][FMT::Short] = Normal_Index<u8, s16, 1>(); table[VCF::Index8][true][NCC::N][FMT::Short] = Normal_ReadIndex<u8, s16, 1>;
table[VCF::Index8][true][NCC::N][FMT::Float] = Normal_Index<u8, float, 1>(); table[VCF::Index8][true][NCC::N][FMT::Float] = Normal_ReadIndex<u8, float, 1>;
table[VCF::Index8][true][NCC::NTB][FMT::UByte] = Normal_Index_Indices3<u8, u8>(); table[VCF::Index8][true][NCC::NTB][FMT::UByte] = Normal_ReadIndex_Indices3<u8, u8>;
table[VCF::Index8][true][NCC::NTB][FMT::Byte] = Normal_Index_Indices3<u8, s8>(); table[VCF::Index8][true][NCC::NTB][FMT::Byte] = Normal_ReadIndex_Indices3<u8, s8>;
table[VCF::Index8][true][NCC::NTB][FMT::UShort] = Normal_Index_Indices3<u8, u16>(); table[VCF::Index8][true][NCC::NTB][FMT::UShort] = Normal_ReadIndex_Indices3<u8, u16>;
table[VCF::Index8][true][NCC::NTB][FMT::Short] = Normal_Index_Indices3<u8, s16>(); table[VCF::Index8][true][NCC::NTB][FMT::Short] = Normal_ReadIndex_Indices3<u8, s16>;
table[VCF::Index8][true][NCC::NTB][FMT::Float] = Normal_Index_Indices3<u8, float>(); table[VCF::Index8][true][NCC::NTB][FMT::Float] = Normal_ReadIndex_Indices3<u8, float>;
table[VCF::Index16][false][NCC::N][FMT::UByte] = Normal_Index<u16, u8, 1>(); table[VCF::Index16][false][NCC::N][FMT::UByte] = Normal_ReadIndex<u16, u8, 1>;
table[VCF::Index16][false][NCC::N][FMT::Byte] = Normal_Index<u16, s8, 1>(); table[VCF::Index16][false][NCC::N][FMT::Byte] = Normal_ReadIndex<u16, s8, 1>;
table[VCF::Index16][false][NCC::N][FMT::UShort] = Normal_Index<u16, u16, 1>(); table[VCF::Index16][false][NCC::N][FMT::UShort] = Normal_ReadIndex<u16, u16, 1>;
table[VCF::Index16][false][NCC::N][FMT::Short] = Normal_Index<u16, s16, 1>(); table[VCF::Index16][false][NCC::N][FMT::Short] = Normal_ReadIndex<u16, s16, 1>;
table[VCF::Index16][false][NCC::N][FMT::Float] = Normal_Index<u16, float, 1>(); table[VCF::Index16][false][NCC::N][FMT::Float] = Normal_ReadIndex<u16, float, 1>;
table[VCF::Index16][false][NCC::NTB][FMT::UByte] = Normal_Index<u16, u8, 3>(); table[VCF::Index16][false][NCC::NTB][FMT::UByte] = Normal_ReadIndex<u16, u8, 3>;
table[VCF::Index16][false][NCC::NTB][FMT::Byte] = Normal_Index<u16, s8, 3>(); table[VCF::Index16][false][NCC::NTB][FMT::Byte] = Normal_ReadIndex<u16, s8, 3>;
table[VCF::Index16][false][NCC::NTB][FMT::UShort] = Normal_Index<u16, u16, 3>(); table[VCF::Index16][false][NCC::NTB][FMT::UShort] = Normal_ReadIndex<u16, u16, 3>;
table[VCF::Index16][false][NCC::NTB][FMT::Short] = Normal_Index<u16, s16, 3>(); table[VCF::Index16][false][NCC::NTB][FMT::Short] = Normal_ReadIndex<u16, s16, 3>;
table[VCF::Index16][false][NCC::NTB][FMT::Float] = Normal_Index<u16, float, 3>(); table[VCF::Index16][false][NCC::NTB][FMT::Float] = Normal_ReadIndex<u16, float, 3>;
// Same for NormalComponentCount::N; differs for NTB // Same for NormalComponentCount::N; differs for NTB
table[VCF::Index16][true][NCC::N][FMT::UByte] = Normal_Index<u16, u8, 1>(); table[VCF::Index16][true][NCC::N][FMT::UByte] = Normal_ReadIndex<u16, u8, 1>;
table[VCF::Index16][true][NCC::N][FMT::Byte] = Normal_Index<u16, s8, 1>(); table[VCF::Index16][true][NCC::N][FMT::Byte] = Normal_ReadIndex<u16, s8, 1>;
table[VCF::Index16][true][NCC::N][FMT::UShort] = Normal_Index<u16, u16, 1>(); table[VCF::Index16][true][NCC::N][FMT::UShort] = Normal_ReadIndex<u16, u16, 1>;
table[VCF::Index16][true][NCC::N][FMT::Short] = Normal_Index<u16, s16, 1>(); table[VCF::Index16][true][NCC::N][FMT::Short] = Normal_ReadIndex<u16, s16, 1>;
table[VCF::Index16][true][NCC::N][FMT::Float] = Normal_Index<u16, float, 1>(); table[VCF::Index16][true][NCC::N][FMT::Float] = Normal_ReadIndex<u16, float, 1>;
table[VCF::Index16][true][NCC::NTB][FMT::UByte] = Normal_Index_Indices3<u16, u8>(); table[VCF::Index16][true][NCC::NTB][FMT::UByte] = Normal_ReadIndex_Indices3<u16, u8>;
table[VCF::Index16][true][NCC::NTB][FMT::Byte] = Normal_Index_Indices3<u16, s8>(); table[VCF::Index16][true][NCC::NTB][FMT::Byte] = Normal_ReadIndex_Indices3<u16, s8>;
table[VCF::Index16][true][NCC::NTB][FMT::UShort] = Normal_Index_Indices3<u16, u16>(); table[VCF::Index16][true][NCC::NTB][FMT::UShort] = Normal_ReadIndex_Indices3<u16, u16>;
table[VCF::Index16][true][NCC::NTB][FMT::Short] = Normal_Index_Indices3<u16, s16>(); table[VCF::Index16][true][NCC::NTB][FMT::Short] = Normal_ReadIndex_Indices3<u16, s16>;
table[VCF::Index16][true][NCC::NTB][FMT::Float] = Normal_Index_Indices3<u16, float>(); table[VCF::Index16][true][NCC::NTB][FMT::Float] = Normal_ReadIndex_Indices3<u16, float>;
return table; return table;
} }
constexpr Types s_table = InitializeTable(); constexpr Types s_table_read_normal = InitializeTable();
} // Anonymous namespace } // Anonymous namespace
u32 VertexLoader_Normal::GetSize(VertexComponentFormat type, ComponentFormat format,
NormalComponentCount elements, bool index3)
{
return s_table[type][index3][elements][format].gc_size;
}
TPipelineFunction VertexLoader_Normal::GetFunction(VertexComponentFormat type, TPipelineFunction VertexLoader_Normal::GetFunction(VertexComponentFormat type,
ComponentFormat format, ComponentFormat format,
NormalComponentCount elements, bool index3) NormalComponentCount elements, bool index3)
{ {
return s_table[type][index3][elements][format].function; return s_table_read_normal[type][index3][elements][format];
} }

104
Source/Core/VideoCommon/VertexLoader_Normal.h
View File

@ -4,18 +4,110 @@
#pragma once #pragma once
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "VideoCommon/VertexLoader.h" #include "Common/EnumMap.h"
#include "Common/Inline.h"
enum class VertexComponentFormat; #include "VideoCommon/CPMemory.h"
enum class ComponentFormat; #include "VideoCommon/VertexLoader.h"
enum class NormalComponentCount;
class VertexLoader_Normal class VertexLoader_Normal
{ {
public: public:
static u32 GetSize(VertexComponentFormat type, ComponentFormat format, static DOLPHIN_FORCE_INLINE u32 GetSize(VertexComponentFormat type, ComponentFormat format,
NormalComponentCount elements, bool index3); NormalComponentCount elements, bool index3)
{
return s_table_size[type][index3][elements][format];
}
static TPipelineFunction GetFunction(VertexComponentFormat type, ComponentFormat format, static TPipelineFunction GetFunction(VertexComponentFormat type, ComponentFormat format,
NormalComponentCount elements, bool index3); NormalComponentCount elements, bool index3);
private:
template <typename T, auto last_member>
using EnumMap = typename Common::EnumMap<T, last_member>;
using SizeTable = EnumMap<
std::array<EnumMap<EnumMap<u32, ComponentFormat::Float>, NormalComponentCount::NTB>, 2>,
VertexComponentFormat::Index16>;
static constexpr SizeTable s_table_size = []() consteval
{
SizeTable table{};
using VCF = VertexComponentFormat;
using NCC = NormalComponentCount;
using FMT = ComponentFormat;
table[VCF::Direct][false][NCC::N][FMT::UByte] = 3;
table[VCF::Direct][false][NCC::N][FMT::Byte] = 3;
table[VCF::Direct][false][NCC::N][FMT::UShort] = 6;
table[VCF::Direct][false][NCC::N][FMT::Short] = 6;
table[VCF::Direct][false][NCC::N][FMT::Float] = 12;
table[VCF::Direct][false][NCC::NTB][FMT::UByte] = 9;
table[VCF::Direct][false][NCC::NTB][FMT::Byte] = 9;
table[VCF::Direct][false][NCC::NTB][FMT::UShort] = 18;
table[VCF::Direct][false][NCC::NTB][FMT::Short] = 18;
table[VCF::Direct][false][NCC::NTB][FMT::Float] = 36;
// Same as above, since there are no indices
table[VCF::Direct][true][NCC::N][FMT::UByte] = 3;
table[VCF::Direct][true][NCC::N][FMT::Byte] = 3;
table[VCF::Direct][true][NCC::N][FMT::UShort] = 6;
table[VCF::Direct][true][NCC::N][FMT::Short] = 6;
table[VCF::Direct][true][NCC::N][FMT::Float] = 12;
table[VCF::Direct][true][NCC::NTB][FMT::UByte] = 9;
table[VCF::Direct][true][NCC::NTB][FMT::Byte] = 9;
table[VCF::Direct][true][NCC::NTB][FMT::UShort] = 18;
table[VCF::Direct][true][NCC::NTB][FMT::Short] = 18;
table[VCF::Direct][true][NCC::NTB][FMT::Float] = 36;
table[VCF::Index8][false][NCC::N][FMT::UByte] = 1;
table[VCF::Index8][false][NCC::N][FMT::Byte] = 1;
table[VCF::Index8][false][NCC::N][FMT::UShort] = 1;
table[VCF::Index8][false][NCC::N][FMT::Short] = 1;
table[VCF::Index8][false][NCC::N][FMT::Float] = 1;
table[VCF::Index8][false][NCC::NTB][FMT::UByte] = 1;
table[VCF::Index8][false][NCC::NTB][FMT::Byte] = 1;
table[VCF::Index8][false][NCC::NTB][FMT::UShort] = 1;
table[VCF::Index8][false][NCC::NTB][FMT::Short] = 1;
table[VCF::Index8][false][NCC::NTB][FMT::Float] = 1;
// Same for NormalComponentCount::N; differs for NTB
table[VCF::Index8][true][NCC::N][FMT::UByte] = 1;
table[VCF::Index8][true][NCC::N][FMT::Byte] = 1;
table[VCF::Index8][true][NCC::N][FMT::UShort] = 1;
table[VCF::Index8][true][NCC::N][FMT::Short] = 1;
table[VCF::Index8][true][NCC::N][FMT::Float] = 1;
table[VCF::Index8][true][NCC::NTB][FMT::UByte] = 3;
table[VCF::Index8][true][NCC::NTB][FMT::Byte] = 3;
table[VCF::Index8][true][NCC::NTB][FMT::UShort] = 3;
table[VCF::Index8][true][NCC::NTB][FMT::Short] = 3;
table[VCF::Index8][true][NCC::NTB][FMT::Float] = 3;
table[VCF::Index16][false][NCC::N][FMT::UByte] = 2;
table[VCF::Index16][false][NCC::N][FMT::Byte] = 2;
table[VCF::Index16][false][NCC::N][FMT::UShort] = 2;
table[VCF::Index16][false][NCC::N][FMT::Short] = 2;
table[VCF::Index16][false][NCC::N][FMT::Float] = 2;
table[VCF::Index16][false][NCC::NTB][FMT::UByte] = 2;
table[VCF::Index16][false][NCC::NTB][FMT::Byte] = 2;
table[VCF::Index16][false][NCC::NTB][FMT::UShort] = 2;
table[VCF::Index16][false][NCC::NTB][FMT::Short] = 2;
table[VCF::Index16][false][NCC::NTB][FMT::Float] = 2;
// Same for NormalComponentCount::N; differs for NTB
table[VCF::Index16][true][NCC::N][FMT::UByte] = 2;
table[VCF::Index16][true][NCC::N][FMT::Byte] = 2;
table[VCF::Index16][true][NCC::N][FMT::UShort] = 2;
table[VCF::Index16][true][NCC::N][FMT::Short] = 2;
table[VCF::Index16][true][NCC::N][FMT::Float] = 2;
table[VCF::Index16][true][NCC::NTB][FMT::UByte] = 6;
table[VCF::Index16][true][NCC::NTB][FMT::Byte] = 6;
table[VCF::Index16][true][NCC::NTB][FMT::UShort] = 6;
table[VCF::Index16][true][NCC::NTB][FMT::Short] = 6;
table[VCF::Index16][true][NCC::NTB][FMT::Float] = 6;
return table;
}
();
}; };

37
Source/Core/VideoCommon/VertexLoader_Position.cpp
View File

@ -138,45 +138,8 @@ constexpr Table<TPipelineFunction> s_table_read_position = {
e(Pos_ReadIndex<u16, float, 2>, Pos_ReadIndex<u16, float, 3>), e(Pos_ReadIndex<u16, float, 2>, Pos_ReadIndex<u16, float, 3>),
}), }),
}; };
constexpr Table<u32> s_table_read_position_vertex_size = {
g({
e(0u, 0u),
e(0u, 0u),
e(0u, 0u),
e(0u, 0u),
e(0u, 0u),
}),
g({
e(2, 3),
e(2, 3),
e(4, 6),
e(4, 6),
e(8, 12),
}),
g({
e(1, 1),
e(1, 1),
e(1, 1),
e(1, 1),
e(1, 1),
}),
g({
e(2, 2),
e(2, 2),
e(2, 2),
e(2, 2),
e(2, 2),
}),
};
} // Anonymous namespace } // Anonymous namespace
u32 VertexLoader_Position::GetSize(VertexComponentFormat type, ComponentFormat format,
CoordComponentCount elements)
{
return s_table_read_position_vertex_size[type][format][elements];
}
TPipelineFunction VertexLoader_Position::GetFunction(VertexComponentFormat type, TPipelineFunction VertexLoader_Position::GetFunction(VertexComponentFormat type,
ComponentFormat format, ComponentFormat format,
CoordComponentCount elements) CoordComponentCount elements)

51
Source/Core/VideoCommon/VertexLoader_Position.h
View File

@ -4,18 +4,57 @@
#pragma once #pragma once
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "VideoCommon/VertexLoader.h" #include "Common/EnumMap.h"
#include "Common/Inline.h"
enum class VertexComponentFormat; #include "VideoCommon/CPMemory.h"
enum class ComponentFormat; #include "VideoCommon/VertexLoader.h"
enum class CoordComponentCount;
class VertexLoader_Position class VertexLoader_Position
{ {
public: public:
static u32 GetSize(VertexComponentFormat type, ComponentFormat format, static DOLPHIN_FORCE_INLINE u32 GetSize(VertexComponentFormat type, ComponentFormat format,
CoordComponentCount elements); CoordComponentCount elements)
{
return s_table_size[type][format][elements];
}
static TPipelineFunction GetFunction(VertexComponentFormat type, ComponentFormat format, static TPipelineFunction GetFunction(VertexComponentFormat type, ComponentFormat format,
CoordComponentCount elements); CoordComponentCount elements);
private:
template <typename T, auto last_member>
using EnumMap = typename Common::EnumMap<T, last_member>;
using SizeTable = EnumMap<EnumMap<EnumMap<u32, CoordComponentCount::XYZ>, ComponentFormat::Float>,
VertexComponentFormat::Index16>;
static constexpr SizeTable s_table_size = []() consteval
{
SizeTable table{};
using VCF = VertexComponentFormat;
using FMT = ComponentFormat;
table[VCF::Direct][FMT::UByte] = {2, 3};
table[VCF::Direct][FMT::Byte] = {2, 3};
table[VCF::Direct][FMT::UShort] = {4, 6};
table[VCF::Direct][FMT::Short] = {4, 6};
table[VCF::Direct][FMT::Float] = {8, 12};
table[VCF::Index8][FMT::UByte] = {1, 1};
table[VCF::Index8][FMT::Byte] = {1, 1};
table[VCF::Index8][FMT::UShort] = {1, 1};
table[VCF::Index8][FMT::Short] = {1, 1};
table[VCF::Index8][FMT::Float] = {1, 1};
table[VCF::Index16][FMT::UByte] = {2, 2};
table[VCF::Index16][FMT::Byte] = {2, 2};
table[VCF::Index16][FMT::UShort] = {2, 2};
table[VCF::Index16][FMT::Short] = {2, 2};
table[VCF::Index16][FMT::Float] = {2, 2};
return table;
}
();
}; };

37
Source/Core/VideoCommon/VertexLoader_TextCoord.cpp
View File

@ -127,45 +127,8 @@ constexpr Table<TPipelineFunction> s_table_read_tex_coord = {
e(TexCoord_ReadIndex<u16, float, 1>, TexCoord_ReadIndex<u16, float, 2>), e(TexCoord_ReadIndex<u16, float, 1>, TexCoord_ReadIndex<u16, float, 2>),
}), }),
}; };
constexpr Table<u32> s_table_read_tex_coord_vertex_size = {
g({
e(0u, 0u),
e(0u, 0u),
e(0u, 0u),
e(0u, 0u),
e(0u, 0u),
}),
g({
e(1, 2),
e(1, 2),
e(2, 4),
e(2, 4),
e(4, 8),
}),
g({
e(1, 1),
e(1, 1),
e(1, 1),
e(1, 1),
e(1, 1),
}),
g({
e(2, 2),
e(2, 2),
e(2, 2),
e(2, 2),
e(2, 2),
}),
};
} // Anonymous namespace } // Anonymous namespace
u32 VertexLoader_TextCoord::GetSize(VertexComponentFormat type, ComponentFormat format,
TexComponentCount elements)
{
return s_table_read_tex_coord_vertex_size[type][format][elements];
}
TPipelineFunction VertexLoader_TextCoord::GetFunction(VertexComponentFormat type, TPipelineFunction VertexLoader_TextCoord::GetFunction(VertexComponentFormat type,
ComponentFormat format, ComponentFormat format,
TexComponentCount elements) TexComponentCount elements)

51
Source/Core/VideoCommon/VertexLoader_TextCoord.h
View File

@ -4,21 +4,60 @@
#pragma once #pragma once
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "VideoCommon/VertexLoader.h" #include "Common/EnumMap.h"
#include "Common/Inline.h"
enum class VertexComponentFormat; #include "VideoCommon/CPMemory.h"
enum class ComponentFormat; #include "VideoCommon/VertexLoader.h"
enum class TexComponentCount;
class VertexLoader_TextCoord class VertexLoader_TextCoord
{ {
public: public:
static u32 GetSize(VertexComponentFormat type, ComponentFormat format, static DOLPHIN_FORCE_INLINE u32 GetSize(VertexComponentFormat type, ComponentFormat format,
TexComponentCount elements); TexComponentCount elements)
{
return s_table_size[type][format][elements];
}
static TPipelineFunction GetFunction(VertexComponentFormat type, ComponentFormat format, static TPipelineFunction GetFunction(VertexComponentFormat type, ComponentFormat format,
TexComponentCount elements); TexComponentCount elements);
// It is important to synchronize tcIndex. // It is important to synchronize tcIndex.
static TPipelineFunction GetDummyFunction(); static TPipelineFunction GetDummyFunction();
private:
template <typename T, auto last_member>
using EnumMap = typename Common::EnumMap<T, last_member>;
using SizeTable = EnumMap<EnumMap<EnumMap<u32, TexComponentCount::ST>, ComponentFormat::Float>,
VertexComponentFormat::Index16>;
static constexpr SizeTable s_table_size = []() consteval
{
SizeTable table{};
using VCF = VertexComponentFormat;
using FMT = ComponentFormat;
table[VCF::Direct][FMT::UByte] = {1, 2};
table[VCF::Direct][FMT::Byte] = {1, 2};
table[VCF::Direct][FMT::UShort] = {2, 4};
table[VCF::Direct][FMT::Short] = {2, 4};
table[VCF::Direct][FMT::Float] = {4, 8};
table[VCF::Index8][FMT::UByte] = {1, 1};
table[VCF::Index8][FMT::Byte] = {1, 1};
table[VCF::Index8][FMT::UShort] = {1, 1};
table[VCF::Index8][FMT::Short] = {1, 1};
table[VCF::Index8][FMT::Float] = {1, 1};
table[VCF::Index16][FMT::UByte] = {2, 2};
table[VCF::Index16][FMT::Byte] = {2, 2};
table[VCF::Index16][FMT::UShort] = {2, 2};
table[VCF::Index16][FMT::Short] = {2, 2};
table[VCF::Index16][FMT::Float] = {2, 2};
return table;
}
();
}; };