okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
92109ae643f5ba4e08d1c9325f6038dcce39778b
EVEngine/test/animation_skinned.cpp
T

892 lines
32 KiB
C++
Raw Blame History

#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
#include "Fixtures.h"
#include "animation/AnimClip.h"
#include "animation/AnimImporter.h"
#include "animation/AnimPlayer.h"
#include "animation/AnimPose.h"
#include "animation/AnimSkeleton.h"
#include "animation/AnimSkin.h"
#include "animation/Animation.h"
#include "common/Exception.h"
#include "data/ByteData.h"
#include "filesystem/FileData.h"
#include "filesystem/Filesystem.h"
#include "graphics/AmbientOcclusion.h"
#include "graphics/AntiAliasing.h"
#include "graphics/Canvas.h"
#include "graphics/DrawItem2D.h"
#include "graphics/Font.h"
#include "graphics/GBuffer.h"
#include "graphics/GlobalIllumination.h"
#include "graphics/Graphics.h"
#include "graphics/Grass.h"
#include "graphics/Material.h"
#include "graphics/Outline.h"
#include "graphics/Quad.h"
#include "graphics/RenderControl.h"
#include "graphics/ScreenSpaceReflection.h"
#include "graphics/Shader.h"
#include "graphics/Texture.h"
#include "graphics/Volumetric.h"
#include "graphics/Water.h"
#include "graphics/Waterfall.h"
// Color lives in eve::graphics (see graphics/Canvas.h); keep the unqualified form.
using eve::graphics::Color;
#include "graphics/Light.h"
#include "graphics/Mesh.h"
#include "graphics/RenderSystem.h"
#include "graphics/RenderSystem3D.h"
#include "image/Image.h"
#include "image/ImageData.h"
#include "model3d/Model3D.h"
#include "model3d/ModelData.h"
#include "window/Window.h"
#include <assimp/mesh.h>
#include <assimp/scene.h>
#include <SDL2/SDL.h>
#include <algorithm>
#include <array>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <memory>
#include <string>
#include <vector>
using namespace eve::animation;
using namespace eve::graphics;
namespace {
#include "PathBesideSource.h"
EVE_DEFINE_PATH_BESIDE_SOURCE()
bool fileExists(const std::string &path) {
return std::filesystem::is_regular_file(path);
}
std::string cesiumManDir() {
return pathBesideThisSource("assets/skinned/cesium_man/glTF");
}
std::string cesiumManGltfPath() { return cesiumManDir() + "/CesiumMan.gltf"; }
bool ensureSkinnedAssets() {
const std::string gltf = cesiumManGltfPath();
if (fileExists(gltf)) return true;
std::printf(
"animation.skinned: missing %s — run scripts/download_skinned_character.sh "
"(or cmake --build --target download_skinned_character / "
"-DEVENGINE_DOWNLOAD_SKINNED_CHARACTER=ON)\n",
gltf.c_str());
return false;
}
/** Mount the CesiumMan glTF folder in physfs and load via relative path. */
eve::model3d::ModelData *loadCesiumMan(const char *fsIdentity) {
const std::string dir = cesiumManDir();
REQUIRE(fileExists(dir + "/CesiumMan.gltf"));
auto *fs = eve::filesystem::Filesystem::create();
REQUIRE(fs != nullptr);
REQUIRE(fs->setIdentity(fsIdentity, true));
REQUIRE(fs->setupWriteDirectory());
fs->allowMountingForPath(dir);
REQUIRE(fs->mount(dir, "", false));
auto *mod = eve::model3d::Model3D::create();
return mod->newModelDataFromFile("CesiumMan.gltf");
}
int findFirstSkinnedMesh(const eve::model3d::ModelData *model) {
for (int i = 0; i < model->getMeshCount(); ++i) {
if (model->hasBones(i)) return i;
}
return -1;
}
float vertexDeltaMax(const std::vector<float> &a, const std::vector<float> &b) {
const size_t n = std::min(a.size(), b.size());
float maxd = 0.f;
for (size_t i = 0; i < n; ++i) {
maxd = std::max(maxd, std::fabs(a[i] - b[i]));
}
return maxd;
}
// ---- skinned render helpers ------------------------------------------------
struct Bounds {
float minX = 0, minY = 0, minZ = 0;
float maxX = 0, maxY = 0, maxZ = 0;
bool valid = false;
void expand(float x, float y, float z) {
if (!valid) {
minX = maxX = x;
minY = maxY = y;
minZ = maxZ = z;
valid = true;
return;
}
minX = std::min(minX, x);
minY = std::min(minY, y);
minZ = std::min(minZ, z);
maxX = std::max(maxX, x);
maxY = std::max(maxY, y);
maxZ = std::max(maxZ, z);
}
float centerX() const { return 0.5f * (minX + maxX); }
float centerY() const { return 0.5f * (minY + maxY); }
float centerZ() const { return 0.5f * (minZ + maxZ); }
float radius() const {
const float dx = maxX - minX;
const float dy = maxY - minY;
const float dz = maxZ - minZ;
return 0.5f * std::sqrt(dx * dx + dy * dy + dz * dz);
}
};
void resetScene3D() {
if (ecs::current()->getManager<Renderable3D>() != nullptr) {
auto view = ecs::View<Renderable3D, Renderable3D::MeshRenderer>();
for (auto it = view.begin(); it != view.end(); ++it) {
auto [mr] = *it;
mr->visible = false;
}
}
if (ecs::current()->getManager<Camera3D>() != nullptr) {
auto camView = ecs::View<Camera3D, Camera3D::Data>();
for (auto it = camView.begin(); it != camView.end(); ++it) {
auto [data] = *it;
data->active = false;
}
}
if (ecs::current()->getManager<Light3D>() != nullptr) {
auto lightView = ecs::View<Light3D, Light3D::Data>();
for (auto it = lightView.begin(); it != lightView.end(); ++it) {
auto [d] = *it;
d->enabled = false;
}
}
if (ecs::current()->getManager<Renderable2D>() != nullptr) {
auto view = ecs::View<Renderable2D, Renderable2D::Sprite>();
for (auto it = view.begin(); it != view.end(); ++it) {
auto [sp] = *it;
sp->visible = false;
}
}
}
float luma(const Color &c) { return (c.r + c.g + c.b) / 3.f; }
std::vector<float> captureLumaGrid(Graphics *gfx, int step = 2) {
const int w = gfx->getWidth();
const int h = gfx->getHeight();
std::vector<float> out(size_t(w) * size_t(h), 0.f);
for (int y = 0; y < h; y += step) {
for (int x = 0; x < w; x += step) {
out[size_t(y) * size_t(w) + size_t(x)] = luma(gfx->getPixel(x, y));
}
}
return out;
}
float maxLumaAbsDelta(Graphics *gfx, const std::vector<float> &a, const std::vector<float> &b,
int step = 2) {
float best = -1.f;
const int w = gfx->getWidth();
const int h = gfx->getHeight();
for (int y = 0; y < h; y += step) {
for (int x = 0; x < w; x += step) {
const size_t i = size_t(y * w + x);
best = std::max(best, std::fabs(a[i] - b[i]));
}
}
return best;
}
int foregroundPixelCount(const std::vector<float> &L, float threshold) {
int count = 0;
for (float v : L)
if (v > threshold) ++count;
return count;
}
std::vector<char> readBinaryFile(const std::string &path) {
std::ifstream in(path, std::ios::binary);
if (!in) return {};
return std::vector<char>(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>());
}
/** CesiumMan's glTF base-color map (jpg beside the .gltf). */
Texture *loadCesiumManDiffuseTexture(Graphics *gfx) {
const std::string path = cesiumManDir() + "/CesiumMan_img0.jpg";
const auto bytes = readBinaryFile(path);
if (bytes.empty()) return nullptr;
[[maybe_unused]] auto *const imageModule = eve::image::Image::create();
try {
eve::data::ByteData data(bytes.data(), bytes.size());
eve::image::ImageData *img = eve::image::Image::create()->newImageData(&data);
if (!img) return nullptr;
Texture *tex = gfx->newTexture(img);
delete img;
return tex;
} catch (...) {
return nullptr;
}
}
Texture *makeSolidGray(Graphics *gfx, uint8_t g) {
const uint8_t px[4] = {g, g, g, 255};
return gfx->newTexture(1, 1, px);
}
void savePng(Graphics *gfx, const char *pngName) {
[[maybe_unused]] auto *const imageModule = eve::image::Image::create();
eve::image::ImageData *frame = gfx->newImageData();
REQUIRE(frame != nullptr);
eve::filesystem::FileData *png =
frame->encode(medialoader::FormatHandler::ENCODED_PNG, pngName, false);
REQUIRE(png != nullptr);
REQUIRE(png->getSize() > 0);
const std::string outDir = std::string(EVENGINE_TEST_BINARY_DIR) + "/out";
std::error_code ec;
std::filesystem::create_directories(outDir, ec);
const std::string outPath = outDir + "/" + pngName;
{
std::ofstream out(outPath, std::ios::binary);
REQUIRE(out.good());
out.write(static_cast<const char *>(png->getData()),
static_cast<std::streamsize>(png->getSize()));
REQUIRE(out.good());
}
std::printf("animation.skinned render saved: %s\n", outPath.c_str());
delete png;
delete frame;
}
enum class SkinnedRenderDriver {
bindPose,
clipSample,
player,
};
/**
* Open a window, CPU-skin the CesiumMan mesh every frame with the pose produced
* by `driver`, upload it, render, and assert the character is visible. The last
* frame is saved as a PNG next to the other test outputs. `frameCount` frames
* are rendered at ~16ms each so the animation is actually on screen.
*/
void renderSkinnedAnimation(eve::model3d::ModelData *model, const char *pngName,
SkinnedRenderDriver driver, int frameCount) {
REQUIRE(model != nullptr);
REQUIRE(pngName != nullptr);
REQUIRE(frameCount >= 1);
const int meshIndex = findFirstSkinnedMesh(model);
REQUIRE(meshIndex >= 0);
const aiMesh *ai = model->getMesh(meshIndex);
REQUIRE(ai != nullptr);
REQUIRE(ai->mNumVertices > 0u);
REQUIRE(ai->mNumFaces > 0u);
const int vertexCount = static_cast<int>(ai->mNumVertices);
std::unique_ptr<AnimSkeleton> skeleton(AnimImporter::loadSkeletonFromModel(model));
REQUIRE(skeleton.get() != nullptr);
std::unique_ptr<AnimSkin> skin(AnimSkin::fromModel(model, meshIndex, skeleton.get()));
REQUIRE(skin.get() != nullptr);
std::unique_ptr<AnimClip> clip(AnimImporter::loadClipFromModel(model, skeleton.get(), 0));
REQUIRE(clip.get() != nullptr);
CHECK(clip->getDuration() > 0.1f);
std::vector<float> nrm;
if (ai->mNormals) {
nrm.reserve(size_t(vertexCount) * 3u);
for (int v = 0; v < vertexCount; ++v) {
nrm.push_back(ai->mNormals[v].x);
nrm.push_back(ai->mNormals[v].y);
nrm.push_back(ai->mNormals[v].z);
}
}
std::vector<float> uv;
if (ai->mTextureCoords[0]) {
uv.reserve(size_t(vertexCount) * 2u);
for (int v = 0; v < vertexCount; ++v) {
uv.push_back(ai->mTextureCoords[0][v].x);
uv.push_back(ai->mTextureCoords[0][v].y);
}
}
std::vector<uint32_t> indices;
indices.reserve(size_t(ai->mNumFaces) * 3u);
for (unsigned f = 0; f < ai->mNumFaces; ++f) {
const aiFace &face = ai->mFaces[f];
REQUIRE(face.mNumIndices == 3u);
for (unsigned k = 0; k < 3u; ++k) indices.push_back(face.mIndices[k]);
}
const int indexCount = static_cast<int>(indices.size());
Bounds b;
for (int v = 0; v < vertexCount; ++v)
b.expand(ai->mVertices[v].x, ai->mVertices[v].y, ai->mVertices[v].z);
REQUIRE(b.valid);
const float cx = b.centerX(), cy = b.centerY(), cz = b.centerZ();
const float rad = std::max(0.5f, b.radius());
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx);
resetScene3D();
Texture *diffuse = loadCesiumManDiffuseTexture(gfx);
Texture *tex = diffuse ? diffuse : makeSolidGray(gfx, 200);
auto *ent = Renderable3D::create();
ent->setTexture(tex);
ent->setTint(1.f, 1.f, 1.f, 1.f);
ent->meshRenderer()->visible = true;
ent->meshRenderer()->castShadow = false;
ent->meshRenderer()->receiveShadow = false;
auto *cam = Camera3D::createCamera();
cam->setTarget(cx, cy, cz);
cam->setEye(cx + rad * 0.9f, cy + rad * 0.55f, cz + rad * 1.8f);
cam->data()->nearZ = std::max(0.05f, rad * 0.01f);
cam->data()->farZ = std::max(100.f, rad * 20.f);
cam->setAmbient(0.15f, 0.15f, 0.15f);
// Light rays travel from the camera toward the subject (RenderSystem3D legacy).
RenderSystem3D::setDirectionalLight(cx - (cx + rad * 0.9f), cy - (cy + rad * 0.55f) + rad * 1.2f,
cz - (cz + rad * 1.8f), 1.8f, 1.8f, 1.8f);
gfx->setScreenReadbackEnabled(true);
gfx->setBackgroundColor(Color(0.02f, 0.02f, 0.03f, 1.f));
std::unique_ptr<AnimPlayer> player;
if (driver == SkinnedRenderDriver::player) {
player.reset(new AnimPlayer(skeleton.get()));
player->play(clip.get());
}
AnimPose pose;
std::vector<float> firstLuma;
float maxDelta = -1.f;
bool first = true;
std::vector<float> bindPos(static_cast<size_t>(vertexCount) * 3u);
for (int v = 0; v < vertexCount; ++v) {
bindPos[static_cast<size_t>(v) * 3u] = ai->mVertices[v].x;
bindPos[static_cast<size_t>(v) * 3u + 1u] = ai->mVertices[v].y;
bindPos[static_cast<size_t>(v) * 3u + 2u] = ai->mVertices[v].z;
}
Mesh *mesh = gfx->newMeshFromArrays(bindPos.data(), nrm.empty() ? nullptr : nrm.data(),
uv.empty() ? nullptr : uv.data(), vertexCount, indices.data(), indexCount);
REQUIRE(mesh != nullptr);
REQUIRE(skin->bindGpuMesh(gfx, mesh));
ent->meshRenderer()->mesh = mesh;
for (int i = 0; i < frameCount; ++i) {
AnimPose *usedPose = nullptr;
switch (driver) {
case SkinnedRenderDriver::bindPose:
skeleton->applyBindPose(&pose);
pose.computeWorld(skeleton.get());
usedPose = &pose;
break;
case SkinnedRenderDriver::clipSample: {
const float t = frameCount > 1
? clip->getDuration() * float(i) / float(frameCount - 1)
: 0.f;
clip->sample(t, &pose, skeleton.get());
pose.computeWorld(skeleton.get());
usedPose = &pose;
break;
}
case SkinnedRenderDriver::player:
player->update(1.f / 30.f);
usedPose = player->getPose();
REQUIRE(usedPose != nullptr);
usedPose->computeWorld(skeleton.get());
break;
}
REQUIRE(skin->updateGpuMesh(mesh, usedPose));
RenderSystem3D::render(*gfx);
RenderSystem::render(*gfx);
SDL_Event e;
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
win->close();
return;
}
}
SDL_Delay(16);
const auto L = captureLumaGrid(gfx);
if (first) {
firstLuma = L;
first = false;
} else {
maxDelta = std::max(maxDelta, maxLumaAbsDelta(gfx, firstLuma, L));
}
}
const auto last = captureLumaGrid(gfx);
CHECK(foregroundPixelCount(last, 0.15f) > 20);
if (frameCount > 1 && driver != SkinnedRenderDriver::bindPose) CHECK(maxDelta > 0.01f);
savePng(gfx, pngName);
win->close();
}
} // namespace
TEST_CASE("animation.skinned.mat4FromTRSIdentity") {
TransformTRS t = TransformTRS::identity();
Mat4 m = Mat4::fromTRS(t);
CHECK(std::fabs(m.m[0] - 1.f) < 1e-5f);
CHECK(std::fabs(m.m[5] - 1.f) < 1e-5f);
CHECK(std::fabs(m.m[10] - 1.f) < 1e-5f);
CHECK(std::fabs(m.m[15] - 1.f) < 1e-5f);
float ox, oy, oz;
m.transformPoint(1.f, 2.f, 3.f, ox, oy, oz);
CHECK(std::fabs(ox - 1.f) < 1e-5f);
CHECK(std::fabs(oy - 2.f) < 1e-5f);
CHECK(std::fabs(oz - 3.f) < 1e-5f);
}
TEST_CASE("animation.skinned.gpuPaletteOwnsAndValidatesMatrices") {
Mesh mesh;
std::array<float, 32> matrices{};
matrices[0] = matrices[5] = matrices[10] = matrices[15] = 1.f;
matrices[16] = matrices[21] = matrices[26] = matrices[31] = 1.f;
matrices[28] = 3.5f;
CHECK(mesh.setSkinPalette(matrices.data(), 2).ok());
CHECK(mesh.getSkinPaletteCount() == 2);
CHECK(std::fabs(mesh.skinPalette()[28] - 3.5f) < 1e-6f);
matrices[28] = 9.f;
CHECK(std::fabs(mesh.skinPalette()[28] - 3.5f) < 1e-6f);
CHECK(!mesh.setSkinPalette(nullptr, 1).ok());
CHECK(!mesh.setSkinPalette(matrices.data(), -1).ok());
}
TEST_CASE("animation.skinned.worldMatrixMatchesTRS") {
std::unique_ptr<AnimSkeleton> sk(new AnimSkeleton());
const int root = sk->addBone("root", -1);
const int child = sk->addBone("child", root);
sk->setBindPosition(child, 0.f, 1.f, 0.f);
std::unique_ptr<AnimPose> pose(new AnimPose());
sk->applyBindPose(pose.get());
pose->setLocalPosition(root, 10.f, 0.f, 0.f);
pose->computeWorld(sk.get());
CHECK(std::fabs(pose->getWorldPositionX(child) - 10.f) < 1e-4f);
CHECK(std::fabs(pose->getWorldPositionY(child) - 1.f) < 1e-4f);
float mat[16];
pose->getWorldMatrix(child, mat);
CHECK(std::fabs(mat[12] - 10.f) < 1e-4f);
CHECK(std::fabs(mat[13] - 1.f) < 1e-4f);
CHECK(std::fabs(pose->getWorldMatrixElement(child, 12) - 10.f) < 1e-4f);
}
TEST_CASE("animation.skinned.cesiumMan.loadSkinAndDeform") {
if (!ensureSkinnedAssets()) return;
eve::ref<eve::model3d::ModelData> model(loadCesiumMan("ev_ut_animation_skinned"));
REQUIRE(model.get() != nullptr);
REQUIRE(!model->empty());
CHECK(model->getMeshCount() >= 1);
CHECK(model->getAnimationCount() >= 1);
const int meshIndex = findFirstSkinnedMesh(model.get());
REQUIRE(meshIndex >= 0);
CHECK(model->hasBones(meshIndex));
CHECK(model->getBoneCount(meshIndex) >= 2);
CHECK(model->getVertexCount(meshIndex) > 10);
// Weight bookkeeping: every bone weight references a valid vertex.
int totalWeights = 0;
for (int b = 0; b < model->getBoneCount(meshIndex); ++b) {
const std::string name = model->getBoneName(meshIndex, b);
CHECK(!name.empty());
// Inverse-bind should be a finite matrix.
float sumAbs = 0.f;
for (int e = 0; e < 16; ++e) {
const float v = model->getInverseBindMatrixElement(meshIndex, b, e);
CHECK(std::isfinite(v));
sumAbs += std::fabs(v);
}
CHECK(sumAbs > 0.f);
const int wc = model->getBoneWeightCount(meshIndex, b);
totalWeights += wc;
for (int w = 0; w < wc; ++w) {
const int vi = model->getBoneWeightVertex(meshIndex, b, w);
CHECK(vi >= 0);
CHECK(vi < model->getVertexCount(meshIndex));
const float wv = model->getBoneWeightValue(meshIndex, b, w);
CHECK(wv >= 0.f);
CHECK(wv <= 1.f + 1e-3f);
}
}
CHECK(totalWeights > 0);
std::unique_ptr<AnimSkeleton> skeleton(AnimImporter::loadSkeletonFromModel(model.get()));
REQUIRE(skeleton.get() != nullptr);
CHECK(skeleton->getBoneCount() >= model->getBoneCount(meshIndex));
// Skin joints should resolve onto the imported hierarchy by name.
for (int b = 0; b < model->getBoneCount(meshIndex); ++b) {
const std::string name = model->getBoneName(meshIndex, b);
CHECK(skeleton->findBone(name) >= 0);
}
std::unique_ptr<AnimClip> clip(
AnimImporter::loadClipFromModel(model.get(), skeleton.get(), 0));
REQUIRE(clip.get() != nullptr);
CHECK(clip->getDuration() > 0.1f);
std::unique_ptr<AnimSkin> skin(AnimSkin::fromModel(model.get(), meshIndex, skeleton.get()));
REQUIRE(skin.get() != nullptr);
CHECK(skin->getVertexCount() == model->getVertexCount(meshIndex));
CHECK(skin->getBoneCount() >= 2);
// Spot-check influence renormalization: weights per vertex sum to ~0 or ~1.
int weightedVerts = 0;
for (int v = 0; v < skin->getVertexCount(); ++v) {
float sum = 0.f;
for (int i = 0; i < skin->getInfluenceCount(); ++i) {
sum += skin->getVertexWeight(v, i);
}
if (sum > 1e-5f) {
++weightedVerts;
CHECK(std::fabs(sum - 1.f) < 1e-3f);
}
}
CHECK(weightedVerts > 0);
std::unique_ptr<AnimPose> pose0(new AnimPose());
std::unique_ptr<AnimPose> pose1(new AnimPose());
clip->sample(0.f, pose0.get(), skeleton.get());
pose0->computeWorld(skeleton.get());
const float mid = clip->getDuration() * 0.5f;
clip->sample(mid, pose1.get(), skeleton.get());
pose1->computeWorld(skeleton.get());
std::vector<float> skinned0, skinned1;
REQUIRE(skin->skinPositionsTo(pose0.get(), skinned0));
REQUIRE(skin->skinPositionsTo(pose1.get(), skinned1));
CHECK(skinned0.size() == static_cast<size_t>(skin->getVertexCount()) * 3u);
CHECK(skinned1.size() == skinned0.size());
// Walking clip should move skinned vertices between t=0 and mid-clip.
const float delta = vertexDeltaMax(skinned0, skinned1);
CHECK(delta > 0.01f);
// Player path: advance a few frames and keep deforming.
std::unique_ptr<AnimPlayer> player(new AnimPlayer(skeleton.get()));
player->play(clip.get());
for (int i = 0; i < 8; ++i) player->update(1.f / 30.f);
AnimPose *live = player->getPose();
REQUIRE(live != nullptr);
live->computeWorld(skeleton.get());
std::vector<float> skinnedLive;
REQUIRE(skin->skinPositionsTo(live, skinnedLive));
CHECK(vertexDeltaMax(skinned0, skinnedLive) > 1e-4f);
}
TEST_CASE("animation.skinned.getSkinnedPositionsMatchesSkinPositionsTo") {
if (!ensureSkinnedAssets()) return;
eve::ref<eve::model3d::ModelData> model(
loadCesiumMan("ev_ut_animation_skinned_posarray"));
REQUIRE(model.get() != nullptr);
const int meshIndex = findFirstSkinnedMesh(model.get());
REQUIRE(meshIndex >= 0);
std::unique_ptr<AnimSkeleton> skeleton(AnimImporter::loadSkeletonFromModel(model.get()));
REQUIRE(skeleton.get() != nullptr);
std::unique_ptr<AnimSkin> skin(AnimSkin::fromModel(model.get(), meshIndex, skeleton.get()));
REQUIRE(skin.get() != nullptr);
// Not skinned yet: packed getters are empty and the flags are false.
CHECK(skin->getSkinnedPositions().empty());
CHECK(skin->getSkinnedNormals().empty());
CHECK(!skin->hasSkinnedPositions());
CHECK(!skin->hasSkinnedNormals());
std::unique_ptr<AnimClip> clip(
AnimImporter::loadClipFromModel(model.get(), skeleton.get(), 0));
REQUIRE(clip.get() != nullptr);
std::unique_ptr<AnimPose> pose(new AnimPose());
clip->sample(clip->getDuration() * 0.25f, pose.get(), skeleton.get());
pose->computeWorld(skeleton.get());
REQUIRE(skin->updateSkinnedPositions(pose.get()));
CHECK(skin->hasSkinnedPositions());
std::vector<float> expected;
REQUIRE(skin->skinPositionsTo(pose.get(), expected));
const std::vector<float> packed = skin->getSkinnedPositions();
REQUIRE(packed.size() == expected.size());
CHECK(vertexDeltaMax(packed, expected) < 1e-5f);
}
TEST_CASE("animation.skinned.normalsFollowPose") {
if (!ensureSkinnedAssets()) return;
eve::ref<eve::model3d::ModelData> model(
loadCesiumMan("ev_ut_animation_skinned_normals"));
REQUIRE(model.get() != nullptr);
const int meshIndex = findFirstSkinnedMesh(model.get());
REQUIRE(meshIndex >= 0);
const aiMesh *ai = model->getMesh(meshIndex);
REQUIRE(ai != nullptr);
REQUIRE(ai->HasNormals());
REQUIRE(ai->mNormals != nullptr);
std::vector<float> bindNrm(size_t(ai->mNumVertices) * 3u);
for (int v = 0; v < int(ai->mNumVertices); ++v) {
bindNrm[size_t(v) * 3u + 0] = ai->mNormals[v].x;
bindNrm[size_t(v) * 3u + 1] = ai->mNormals[v].y;
bindNrm[size_t(v) * 3u + 2] = ai->mNormals[v].z;
}
std::unique_ptr<AnimSkeleton> skeleton(AnimImporter::loadSkeletonFromModel(model.get()));
REQUIRE(skeleton.get() != nullptr);
std::unique_ptr<AnimSkin> skin(AnimSkin::fromModel(model.get(), meshIndex, skeleton.get()));
REQUIRE(skin.get() != nullptr);
// Bind pose: skin matrices are identity, so normals must stay in place.
std::unique_ptr<AnimPose> bind(new AnimPose());
skeleton->applyBindPose(bind.get());
bind->computeWorld(skeleton.get());
REQUIRE(skin->updateSkinnedNormals(bind.get()));
CHECK(skin->hasSkinnedNormals());
std::vector<float> bindSkinned = skin->getSkinnedNormals();
REQUIRE(bindSkinned.size() == bindNrm.size());
CHECK(vertexDeltaMax(bindSkinned, bindNrm) < 1e-3f);
// Mid-clip pose: at least one normal must rotate, and all stay unit length.
std::unique_ptr<AnimClip> clip(
AnimImporter::loadClipFromModel(model.get(), skeleton.get(), 0));
REQUIRE(clip.get() != nullptr);
std::unique_ptr<AnimPose> mid(new AnimPose());
clip->sample(clip->getDuration() * 0.5f, mid.get(), skeleton.get());
mid->computeWorld(skeleton.get());
REQUIRE(skin->updateSkinnedNormals(mid.get()));
const std::vector<float> midSkinned = skin->getSkinnedNormals();
REQUIRE(midSkinned.size() == bindNrm.size());
CHECK(vertexDeltaMax(midSkinned, bindNrm) > 1e-3f);
for (size_t i = 0; i + 2 < midSkinned.size(); i += 3) {
const float nx = midSkinned[i];
const float ny = midSkinned[i + 1];
const float nz = midSkinned[i + 2];
const float len = std::sqrt(nx * nx + ny * ny + nz * nz);
CHECK(std::fabs(len - 1.f) < 1e-3f);
}
}
TEST_CASE("animation.skinned.cesiumMan.animationFactory") {
if (!ensureSkinnedAssets()) return;
eve::ref<eve::model3d::ModelData> model(
loadCesiumMan("ev_ut_animation_skinned_factory"));
REQUIRE(model.get() != nullptr);
// Animation::create() returns the process-wide module singleton owned by
// ModuleManager; do NOT wrap it in unique_ptr (that would delete the
// singleton out from under ModuleManager and leave a dangling pointer for
// later tests that call Animation::create() again).
Animation *anim = Animation::create();
REQUIRE(anim != nullptr);
std::unique_ptr<AnimSkeleton> sk(anim->newSkeletonFromModel(model.get()));
REQUIRE(sk.get() != nullptr);
const int meshIndex = findFirstSkinnedMesh(model.get());
REQUIRE(meshIndex >= 0);
std::unique_ptr<AnimSkin> skin(anim->newSkinFromModel(model.get(), meshIndex, sk.get()));
REQUIRE(skin.get() != nullptr);
CHECK(skin->getVertexCount() > 0);
std::unique_ptr<AnimClip> clip(anim->newClipFromModel(model.get(), sk.get(), 0));
REQUIRE(clip.get() != nullptr);
CHECK(clip->getDuration() > 0.f);
}
TEST_CASE("animation.skinned.render.bindPose") {
if (!ensureSkinnedAssets()) return;
eve::ref<eve::model3d::ModelData> model(
loadCesiumMan("ev_ut_animation_skinned_render_bindpose"));
REQUIRE(model.get() != nullptr);
renderSkinnedAnimation(model.get(), "animation_skinned_bindpose.png",
SkinnedRenderDriver::bindPose, 3);
}
TEST_CASE("animation.skinned.render.clipSampledMovesPixels") {
if (!ensureSkinnedAssets()) return;
eve::ref<eve::model3d::ModelData> model(
loadCesiumMan("ev_ut_animation_skinned_render_clipsample"));
REQUIRE(model.get() != nullptr);
// Walk cycle across 32 frames: mid-cycle pose differs from the first frame,
// so the rendered silhouette must move (loop start/end are identical).
renderSkinnedAnimation(model.get(), "animation_skinned_walk.png",
SkinnedRenderDriver::clipSample, 32);
}
TEST_CASE("animation.skinned.render.playerDriven") {
if (!ensureSkinnedAssets()) return;
eve::ref<eve::model3d::ModelData> model(
loadCesiumMan("ev_ut_animation_skinned_render_player"));
REQUIRE(model.get() != nullptr);
renderSkinnedAnimation(model.get(), "animation_skinned_player.png",
SkinnedRenderDriver::player, 60);
}
TEST_CASE("animation.skinned.render.applyToMesh") {
if (!ensureSkinnedAssets()) return;
eve::ref<eve::model3d::ModelData> model(
loadCesiumMan("ev_ut_animation_skinned_render_apply"));
REQUIRE(model.get() != nullptr);
const int meshIndex = findFirstSkinnedMesh(model.get());
REQUIRE(meshIndex >= 0);
const aiMesh *ai = model->getMesh(meshIndex);
REQUIRE(ai != nullptr);
REQUIRE(ai->mNumVertices > 0u);
REQUIRE(ai->mNumFaces > 0u);
const int vertexCount = static_cast<int>(ai->mNumVertices);
std::vector<float> pos, nrm, uv;
pos.reserve(size_t(vertexCount) * 3u);
for (int v = 0; v < vertexCount; ++v) {
pos.push_back(ai->mVertices[v].x);
pos.push_back(ai->mVertices[v].y);
pos.push_back(ai->mVertices[v].z);
}
if (ai->mNormals) {
nrm.reserve(size_t(vertexCount) * 3u);
for (int v = 0; v < vertexCount; ++v) {
nrm.push_back(ai->mNormals[v].x);
nrm.push_back(ai->mNormals[v].y);
nrm.push_back(ai->mNormals[v].z);
}
}
if (ai->mTextureCoords[0]) {
uv.reserve(size_t(vertexCount) * 2u);
for (int v = 0; v < vertexCount; ++v) {
uv.push_back(ai->mTextureCoords[0][v].x);
uv.push_back(ai->mTextureCoords[0][v].y);
}
}
std::vector<uint32_t> indices;
indices.reserve(size_t(ai->mNumFaces) * 3u);
for (unsigned f = 0; f < ai->mNumFaces; ++f) {
const aiFace &face = ai->mFaces[f];
REQUIRE(face.mNumIndices == 3u);
for (unsigned k = 0; k < 3u; ++k) indices.push_back(face.mIndices[k]);
}
const int indexCount = static_cast<int>(indices.size());
Bounds b;
for (int v = 0; v < vertexCount; ++v)
b.expand(ai->mVertices[v].x, ai->mVertices[v].y, ai->mVertices[v].z);
REQUIRE(b.valid);
const float cx = b.centerX(), cy = b.centerY(), cz = b.centerZ();
const float rad = std::max(0.5f, b.radius());
eve::window::Window *win = nullptr;
Graphics *gfx = nullptr;
openGfxWindow(win, gfx);
resetScene3D();
Texture *diffuse = loadCesiumManDiffuseTexture(gfx);
Texture *tex = diffuse ? diffuse : makeSolidGray(gfx, 200);
auto *ent = Renderable3D::create();
ent->setTexture(tex);
ent->setTint(1.f, 1.f, 1.f, 1.f);
ent->meshRenderer()->visible = true;
ent->meshRenderer()->castShadow = false;
ent->meshRenderer()->receiveShadow = false;
auto *cam = Camera3D::createCamera();
cam->setTarget(cx, cy, cz);
cam->setEye(cx + rad * 0.9f, cy + rad * 0.55f, cz + rad * 1.8f);
cam->data()->nearZ = std::max(0.05f, rad * 0.01f);
cam->data()->farZ = std::max(100.f, rad * 20.f);
cam->setAmbient(0.15f, 0.15f, 0.15f);
RenderSystem3D::setDirectionalLight(
cx - (cx + rad * 0.9f), cy - (cy + rad * 0.55f) + rad * 1.2f,
cz - (cz + rad * 1.8f), 1.8f, 1.8f, 1.8f);
gfx->setScreenReadbackEnabled(true);
gfx->setBackgroundColor(Color(0.02f, 0.02f, 0.03f, 1.f));
// Mesh created once; skinned results are written back in place per frame.
Mesh *mesh = gfx->newMeshFromArrays(pos.data(), nrm.empty() ? nullptr : nrm.data(),
uv.empty() ? nullptr : uv.data(), vertexCount,
indices.data(), indexCount);
REQUIRE(mesh != nullptr);
CHECK(mesh->getVertexCount() == vertexCount);
ent->meshRenderer()->mesh = mesh;
std::unique_ptr<AnimSkeleton> skeleton(AnimImporter::loadSkeletonFromModel(model.get()));
REQUIRE(skeleton.get() != nullptr);
std::unique_ptr<AnimSkin> skin(AnimSkin::fromModel(model.get(), meshIndex, skeleton.get()));
REQUIRE(skin.get() != nullptr);
CHECK(skin->getVertexCount() == vertexCount);
std::unique_ptr<AnimClip> clip(
AnimImporter::loadClipFromModel(model.get(), skeleton.get(), 0));
REQUIRE(clip.get() != nullptr);
std::unique_ptr<AnimPlayer> player(new AnimPlayer(skeleton.get()));
player->play(clip.get());
std::vector<float> firstLuma;
float maxDelta = -1.f;
bool first = true;
for (int i = 0; i < 30; ++i) {
player->update(1.f / 30.f);
AnimPose *pose = player->getPose();
REQUIRE(pose != nullptr);
pose->computeWorld(skeleton.get());
REQUIRE(skin->applyToMesh(gfx, mesh, pose));
RenderSystem3D::render(*gfx);
RenderSystem::render(*gfx);
SDL_Event e;
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) {
win->close();
return;
}
}
SDL_Delay(16);
const auto L = captureLumaGrid(gfx);
if (first) {
firstLuma = L;
first = false;
} else {
maxDelta = std::max(maxDelta, maxLumaAbsDelta(gfx, firstLuma, L));
}
}
const auto last = captureLumaGrid(gfx);
CHECK(foregroundPixelCount(last, 0.15f) > 20);
CHECK(maxDelta > 0.01f);
savePng(gfx, "animation_skinned_apply.png");
win->close();
}
Reference in new issue View Git Blame Copy Permalink