mirror of
https://github.com/Kelsidavis/WoWee.git
synced 2026-05-11 11:33:52 +00:00
dadf72307c
46th open format — replaces AnimationData.dbc plus the hard-coded animation-id tables in M2 model loaders. Defines named animations (Stand, Walk, Run, Cast, Death, MountIdle, Fly, ...) with fallback chains, behavior tier (default / mounted / sitting / aerial / swimming), and weapon-flag bitmasks that select the correct animation variant when the model wields 1H / 2H / dual / bow / rifle / wand / etc. Cross-references with prior formats — fallbackId resolves within the same WANI catalog (graceful degradation when the requested animation is absent: Run falls back to Walk, Attack2H falls back to Attack1H). 10 weapon-flag constants + 6 behavior flags (Looped, BlendableCycle, Interruptable, MovementSync, OneShot, PreserveAtEnd). 5 behavior tiers. CLI: --gen-animations (5 essentials), --gen-animations-combat (8 weapon-typed attacks + parry + channel), --gen-animations-movement (6 locomotion anims with tier transitions). Validator catches id-uniqueness, fallback-self-loop, looped-without-duration, mutually-exclusive Looped+OneShot flags, weaponFlags=0 warning, and unresolved fallback warnings. Also extends --list-formats and --info-magic with WANI.
268 lines
8.8 KiB
C++
268 lines
8.8 KiB
C++
#include "pipeline/wowee_animations.hpp"
|
|
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <fstream>
|
|
|
|
namespace wowee {
|
|
namespace pipeline {
|
|
|
|
namespace {
|
|
|
|
constexpr char kMagic[4] = {'W', 'A', 'N', 'I'};
|
|
constexpr uint32_t kVersion = 1;
|
|
|
|
template <typename T>
|
|
void writePOD(std::ofstream& os, const T& v) {
|
|
os.write(reinterpret_cast<const char*>(&v), sizeof(T));
|
|
}
|
|
|
|
template <typename T>
|
|
bool readPOD(std::ifstream& is, T& v) {
|
|
is.read(reinterpret_cast<char*>(&v), sizeof(T));
|
|
return is.gcount() == static_cast<std::streamsize>(sizeof(T));
|
|
}
|
|
|
|
void writeStr(std::ofstream& os, const std::string& s) {
|
|
uint32_t n = static_cast<uint32_t>(s.size());
|
|
writePOD(os, n);
|
|
if (n > 0) os.write(s.data(), n);
|
|
}
|
|
|
|
bool readStr(std::ifstream& is, std::string& s) {
|
|
uint32_t n = 0;
|
|
if (!readPOD(is, n)) return false;
|
|
if (n > (1u << 20)) return false;
|
|
s.resize(n);
|
|
if (n > 0) {
|
|
is.read(s.data(), n);
|
|
if (is.gcount() != static_cast<std::streamsize>(n)) {
|
|
s.clear();
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::string normalizePath(std::string base) {
|
|
if (base.size() < 5 || base.substr(base.size() - 5) != ".wani") {
|
|
base += ".wani";
|
|
}
|
|
return base;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
const WoweeAnimation::Entry*
|
|
WoweeAnimation::findById(uint32_t animationId) const {
|
|
for (const auto& e : entries)
|
|
if (e.animationId == animationId) return &e;
|
|
return nullptr;
|
|
}
|
|
|
|
const char* WoweeAnimation::behaviorTierName(uint8_t t) {
|
|
switch (t) {
|
|
case Default: return "default";
|
|
case Mounted: return "mounted";
|
|
case Sitting: return "sitting";
|
|
case Aerial: return "aerial";
|
|
case Swimming: return "swimming";
|
|
default: return "unknown";
|
|
}
|
|
}
|
|
|
|
bool WoweeAnimationLoader::save(const WoweeAnimation& cat,
|
|
const std::string& basePath) {
|
|
std::ofstream os(normalizePath(basePath), std::ios::binary);
|
|
if (!os) return false;
|
|
os.write(kMagic, 4);
|
|
writePOD(os, kVersion);
|
|
writeStr(os, cat.name);
|
|
uint32_t entryCount = static_cast<uint32_t>(cat.entries.size());
|
|
writePOD(os, entryCount);
|
|
for (const auto& e : cat.entries) {
|
|
writePOD(os, e.animationId);
|
|
writeStr(os, e.name);
|
|
writeStr(os, e.description);
|
|
writePOD(os, e.fallbackId);
|
|
writePOD(os, e.behaviorId);
|
|
writePOD(os, e.behaviorTier);
|
|
uint8_t pad[3] = {0, 0, 0};
|
|
os.write(reinterpret_cast<const char*>(pad), 3);
|
|
writePOD(os, e.flags);
|
|
writePOD(os, e.weaponFlags);
|
|
writePOD(os, e.loopDurationMs);
|
|
}
|
|
return os.good();
|
|
}
|
|
|
|
WoweeAnimation WoweeAnimationLoader::load(const std::string& basePath) {
|
|
WoweeAnimation out;
|
|
std::ifstream is(normalizePath(basePath), std::ios::binary);
|
|
if (!is) return out;
|
|
char magic[4];
|
|
is.read(magic, 4);
|
|
if (std::memcmp(magic, kMagic, 4) != 0) return out;
|
|
uint32_t version = 0;
|
|
if (!readPOD(is, version) || version != kVersion) return out;
|
|
if (!readStr(is, out.name)) return out;
|
|
uint32_t entryCount = 0;
|
|
if (!readPOD(is, entryCount)) return out;
|
|
if (entryCount > (1u << 20)) return out;
|
|
out.entries.resize(entryCount);
|
|
for (auto& e : out.entries) {
|
|
if (!readPOD(is, e.animationId)) {
|
|
out.entries.clear(); return out;
|
|
}
|
|
if (!readStr(is, e.name) || !readStr(is, e.description)) {
|
|
out.entries.clear(); return out;
|
|
}
|
|
if (!readPOD(is, e.fallbackId) ||
|
|
!readPOD(is, e.behaviorId) ||
|
|
!readPOD(is, e.behaviorTier)) {
|
|
out.entries.clear(); return out;
|
|
}
|
|
uint8_t pad[3];
|
|
is.read(reinterpret_cast<char*>(pad), 3);
|
|
if (is.gcount() != 3) { out.entries.clear(); return out; }
|
|
if (!readPOD(is, e.flags) ||
|
|
!readPOD(is, e.weaponFlags) ||
|
|
!readPOD(is, e.loopDurationMs)) {
|
|
out.entries.clear(); return out;
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
bool WoweeAnimationLoader::exists(const std::string& basePath) {
|
|
std::ifstream is(normalizePath(basePath), std::ios::binary);
|
|
return is.good();
|
|
}
|
|
|
|
WoweeAnimation WoweeAnimationLoader::makeStarter(const std::string& catalogName) {
|
|
WoweeAnimation c;
|
|
c.name = catalogName;
|
|
auto add = [&](uint32_t id, const char* name, uint32_t fallback,
|
|
uint32_t flags, uint32_t durMs, const char* desc) {
|
|
WoweeAnimation::Entry e;
|
|
e.animationId = id; e.name = name; e.description = desc;
|
|
e.fallbackId = fallback;
|
|
e.flags = flags;
|
|
e.loopDurationMs = durMs;
|
|
e.behaviorTier = WoweeAnimation::Default;
|
|
c.entries.push_back(e);
|
|
};
|
|
// Animation IDs match the canonical WoW table.
|
|
add(0, "Stand", 0,
|
|
WoweeAnimation::kFlagLooped |
|
|
WoweeAnimation::kFlagBlendableCycle, 2000,
|
|
"Idle stance — looping default.");
|
|
add(4, "Walk", 0, // fall back to Stand
|
|
WoweeAnimation::kFlagLooped |
|
|
WoweeAnimation::kFlagMovementSync, 1000,
|
|
"Slow walk cycle — synced to movement speed.");
|
|
add(5, "Run", 4, // fall back to Walk
|
|
WoweeAnimation::kFlagLooped |
|
|
WoweeAnimation::kFlagMovementSync, 800,
|
|
"Run cycle — synced to movement speed.");
|
|
add(1, "Death", 0,
|
|
WoweeAnimation::kFlagOneShot |
|
|
WoweeAnimation::kFlagPreserveAtEnd, 2500,
|
|
"Death animation — pose preserved at end.");
|
|
add(17, "AttackUnarmed", 0,
|
|
WoweeAnimation::kFlagOneShot |
|
|
WoweeAnimation::kFlagInterruptable, 1500,
|
|
"Bare-handed melee swing.");
|
|
return c;
|
|
}
|
|
|
|
WoweeAnimation WoweeAnimationLoader::makeCombat(const std::string& catalogName) {
|
|
WoweeAnimation c;
|
|
c.name = catalogName;
|
|
auto add = [&](uint32_t id, const char* name, uint32_t fallback,
|
|
uint32_t weaponFlags, uint32_t durMs,
|
|
const char* desc) {
|
|
WoweeAnimation::Entry e;
|
|
e.animationId = id; e.name = name; e.description = desc;
|
|
e.fallbackId = fallback;
|
|
e.flags = WoweeAnimation::kFlagOneShot |
|
|
WoweeAnimation::kFlagInterruptable;
|
|
e.weaponFlags = weaponFlags;
|
|
e.loopDurationMs = durMs;
|
|
c.entries.push_back(e);
|
|
};
|
|
add(17, "Attack1H", 0,
|
|
WoweeAnimation::kWeapon1HMelee, 1500,
|
|
"1H melee swing.");
|
|
add(18, "Attack2H", 17, // fall back to Attack1H
|
|
WoweeAnimation::kWeapon2HMelee, 2000,
|
|
"2H melee swing — slower wind-up.");
|
|
add(19, "AttackDualWield", 17,
|
|
WoweeAnimation::kWeaponDualWield, 1200,
|
|
"Dual-wield alternating swings.");
|
|
add(40, "AttackBow", 0,
|
|
WoweeAnimation::kWeaponBow, 1800,
|
|
"Bow draw + release.");
|
|
add(41, "AttackRifle", 40,
|
|
WoweeAnimation::kWeaponRifle, 1500,
|
|
"Rifle shoulder + fire.");
|
|
add(46, "AttackThrown", 0,
|
|
WoweeAnimation::kWeaponAny, 1000,
|
|
"Thrown weapon over-arm release.");
|
|
add(53, "Parry", 0,
|
|
WoweeAnimation::kWeapon1HMelee |
|
|
WoweeAnimation::kWeapon2HMelee, 600,
|
|
"Defensive weapon parry.");
|
|
add(54, "ChannelCast", 0,
|
|
WoweeAnimation::kWeaponAny, 3000,
|
|
"Channeled spell cast — looping arms-out.");
|
|
return c;
|
|
}
|
|
|
|
WoweeAnimation WoweeAnimationLoader::makeMovement(const std::string& catalogName) {
|
|
WoweeAnimation c;
|
|
c.name = catalogName;
|
|
auto add = [&](uint32_t id, const char* name, uint32_t fallback,
|
|
uint8_t tier, uint32_t flags, uint32_t durMs,
|
|
const char* desc) {
|
|
WoweeAnimation::Entry e;
|
|
e.animationId = id; e.name = name; e.description = desc;
|
|
e.fallbackId = fallback;
|
|
e.behaviorTier = tier;
|
|
e.flags = flags;
|
|
e.loopDurationMs = durMs;
|
|
c.entries.push_back(e);
|
|
};
|
|
add(4, "Walk", 0,
|
|
WoweeAnimation::Default,
|
|
WoweeAnimation::kFlagLooped |
|
|
WoweeAnimation::kFlagMovementSync, 1000,
|
|
"Walk cycle (default tier).");
|
|
add(5, "Run", 4,
|
|
WoweeAnimation::Default,
|
|
WoweeAnimation::kFlagLooped |
|
|
WoweeAnimation::kFlagMovementSync, 800,
|
|
"Run cycle.");
|
|
add(7, "Sprint", 5,
|
|
WoweeAnimation::Default,
|
|
WoweeAnimation::kFlagLooped, 600,
|
|
"Sprint — boosted run.");
|
|
add(8, "Swim", 4,
|
|
WoweeAnimation::Swimming,
|
|
WoweeAnimation::kFlagLooped |
|
|
WoweeAnimation::kFlagMovementSync, 1200,
|
|
"Underwater swim cycle.");
|
|
add(91, "MountIdle", 0,
|
|
WoweeAnimation::Mounted,
|
|
WoweeAnimation::kFlagLooped, 2500,
|
|
"Sitting on a mount, holding the reins.");
|
|
add(132, "Fly", 5,
|
|
WoweeAnimation::Aerial,
|
|
WoweeAnimation::kFlagLooped |
|
|
WoweeAnimation::kFlagMovementSync, 1000,
|
|
"Flying with wings extended.");
|
|
return c;
|
|
}
|
|
|
|
} // namespace pipeline
|
|
} // namespace wowee
|