132 lines
4.9 KiB
C++
132 lines
4.9 KiB
C++
#pragma once
|
|
|
|
#include <godot_cpp/classes/node3d.hpp>
|
|
#include <godot_cpp/variant/dictionary.hpp>
|
|
#include <godot_cpp/variant/node_path.hpp>
|
|
#include <godot_cpp/variant/string.hpp>
|
|
#include <godot_cpp/variant/vector3.hpp>
|
|
|
|
#include <gr2/gr2.h>
|
|
#include <msa.h>
|
|
|
|
#include <optional>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
namespace mtgodot {
|
|
|
|
class Metin2Model;
|
|
|
|
// Drives a Metin2Model each frame by sampling a (possibly separate) animation
|
|
// .gr2 with libgr2, then skinning it with the resulting matrices:
|
|
//
|
|
// sample_pose(model.skeleton, anim, t) -> world[i], skin[i]
|
|
// skin[i] = inverse_world[i] * world[i] (gr2 deformer matrix per bone)
|
|
//
|
|
// The skinning itself is done in Metin2Model (NOT via Skeleton3D — Godot's
|
|
// built-in skinning orthonormalizes the bone matrix and drops the shear Granny
|
|
// bakes onto some rig bones; see docs/MIDREVIEW.md §4):
|
|
// - default : cpu_skin(skin[]) — CPU LBS, ArrayMesh rebuilt/frame
|
|
// - MTGODOT_GPUSKIN=1 : gpu_skin(skin[]) — full 4x3 matrices in a float
|
|
// texture, LBS in the SRC_SKIN vertex shader
|
|
class Metin2AnimPlayer : public godot::Node3D {
|
|
GDCLASS(Metin2AnimPlayer, godot::Node3D)
|
|
|
|
public:
|
|
Metin2AnimPlayer();
|
|
~Metin2AnimPlayer() override;
|
|
|
|
void _ready() override;
|
|
void _process(double delta) override;
|
|
|
|
void set_anim_path(const godot::String &p);
|
|
godot::String get_anim_path() const { return anim_path; }
|
|
|
|
void set_model_path(const godot::NodePath &p);
|
|
godot::NodePath get_model_path() const { return model_path; }
|
|
|
|
void set_playing(bool v) { playing = v; }
|
|
bool get_playing() const { return playing; }
|
|
void set_loop(bool v) { loop = v; }
|
|
bool get_loop() const { return loop; }
|
|
|
|
void set_time_scale(double s) { time_scale = s; }
|
|
double get_time_scale() const { return time_scale; }
|
|
|
|
// Crossfade duration (s) applied when anim_path changes while a clip is
|
|
// already playing (PARITY §2.9). 0 = hard cut (old behaviour).
|
|
void set_blend_time(double s) { blend_time = s < 0.0 ? 0.0 : s; }
|
|
double get_blend_time() const { return blend_time; }
|
|
|
|
void set_time(double t);
|
|
double get_time() const { return time; }
|
|
|
|
double get_duration() const { return duration; }
|
|
void reload();
|
|
godot::String get_info() const { return last_info; }
|
|
|
|
// .msa metadata (empty / zero when anim_path is a raw .gr2).
|
|
godot::Vector3 get_accumulation() const { return accumulation; }
|
|
godot::Array get_events() const; // [{type,start_time,effect,sound,pos}, ...]
|
|
// Full affine pose in model GR2 coordinates, shared by CPU/GPU and blending.
|
|
godot::Dictionary get_effect_bone_pose(const godot::String &bone);
|
|
godot::Dictionary get_loop_data() const;
|
|
godot::Dictionary get_motion_data() const; // {duration,next_combo,attack_start_time,...}
|
|
static godot::Dictionary get_clip_cache_stats();
|
|
static void clear_clip_cache();
|
|
|
|
// CLIENT-GAP §3.5 — parse the PC combo tables out of playersettingmodule.py
|
|
// (chrmgr.ReserveComboAttackNew / RegisterComboAttackNew → CRaceData). Returns
|
|
// { class_idx:int -> { combo_key:int -> PackedInt32Array(段号 14..21) } }
|
|
// with class_idx 0=warrior 1=assassin 2=sura 3=shaman and
|
|
// combo_key = (motion_mode << 16) | combo_type. Empty Dictionary on failure.
|
|
static godot::Dictionary parse_combo_tables(const godot::String &py_path);
|
|
// (motion_mode << 16) | combo_type — mirrors RaceData.h MAKE_COMBO_KEY.
|
|
static int make_combo_key(int motion_mode, int combo_type);
|
|
|
|
// NaN-scan every animation in anim_path across [0,dur]; returns a report string.
|
|
godot::String selfcheck(int samples = 24);
|
|
|
|
protected:
|
|
static void _bind_methods();
|
|
|
|
private:
|
|
void emit_motion_event(const fmt::MotionEvent &ev);
|
|
godot::String anim_path;
|
|
godot::NodePath model_path;
|
|
bool playing = true;
|
|
bool loop = true; // whole-clip playback mode; independent from .msa LoopData
|
|
double time_scale = 1.0;
|
|
double time = 0.0;
|
|
double duration = 0.0;
|
|
godot::String last_info;
|
|
|
|
std::shared_ptr<const gr2::File> anim_file;
|
|
std::vector<gr2::Mat4> world_buf;
|
|
std::vector<gr2::Mat4> skin_buf;
|
|
|
|
// Crossfade state: the outgoing clip is kept and sampled at a frozen time,
|
|
// its pose blended into the incoming clip for `blend_time` seconds.
|
|
double blend_time = 0.15;
|
|
std::shared_ptr<const gr2::File> prev_anim_file;
|
|
double prev_anim_time = 0.0;
|
|
double prev_anim_duration = 0.0;
|
|
bool prev_anim_loop = true;
|
|
double blend_elapsed = 0.0;
|
|
std::vector<gr2::Mat4> prev_world_buf, prev_skin_buf, blend_world_buf;
|
|
|
|
godot::Vector3 accumulation; // .msa Accumulation (root motion)
|
|
std::vector<fmt::MotionEvent> events;
|
|
fmt::Msa msa_metadata;
|
|
int next_event = 0; // index into `events`, for _process dispatch
|
|
double prev_time = 0.0;
|
|
|
|
Metin2Model *resolve_model() const;
|
|
void apply_pose(double t);
|
|
void dispatch_events(double from, double to);
|
|
// .msa path -> real motion .gr2 path; passes plain .gr2 paths through.
|
|
static godot::String resolve_anim_gr2(const godot::String &spec, const fmt::Msa &metadata);
|
|
};
|
|
|
|
} // namespace mtgodot
|