diff --git a/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp b/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp index c529a628e6..1126cbd73a 100644 --- a/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp +++ b/Source/UnitTests/VideoCommon/VertexLoaderTest.cpp @@ -13,7 +13,9 @@ TEST(VertexLoaderUID, UniqueEnough) std::set uids; TVtxDesc vtx_desc; + memset(&vtx_desc, 0, sizeof (vtx_desc)); VAT vat; + memset(&vat, 0, sizeof (vat)); uids.insert(VertexLoaderUID(vtx_desc, vat)); vtx_desc.Hex = 0xFEDCBA9876543210ull; @@ -27,21 +29,22 @@ TEST(VertexLoaderUID, UniqueEnough) uids.insert(VertexLoaderUID(vtx_desc, vat)); } +static u8 input_memory[16 * 1024 * 1024]; +static u8 output_memory[16 * 1024 * 1024]; + class VertexLoaderTest : public testing::Test { protected: + void SetUp() override { - // The vertex loading code is still using global variables to specify - // where to load and store data. - // - // Reserve 64K of memory for both. - m_input_memory.clear(); m_input_memory.resize(65536); - m_output_memory.clear(); m_output_memory.resize(65536); - g_pVideoData = m_input_memory.data(); - VertexManager::s_pCurBufferPointer = m_output_memory.data(); + memset(&input_memory[0], 0, sizeof (input_memory)); + memset(&output_memory[0], 0, sizeof (input_memory)); - m_input_pos = m_output_pos = 0; + memset(&m_vtx_desc, 0, sizeof (m_vtx_desc)); + memset(&m_vtx_attr, 0, sizeof (m_vtx_attr)); + + ResetPointers(); } // Pushes a value to the input stream. @@ -49,7 +52,7 @@ protected: void Input(T val) { // Converts *to* big endian, not from. - *(T*)(&m_input_memory[m_input_pos]) = Common::FromBigEndian(val); + *(T*)(&input_memory[m_input_pos]) = Common::FromBigEndian(val); m_input_pos += sizeof (val); } @@ -57,28 +60,38 @@ protected: template T Output() { - T out = *(T*)&m_output_memory[m_output_pos]; + T out = *(T*)&output_memory[m_output_pos]; m_output_pos += sizeof (out); return out; } + // Combination of EXPECT_EQ and Output. + template + void ExpectOut(T val) + { + EXPECT_EQ(val, Output()); + } + + void ResetPointers() + { + g_pVideoData = &input_memory[0]; + VertexManager::s_pCurBufferPointer = &output_memory[0]; + m_input_pos = m_output_pos = 0; + } + u32 m_input_pos, m_output_pos; - std::vector m_input_memory, m_output_memory; + + TVtxDesc m_vtx_desc; + VAT m_vtx_attr; }; -TEST_F(VertexLoaderTest, PositionDirectXYZ) +TEST_F(VertexLoaderTest, PositionDirectFloatXYZ) { - TVtxDesc vtx_desc; - VAT vtx_attr; + m_vtx_desc.Position = 1; // Direct + m_vtx_attr.g0.PosElements = 1; // XYZ + m_vtx_attr.g0.PosFormat = 4; // Float - memset(&vtx_desc, 0, sizeof (vtx_desc)); - memset(&vtx_attr, 0, sizeof (vtx_attr)); - - vtx_desc.Position = 1; // Direct. - vtx_attr.g0.PosElements = 1; // XYZ - vtx_attr.g0.PosFormat = 4; // Float - - VertexLoader loader(vtx_desc, vtx_attr); + VertexLoader loader(m_vtx_desc, m_vtx_attr); ASSERT_EQ(3 * sizeof (float), (u32)loader.GetNativeVertexDeclaration().stride); ASSERT_EQ(3 * sizeof (float), (u32)loader.GetVertexSize()); @@ -90,21 +103,147 @@ TEST_F(VertexLoaderTest, PositionDirectXYZ) Input(0.0f); Input(0.0f); Input(1.0f); // Convert 4 points. "7" -> primitive are points. - loader.RunVertices(vtx_attr, 7, 4); + loader.RunVertices(m_vtx_attr, 7, 4); - EXPECT_EQ(0.0f, Output()); - EXPECT_EQ(0.0f, Output()); - EXPECT_EQ(0.0f, Output()); + ExpectOut(0.0f); ExpectOut(0.0f); ExpectOut(0.0f); + ExpectOut(1.0f); ExpectOut(0.0f); ExpectOut(0.0f); + ExpectOut(0.0f); ExpectOut(1.0f); ExpectOut(0.0f); + ExpectOut(0.0f); ExpectOut(0.0f); ExpectOut(1.0f); - EXPECT_EQ(1.0f, Output()); - EXPECT_EQ(0.0f, Output()); - EXPECT_EQ(0.0f, Output()); - - EXPECT_EQ(0.0f, Output()); - EXPECT_EQ(1.0f, Output()); - EXPECT_EQ(0.0f, Output()); - - EXPECT_EQ(0.0f, Output()); - EXPECT_EQ(0.0f, Output()); - EXPECT_EQ(1.0f, Output()); + // Test that scale does nothing for floating point inputs. + Input(1.0f); Input(2.0f); Input(4.0f); + m_vtx_attr.g0.PosFrac = 1; + loader.RunVertices(m_vtx_attr, 7, 1); + ExpectOut(1.0f); ExpectOut(2.0f); ExpectOut(4.0f); +} + +TEST_F(VertexLoaderTest, PositionDirectU16XY) +{ + m_vtx_desc.Position = 1; // Direct + m_vtx_attr.g0.PosElements = 0; // XY + m_vtx_attr.g0.PosFormat = 2; // U16 + + VertexLoader loader(m_vtx_desc, m_vtx_attr); + + ASSERT_EQ(3 * sizeof (float), (u32)loader.GetNativeVertexDeclaration().stride); + ASSERT_EQ(2 * sizeof (u16), (u32)loader.GetVertexSize()); + + // Write some vertices. + Input(0); Input(0); + Input(1); Input(2); + Input(256); Input(257); + Input(65535); Input(65534); + Input(12345); Input(54321); + + // Convert 5 points. "7" -> primitive are points. + loader.RunVertices(m_vtx_attr, 7, 5); + + ExpectOut(0.0f); ExpectOut(0.0f); ExpectOut(0.0f); + ExpectOut(1.0f); ExpectOut(2.0f); ExpectOut(0.0f); + ExpectOut(256.0f); ExpectOut(257.0f); ExpectOut(0.0f); + ExpectOut(65535.0f); ExpectOut(65534.0f); ExpectOut(0.0f); + ExpectOut(12345.0f); ExpectOut(54321.0f); ExpectOut(0.0f); + + // Test that scale works on U16 inputs. + Input(42); Input(24); + m_vtx_attr.g0.PosFrac = 1; + loader.RunVertices(m_vtx_attr, 7, 1); + ExpectOut(21.0f); ExpectOut(12.0f); ExpectOut(0.0f); +} + +TEST_F(VertexLoaderTest, PositionDirectFloatXYZSpeed) +{ + m_vtx_desc.Position = 1; // Direct + m_vtx_attr.g0.PosElements = 1; // XYZ + m_vtx_attr.g0.PosFormat = 4; // Float + + VertexLoader loader(m_vtx_desc, m_vtx_attr); + + ASSERT_EQ(3 * sizeof (float), (u32)loader.GetNativeVertexDeclaration().stride); + ASSERT_EQ(3 * sizeof (float), (u32)loader.GetVertexSize()); + + for (int i = 0; i < 1000; ++i) + { + ResetPointers(); + loader.RunVertices(m_vtx_attr, 7, 100000); + } +} + +TEST_F(VertexLoaderTest, PositionDirectU16XYSpeed) +{ + m_vtx_desc.Position = 1; // Direct + m_vtx_attr.g0.PosElements = 0; // XY + m_vtx_attr.g0.PosFormat = 2; // U16 + + VertexLoader loader(m_vtx_desc, m_vtx_attr); + + ASSERT_EQ(3 * sizeof (float), (u32)loader.GetNativeVertexDeclaration().stride); + ASSERT_EQ(2 * sizeof (u16), (u32)loader.GetVertexSize()); + + for (int i = 0; i < 1000; ++i) + { + ResetPointers(); + loader.RunVertices(m_vtx_attr, 7, 100000); + } +} + +TEST_F(VertexLoaderTest, LargeFloatVertexSpeed) +{ + // Enables most attributes in floating point direct mode to test speed. + m_vtx_desc.PosMatIdx = 1; + m_vtx_desc.Tex0MatIdx = 1; + m_vtx_desc.Tex1MatIdx = 1; + m_vtx_desc.Tex2MatIdx = 1; + m_vtx_desc.Tex3MatIdx = 1; + m_vtx_desc.Tex4MatIdx = 1; + m_vtx_desc.Tex5MatIdx = 1; + m_vtx_desc.Tex6MatIdx = 1; + m_vtx_desc.Tex7MatIdx = 1; + m_vtx_desc.Position = 1; + m_vtx_desc.Normal = 1; + m_vtx_desc.Color0 = 1; + m_vtx_desc.Color1 = 1; + m_vtx_desc.Tex0Coord = 1; + m_vtx_desc.Tex1Coord = 1; + m_vtx_desc.Tex2Coord = 1; + m_vtx_desc.Tex3Coord = 1; + m_vtx_desc.Tex4Coord = 1; + m_vtx_desc.Tex5Coord = 1; + m_vtx_desc.Tex6Coord = 1; + m_vtx_desc.Tex7Coord = 1; + + m_vtx_attr.g0.PosElements = 1; // XYZ + m_vtx_attr.g0.PosFormat = 4; // Float + m_vtx_attr.g0.NormalElements = 1; // NBT + m_vtx_attr.g0.NormalFormat = 4; // Float + m_vtx_attr.g0.Color0Elements = 1; // Has Alpha + m_vtx_attr.g0.Color0Comp = 5; // RGBA8888 + m_vtx_attr.g0.Color1Elements = 1; // Has Alpha + m_vtx_attr.g0.Color1Comp = 5; // RGBA8888 + m_vtx_attr.g0.Tex0CoordElements = 1; // ST + m_vtx_attr.g0.Tex0CoordFormat = 4; // Float + m_vtx_attr.g1.Tex1CoordElements = 1; // ST + m_vtx_attr.g1.Tex1CoordFormat = 4; // Float + m_vtx_attr.g1.Tex2CoordElements = 1; // ST + m_vtx_attr.g1.Tex2CoordFormat = 4; // Float + m_vtx_attr.g1.Tex3CoordElements = 1; // ST + m_vtx_attr.g1.Tex3CoordFormat = 4; // Float + m_vtx_attr.g1.Tex4CoordElements = 1; // ST + m_vtx_attr.g1.Tex4CoordFormat = 4; // Float + m_vtx_attr.g2.Tex5CoordElements = 1; // ST + m_vtx_attr.g2.Tex5CoordFormat = 4; // Float + m_vtx_attr.g2.Tex6CoordElements = 1; // ST + m_vtx_attr.g2.Tex6CoordFormat = 4; // Float + m_vtx_attr.g2.Tex7CoordElements = 1; // ST + m_vtx_attr.g2.Tex7CoordFormat = 4; // Float + + VertexLoader loader(m_vtx_desc, m_vtx_attr); + + // This test is only done 100x in a row since it's ~20x slower using the + // current vertex loader implementation. + for (int i = 0; i < 100; ++i) + { + ResetPointers(); + loader.RunVertices(m_vtx_attr, 7, 100000); + } }