Max/korenkonder_ReDIVA
1
0
Fork 0
mirror of https://github.com/korenkonder/ReDIVA.git synced 2026-10-04 12:47:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
64091ff80d8a0d908d55df61028c4cfeba712747
korenkonder_ReDIVA/src/KKdLib/mot.cpp
T
korenkonder 64091ff80d Formatting
2023-06-18 16:28:24 +03:00

1045 lines
36 KiB
C++
Raw Blame History

/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#include "mot.hpp"
#include "f2/struct.hpp"
#include "io/path.hpp"
#include "io/memory_stream.hpp"
#include "half_t.hpp"
#include "hash.hpp"
#include "str_utils.hpp"
struct mot_header_classic {
uint32_t key_set_info_offset;
uint32_t key_set_types_offset;
uint32_t key_set_offset;
uint32_t bone_info_offset;
};
struct mot_header_modern {
uint32_t hash;
int64_t name_offset;
int64_t key_set_info_offset;
int64_t key_set_types_offset;
int64_t key_set_offset;
int64_t bone_info_offset;
int64_t bone_hash_offset;
int32_t bone_info_count;
};
static void mot_classic_read_inner(mot_set* ms, prj::shared_ptr<prj::stack_allocator>& alloc, stream& s);
static void mot_classic_write_inner(mot_set* ms, stream& s);
static void mot_modern_read_inner(mot_set* ms, prj::shared_ptr<prj::stack_allocator>& alloc, stream& s);
static void mot_modern_write_inner(mot_set* ms, stream& s);
static const char* mot_move_data_string(const char* str,
prj::shared_ptr<prj::stack_allocator>& alloc);
static void mot_data_move_data(mot_data* mot_dst, const mot_data* mot_src,
prj::shared_ptr<prj::stack_allocator> alloc);
static const char* mot_read_utf8_string_null_terminated_offset(
prj::shared_ptr<prj::stack_allocator>& alloc, stream& s, int64_t offset);
mot_bone_info::mot_bone_info() : name(), index() {
}
mot_key_set_data::mot_key_set_data() : type(), frames(), values(), keys_count(), data_type() {
}
mot_data::mot_data() : info(), frame_count(), bone_info_count(), murmurhash(),
div_frames(), div_count(), name(), bone_info_array(), key_set_array() {
}
mot_set::mot_set() : ready(), modern(), big_endian(), is_x(), name(), mot_data(), mot_num() {
}
void mot_set::move_data(mot_set* set_src, prj::shared_ptr<prj::stack_allocator> alloc) {
if (!set_src->ready) {
ready = false;
modern = false;
big_endian = false;
is_x = false;
return;
}
ready = true;
modern = set_src->modern;
big_endian = set_src->big_endian;
is_x = set_src->is_x;
name = mot_move_data_string(set_src->name, alloc);
uint32_t mot_num = set_src->mot_num;
::mot_data* mot_data_src = set_src->mot_data;
::mot_data* mot_data_dst = alloc->allocate<::mot_data>(mot_num);
for (uint32_t i = 0; i < mot_num; i++)
mot_data_move_data(&mot_data_dst[i], &mot_data_src[i], alloc);
this->mot_data = mot_data_dst;
this->mot_num = mot_num;
}
void mot_set::pack_file(void** data, size_t* size) {
if (!data || !size || !ready)
return;
memory_stream s;
s.open();
if (!modern)
mot_classic_write_inner(this, s);
else
mot_modern_write_inner(this, s);
s.copy(data, size);
}
void mot_set::unpack_file(prj::shared_ptr<prj::stack_allocator> alloc, const void* data, size_t size, bool modern) {
if (!data || !size)
return;
memory_stream s;
s.open(data, size);
if (!modern)
mot_classic_read_inner(this, alloc, s);
else
mot_modern_read_inner(this, alloc, s);
}
static float_t interpolate_mot_value(float_t p1, float_t p2,
float_t t1, float_t t2, float_t f1, float_t f2, float_t f) {
float_t df = f - f1;
float_t t = df / (f2 - f1);
float_t t_1 = t - 1.0f;
return (t_1 * t1 + t * t2) * t_1 * df
+ (t * 2.0f - 3.0f) * (t * t) * (p1 - p2) + p1;
}
static void interpolate_mot_reverse_value(float_t* arr, size_t length,
float_t& t1, float_t& t2, size_t f1, size_t f2, size_t f) {
vec2 t = vec2(
(float_t)(int64_t)(f - f1 + 0),
(float_t)(int64_t)(f - f1 + 1)
) / (float_t)(int64_t)(f2 - f1);
vec2 t_1 = t - 1.0f;
vec2 t1_t2 = *(vec2*)&arr[f] - arr[f1] - (t * 2.0f - 3.0f) * (t * t) * (arr[f1] - arr[f2]);
t1_t2 /= t_1 * t;
t1 = -t1_t2.x * t.y + t1_t2.y * t.x;
t2 = t1_t2.x * t_1.y - t1_t2.y * t_1.x;
}
inline static void mot_set_add_key(uint16_t frame, float_t v, float_t t,
std::vector<uint16_t>& frames, std::vector<float_t>& values) {
frames.push_back(frame);
values.push_back(v);
values.push_back(t);
}
inline static float_t mot_set_add_key(bool has_error, float_t* a, int32_t frame,
size_t i, float_t t1, float_t t2, float_t t2_old,
std::vector<uint16_t>& frames, std::vector<float_t>& values, bool fast = false) {
if (has_error) {
mot_set_add_key((uint16_t)frame, a[0], t2_old, frames, values);
if (fabsf(t2) != 0.0f)
mot_set_add_key((uint16_t)frame, a[0], 0.0f, frames, values);
for (size_t j = 1; j < i; j++)
mot_set_add_key((uint16_t)(frame + j), a[j], 0.0f, frames, values);
return 0.0f;
}
else {
const float_t reverse_bias = fast ? 0.0001f : 0.00001f;
if (fabsf(t1 - t2_old) > reverse_bias) {
mot_set_add_key((uint16_t)frame, a[0], t2_old, frames, values);
mot_set_add_key((uint16_t)frame, a[0], t1, frames, values);
}
else
mot_set_add_key((uint16_t)frame, a[0], (t1 + t2_old) * 0.5f, frames, values);
return t2;
}
}
mot_key_set_type mot_set::fit_keys_into_curve(std::vector<float_t>& values_src,
std::vector<uint16_t>& frames, std::vector<float_t>& values, bool fast) {
size_t count = values_src.size();
if (!count)
return MOT_KEY_SET_NONE;
else if (count == 1) {
if (values_src[0] != 0.0f) {
values.push_back(values_src[0]);
return MOT_KEY_SET_STATIC;
}
else
return MOT_KEY_SET_NONE;
}
else {
float_t val = values_src.data()[0];
float_t* arr = &values_src.data()[1];
for (size_t i = count - 1; i; i--)
if (val != *arr++)
break;
if (arr == values_src.data() + count)
if (values_src[0] != 0.0f) {
values.push_back(values_src[0]);
return MOT_KEY_SET_STATIC;
}
else
return MOT_KEY_SET_NONE;
}
float_t* arr = values_src.data();
const float_t reverse_bias = 0.0001f;
const int32_t reverse_min_count = 4;
mot_set_add_key(0, arr[0], 0.0f, frames, values);
float_t* a = arr;
size_t left_count = count;
int32_t frame = 0;
int32_t prev_frame = 0;
float_t t2_old = 0.0f;
while (left_count > 0) {
if (left_count < reverse_min_count) {
if (left_count > 1)
t2_old = mot_set_add_key(true, a, frame,
left_count - 1, 0.0f, 0.0f, t2_old, frames, values);
break;
}
size_t i = 0;
size_t i_prev = 0;
float_t t1 = 0.0f;
float_t t2 = 0.0f;
float_t t1_prev = 0.0f;
float_t t2_prev = 0.0f;
bool has_prev_succeded = false;
bool has_error = false;
bool has_prev_error = false;
bool constant_prev = false;
int32_t c = 0;
for (i = reverse_min_count - 1, i_prev = i; i < left_count; i++) {
bool constant = true;
for (size_t j = 1; j <= i; j++)
if (memcmp(&a[0], &a[j], sizeof(float_t))) {
constant = false;
break;
}
if (!fast) {
double_t t1_accum = 0.0;
double_t t2_accum = 0.0;
for (size_t j = 1; j < i - 1; j++) {
float_t t1 = 0.0f;
float_t t2 = 0.0f;
interpolate_mot_reverse_value(a, left_count, t1, t2, 0, i, j);
t1_accum += t1;
t2_accum += t2;
}
t1 = (float_t)(t1_accum / (double_t)(i - 2));
t2 = (float_t)(t2_accum / (double_t)(i - 2));
}
else
interpolate_mot_reverse_value(a, left_count, t1, t2, 0, i, 1);
has_error = false;
for (size_t j = 1; j < i; j++) {
float_t val = interpolate_mot_value(a[0], a[i], t1, t2, 0.0f, (float_t)i, (float_t)j);
if (fabsf(val - a[j]) > reverse_bias) {
has_error = true;
break;
}
}
if (fabsf(t1) > 0.5f || fabsf(t2) > 0.5f)
has_error = true;
if (!has_error) {
i_prev = i;
t1_prev = t1;
t2_prev = t2;
constant_prev = constant;
has_prev_error = false;
has_prev_succeded = true;
if (i < left_count)
continue;
}
if (has_prev_succeded) {
i = i_prev;
t1 = t1_prev;
t2 = t2_prev;
constant = constant_prev;
has_error = false;
has_prev_succeded = false;
}
if (!has_error) {
if (constant) {
t1 = 0.0f;
t2 = 0.0f;
}
c = (int32_t)i;
t2_old = mot_set_add_key(has_error, a, frame, c, t1, t2, t2_old, frames, values, fast);
has_prev_error = false;
break;
}
has_prev_error = true;
}
if (has_prev_succeded) {
t2_old = mot_set_add_key(has_error, a, frame, c, t1_prev, t2_prev, t2_old, frames, values, fast);
c = (int32_t)i;
}
else if (has_prev_error) {
t2_old = mot_set_add_key(has_error, a, frame, c, t1, t2, t2_old, frames, values, fast);
c = 1;
}
prev_frame = frame;
frame += c;
a += c;
left_count -= c;
}
if (frames.back() != (uint16_t)(count - 1))
mot_set_add_key((uint16_t)(count - 1), arr[count - 1], t2_old, frames, values);
mot_set_add_key((uint16_t)(count - 1), arr[count - 1], 0.0f, frames, values);
count = frames.size();
arr = values.data();
for (size_t i = count; i; i--, arr += 2)
if (arr[1] != 0.0f)
break;
if (arr != values.data() + count)
return MOT_KEY_SET_HERMITE_TANGENT;
float_t* arr_src = values.data();
float_t* arr_dst = values.data();
for (size_t i = count; i; i--) {
*arr_dst = *arr_src;
arr_src++;
arr_dst += 2;
}
values.resize(count);
return MOT_KEY_SET_HERMITE;
}
static void mot_classic_read_inner(mot_set* ms, prj::shared_ptr<prj::stack_allocator>& alloc, stream& s) {
size_t count = 0;
while (s.read_uint64_t() != 0) {
s.read_uint64_t();
count++;
}
if (!count) {
ms->ready = false;
ms->modern = false;
ms->big_endian = false;
ms->is_x = false;
return;
}
uint32_t mot_num = (uint32_t)count;
::mot_data* mot_data = alloc->allocate<::mot_data>(mot_num);
ms->mot_data = mot_data;
ms->mot_num = mot_num;
s.set_position(0x00, SEEK_SET);
mot_header_classic* mh = force_malloc_s(mot_header_classic, mot_num);
for (uint32_t i = 0; i < mot_num; i++) {
mh[i].key_set_info_offset = s.read_uint32_t();
mh[i].key_set_types_offset = s.read_uint32_t();
mh[i].key_set_offset = s.read_uint32_t();
mh[i].bone_info_offset = s.read_uint32_t();
}
for (size_t i = 0; i < mot_num; i++) {
::mot_data* m = &ms->mot_data[i];
s.set_position(mh[i].bone_info_offset, SEEK_SET);
uint32_t bone_info_count = 0;
s.read_uint16_t();
do
bone_info_count++;
while (s.read_uint16_t() != 0 && s.get_position() < s.length);
m->bone_info_count = bone_info_count;
mot_bone_info* bone_info_array = alloc->allocate<mot_bone_info>(bone_info_count);
m->bone_info_array = bone_info_array;
s.set_position(mh[i].bone_info_offset, SEEK_SET);
for (size_t j = 0; j < m->bone_info_count; j++)
bone_info_array[j].index = s.read_uint16_t();
s.set_position(mh[i].key_set_info_offset, SEEK_SET);
m->info = s.read_uint16_t();
m->frame_count = s.read_uint16_t();
uint32_t key_set_count = m->key_set_count;
mot_key_set_data* key_set_array = alloc->allocate<mot_key_set_data>(key_set_count);
m->key_set_array = key_set_array;
s.set_position(mh[i].key_set_types_offset, SEEK_SET);
for (int32_t j = 0, b = 0; j < m->key_set_count; j++) {
if (!(j % 8))
b = s.read_uint16_t();
key_set_array[j].type = (mot_key_set_type)((b >> (j % 8 * 2)) & 0x03);
}
s.set_position(mh[i].key_set_offset, SEEK_SET);
for (int32_t j = 0; j < m->key_set_count; j++) {
mot_key_set_data* key_set = &key_set_array[j];
if (key_set->type == MOT_KEY_SET_NONE) {
key_set->keys_count = 0;
key_set->frames = 0;
key_set->values = 0;
}
else if (key_set->type == MOT_KEY_SET_STATIC) {
key_set->keys_count = 1;
key_set->frames = 0;
key_set->values = alloc->allocate<float_t>(1);
key_set->values[0] = s.read_float_t();
}
else {
bool has_tangents = key_set->type != MOT_KEY_SET_HERMITE;
uint16_t keys_count = s.read_uint16_t();
key_set->keys_count = keys_count;
uint16_t* frames = alloc->allocate<uint16_t>(keys_count);
float_t* values = alloc->allocate<float_t>(has_tangents ? keys_count * 2ULL : keys_count);
key_set->frames = frames;
key_set->values = values;
s.read(frames, sizeof(uint16_t) * keys_count);
s.align_read(0x04);
if (!has_tangents)
s.read(values, sizeof(float_t) * keys_count);
else
s.read(values, sizeof(float_t) * keys_count * 2ULL);
}
}
}
free_def(mh);
ms->ready = true;
ms->modern = false;
ms->big_endian = false;
ms->is_x = false;
}
static void mot_classic_write_inner(mot_set* ms, stream& s) {
::mot_data* mot_data = ms->mot_data;
uint32_t mot_num = ms->mot_num;
s.set_position(mot_num * 0x10ULL + 0x10, SEEK_SET);
mot_header_classic* mh = force_malloc_s(mot_header_classic, mot_num);
for (size_t i = 0; i < mot_num; i++) {
::mot_data* m = &mot_data[i];
mh[i].key_set_info_offset = (uint32_t)s.get_position();
s.write_uint16_t(m->info);
s.write_uint16_t(m->frame_count);
uint16_t key_set_count = m->key_set_count;
mot_key_set_data* key_set_array = m->key_set_array;
mh[i].key_set_types_offset = (uint32_t)s.get_position();
uint16_t key_set_type_buf = 0;
for (uint32_t j = 0; j < key_set_count; j++) {
mot_key_set_type type = key_set_array[j].type;
if (type == MOT_KEY_SET_STATIC && key_set_array[j].values[0] == 0.0f)
type = MOT_KEY_SET_NONE;
key_set_type_buf |= ((uint16_t)type & 0x03) << (j % 8 * 2);
if (j % 8 == 7) {
s.write_uint16_t(key_set_type_buf);
key_set_type_buf = 0;
}
}
if (m->key_set_count % 8 != 0)
s.write_uint16_t(key_set_type_buf);
s.align_write(0x04);
mh[i].key_set_offset = (uint32_t)s.get_position();
for (uint32_t j = 0; j < key_set_count; j++) {
mot_key_set_data* key_set = &key_set_array[j];
if (key_set->type == MOT_KEY_SET_STATIC) {
if (key_set->values[0] != 0.0f)
s.write_float_t(key_set->values[0]);
}
else if (key_set->type != MOT_KEY_SET_NONE) {
bool has_tangents = key_set->type != MOT_KEY_SET_HERMITE;
uint16_t keys_count = key_set->keys_count;
s.write_uint16_t(keys_count);
uint16_t* frames = key_set->frames;
s.write(frames, sizeof(uint16_t) * keys_count);
s.align_write(0x04);
float_t* values = key_set->values;
if (!has_tangents)
s.write(values, sizeof(float_t) * keys_count);
else
s.write(values, sizeof(float_t) * keys_count * 2ULL);
}
}
s.align_write(0x04);
uint16_t bone_info_count = m->bone_info_count;
mot_bone_info* bone_info_array = m->bone_info_array;
mh[i].bone_info_offset = (uint32_t)s.get_position();
if (m->bone_info_count)
for (int32_t j = 0; j < bone_info_count; j++)
s.write_uint16_t(bone_info_array[j].index);
else
s.write_uint16_t(0x00);
s.write_uint16_t(0x00);
}
s.align_write(0x10);
s.set_position(0x00, SEEK_SET);
for (size_t i = 0; i < mot_num; i++) {
s.write_uint32_t(mh[i].key_set_info_offset);
s.write_uint32_t(mh[i].key_set_types_offset);
s.write_uint32_t(mh[i].key_set_offset);
s.write_uint32_t(mh[i].bone_info_offset);
}
free_def(mh);
}
static void mot_modern_read_inner(mot_set* ms, prj::shared_ptr<prj::stack_allocator>& alloc, stream& s) {
f2_struct st;
st.read(s);
if (st.header.signature != reverse_endianness_uint32_t('MOTC') || !st.data.size()) {
ms->ready = false;
ms->modern = false;
ms->big_endian = false;
ms->is_x = false;
return;
}
uint32_t header_length = st.header.length;
bool big_endian = st.header.use_big_endian;
bool is_x = st.pof.shift_x;
memory_stream s_motc;
s_motc.open(st.data);
s_motc.big_endian = big_endian;
::mot_data* mot_data = alloc->allocate<::mot_data>();
ms->mot_data = mot_data;
ms->mot_num = 1;
s_motc.set_position(0x00, SEEK_SET);
mot_header_modern mh = {};
if (!is_x) {
mh.hash = (uint32_t)s_motc.read_uint64_t_reverse_endianness();
mh.name_offset = s_motc.read_offset_f2(header_length);
mh.key_set_info_offset = s_motc.read_offset_f2(header_length);
mh.key_set_types_offset = s_motc.read_offset_f2(header_length);
mh.key_set_offset = s_motc.read_offset_f2(header_length);
mh.bone_info_offset = s_motc.read_offset_f2(header_length);
mh.bone_hash_offset = s_motc.read_offset_f2(header_length);
mh.bone_info_count = s_motc.read_int32_t_reverse_endianness();
}
else {
mh.hash = (uint32_t)s_motc.read_uint64_t_reverse_endianness();
mh.name_offset = s_motc.read_offset_x();
mh.key_set_info_offset = s_motc.read_offset_x();
mh.key_set_types_offset = s_motc.read_offset_x();
mh.key_set_offset = s_motc.read_offset_x();
mh.bone_info_offset = s_motc.read_offset_x();
mh.bone_hash_offset = s_motc.read_offset_x();
mh.bone_info_count = s_motc.read_int32_t_reverse_endianness();
}
::mot_data* m = &mot_data[0];
m->div_frames = s_motc.read_uint16_t_reverse_endianness();
m->div_count = s_motc.read_uint8_t();
m->name = mot_read_utf8_string_null_terminated_offset(alloc, s_motc, mh.name_offset);
uint32_t bone_info_count = mh.bone_info_count;
mot_bone_info* bone_info_array = alloc->allocate<mot_bone_info>(bone_info_count);
m->bone_info_array = bone_info_array;
m->bone_info_count = bone_info_count;
s_motc.set_position(mh.bone_info_offset, SEEK_SET);
if (!is_x)
for (size_t j = 0; j < mh.bone_info_count; j++)
bone_info_array[j].name = mot_read_utf8_string_null_terminated_offset(alloc,
s_motc, s_motc.read_offset_f2(header_length));
else
for (size_t j = 0; j < mh.bone_info_count; j++)
bone_info_array[j].name = mot_read_utf8_string_null_terminated_offset(alloc,
s_motc, s_motc.read_offset_x());
s_motc.set_position(mh.bone_hash_offset, SEEK_SET);
for (size_t j = 0; j < mh.bone_info_count; j++)
s_motc.read_uint64_t_reverse_endianness();
s_motc.set_position(mh.key_set_info_offset, SEEK_SET);
m->info = s_motc.read_uint16_t_reverse_endianness();
m->frame_count = s_motc.read_uint16_t_reverse_endianness();
uint32_t key_set_count = m->key_set_count;
mot_key_set_data* key_set_array = alloc->allocate<mot_key_set_data>(key_set_count);
m->key_set_array = key_set_array;
s_motc.set_position(mh.key_set_types_offset, SEEK_SET);
for (uint32_t j = 0, b = 0; j < key_set_count; j++) {
if (!(j % 8))
b = s_motc.read_uint16_t_reverse_endianness();
key_set_array[j].type = (mot_key_set_type)((b >> (j % 8 * 2)) & 0x03);
}
s_motc.set_position(mh.key_set_offset, SEEK_SET);
for (uint32_t j = 0; j < key_set_count; j++) {
mot_key_set_data* key_set = &key_set_array[j];
if (key_set->type == MOT_KEY_SET_NONE) {
key_set->keys_count = 0;
key_set->frames = 0;
key_set->values = 0;
}
else if (key_set->type == MOT_KEY_SET_STATIC) {
key_set->keys_count = 1;
key_set->frames = 0;
key_set->values = alloc->allocate<float_t>(1);
key_set->values[0] = s.read_float_t();
}
else {
bool has_tangents = key_set->type != MOT_KEY_SET_HERMITE;
uint16_t keys_count = s_motc.read_uint16_t_reverse_endianness();
mot_key_set_data_type data_type
= (mot_key_set_data_type)s_motc.read_uint16_t_reverse_endianness();
key_set->keys_count = keys_count;
key_set->data_type = data_type;
int16_t* frames = alloc->allocate<int16_t>(keys_count);
float_t* values = alloc->allocate<float_t>(has_tangents ? keys_count * 2ULL : keys_count);
key_set->frames = (uint16_t*)frames;
key_set->values = values;
uint8_t step = has_tangents ? 2 : 1;
if (has_tangents) {
float_t* values = &key_set->values[1];
for (int32_t k = 0; k < keys_count; k++, values += step)
*values = s_motc.read_float_t_reverse_endianness();
}
if (data_type == MOT_KEY_SET_DATA_F16)
for (int32_t k = 0; k < keys_count; k++, values += step)
*values = half_to_float(s_motc.read_half_t_reverse_endianness());
else
for (int32_t k = 0; k < keys_count; k++, values += step)
*values = s_motc.read_float_t_reverse_endianness();
s_motc.align_read(0x04);
for (int32_t k = 0; k < keys_count; k++)
*frames++ = s_motc.read_int16_t_reverse_endianness();
s_motc.align_read(0x04);
}
}
m->murmurhash = st.header.murmurhash;
ms->ready = true;
ms->modern = true;
ms->big_endian = big_endian;
ms->is_x = is_x;
}
static void mot_modern_write_inner(mot_set* ms, stream& s) {
bool big_endian = ms->big_endian;
bool is_x = ms->is_x;
::mot_data* mot_data = ms->mot_data;
uint32_t mot_num = ms->mot_num;
memory_stream s_motc;
s_motc.open();
s_motc.big_endian = big_endian;
uint32_t o;
enrs e;
enrs_entry ee;
pof pof;
uint32_t murmurhash = 0;
if (mot_num > 0) {
mot_header_modern mh = {};
::mot_data* m = &mot_data[0];
if (!is_x) {
ee = { 0, 3, 48, 1 };
ee.append(0, 1, ENRS_QWORD);
ee.append(0, 7, ENRS_DWORD);
ee.append(0, 1, ENRS_WORD);
e.vec.push_back(ee);
o = 48;
}
else {
ee = { 0, 3, 64, 1 };
ee.append(0, 7, ENRS_QWORD);
ee.append(0, 1, ENRS_DWORD);
ee.append(0, 1, ENRS_WORD);
e.vec.push_back(ee);
o = 64;
}
ee = { o, 1, 4, 1 };
ee.append(0, 2, ENRS_WORD);
e.vec.push_back(ee);
o = 4;
uint32_t key_set_count = m->key_set_count;
uint16_t bone_info_count = m->bone_info_count;
mot_key_set_data* key_set_array = m->key_set_array;
ee = { o, 1, (uint32_t)((key_set_count + 3ULL) / 4), 1 };
ee.append(0, (uint32_t)((key_set_count + 7ULL) / 8), ENRS_WORD);
e.vec.push_back(ee);
o = (key_set_count + 3) / 4;
o = align_val(o, 4);
for (uint32_t j = 0; j < key_set_count; j++) {
mot_key_set_data* key_set = &key_set_array[j];
if (key_set->type == MOT_KEY_SET_STATIC) {
if (key_set->values[0] != 0.0f) {
ee = { o, 1, 4, 1 };
ee.append(0, 1, ENRS_DWORD);
e.vec.push_back(ee);
o = 4;
}
}
else if (key_set->type != MOT_KEY_SET_NONE) {
bool has_tangents = key_set->type != MOT_KEY_SET_HERMITE;
if (has_tangents)
ee = { o, 1, 4, 1 };
else
ee = { o, 1, 3, 1 };
uint16_t keys_count = key_set->keys_count;
mot_key_set_data_type data_type = key_set->data_type;
o = 4;
if (has_tangents)
o += keys_count * 4;
if (data_type == MOT_KEY_SET_DATA_F16)
o += align_val(keys_count * 2, 4);
else
o += keys_count * 4;
o += align_val(keys_count * 2, 4);
o = align_val(o, 4);
ee.size = o;
ee.append(0, 2, ENRS_WORD);
if (has_tangents)
ee.append(0, keys_count, ENRS_DWORD);
if (data_type == MOT_KEY_SET_DATA_F16) {
ee.append(0, keys_count, ENRS_WORD);
ee.append(keys_count % 2 == 1 ? 2u : 0u, keys_count, ENRS_WORD);
}
else {
ee.append(0, keys_count, ENRS_DWORD);
ee.append(0, keys_count, ENRS_WORD);
}
e.vec.push_back(ee);
}
}
o = align_val(o, 16);
if (!is_x) {
ee = { o, 1, (uint32_t)(bone_info_count * 4ULL), 1 };
ee.append(0, bone_info_count, ENRS_DWORD);
e.vec.push_back(ee);
o = m->bone_info_count * 4;
}
else {
ee = { o, 1, (uint32_t)(bone_info_count * 8ULL), 1 };
ee.append(0, bone_info_count, ENRS_QWORD);
e.vec.push_back(ee);
o = m->bone_info_count * 8;
}
o = align_val(o, 16);
ee = { o, 1,(uint32_t)(bone_info_count * 8ULL), 1 };
ee.append(0, bone_info_count, ENRS_QWORD);
e.vec.push_back(ee);
o = bone_info_count * 8;
if (!is_x) {
s_motc.write_uint64_t(0);
io_write_offset_f2_pof_add(s_motc, 0, 0x40, &pof);
io_write_offset_f2_pof_add(s_motc, 0, 0x40, &pof);
io_write_offset_f2_pof_add(s_motc, 0, 0x40, &pof);
io_write_offset_f2_pof_add(s_motc, 0, 0x40, &pof);
io_write_offset_f2_pof_add(s_motc, 0, 0x40, &pof);
io_write_offset_f2_pof_add(s_motc, 0, 0x40, &pof);
s_motc.write_int32_t(0);
s_motc.write_int32_t(0);
}
else {
s_motc.write_uint64_t(0);
io_write_offset_x_pof_add(s_motc, 0, &pof);
io_write_offset_x_pof_add(s_motc, 0, &pof);
io_write_offset_x_pof_add(s_motc, 0, &pof);
io_write_offset_x_pof_add(s_motc, 0, &pof);
io_write_offset_x_pof_add(s_motc, 0, &pof);
io_write_offset_x_pof_add(s_motc, 0, &pof);
s_motc.write_int32_t(0);
}
s_motc.write_uint16_t(0);
s_motc.write_uint8_t(0);
s_motc.align_write(0x10);
mh.hash = hash_string_murmurhash(m->name);
mh.key_set_info_offset = s_motc.get_position();
s_motc.write_uint16_t_reverse_endianness(m->info);
s_motc.write_uint16_t_reverse_endianness(m->frame_count);
mh.key_set_types_offset = s_motc.get_position();
uint16_t key_set_type_buf = 0;
for (uint32_t j = 0; j < key_set_count; j++) {
mot_key_set_type type = key_set_array[j].type;
if (type == MOT_KEY_SET_STATIC && key_set_array[j].values[0] == 0.0f)
type = MOT_KEY_SET_NONE;
key_set_type_buf |= ((uint16_t)type & 0x03) << (j % 8 * 2);
if (j % 8 == 7) {
s_motc.write_uint16_t_reverse_endianness(key_set_type_buf);
key_set_type_buf = 0;
}
}
if (m->key_set_count % 8 != 0)
s_motc.write_uint16_t_reverse_endianness(key_set_type_buf);
s_motc.align_write(0x04);
mh.key_set_offset = s_motc.get_position();
for (int32_t j = 0; j < m->key_set_count; j++) {
mot_key_set_data* key_set = &key_set_array[j];
if (key_set->type == MOT_KEY_SET_STATIC) {
if (key_set->values[0] != 0.0f)
s.write_float_t_reverse_endianness(key_set->values[0]);
}
else if (key_set->type != MOT_KEY_SET_NONE) {
bool has_tangents = key_set->type != MOT_KEY_SET_HERMITE;
uint16_t keys_count = key_set->keys_count;
mot_key_set_data_type data_type = key_set->data_type;
s_motc.write_uint16_t_reverse_endianness(keys_count);
s_motc.write_uint16_t_reverse_endianness((uint16_t)data_type);
uint8_t step = has_tangents ? 2 : 1;
if (has_tangents) {
float_t* values = &key_set->values[1];
for (int32_t k = 0; k < keys_count; k++, values += step)
s_motc.write_float_t_reverse_endianness(*values);
}
float_t* values = key_set->values;
if (data_type == MOT_KEY_SET_DATA_F16)
for (int32_t k = 0; k < keys_count; k++, values += step)
s_motc.write_half_t_reverse_endianness(float_to_half(*values));
else
for (int32_t k = 0; k < keys_count; k++, values += step)
s_motc.write_float_t_reverse_endianness(*values);
s_motc.align_write(0x04);
int16_t* frames = (int16_t*)key_set->frames;
for (int32_t k = 0; k < keys_count; k++)
s_motc.write_int16_t_reverse_endianness(*frames++);
s_motc.align_write(0x04);
}
}
s_motc.align_write(0x10);
mot_bone_info* bone_info_array = m->bone_info_array;
size_t* bone_info_offsets = force_malloc_s(size_t, bone_info_count);
mh.bone_info_offset = s_motc.get_position();
if (!is_x)
for (int32_t j = 0; j < bone_info_count; j++)
io_write_offset_f2_pof_add(s_motc, 0, 0x40, &pof);
else
for (int32_t j = 0; j < bone_info_count; j++)
io_write_offset_x_pof_add(s_motc, 0, &pof);
s_motc.align_write(0x10);
mh.bone_hash_offset = s_motc.get_position();
for (int32_t j = 0; j < bone_info_count; j++)
s_motc.write_uint64_t_reverse_endianness(hash_string_murmurhash(bone_info_array[j].name));
s_motc.align_write(0x10);
mh.name_offset = s_motc.get_position();
s_motc.write_string_null_terminated(m->name);
for (int32_t j = 0; j < bone_info_count; j++) {
bone_info_offsets[j] = s_motc.get_position();
s_motc.write_string_null_terminated(bone_info_array[j].name);
}
s_motc.align_write(0x10);
s_motc.set_position(mh.bone_info_offset, SEEK_SET);
mh.bone_info_count = bone_info_count;
if (!is_x)
for (int32_t j = 0; j < bone_info_count; j++)
s_motc.write_offset_f2(bone_info_offsets[j], 0x40);
else
for (int32_t j = 0; j < bone_info_count; j++)
s_motc.write_offset_x(bone_info_offsets[j]);
free_def(bone_info_offsets);
s_motc.set_position(0x00, SEEK_SET);
if (!is_x) {
s_motc.write_uint64_t_reverse_endianness((uint64_t)mh.hash);
s_motc.write_offset_f2(mh.name_offset, 0x40);
s_motc.write_offset_f2(mh.key_set_info_offset, 0x40);
s_motc.write_offset_f2(mh.key_set_types_offset, 0x40);
s_motc.write_offset_f2(mh.key_set_offset, 0x40);
s_motc.write_offset_f2(mh.bone_info_offset, 0x40);
s_motc.write_offset_f2(mh.bone_hash_offset, 0x40);
s_motc.write_int32_t_reverse_endianness(mh.bone_info_count);
}
else {
s_motc.write_uint64_t_reverse_endianness((uint64_t)mh.hash);
s_motc.write_offset_x(mh.name_offset);
s_motc.write_offset_x(mh.key_set_info_offset);
s_motc.write_offset_x(mh.key_set_types_offset);
s_motc.write_offset_x(mh.key_set_offset);
s_motc.write_offset_x(mh.bone_info_offset);
s_motc.write_offset_x(mh.bone_hash_offset);
s_motc.write_int32_t_reverse_endianness(mh.bone_info_count);
}
if (m->div_frames > 0) {
s_motc.write_uint16_t_reverse_endianness(m->div_frames);
s_motc.write_uint8_t(m->div_count);
}
else {
s_motc.write_uint16_t_reverse_endianness(0);
s_motc.write_uint8_t(0);
}
murmurhash = m->murmurhash;
}
f2_struct st;
s_motc.align_write(0x10);
s_motc.copy(st.data);
s_motc.close();
st.enrs = e;
st.pof = pof;
st.header.signature = reverse_endianness_uint32_t('MOTC');
st.header.length = 0x40;
st.header.use_big_endian = big_endian;
st.header.use_section_size = true;
st.header.murmurhash = murmurhash;
st.header.inner_signature = 0xFF010008;
st.write(s, true, is_x);
}
inline static const char* mot_move_data_string(const char* str,
prj::shared_ptr<prj::stack_allocator>& alloc) {
if (str)
return alloc->allocate<char>(str, utf8_length(str) + 1);
return 0;
}
static void mot_data_move_data(mot_data* mot_dst, const mot_data* mot_src,
prj::shared_ptr<prj::stack_allocator> alloc) {
mot_dst->info = mot_src->info;
mot_dst->frame_count = mot_src->frame_count;
mot_dst->bone_info_count = mot_src->bone_info_count;
mot_dst->murmurhash = mot_src->murmurhash;
mot_dst->div_frames = mot_src->div_frames;
mot_dst->div_count = mot_src->div_count;
mot_dst->name = mot_move_data_string(mot_src->name, alloc);
uint32_t bone_info_count = mot_src->bone_info_count;
mot_bone_info* bone_info_array_src = mot_src->bone_info_array;
mot_bone_info* bone_info_array_dst = alloc->allocate<mot_bone_info>(bone_info_count);
for (uint32_t i = 0; i < bone_info_count; i++) {
mot_bone_info* bone_info_src = &bone_info_array_src[i];
mot_bone_info* bone_info_dst = &bone_info_array_dst[i];
bone_info_dst->name = mot_move_data_string(bone_info_src->name, alloc);
bone_info_dst->index = bone_info_src->index;
}
mot_dst->bone_info_array = bone_info_array_dst;
uint32_t key_set_count = mot_src->key_set_count;
mot_key_set_data* key_set_array_src = mot_src->key_set_array;
mot_key_set_data* key_set_array_dst = alloc->allocate<mot_key_set_data>(key_set_count);
for (uint32_t i = 0; i < key_set_count; i++) {
mot_key_set_data* key_set_src = &key_set_array_src[i];
mot_key_set_data* key_set_dst = &key_set_array_dst[i];
mot_key_set_type type = key_set_src->type;
uint16_t keys_count = key_set_src->keys_count;
switch (type) {
case MOT_KEY_SET_NONE:
key_set_dst->frames = 0;
key_set_dst->values = 0;
break;
case MOT_KEY_SET_STATIC:
key_set_dst->frames = 0;
key_set_dst->values = alloc->allocate<float_t>(key_set_src->values, 1);
break;
case MOT_KEY_SET_HERMITE:
key_set_dst->frames = alloc->allocate<uint16_t>(key_set_src->frames, keys_count);
key_set_dst->values = alloc->allocate<float_t>(key_set_src->values, keys_count);
break;
case MOT_KEY_SET_HERMITE_TANGENT:
key_set_dst->frames = alloc->allocate<uint16_t>(key_set_src->frames, keys_count);
key_set_dst->values = alloc->allocate<float_t>(key_set_src->values, keys_count * 2ULL);
break;
}
key_set_dst->type = type;
key_set_dst->keys_count = keys_count;
key_set_dst->data_type = key_set_src->data_type;
}
mot_dst->key_set_array = key_set_array_dst;
}
inline static const char* mot_read_utf8_string_null_terminated_offset(
prj::shared_ptr<prj::stack_allocator>& alloc, stream& s, int64_t offset) {
size_t len = s.read_utf8_string_null_terminated_offset_length(offset);
char* str = alloc->allocate<char>(len + 1);
s.position_push(offset, SEEK_SET);
s.read(str, len);
s.position_pop();
str[len] = 0;
return str;
}
Reference in New Issue View Git Blame Copy Permalink