459 lines
22 KiB
C++
459 lines
22 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "gstests/Defs.h"
|
|
#include "gstests/Fixtures.h"
|
|
|
|
#include "genesplicer/GeneSplicerDNAReaderImpl.h"
|
|
#include "genesplicer/dna/Aliases.h"
|
|
#include "genesplicer/splicedata/genepool/SingleJointBehavior.h"
|
|
#include "genesplicer/splicedata/genepool/BlendShapeDeltas.h"
|
|
#include "genesplicer/splicedata/rawgenes/RawGenes.h"
|
|
#include "genesplicer/types/Aliases.h"
|
|
#include "genesplicer/types/VariableWidthMatrix.h"
|
|
#include "genesplicer/types/Vec3.h"
|
|
#include "genesplicer/types/BlockStorage.h"
|
|
|
|
namespace gs4 {
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 6326)
|
|
#endif
|
|
|
|
inline void assertVec3Near(Vec3 result, Vec3 expected, float threshold) {
|
|
ASSERT_NEAR(result.x, expected.x, threshold);
|
|
ASSERT_NEAR(result.y, expected.y, threshold);
|
|
ASSERT_NEAR(result.z, expected.z, threshold);
|
|
}
|
|
|
|
inline void assertNeutralMeshes(Reader* output, Reader* expected, float threshold) {
|
|
ASSERT_EQ(output->getMeshCount(), expected->getMeshCount());
|
|
for (std::uint16_t meshIdx = 0u; meshIdx < expected->getMeshCount(); ++meshIdx) {
|
|
ASSERT_EQ(output->getVertexPositionCount(meshIdx), expected->getVertexPositionCount(meshIdx));
|
|
for (std::uint32_t vertexIdx = 0u; vertexIdx < expected->getVertexPositionCount(meshIdx); ++vertexIdx) {
|
|
Vec3 resultPosition = output->getVertexPosition(meshIdx, vertexIdx);
|
|
Vec3 expectedPosition = expected->getVertexPosition(meshIdx, vertexIdx);
|
|
assertVec3Near(resultPosition, expectedPosition, threshold);
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertNeutralMeshes(ConstArrayView<RawVector3Vector> neutralMeshes, Reader* expected) {
|
|
std::uint16_t expectedMeshCount = expected->getMeshCount();
|
|
auto actualMeshCount = static_cast<std::uint16_t>(neutralMeshes.size());
|
|
ASSERT_EQ(expectedMeshCount, actualMeshCount);
|
|
for (std::uint16_t meshIdx = 0u; meshIdx < actualMeshCount; meshIdx++) {
|
|
auto expectedVerticesXs = expected->getVertexPositionXs(meshIdx);
|
|
const auto& actualVerticesXs = neutralMeshes[meshIdx].xs;
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(expectedVerticesXs, actualVerticesXs);
|
|
|
|
auto expectedVerticesYs = expected->getVertexPositionYs(meshIdx);
|
|
const auto& actualVerticesYs = neutralMeshes[meshIdx].ys;
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(expectedVerticesYs, actualVerticesYs);
|
|
|
|
auto expectedVerticesZs = expected->getVertexPositionZs(meshIdx);
|
|
const auto& actualVerticesZs = neutralMeshes[meshIdx].zs;
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(expectedVerticesZs, actualVerticesZs);
|
|
}
|
|
}
|
|
|
|
inline void assertNeutralMeshPoolData(ConstArrayView<XYZTiledMatrix<16u> > actualData,
|
|
const Vector<Matrix<XYZBlock<16u> > >& expectedData) {
|
|
ASSERT_EQ(actualData.size(), expectedData.size());
|
|
for (std::uint16_t meshIndex = 0; meshIndex < expectedData.size(); meshIndex++) {
|
|
const auto& mesh = actualData[meshIndex];
|
|
const auto& expectedMesh = expectedData[meshIndex];
|
|
std::size_t blockCount = mesh.rowCount();
|
|
ASSERT_EQ(blockCount, expectedMesh.size());
|
|
|
|
for (std::uint32_t blockIdx = 0u; blockIdx < blockCount; blockIdx++) {
|
|
for (std::size_t dnaIdx = 0u; dnaIdx < mesh[blockIdx].size(); dnaIdx++) {
|
|
ASSERT_EQ(mesh[blockIdx][dnaIdx], expectedMesh[blockIdx][dnaIdx]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertBlendShapeTargets(Reader* output, Reader* expected, float threshold) {
|
|
ASSERT_EQ(output->getMeshCount(), expected->getMeshCount());
|
|
for (std::uint16_t meshIdx = 0u; meshIdx < expected->getMeshCount(); ++meshIdx) {
|
|
ASSERT_EQ(output->getBlendShapeTargetCount(meshIdx), expected->getBlendShapeTargetCount(meshIdx));
|
|
for (std::uint16_t bsIdx = 0u; bsIdx < expected->getBlendShapeTargetCount(meshIdx); ++bsIdx) {
|
|
ASSERT_EQ(output->getBlendShapeTargetDeltaCount(meshIdx, bsIdx),
|
|
expected->getBlendShapeTargetDeltaCount(meshIdx, bsIdx));
|
|
|
|
auto resultIndices = output->getBlendShapeTargetVertexIndices(meshIdx, bsIdx);
|
|
auto expectedIndices = expected->getBlendShapeTargetVertexIndices(meshIdx, bsIdx);
|
|
ASSERT_EQ(resultIndices, expectedIndices);
|
|
|
|
for (std::uint32_t deltaIdx = 0u; deltaIdx < expected->getBlendShapeTargetDeltaCount(meshIdx, bsIdx); ++deltaIdx) {
|
|
Vec3 resultDelta = output->getBlendShapeTargetDelta(meshIdx, bsIdx, deltaIdx);
|
|
Vec3 expectedDelta = expected->getBlendShapeTargetDelta(meshIdx, bsIdx, deltaIdx);
|
|
assertVec3Near(resultDelta, expectedDelta, threshold);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertBlendShapeTargets(const VariableWidthMatrix<RawBlendShapeTarget>& blendShapeTargets, Reader* expected) {
|
|
std::uint16_t expectedMeshCount = expected->getMeshCount();
|
|
|
|
ASSERT_EQ(blendShapeTargets.rowCount(), expectedMeshCount);
|
|
for (std::uint16_t meshIndex = 0u; meshIndex < expectedMeshCount; meshIndex++) {
|
|
auto mesh = blendShapeTargets[meshIndex];
|
|
|
|
std::uint16_t expectedBlendShapeCount = expected->getBlendShapeTargetCount(meshIndex);
|
|
ASSERT_EQ(mesh.size(),
|
|
expectedBlendShapeCount);
|
|
|
|
for (std::uint16_t bsIdx = 0u; bsIdx < expectedBlendShapeCount; bsIdx++) {
|
|
auto expectedIndices = expected->getBlendShapeTargetVertexIndices(meshIndex, bsIdx);
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(mesh[bsIdx].vertexIndices, expectedIndices);
|
|
auto expectedXs = expected->getBlendShapeTargetDeltaXs(meshIndex, bsIdx);
|
|
auto expectedYs = expected->getBlendShapeTargetDeltaYs(meshIndex, bsIdx);
|
|
auto expectedZs = expected->getBlendShapeTargetDeltaZs(meshIndex, bsIdx);
|
|
|
|
const auto& actualDeltas = mesh[bsIdx].deltas;
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(actualDeltas.xs, expectedXs);
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(actualDeltas.ys, expectedYs);
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(actualDeltas.zs, expectedZs);
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertBlendShapePoolVertexIndices(ConstArrayView<VariableWidthMatrix<std::uint32_t> > indices,
|
|
const Vector<Matrix<std::uint32_t> >& expectedIndices) {
|
|
ASSERT_EQ(indices.size(), expectedIndices.size());
|
|
for (std::uint16_t meshIndex = 0u; meshIndex < indices.size(); meshIndex++) {
|
|
const auto& mesh = indices[meshIndex];
|
|
const auto& expectedMesh = expectedIndices[meshIndex];
|
|
auto blendShapeCount = static_cast<std::uint16_t>(mesh.rowCount());
|
|
ASSERT_EQ(blendShapeCount,
|
|
expectedMesh.size());
|
|
|
|
for (std::uint16_t bsIdx = 0u; bsIdx < blendShapeCount; bsIdx++) {
|
|
ASSERT_EQ(mesh[bsIdx],
|
|
expectedMesh[bsIdx]);
|
|
}
|
|
}
|
|
}
|
|
|
|
template<std::uint16_t BlockSize>
|
|
inline void assertBlendShapePoolDeltas(const VariableWidthMatrix<AlignedVariableWidthMatrix<XYZBlock<BlockSize> > >& deltas,
|
|
const Matrix<Matrix<XYZBlock<BlockSize> > >& expectedDeltas) {
|
|
ASSERT_EQ(deltas.rowCount(),
|
|
expectedDeltas.size());
|
|
for (std::uint16_t meshIndex = 0; meshIndex < expectedDeltas.size(); meshIndex++) {
|
|
auto mesh = deltas[meshIndex];
|
|
const auto& expectedMesh = expectedDeltas[meshIndex];
|
|
ASSERT_EQ(mesh.size(), expectedMesh.size());
|
|
|
|
for (std::uint16_t bsIdx = 0u; bsIdx < mesh.size(); bsIdx++) {
|
|
const auto& blendShape = mesh[bsIdx];
|
|
const auto& expectedBlendShape = expectedMesh[bsIdx];
|
|
auto blockCount = static_cast<std::uint16_t>(blendShape.rowCount());
|
|
|
|
for (std::uint32_t blockIdx = 0u; blockIdx < blockCount; blockIdx++) {
|
|
for (std::size_t dnaIdx = 0u; dnaIdx < blendShape[blockIdx].size(); dnaIdx++) {
|
|
const auto& dnaValues = blendShape[blockIdx][dnaIdx];
|
|
const auto& expectedDNAValues = expectedBlendShape[blockIdx][dnaIdx];
|
|
ASSERT_EQ(dnaValues, expectedDNAValues);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
template<std::uint16_t BlockSize>
|
|
inline void assertBlendShapePoolArchDeltas(const Vector<AlignedVariableWidthMatrix<XYZBlock<BlockSize> > >& deltas,
|
|
const Vector<Matrix<XYZBlock<BlockSize> > >& expectedDeltas) {
|
|
ASSERT_EQ(deltas.size(), expectedDeltas.size());
|
|
|
|
for (std::uint16_t meshIndex = 0; meshIndex < expectedDeltas.size(); meshIndex++) {
|
|
auto mesh = deltas[meshIndex];
|
|
const auto& expectedMesh = expectedDeltas[meshIndex];
|
|
ASSERT_EQ(mesh.rowCount(), expectedMesh.size());
|
|
|
|
for (std::uint16_t bsIdx = 0u; bsIdx < mesh.rowCount(); bsIdx++) {
|
|
const auto& blendShape = mesh[bsIdx];
|
|
const auto& expectedBlendShape = expectedMesh[bsIdx];
|
|
auto blockCount = static_cast<std::uint16_t>(blendShape.size());
|
|
|
|
for (std::uint32_t blockIdx = 0u; blockIdx < blockCount; blockIdx++) {
|
|
const auto& archValues = blendShape[blockIdx];
|
|
const auto& expectedDNAValues = expectedBlendShape[blockIdx];
|
|
ASSERT_EQ(archValues, expectedDNAValues);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertBlendShapePoolDNAIndices(const VariableWidthMatrix<VariableWidthMatrix<std::uint16_t> >& dnaIndices,
|
|
const Matrix<Matrix<std::uint16_t> >& expectedDNAIndices) {
|
|
ASSERT_EQ(dnaIndices.rowCount(), expectedDNAIndices.size());
|
|
|
|
for (std::uint16_t meshIndex = 0; meshIndex < expectedDNAIndices.size(); meshIndex++) {
|
|
auto mesh = dnaIndices[meshIndex];
|
|
const auto& expectedMesh = expectedDNAIndices[meshIndex];
|
|
ASSERT_EQ(mesh.size(), expectedMesh.size());
|
|
|
|
for (std::uint16_t bsIdx = 0u; bsIdx < mesh.size(); bsIdx++) {
|
|
const auto& blendShape = mesh[bsIdx];
|
|
const auto& expectedBlendShape = expectedMesh[bsIdx];
|
|
auto blockCount = static_cast<std::uint16_t>(blendShape.rowCount());
|
|
|
|
for (std::uint32_t blockIdx = 0u; blockIdx < blockCount; blockIdx++) {
|
|
for (std::size_t dnaIdx = 0u; dnaIdx < blendShape[blockIdx].size(); dnaIdx++) {
|
|
const auto& indices = blendShape[blockIdx][dnaIdx];
|
|
const auto& expectedIndices = expectedBlendShape[blockIdx][dnaIdx];
|
|
ASSERT_EQ(indices, expectedIndices);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertNeutralJointTranslations(Reader* output, Reader* expected, float threshold) {
|
|
ASSERT_EQ(output->getJointCount(), expected->getJointCount());
|
|
for (std::uint16_t jointIdx = 0u; jointIdx < expected->getJointCount(); ++jointIdx) {
|
|
Vec3 resultOffset = output->getNeutralJointTranslation(jointIdx);
|
|
Vec3 expectedOffset = expected->getNeutralJointTranslation(jointIdx);
|
|
assertVec3Near(resultOffset, expectedOffset, threshold);
|
|
}
|
|
}
|
|
|
|
inline void assertNeutralJointTranslation(const RawVector3Vector& neutralJoints, Reader* expected) {
|
|
auto expectedTranslationXs = expected->getNeutralJointTranslationXs();
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(neutralJoints.xs, expectedTranslationXs);
|
|
|
|
auto expectedTranslationYs = expected->getNeutralJointTranslationYs();
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(neutralJoints.ys, expectedTranslationYs);
|
|
|
|
auto expectedTranslationZs = expected->getNeutralJointTranslationZs();
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(neutralJoints.zs, expectedTranslationZs);
|
|
}
|
|
|
|
inline void assertNeutralJoints(const RawVector3Vector& actual, Vector<Vector3> expected, float threshold) {
|
|
ASSERT_EQ(actual.size(), expected.size());
|
|
for (std::size_t i = 0; i < actual.size(); i++) {
|
|
ASSERT_NEAR(actual.xs[i], expected[i].x, threshold);
|
|
ASSERT_NEAR(actual.ys[i], expected[i].y, threshold);
|
|
ASSERT_NEAR(actual.zs[i], expected[i].z, threshold);
|
|
}
|
|
}
|
|
|
|
inline void assertNeutralJointPool(const XYZTiledMatrix<16u>& actual, const Matrix<XYZBlock<16u> >& expected) {
|
|
std::size_t blockCount = actual.rowCount();
|
|
ASSERT_EQ(blockCount, expected.size());
|
|
|
|
for (std::uint32_t blockIdx = 0u; blockIdx < blockCount; blockIdx++) {
|
|
for (std::size_t dnaIdx = 0u; dnaIdx < expected[blockIdx].size(); dnaIdx++) {
|
|
const auto& actualBlock = actual[blockIdx][dnaIdx];
|
|
const auto& expectedBlock = expected[blockIdx][dnaIdx];
|
|
for (std::size_t i = 0; i < 16; i++) {
|
|
ASSERT_NEAR(actualBlock.Xs[i], expectedBlock.Xs[i], 0.001);
|
|
ASSERT_NEAR(actualBlock.Ys[i], expectedBlock.Ys[i], 0.001);
|
|
ASSERT_NEAR(actualBlock.Zs[i], expectedBlock.Zs[i], 0.001);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertNeutralJointRotations(Reader* output, Reader* expected, float threshold) {
|
|
ASSERT_EQ(output->getJointCount(), expected->getJointCount());
|
|
for (std::uint16_t jointIdx = 0u; jointIdx < expected->getJointCount(); ++jointIdx) {
|
|
Vec3 resultOffset = output->getNeutralJointRotation(jointIdx);
|
|
Vec3 expectedOffset = expected->getNeutralJointRotation(jointIdx);
|
|
assertVec3Near(resultOffset, expectedOffset, threshold);
|
|
}
|
|
}
|
|
|
|
inline void assertNeutralJointRotation(const RawVector3Vector& neutralJoints, Reader* expected) {
|
|
auto expectedRotationXs = expected->getNeutralJointRotationXs();
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(neutralJoints.xs, expectedRotationXs);
|
|
|
|
auto expectedRotationYs = expected->getNeutralJointRotationYs();
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(neutralJoints.ys, expectedRotationYs);
|
|
|
|
auto expectedRotationZs = expected->getNeutralJointRotationZs();
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(neutralJoints.zs, expectedRotationZs);
|
|
}
|
|
|
|
inline void assertJointBehavior(Reader* output, Reader* expected, float threshold) {
|
|
ASSERT_EQ(output->getJointGroupCount(), expected->getJointGroupCount());
|
|
for (std::uint16_t jointGroupIdx = 0u; jointGroupIdx < expected->getJointGroupCount(); ++jointGroupIdx) {
|
|
auto resultOutputIndices = output->getJointGroupOutputIndices(jointGroupIdx);
|
|
auto expectedOutputIndices = expected->getJointGroupOutputIndices(jointGroupIdx);
|
|
ASSERT_EQ(resultOutputIndices, expectedOutputIndices);
|
|
|
|
auto resultValues = output->getJointGroupValues(jointGroupIdx);
|
|
auto expectedValues = expected->getJointGroupValues(jointGroupIdx);
|
|
ASSERT_ELEMENTS_NEAR(resultValues, expectedValues, expectedValues.size(), threshold);
|
|
|
|
auto resultLODs = output->getJointGroupLODs(jointGroupIdx);
|
|
auto expectedLODs = expected->getJointGroupLODs(jointGroupIdx);
|
|
ASSERT_EQ(resultLODs, expectedLODs);
|
|
}
|
|
}
|
|
|
|
inline void assertJointBehavior(ConstArrayView<RawJointGroup> jointGroups, Reader* expected) {
|
|
std::uint16_t expectedJointGroupCount = expected->getJointGroupCount();
|
|
|
|
ASSERT_EQ(jointGroups.size(), expectedJointGroupCount);
|
|
for (std::uint16_t jointGroupIdx = 0u; jointGroupIdx < expectedJointGroupCount; jointGroupIdx++) {
|
|
|
|
const auto& actualJointGroup = jointGroups[jointGroupIdx];
|
|
|
|
auto expectedInputIndices = expected->getJointGroupInputIndices(jointGroupIdx);
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(expectedInputIndices, actualJointGroup.inputIndices);
|
|
|
|
auto expectedOutputIndices = expected->getJointGroupOutputIndices(jointGroupIdx);
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(expectedOutputIndices, actualJointGroup.outputIndices);
|
|
|
|
auto expectedLODs = expected->getJointGroupLODs(jointGroupIdx);
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(expectedLODs, actualJointGroup.lods);
|
|
|
|
auto expectedValues = expected->getJointGroupValues(jointGroupIdx);
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(expectedValues, actualJointGroup.values);
|
|
}
|
|
}
|
|
|
|
inline void assertJointBehaviorPoolIndices(const VariableWidthMatrix<std::uint16_t>& indices,
|
|
const Matrix<std::uint16_t>& expectedIndices) {
|
|
auto jointGroupCount = static_cast<std::uint16_t>(expectedIndices.size());
|
|
ASSERT_EQ(indices.rowCount(), jointGroupCount);
|
|
for (std::uint16_t jntGrpIdx = 0u; jntGrpIdx < jointGroupCount; jntGrpIdx++) {
|
|
ASSERT_EQ(indices[jntGrpIdx], expectedIndices[jntGrpIdx]);
|
|
}
|
|
}
|
|
|
|
inline void assertJointBehaviorValues(ConstArrayView<SingleJointBehavior> actualJoints,
|
|
const Vector<canonical::JBJoint>& expectedJoints) {
|
|
for (std::uint16_t jntOffset = 0u; jntOffset < expectedJoints.size(); jntOffset++) {
|
|
const auto& joint = actualJoints[jntOffset];
|
|
const auto& expectedJoint = expectedJoints[jntOffset];
|
|
auto blockValues = joint.getValues();
|
|
ASSERT_EQ(blockValues.size(), expectedJoint.blockValues.size());
|
|
|
|
for (std::size_t outPos = 0; outPos < blockValues.size(); outPos++) {
|
|
const auto& outPosValues = blockValues[outPos];
|
|
const auto& expectedOutPosValues = expectedJoint.blockValues[outPos];
|
|
ASSERT_EQ(outPosValues.rowCount(), expectedOutPosValues.size());
|
|
|
|
for (std::size_t vBlockIdx = 0u; vBlockIdx < outPosValues.rowCount(); vBlockIdx++) {
|
|
for (std::size_t dnaIdx = 0u; dnaIdx < outPosValues[vBlockIdx].size(); dnaIdx++) {
|
|
ASSERT_EQ(outPosValues[vBlockIdx][dnaIdx], expectedOutPosValues[vBlockIdx][dnaIdx]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertSkinWeights(Reader* output, Reader* expected, float threshold) {
|
|
ASSERT_EQ(output->getMeshCount(), expected->getMeshCount());
|
|
for (std::uint16_t meshIdx = 0; meshIdx < expected->getMeshCount(); ++meshIdx) {
|
|
ASSERT_EQ(output->getVertexPositionCount(meshIdx), expected->getVertexPositionCount(meshIdx));
|
|
for (std::uint32_t vertexIdx = 0; vertexIdx < expected->getVertexPositionCount(meshIdx); ++vertexIdx) {
|
|
auto resultWeights = output->getSkinWeightsValues(meshIdx, vertexIdx);
|
|
auto expectedWeights = expected->getSkinWeightsValues(meshIdx, vertexIdx);
|
|
ASSERT_ELEMENTS_NEAR(resultWeights, expectedWeights, expectedWeights.size(), threshold);
|
|
|
|
auto resultJointIndices = output->getSkinWeightsJointIndices(meshIdx, vertexIdx);
|
|
auto expectedJointIndices = expected->getSkinWeightsJointIndices(meshIdx, vertexIdx);
|
|
ASSERT_EQ(resultJointIndices, expectedJointIndices);
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertSkinWeights(ConstArrayView<Vector<RawVertexSkinWeights> > skinWeights, Reader* expected) {
|
|
std::uint16_t expectedMeshCount = expected->getMeshCount();
|
|
auto actualMeshCount = static_cast<std::uint16_t>(skinWeights.size());
|
|
ASSERT_EQ(actualMeshCount, expectedMeshCount);
|
|
|
|
for (std::uint16_t meshIdx = 0u; meshIdx < actualMeshCount; meshIdx++) {
|
|
std::uint32_t expectedSkinWeightCount = expected->getSkinWeightsCount(meshIdx);
|
|
auto actualSkinWeightCount = static_cast<std::uint32_t>(skinWeights[meshIdx].size());
|
|
ASSERT_EQ(actualSkinWeightCount,
|
|
expectedSkinWeightCount);
|
|
|
|
for (std::uint32_t vertexIdx = 0u; vertexIdx < expectedSkinWeightCount; vertexIdx++) {
|
|
auto expectedValues = expected->getSkinWeightsValues(meshIdx, vertexIdx);
|
|
const auto& actualValues = skinWeights[meshIdx][vertexIdx].weights;
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(actualValues, expectedValues);
|
|
|
|
auto expectedJointIndices = expected->getSkinWeightsJointIndices(meshIdx, vertexIdx);
|
|
const auto& actualJointIndices = skinWeights[meshIdx][vertexIdx].jointIndices;
|
|
ASSERT_ELEMENTS_AND_SIZE_EQ(actualJointIndices, expectedJointIndices);
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertSkinWeightPoolJointIndices(ConstArrayView<VariableWidthMatrix<std::uint16_t> > indices,
|
|
const Vector<Matrix<std::uint16_t> >& expectedIndices) {
|
|
ASSERT_EQ(indices.size(), expectedIndices.size());
|
|
|
|
for (std::uint32_t meshIndex = 0u; meshIndex < indices.size(); meshIndex++) {
|
|
const auto& mesh = indices[meshIndex];
|
|
const auto& expectedMesh = expectedIndices[meshIndex];
|
|
const auto vertexCount = mesh.rowCount();
|
|
ASSERT_EQ(vertexCount, expectedMesh.size());
|
|
|
|
for (std::uint16_t vtxIdx = 0u; vtxIdx < vertexCount; vtxIdx++) {
|
|
ASSERT_EQ(mesh[vtxIdx], expectedMesh[vtxIdx]);
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertSkinWeightPoolValues(const VariableWidthMatrix<TiledMatrix2D<16u> >& weights,
|
|
const Matrix<Matrix<VBlock<16u> > >& expectedWeights) {
|
|
ASSERT_EQ(weights.rowCount(), expectedWeights.size());
|
|
|
|
for (std::uint16_t meshIndex = 0; meshIndex < weights.rowCount(); meshIndex++) {
|
|
auto mesh = weights[meshIndex];
|
|
const auto& expectedMesh = expectedWeights[meshIndex];
|
|
auto blockCount = static_cast<std::uint32_t>(mesh.size());
|
|
ASSERT_EQ(blockCount, expectedMesh.size());
|
|
|
|
for (std::uint32_t blockIdx = 0u; blockIdx < blockCount; blockIdx++) {
|
|
const auto& dnaBlock = mesh[blockIdx];
|
|
const auto& expectedDNABlock = expectedMesh[blockIdx];
|
|
|
|
for (std::size_t dnaIdx = 0u; dnaIdx < expectedDNABlock.size(); dnaIdx++) {
|
|
auto dnaValues = dnaBlock[dnaIdx];
|
|
const auto& expectedDNAValues = expectedDNABlock[dnaIdx];
|
|
ASSERT_EQ(dnaValues.size(), expectedDNAValues.size());
|
|
auto jntPosCount = static_cast<std::uint16_t>(dnaValues.size());
|
|
|
|
for (std::uint32_t jntPos = 0u; jntPos < jntPosCount; jntPos++) {
|
|
ASSERT_EQ(dnaValues[jntPos], expectedDNAValues[jntPos]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
inline void assertRawGenes(const RawGenes& rawGenes, Reader* expected) {
|
|
ASSERT_EQ(expected->getMeshCount(), rawGenes.getMeshCount());
|
|
for (std::uint16_t meshIdx = 0u; meshIdx < rawGenes.getMeshCount(); meshIdx++) {
|
|
ASSERT_EQ(expected->getVertexPositionCount(meshIdx), rawGenes.getVertexCount(meshIdx));
|
|
ASSERT_EQ(expected->getSkinWeightsCount(meshIdx), rawGenes.getSkinWeightsCount(meshIdx));
|
|
}
|
|
ASSERT_EQ(expected->getJointCount(), rawGenes.getJointCount());
|
|
assertNeutralMeshes(rawGenes.getNeutralMeshes(), expected);
|
|
assertBlendShapeTargets(rawGenes.getBlendShapeTargets(), expected);
|
|
assertSkinWeights(rawGenes.getSkinWeights(), expected);
|
|
assertNeutralJoints(rawGenes.getNeutralJoints(JointAttribute::Translation),
|
|
canonical::expectedRawGenesNeutralJointTranslations,
|
|
0.0001f);
|
|
assertNeutralJoints(rawGenes.getNeutralJoints(JointAttribute::Rotation),
|
|
canonical::expectedRawGenesNeutralJointRotations,
|
|
0.0001f);
|
|
assertJointBehavior(rawGenes.getJointGroups(), expected);
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
} // namespace gs4
|