Max/korenkonder_ReDIVA
1
0
Fork 0
mirror of https://github.com/korenkonder/ReDIVA.git synced 2026-10-10 16:18:35 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
f584e1d6e6da746509efa35a2aacabbd50f1d951
korenkonder_ReDIVA/src/CRE/auth_3d.cpp
T
korenkonder f584e1d6e6 Overhaul of rndr::Render class 
Should be called PostProcess later
2026-06-02 08:45:40 +03:00

8506 lines
258 KiB
C++
Raw Blame History

/*
by korenkonder
GitHub/GitLab: korenkonder
*/
#include "auth_3d.hpp"
#include "../KKdLib/io/file_stream.hpp"
#include "../KKdLib/io/json.hpp"
#include "../KKdLib/io/path.hpp"
#include "../KKdLib/prj/algorithm.hpp"
#include "../KKdLib/farc.hpp"
#include "../KKdLib/hash.hpp"
#include "../KKdLib/interpolation.hpp"
#include "../KKdLib/msgpack.hpp"
#include "../KKdLib/str_utils.hpp"
#include "rob/rob.hpp"
#include "rob/motion.hpp"
#include "app_system_detail.hpp"
#include "clear_color.hpp"
#include "data.hpp"
#include "debug_print.hpp"
#include "effect.hpp"
#include "object.hpp"
#include "pv_db.hpp"
#include "render.hpp"
#include "shadow.hpp"
#include "sound.hpp"
#include "stage.hpp"
#include "task.hpp"
namespace auth_3d_detail {
class TaskAuth3d : public app::Task {
public:
TaskAuth3d();
virtual ~TaskAuth3d() override;
virtual bool init() override;
virtual bool ctrl() override;
virtual void disp() override;
};
class FrameRateTimeStop : public FrameRateControl {
public:
FrameRateTimeStop();
virtual ~FrameRateTimeStop() override;
virtual float_t get_delta_frame() override;
};
static void event_log(const char* fmt, ...);
static const char* get_ID_EVENT_TYPE(EVENT_TYPE type);
template <class T>
size_t get_index_by_name(const T& in_c, const std::string& in_name);
template <class T, class U, typename... Args>
void list_load(T& in_c, const SceneFile& in_file, const U& in_a, Args... args);
template <class T, class U, typename... Args>
void list_store(const T& in_c, const SceneFile& in_file, U& in_a, Args... args);
}
static void a3da_msgpack_read(const char* path, const char* file, a3d::Scene* auth_file);
static void auth_3d_set_material_list(auth_3d_detail::Scene& in_scene, render_context* rctx);
namespace auth_3d_detail {
Auth3dManager* g_manager;
TaskAuth3d* task_auth_3d;
}
static int16_t magic_number;
static const mat4 bad_matrix;
static auth_3d_detail::FrameRateTimeStop frame_rate_time_stop;
extern render_context* rctx_ptr;
namespace a3d {
EventListener::EventListener() {
}
EventListener::~EventListener() {
}
EventAdapter::EventAdapter() {
}
EventAdapter::~EventAdapter() {
}
void EventAdapter::loadFinished(auth_3d_detail::Handle& in_handle) {
}
void EventAdapter::playStart(auth_3d_detail::Handle& in_handle) {
}
void EventAdapter::playFinished(auth_3d_detail::Handle& in_handle) {
}
void EventAdapter::playLoopJumpAfter(auth_3d_detail::Handle& in_handle) {
}
void EventAdapter::playLoopJumpBefore(auth_3d_detail::Handle& in_handle) {
}
}
namespace auth_3d_detail {
// 0x1401AF2F0
const Fcurve::KeyData* Fcurve::KeyData::next() const {
return this + 1;
}
// Missing
Fcurve::KeyData* Fcurve::KeyData::next() {
return this + 1;
}
// 0x1401AF360
const Fcurve::KeyData* Fcurve::KeyData::prev() const {
return this - 1;
}
// Missing
Fcurve::KeyData* Fcurve::KeyData::prev() {
return this - 1;
}
// 0x1401C1DF0
float_t Fcurve::KeyData::S_calc(FC_TYPE in_type, float_t in_frame,
const Fcurve::KeyData* curr_key, const Fcurve::KeyData* next_key) {
switch (in_type) {
case FC_TYPE_LINEAR:
if (curr_key->frame < next_key->frame)
return interpolate_linear_value(curr_key->value, next_key->value,
curr_key->frame, next_key->frame, in_frame);
else
return curr_key->value;
case FC_TYPE_HERMITE:
if (curr_key->frame < next_key->frame)
return interpolate_chs_value(curr_key->value, next_key->value,
curr_key->r_slope, next_key->l_slope,
curr_key->frame, next_key->frame, in_frame);
else
return curr_key->value;
case FC_TYPE_NO_INTERPOLATION:
if (in_frame >= next_key->frame)
return next_key->value;
else
return curr_key->value;
default:
return 0.0f;
}
}
// 0x1401BF960
void Fcurve::M_init() {
m_max_frame = 0.0f;
m_ep_type_pre = EP_TYPE_CONSTANT;
m_ep_type_post = EP_TYPE_CONSTANT;
m_frame_delta = 0.0f;
m_value_delta = 0.0f;
m_key_data_list.clear();
m_key_data_list.shrink_to_fit();
m_key_data_size = 0;
m_key_data_ptr = 0;
m_frame = 0.0f;
m_value = 0.0f;
}
// 0x1401BF870
float_t Fcurve::M_get(float_t in_frame) const {
const KeyData* first_key = m_key_data_ptr;
const KeyData* next_key = find_key_data(in_frame);
if (next_key == first_key)
return first_key->value;
const KeyData* prev_key = next_key->prev();
if (next_key == &first_key[m_key_data_size])
return prev_key->value;
return KeyData::S_calc(m_type, in_frame, prev_key, next_key);
}
// 0x1401C1B00
void Fcurve::M_set_ep_type(EP_TYPE in_ep_type_pre, EP_TYPE in_ep_type_post) {
m_ep_type_pre = EP_TYPE_CONSTANT;
m_ep_type_post = EP_TYPE_CONSTANT;
m_frame_delta = m_max_frame;
m_value_delta = 0.0f;
if (m_key_data_size) {
const KeyData* first_key = &m_key_data_ptr[0];
const KeyData* last_key = &m_key_data_ptr[m_key_data_size - 1];
if (first_key->frame < last_key->frame
&& check_ep_range(0.0f, m_max_frame, first_key->frame, last_key->frame)) {
m_ep_type_pre = in_ep_type_pre;
m_ep_type_post = in_ep_type_post;
m_frame_delta = last_key->frame - first_key->frame;
m_value_delta = last_key->value - first_key->value;
}
}
}
// 0x1401B3E60
Fcurve::Fcurve() : m_type(), m_static_value(), m_max_frame(),
m_ep_type_pre(), m_ep_type_post(), m_frame_delta(), m_value_delta(),
m_key_data_list(), m_key_data_size(), m_key_data_ptr(), m_frame(), m_value() {
}
// Missing
Fcurve::Fcurve(float_t in_value) : m_type(FC_TYPE_STATIC_DATA), m_static_value(in_value),
m_max_frame(), m_ep_type_pre(), m_ep_type_post(), m_frame_delta(), m_value_delta(),
m_key_data_list(), m_key_data_size(), m_key_data_ptr(), m_frame(), m_value() {
}
// 0x1401B3DF0
Fcurve::Fcurve(const Fcurve& other) : m_type(other.m_type), m_static_value(other.m_static_value),
m_max_frame(other.m_max_frame), m_ep_type_pre(other.m_ep_type_pre), m_ep_type_post(other.m_ep_type_post),
m_frame_delta(other.m_frame_delta), m_value_delta(other.m_value_delta),
m_key_data_list(other.m_key_data_list), m_key_data_size(other.m_key_data_size),
m_key_data_ptr(other.m_key_data_ptr), m_frame(other.m_frame), m_value(other.m_value) {
}
// Missing
Fcurve::~Fcurve() {
}
// 0x1401D6F80
void Fcurve::init() {
m_type = FC_TYPE_STATIC_0;
m_static_value = 0.0f;
M_init();
}
// 0x1401D6F20
void Fcurve::init(float_t in_value) {
m_type = FC_TYPE_STATIC_DATA;
m_static_value = in_value;
M_init();
}
// 0x1401D4230
float_t Fcurve::get(float_t in_frame) {
if (m_type == FC_TYPE_STATIC_DATA)
return m_static_value;
else if (m_type < FC_TYPE_STATIC_DATA
|| m_type > FC_TYPE_NO_INTERPOLATION || !m_key_data_size)
return 0.0f;
const KeyData* first_key = &m_key_data_ptr[0];
const KeyData* last_key = &m_key_data_ptr[m_key_data_size - 1];
float_t first_frame = first_key->frame;
float_t last_frame = last_key->frame;
float_t offset = 0.0f;
float_t frame = in_frame;
if (frame < first_frame) {
float_t delta_frame = first_frame - frame;
switch (m_ep_type_pre) {
case a3d::EP_TYPE_CONSTANT:
default:
m_frame = frame;
m_value = first_key->value;
return m_value;
case a3d::EP_TYPE_LINEAR:
m_frame = frame;
m_value = first_key->value + delta_frame * first_key->l_slope;
return m_value;
case a3d::EP_TYPE_CYCLE:
frame = last_frame - fmodf(delta_frame, m_frame_delta);
break;
case a3d::EP_TYPE_CYCLE_WITH_OFFSET:
offset = (prj::truncf(delta_frame / m_frame_delta) + 1.0f) * m_value_delta;
frame = last_frame - fmodf(delta_frame, m_frame_delta);
break;
}
}
else if (frame >= last_frame) {
float_t delta_frame = frame - last_frame;
switch (m_ep_type_post) {
case a3d::EP_TYPE_CONSTANT:
default:
m_frame = frame;
m_value = last_key->value;
return m_value;
case a3d::EP_TYPE_LINEAR:
m_frame = frame;
m_value = last_key->value - delta_frame * last_key->r_slope;
return m_value;
case a3d::EP_TYPE_CYCLE:
frame = first_frame + fmodf(delta_frame, m_frame_delta);
break;
case a3d::EP_TYPE_CYCLE_WITH_OFFSET:
offset = (prj::truncf(delta_frame / m_frame_delta) + 1.0f) * m_value_delta;
frame = first_frame + fmodf(delta_frame, m_frame_delta);
break;
}
}
m_frame = frame;
m_value = M_get(frame) + offset;
return m_value;
}
// Missing
float_t Fcurve::operator()(float_t in_frame) {
return get(in_frame);
}
// 0x1401D3AB0
const Fcurve::KeyData* Fcurve::find_key_data(float_t in_frame) const {
return std::upper_bound(m_key_data_ptr, m_key_data_ptr + m_key_data_size,
in_frame, [](float_t in_frame, const KeyData& key) {
return in_frame < key.frame;
});
}
// Missing
float_t Fcurve::get_size() const {
return m_max_frame;
}
// 0x1401CBFF0
bool Fcurve::check_discontinuity(float_t in_frame) const {
if (m_type < FC_TYPE_LINEAR || m_type > FC_TYPE_NO_INTERPOLATION)
return false;
const float_t frame = clamp_def(in_frame, 0.0f, m_max_frame);
if (!m_key_data_size)
return false;
const KeyData* key = find_key_data(frame);
if (key == m_key_data_ptr || key == &m_key_data_ptr[m_key_data_size])
return false;
return key->frame - key->prev()->frame < 2.0f;
}
// 0x1401CC540
bool Fcurve::check_threshold_discontinuity(float_t in_frame, float_t in_threshold) const {
if (m_type < FC_TYPE_LINEAR || m_type > FC_TYPE_NO_INTERPOLATION)
return false;
const float_t frame = clamp_def(in_frame, 0.0f, m_max_frame);
if (!m_key_data_size)
return false;
const KeyData* keys = m_key_data_ptr;
const KeyData* keys_end = &keys[m_key_data_size];
const KeyData* key = find_key_data(frame);
if (key == keys || key == keys_end || key == keys->next())
return false;
const KeyData* next_key = key->next();
if (next_key == keys_end)
return false;
const KeyData* prev_key = key->prev();
const float_t frame_diff = key->frame - prev_key->frame;
if (frame_diff >= 2.0f || frame_diff <= 0.0f)
return false;
if (fabsf(key->value - prev_key->value) <= in_threshold)
return false;
const KeyData* prev2_key = prev_key->prev();
while (prev_key->frame <= prev2_key->frame)
if (prev2_key == keys)
return false;
else
prev2_key = prev2_key->prev();
const KeyData* next_key_1 = next_key;
while (key->frame >= next_key->frame)
next_key_1 = next_key;
// Intentional! Should be (V2 - V1) / (F2 - F1), but first parenthesis is missing
const float_t center_slope = key->value - prev_key->value / frame_diff;
float_t left_slope;
float_t right_slope;
if (m_type != FC_TYPE_HERMITE) {
left_slope = (prev_key->value - prev2_key->value) / (prev_key->frame - prev2_key->frame);
right_slope = (next_key_1->value - key->value) / (next_key_1->frame - key->frame);
}
else {
if ((prev_key->frame - prev2_key->frame) >= 2.0f) {
float_t value;
if (prev2_key->frame < prev_key->frame)
value = interpolate_chs_value(
prev2_key->value, prev_key->value, prev2_key->r_slope, prev_key->l_slope,
prev_key->frame, prev2_key->frame, prev_key->frame - 1.0f);
else
value = prev2_key->value;
left_slope = prev_key->value - value;
}
else
left_slope = (prev_key->value - prev2_key->value) / (prev_key->frame - prev2_key->frame);
if (next_key_1->frame - key->frame >= 2.0f) {
float_t value;
if (key->frame < next_key_1->frame)
value = interpolate_chs_value(
key->value, next_key_1->value, key->r_slope, next_key_1->l_slope,
key->frame, next_key_1->frame, key->frame + 1.0f);
else
value = key->value;
right_slope = value - key->value;
}
else
right_slope = (next_key_1->value - key->value) / (next_key_1->frame - key->frame);
}
const float_t left_dot = left_slope * center_slope;
const float_t right_dot = right_slope * center_slope;
const float_t abs_left_slope = fabsf(left_slope);
const float_t abs_center_slope = fabsf(center_slope);
const float_t abs_right_slope = fabsf(right_slope);
bool left_small = abs_left_slope < abs_center_slope && abs_left_slope <= in_threshold;
bool right_small = abs_right_slope < abs_center_slope && abs_right_slope <= in_threshold;
return (left_dot <= 0.0f || left_small)
&& (right_dot <= 0.0f || right_small);
}
// 0x1401DB1A0
bool Fcurve::load(const SceneFile& in_file, const a3d::Fcurve& in_fcv) {
m_max_frame = in_file.frame_max;
m_frame_delta = m_max_frame;
m_value_delta = 0.0f;
switch (in_fcv.type) {
case a3d::FC_TYPE_STATIC_0:
m_type = FC_TYPE_STATIC_0;
m_static_value = 0.0f;
return true;
case a3d::FC_TYPE_STATIC_DATA:
m_type = in_fcv.value != 0.0f ? FC_TYPE_STATIC_DATA : FC_TYPE_STATIC_0;
m_static_value = in_fcv.value;
return true;
case a3d::FC_TYPE_LINEAR:
m_type = FC_TYPE_LINEAR;
break;
case a3d::FC_TYPE_HERMITE:
default:
m_type = FC_TYPE_HERMITE;
break;
case a3d::FC_TYPE_NO_INTERPOLATION:
m_type = FC_TYPE_NO_INTERPOLATION;
break;
}
size_t key_data_size = in_fcv.keys.size();
if (key_data_size > 1) {
m_key_data_list.assign(in_fcv.keys.begin(), in_fcv.keys.end());
m_key_data_size = key_data_size;
m_key_data_ptr = m_key_data_list.data();
M_set_ep_type((EP_TYPE)in_fcv.ep_type_pre, (EP_TYPE)in_fcv.ep_type_post);
}
else if (key_data_size == 1) {
float_t value = in_fcv.keys.front().value;
m_type = value != 0.0f ? FC_TYPE_STATIC_DATA : FC_TYPE_STATIC_0;
m_static_value = value;
}
else {
m_type = FC_TYPE_STATIC_0;
m_static_value = 0.0f;
}
return true;
}
// Added
void Fcurve::store(const SceneFile& in_file, a3d::Fcurve& out_fcv) const {
out_fcv.max_frame = in_file.frame_max;
switch (m_type) {
case FC_TYPE_STATIC_0:
out_fcv.type = a3d::FC_TYPE_STATIC_0;
out_fcv.value = 0.0f;
return;
case FC_TYPE_STATIC_DATA:
out_fcv.type = m_static_value != 0.0f ? a3d::FC_TYPE_STATIC_DATA : a3d::FC_TYPE_STATIC_0;
out_fcv.value = m_static_value;
return;
case FC_TYPE_LINEAR:
out_fcv.type = a3d::FC_TYPE_LINEAR;
break;
case FC_TYPE_HERMITE:
default:
out_fcv.type = a3d::FC_TYPE_HERMITE;
break;
case FC_TYPE_NO_INTERPOLATION:
out_fcv.type = a3d::FC_TYPE_NO_INTERPOLATION;
break;
}
size_t key_data_size = m_key_data_list.size();
if (key_data_size > 1) {
out_fcv.keys.assign(m_key_data_list.begin(), m_key_data_list.end());
const KeyData* first_key = &m_key_data_ptr[0];
const KeyData* last_key = &m_key_data_ptr[key_data_size - 1];
if (first_key->frame < last_key->frame
&& check_ep_range(0.0f, m_max_frame, first_key->frame, last_key->frame)) {
out_fcv.ep_type_pre = (a3d::EP_TYPE)m_ep_type_pre;
out_fcv.ep_type_post = (a3d::EP_TYPE)m_ep_type_post;
}
}
else if (key_data_size == 1) {
float_t value = m_key_data_list.front().value;
out_fcv.type = value != 0.0f ? a3d::FC_TYPE_STATIC_DATA : a3d::FC_TYPE_STATIC_0;
out_fcv.value = value;
}
else {
out_fcv.type = a3d::FC_TYPE_STATIC_0;
out_fcv.value = 0.0f;
}
}
// 0x1401BBAB0
Fcurve& Fcurve::operator=(const Fcurve& other) {
m_type = other.m_type;
m_static_value = other.m_static_value;
m_max_frame = other.m_max_frame;
m_ep_type_pre = other.m_ep_type_pre;
m_ep_type_post = other.m_ep_type_post;
m_frame_delta = other.m_frame_delta;
m_value_delta = other.m_value_delta;
m_key_data_list.assign(other.m_key_data_list.begin(), other.m_key_data_list.end());
m_key_data_size = other.m_key_data_size;
m_key_data_ptr = m_key_data_list.data();
return *this;
}
// 0x1401AF540
bool Fcurve::check_ep_range(float_t in_frame_begin, float_t in_frame_end,
float_t in_key_frame_begin, float_t in_key_frame_end) {
return in_key_frame_end > in_frame_begin && in_frame_end > in_key_frame_begin;
}
// 0x1401B3D60
Fcurve3f::Fcurve3f() : x(), y(), z() {
}
// Missing
Fcurve3f::Fcurve3f(float_t in_value) : x(in_value), y(in_value), z(in_value) {
}
// 0x1401B3C10
Fcurve3f::Fcurve3f(const Fcurve3f& other) : x(other.x), y(other.y), z(other.z) {
}
// 0x1401B8850
Fcurve3f::~Fcurve3f() {
}
// 0x1401D6E20
void Fcurve3f::init() {
x.init();
y.init();
z.init();
}
// 0x1401D6D00
void Fcurve3f::init(float_t in_value) {
x.init(in_value);
y.init(in_value);
z.init(in_value);
}
// 0x1401D41B0
vec3 Fcurve3f::get(float_t in_frame) {
vec3 value;
value.x = x.get(in_frame);
value.y = y.get(in_frame);
value.z = z.get(in_frame);
return value;
}
// 0x1401DB050
bool Fcurve3f::load(const SceneFile& in_file, const a3d::Fcurve3f& in_fcv3f) {
x.load(in_file, in_fcv3f.x);
y.load(in_file, in_fcv3f.y);
z.load(in_file, in_fcv3f.z);
return true;
}
// Added
void Fcurve3f::store(const SceneFile& in_file, a3d::Fcurve3f& out_fcv3f) const {
x.store(in_file, out_fcv3f.x);
y.store(in_file, out_fcv3f.y);
z.store(in_file, out_fcv3f.z);
}
// 0x1401BB970
Fcurve3f& Fcurve3f::operator=(const Fcurve3f& other) {
x = other.x;
y = other.y;
z = other.z;
return *this;
}
// 0x1401B4090
FcurveColor4f::FcurveColor4f() : r(), g(), b(), a(), has_r(), has_g(), has_b(), has_a() {
}
// 0x1401B3E90
FcurveColor4f::FcurveColor4f(const FcurveColor4f& other) : r(other.r), g(other.g), b(other.b), a(other.a),
has_r(other.has_r), has_g(other.has_g), has_b(other.has_g), has_a(other.has_g) {
}
// 0x1401B8900
FcurveColor4f::~FcurveColor4f() {
}
// 0x1401D6FE0
void FcurveColor4f::init() {
r.init();
g.init();
b.init();
a.init();
has_r = false;
has_g = false;
has_b = false;
has_a = false;
}
// 0x1401D4450
vec4 FcurveColor4f::get(float_t in_frame) {
vec4 value;
value.x = r.get(in_frame);
value.y = g.get(in_frame);
value.z = b.get(in_frame);
value.w = a.get(in_frame);
return value;
}
// 0x1401DB520
bool FcurveColor4f::load(const SceneFile& in_file, const a3d::FcurveColor4f& in_fcv_col4f) {
if (in_fcv_col4f.has_r) {
r.load(in_file, in_fcv_col4f.r);
has_r = true;
}
if (in_fcv_col4f.has_g) {
g.load(in_file, in_fcv_col4f.g);
has_g = true;
}
if (in_fcv_col4f.has_b) {
b.load(in_file, in_fcv_col4f.b);
has_b = true;
}
if (in_fcv_col4f.has_a) {
a.load(in_file, in_fcv_col4f.a);
has_a = true;
}
return has_r || has_g || has_b || has_a;
}
// Added
void FcurveColor4f::store(const SceneFile& in_file, a3d::FcurveColor4f& out_fcv_col4f) const {
if (has_r) {
r.store(in_file, out_fcv_col4f.r);
out_fcv_col4f.has_r = true;
}
if (has_g) {
g.store(in_file, out_fcv_col4f.g);
out_fcv_col4f.has_g = true;
}
if (has_b) {
b.store(in_file, out_fcv_col4f.b);
out_fcv_col4f.has_b = true;
}
if (has_a) {
a.store(in_file, out_fcv_col4f.a);
out_fcv_col4f.has_a = true;
}
}
// 0x1401BBB20
FcurveColor4f& FcurveColor4f::operator=(const FcurveColor4f& other) {
r = other.r;
g = other.g;
b = other.b;
a = other.a;
has_r = other.has_r;
has_g = other.has_g;
has_b = other.has_b;
has_a = other.has_a;
return *this;
}
// 0x1401B30B0
Color::Color() : fcurve_color(), color(), has_color() {
}
// 0x1401B3050
Color::Color(const Color& other) : fcurve_color(other.fcurve_color), color(other.color) {
has_color[0] = other.has_color[0];
has_color[1] = other.has_color[1];
has_color[2] = other.has_color[2];
has_color[3] = other.has_color[3];
}
// 0x1401B85A0
Color::~Color() {
init();
}
/// 0x1401D6CA0
void Color::init() {
fcurve_color.init();
has_color[0] = true;
has_color[1] = true;
has_color[2] = true;
has_color[3] = true;
}
// 0x1401D4070
void Color::get(float_t in_frame) {
color = fcurve_color.get(in_frame);
has_color[0] = fcurve_color.has_r;
has_color[1] = fcurve_color.has_b; // TYPO!
has_color[2] = fcurve_color.has_g; // TYPO!
has_color[3] = fcurve_color.has_a;
}
// 0x1401DA200
bool Color::load(const SceneFile& in_file, const a3d::FcurveColor4f& in_fcv_col4f) {
fcurve_color.load(in_file, in_fcv_col4f);
return true;
}
// Added
void Color::store(const SceneFile& in_file, a3d::FcurveColor4f& out_fcv_col4f) const {
fcurve_color.store(in_file, out_fcv_col4f);
}
// 0x1401BB740
Color& Color::operator=(const Color& other) {
fcurve_color = other.fcurve_color;
color = other.color;
has_color[0] = other.has_color[0];
has_color[1] = other.has_color[1];
has_color[2] = other.has_color[2];
has_color[3] = other.has_color[3];
return *this;
}
// 0x1401B4E10
ModelTransform::ModelTransform() : matrix(), fcurve_scale(), fcurve_rotation(),
fcurve_translation(), fcurve_visibility(), scale(), rotation(), translation(), visibility() {
}
// 0x1401B4C50
ModelTransform::ModelTransform(const ModelTransform& other) : matrix(other.matrix),
fcurve_scale(other.fcurve_scale), fcurve_rotation(other.fcurve_rotation),
fcurve_translation(other.fcurve_translation), fcurve_visibility(other.fcurve_visibility),
scale(other.scale), rotation(other.rotation), translation(other.translation), visibility(other.visibility) {
}
// 0x1401B8D50
ModelTransform::~ModelTransform() {
}
// 0x1401D74B0
void ModelTransform::init() {
matrix = mat4_identity;
fcurve_scale.init();
fcurve_rotation.init();
fcurve_translation.init();
fcurve_visibility.init();
scale = 0.0f;
rotation = 0.0f;
translation = 0.0f;
visibility = false;
}
// 0x1401D8840
void ModelTransform::init_static() {
matrix = mat4_identity;
fcurve_scale.init(1.0f);
fcurve_rotation.init(0.0f);
fcurve_translation.init(0.0f);
fcurve_visibility.init(1.0f);
scale = 1.0f;
rotation = 0.0f;
translation = 0.0f;
visibility = true;
}
// 0x1401D4680
void ModelTransform::get(float_t in_frame) {
scale = fcurve_scale.get(in_frame);
rotation = fcurve_rotation.get(in_frame);
translation = fcurve_translation.get(in_frame);
visibility = fcurve_visibility.get(in_frame) >= 0.999f;
if (visibility && (scale.x == 0.0f || scale.y == 0.0f || scale.z == 0.0f))
visibility = false;
}
// 0x1401E1CB0
const mat4& ModelTransform::mul(const mat4& in_base_mat) {
matrix = in_base_mat;
mat4_mul_translate(&matrix, &translation, &matrix);
mat4_mul_rotate_zyx(&matrix, &rotation, &matrix);
mat4_scale_rot(&matrix, &scale, &matrix);
return matrix;
}
// Inlined
inline const mat4& ModelTransform::get_matrix() {
return matrix;
}
// 0x1401DCFB0
bool ModelTransform::load(const SceneFile& in_file, const a3d::ModelTransform& in_mt) {
fcurve_rotation.load(in_file, in_mt.rotation);
fcurve_scale.load(in_file, in_mt.scale);
fcurve_translation.load(in_file, in_mt.translation);
fcurve_visibility.load(in_file, in_mt.visibility);
return true;
}
// Added
void ModelTransform::store(const SceneFile& in_file, a3d::ModelTransform& out_mt) const {
fcurve_rotation.store(in_file, out_mt.rotation);
fcurve_scale.store(in_file, out_mt.scale);
fcurve_translation.store(in_file, out_mt.translation);
fcurve_visibility.store(in_file, out_mt.visibility);
}
// 0x1401BC1F0
ModelTransform& ModelTransform::operator=(const ModelTransform& other) {
matrix = other.matrix;
fcurve_scale = other.fcurve_scale;
fcurve_rotation = other.fcurve_rotation;
fcurve_translation = other.fcurve_translation;
fcurve_visibility = other.fcurve_visibility;
scale = other.scale;
rotation = other.rotation;
translation = other.translation;
visibility = other.visibility;
return *this;
}
// MGF
Ambient::Ambient() : flag(), name(), light_diffuse(), rim_light_diffuse() {
}
// MGF
Ambient::Ambient(const Ambient& other) : flag(other.flag), name(other.name),
light_diffuse(other.light_diffuse), rim_light_diffuse(other.rim_light_diffuse) {
}
// MGF
Ambient::~Ambient() {
}
// MGF
void Ambient::init() {
flag = 0;
name.clear();
name.shrink_to_fit();
light_diffuse.init();
rim_light_diffuse.init();
}
// MGF
void Ambient::get(float_t in_frame) {
if (has_light_diffuse())
light_diffuse.get(in_frame);
if (has_rim_light_diffuse())
rim_light_diffuse.get(in_frame);
}
// MGF
void Ambient::ctrl(render_context* rctx) {
}
// MGF
bool Ambient::load(const SceneFile& in_file, const a3d::Ambient& in_a) {
name.assign(in_a.name);
if (in_a.flag & a3d::Ambient::FLAG_LIGHT_DIFFUSE) {
light_diffuse.load(in_file, in_a.light_diffuse);
flag |= FLAG_LIGHT_DIFFUSE;
}
if (in_a.flag & a3d::Ambient::FLAG_RIM_LIGHT_DIFFUSE) {
rim_light_diffuse.load(in_file, in_a.rim_light_diffuse);
flag |= FLAG_RIM_LIGHT_DIFFUSE;
}
return true;
}
// MGF, Added
void Ambient::store(const SceneFile& in_file, a3d::Ambient& out_a) const {
out_a.name.assign(name);
if (flag & FLAG_LIGHT_DIFFUSE) {
light_diffuse.store(in_file, out_a.light_diffuse);
out_a.flag |= a3d::Ambient::FLAG_LIGHT_DIFFUSE;
}
if (flag & FLAG_RIM_LIGHT_DIFFUSE) {
rim_light_diffuse.store(in_file, out_a.rim_light_diffuse);
out_a.flag |= a3d::Ambient::FLAG_RIM_LIGHT_DIFFUSE;
}
}
// MGF
Ambient& Ambient::operator=(const Ambient& other) {
flag = other.flag;
name.assign(other.name);
light_diffuse = other.light_diffuse;
rim_light_diffuse = other.rim_light_diffuse;
return *this;
}
// 0x1401B2790
Auth2d::Auth2d() : name() {
}
// 0x1401B2750
Auth2d::Auth2d(const Auth2d& other) : name(other.name) {
}
// 0x1401B7D80
Auth2d::~Auth2d() {
}
// 0x1401D9960
bool Auth2d::load(const SceneFile& in_file, const a3d::Auth2d& in_a2) {
name.assign(in_a2.name);
if (!name.find("S_ADVPR0"))
name[7] = 'O';
return true;
}
// Added
void Auth2d::store(const SceneFile& in_file, a3d::Auth2d& out_a2) const {
out_a2.name.assign(name);
}
// 0x1401BB350
Auth2d& Auth2d::operator=(const Auth2d& other) {
name.assign(other.name);
return *this;
}
// 0x1401B28C0
CameraAuxiliary::CameraAuxiliary() : flag(), fcurve_exposure(), fcurve_exposure_rate(),
fcurve_gamma(), fcurve_gamma_rate(), fcurve_saturate(), fcurve_auto_exposure(), exposure(2.0f),
exposure_rate(1.0f), gamma(1.0f), gamma_rate(1.0f), saturate(1.0f), auto_exposure(1.0f) {
}
// Missing
CameraAuxiliary::CameraAuxiliary(const CameraAuxiliary& other) : flag(other.flag),
fcurve_exposure(other.fcurve_exposure), fcurve_exposure_rate(other.fcurve_exposure_rate),
fcurve_gamma(other.fcurve_gamma), fcurve_gamma_rate(other.fcurve_gamma_rate),
fcurve_saturate(other.fcurve_saturate), fcurve_auto_exposure(other.fcurve_auto_exposure),
exposure(other.exposure), exposure_rate(other.exposure_rate), gamma(other.gamma),
gamma_rate(other.gamma_rate), saturate(other.saturate), auto_exposure(other.auto_exposure) {
}
// 0x1401B8140
CameraAuxiliary::~CameraAuxiliary() {
}
// 0x1401D69D0
void CameraAuxiliary::init() {
flag = 0;
fcurve_exposure.init();
fcurve_exposure_rate.init(); // F/F2/X/XHD
fcurve_gamma.init();
fcurve_gamma_rate.init(); // F/F2/X/XHD
fcurve_saturate.init();
fcurve_auto_exposure.init();
}
// 0x1401D3BD0
void CameraAuxiliary::get(float_t in_frame) {
if (has_exposure())
exposure = fcurve_exposure.get(in_frame);
if (has_exposure_rate()) // F/F2/X/XHD
exposure_rate = fcurve_exposure_rate.get(in_frame);
if (has_gamma())
gamma = fcurve_gamma.get(in_frame);
if (has_gamma_rate()) // F/F2/X/XHD
gamma_rate = fcurve_gamma_rate.get(in_frame);
if (has_saturate())
saturate = fcurve_saturate.get(in_frame);
if (has_auto_exposure())
auto_exposure = fcurve_auto_exposure.get(in_frame);
}
// 0x1401CE3E0
void CameraAuxiliary::ctrl(Scene& in_scene, render_context* rctx) {
if (has_exposure())
rctx->render->set_exposure(exposure);
if (has_gamma())
rctx->render->set_gamma(gamma);
if (has_saturate())
rctx->render->set_saturate_coef(saturate, 0, false);
if (has_auto_exposure())
rctx->render->set_auto_exposure(auto_exposure > 0.0f);
}
// 0x1401CFDE0
void CameraAuxiliary::dest(render_context* rctx) {
if (has_exposure())
rctx->render->set_exposure(2.0f);
if (has_gamma())
rctx->render->set_gamma(1.0f);
if (has_saturate())
rctx->render->set_saturate_coef(1.0f, 0, false);
if (has_auto_exposure())
rctx->render->set_auto_exposure(true);
init();
}
// 0x1401D9A60
bool CameraAuxiliary::load(const SceneFile& in_file, const a3d::CameraAuxiliary& in_ca) {
if (in_ca.flag & a3d::CameraAuxiliary::FLAG_EXPOSURE) {
fcurve_exposure.load(in_file, in_ca.exposure);
flag |= FLAG_EXPOSURE;
}
// F/F2/X/XHD
if (in_ca.flag & a3d::CameraAuxiliary::FLAG_EXPOSURE_RATE) {
fcurve_exposure_rate.load(in_file, in_ca.exposure_rate);
flag |= FLAG_EXPOSURE_RATE;
}
if (in_ca.flag & a3d::CameraAuxiliary::FLAG_GAMMA) {
fcurve_gamma.load(in_file, in_ca.gamma);
flag |= FLAG_GAMMA;
}
// F/F2/X/XHD
if (in_ca.flag & a3d::CameraAuxiliary::FLAG_GAMMA_RATE) {
fcurve_gamma_rate.load(in_file, in_ca.gamma_rate);
flag |= FLAG_GAMMA_RATE;
}
if (in_ca.flag & a3d::CameraAuxiliary::FLAG_SATURATE) {
fcurve_saturate.load(in_file, in_ca.saturate);
flag |= FLAG_SATURATE;
}
if (in_ca.flag & a3d::CameraAuxiliary::FLAG_AUTO_EXPOSURE) {
fcurve_auto_exposure.load(in_file, in_ca.auto_exposure);
flag |= FLAG_AUTO_EXPOSURE;
}
return true;
}
// Added
void CameraAuxiliary::store(const SceneFile& in_file, a3d::CameraAuxiliary& out_ca) const {
if (flag & FLAG_EXPOSURE) {
fcurve_exposure.store(in_file, out_ca.exposure);
out_ca.flag |= a3d::CameraAuxiliary::FLAG_EXPOSURE;
}
// F/F2/X/XHD
if (flag & FLAG_EXPOSURE_RATE) {
fcurve_exposure_rate.store(in_file, out_ca.exposure_rate);
out_ca.flag |= a3d::CameraAuxiliary::FLAG_EXPOSURE_RATE;
}
if (flag & FLAG_GAMMA) {
fcurve_gamma.store(in_file, out_ca.gamma);
out_ca.flag |= a3d::CameraAuxiliary::FLAG_GAMMA;
}
// F/F2/X/XHD
if (flag & FLAG_GAMMA_RATE) {
fcurve_gamma_rate.store(in_file, out_ca.gamma_rate);
out_ca.flag |= a3d::CameraAuxiliary::FLAG_GAMMA_RATE;
}
if (flag & FLAG_SATURATE) {
fcurve_saturate.store(in_file, out_ca.saturate);
out_ca.flag |= a3d::CameraAuxiliary::FLAG_SATURATE;
}
if (flag & FLAG_AUTO_EXPOSURE) {
fcurve_auto_exposure.store(in_file, out_ca.auto_exposure);
out_ca.flag |= a3d::CameraAuxiliary::FLAG_AUTO_EXPOSURE;
}
}
// Missing
CameraAuxiliary& CameraAuxiliary::operator=(const CameraAuxiliary& other) {
flag = other.flag;
fcurve_exposure = other.fcurve_exposure;
fcurve_exposure_rate = other.fcurve_exposure_rate; // F/F2/X/XHD
fcurve_gamma = other.fcurve_gamma;
fcurve_gamma_rate = other.fcurve_gamma_rate; // F/F2/X/XHD
fcurve_saturate = other.fcurve_saturate;
fcurve_auto_exposure = other.fcurve_auto_exposure;
exposure = other.exposure;
exposure_rate = other.exposure_rate; // F/F2/X/XHD
gamma = other.gamma;
gamma_rate = other.gamma_rate; // F/F2/X/XHD
saturate = other.saturate;
auto_exposure = other.auto_exposure;
return *this;
}
// 0x1401B29E0
CameraInterest::CameraInterest() : model_transform() {
init();
}
// 0x1401B29C0
CameraInterest::CameraInterest(const CameraInterest& other) : model_transform(other.model_transform) {
}
// 0x1401B81E0
CameraInterest::~CameraInterest() {
}
// Inlined
inline void CameraInterest::init() {
model_transform.init();
}
// 0x1401D9C90
bool CameraInterest::load(const SceneFile& in_file, const a3d::CameraInterest& in_ci) {
model_transform.load(in_file, in_ci.model_transform);
return true;
}
// Added
void CameraInterest::store(const SceneFile& in_file, a3d::CameraInterest& out_ci) const {
model_transform.store(in_file, out_ci.model_transform);
}
// 0x1401BB380
CameraInterest& CameraInterest::operator=(const CameraInterest& other) {
model_transform = other.model_transform;
return *this;
}
// 0x1401B2CA0
CameraViewPoint::CameraViewPoint() : model_transform(), roll(), has_fov(), fov_is_horizontal(),
fov(), aspect(), focal_length(), camera_aperture_w(), camera_aperture_h() {
init();
}
// 0x1401B2AA0
CameraViewPoint::CameraViewPoint(const CameraViewPoint& other) : model_transform(other.model_transform),
roll(other.roll), has_fov(other.has_fov), fov_is_horizontal(other.fov_is_horizontal),
fov(other.fov), aspect(other.aspect), focal_length(other.focal_length),
camera_aperture_w(other.camera_aperture_w), camera_aperture_h(other.camera_aperture_h) {
}
// 0x1401B8370
CameraViewPoint::~CameraViewPoint() {
}
// 0x1401D6B30
void CameraViewPoint::init() {
model_transform.init();
roll.init();
has_fov = true;
fov.init();
fov_is_horizontal = false;
aspect = 1.667f;
focal_length.init();
camera_aperture_w = 1.0f;
camera_aperture_h = 1.0f;
}
// 0x1401D9D90
bool CameraViewPoint::load(const SceneFile& in_file, const a3d::CameraViewPoint& in_cvp) {
model_transform.load(in_file, in_cvp.model_transform);
roll.load(in_file, in_cvp.roll);
if (in_cvp.has_fov) {
has_fov = true;
fov.load(in_file, in_cvp.fov);
fov_is_horizontal = in_cvp.fov_is_horizontal;
aspect = in_cvp.aspect;
}
else {
has_fov = false;
focal_length.load(in_file, in_cvp.focal_length);
camera_aperture_w = in_cvp.camera_aperture_w;
camera_aperture_h = in_cvp.camera_aperture_h;
}
return true;
}
// 0x1401D6380
float_t CameraViewPoint::get_v_fov(float_t in_frame) {
if (has_fov) {
float_t fov_value = fov.get(in_frame);
if (fov_is_horizontal)
fov_value = atanf(tanf(fov_value * 0.5f) / aspect) * 2.0f;
return fov_value;
}
else {
float_t half_cam_aper_h_mm = (camera_aperture_h * 25.4f) * 0.5f;
float_t focal_lenth_value = focal_length.get(in_frame);
return atanf(half_cam_aper_h_mm / focal_lenth_value) * 2.0f;
}
}
// Added
void CameraViewPoint::store(const SceneFile& in_file, a3d::CameraViewPoint& out_cvp) const {
model_transform.store(in_file, out_cvp.model_transform);
roll.store(in_file, out_cvp.roll);
if (has_fov) {
out_cvp.has_fov = true;
fov.store(in_file, out_cvp.fov);
out_cvp.fov_is_horizontal = fov_is_horizontal;
out_cvp.aspect = aspect;
}
else {
focal_length.store(in_file, out_cvp.focal_length);
out_cvp.camera_aperture_w = camera_aperture_w;
out_cvp.camera_aperture_h = camera_aperture_h;
}
}
// 0x1401BB3F0
CameraViewPoint& CameraViewPoint::operator=(const CameraViewPoint& other) {
model_transform = other.model_transform;
roll = other.roll;
has_fov = other.has_fov;
fov_is_horizontal = other.fov_is_horizontal;
fov = other.fov;
aspect = other.aspect;
focal_length = other.focal_length;
camera_aperture_w = other.camera_aperture_w;
camera_aperture_h = other.camera_aperture_h;
return *this;
}
// 0x1401B2A60
CameraRoot::CameraRoot() : model_transform(), interest(), view_point() {
}
// 0x1401B2A00
CameraRoot::CameraRoot(const CameraRoot& other) : model_transform(other.model_transform),
interest(other.interest), view_point(other.view_point) {
}
// 0x1401B8240
CameraRoot::~CameraRoot() {
}
// Inlined
inline void CameraRoot::init() {
model_transform.init();
interest.init();
view_point.init();
}
// 0x1401D3C70
CameraParam CameraRoot::get(float_t in_frame, const Scene& in_scene, render_context* rctx) {
float_t frame = in_frame;
Fcurve3f& vp_translation = view_point.model_transform.fcurve_translation;
Fcurve3f& intr_translation = interest.model_transform.fcurve_translation;
if (vp_translation.x.check_threshold_discontinuity(frame)
|| vp_translation.y.check_threshold_discontinuity(frame)
|| vp_translation.z.check_threshold_discontinuity(frame)
|| intr_translation.x.check_threshold_discontinuity(frame)
|| intr_translation.y.check_threshold_discontinuity(frame)
|| intr_translation.z.check_threshold_discontinuity(frame)) {
frame = prj::floorf(frame);
rctx->camera->set_fast_change(true);
}
else {
float_t frame_prev = frame - get_delta_frame();
if (frame_prev > 0.0f && (int32_t)frame - (int32_t)frame_prev == 2) {
frame_prev = prj::ceilf(frame_prev);
if (vp_translation.x.check_threshold_discontinuity(frame_prev)
|| vp_translation.y.check_threshold_discontinuity(frame_prev)
|| vp_translation.z.check_threshold_discontinuity(frame_prev)
|| intr_translation.x.check_threshold_discontinuity(frame_prev)
|| intr_translation.y.check_threshold_discontinuity(frame_prev)
|| intr_translation.z.check_threshold_discontinuity(frame_prev))
rctx->camera->set_fast_change_hist0(true);
}
}
CameraParam cam;
model_transform.get(frame);
model_transform.mul(mat4_identity);
const mat4& cr_mat = model_transform.get_matrix();
vec3 _view_point = vp_translation.get(frame);
mat4_transform_point(&cr_mat, &_view_point, &cam.view_point);
vec3 _interest = intr_translation.get(frame);
mat4_transform_point(&cr_mat, &_interest, &cam.interest);
cam.v_fov = view_point.get_v_fov(frame) * in_scene.M_fov_adjust;
cam.roll = view_point.roll.get(frame);
return cam;
}
// 0x1401D9CA0
bool CameraRoot::load(const SceneFile& in_file, const a3d::CameraRoot& in_cr) {
model_transform.load(in_file, in_cr.model_transform);
interest.load(in_file, in_cr.interest);
view_point.load(in_file, in_cr.view_point);
return true;
}
// Added
void CameraRoot::store(const SceneFile& in_file, a3d::CameraRoot& out_cr) const {
model_transform.store(in_file, out_cr.model_transform);
interest.store(in_file, out_cr.interest);
view_point.store(in_file, out_cr.view_point);
}
// 0x1401BB3A0
CameraRoot& CameraRoot::operator=(const CameraRoot& other) {
model_transform = other.model_transform;
interest = other.interest;
view_point = other.view_point;
return *this;
}
// 0x1401B3000
Chara::Chara() : name(), model_transform(), rob_id(ROB_ID_NULL) {
}
// 0x1401B2F90
Chara::Chara(const Chara& other)
: name(other.name), model_transform(other.model_transform), rob_id(other.rob_id) {
}
// 0x1401B8520
Chara::~Chara() {
}
// 0x1401D4060
void Chara::get(float_t in_frame) {
model_transform.get(in_frame);
}
// 0x1401CE470
void Chara::ctrl(Scene& in_scene) {
mat4 base_matrix = in_scene.get_base_matrix();
vec3 pos = model_transform.translation;
if (in_scene.get_reverse_side())
pos.x = -pos.x;
mat4_transform_point(&base_matrix, &pos, &pos);
RobAngle mt_yang;
mt_yang.set_rad(model_transform.rotation.y);
if (in_scene.get_reverse_side())
mt_yang = -mt_yang;
RobAngle base_yang;
base_yang.set_rad(atan2f(base_matrix.row2.x, base_matrix.row2.z));
RobAngle yang = base_yang + mt_yang;
if (rob_id >= 0 && rob_id < ROB_ID_MAX) {
RobManagement* rob_man = get_rob_management();
rob_man->set_rob_pos((ROB_ID)rob_id, pos);
rob_man->set_rob_yang((ROB_ID)rob_id, yang);
}
}
// 0x1401D0380
void Chara::disp(const Scene& in_scene, const mat4& in_base_mat, render_context* rctx) {
if (rob_id >= 0 && rob_id < ROB_ID_MAX)
get_rob_management()->set_disp_on((ROB_ID)rob_id, model_transform.visibility);
if (in_scene.M_debug) {
model_transform.mul(in_scene.base_matrix);
debug_put_line_axis(model_transform.get_matrix());
}
}
// 0x1401E63E0
void Chara::set_disp_freeze(bool in_value) const {
if (rob_id >= 0 && rob_id < ROB_ID_MAX)
get_rob_management()->set_disp_freeze((ROB_ID)rob_id, in_value);
}
// 0x1401D8A70
bool Chara::is_bind() const {
return rob_id >= 0 && rob_id < ROB_ID_MAX;
}
// 0x1401DA100
bool Chara::load(const SceneFile& in_file, const a3d::Chara& in_c) {
name.assign(in_c.name);
model_transform.load(in_file, in_c.model_transform);
return true;
}
// Added
void Chara::store(const SceneFile& in_file, a3d::Chara& out_c) const {
out_c.name.assign(name);
model_transform.store(in_file, out_c.model_transform);
}
// 0x1401BB6F0
Chara& Chara::operator=(const Chara& other) {
name.assign(other.name);
model_transform = other.model_transform;
rob_id = other.rob_id;
return *this;
}
// 0x1401B3180
Curve::Curve() : curve(), name(), value() {
}
// 0x1401B30E0
Curve::Curve(const Curve& other) : curve(other.curve), name(other.name), value(other.value) {
}
// 0x1401B85B0
Curve::~Curve() {
}
// 0x1401D4140
void Curve::get(float_t in_frame) {
value = curve.get(in_frame);
}
// Inlined
inline Fcurve* Curve::M_get_fcurve() {
return &curve;
}
// 0x1401DA230
bool Curve::load(const SceneFile& in_file, const a3d::Curve& in_c) {
curve.load(in_file, in_c.fcurve);
name.assign(in_c.name);
return true;
}
// Added
void Curve::store(const SceneFile& in_file, a3d::Curve& out_c) const {
curve.store(in_file, out_c.fcurve);
out_c.name.assign(name);
}
// 0x1401BB7D0
Curve& Curve::operator=(const Curve& other) {
curve = other.curve;
name.assign(other.name);
value = other.value;
return *this;
}
// 0x1401B3220
CurveWithOffset::CurveWithOffset() : fcurve_ptr(), offset(), value() {
init();
}
// 0x1401B31C0
CurveWithOffset::CurveWithOffset(const CurveWithOffset& other)
: fcurve_ptr(other.fcurve_ptr), offset(other.offset), value(other.value) {
}
// 0x1401B8610
CurveWithOffset::~CurveWithOffset() {
}
// 0x1401D6CD0
void CurveWithOffset::init() {
fcurve_ptr = 0;
name.clear();
name.shrink_to_fit();
offset = 0.0f;
value = 0.0f;
}
// Inlined
inline void CurveWithOffset::bind(Curve& in_c) {
fcurve_ptr = &in_c;
}
// 0x1401D4160
void CurveWithOffset::get(float_t in_frame) {
if (!fcurve_ptr)
return;
float_t frame = in_frame;
if (offset != 0.0f) {
frame += offset;
if (frame >= fcurve_ptr->curve.m_max_frame)
frame -= fcurve_ptr->curve.m_max_frame;
}
value = fcurve_ptr->curve.get(frame);
}
// Inlined
inline bool CurveWithOffset::is_valid() const {
return fcurve_ptr != 0;
}
// 0x1401BB860
CurveWithOffset& CurveWithOffset::operator=(const CurveWithOffset& other) {
fcurve_ptr = other.fcurve_ptr;
name.assign(other.name);
offset = other.offset;
value = other.value;
return *this;
}
// 0x1401B32C0
Dof::Dof() : has_dof() {
init();
}
// Missing
Dof::Dof(const Dof& other) : has_dof(other.has_dof), model_transform(other.model_transform) {
}
// 0x1401B86D0
Dof::~Dof() {
}
// 0x1401D6CF0
void Dof::init() {
has_dof = false;
model_transform.init();
}
// 0x1401D41A0
void Dof::get(float_t in_frame) {
if (has_dof)
model_transform.get(in_frame);
}
// 0x1401CE5F0
void Dof::ctrl(render_context* rctx) {
if (!has_dof)
return;
vec3 view_point;
rctx->camera->get_view_point(view_point);
float_t focus = vec3::distance(model_transform.translation, view_point);
rctx->render->enable_dof_set(fabsf(model_transform.rotation.z) > 0.000001f);
rctx->render->set_dof_data(focus, model_transform.scale.x,
model_transform.rotation.x, model_transform.rotation.y);
}
// 0x1401CFE70
void Dof::dest(render_context* rctx) {
if (has_dof)
rctx->render->enable_dof_set(false);
has_dof = false;
init();
}
// 0x1401DAFA0
bool Dof::load(const SceneFile& in_file, const a3d::Dof& in_d) {
if (in_d.has_dof) {
model_transform.load(in_file, in_d.model_transform);
has_dof = true;
}
return true;
}
// Added
void Dof::store(const SceneFile& in_file, a3d::Dof& out_d) const {
if (has_dof) {
model_transform.store(in_file, out_d.model_transform);
out_d.has_dof = true;
}
}
// Missing
Dof& Dof::operator=(const Dof& other) {
has_dof = other.has_dof;
model_transform = other.model_transform;
return *this;
}
// 0x1401B32E0
Event::Event(const a3d::Event& in_e) {
active = false;
switch (in_e.type) {
case a3d::EVENT_MISC:
default:
type = EVENT_MISC;
break;
case a3d::EVENT_FLT:
type = EVENT_FLT;
break;
case a3d::EVENT_FX:
type = EVENT_FX;
break;
case a3d::EVENT_SND:
type = EVENT_SND;
break;
case a3d::EVENT_MOT:
type = EVENT_MOT;
break;
case a3d::EVENT_A2D:
type = EVENT_A2D;
break;
}
name.assign(in_e.name);
index = 0;
begin = in_e.begin;
end = in_e.end;
param1.assign(in_e.param1);
ref.assign(in_e.ref);
ref_index = -1;
}
// 0x1401B8730
Event::~Event() {
}
// 0x1401E5CD0
void Event::resolve_relation(const Scene& in_scene) {
}
// 0x1401D1E80
void Event::entry(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
}
// 0x1401D3880
void Event::exit(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
}
// 0x1401D14F0
void Event::do_ctrl(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
}
// 0x1401D1750
void Event::do_disp(const Scene& in_scene, const mat4& in_mat, render_context* rctx) {
}
// Added
void Event::store(const SceneFile& in_file, a3d::Event& out_e) const {
}
// 0x1401B3710
EventA2d::EventA2d(const a3d::Event& in_e) : Event(in_e) {
}
// 0x1401B87C0
EventA2d::~EventA2d() {
}
// 0x1401D1E90
void EventA2d::entry(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
float_t frame = in_scene.get_frame();
if (frame >= begin && frame < end)
M_a2d_handle.restart();
}
// 0x1401D3890
void EventA2d::exit(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
}
// 0x1401D1500
void EventA2d::do_ctrl(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
}
// 0x1401D1760
void EventA2d::do_disp(const Scene& in_scene, const mat4& in_mat, render_context* rctx) {
}
// 0x1401B3860
EventFX::EventFX(const a3d::Event& in_e) : Event(in_e) {
}
// 0x1401B87F0
EventFX::~EventFX() {
}
// 0x1401E5CE0
void EventFX::resolve_relation(const Scene& in_scene) {
if (param1.compare("DOWN") && param1.compare("KABEHIT1") && param1.compare("PAPER1"))
return;
ref_index = in_scene.get_point_index(ref);;
}
// 0x1401D1EF0
void EventFX::entry(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
event_log(" [FX]: %s\n", param1.c_str());
}
// 0x1401D1510
void EventFX::do_ctrl(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
if (ref_index >= in_scene.point_list.size() || in_scene.M_frame < begin
|| in_scene.M_frame >= end || param1.compare("PAPER1"))
return;
mat4 base_matrix = in_scene.get_base_matrix();
const Point& point = in_scene.point_list[ref_index];
vec3 pos = point.model_transform.translation;
if (in_scene.get_reverse_side())
pos.x = -pos.x;
mat4_transform_point(&base_matrix, &pos, &pos);
particle_event_data event;
event.type = 1.0f;
event.count = point.model_transform.scale.x * 100.0f;
event.size = point.model_transform.scale.z;
event.pos = pos;
event.force = point.model_transform.scale.y;
effect_manager_event(EFFECT_PARTICLE, 1, &event);
}
// 0x1401B3890
EventFXSmoothCut::EventFXSmoothCut(const a3d::Event& in_e) : Event(in_e), is_camera() {
}
// 0x1401B8800
EventFXSmoothCut::~EventFXSmoothCut() {
}
// 0x1401E5E10
void EventFXSmoothCut::resolve_relation(const Scene& in_scene) {
if (!ref.compare("CAM")) {
is_camera = true;
return;
}
ref_index = in_scene.get_chara_index(ref);
}
// 0x1401D1F10
void EventFXSmoothCut::entry(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
if (is_camera || !in_scene.chara_list.size() || ref_index >= in_scene.chara_list.size())
return;
int32_t rob_id = in_scene.chara_list[ref_index].rob_id;
if (rob_id >= 0 && rob_id < ROB_ID_MAX)
get_rob_management()->reset_osage_pos((ROB_ID)rob_id);
}
// 0x1401D38A0
void EventFXSmoothCut::exit(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
}
// 0x1401D1770
void EventFXSmoothCut::do_disp(const Scene& in_scene, const mat4& in_mat, render_context* rctx) {
}
// 0x1401B38C0
EventFilterFade::EventFilterFade(const a3d::Event& in_e) : Event(in_e) {
fade_type = Type::FADE_NONE;
}
// 0x1401B8810
EventFilterFade::~EventFilterFade() {
}
// 0x1401D1F90
void EventFilterFade::entry(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
}
// 0x1401D38B0
void EventFilterFade::exit(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
switch (fade_type) {
case EventFilterFade::Type::FADE_OUT:
case EventFilterFade::Type::FADE_IN:
break;
default:
return;
}
rctx->render->set_fade_color_default();
}
// 0x1401D1780
void EventFilterFade::do_disp(const Scene& in_scene, const mat4& in_mat, render_context* rctx) {
switch (fade_type) {
case EventFilterFade::Type::FADE_OUT:
case EventFilterFade::Type::FADE_IN:
break;
default:
return;
}
float_t t = (in_scene.M_frame - begin) / (end - begin);
vec4 value;
*(vec3*)&value = fade_color;
if (fade_type == EventFilterFade::Type::FADE_IN)
value.w = t;
else
value.w = 1.0f - t;
rctx->render->set_fade_color(&value);
}
// 0x1401B3AD0
EventFilterTimeStop::EventFilterTimeStop(const a3d::Event& in_e) : Event(in_e) {
}
// 0x1401B8820
EventFilterTimeStop::~EventFilterTimeStop() {
}
// 0x1401D1FA0
void EventFilterTimeStop::entry(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
for (const Chara& i : in_scene.chara_list)
i.set_disp_freeze(true);
effect_manager_set_frame_rate_control(&frame_rate_time_stop);
}
// 0x1401D38E0
void EventFilterTimeStop::exit(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
for (const Chara& i : in_scene.chara_list)
i.set_disp_freeze(false);
effect_manager_set_frame_rate_control(get_sys_frame_rate());
}
// 0x1401D1830
void EventFilterTimeStop::do_disp(const Scene& in_scene, const mat4& in_mat, render_context* rctx) {
}
// 0x1401B3B00
EventMot::EventMot(const a3d::Event& in_e) : Event(in_e) {
}
// 0x1401B8830
EventMot::~EventMot() {
}
// 0x1401E5EC0
void EventMot::resolve_relation(const Scene& in_scene) {
ref_index = in_scene.get_chara_index(ref);
}
// 0x1401D1FF0
void EventMot::entry(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
if (ref_index < 0 || ref_index >= in_scene.chara_list.size())
return;
const Chara& chara = in_scene.chara_list[ref_index];
if (chara.rob_id < 0 || chara.rob_id >= ROB_ID_MAX)
return;
data_struct* aft_data = &data_list[DATA_AFT];
bone_database* aft_bone_data = &aft_data->data_ft.bone_data;
motion_database* aft_mot_db = &aft_data->data_ft.mot_db;
mat4 base_matrix = in_scene.get_base_matrix();
vec3 pos = chara.model_transform.translation;
if (in_scene.get_reverse_side())
pos.x = -pos.x;
mat4_transform_point(&base_matrix, &pos, &pos);
RobAngle mt_yang;
mt_yang.set_rad(chara.model_transform.rotation.y);
if (in_scene.get_reverse_side())
mt_yang = -mt_yang;
RobAngle base_yang;
base_yang.set_rad(-atan2f(base_matrix.row2.x, base_matrix.row2.z));
RobAngle yang = base_yang + mt_yang;
RobInit rob_init;
rob_init.rob_type = ROB_TYPE_AUTH;
rob_init.mirror = in_scene.get_reverse_side();
rob_init.pos = pos;
rob_init.yang = yang;
rob_init.energy = 200;
ROB_ID rob_id = (ROB_ID)chara.rob_id;
RobManagement* rob_man = get_rob_management();
rob_man->reset_rob(rob_id, rob_init, aft_bone_data, aft_mot_db);
rob_man->set_disp_on(rob_id, true);
uint32_t motnum = aft_mot_db->get_motion_id(param1.c_str());
if (motnum != -1 && motion_storage_check_mot_file_not_ready(
aft_mot_db->get_motion_set_id_by_motion_id(motnum)))
rob_man->set_motion(rob_id, motnum);
}
// 0x1401D3940
void EventMot::exit(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
}
// 0x1401D16F0
void EventMot::do_ctrl(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
float_t frame = in_scene.get_frame();
if (begin <= frame && frame < end) {
int32_t rob_id = in_scene.chara_list[ref_index].rob_id;
get_rob_management()->set_mot_frame((ROB_ID)rob_id, frame);
}
}
// 0x1401D1840
void EventMot::do_disp(const Scene& in_scene, const mat4& in_mat, render_context* rctx) {
}
// 0x1401B3B30
EventSnd::EventSnd(const a3d::Event& in_e) : Event(in_e) {
is_pseudo = param1.find("zz", 0, 2) == 0;
}
// 0x1401B8840
EventSnd::~EventSnd() {
}
// 0x1401E5EF0
void EventSnd::resolve_relation(const Scene& in_scene) {
}
// 0x1401B8840
void EventSnd::entry(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
float_t frame = in_scene.M_frame;
if (begin > frame || frame >= end || ((in_eaf & EAF_JUMP_BACKWARD) && fabsf(frame - begin) > 0.1f))
return;
ROB_ID rob_id = ROB_ID_NULL;
if (in_scene.chara_list.size())
rob_id = (ROB_ID)in_scene.chara_list.front().rob_id;
if (rob_id >= 0 && rob_id < ROB_ID_MAX)
get_rob_management()->play_auth3d_sound(rob_id, param1.c_str());
else if (sound_work_has_property(param1.c_str()))
sound_work_play_se(1, param1.c_str());
}
// 0x1401D3950
void EventSnd::exit(const Scene& in_scene, EventActionFlag in_eaf, render_context* rctx) {
}
// 0x1401D1850
void EventSnd::do_disp(const Scene& in_scene, const mat4& in_mat, render_context* rctx) {
}
// 0x1401B4470
Fog::Fog() : flag(), backup_flag(), id(), name(), fcurve_density(), fcurve_start(), fcurve_end(),
density(), start(), end(), color(), backup_density(), backup_start(), backup_end(), backup_color() {
}
// 0x1401B41C0
Fog::Fog(const Fog& other) : flag(other.flag), backup_flag(other.backup_flag), id(other.id), name(other.name),
fcurve_density(other.fcurve_density), fcurve_start(other.fcurve_start), fcurve_end(other.fcurve_end),
density(other.density), start(other.start), end(other.end), color(other.color),
backup_density(other.backup_density), backup_start(other.backup_start),
backup_end(other.backup_end), backup_color(other.backup_color) {
}
// 0x1401B89B0
Fog::~Fog() {
}
// 0x1401D7150
void Fog::init() {
id = -1;
flag = 0;
backup_flag = 0;
name.assign("(init)");
density = 0.0f;
start = 10.0f;
end = 100.0f;
fcurve_density.init();
fcurve_start.init();
fcurve_end.init();
}
// 0x1401CE730
void Fog::ctrl(render_context* rctx) {
if (id < 0 || id > FOG_MAX)
return;
fog* data = &rctx->fog[id];
if (has_start()) {
if (!(backup_flag & FLAG_START)) {
backup_start = data->get_start();
backup_flag |= FLAG_START;
}
data->set_start(start);
}
if (has_end()) {
if (!(backup_flag & FLAG_END)) {
backup_end = data->get_end();
backup_flag |= FLAG_END;
}
data->set_end(end);
}
if (has_density()) {
if (!(backup_flag & FLAG_DENSITY)) {
backup_density = data->get_density();
backup_flag |= FLAG_DENSITY;
}
data->set_density(density);
}
if (has_color()) {
if (!(backup_flag & FLAG_COLOR)) {
vec4 color;
data->get_color(color);
backup_color = color;
backup_flag |= FLAG_COLOR;
}
data->set_color(color.color);
}
}
// 0x1401CFEB0
void Fog::dest(render_context* rctx) {
if (id < 0 || id >= FOG_MAX)
return;
fog* data = &rctx->fog[id];
if (backup_flag & FLAG_DENSITY)
data->set_density(backup_density);
if (backup_flag & FLAG_START)
data->set_start(backup_start);
if (backup_flag & FLAG_END)
data->set_end(backup_end);
if (backup_flag & FLAG_COLOR)
data->set_color(backup_color);
init();
}
// 0x1401D4500
void Fog::get(float_t in_frame) {
if (has_density())
density = fcurve_density.get(in_frame);
if (has_start())
start = fcurve_start.get(in_frame);
if (has_end())
end = fcurve_end.get(in_frame);
if (has_color())
color.get(in_frame);
}
// 0x1401DBB20
bool Fog::load(const SceneFile& in_file, const a3d::Fog& in_f) {
id = in_f.id;
name.assign(in_f.name);
if (in_f.flag & a3d::Fog::FLAG_DENSITY) {
fcurve_density.load(in_file, in_f.density);
flag |= FLAG_DENSITY;
}
if (in_f.flag & a3d::Fog::FLAG_START) {
fcurve_start.load(in_file, in_f.start);
flag |= FLAG_START;
}
if (in_f.flag & a3d::Fog::FLAG_END) {
fcurve_end.load(in_file, in_f.end);
flag |= FLAG_END;
}
if (in_f.flag & a3d::Fog::FLAG_COLOR) {
color.load(in_file, in_f.color);
flag |= FLAG_COLOR;
}
return true;
}
// Added
void Fog::store(const SceneFile& in_file, a3d::Fog& out_f) const {
out_f.id = id;
out_f.name.assign(name);
if (flag & FLAG_DENSITY) {
fcurve_density.store(in_file, out_f.density);
out_f.flag |= a3d::Fog::FLAG_DENSITY;
}
if (flag & FLAG_START) {
fcurve_start.store(in_file, out_f.start);
out_f.flag |= a3d::Fog::FLAG_START;
}
if (flag & FLAG_END) {
fcurve_end.store(in_file, out_f.end);
out_f.flag |= a3d::Fog::FLAG_END;
}
if (flag & FLAG_COLOR) {
color.store(in_file, out_f.color);
out_f.flag |= a3d::Fog::FLAG_COLOR;
}
}
// 0x1401BBD30
Fog& Fog::operator=(const Fog& other) {
flag = other.flag;
backup_flag = other.backup_flag;
id = other.id;
name.assign(other.name);
fcurve_density = other.fcurve_density;
fcurve_start = other.fcurve_start;
fcurve_end = other.fcurve_end;
density = other.density;
start = other.start;
end = other.end;
color = other.color;
backup_density = other.backup_density;
backup_start = other.backup_start;
backup_end = other.backup_end;
backup_color = other.backup_color;
return *this;
}
// 0x1401B4730
HierarchyObject::HierarchyObject() : node_list(), mats(), ex_node_mat(), name(), uid_name(),
obj_uid(), obj_hash(), is_reflect(), is_refract(), has_shadow(), parent_name(), parent_node(),
child_object_list(), child_object_list_parent_node(),
child_object_hrc_list(), child_object_hrc_list_parent_node() {
}
// 0x1401B45D0
HierarchyObject::HierarchyObject(const HierarchyObject& other) : node_list(other.node_list), mats(other.mats),
ex_node_mat(other.ex_node_mat), name(other.name), uid_name(other.uid_name), obj_uid(other.obj_uid),
obj_hash(other.obj_hash), is_reflect(other.is_reflect), is_refract(other.is_refract),
has_shadow(other.has_shadow), parent_name(other.parent_name), parent_node(other.parent_node),
child_object_list(other.child_object_list),
child_object_list_parent_node(other.child_object_list_parent_node),
child_object_hrc_list(other.child_object_hrc_list),
child_object_hrc_list_parent_node(other.child_object_hrc_list_parent_node) {
}
// 0x1401B8A80
HierarchyObject::~HierarchyObject() {
}
// 0x1401D72A0
void HierarchyObject::init() {
name.clear();
name.shrink_to_fit();
uid_name.clear();
uid_name.shrink_to_fit();
obj_uid = {};
obj_hash = (uint32_t)-1;
is_reflect = false;
is_refract = false;
has_shadow = false;
node_list.clear();
node_list.shrink_to_fit();
mats.clear();
mats.shrink_to_fit();
parent_name.clear();
parent_name.shrink_to_fit();
parent_node.clear();
parent_node.shrink_to_fit();
child_object_list.clear();
child_object_list.shrink_to_fit();
child_object_list_parent_node.clear();
child_object_list_parent_node.shrink_to_fit();
child_object_hrc_list.clear();
child_object_hrc_list.shrink_to_fit();
child_object_hrc_list_parent_node.clear();
child_object_hrc_list_parent_node.shrink_to_fit();
}
// 0x1401D45A0
void HierarchyObject::get(float_t in_frame) {
for (TransformNode& i : node_list)
i.get(in_frame);
}
// 0x1401CE860
void HierarchyObject::ctrl(const mat4& in_base_mat) {
//if (!node.front().motion_transform.visibility)
// return;
calc_matrix_hierarchy(in_base_mat);
TransformNode* node = node_list.data();
for (size_t i = 0; i < child_object_list.size(); i++)
child_object_list[i]->ctrl(node[child_object_list_parent_node[i]].motion_transform.matrix);
for (size_t i = 0; i < child_object_hrc_list.size(); i++)
child_object_hrc_list[i]->ctrl(
node[child_object_hrc_list_parent_node[i]].motion_transform.matrix);
}
// 0x1401D04A0
void HierarchyObject::disp(Scene& in_scene, render_context* rctx) {
if (!in_scene.M_is_visible || !node_list.front().motion_transform.visibility)
return;
mdl::DispManager& disp_manager = *rctx->disp_manager;
const object_database* obj_db = in_scene.obj_db;
const texture_database* tex_db = in_scene.tex_db;
mdl::ObjFlags flag = mdl::OBJ_SSS;
if (in_scene.M_shadow | has_shadow)
enum_or(flag, mdl::OBJ_4 | mdl::OBJ_SHADOW);
if (is_reflect)
enum_or(flag, mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFLECT);
if (is_refract)
enum_or(flag, mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFRACT);
if (in_scene.trnsl < 1.0f)
enum_or(flag, in_scene.trnsl_state);
disp_manager.set_obj_flags(flag);
disp_manager.set_shadow_group(0);
mat4 mat = mat4_identity;
if (in_scene.M_assign_rob_id >= 0 && in_scene.M_assign_rob_id < ROB_ID_MAX) {
RobManagement* rob_man = get_rob_management();
if (rob_man->is_init((ROB_ID)in_scene.M_assign_rob_id)) {
rob_chara* rob_chr = rob_man->get_rob((ROB_ID)in_scene.M_assign_rob_id);
mat4_mul(&rob_chr->rob_base.position.rob_mat,
in_scene.M_chara_item
? &rob_chr->rob_base.adjust.item_mat
: &rob_chr->rob_base.adjust.mat, &mat);
if (in_scene.M_assign_rob_id)
disp_manager.set_shadow_group(1);
}
}
else if (flag & mdl::OBJ_SHADOW) {
disp_manager.set_shadow_group(1);
const mat4& root_matrix = get_root_matrix();
vec3 pos;
mat4_get_translation(&root_matrix, &pos);
get_shadow()->set_dist_base(1, &pos);
}
if (mats.size())
disp_manager.entry_obj_by_object_info_object_skin(
obj_uid, 0, 0, in_scene.trnsl, mats.data(), 0, 0, mat);
disp_manager.set_obj_flags();
disp_manager.set_shadow_group(0);
for (Object*& i : child_object_list)
i->disp(in_scene, rctx);
for (HierarchyObject*& i : child_object_hrc_list)
i->disp(in_scene, rctx);
}
void HierarchyObject::add_child_object(int32_t in_index, Object* in_obj) {
child_object_list_parent_node.push_back(in_index);
child_object_list.push_back(in_obj);
}
void HierarchyObject::add_child_object(int32_t in_index, HierarchyObject * in_obj) {
child_object_hrc_list_parent_node.push_back(in_index);
child_object_hrc_list.push_back(in_obj);
}
// 0x1401CA530
void HierarchyObject::assign_object_skin() {
const obj_skin* skin = get_object_skin(obj_uid);
if (!skin) {
std::string error_str = sprintf_s_string("%s skin data is not found", uid_name.c_str());
throw std::runtime_error(error_str.c_str());
}
size_t bone_num = 0;
for (TransformNode& i : node_list) {
if (!skin->num_bone)
continue;
size_t num_bone = skin->num_bone;
for (size_t j = 0; j < num_bone; j++)
if (!i.name.compare(skin->bone_array[j].name)) {
i.node_index = skin->bone_array[j].id;
bone_num++;
break;
}
}
if (!node_list.size() || !bone_num) {
std::string error_str = sprintf_s_string("%s skin data has no bone", uid_name.c_str());
throw std::runtime_error(error_str.c_str());
}
if (ex_node_mat) {
for (TransformNode& i : node_list)
if (i.node_index >= 0 && (i.node_index & 0x8000))
i.mat_ptr = &ex_node_mat[i.node_index & 0x7FFF];
}
else {
if (bone_num != skin->num_bone)
throw std::runtime_error("bone_num mismatch");
mats.resize(bone_num);
for (TransformNode& i : node_list)
if (i.node_index >= 0 && !(i.node_index & 0x8000))
i.mat_ptr = &mats[i.node_index];
}
}
// 0x1401CB190
void HierarchyObject::calc_matrix_hierarchy(const mat4& in_base_mat) {
for (TransformNode& i : node_list) {
i.motion_transform.calc_matrix_local();
mat4 mat;
if (i.parent_id >= 0)
mat = node_list[i.parent_id].motion_transform.matrix;
else
mat = in_base_mat;
i.calc_matrix_local(mat);
}
}
// 0x1401E3510
bool HierarchyObject::replace_chara(int32_t in_cn_src, int32_t in_cn_dst, const object_database* obj_db) {
if (in_cn_src < 0 || in_cn_src >= CN_MAX
|| in_cn_dst < 0 || in_cn_dst >= CN_MAX || in_cn_src == in_cn_dst)
return false;
std::string cn_src_str(get_char_id_str((CHARA_NUM)in_cn_src));
std::string cn_dst_str(get_char_id_str((CHARA_NUM)in_cn_dst));
std::string uid_name(this->uid_name);
size_t pos = uid_name.find(cn_src_str);
if (pos != -1)
uid_name.assign(uid_name.replace(pos, cn_src_str.size(), cn_dst_str));
object_info obj_uid = obj_db->get_object_info(uid_name.c_str());
if (obj_uid.not_null()) {
this->obj_uid = obj_uid;
this->uid_name.assign(uid_name);
return true;
}
return false;
}
// 0x1401CC0B0
void HierarchyObject::check_rob_chara(const std::string& in_name) {
static std::string chara_str("_CHARA");
static std::string exchr_str("_EXCHR");
for (TransformNode& i : node_list) {
if (i.name.find(chara_str) == -1) {
if (i.name.find(exchr_str.c_str()) == -1)
continue;
std::string chr = i.name.substr(i.name.find(exchr_str) + exchr_str.size()) + "____";
if (in_name.size() && chr.find(in_name) == -1 || !in_name.size())
i.motion_transform.init_static();
}
else {
std::string chr = i.name.substr(i.name.find(chara_str) + chara_str.size());
if (in_name.size() && chr.find(in_name) == -1)
i.motion_transform.init_static();
}
}
}
// 0x1401D5EB0
const mat4& HierarchyObject::get_root_matrix() const {
for (const TransformNode& i : node_list)
if (i.mat_ptr)
return *i.mat_ptr;
return node_list.front().motion_transform.matrix;
}
// 0x1401D8D20
void HierarchyObject::join(const HierarchyObject& in_other, float_t in_blend, float_t in_inv_blend) {
if (node_list.size() != in_other.node_list.size())
return;
for (size_t i = 0; i < node_list.size(); i++)
node_list[i].motion_transform.join(
in_other.node_list[i].motion_transform, in_blend, in_inv_blend);
}
// 0x1401D93B0
void HierarchyObject::join_lock(const HierarchyObject& in_other, float_t in_blend, float_t in_inv_blend) {
if (node_list.size() != in_other.node_list.size())
return;
for (size_t i = 0; i < node_list.size(); i++)
node_list[i].motion_transform.join_lock(
in_other.node_list[i].motion_transform, in_blend, in_inv_blend);
}
// 0x1401E1340
void HierarchyObject::lock_set() {
for (TransformNode& i : node_list)
i.motion_transform.lock_set();
}
// 0x1401E5F30
int32_t HierarchyObject::query_node_index(const char* in_name) const {
for (const TransformNode& i : node_list)
if (!i.name.compare(in_name))
return (int32_t)(&i - node_list.data());
return -1;
}
// 0x1401E69E0
void HierarchyObject::set_obj_uid(object_info objuid) {
if (objuid.not_null())
obj_uid = objuid;
assign_object_skin();
}
// 0x1401DBED0
bool HierarchyObject::load(const SceneFile& in_file,
const a3d::ObjectHrc& in_oh, const object_database* obj_db) {
name.assign(in_oh.name);
uid_name.assign(in_oh.uid_name);
obj_uid = obj_db->get_object_info(uid_name.c_str());
obj_hash = hash_string_murmurhash(uid_name);
static std::string reflect_str = "_REFLECT";
is_reflect = uid_name.find(reflect_str) != -1;
static std::string refract_str = "_REFRACT";
is_refract = uid_name.find(refract_str) != -1;
has_shadow = in_oh.shadow;
list_load(node_list, in_file, in_oh.node);
parent_name.assign(in_oh.parent_name);
parent_node.assign(in_oh.parent_node);
int32_t node_index = 0;
for (TransformNode& i : node_list) {
if (i.parent_id >= node_index)
throw std::range_error("parent_id is not less than child");
node_index++;
}
return true;
}
// Added
void HierarchyObject::store(const SceneFile& in_file, a3d::ObjectHrc& out_oh) const {
out_oh.name.assign(name);
out_oh.uid_name.assign(uid_name);
out_oh.shadow = has_shadow;
list_store(node_list, in_file, out_oh.node);
out_oh.parent_name.assign(parent_name);
out_oh.parent_node.assign(parent_node);
}
// 0x1401BBF50
HierarchyObject& HierarchyObject::operator=(const HierarchyObject& other) {
node_list.assign(other.node_list.begin(), other.node_list.end());
mats.assign(other.mats.begin(), other.mats.end());
ex_node_mat = other.ex_node_mat;
name.assign(other.name);
uid_name.assign(other.uid_name);
obj_uid = other.obj_uid;
obj_hash = other.obj_hash;
is_reflect = other.is_reflect;
is_refract = other.is_refract;
has_shadow = other.has_shadow;
parent_name.assign(other.parent_name);
parent_node.assign(other.parent_node);
child_object_list.assign(
other.child_object_list.begin(), other.child_object_list.end());
child_object_list_parent_node.assign(
other.child_object_list_parent_node.begin(), other.child_object_list_parent_node.end());
child_object_hrc_list.assign(
other.child_object_hrc_list.begin(), other.child_object_hrc_list.end());
child_object_hrc_list_parent_node.assign(
other.child_object_hrc_list_parent_node.begin(), other.child_object_hrc_list_parent_node.end());
return *this;
}
// 0x1401B4B20
Light::Light() : flag(), backup_flag(), id(), name(), type(), position(), spot_direction(),
ambient(), diffuse(), specular(), tone_curve(), fcurve_constant(), fcurve_intensity(), fcurve_far(),
fcurve_linear(), fcurve_quadratic(), fcurve_drop_off(), fcurve_cone_angle(), constant(), intensity(),
far_(), linear(), quadratic(), drop_off(), cone_angle(), backup_ambient(), backup_diffuse(),
backup_specular(), backup_tone_curve(), backup_constant(), backup_intensity(), backup_far(),
backup_linear(), backup_quadratic(), backup_drop_off(), backup_cone_angle() {
}
// 0x1401B4840
Light::Light(const Light& other) : flag(other.flag), backup_flag(other.backup_flag), id(other.id),
name(other.name), type(other.type), position(other.position), spot_direction(other.spot_direction),
ambient(other.ambient), diffuse(other.diffuse), specular(other.specular), tone_curve(other.tone_curve),
fcurve_constant(other.fcurve_constant), fcurve_intensity(other.fcurve_intensity),
fcurve_far(other.fcurve_far), fcurve_linear(other.fcurve_linear), fcurve_quadratic(other.fcurve_quadratic),
fcurve_drop_off(other.fcurve_drop_off), fcurve_cone_angle(other.fcurve_cone_angle), constant(other.constant),
intensity(other.intensity), far_(other.far_), linear(other.linear), quadratic(other.quadratic),
drop_off(other.drop_off), cone_angle(other.cone_angle),
backup_ambient(other.backup_ambient), backup_diffuse(other.backup_diffuse),
backup_specular(other.backup_specular), backup_tone_curve(other.backup_tone_curve),
backup_constant(other.backup_constant), backup_intensity(other.backup_intensity),
backup_far(other.backup_far), backup_linear(other.backup_linear), backup_quadratic(other.backup_quadratic),
backup_drop_off(other.backup_drop_off), backup_cone_angle(other.backup_cone_angle) {
}
// 0x1401B8C30
Light::~Light() {
}
// 0x1401D7450
void Light::init() {
id = -1;
flag = 0;
backup_flag = 0;
name.assign("(init)");
type.assign("(init)");
position.init();
spot_direction.init();
}
// 0x1401CEA90
void Light::ctrl(render_context* rctx) {
light_set* set = &rctx->light_set[LIGHT_SET_MAIN];
if (has_ambient()) {
if (!(backup_flag & FLAG_AMBIENT)) {
vec4 ambient;
set->lights[id].get_ambient(ambient);
backup_ambient = ambient;
backup_flag |= FLAG_AMBIENT;
}
set->lights[id].set_ambient(ambient.color, ambient.has_color);
}
if (has_diffuse()) {
if (!(backup_flag & FLAG_DIFFUSE)) {
vec4 diffuse;
set->lights[id].get_diffuse(diffuse);
backup_diffuse = diffuse;
backup_flag |= FLAG_DIFFUSE;
}
set->lights[id].set_diffuse(diffuse.color, diffuse.has_color);
}
if (has_specular()) {
if (!(backup_flag & FLAG_SPECULAR)) {
vec4 specular;
set->lights[id].get_specular(specular);
backup_specular = specular;
backup_flag |= FLAG_SPECULAR;
}
set->lights[id].set_specular(specular.color, specular.has_color);
}
if (has_tone_curve()) {
if (!(backup_flag & FLAG_TONE_CURVE)) {
set->lights[id].get_tone_curve(backup_tone_curve);
backup_flag |= FLAG_TONE_CURVE;
}
light_tone_curve curve;
curve.start_point = tone_curve.color.x;
curve.end_point = tone_curve.color.y;
curve.coefficient = tone_curve.color.z;
set->lights[id].set_tone_curve(curve);
}
if (id >= 0 && id < LIGHT_MAX) {
light_data* data = &set->lights[id];
data->set_position(position.translation);
data->set_spot_direction(spot_direction.translation);
}
}
// 0x1401CFF60
void Light::dest(render_context* rctx) {
light_set* set = &rctx->light_set[LIGHT_SET_MAIN];
if (backup_flag & FLAG_AMBIENT)
set->lights[id].set_ambient(backup_ambient);
if (backup_flag & FLAG_DIFFUSE)
set->lights[id].set_diffuse(backup_diffuse);
if (backup_flag & FLAG_SPECULAR)
set->lights[id].set_specular(backup_specular);
if (backup_flag & FLAG_TONE_CURVE)
set->lights[id].set_tone_curve(backup_tone_curve);
init();
}
// 0x1401DCA70
bool Light::load(const SceneFile& in_file, const a3d::Light& in_l) {
id = in_l.id;
name.assign(in_l.name);
type.assign(in_l.type);
position.load(in_file, in_l.position);
spot_direction.load(in_file, in_l.spot_direction);
if (in_l.flag & a3d::Light::FLAG_AMBIENT) {
ambient.load(in_file, in_l.ambient);
flag |= FLAG_AMBIENT;
}
if (in_l.flag & a3d::Light::FLAG_DIFFUSE) {
diffuse.load(in_file, in_l.diffuse);
flag |= FLAG_DIFFUSE;
}
if (in_l.flag & a3d::Light::FLAG_SPECULAR) {
specular.load(in_file, in_l.specular);
flag |= FLAG_SPECULAR;
}
if (in_l.flag & a3d::Light::FLAG_TONE_CURVE) {
tone_curve.load(in_file, in_l.tone_curve);
flag |= FLAG_TONE_CURVE;
}
/// XHD
if (in_l.flag & a3d::Light::FLAG_CONSTANT) {
fcurve_constant.load(in_file, in_l.constant);
flag |= FLAG_CONSTANT;
}
/// XHD
if (in_l.flag & a3d::Light::FLAG_INTENSITY) {
fcurve_intensity.load(in_file, in_l.intensity);
flag |= FLAG_INTENSITY;
}
/// XHD
if (in_l.flag & a3d::Light::FLAG_FAR) {
fcurve_far.load(in_file, in_l.far_);
flag |= FLAG_FAR;
}
/// XHD
if (in_l.flag & a3d::Light::FLAG_LINEAR) {
fcurve_linear.load(in_file, in_l.linear);
flag |= FLAG_LINEAR;
}
/// XHD
if (in_l.flag & a3d::Light::FLAG_QUADRATIC) {
fcurve_quadratic.load(in_file, in_l.quadratic);
flag |= FLAG_QUADRATIC;
}
/// XHD
if (in_l.flag & a3d::Light::FLAG_DROP_OFF) {
fcurve_drop_off.load(in_file, in_l.drop_off);
flag |= FLAG_DROP_OFF;
}
/// XHD
if (in_l.flag & a3d::Light::FLAG_CONE_ANGLE) {
fcurve_cone_angle.load(in_file, in_l.cone_angle);
flag |= FLAG_CONE_ANGLE;
}
return true;
}
// Added
void Light::store(const SceneFile& in_file, a3d::Light& out_l) const {
out_l.id = id;
out_l.name.assign(name);
out_l.type.assign(type);
position.store(in_file, out_l.position);
spot_direction.store(in_file, out_l.spot_direction);
if (flag & FLAG_AMBIENT) {
ambient.store(in_file, out_l.ambient);
out_l.flag |= a3d::Light::FLAG_AMBIENT;
}
if (flag & FLAG_DIFFUSE) {
diffuse.store(in_file, out_l.diffuse);
out_l.flag |= a3d::Light::FLAG_DIFFUSE;
}
if (flag & FLAG_SPECULAR) {
specular.store(in_file, out_l.specular);
out_l.flag |= a3d::Light::FLAG_SPECULAR;
}
if (flag & FLAG_TONE_CURVE) {
tone_curve.store(in_file, out_l.tone_curve);
out_l.flag |= a3d::Light::FLAG_TONE_CURVE;
}
/// XHD
if (flag & FLAG_CONSTANT) {
fcurve_constant.store(in_file, out_l.constant);
out_l.flag |= a3d::Light::FLAG_CONSTANT;
}
/// XHD
if (flag & FLAG_INTENSITY) {
fcurve_intensity.store(in_file, out_l.intensity);
out_l.flag |= a3d::Light::FLAG_INTENSITY;
}
/// XHD
if (flag & FLAG_FAR) {
fcurve_far.store(in_file, out_l.far_);
out_l.flag |= a3d::Light::FLAG_FAR;
}
/// XHD
if (flag & FLAG_LINEAR) {
fcurve_linear.store(in_file, out_l.linear);
out_l.flag |= a3d::Light::FLAG_LINEAR;
}
/// XHD
if (flag & FLAG_QUADRATIC) {
fcurve_quadratic.store(in_file, out_l.quadratic);
out_l.flag |= a3d::Light::FLAG_QUADRATIC;
}
/// XHD
if (flag & FLAG_DROP_OFF) {
fcurve_drop_off.store(in_file, out_l.drop_off);
out_l.flag |= a3d::Light::FLAG_DROP_OFF;
}
/// XHD
if (flag & FLAG_CONE_ANGLE) {
fcurve_cone_angle.store(in_file, out_l.cone_angle);
out_l.flag |= a3d::Light::FLAG_CONE_ANGLE;
}
}
// 0x1401D45F0
void Light::get(float_t in_frame) {
position.get(in_frame);
spot_direction.get(in_frame);
if (has_ambient())
ambient.get(in_frame);
if (has_diffuse())
diffuse.get(in_frame);
if (has_specular())
specular.get(in_frame);
if (has_tone_curve())
tone_curve.get(in_frame);
/// XHD
if (has_constant())
constant = fcurve_constant.get(in_frame);
if (has_intensity())
intensity = fcurve_intensity.get(in_frame);
if (has_far())
far_ = fcurve_far.get(in_frame);
if (has_linear())
linear = fcurve_linear.get(in_frame);
if (has_quadratic())
quadratic = fcurve_quadratic.get(in_frame);
if (has_drop_off())
drop_off = fcurve_drop_off.get(in_frame);
if (has_cone_angle())
cone_angle = fcurve_cone_angle.get(in_frame);
}
// 0x1401BC060
Light& Light::operator=(const Light& other) {
flag = other.flag;
backup_flag = other.backup_flag;
id = other.id;
name.assign(other.name);
type.assign(other.type);
position = other.position;
spot_direction = other.spot_direction;
ambient = other.ambient;
diffuse = other.diffuse;
specular = other.specular;
tone_curve = other.tone_curve;
/// XHD
fcurve_constant = other.fcurve_constant;
fcurve_intensity = other.fcurve_intensity;
fcurve_far = other.fcurve_far;
fcurve_linear = other.fcurve_linear;
fcurve_quadratic = other.fcurve_quadratic;
fcurve_drop_off = other.fcurve_drop_off;
fcurve_cone_angle = other.fcurve_cone_angle;
/// XHD
constant = other.constant;
intensity = other.intensity;
far_ = other.far_;
linear = other.linear;
quadratic = other.quadratic;
drop_off = other.drop_off;
cone_angle = other.cone_angle;
backup_ambient = other.backup_ambient;
backup_diffuse = other.backup_diffuse;
backup_specular = other.backup_specular;
backup_tone_curve = other.backup_tone_curve;
/// XHD
backup_constant = other.backup_constant;
backup_intensity = other.backup_intensity;
backup_far = other.backup_far;
backup_linear = other.backup_linear;
backup_quadratic = other.backup_quadratic;
backup_drop_off = other.backup_drop_off;
backup_cone_angle = other.backup_cone_angle;
return *this;
}
// X/XHD
MaterialList::MaterialList() : flag(), name(), hash(hash_murmurhash_empty),
emission(), blend_color(), fcurve_glow_intensity(), glow_intensity() {
}
// X/XHD
MaterialList::MaterialList(const MaterialList& other) : flag(other.flag), name(other.name),
hash(other.hash), emission(other.emission), blend_color(other.blend_color),
fcurve_glow_intensity(other.fcurve_glow_intensity), glow_intensity(other.glow_intensity) {
}
// X/XHD
MaterialList::~MaterialList() {
}
// X/XHD
void MaterialList::init() {
flag = 0;
name.clear();
name.shrink_to_fit();
hash = hash_murmurhash_empty;
fcurve_glow_intensity.init();
}
// X/XHD
void MaterialList::get(float_t in_frame) {
if (has_emission())
emission.get(in_frame);
if (has_blend_color())
blend_color.get(in_frame);
if (has_glow_intensity())
glow_intensity = fcurve_glow_intensity.get(in_frame);
}
// X/XHD
bool MaterialList::load(const SceneFile& in_file, const a3d::MaterialList& in_ml) {
name.assign(in_ml.name);
hash = hash_string_murmurhash(name);
if (in_ml.flag & a3d::MaterialList::FLAG_EMISSION) {
emission.load(in_file, in_ml.emission);
flag |= FLAG_EMISSION;
}
if (in_ml.flag & a3d::MaterialList::FLAG_BLEND_COLOR) {
blend_color.load(in_file, in_ml.blend_color);
flag |= FLAG_BLEND_COLOR;
}
if (in_ml.flag & a3d::MaterialList::FLAG_GLOW_INTENSITY) {
fcurve_glow_intensity.load(in_file, in_ml.glow_intensity);
flag |= FLAG_GLOW_INTENSITY;
}
return true;
}
// X/XHD, Added
void MaterialList::store(const SceneFile& in_file, a3d::MaterialList& out_ml) const {
out_ml.name.assign(name);
if (flag & FLAG_EMISSION) {
emission.store(in_file, out_ml.emission);
out_ml.flag |= a3d::MaterialList::FLAG_EMISSION;
}
if (flag & FLAG_BLEND_COLOR) {
blend_color.store(in_file, out_ml.blend_color);
out_ml.flag |= a3d::MaterialList::FLAG_BLEND_COLOR;
}
if (flag & FLAG_GLOW_INTENSITY) {
fcurve_glow_intensity.store(in_file, out_ml.glow_intensity);
out_ml.flag |= a3d::MaterialList::FLAG_GLOW_INTENSITY;
}
}
// X/XHD
MaterialList& MaterialList::operator=(const MaterialList & other) {
flag = other.flag;
name.assign(other.name);
hash = other.hash;
emission = other.emission;
blend_color = other.blend_color;
fcurve_glow_intensity = other.fcurve_glow_intensity;
glow_intensity = other.glow_intensity;
return *this;
}
// 0x1401B5100
Motion::Motion() : name() {
}
// 0x1401B50C0
Motion::Motion(const Motion& other) : name(other.name) {
}
// 0x1401B8DB0
Motion::~Motion() {
}
// 0x1401DD2E0
bool Motion::load(const SceneFile& in_file, const a3d::Motion& in_m) {
name.assign(in_m.name);
return true;
}
// Added
void Motion::store(const SceneFile& in_file, a3d::Motion& out_m) const {
out_m.name.assign(name);
}
// 0x1401BC3A0
Motion& Motion::operator=(const Motion& other) {
name.assign(other.name);
return *this;
}
// 0x1401B5550
MotionTransform::MotionTransform() : matrix(), matrix_local(), fcurve_translation(),
fcurve_rotation(), fcurve_scale(), fcurve_visibility(), translation(0.0f), rotation(0.0f), scale(1.0f),
visibility(false), rot(), trans_lock(0.0f), rot_lock(), scale_lock(1.0f), frame(-1.0f),
update_rot(), matrix_local_ready(), has_scale(), has_visibility() {
matrix = mat4_identity;
matrix_local = mat4_identity;
rot = mat4_identity;
rot = mat4_identity;
}
// 0x1401B5120
MotionTransform::MotionTransform(const MotionTransform& other) : matrix(other.matrix),
matrix_local(other.matrix_local), fcurve_translation(other.fcurve_translation),
fcurve_rotation(other.fcurve_rotation), fcurve_scale(other.fcurve_scale),
fcurve_visibility(other.fcurve_visibility), translation(other.translation),
rotation(other.rotation), scale(other.scale), visibility(other.visibility), rot(other.rot),
trans_lock(other.trans_lock), rot_lock(other.rot_lock), scale_lock(other.scale_lock),
frame(other.frame), update_rot(other.update_rot), matrix_local_ready(other.matrix_local_ready),
has_scale(other.has_scale), has_visibility(other.has_visibility) {
}
// 0x1401B8DF0
MotionTransform::~MotionTransform() {
}
// 0x1401D47F0
void MotionTransform::get(float_t in_frame) {
if (frame != in_frame || update_rot) {
translation = fcurve_translation.get(in_frame);
rotation = fcurve_rotation.get(in_frame);
if (has_scale)
scale = fcurve_scale.get(in_frame);
if (has_visibility)
visibility = fcurve_visibility.get(in_frame) >= 0.999f;
mat4_rotate_zyx(&rotation, &rot);
frame = in_frame;
update_rot = false;
matrix_local_ready = false;
}
if (matrix_local_ready && !update_rot)
return;
}
// 0x1401D7550
void MotionTransform::init() {
matrix = mat4_identity;
matrix_local = mat4_identity;
fcurve_translation.init();
fcurve_rotation.init();
fcurve_scale.init();
fcurve_visibility.init();
rot = mat4_identity;
frame = -1.0f;
update_rot = false;
matrix_local_ready = false;
has_scale = false;
has_visibility = false;
}
// 0x1401D8900
void MotionTransform::init_static() {
matrix = mat4_identity;
matrix_local = mat4_identity;
fcurve_translation.init(0.0f);
fcurve_rotation.init(0.0f);
fcurve_scale.init(1.0f);
fcurve_visibility.init(1.0f);
rot = mat4_identity;
frame = -1.0f;
update_rot = false;
matrix_local_ready = false;
has_scale = false;
has_visibility = false;
}
// 0x1401CADD0
void MotionTransform::calc_matrix(const mat4& in_mat) {
mat4_mul(&matrix_local, &in_mat, &matrix);
}
// 0x1401CB020
void MotionTransform::calc_matrix_local() {
if (!matrix_local_ready || update_rot) {
mat4_translate(&translation, &matrix_local);
mat4_mul(&rot, &matrix_local, &matrix_local);
if (has_scale)
mat4_scale_rot(&matrix_local, &scale, &matrix_local);
matrix_local_ready = true;
}
}
// 0x1401CC4A0
void MotionTransform::check_scale() {
if (fcurve_scale.x.m_type == FC_TYPE_STATIC_DATA
&& fabsf(1.0f - fcurve_scale.x.m_static_value) <= 0.000001f
&& fcurve_scale.y.m_type == FC_TYPE_STATIC_DATA
&& fabsf(1.0f - fcurve_scale.y.m_static_value) <= 0.000001f
&& fcurve_scale.z.m_type == FC_TYPE_STATIC_DATA
&& fabsf(1.0f - fcurve_scale.z.m_static_value) <= 0.000001f) {
has_scale = false;
scale = 1.0f;
}
else
has_scale = true;
}
// 0x1401CC8C0
void MotionTransform::check_visibility() {
if (fcurve_visibility.m_type == FC_TYPE_STATIC_DATA) {
has_visibility = false;
visibility = fcurve_visibility.m_static_value >= 0.999f;
}
else
has_visibility = true;
}
// 0x1401D8E60
void MotionTransform::join(const MotionTransform& in_mt1,
const MotionTransform& in_mt2, float_t in_inv_blend, float_t in_blend) {
translation = in_mt2.translation * in_blend + in_mt1.translation * in_inv_blend;
mat4_blend_rotation(&in_mt2.rot, &in_mt1.rot, &rot, in_blend);
if (has_scale)
scale = in_mt2.scale * in_blend + in_mt1.scale * in_inv_blend;
update_rot = true;
}
// 0x1401D9020
void MotionTransform::join(
const MotionTransform& in_mt1, float_t in_inv_blend, float_t in_blend) {
translation = in_mt1.translation * in_blend + translation * in_inv_blend;
mat4_blend_rotation(&rot, &in_mt1.rot, &rot, in_blend);
if (has_scale)
scale = in_mt1.scale * in_blend + scale * in_inv_blend;
update_rot = true;
}
// 0x1401D94F0
void MotionTransform::join_lock(const MotionTransform& in_mt1,
const MotionTransform& in_mt2, float_t in_inv_blend, float_t in_blend) {
translation = in_mt2.trans_lock * in_blend + in_mt1.translation * in_inv_blend;
mat4_blend_rotation(&in_mt2.rot_lock, &in_mt1.rot, &rot, in_blend);
if (has_scale)
scale = in_mt2.scale_lock * in_blend + in_mt1.scale * in_inv_blend;
update_rot = true;
}
// 0x1401D96B0
void MotionTransform::join_lock(
const MotionTransform& in_mt1, float_t in_inv_blend, float_t in_blend) {
translation = in_mt1.trans_lock * in_blend + translation * in_inv_blend;
mat4_blend_rotation(&in_mt1.rot_lock, &rot, &rot, in_blend);
if (has_scale)
scale = in_mt1.scale_lock * in_blend + scale * in_inv_blend;
update_rot = true;
}
// 0x1401E1380
void MotionTransform::lock_set() {
trans_lock = translation;
rot_lock = rot;
if (has_scale)
scale_lock = scale;
}
// 0x1401C8FF0
void MotionTransform::add(
const MotionTransform& in_mt1, const MotionTransform& in_mt2) {
translation = in_mt1.translation + in_mt2.translation;
mat4_mul(&in_mt2.rot, &in_mt1.rot, &rot);
if (has_scale)
scale = in_mt1.scale * in_mt2.scale;
update_rot = true;
}
// 0x1401E7B00
void MotionTransform::sub(
const MotionTransform& in_mt1, const MotionTransform& in_mt2) {
translation = in_mt1.translation - in_mt2.translation;
mat4_mul(&in_mt1.rot, &in_mt2.rot, &rot);
if (has_scale)
scale = in_mt1.scale / in_mt2.scale;
update_rot = true;
}
// 0x1401DD3B0
bool MotionTransform::load(const SceneFile& in_file, const a3d::ModelTransform& in_mt) {
fcurve_translation.load(in_file, in_mt.translation);
fcurve_rotation.load(in_file, in_mt.rotation);
fcurve_scale.load(in_file, in_mt.scale);
fcurve_visibility.load(in_file, in_mt.visibility);
check_scale();
check_visibility();
return true;
}
// Added
void MotionTransform::store(const SceneFile& in_file, a3d::ModelTransform& out_mt) const {
fcurve_translation.store(in_file, out_mt.translation);
fcurve_rotation.store(in_file, out_mt.rotation);
fcurve_scale.store(in_file, out_mt.scale);
fcurve_visibility.store(in_file, out_mt.visibility);
}
// 0x1401BC3D0
MotionTransform& MotionTransform::operator=(const MotionTransform& other) {
matrix = other.matrix;
matrix_local = other.matrix_local;
fcurve_translation = other.fcurve_translation;
fcurve_rotation = other.fcurve_rotation;
fcurve_scale = other.fcurve_scale;
fcurve_visibility = other.fcurve_visibility;
translation = other.translation;
rotation = other.rotation;
scale = other.scale;
visibility = other.visibility;
rot = other.rot;
trans_lock = other.trans_lock;
rot_lock = other.rot_lock;
scale_lock = other.scale_lock;
frame = other.frame;
update_rot = other.update_rot;
matrix_local_ready = other.matrix_local_ready;
has_scale = other.has_scale;
has_visibility = other.has_visibility;
return *this;
}
// 0x1401B5950
MultiHierarchyObject::MultiHierarchyObject() : name(), motion_transform(), node_list(), instance_list() {
}
// 0x1401B58C0
MultiHierarchyObject::MultiHierarchyObject(const MultiHierarchyObject& other) : name(other.name),
motion_transform(other.motion_transform), node_list(other.node_list), instance_list(other.instance_list) {
}
// 0x1401B8E50
MultiHierarchyObject::~MultiHierarchyObject() {
}
// 0x1401D7620
void MultiHierarchyObject::init() {
name.clear();
name.shrink_to_fit();
node_list.clear();
node_list.shrink_to_fit();
instance_list.clear();
instance_list.shrink_to_fit();
}
// 0x1401D49B0
void MultiHierarchyObject::get(float_t in_frame) {
motion_transform.get(in_frame);
motion_transform.calc_matrix_local();
for (ObjectInstance& i : instance_list)
i.get(in_frame);
for (TransformNode& i : node_list)
i.get(in_frame);
}
// 0x1401CEC40
void MultiHierarchyObject::ctrl(const mat4& in_base_mat) {
//if (!motion_transform.visibility)
// return;
TransformNode* node = node_list.data();
calc_matrix_hierarchy();
motion_transform.calc_matrix(in_base_mat);
mat4& mat = motion_transform.matrix;
for (ObjectInstance& i : instance_list) {
//if (!i.motion_transform.visibility)
// continue;
i.motion_transform.calc_matrix(mat);
int32_t* matrix_id = i.matrix_id.data();
size_t matrix_id_count = i.matrix_id.size();
mat4* mats = i.mats.data();
for (size_t j = 0; j < matrix_id_count; j++)
mats[j] = node[matrix_id[j]].motion_transform.matrix;
}
}
// 0x1401D0760
void MultiHierarchyObject::disp(Scene& in_scene, render_context* rctx) {
if (!in_scene.M_is_visible || !motion_transform.visibility)
return;
mdl::DispManager& disp_manager = *rctx->disp_manager;
const mat4& root_matrix = get_root_matrix();
for (ObjectInstance& i : instance_list) {
if (!i.motion_transform.visibility)
continue;
mdl::ObjFlags flag = mdl::OBJ_SSS;
int32_t shadow_group = 0;
if (in_scene.M_shadow || i.shadow) {
enum_or(flag, mdl::OBJ_4 | mdl::OBJ_SHADOW);
shadow_group = 1;
}
if (in_scene.trnsl < 1.0f)
enum_or(flag, in_scene.trnsl_state);
disp_manager.set_obj_flags(flag);
disp_manager.set_shadow_group(shadow_group);
Shadow* shad = get_shadow();
if (shad && (flag & mdl::OBJ_SHADOW)) {
disp_manager.set_shadow_group(1);
mat4 mat;
mat4_mul(&i.motion_transform.matrix, &root_matrix, &mat);
vec3 pos;
mat4_get_translation(&mat, &pos);
get_shadow()->set_dist_base(1, &pos);
}
if (i.mats.size())
disp_manager.entry_obj_by_object_info_object_skin(
i.obj_uid, 0, 0, in_scene.trnsl, i.mats.data(), 0, 0, i.motion_transform.matrix);
}
disp_manager.set_obj_flags();
disp_manager.set_shadow_group(0);
}
// 0x1401CAE40
void MultiHierarchyObject::calc_matrix_hierarchy() {
TransformNode* node = node_list.data();
for (TransformNode& i : node_list)
if (i.parent_id >= 0)
i.motion_transform.calc_matrix(node[i.parent_id].motion_transform.matrix);
else
i.motion_transform.matrix = i.motion_transform.matrix_local;
}
// 0x1401CB0A0
void MultiHierarchyObject::calc_matrix_local() {
for (TransformNode& i : node_list)
i.motion_transform.calc_matrix_local();
}
// 0x1401D5F20
const mat4& MultiHierarchyObject::get_root_matrix() const {
for (const TransformNode& i : node_list)
if (i.mat_ptr)
return *i.mat_ptr;
return node_list.front().motion_transform.matrix;
}
// 0x1401DD710
bool MultiHierarchyObject::load(const SceneFile& in_file,
const a3d::MObjectHrc& in_moh, const object_database* obj_db) {
name.assign(in_moh.name);
motion_transform.load(in_file, in_moh.model_transform);
list_load(node_list, in_file, in_moh.node);
list_load(instance_list, in_file, in_moh.instance, *this, obj_db);
int32_t node_index = 0;
for (TransformNode& i : node_list) {
if (i.parent_id >= node_index)
throw std::range_error("parent_id is not less than child");
node_index++;
}
return true;
}
// Added
void MultiHierarchyObject::store(const SceneFile& in_file, a3d::MObjectHrc& out_moh) const {
out_moh.name.assign(name);
motion_transform.store(in_file, out_moh.model_transform);
list_store(node_list, in_file, out_moh.node);
list_store(instance_list, in_file, out_moh.instance, *this);
}
// 0x1401BC7F0
MultiHierarchyObject& MultiHierarchyObject::operator=(const MultiHierarchyObject& other) {
name.assign(other.name);
motion_transform = other.motion_transform;
node_list.assign(other.node_list.begin(), other.node_list.end());
instance_list.assign(other.instance_list.begin(), other.instance_list.end());
return *this;
}
// 0x1401B5BD0
Object::Object() : model_transform(), index(), name(), uid_name(), parent_name(), parent_node(),
obj_pat(), obj_morph(), texture_list(), texture_transform_list(), child_object_list(),
child_object_hrc_list(), obj_uid(), obj_hash(hash_murmurhash_empty), is_reflect(), is_refract() {
}
// 0x1401B59C0
Object::Object(const Object& other) : model_transform(other.model_transform), index(other.index),
name(other.name), uid_name(other.uid_name), parent_name(other.parent_name), parent_node(other.parent_node),
obj_pat(other.obj_pat), obj_morph(other.obj_morph), texture_list(other.texture_list),
texture_transform_list(other.texture_transform_list), child_object_list(other.child_object_list),
child_object_hrc_list(other.child_object_hrc_list), obj_uid(other.obj_uid),
obj_hash(other.obj_hash), is_reflect(other.is_reflect), is_refract(other.is_refract) {
}
// 0x1401B8F80
Object::~Object() {
}
// 0x1401D76D0
void Object::init() {
index = -1;
name.clear();
name.shrink_to_fit();
uid_name.clear();
uid_name.shrink_to_fit();
parent_name.clear();
parent_name.shrink_to_fit();
parent_node.clear();
parent_node.shrink_to_fit();
obj_pat.init();
obj_morph.init();
texture_list.clear();
texture_list.shrink_to_fit();
texture_transform_list.clear();
texture_transform_list.shrink_to_fit();
child_object_list.clear();
child_object_list.shrink_to_fit();
child_object_hrc_list.clear();
child_object_hrc_list.shrink_to_fit();
obj_uid = {};
obj_hash = hash_murmurhash_empty;
is_reflect = false;
is_refract = false;
}
// 0x1401D4A70
void Object::get(float_t in_frame) {
model_transform.get(in_frame);
obj_morph.get(in_frame);
obj_pat.get(in_frame);
for (Texture& i : texture_list)
i.get(in_frame);
for (TextureTransform& i : texture_transform_list)
i.get(in_frame);
}
// 0x1401CEE70
void Object::ctrl(const mat4& in_base_mat) {
//if (!model_transform.visibility)
// return;
model_transform.mul(in_base_mat);
const mat4& mat = model_transform.get_matrix();
for (Object*& i : child_object_list)
i->ctrl(mat);
for (HierarchyObject*& i : child_object_hrc_list)
i->ctrl(mat);
}
// 0x1401D0970
void Object::disp(Scene& in_scene, render_context* rctx) {
if (!model_transform.visibility)
return;
if (!in_scene.M_is_visible) {
if (in_scene.M_debug)
debug_put_line_axis(model_transform.get_matrix());
for (Object*& i : child_object_list)
i->disp(in_scene, rctx);
for (HierarchyObject*& i : child_object_hrc_list)
i->disp(in_scene, rctx);
return;
}
mat4 matrix = model_transform.get_matrix();
mdl::DispManager& disp_manager = *rctx->disp_manager;
const object_database* obj_db = in_scene.obj_db;
const texture_database* tex_db = in_scene.tex_db;
if (in_scene.M_assign_rob_id >= 0 && in_scene.M_assign_rob_id < ROB_ID_MAX) {
RobManagement* rob_man = get_rob_management();
if (rob_man->is_init((ROB_ID)in_scene.M_assign_rob_id)) {
rob_chara* rob_chr = rob_man->get_rob((ROB_ID)in_scene.M_assign_rob_id);
mat4 m;
mat4_mul(&rob_chr->rob_base.position.rob_mat,
in_scene.M_chara_item
? &rob_chr->rob_base.adjust.item_mat
: &rob_chr->rob_base.adjust.mat, &m);
mat4_mul(&matrix, &m, &matrix);
disp_manager.set_shadow_group(in_scene.M_assign_rob_id ? 1 : 0);
}
}
mdl::ObjFlags flag = (mdl::ObjFlags)0;
if (in_scene.M_shadow)
enum_or(flag, mdl::OBJ_4 | mdl::OBJ_SHADOW);
if (is_reflect)
enum_or(flag, mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFLECT);
if (is_refract)
enum_or(flag, mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFRACT);
disp_manager.set_obj_flags(flag);
char buf[0x80];
int32_t tex_pat_count = 0;
TexChange tex_pat[TEXTURE_PATTERN_COUNT];
for (Texture& i : texture_list) {
if (!i.tex_pat.is_valid() || i.name.size() <= 3)
continue;
else if (tex_pat_count >= TEXTURE_PATTERN_COUNT)
break;
sprintf_s(buf, sizeof(buf), "%.*s%03d",
(int32_t)(i.name.size() - 3), i.name.c_str(), (int32_t)prj::roundf(i.tex_pat.value));
tex_pat[tex_pat_count].org_texid = texture_id(0x00, i.tex_uid);
tex_pat[tex_pat_count].change_texid = texture_id(0x00, tex_db->get_texture_id(buf));
tex_pat_count++;
}
if (tex_pat_count)
disp_manager.set_texture_pattern(tex_pat_count, tex_pat);
int32_t tex_trans_count = 0;
texture_transform_struct tex_trans[TEXTURE_TRANSFORM_COUNT];
for (TextureTransform& i : texture_transform_list) {
if (tex_trans_count >= TEXTURE_TRANSFORM_COUNT || i.tex_uid == -1
|| !texture_manager_get_texture(i.tex_uid))
continue;
tex_trans[tex_trans_count].texid = i.tex_uid;
tex_trans[tex_trans_count].mat = i.mat;
tex_trans_count++;
}
if (tex_trans_count)
disp_manager.set_texture_transform(tex_trans_count, tex_trans);
if (obj_morph.is_valid()) {
const char* uid_name = this->uid_name.c_str();
size_t uid_name_length = this->uid_name.size();
if (uid_name_length > 3) {
float_t morph = obj_morph.value;
int32_t morph_int = (int32_t)morph;
morph = fmodf(morph, 1.0f);
if (morph > 0.0f && morph < 1.0f) {
sprintf_s(buf, sizeof(buf), "%.*s%03d",
(int32_t)uid_name_length - 3, uid_name, morph_int + 1);
object_info morph_obj_uid = obj_db->get_object_info(buf);
if (morph_obj_uid.is_null())
morph_obj_uid = obj_uid;
disp_manager.set_morph(morph_obj_uid, morph);
sprintf_s(buf, sizeof(buf), "%.*s%03d",
(int32_t)uid_name_length - 3, uid_name, morph_int);
object_info obj_uid = obj_db->get_object_info(buf);
in_scene.M_put_obj(matrix, obj_uid, rctx);
disp_manager.set_morph({}, 0.0f);
}
else {
if (morph >= 1.0f)
morph_int++;
sprintf_s(buf, sizeof(buf), "%.*s%03d",
(int32_t)uid_name_length - 3, uid_name, morph_int);
object_info obj_uid = obj_db->get_object_info(buf);
if (obj_uid.is_null())
obj_uid = this->obj_uid;
in_scene.M_put_obj(matrix, obj_uid, rctx);
}
}
}
else if (obj_pat.is_valid()) {
const char* uid_name = this->uid_name.c_str();
size_t uid_name_length = this->uid_name.size();
if (uid_name_length > 3) {
float_t pat = prj::roundf(obj_pat.value);
int32_t pat_int = (int32_t)pat;
sprintf_s(buf, sizeof(buf), "%.*s%03d",
(int32_t)uid_name_length - 3, uid_name, pat_int);
object_info obj_uid = obj_db->get_object_info(buf);
in_scene.M_put_obj(matrix, obj_uid, rctx);
}
else
in_scene.M_put_obj(matrix, obj_uid, rctx);
}
else
in_scene.M_put_obj(matrix, obj_uid, rctx);
disp_manager.set_texture_transform();
disp_manager.set_texture_pattern();
disp_manager.set_obj_flags();
if (in_scene.M_debug)
debug_put_line_axis(model_transform.get_matrix());
for (Object*& i : child_object_list)
i->disp(in_scene, rctx);
for (HierarchyObject*& i : child_object_hrc_list)
i->disp(in_scene, rctx);
}
// 0x1401E3510
bool Object::replace_chara(int32_t in_cn_src, int32_t in_cn_dst, const object_database* obj_db) {
if (in_cn_src < 0 || in_cn_src >= CN_MAX || in_cn_dst < 0 || in_cn_dst >= CN_MAX || in_cn_src == in_cn_dst)
return false;
std::string cn_src_str(get_char_id_str((CHARA_NUM)in_cn_src));
std::string cn_dst_str(get_char_id_str((CHARA_NUM)in_cn_dst));
std::string uid_name(this->uid_name);
size_t pos = uid_name.find(cn_src_str);
if (pos != -1)
uid_name.assign(uid_name.replace(pos, cn_src_str.size(), cn_dst_str));
object_info obj_uid = obj_db->get_object_info(uid_name.c_str());
if (obj_uid.not_null()) {
this->obj_uid = obj_uid;
this->uid_name.assign(uid_name);
return true;
}
return false;
}
// Added
void Object::prepare_morph(const object_database* obj_db) {
if (!obj_morph.is_valid())
return;
float_t min_value = FLT_MAX;
float_t max_value = -FLT_MAX;
float_t first_frame = 0.0f;
float_t last_frame = obj_morph.fcurve_ptr->curve.m_max_frame;
for (float_t i = first_frame; i <= last_frame; i += 1.0f) {
obj_morph.get(i);
min_value = fminf(min_value, obj_morph.value);
max_value = fmaxf(max_value, obj_morph.value);
}
obj_morph.get(0.0f);
int32_t min = (int32_t)prj::floorf(min_value);
int32_t max = (int32_t)prj::ceilf(max_value);
if (min >= max)
return;
const char* uid_name = this->uid_name.c_str();
int32_t uid_name_length = (int32_t)this->uid_name.size();
char buf[0x80];
for (int32_t i = min; i < max; i++) {
sprintf_s(buf, sizeof(buf), "%.*s%03d", uid_name_length - 3, uid_name, i + 1);
object_info morph_obj_uid = obj_db->get_object_info(buf);
if (morph_obj_uid.is_null())
morph_obj_uid = this->obj_uid;
sprintf_s(buf, sizeof(buf), "%.*s%03d", uid_name_length - 3, uid_name, i);
object_info obj_uid = obj_db->get_object_info(buf);
::obj* obj = get_object_header(obj_uid);
if (!obj)
continue;
VertexBuffer* vbhn_array = get_object_vertex_buffer(obj_uid);
IndexBuffer* ibhn_array = get_object_index_buffer(obj_uid);
VertexBuffer* morph_vbhn_array = 0;
if (morph_obj_uid.set_id != -1)
morph_vbhn_array = get_object_vertex_buffer(morph_obj_uid);
for (int32_t i = 0; i < obj->num_mesh; i++) {
const obj_mesh* mesh = &obj->mesh_array[i];
for (int32_t j = 0; j < mesh->num_submesh; j++) {
const obj_sub_mesh* sub_mesh = &mesh->submesh_array[j];
if (sub_mesh->attrib.m.hide)
continue;
obj_material_data* material = &obj->material_array[sub_mesh->material_index];
GLuint morph_vb = 0;
uint32_t morph_vb_offset = 0;
if (morph_vbhn_array) {
morph_vb = morph_vbhn_array[i].get_glvb();
morph_vb_offset = morph_vbhn_array[i].get_glvb_offset();
}
GLuint ib = 0;
if (ibhn_array)
ib = ibhn_array[i].ib;
GLuint vb = 0;
uint32_t vb_offset = 0;
if (vbhn_array) {
vb = vbhn_array[i].get_glvb();
vb_offset = vbhn_array[i].get_glvb_offset();
}
if (vb && ib && (!morph_vbhn_array || morph_vb))
rctx_ptr->disp_manager->add_vertex_array(mesh, sub_mesh, material,
vb, vb_offset, ib, morph_vb, morph_vb_offset);
}
}
}
}
// 0x1401DE5F0
bool Object::load(const SceneFile& in_file, const a3d::Object& in_o,
const object_database* obj_db, const texture_database* tex_db) {
name.assign(in_o.name);
uid_name.assign(in_o.uid_name);
obj_uid = obj_db->get_object_info(uid_name.c_str());
obj_hash = hash_string_murmurhash(uid_name);
static std::string reflect_str = "_REFLECT";
is_reflect = uid_name.find(reflect_str) != -1;
static std::string refract_str = "_REFRACT";
is_refract = uid_name.find(refract_str) != -1;
model_transform.load(in_file, in_o.model_transform);
obj_morph.name.assign(in_o.morph);
obj_morph.offset = in_o.morph_offset;
obj_pat.name.assign(in_o.pattern);
obj_pat.offset = in_o.pattern_offset;
parent_name.assign(in_o.parent_name);
parent_node.assign(in_o.parent_node);
list_load(texture_list, in_file, in_o.texture, tex_db);
list_load(texture_transform_list, in_file, in_o.texture_transform, tex_db);
return true;
}
// Added
void Object::store(const SceneFile& in_file, a3d::Object& out_o) const {
out_o.name.assign(name);
out_o.uid_name.assign(uid_name);
model_transform.store(in_file, out_o.model_transform);
out_o.morph.assign(obj_morph.name);
out_o.morph_offset = obj_morph.offset;
out_o.pattern.assign(obj_pat.name);
out_o.pattern_offset = obj_pat.offset;
out_o.parent_name.assign(parent_name);
out_o.parent_node.assign(parent_node);
list_store(texture_list, in_file, out_o.texture);
list_store(texture_transform_list, in_file, out_o.texture_transform);
}
// 0x1401BC860
Object& Object::operator=(const Object& other) {
model_transform = other.model_transform;
index = other.index;
name.assign(other.name);
uid_name.assign(other.uid_name);
parent_name.assign(other.parent_name);
parent_node.assign(other.parent_node);
obj_pat = other.obj_pat;
obj_morph = other.obj_morph;
texture_list.assign(other.texture_list.begin(), other.texture_list.end());
texture_transform_list.assign(other.texture_transform_list.begin(), other.texture_transform_list.end());
child_object_list.assign(other.child_object_list.begin(), other.child_object_list.end());
child_object_hrc_list.assign(other.child_object_hrc_list.begin(), other.child_object_hrc_list.end());
obj_uid = other.obj_uid;
obj_hash = other.obj_hash;
is_reflect = other.is_reflect;
is_refract = other.is_refract;
return *this;
}
// 0x1401B5DE0
ObjectInstance::ObjectInstance() : name(), uid_name(), obj_uid(),
obj_hash(hash_murmurhash_empty), shadow(), motion_transform(), matrix_id(), mats() {
}
// 0x1401B5D20
ObjectInstance::ObjectInstance(const ObjectInstance& other) : name(other.name),
uid_name(other.uid_name), obj_uid(other.obj_uid), obj_hash(other.obj_hash), shadow(other.shadow),
motion_transform(other.motion_transform), matrix_id(other.matrix_id), mats(other.mats) {
}
// 0x1401B91E0
ObjectInstance::~ObjectInstance() {
}
// Missing
void ObjectInstance::init() {
name.clear();
name.shrink_to_fit();
uid_name.clear();
uid_name.shrink_to_fit();
obj_uid = {};
obj_hash = (uint32_t)-1;
shadow = false;
matrix_id.clear();
matrix_id.shrink_to_fit();
mats.clear();
mats.shrink_to_fit();
}
// Inlined
inline void ObjectInstance::get(float_t in_frame) {
motion_transform.get(in_frame);
motion_transform.calc_matrix_local();
}
// Inlined
inline bool ObjectInstance::load(const SceneFile& in_file, const a3d::ObjectInstance& in_oi,
const MultiHierarchyObject& in_mho, const object_database* obj_db) {
name.assign(in_oi.name);
uid_name.assign(in_oi.uid_name);
obj_uid = obj_db->get_object_info(uid_name.c_str());
obj_hash = hash_string_murmurhash(uid_name);
shadow = in_oi.shadow;
motion_transform.load(in_file, in_oi.model_transform);
const obj_skin* skin = get_object_skin(obj_uid);
if (!skin) {
std::string error_str = sprintf_s_string("%s skin data is not found", uid_name.c_str());
throw std::runtime_error(error_str.c_str());
}
matrix_id.resize(skin->num_bone);
size_t bone_num = 0;
for (size_t i = 0; i < in_mho.node_list.size(); i++) {
const TransformNode& node = in_mho.node_list[i];
size_t num_bone = skin->num_bone;
for (size_t j = 0; j < num_bone; j++)
if (!node.name.compare(skin->bone_array[j].name)) {
int32_t node_index = skin->bone_array[j].id;
if (node_index & 0x8000) {
std::string error_str = sprintf_s_string(
"%s skin bone type is not normal bone", uid_name.c_str());
throw std::runtime_error(error_str.c_str());
}
matrix_id[node_index] = (int32_t)i;
bone_num++;
break;
}
}
if (!bone_num) {
std::string error_str = sprintf_s_string("%s skin data has no bone", uid_name.c_str());
throw std::runtime_error(error_str.c_str());
}
if (bone_num != skin->num_bone)
throw std::range_error("bone_num mismatch");
mats.resize(bone_num);
return true;
}
// Added
inline void ObjectInstance::store(const SceneFile& in_file, a3d::ObjectInstance& out_oi,
const MultiHierarchyObject& in_mho) const {
out_oi.name.assign(name);
out_oi.uid_name.assign(uid_name);
out_oi.shadow = shadow;
motion_transform.store(in_file, out_oi.model_transform);
}
// 0x1401BCA10
ObjectInstance& ObjectInstance::operator=(const ObjectInstance& other) {
name.assign(other.name);
uid_name.assign(other.uid_name);
obj_uid = other.obj_uid;
obj_hash = other.obj_hash;
shadow = other.shadow;
motion_transform = other.motion_transform;
matrix_id.assign(other.matrix_id.begin(), other.matrix_id.end());
mats.assign(other.mats.begin(), other.mats.end());
return *this;
}
// Missing
PlayControl::PlayControl() : flag(),
begin(), div(), fps(), offset(), size() {
}
// Missing
PlayControl::PlayControl(const PlayControl& other) : flag(other.flag),
begin(other.begin), div(other.div), fps(other.fps), offset(other.offset), size(other.size) {
}
// Missing
PlayControl::~PlayControl() {
}
// 0x1401D78B0
void PlayControl::init() {
flag = 0;
begin = 0.0f;
div = 0; // F2/X/XHD
fps = 0.0f;
offset = 0.0f;
size = 0.0f;
}
// 0x1401DEE10
bool PlayControl::load(const SceneFile& in_file, const a3d::PlayControl& in_pc) {
begin = in_pc.begin;
// F2/X/XHD
if (in_pc.flag & a3d::PlayControl::FLAG_DIV) {
div = in_pc.div;
flag |= FLAG_DIV;
}
fps = in_pc.fps;
// F2/X/XHD
if (in_pc.flag & a3d::PlayControl::FLAG_OFFSET) {
offset = in_pc.offset;
flag |= FLAG_OFFSET;
}
size = in_pc.size;
return true;
}
// Added
void PlayControl::store(const SceneFile& in_file, a3d::PlayControl& out_pc) const {
out_pc.begin = begin;
// F2/X/XHD
if (flag & FLAG_DIV) {
out_pc.div = div;
out_pc.flag |= a3d::PlayControl::FLAG_DIV;
}
out_pc.fps = fps;
// F2/X/XHD
if (flag & FLAG_OFFSET) {
out_pc.offset = offset;
out_pc.flag |= a3d::PlayControl::FLAG_OFFSET;
}
out_pc.size = size;
}
// Missing
PlayControl& PlayControl::operator=(const PlayControl& other) {
flag = other.flag;
begin = other.begin;
div = other.div;
fps = other.fps;
offset = other.offset;
size = other.size;
return *this;
}
// 0x1401B5EE0
Point::Point() : name(), model_transform() {
}
// 0x1401B5E80
Point::Point(const Point& other) : name(other.name), model_transform(other.model_transform) {
}
// 0x1401B92D0
Point::~Point() {
}
// 0x1401D4B20
void Point::get(float_t in_frame) {
model_transform.get(in_frame);
}
// 0x1401D1150
void Point::disp(const Scene& in_scene, render_context* rctx) {
if (in_scene.M_debug) {
model_transform.mul(in_scene.base_matrix);
debug_put_line_axis(model_transform.get_matrix());
}
}
// 0x1401DEF50
bool Point::load(const SceneFile& in_file, const a3d::Point& in_p) {
name.assign(in_p.name);
model_transform.load(in_file, in_p.model_transform);
return true;
}
// Added
void Point::store(const SceneFile& in_file, a3d::Point& out_p) const {
out_p.name.assign(name);
model_transform.store(in_file, out_p.model_transform);
}
// 0x1401BCAA0
Point& Point::operator=(const Point& other) {
name.assign(other.name);
model_transform = other.model_transform;
return *this;
}
// 0x1401B5F20
PostProcess::PostProcess() : flag(), backup_flag(),
fcurve_lens_flare(), fcurve_lens_shaft(), fcurve_lens_ghost(), radius(), intensity(),
scene_fade(), backup_lens_flare(), backup_lens_shaft(), backup_lens_ghost(), backup_radius(),
backup_intensity(), backup_scene_fade(), lens_flare(), lens_shaft(), lens_ghost() {
}
// Missing
PostProcess::PostProcess(const PostProcess& other) : flag(other.flag), backup_flag(other.backup_flag),
fcurve_lens_flare(other.fcurve_lens_flare), fcurve_lens_shaft(other.fcurve_lens_shaft),
fcurve_lens_ghost(other.fcurve_lens_ghost), radius(other.radius), intensity(other.intensity),
scene_fade(other.scene_fade), backup_lens_flare(other.backup_lens_flare),
backup_lens_shaft(other.backup_lens_shaft), backup_lens_ghost(other.backup_lens_ghost),
backup_radius(other.backup_radius), backup_intensity(other.backup_intensity),
backup_scene_fade(other.backup_scene_fade), lens_flare(other.lens_flare),
lens_shaft(other.lens_shaft), lens_ghost(other.lens_ghost) {
}
// 0x1401B9350
PostProcess::~PostProcess() {
}
// 0x1401D78C0
void PostProcess::init() {
flag = 0;
backup_flag = 0;
fcurve_lens_flare.init();
fcurve_lens_shaft.init();
fcurve_lens_ghost.init();
}
// 0x1401D4B30
void PostProcess::get(float_t in_frame) {
if (has_lens_flare())
lens_flare = fcurve_lens_flare.get(in_frame);
if (has_lens_shaft())
lens_shaft = fcurve_lens_shaft.get(in_frame);
if (has_lens_ghost())
lens_ghost = fcurve_lens_ghost.get(in_frame);
if (has_radius())
radius.get(in_frame);
if (has_intensity())
intensity.get(in_frame);
if (has_scene_fade())
scene_fade.get(in_frame);
}
// 0x1401CEF00
void PostProcess::ctrl(Scene& in_scene, render_context* rctx) {
if (has_lens()) {
float_t flare_coef[3];
rctx->render->get_flare_coef(flare_coef);
if (has_lens_flare()) {
if (!(backup_flag & FLAG_LENS_FLARE)) {
backup_lens_flare = flare_coef[0];
backup_flag |= FLAG_LENS_FLARE;
}
flare_coef[0] = lens_flare;
}
if (has_lens_shaft()) {
if (!(backup_flag & FLAG_LENS_SHAFT)) {
backup_lens_shaft = flare_coef[1];
backup_flag |= FLAG_LENS_SHAFT;
}
flare_coef[1] = lens_shaft;
}
if (has_lens_ghost()) {
if (!(backup_flag & FLAG_LENS_GHOST)) {
backup_lens_ghost = flare_coef[2];
backup_flag |= FLAG_LENS_GHOST;
}
flare_coef[2] = lens_ghost;
}
rctx->render->set_fade_color(flare_coef);
}
if (has_radius()) {
if (!(backup_flag & FLAG_RADIUS)) {
rctx->render->get_sigma((float_t*)&backup_radius);
backup_flag |= FLAG_RADIUS;
}
rctx->render->set_sigma((float_t*)&radius.color);
}
if (has_intensity()) {
if (!(backup_flag & FLAG_INTENSITY)) {
rctx->render->get_intensity((float_t*)&backup_intensity);
backup_flag |= FLAG_INTENSITY;
}
rctx->render->set_intensity((float_t*)&intensity.color);
}
if (has_scene_fade()) {
if (!(backup_flag & FLAG_SCENE_FADE)) {
rctx->render->get_fade_color(&backup_scene_fade);
backup_flag |= FLAG_SCENE_FADE;
}
rctx->render->set_fade_color(&scene_fade.color);
}
}
// 0x1401D0050
void PostProcess::dest(render_context* rctx) {
if (backup_flag & (FLAG_LENS_FLARE | FLAG_LENS_SHAFT | FLAG_LENS_GHOST)) {
float_t flare_coef[3];
rctx->render->get_flare_coef(flare_coef);
if (backup_flag & FLAG_LENS_FLARE)
flare_coef[0] = backup_lens_flare;
if (backup_flag & FLAG_LENS_SHAFT)
flare_coef[1] = backup_lens_shaft;
if (backup_flag & FLAG_LENS_GHOST)
flare_coef[2] = backup_lens_ghost;
rctx->render->set_fade_color(flare_coef);
}
if (backup_flag & FLAG_RADIUS)
rctx->render->set_sigma((float_t*)&backup_radius);
if (backup_flag & FLAG_INTENSITY)
rctx->render->set_intensity((float_t*)&backup_intensity);
if (backup_flag & FLAG_SCENE_FADE)
rctx->render->set_fade_color(&backup_scene_fade);
}
// 0x1401DF050
bool PostProcess::load(const SceneFile& in_file, const a3d::PostProcess& in_pp) {
if (in_pp.flag & a3d::PostProcess::FLAG_LENS_FLARE) {
fcurve_lens_flare.load(in_file, in_pp.lens_flare);
flag |= FLAG_LENS_FLARE;
}
if (in_pp.flag & a3d::PostProcess::FLAG_LENS_SHAFT) {
fcurve_lens_shaft.load(in_file, in_pp.lens_shaft);
flag |= FLAG_LENS_SHAFT;
}
if (in_pp.flag & a3d::PostProcess::FLAG_LENS_GHOST) {
fcurve_lens_ghost.load(in_file, in_pp.lens_ghost);
flag |= FLAG_LENS_GHOST;
}
if (in_pp.flag & a3d::PostProcess::FLAG_RADIUS) {
radius.load(in_file, in_pp.radius);
flag |= FLAG_RADIUS;
}
if (in_pp.flag & a3d::PostProcess::FLAG_INTENSITY) {
intensity.load(in_file, in_pp.intensity);
flag |= FLAG_INTENSITY;
}
if (in_pp.flag & a3d::PostProcess::FLAG_SCENE_FADE) {
scene_fade.load(in_file, in_pp.scene_fade);
flag |= FLAG_SCENE_FADE;
}
return true;
}
// Added
void PostProcess::store(const SceneFile& in_file, a3d::PostProcess& out_pp) const {
if (flag & FLAG_LENS_FLARE) {
fcurve_lens_flare.store(in_file, out_pp.lens_flare);
out_pp.flag |= a3d::PostProcess::FLAG_LENS_FLARE;
}
if (flag & FLAG_LENS_SHAFT) {
fcurve_lens_shaft.store(in_file, out_pp.lens_shaft);
out_pp.flag |= a3d::PostProcess::FLAG_LENS_SHAFT;
}
if (flag & FLAG_LENS_GHOST) {
fcurve_lens_ghost.store(in_file, out_pp.lens_ghost);
out_pp.flag |= a3d::PostProcess::FLAG_LENS_GHOST;
}
if (flag & FLAG_RADIUS) {
radius.store(in_file, out_pp.radius);
out_pp.flag |= a3d::PostProcess::FLAG_RADIUS;
}
if (flag & FLAG_INTENSITY) {
intensity.store(in_file, out_pp.intensity);
out_pp.flag |= a3d::PostProcess::FLAG_INTENSITY;
}
if (flag & FLAG_SCENE_FADE) {
scene_fade.store(in_file, out_pp.scene_fade);
out_pp.flag |= a3d::PostProcess::FLAG_SCENE_FADE;
}
}
// Missing
PostProcess& PostProcess::operator=(const PostProcess& other) {
flag = other.flag;
backup_flag = other.backup_flag;
fcurve_lens_flare = other.fcurve_lens_flare;
fcurve_lens_shaft = other.fcurve_lens_shaft;
fcurve_lens_ghost = other.fcurve_lens_ghost;
radius = other.radius;
intensity = other.intensity;
scene_fade = other.scene_fade;
backup_lens_flare = other.backup_lens_flare;
backup_lens_shaft = other.backup_lens_shaft;
backup_lens_ghost = other.backup_lens_ghost;
backup_radius = other.backup_radius;
backup_intensity = other.backup_intensity;
backup_scene_fade = other.backup_scene_fade;
lens_flare = other.lens_flare;
lens_shaft = other.lens_shaft;
lens_ghost = other.lens_ghost;
return *this;
}
// 0x1401B6550
Texture::Texture() : name(), tex_uid(-1), tex_pat() {
}
// 0x1401B64C0
Texture::Texture(const Texture& other)
: name(other.name), tex_uid(other.tex_uid), tex_pat(other.tex_pat) {
}
// 0x1401B9BF0
Texture::~Texture() {
}
// 0x1401D8420
void Texture::init() {
name.clear();
name.shrink_to_fit();
tex_uid = -1;
tex_pat.init();
}
// 0x1401D4C00
void Texture::get(float_t in_frame) {
tex_pat.get(in_frame);
}
// 0x1401DFA50
bool Texture::load(const SceneFile& in_file,
const a3d::Texture& in_t, const texture_database* tex_db) {
name.assign(in_t.name);
tex_uid = tex_db->get_texture_id(name.c_str());
tex_pat.name.assign(in_t.pattern);
tex_pat.offset = in_t.pattern_offset;
return true;
}
// Added
void Texture::store(const SceneFile& in_file, a3d::Texture& out_t) const {
out_t.name.assign(name);
out_t.pattern.assign(tex_pat.name);
out_t.pattern_offset = tex_pat.offset;
}
// 0x1401BCBA0
Texture& Texture::operator=(const Texture& other) {
name.assign(other.name);
tex_uid = other.tex_uid;
tex_pat = other.tex_pat;
return *this;
}
// 0x1401B6C30
TextureTransform::TextureTransform() : flag(), backup_flag(), name(), tex_uid(), fcurve_coverage_u(),
fcurve_coverage_v(), fcurve_repeat_u(), fcurve_repeat_v(), fcurve_translate_frame_u(),
fcurve_translate_frame_v(), fcurve_offset_u(), fcurve_offset_v(), fcurve_rotate_frame(),
fcurve_rotate(), mat(), scale(), repeat(), rotate(), translate_frame() {
}
// 0x1401B65A0
TextureTransform::TextureTransform(const TextureTransform& other)
: flag(other.flag), backup_flag(other.backup_flag), name(other.name), tex_uid(other.tex_uid),
fcurve_coverage_u(other.fcurve_coverage_u), fcurve_coverage_v(other.fcurve_coverage_v),
fcurve_repeat_u(other.fcurve_repeat_u), fcurve_repeat_v(other.fcurve_repeat_v),
fcurve_translate_frame_u(other.fcurve_translate_frame_u),
fcurve_translate_frame_v(other.fcurve_translate_frame_v),
fcurve_offset_u(other.fcurve_offset_u), fcurve_offset_v(other.fcurve_offset_v),
fcurve_rotate_frame(other.fcurve_rotate_frame), fcurve_rotate(other.fcurve_rotate),
mat(other.mat), scale(other.scale), repeat(other.repeat), rotate(other.rotate),
translate_frame(other.translate_frame) {
}
// 0x1401B9C50
TextureTransform::~TextureTransform() {
}
// 0x1401D8460
void TextureTransform::init() {
flag = 0;
tex_uid = -1;
name.clear();
name.shrink_to_fit();
mat = mat4_identity;
fcurve_coverage_u.init();
fcurve_coverage_v.init();
fcurve_repeat_u.init();
fcurve_repeat_v.init();
fcurve_translate_frame_u.init();
fcurve_translate_frame_v.init();
fcurve_offset_u.init();
fcurve_offset_v.init();
fcurve_rotate_frame.init();
fcurve_rotate.init();
}
// 0x1401D4C10
void TextureTransform::get(float_t in_frame) {
scale = 1.0f;
if (has_coverage_u() && fcurve_coverage_u.m_max_frame > 0.0f) {
float_t coverage_u = fcurve_coverage_u.get(in_frame);
if (fabsf(coverage_u) > 0.000001f)
scale.x = 1.0f / coverage_u;
}
if (has_coverage_v() && fcurve_coverage_v.m_max_frame > 0.0f) {
float_t coverage_v = fcurve_coverage_v.get(in_frame);
if (fabsf(coverage_v) > 0.000001f)
scale.y = 1.0f / coverage_v;
}
repeat = 1.0f;
if (has_repeat_u() && fcurve_repeat_u.m_max_frame > 0.0f) {
float_t value = fcurve_repeat_u.get(in_frame);
if (fabsf(value) > 0.000001f)
repeat.x = value;
}
if (has_repeat_v() && fcurve_repeat_v.m_max_frame > 0.0f) {
float_t value = fcurve_repeat_v.get(in_frame);
if (fabsf(value) > 0.000001f)
repeat.y = value;
}
float_t rotate_frame_value = 0.0f;
if (has_rotate_frame())
rotate_frame_value = fcurve_rotate_frame.get(in_frame);
float_t rotate_value = 0.0f;
if (has_rotate())
rotate_value = fcurve_rotate.get(in_frame);
rotate.z = rotate_frame_value + rotate_value;
float_t translate_frame_u = 0.0f;
if (has_translate_frame_u())
translate_frame_u = -fcurve_translate_frame_u.get(in_frame);
float_t offset_u = 0.0f;
if (has_offset_u())
offset_u = fcurve_offset_u.get(in_frame);
translate_frame.x = (translate_frame_u + offset_u) * repeat.x;
float_t translate_frame_v = 0.0f;
if (has_translate_frame_v())
translate_frame_v = -fcurve_translate_frame_v.get(in_frame);
float_t offset_v = 0.0f;
if (has_offset_v())
offset_v = fcurve_offset_v.get(in_frame);
translate_frame.y = (translate_frame_v + offset_v) * repeat.y;
mul();
}
// 0x1401E1DB0
void TextureTransform::mul() {
mat4_translate(&translate_frame, &mat);
mat4_scale_rot(&mat, &scale, &mat);
mat4_mul_translate(&mat, 1.0f, 1.0f, 0.0f, &mat);
mat4_scale_rot(&mat, &repeat, &mat);
mat4_mul_translate(&mat, -1.0f, -1.0f, 0.0f, &mat);
mat4_mul_translate(&mat, 0.5f, 0.5f, 0.0f, &mat);
mat4_mul_rotate_z(&mat, rotate.z, &mat);
mat4_mul_translate(&mat, -0.5f, -0.5f, 0.0f, &mat);
}
// 0x1401DFCB0
bool TextureTransform::load(const SceneFile& in_file,
const a3d::TextureTransform& in_tt, const texture_database* tex_db) {
name.assign(in_tt.name);
tex_uid = tex_db->get_texture_id(name.c_str());
if (in_tt.flag & a3d::TextureTransform::FLAG_COVERAGE_U) {
fcurve_coverage_u.load(in_file, in_tt.coverage_u);
flag |= FLAG_COVERAGE_U;
}
if (in_tt.flag & a3d::TextureTransform::FLAG_COVERAGE_V) {
fcurve_coverage_v.load(in_file, in_tt.coverage_v);
flag |= FLAG_COVERAGE_V;
}
if (in_tt.flag & a3d::TextureTransform::FLAG_REPEAT_U) {
fcurve_repeat_u.load(in_file, in_tt.repeat_u);
flag |= FLAG_REPEAT_U;
}
if (in_tt.flag & a3d::TextureTransform::FLAG_REPEAT_V) {
fcurve_repeat_v.load(in_file, in_tt.repeat_v);
flag |= FLAG_REPEAT_V;
}
if (in_tt.flag & a3d::TextureTransform::FLAG_ROTATE) {
fcurve_rotate.load(in_file, in_tt.rotate);
flag |= FLAG_ROTATE;
}
if (in_tt.flag & a3d::TextureTransform::FLAG_ROTATE_FRAME) {
fcurve_rotate_frame.load(in_file, in_tt.rotate_frame);
flag |= FLAG_ROTATE_FRAME;
}
if (in_tt.flag & a3d::TextureTransform::FLAG_OFFSET_U) {
fcurve_offset_u.load(in_file, in_tt.offset_u);
flag |= FLAG_OFFSET_U;
}
if (in_tt.flag & a3d::TextureTransform::FLAG_OFFSET_V) {
fcurve_offset_v.load(in_file, in_tt.offset_v);
flag |= FLAG_OFFSET_V;
}
if (in_tt.flag & a3d::TextureTransform::FLAG_TRANSLATE_FRAME_U) {
fcurve_translate_frame_u.load(in_file, in_tt.translate_frame_u);
flag |= FLAG_TRANSLATE_FRAME_U;
}
if (in_tt.flag & a3d::TextureTransform::FLAG_TRANSLATE_FRAME_V) {
fcurve_translate_frame_v.load(in_file, in_tt.translate_frame_v);
flag |= FLAG_TRANSLATE_FRAME_V;
}
return true;
}
// Added
void TextureTransform::store(const SceneFile& in_file, a3d::TextureTransform& out_tt) const {
out_tt.name.assign(name);
if (flag & FLAG_COVERAGE_U) {
fcurve_coverage_u.store(in_file, out_tt.coverage_u);
out_tt.flag |= a3d::TextureTransform::FLAG_COVERAGE_U;
}
if (flag & FLAG_COVERAGE_V) {
fcurve_coverage_v.store(in_file, out_tt.coverage_v);
out_tt.flag |= a3d::TextureTransform::FLAG_COVERAGE_V;
}
if (flag & FLAG_REPEAT_U) {
fcurve_repeat_u.store(in_file, out_tt.repeat_u);
out_tt.flag |= a3d::TextureTransform::FLAG_REPEAT_U;
}
if (flag & FLAG_REPEAT_V) {
fcurve_repeat_v.store(in_file, out_tt.repeat_v);
out_tt.flag |= a3d::TextureTransform::FLAG_REPEAT_V;
}
if (flag & FLAG_ROTATE) {
fcurve_rotate.store(in_file, out_tt.rotate);
out_tt.flag |= a3d::TextureTransform::FLAG_ROTATE;
}
if (flag & FLAG_ROTATE_FRAME) {
fcurve_rotate_frame.store(in_file, out_tt.rotate_frame);
out_tt.flag |= a3d::TextureTransform::FLAG_ROTATE_FRAME;
}
if (flag & FLAG_OFFSET_U) {
fcurve_offset_u.store(in_file, out_tt.offset_u);
out_tt.flag |= a3d::TextureTransform::FLAG_OFFSET_U;
}
if (flag & FLAG_OFFSET_V) {
fcurve_offset_v.store(in_file, out_tt.offset_v);
out_tt.flag |= a3d::TextureTransform::FLAG_OFFSET_V;
}
if (flag & FLAG_TRANSLATE_FRAME_U) {
fcurve_translate_frame_u.store(in_file, out_tt.translate_frame_u);
out_tt.flag |= a3d::TextureTransform::FLAG_TRANSLATE_FRAME_U;
}
if (flag & FLAG_TRANSLATE_FRAME_V) {
fcurve_translate_frame_v.store(in_file, out_tt.translate_frame_v);
out_tt.flag |= a3d::TextureTransform::FLAG_TRANSLATE_FRAME_V;
}
}
// 0x1401BCC10
TextureTransform& TextureTransform::operator=(const TextureTransform& other) {
flag = other.flag;
backup_flag = other.backup_flag;
name.assign(other.name);
tex_uid = other.tex_uid;
fcurve_coverage_u = other.fcurve_coverage_u;
fcurve_coverage_v = other.fcurve_coverage_v;
fcurve_repeat_u = other.fcurve_repeat_u;
fcurve_repeat_v = other.fcurve_repeat_v;
fcurve_translate_frame_u = other.fcurve_translate_frame_u;
fcurve_translate_frame_v = other.fcurve_translate_frame_v;
fcurve_offset_u = other.fcurve_offset_u;
fcurve_offset_v = other.fcurve_offset_v;
fcurve_rotate_frame = other.fcurve_rotate_frame;
fcurve_rotate = other.fcurve_rotate;
mat = other.mat;
scale = other.scale;
repeat = other.repeat;
rotate = other.rotate;
translate_frame = other.translate_frame;
return *this;
}
// 0x1401B7080
TransformNode::TransformNode() : flag(), name(), node_index(-1), parent_id(-1),
motion_transform(), mat_ptr(), joint_orient(), joint_orient_mat() {
}
// 0x1401B6F40
TransformNode::TransformNode(const TransformNode& other) : flag(other.flag), name(other.name),
node_index(other.node_index), parent_id(other.parent_id), motion_transform(other.motion_transform),
mat_ptr(other.mat_ptr), joint_orient(other.joint_orient), joint_orient_mat(other.joint_orient_mat) {
}
// 0x1401B9E00
TransformNode::~TransformNode() {
}
// Missing
void TransformNode::init() {
flag = 0;
name.clear();
name.shrink_to_fit();
node_index = -1;
parent_id = -1;
mat_ptr = 0;
}
// Inlined
inline void TransformNode::get(float_t in_frame) {
motion_transform.get(in_frame);
motion_transform.calc_matrix_local();
}
// 0x1401CAF10
void TransformNode::calc_matrix_local(const mat4& in_base_mat) {
mat4 mat = in_base_mat;
mat4_mul(&joint_orient_mat, &mat, &mat);
motion_transform.calc_matrix(mat);
if (mat_ptr)
*mat_ptr = motion_transform.matrix;
}
// Inlined
inline bool TransformNode::load(const SceneFile& in_file, const a3d::ObjectNode& in_on) {
name.assign(in_on.name);
parent_id = in_on.parent;
motion_transform.load(in_file, in_on.model_transform);
if (in_on.flag & a3d::ObjectNode::FLAG_JOINT_ORIENT) {
joint_orient = in_on.joint_orient;
mat4_rotate_zyx(&joint_orient, &joint_orient_mat);
flag |= FLAG_JOINT_ORIENT;
}
else {
joint_orient = 0.0f;
joint_orient_mat = mat4_identity;
}
return true;
}
// Added
inline void TransformNode::store(const SceneFile& in_file, a3d::ObjectNode& out_on) const {
out_on.name.assign(name);
out_on.parent = parent_id;
motion_transform.store(in_file, out_on.model_transform);
if (flag & FLAG_JOINT_ORIENT) {
out_on.joint_orient = joint_orient;
out_on.flag |= a3d::ObjectNode::FLAG_JOINT_ORIENT;
}
else
out_on.joint_orient = 0.0f;
}
// 0x1401BD280
TransformNode& TransformNode::operator=(const TransformNode& other) {
flag = other.flag;
name.assign(other.name);
node_index = other.node_index;
parent_id = other.parent_id;
motion_transform = other.motion_transform;
mat_ptr = other.mat_ptr;
joint_orient = other.joint_orient;
joint_orient_mat = other.joint_orient_mat;
return *this;
}
// 0x1401B3250
DB::DB() {
}
// 0x1401B8650
DB::~DB() {
}
// 0x1401C1850
void CategoryData::M_load_req(const char* in_mdata_dir) {
if (load_state != S_BEFORE_LOADING) {
load_state = S_DONE;
return;
}
load_state = S_NOW_LOADING;
if (in_mdata_dir && *in_mdata_dir) {
path.assign(in_mdata_dir);
path.append("rom/auth_3d/");
}
else
path.assign("rom/auth_3d/");
file.assign(category_name);
file.append(".farc");
if (file_handler.read_file(&data_list[DATA_AFT],
path.c_str(), file.c_str(), prj::MemCSystem))
file_handler.set_callback_data(0, (PFNFILEHANDLERCALLBACK*)S_load_cb, this);
else
load_state = S_DONE;
}
// Added
void CategoryData::M_load_req_modern(void* data) {
if (load_state != S_BEFORE_LOADING) {
load_state = S_DONE;
return;
}
load_state = S_NOW_LOADING;
path.assign("root+/auth_3d/");
file.assign(category_name);
file.append(".farc");
if (file_handler.read_file(data, path.c_str(),
hash_string_murmurhash(category_name), ".farc", prj::MemCSystem))
file_handler.set_callback_data(0, (PFNFILEHANDLERCALLBACK*)S_load_cb, this);
else
load_state = S_DONE;
}
// 0x1401BF7B0
void CategoryData::M_free() {
if (load_state == S_NOW_LOADING)
file_handler.call_free_callback();
else if (load_state == S_DONE) {
delete ar;
ar = 0;
file_handler.reset();
}
path.clear();
path.shrink_to_fit();
file.clear();
file.shrink_to_fit();
raw_data = 0;
raw_size = 0;
load_state = S_BEFORE_LOADING;
}
// 0x1401C1EE0
bool CategoryData::S_load_cb(CategoryData* data, const void* file_data, size_t file_size) {
if (data->load_state == S_NOW_LOADING) {
data->load_state = S_DONE;
data->raw_data = file_data;
data->raw_size = file_size;
}
if (!data->ar)
data->ar = new farc;
if (data->ar) {
data->ar->read(data->raw_data, data->raw_size, true);
return true;
}
return false;
}
// 0x1401B2F20
CategoryData::CategoryData() : ref_count(), load_state(), ar(), raw_data(), raw_size() {
}
// 0x1401B2E80
CategoryData::CategoryData(const CategoryData& other) {
*this = other;
}
// 0x1401B84C0
CategoryData::~CategoryData() {
delete ar;
}
// 0x1401E0F60
void CategoryData::load_req(const char* in_mdata_dir) {
if (ref_count)
ref_count++;
else {
ref_count = 1;
M_load_req(in_mdata_dir);
}
}
// Added
void CategoryData::load_req_modern(void* data) {
if (ref_count)
ref_count++;
else {
ref_count = 1;
M_load_req_modern(data);
}
}
// 0x1401D3B10
void CategoryData::free() {
if (--ref_count < 0)
ref_count = 0;
else if (!ref_count)
M_free();
}
// 0x1401D54C0
std::tuple<size_t, const void*> CategoryData::get_file(const std::string& in_name) {
if (ar) {
farc_file* ff = ar->read_file(in_name.c_str());
if (ff)
return { ff->size, ff->data };
}
return {};
}
// Added
std::tuple<size_t, const void*, const char*> CategoryData::get_file(uint32_t in_hash) {
if (ar) {
farc_file* ff = ar->read_file(in_hash);
if (ff)
return { ff->size, ff->data, ff->name.c_str() };
}
return {};
}
// 0x1401E0670
inline bool CategoryData::load_is_done() const {
return load_state == S_DONE;
}
// 0x1401BB670
CategoryData& CategoryData::operator=(const CategoryData& other) {
ref_count = other.ref_count;
category_name.assign(other.category_name);
load_state = other.load_state;
path.assign(other.path);
file.assign(other.file);
file_handler = other.file_handler;
ar = other.ar ? new farc(*other.ar) : 0;
raw_data = other.raw_data;
raw_size = other.raw_size;
return *this;
}
// 0x1401B63F0
SceneFile::SceneFile() : frame_max(), raw_data(), raw_size(), has_raw(), prop_is_ready() {
}
// 0x1401B6320
SceneFile::SceneFile(const SceneFile& other) {
*this = other;
}
// 0x1401B9B20
SceneFile::~SceneFile() {
}
// 0x1401DF370
void SceneFile::load(const void* in_data, size_t in_size) {
frame_max = 0.0f;
raw_data = in_data;
raw_size = in_size;
has_raw = true;
prop.read(in_data, in_size);
prop_is_ready = prop.ready;
}
// 0x1401CD130
void SceneFile::clear() {
frame_max = 0.0f;
raw_data = 0;
raw_size = 0;
has_raw = false;
prop = {};
prop_is_ready = 0;
}
// 0x1401BCAE0
SceneFile& SceneFile::operator=(const SceneFile& other) {
frame_max = other.frame_max;
raw_data = other.raw_data;
raw_size = other.raw_size;
has_raw = other.has_raw;
prop = other.prop;
prop_is_ready = other.prop_is_ready;
return *this;
}
// Inlined
void UidData::M_load_req(const auth_3d_database* auth_3d_db) {
load_state = S_DONE;
if (uid >= auth_3d_db->uid.size())
return;
const auth_3d_database_uid* db_uid = &auth_3d_db->uid[uid];
if (!db_uid->enabled)
return;
name = db_uid->name.c_str();
file_name.assign(db_uid->name);
file_name.append(".a3da");
category = g_manager->get_category_data(db_uid->category_name.c_str());
if (category) {
ref_count = 1;
M_load_req_category();
}
}
// 0x1401C1A80
void UidData::M_load_req_category() {
load_state = S_NOW_LOADING;
category->load_req(0);
}
// 0x1401BF810
void UidData::M_free() {
if (load_state == S_NOW_LOADING)
category->free();
else if (load_state == S_DONE) {
file.clear();
category->free();
}
name = 0;
category = 0;
load_state = S_BEFORE_LOADING;
}
// 0x1401C1710
void UidData::M_load_is_done() {
if (load_state != S_NOW_LOADING || !category->load_is_done())
return;
std::string file_name(name);
file_name.append(".a3da");
size_t size;
const void* data;
std::tie(size, data) = category->get_file(file_name);
time_struct time;
file.load(data, size);
time.calc_time();
load_state = S_DONE;
}
// 0x1401B7240
UidData::UidData() : ref_count(), uid(), load_state(), name(), category() {
}
// 0x1401B71B0
UidData::UidData(const UidData& other) {
*this = other;
}
// 0x1401B9ED0
UidData::~UidData() {
}
// 0x1401E1040
void UidData::load_req(const auth_3d_database* auth_3d_db) {
if (ref_count)
ref_count++;
else if (load_state == S_BEFORE_LOADING)
M_load_req(auth_3d_db);
}
// 0x1401D3B30
void UidData::free() {
if (--ref_count < 0)
ref_count = 0;
else if (!ref_count)
M_free();
}
// 0x1401E06E0
bool UidData::load_is_done() {
M_load_is_done();
return load_state == S_DONE;
}
// 0x1401BD3F0
UidData& UidData::operator=(const UidData& other) {
ref_count = other.ref_count;
uid = other.uid;
file_name.assign(file_name);
load_state = other.load_state;
file = other.file;
name = other.name;
category = other.category;
return *this;
}
// Added
void UidDataModern::M_load_req() {
load_state = S_DONE;
category = g_manager->get_category_data_modern(hash);
if (category) {
file_name.assign(category->ar->get_file_name(hash));
ref_count = 1;
M_load_req_category();
}
}
// Added
void UidDataModern::M_load_req_category() {
load_state = S_NOW_LOADING;
category->load_req(0);
}
// Added
void UidDataModern::M_free() {
if (load_state == S_NOW_LOADING)
category->free();
else if (load_state == S_DONE) {
file.clear();
category->free();
}
name.clear();
name.shrink_to_fit();
category = 0;
load_state = S_BEFORE_LOADING;
g_manager->uid_data_list_modern.erase(hash);
}
// Added
void UidDataModern::M_load_is_done() {
if (load_state != S_NOW_LOADING || !category->load_is_done())
return;
size_t size;
const void* data;
const char* name;
std::tie(size, data, name) = category->get_file(hash);
time_struct time;
file_name.assign(name);
file.load(data, size);
time.calc_time();
load_state = S_DONE;
}
// Added
UidDataModern::UidDataModern() : ref_count(),
load_state(), name(), category(), data(), obj_db(), tex_db() {
hash = hash_murmurhash_empty;
}
// Added
UidDataModern::UidDataModern(const UidDataModern& other) {
*this = other;
}
// Added
UidDataModern::~UidDataModern() {
}
// Added
void UidDataModern::load_req() {
if (ref_count)
ref_count++;
else if (load_state == S_BEFORE_LOADING)
M_load_req();
}
// Added
void UidDataModern::free() {
if (--ref_count < 0)
ref_count = 0;
else if (!ref_count)
M_free();
}
// Added
bool UidDataModern::load_is_done() {
M_load_is_done();
return load_state == S_DONE;
}
// Added
UidDataModern& UidDataModern::operator=(const UidDataModern& other) {
ref_count = other.ref_count;
hash = other.hash;
file_name.assign(file_name);
load_state = other.load_state;
file = other.file;
name.assign(name);
category = other.category;
data = other.data;
obj_db = other.obj_db;
tex_db = other.tex_db;
return *this;
}
// 0x1401B60B0
Scene::Scene() : M_uid(), my_handle(), M_is_enabled(), M_camera_is_enabled(),
M_is_visible(), M_is_looped(), M_is_start(), M_is_finished(), M_is_reverse_side(),
M_is_auto_disable(), trnsl(), trnsl_state(), M_is_attribute_wall(), M_assign_rob_id(),
M_ex_node_mat(), M_shadow(), M_chara_item(), M_reflect(), M_cn_src(), M_cn_dst(),
M_debug(), M_data(), M_frc(), M_frame(), frame_req(), frame_max(), is_requested_frame(),
M_frame_loop_begin(), M_frame_loop_end(), M_fov_adjust(), object_hrc_blend_list(),
object_hrc_blend(), now_pause(), event_time_unread_ptr() {
hash = hash_murmurhash_empty;
init();
}
// 0x1401B93F0
Scene::~Scene() {
init();
}
// 0x1401D79C0
void Scene::init() {
M_uid = -1;
my_handle = -1;
M_is_enabled = false;
M_camera_is_enabled = true;
M_is_visible = true;
M_is_looped = false;
M_is_start = false;
M_is_finished = false;
M_is_reverse_side = false;
M_is_auto_disable = false;
base_matrix = mat4_identity;
trnsl = 1.0f;
trnsl_state = mdl::OBJ_ALPHA_ORDER_POST_GLITTER;
M_is_attribute_wall = false;
item_attr_map.clear();
item_texchg_list.clear();
item_texchg_list.shrink_to_fit();
M_assign_rob_id = ROB_ID_NULL;
M_ex_node_mat = 0;
M_obj_uid = {};
M_shadow = false;
M_chara_item = false;
M_reflect = false;
M_cn_src = CN_MAX;
M_cn_dst = CN_MAX;
M_debug = 0;
M_data = 0;
M_frc = get_sys_frame_rate();
M_frame = 0.0f;
frame_req = 0.0f;
frame_max = -1.0f;
is_requested_frame = true;
M_frame_loop_begin = 0.0f;
M_frame_loop_end = 0.0f;
M_fov_adjust = 1.0f;
object_hrc_blend_list = 0;
object_hrc_blend = 0.0f;
now_pause = true;
for (Event*& i : event_list)
if (i) {
delete i;
i = 0;
}
event_list.clear();
event_list.shrink_to_fit();
event_time_list.clear();
event_time_list.shrink_to_fit();
event_time_unread_ptr = event_time_list.begin();
play_control.init();
point_list.clear();
point_list.shrink_to_fit();
curve_list.clear();
curve_list.shrink_to_fit();
camera_root_list.clear();
camera_root_list.shrink_to_fit();
camera_auxiliary.init();
light_list.clear();
light_list.shrink_to_fit();
// MGF
ambient_list.clear();
ambient_list.shrink_to_fit();
fog_list.clear();
fog_list.shrink_to_fit();
post_process.init();
dof.init();
chara_list.clear();
chara_list.shrink_to_fit();
motion_list.clear();
motion_list.shrink_to_fit();
object_holder.clear();
object_holder.shrink_to_fit();
object_list.clear();
object_list.shrink_to_fit();
object_hrc_holder.clear();
object_hrc_holder.shrink_to_fit();
object_hrc_list.clear();
object_hrc_list.shrink_to_fit();
m_object_hrc_holder.clear();
m_object_hrc_holder.shrink_to_fit();
m_object_hrc_list.clear();
m_object_hrc_list.shrink_to_fit();
adx_sound_list.clear();
adx_sound_list.shrink_to_fit();
// X/XHD
material_list.clear();
material_list.shrink_to_fit();
object_name_list.clear();
object_name_list.shrink_to_fit();
object_hrc_name_list.clear();
object_hrc_name_list.shrink_to_fit();
m_object_hrc_name_list.clear();
m_object_hrc_name_list.shrink_to_fit();
auth_2d_list.clear();
auth_2d_list.shrink_to_fit();
load_state = S_BEFORE_LOADING;
my_event_listener.clear();
my_event_listener.shrink_to_fit();
file_name.clear();
file_name.shrink_to_fit();
hash = hash_murmurhash_empty;
obj_db = 0;
tex_db = 0;
}
// 0x1401D01C0
void Scene::destroy(render_context* rctx) {
camera_auxiliary.dest(rctx);
for (Light& i : light_list)
i.dest(rctx);
for (Fog& i : fog_list)
i.dest(rctx);
dof.dest(rctx);
post_process.dest(rctx);
for (Event* i : event_list)
if (i->active) {
i->active = false;
i->exit(*this, EAF_DESTROY, rctx);
}
if (load_state != S_BEFORE_LOADING)
if (hash == hash_murmurhash_empty) {
data_struct* aft_data = &data_list[DATA_AFT];
auth_3d_database* aft_auth_3d_db = &aft_data->data_ft.auth_3d_db;
g_manager->uid_free(M_uid, aft_auth_3d_db);
}
else
g_manager->uid_free_modern(hash);
init();
}
// 0x1401D6310
int32_t Scene::get_uid() const {
return M_uid;
}
// 0x1401CF110
void Scene::ctrl(render_context* rctx) {
M_load_exec();
if (load_state != S_DONE || !M_is_enabled)
return;
EventActionFlag eaf = (EventActionFlag)0;
bool set = false;
while (true) {
bool is_start = M_is_start;
if (is_requested_frame) {
is_requested_frame = false;
if (frame_req < M_frame) {
event_time_unread_ptr = event_time_list.begin();
enum_or(eaf, EAF_JUMP_BACKWARD);
}
else
enum_or(eaf, EAF_JUMP_FORWARD);
M_frame = frame_req;
M_is_start = true;
M_is_finished = false;
if (frame_max >= 0.0f && M_frame >= frame_max)
frame_max = -1.0f;
}
else if (!now_pause) {
enum_or(eaf, EAF_PASS);
M_frame += M_frc->get_delta_frame();
if (frame_max >= 0.0f && M_frame > frame_max)
M_frame = frame_max;
}
float_t frame = M_frame;
for (Point& i : point_list)
i.get(frame);
for (Curve& i : curve_list)
i.get(frame);
for (Chara& i : chara_list)
i.get(frame);
for (Object& i : object_holder)
i.get(frame);
for (Object*& i : object_list)
i->ctrl(base_matrix);
for (HierarchyObject& i : object_hrc_holder)
i.get(frame);
for (HierarchyObject*& i : object_hrc_list)
i->ctrl(base_matrix);
for (MultiHierarchyObject& i : m_object_hrc_holder)
i.get(frame);
for (MultiHierarchyObject*& i : m_object_hrc_list)
i->ctrl(base_matrix);
// X/XHD
for (MaterialList& i : material_list)
i.get(frame);
for (Light& i : light_list) {
i.get(frame);
i.ctrl(rctx);
}
// MGF
for (Ambient& i : ambient_list) {
i.get(frame);
i.ctrl(rctx);
}
for (Fog& i : fog_list) {
i.get(frame);
i.ctrl(rctx);
}
post_process.get(frame);
post_process.ctrl(*this, rctx);
for (Chara& i : chara_list)
i.ctrl(*this);
auto i_event = event_time_unread_ptr;
auto i_event_end = event_time_list.end();
for (; i_event != i_event_end && frame >= i_event->frame; i_event++) {
Event* e = event_list[i_event->event_index];
if (!i_event->type) {
event_log(" [%s]: [%s][%s]\n",
get_ID_EVENT_TYPE(e->type), e->ref.c_str(), e->param1.c_str());
e->entry(*this, eaf, rctx);
e->active = true;
}
else if (i_event->type) {
event_log(" [%s]: [%s][%s]\n",
get_ID_EVENT_TYPE(e->type), e->ref.c_str(), e->param1.c_str());
if (e->active) {
e->active = false;
e->exit(*this, eaf, rctx);
}
}
}
event_time_unread_ptr = i_event;
for (Event* i : event_list)
if (i->active)
i->do_ctrl(*this, eaf, rctx);
camera_auxiliary.get(frame);
camera_auxiliary.ctrl(*this, rctx);
if (M_camera_is_enabled)
for (CameraRoot& i : camera_root_list) {
CameraParam cam = i.get(frame, *this, rctx);
if (M_is_reverse_side) {
cam.interest.x = -cam.interest.x;
cam.view_point.x = -cam.view_point.x;
cam.roll = -cam.roll;
}
mat4_transform_point(&base_matrix, &cam.interest, &cam.interest);
mat4_transform_point(&base_matrix, &cam.view_point, &cam.view_point);
cam.set(rctx->camera);
break;
}
dof.get(frame);
dof.ctrl(rctx);
if (M_is_start && is_start != M_is_start)
for (a3d::EventListener*& i : my_event_listener) {
Handle handle = to_handle();
i->playStart(handle);
}
if (set || !M_is_looped || M_frame_loop_end > frame)
break;
for (a3d::EventListener*& i : my_event_listener) {
Handle handle = to_handle();
i->playLoopJumpBefore(handle);
}
frame_req = frame - M_frame_loop_end + M_frame_loop_begin;
is_requested_frame = true;
set = true;
}
for (a3d::EventListener*& i : my_event_listener) {
Handle handle = to_handle();
i->playLoopJumpAfter(handle);
}
bool is_finished = play_control.size <= M_frame;
if (is_finished && M_is_finished != is_finished) {
now_pause = true;
if (M_is_auto_disable)
M_is_enabled = false;
for (a3d::EventListener*& i : my_event_listener) {
Handle handle = to_handle();
i->playFinished(handle);
}
}
M_is_finished = is_finished;
}
// 0x1401D1230
void Scene::disp(render_context* rctx) {
if (load_state != S_DONE || !M_is_enabled)
return;
if (M_debug)
debug_put_line_axis(base_matrix);
// X/XHD
auth_3d_set_material_list(*this, rctx);
extern bool reflect_full;
extern bool reflect_draw;
reflect_draw = reflect_full && M_reflect;
for (Point& i : point_list)
i.disp(*this, rctx);
for (Chara& i : chara_list)
i.disp(*this, base_matrix, rctx);
for (Object*& i : object_list)
i->disp(*this, rctx);
for (HierarchyObject*& i : object_hrc_list)
i->disp(*this, rctx);
for (MultiHierarchyObject*& i : m_object_hrc_list)
i->disp(*this, rctx);
for (Event* i : event_list)
if (i->active)
i->do_disp(*this, base_matrix, rctx);
reflect_draw = false;
rctx->disp_manager->set_material_list();
}
// 0x1401E0FC0
void Scene::load_req(const auth_3d_database* auth_3d_db) {
if (g_manager->uid_load_req(M_uid, auth_3d_db))
load_state = S_NOW_LOADING;
}
// Added
void Scene::load_req_modern() {
if (g_manager->uid_load_req_modern(hash))
load_state = S_NOW_LOADING;
}
// 0x1401C1AE0
void Scene::M_put_obj(const mat4& in_mat, object_info in_id, render_context* rctx) const {
if (trnsl < 0.999f)
rctx->disp_manager->entry_obj_by_object_info(in_mat, in_id, trnsl);
else
rctx->disp_manager->entry_obj_by_object_info(in_mat, in_id);
}
// 0x1401E06D0
bool Scene::load_is_done() const {
return load_state == S_DONE;
}
// 0x1401C92A0
void Scene::add_event_listener(a3d::EventListener* in_evt_list) {
my_event_listener.push_back(in_evt_list);
}
// 0x1401E3490
void Scene::remove_event_listener(a3d::EventListener* in_evt_list) {
prj::find_and_erase(my_event_listener, in_evt_list);
}
// 0x1401BF9C0
void Scene::M_loadFromProperties(SceneFile& in_file,
const object_database* in_obj_db, const texture_database* in_tex_db) {
a3d::Scene& prop = in_file.prop;
hash = hash_murmurhash_empty;
play_control.load(in_file, prop.play_control);
in_file.frame_max = play_control.size;
frame_max = play_control.size;
M_frame_loop_begin = 0.0f;
M_frame_loop_end = play_control.size;
obj_db = in_obj_db;
tex_db = in_tex_db;
list_load(point_list, in_file, prop.point);
list_load(curve_list, in_file, prop.curve);
list_load(camera_root_list, in_file, prop.camera_root);
camera_auxiliary.load(in_file, prop.camera_auxiliary);
list_load(light_list, in_file, prop.light);
// MGF
list_load(ambient_list, in_file, prop.ambient);
list_load(fog_list, in_file, prop.fog);
post_process.load(in_file, prop.post_process);
dof.load(in_file, prop.dof);
list_load(chara_list, in_file, prop.chara);
list_load(motion_list, in_file, prop.motion);
list_load(auth_2d_list, in_file, prop.auth_2d);
list_load(object_holder, in_file, prop.object, obj_db, tex_db);
size_t object_index = 0;
for (Object& i : object_holder) {
i.replace_chara(M_cn_src, M_cn_dst, obj_db);
i.index = object_index++;
}
if (prop.object_list.size())
object_name_list.assign(prop.object_list.begin(), prop.object_list.end());
for (Object& i : object_holder) {
if (i.obj_pat.name.size()) {
size_t index = get_curve_index(i.obj_pat.name);
if (index != -1)
i.obj_pat.bind(curve_list[index]);
}
if (i.obj_morph.name.size()) {
size_t index = get_curve_index(i.obj_morph.name);
if (index != -1)
i.obj_morph.bind(curve_list[index]);
}
for (Texture& j : i.texture_list)
if (j.tex_pat.name.size()) {
size_t index = get_curve_index(j.tex_pat.name);
if (index != -1)
j.tex_pat.bind(curve_list[index]);
}
i.prepare_morph(obj_db);
}
object_list.reserve(object_name_list.size());
for (const std::string& i : object_name_list)
object_list.push_back(&object_holder[get_object_index(i)]);
list_load(object_hrc_holder, in_file, prop.object_hrc, obj_db);
for (HierarchyObject& i : object_hrc_holder) {
i.ex_node_mat = M_ex_node_mat;
bool v45 = i.replace_chara(M_cn_src, M_cn_dst, obj_db);
object_info obj_uid;
if (!v45 && !i.parent_name.size())
obj_uid = M_obj_uid;
i.set_obj_uid(obj_uid);
}
std::string chara_str;
if (M_assign_rob_id >= 0 || M_assign_rob_id < ROB_ID_MAX) {
std::string char_str = get_char_id_str(get_rob_management()->get_chara((ROB_ID)M_assign_rob_id));
chara_str.assign("_" + char_str);
}
else
chara_str.assign("____");
for (HierarchyObject& i : object_hrc_holder)
i.check_rob_chara(chara_str);
if (prop.object_hrc_list.size())
object_hrc_name_list.assign(prop.object_hrc_list.begin(), prop.object_hrc_list.end());
object_hrc_list.reserve(object_hrc_name_list.size());
for (const std::string& i : object_hrc_name_list) {
size_t index = get_object_hrc_index(i);
if (index != -1)
object_hrc_list.push_back(&object_hrc_holder[index]);
}
list_load(m_object_hrc_holder, in_file, prop.m_object_hrc, obj_db);
if (prop.m_object_hrc_list.size())
m_object_hrc_name_list.assign(prop.m_object_hrc_list.begin(), prop.m_object_hrc_list.end());
m_object_hrc_list.reserve(m_object_hrc_name_list.size());
for (const std::string& i : m_object_hrc_name_list) {
size_t index = get_m_object_hrc_index(i);
if (index != -1)
m_object_hrc_list.push_back(&m_object_hrc_holder[index]);
}
if (object_holder.size()) {
for (Object& i : object_holder) {
if (!i.parent_name.size())
continue;
if (i.parent_node.size())
for (HierarchyObject& j : object_hrc_holder) {
if (i.parent_name.compare(j.name))
continue;
int32_t node_index = j.query_node_index(i.parent_node.c_str());
if (node_index >= 0)
j.add_child_object(node_index, &i);
break;
}
else
for (Object& j : object_holder) {
if (i.parent_name.compare(j.name))
continue;
j.child_object_list.push_back(&i);
break;
}
}
}
if (object_hrc_holder.size()) {
for (HierarchyObject& i : object_hrc_holder) {
if (!i.parent_name.size())
continue;
if (i.parent_node.size())
for (HierarchyObject& j : object_hrc_holder) {
if (i.parent_name.compare(j.name))
continue;
int32_t node_index = j.query_node_index(i.parent_node.c_str());
if (node_index >= 0)
j.add_child_object(node_index, &i);
break;
}
else
for (Object& j : object_holder) {
if (i.parent_name.compare(j.name))
continue;
j.child_object_hrc_list.push_back(&i);
break;
}
}
}
adx_sound_list.clear();
// X/XHD
list_load(material_list, in_file, prop.material_list);
if (prop.event.size()) {
event_list.reserve(prop.event.size());
for (const a3d::Event& i : prop.event) {
Event* e = createEvent(in_file, i);
if (e) {
event_list.push_back(e);
if (e->type == a3d::EVENT_SND) {
std::string param1(e->param1);
if (param1.find("_adx") == param1.size() - 4)
adx_sound_list.push_back(param1);
}
}
}
if (adx_sound_list.size()) {
std::string path("rom/sound/voice/auth_voice/");
path.append(adx_sound_list.front());
path.append(".adx");
sound_work_play_stream(2, path.c_str(), true);
}
for (Event* i : event_list)
if (i)
i->resolve_relation(*this);
}
event_time_list.clear();
event_time_list.shrink_to_fit();
if (event_list.size()) {
size_t event_index = 0;
event_time_list.reserve(event_list.size() * 2);
for (Event* i : event_list) {
event_time_list.push_back({ i->begin, 0, event_index });
event_time_list.push_back({ i->end , 1, event_index });
event_index++;
}
std::sort(event_time_list.begin(), event_time_list.end(),
[](const TimeEvent& left, const TimeEvent& right) {
return left.frame < right.frame;
});
}
event_time_unread_ptr = event_time_list.begin();
file_name.assign(prop._file_name);
}
// Added
void Scene::M_storeToProperties(SceneFile& in_file) const {
a3d::Scene& prop = in_file.prop;
play_control.store(in_file, prop.play_control);
list_store(point_list, in_file, prop.point);
list_store(curve_list, in_file, prop.curve);
list_store(camera_root_list, in_file, prop.camera_root);
camera_auxiliary.store(in_file, prop.camera_auxiliary);
list_store(light_list, in_file, prop.light);
// MGF
list_store(ambient_list, in_file, prop.ambient);
list_store(fog_list, in_file, prop.fog);
post_process.store(in_file, prop.post_process);
dof.store(in_file, prop.dof);
list_store(chara_list, in_file, prop.chara);
list_store(motion_list, in_file, prop.motion);
list_store(auth_2d_list, in_file, prop.auth_2d);
list_store(object_holder, in_file, prop.object);
if (object_name_list.size())
prop.object_list.assign(object_name_list.begin(), object_name_list.end());
list_store(object_hrc_holder, in_file, prop.object_hrc);
if (object_hrc_name_list.size())
prop.object_hrc_list.assign(
object_hrc_name_list.begin(), object_hrc_name_list.end());
list_store(m_object_hrc_holder, in_file, prop.m_object_hrc);
if (m_object_hrc_name_list.size())
prop.m_object_hrc_list.assign(
m_object_hrc_name_list.begin(), m_object_hrc_name_list.end());
// X/XHD
list_store(material_list, in_file, prop.material_list);
if (event_list.size()) {
size_t event_index = 0;
prop.motion.resize(event_list.size());
for (const Event* i : event_list)
i->store(in_file, prop.event[event_index++]);
}
}
// 0x1401D8C10
inline bool Scene::is_valid() const {
return my_handle != -1;
}
// 0x1401E6730
void Scene::set_frame_rate_control(FrameRateControl* in_value) {
if (in_value)
M_frc = in_value;
else
M_frc = get_sys_frame_rate();
}
// 0x1401D58D0
float_t Scene::get_frame_speed() const {
return M_frc->get_delta_frame();
}
// 0x1401E67B0
void Scene::set_frame_req(float_t in_frame) {
frame_req = in_frame;
is_requested_frame = true;
}
void Scene::set_frame_max(float_t in_frame) {
frame_max = in_frame;
}
float_t Scene::get_frame() const {
return M_frame;
}
float_t Scene::get_frame_size() const {
return play_control.size;
}
float_t Scene::get_frame_fps() const {
return play_control.fps;
}
float_t Scene::get_frame_begin() const {
return play_control.begin;
}
// 0x1401E6A50
void Scene::set_pause(bool in_value) {
now_pause = in_value;
}
// 0x1401D5DD0
bool Scene::get_pause() const {
return now_pause;
}
// 0x1401E6460
void Scene::set_enabled(bool in_value) {
M_is_enabled = in_value;
}
// 0x1401D55C0
bool Scene::get_enabled() const {
return M_is_enabled;
}
// 0x1401E6BC0
void Scene::set_visible(bool in_value) {
M_is_visible = in_value;
}
// 0x1401D64E0
bool Scene::get_visible() const {
return M_is_visible;
}
// 0x1401E6990
void Scene::set_looped(bool in_value) {
M_is_looped = in_value;
}
// 0x1401D59D0
bool Scene::get_looped() const {
return M_is_looped;
}
// 0x1401E65F0
void Scene::set_frame_loop_begin(float_t in_frame) {
M_frame_loop_begin = in_frame;
}
// 0x1401E6600
void Scene::set_frame_loop_begin() {
M_frame_loop_begin = 0.0f;
}
// 0x1401D5800
float_t Scene::get_frame_loop_begin() const {
return M_frame_loop_begin;
}
// 0x1401E6690
void Scene::set_frame_loop_end(float_t in_frame) {
M_frame_loop_end = in_frame;
}
// 0x1401E66A0
void Scene::set_frame_loop_end() {
M_frame_loop_end = play_control.size;
}
// 0x1401D5850
float_t Scene::get_frame_loop_end() const {
return M_frame_loop_end;
}
// 0x1401D8AF0
bool Scene::is_finished() const {
return M_is_finished;
}
// 0x1401E6AC0
void Scene::set_reverse_side(bool in_value) {
M_is_reverse_side = in_value;
}
// 0x1401D5EA0
bool Scene::get_reverse_side() const {
return M_is_reverse_side;
}
// 0x1401E6320
void Scene::set_auto_disable(bool in_value) {
M_is_auto_disable = in_value;
}
// 0x1401D51F0
bool Scene::get_auto_disable() const {
return M_is_auto_disable;
}
// 0x1401E6370
void Scene::set_base_matrix(const mat4& in_value) {
base_matrix = in_value;
}
// 0x1401D5280
const mat4& Scene::get_base_matrix() const {
return base_matrix;
}
// 0x1401E6B60
void Scene::set_trnsl(float_t in_value, mdl::ObjFlags in_state) {
trnsl = in_value;
trnsl_state = in_state;
}
// 0x1401D6110
float_t Scene::get_trnsl() const {
return trnsl;
}
// 0x1401E62D0
void Scene::set_attribute_wall(bool in_value) {
M_is_attribute_wall = in_value;
}
// 0x1401D50E0
bool Scene::get_attribute_wall() const {
return M_is_attribute_wall;
}
// 0x1401E6860
void Scene::set_item_attr(uint32_t in_id, uint32_t in_attr) {
item_attr_map.insert({ in_id, in_attr });
}
// Missing
uint32_t Scene::get_item_attr(uint32_t in_id) const {
auto elem = item_attr_map.find(in_id);
if (elem != item_attr_map.end())
return elem->second;
return 0;
}
// 0x1401E68E0
void Scene::set_item_texchange(const std::vector<ItemTexChange>& in_list) {
item_texchg_list.assign(in_list.begin(), in_list.end());
}
// Missing
const std::vector<ItemTexChange>& Scene::get_item_texchange() const {
return item_texchg_list;
}
// 0x1401D5480
inline size_t Scene::get_chara_size() const {
return chara_list.size();
}
// 0x1401D5400
inline size_t Scene::get_chara_index(const std::string& in_name) const {
return get_index_by_name(chara_list, in_name);
}
// 0x1401CBF60
const std::string* Scene::chara_get_name(size_t in_index) const {
if (in_index < chara_list.size())
return &chara_list[in_index].name;
return 0;
}
// Inlined
void Scene::chara_bind_rob(size_t in_index, int32_t in_rob_id) {
if (in_index < chara_list.size()
&& (in_rob_id == ROB_ID_NULL || in_rob_id == ROB_ID_1P || in_rob_id == ROB_ID_2P)
&& chara_list[in_index].rob_id != in_rob_id)
chara_list[in_index].rob_id = in_rob_id;
}
// 0x1401D5C80
size_t Scene::get_object_size() const {
return object_holder.size();
}
// 0x1401D5AD0
size_t Scene::get_object_index(const std::string& in_name) const {
return get_index_by_name(object_holder, in_name);
}
// 0x1401D5AE0
int32_t Scene::get_object_index(object_info in_obj_uid, int32_t in_instance) const {
if (in_instance >= 0) {
int32_t index = 0;
int32_t instance = 0;
for (auto i = object_holder.cbegin(); i != object_holder.cend(); i++, index++)
if (in_obj_uid == i->obj_uid) {
if (in_instance == instance)
return index;
instance++;
}
return -1;
}
int32_t index = 0;
for (auto i = object_holder.cbegin(); i != object_holder.cend(); i++, index++)
if (in_obj_uid == i->obj_uid)
return index;
return -1;
}
// Added
int32_t Scene::get_object_index(uint32_t in_obj_hash, int32_t in_instance) const {
if (in_instance >= 0) {
int32_t index = 0;
int32_t instance = 0;
for (auto i = object_holder.cbegin(); i != object_holder.cend(); i++, index++)
if (in_obj_hash == i->obj_hash) {
if (in_instance == instance)
return index;
instance++;
}
return -1;
}
int32_t index = 0;
for (auto i = object_holder.cbegin(); i != object_holder.cend(); i++, index++)
if (in_obj_hash == i->obj_hash)
return index;
return -1;
}
// Inlined
const std::string* Scene::object_get_name(size_t in_index) const {
if (in_index < object_holder.size())
return &object_holder[in_index].name;
return 0;
}
// 0x1401D5B70
const mat4* Scene::get_object_matrix(size_t in_index) const {
if (in_index < object_holder.size())
return &object_holder[in_index].model_transform.matrix;
return 0;
}
// Inlined
const mat4* Scene::get_object_matrix(size_t in_index, bool in_is_hrc) const {
if (in_is_hrc)
return get_object_hrc_matrix(in_index);
return get_object_matrix(in_index);
}
// Inlined
inline size_t Scene::get_object_hrc_size() const {
return object_hrc_holder.size();
}
// 0x0x1401D5CB0
size_t Scene::get_object_hrc_index(const std::string& in_name) const {
return get_index_by_name(object_hrc_holder, in_name);
}
// 0x1401D5CC0
int32_t Scene::get_object_hrc_index(object_info in_obj_uid, int32_t in_instance) const {
if (in_instance >= 0) {
int32_t index = 0;
int32_t instance = 0;
for (auto i = object_hrc_holder.cbegin(); i != object_hrc_holder.cend(); i++, index++)
if (in_obj_uid == i->obj_uid) {
if (in_instance == instance)
return index;
instance++;
}
return -1;
}
int32_t index = 0;
for (auto i = object_hrc_holder.cbegin(); i != object_hrc_holder.cend(); i++, index++)
if (in_obj_uid == i->obj_uid)
return index;
return -1;
}
// Added
int32_t Scene::get_object_hrc_index(uint32_t in_obj_hash, int32_t in_instance) const {
if (in_instance >= 0) {
int32_t index = 0;
int32_t instance = 0;
for (auto i = object_hrc_holder.cbegin(); i != object_hrc_holder.cend(); i++, index++)
if (in_obj_hash == i->obj_hash) {
if (in_instance == instance)
return index;
instance++;
}
return -1;
}
int32_t index = 0;
for (auto i = object_hrc_holder.cbegin(); i != object_hrc_holder.cend(); i++, index++)
if (in_obj_hash == i->obj_hash)
return index;
return -1;
}
// Missing
const std::string* Scene::object_hrc_get_name(size_t in_index) const {
if (in_index < object_hrc_holder.size())
return &object_hrc_holder[in_index].name;
return 0;
}
// 0x1401D5D00
const mat4* Scene::get_object_hrc_matrix(size_t in_index) const {
if (in_index < object_hrc_holder.size()) {
const HierarchyObject& hrc_obj = object_hrc_holder[in_index];
if (hrc_obj.mats.size())
return &hrc_obj.mats[0];
}
return 0;
}
// Inlined
inline size_t Scene::get_m_object_hrc_size() const {
return m_object_hrc_holder.size();
}
// 0x1401D5A70
size_t Scene::get_m_object_hrc_index(const std::string& in_name) const {
return get_index_by_name(m_object_hrc_holder, in_name);
}
// Missing
const std::string* Scene::m_object_hrc_get_name(size_t in_index) const {
if (in_index < m_object_hrc_holder.size())
return &m_object_hrc_holder[in_index].name;
return 0;
}
// 0x1401CB5C0
void Scene::camera_set_enabled(bool in_value) {
M_camera_is_enabled = in_value;
}
// 0x1401CB510
bool Scene::camera_get_enabled() const {
return M_camera_is_enabled;
}
// 0x1401CB610
void Scene::camera_set_fov_adjust(float_t in_value) {
M_fov_adjust = in_value;
}
// 0x1401CB570
float_t Scene::camera_get_fov_adjust() const {
return M_fov_adjust;
}
// 0x1401D5190
size_t Scene::get_auth_2d_size() const {
return auth_2d_list.size();
}
// 0x1401D5140
size_t Scene::get_auth_2d_index(const std::string& in_name) const {
return get_index_by_name(auth_2d_list, in_name);
}
// 0x1401CA890
const std::string* Scene::auth_2d_get_name(size_t in_index) const {
if (in_index < get_auth_2d_size())
return &auth_2d_list[in_index].name;
return 0;
}
// 0x1401D5DE0
size_t Scene::get_point_index(const std::string& in_name) const {
return get_index_by_name(point_list, in_name);
}
// 0x1401D54B0
size_t Scene::get_curve_index(const std::string& in_name) const {
return get_index_by_name(curve_list, in_name);
}
// Missing
void Scene::set_data(size_t in_value) {
M_data = in_value;
}
// Missing
size_t Scene::get_data() const {
return M_data;
}
// 0x1401E63D0
void Scene::set_debug(uint32_t in_value) {
M_debug = in_value;
}
// 0x1401D5570
uint32_t Scene::get_debug() const {
return M_debug;
}
// 0x1401CA880
void Scene::assign_rob_id(int32_t in_value) {
M_assign_rob_id = in_value;
}
// 0x1401D5090
int32_t Scene::get_assign_rob_id() const {
return M_assign_rob_id;
}
// 0x1401E6A00
void Scene::set_obj_uid(object_info in_value) {
M_obj_uid = in_value;
}
// 0x1401E6B10
void Scene::set_shadow(bool in_value) {
M_shadow = in_value;
}
// 0x1401D8B00
bool Scene::is_shadow() const {
return M_shadow;
}
// 0x1401E3B70
void Scene::replace_chara(int32_t in_cn_src, int32_t in_cn_dst) {
M_cn_src = in_cn_src;
M_cn_dst = in_cn_dst;
}
// 0x1401E64D0
void Scene::set_frame_object_hrc(float_t in_frame) {
M_is_start = true;
now_pause = true;
M_is_finished = !(in_frame < play_control.size);
M_frame = in_frame;
if (frame_max >= 0.0f && frame_max <= in_frame)
frame_max = -1.0f;
}
// 0x1401E68F0
void Scene::set_object_hrc_blend(const Scene * in_scene, float_t in_value) {
if (in_scene && object_hrc_list.size()
&& object_hrc_list.size() == in_scene->object_hrc_list.size()) {
object_hrc_blend_list = &in_scene->object_hrc_list;
object_hrc_blend = in_value;
}
else {
object_hrc_blend_list = 0;
object_hrc_blend = 0.0f;
}
}
// Inlined
inline void Scene::calc_matrix_hierarchy(const mat4& in_value) {
base_matrix = in_value;
calc_matrix_hierarchy_mul();
}
// 0x1401CB250
void Scene::calc_matrix_hierarchy_get() {
if (M_ex_node_mat)
for (HierarchyObject*& i : object_hrc_list)
i->calc_matrix_hierarchy(base_matrix);
}
// 0x1401CB2B0
void Scene::calc_matrix_hierarchy_mul() {
if (M_ex_node_mat)
for (HierarchyObject*& i : object_hrc_list)
i->calc_matrix_hierarchy(base_matrix);
}
// 0x1401D91C0
void Scene::join() {
if (!M_ex_node_mat || !object_hrc_blend_list
|| object_hrc_list.size() != object_hrc_blend_list->size())
return;
float_t blend = object_hrc_blend;
float_t inv_blend = 1.0f - object_hrc_blend;
for (size_t i = 0; i < object_hrc_list.size(); i++)
object_hrc_list[i]->join(*(*object_hrc_blend_list)[i], blend, inv_blend);
}
// 0x1401D9850
void Scene::join_lock() {
if (!M_ex_node_mat || !object_hrc_blend_list
|| object_hrc_list.size() != object_hrc_blend_list->size())
return;
float_t blend = object_hrc_blend;
float_t inv_blend = 1.0f - object_hrc_blend;
for (size_t i = 0; i < object_hrc_list.size(); i++)
object_hrc_list[i]->join_lock(*(*object_hrc_blend_list)[i], blend, inv_blend);
}
// 0x1401E64B0
void Scene::set_ex_node_mat(mat4* in_value) {
M_ex_node_mat = in_value;
}
// 0x1401D8AA0
bool Scene::is_ex_node_mat() const {
return M_ex_node_mat;
}
// 0x1401E1280
void Scene::lock_list_set() {
for (HierarchyObject*& i : object_hrc_list)
i->lock_set();
}
// Added
void Scene::set_chara_item(bool in_value) {
M_chara_item = in_value;
}
// Added
bool Scene::get_chara_item() const {
return M_chara_item;
}
// Added
void Scene::set_reflect(bool in_value) {
M_reflect = in_value;
}
// Added
bool Scene::get_reflect() const {
return M_reflect;
}
// 0x1401B27B0
Auth3dManager::Auth3dManager() {
}
// 0x1401B7DC0
Auth3dManager::~Auth3dManager() {
}
// Inlined
inline UidData* Auth3dManager::get_uid_data(int32_t in_uid, const auth_3d_database* auth_3d_db) {
if (in_uid >= auth_3d_db->uid.size())
return 0;
const auth_3d_database_uid* db_uid = &auth_3d_db->uid[in_uid];
if (db_uid && db_uid->enabled) {
UidData* uid_data = &uid_data_list[in_uid];
if (uid_data->uid == in_uid)
return uid_data;
}
return 0;
}
// Added
inline UidDataModern* Auth3dManager::get_uid_data_modern(uint32_t hash) {
auto elem = uid_data_list_modern.find(hash);
if (elem == uid_data_list_modern.end())
return 0;
UidDataModern* uid_data = &elem->second;
if (uid_data->hash == hash)
return uid_data;
return 0;
}
// 0x1401CBA80
void Auth3dManager::category_free(const char* in_name) {
if (!in_name)
return;
CategoryData* category_data = get_category_data(in_name);
if (category_data)
category_data->free();
}
// Added
void Auth3dManager::category_free(uint32_t in_hash) {
if (!in_hash || in_hash == hash_murmurhash_empty)
return;
auto elem = category_data_list_modern.find(in_hash);
if (elem != category_data_list_modern.end()) {
elem->second.free();
if (elem->second.ref_count <= 0)
category_data_list_modern.erase(elem);
}
}
// 0x1401CBDF0
bool Auth3dManager::category_load_is_done(const char* in_name) {
if (!in_name)
return true;
CategoryData* category_data = get_category_data(in_name);
if (category_data)
return category_data->load_is_done();
return true;
}
// Added
bool Auth3dManager::category_load_is_done(uint32_t in_hash) {
if (!in_hash || in_hash == hash_murmurhash_empty)
return true;
auto elem = category_data_list_modern.find(in_hash);
if (elem != category_data_list_modern.end())
return elem->second.load_is_done();
return true;
}
// 0x1401CBE30
void Auth3dManager::category_load_req(const char* in_name, const char* in_mdata_dir) {
if (!in_name)
return;
CategoryData* category_data = get_category_data(in_name);
if (category_data)
category_data->load_req(in_mdata_dir);
}
// Added
void Auth3dManager::category_load_req(void* data, const char* in_name, uint32_t in_hash) {
if (!in_hash || in_hash == hash_murmurhash_empty)
return;
auto elem = category_data_list_modern.find(in_hash);
if (elem == category_data_list_modern.end()) {
elem = category_data_list_modern.insert({ in_hash, {} }).first;
CategoryData* category_data = &elem->second;
category_data->category_name.assign(in_name);
}
CategoryData* category_data = &elem->second;
if (category_data)
category_data->load_req_modern(data);
}
// 0x1401D5B20
const mat4* Auth3dManager::get_object_matrix(int32_t in_handle, size_t in_index, bool in_is_hrc) const {
const Scene* scene = get_work_enabled(in_handle);
if (scene)
return scene->get_object_matrix(in_index, in_is_hrc);
return 0;
}
// 0x1401D5A80
const char* Auth3dManager::get_name_uid(int32_t in_uid, const auth_3d_database* auth_3d_db) const {
if (in_uid >= auth_3d_db->uid.size())
return 0;
const auth_3d_database_uid* db_uid = &auth_3d_db->uid[in_uid];
if (db_uid && db_uid->enabled)
return db_uid->name.c_str();
return 0;
}
// Added
Scene* Auth3dManager::get_scene(int32_t in_uid) {
for (int32_t& i : handle_list) {
Scene* scene = get_work(i);
if (scene && scene->M_uid == in_uid)
return scene;
}
return 0;
}
// Added
Scene* Auth3dManager::get_scene(uint32_t hash) {
for (int32_t& i : handle_list) {
Scene* scene = get_work(i);
if (scene && scene->hash == hash)
return scene;
}
return 0;
}
// 0x1401D5FA0
int32_t Auth3dManager::get_scene_object_index(object_info in_obj_uid,
int32_t* out_index, bool* out_is_hrc, int32_t in_instance) {
for (const int32_t handle : handle_list) {
Scene* scene = get_work_enabled(handle);
if (!scene)
continue;
int32_t obj_hrc_index = scene->get_object_hrc_index(in_obj_uid, in_instance);
if (obj_hrc_index >= 0) {
if (out_index)
*out_index = obj_hrc_index;
if (out_is_hrc)
*out_is_hrc = true;
return handle;
}
int32_t obj_index = scene->get_object_index(in_obj_uid, in_instance);
if (obj_index >= 0) {
if (out_index)
*out_index = obj_index;
if (out_is_hrc)
*out_is_hrc = false;
return handle;
}
}
return -1;
}
// Added
int32_t Auth3dManager::get_scene_object_index(uint32_t in_file_name_hash, uint32_t in_obj_hash,
int32_t* out_index, bool* out_is_hrc, int32_t in_instance) {
for (int32_t& i : g_manager->handle_list) {
Scene* scene = get_work_enabled(i);
if (!scene)
continue;
bool ret = false;
if (in_file_name_hash != hash_murmurhash_empty) {
if (scene->hash != in_file_name_hash)
continue;
ret = true;
}
int32_t obj_index = scene->get_object_index(in_obj_hash, in_instance);
if (obj_index >= 0) {
if (out_index)
*out_index = obj_index;
if (out_is_hrc)
*out_is_hrc = false;
return i;
}
int32_t obj_hrc_index = scene->get_object_hrc_index(in_obj_hash, in_instance);
if (obj_hrc_index >= 0) {
if (out_index)
*out_index = obj_hrc_index;
if (out_is_hrc)
*out_is_hrc = true;
return i;
}
if (ret)
return -1;
}
return -1;
}
// 0x1401E7DE0
bool Auth3dManager::uid_load_req(int32_t in_uid, const auth_3d_database* auth_3d_db) {
UidData* uid_data = get_uid_data(in_uid, auth_3d_db);
if (uid_data) {
uid_data->load_req(auth_3d_db);
return true;
}
return false;
}
// Added
bool Auth3dManager::uid_load_req_modern(uint32_t hash) {
UidDataModern* uid_data = get_uid_data_modern(hash);
if (uid_data) {
uid_data->load_req();
return true;
}
return false;
}
// Inlined
void Auth3dManager::uid_free(int32_t in_uid, const auth_3d_database* auth_3d_db) {
UidData* uid_data = get_uid_data(in_uid, auth_3d_db);
if (uid_data)
uid_data->free();
}
// Added
void Auth3dManager::uid_free_modern(uint32_t hash) {
UidDataModern* uid_data = get_uid_data_modern(hash);
if (uid_data)
uid_data->free();
}
// 0x1401D6910
bool Auth3dManager::init() {
handle_list.clear();
handle_list.shrink_to_fit();
for (int32_t i = 0; i < AUTH_3D_DATA_COUNT; i++)
scene_buffer[i].init();
return true;
}
// 0x1401CE370
bool Auth3dManager::ctrl() {
for (const int32_t handle : handle_list) {
Scene* scene = get_work(handle);
if (scene)
scene->ctrl(rctx_ptr);
}
return false;
}
// 0x1401D0310
void Auth3dManager::disp() {
for (const int32_t handle : handle_list) {
Scene* scene = get_work(handle);
if (scene)
scene->disp(rctx_ptr);
}
}
// Missing
inline const Scene* Auth3dManager::M_get_work(int32_t in_handle) const {
if (in_handle >= 0) {
size_t idx = in_handle & 0x7FFF;
if (idx < AUTH_3D_DATA_COUNT)
return &scene_buffer[idx];
}
return 0;
}
// 0x1401BF8F0
inline Scene* Auth3dManager::M_get_work(int32_t in_handle) {
if (in_handle >= 0) {
size_t idx = in_handle & 0x7FFF;
if (idx < AUTH_3D_DATA_COUNT)
return &scene_buffer[idx];
}
return 0;
}
// Missing
inline const Scene* Auth3dManager::get_work(int32_t in_handle) const {
const Scene* scene = M_get_work(in_handle);
if (scene && scene->my_handle == in_handle)
return scene;
return 0;
}
// 0x1401D64F0
inline Scene* Auth3dManager::get_work(int32_t in_handle) {
Scene* scene = M_get_work(in_handle);
if (scene && scene->my_handle == in_handle)
return scene;
return 0;
}
// Missing
inline const Scene* Auth3dManager::get_work_enabled(int32_t in_handle) const {
const Scene* scene = M_get_work(in_handle);
if (scene && scene->my_handle == in_handle && scene->M_is_enabled)
return scene;
return 0;
}
// Inlined
inline Scene* Auth3dManager::get_work_enabled(int32_t in_handle) {
Scene* scene = M_get_work(in_handle);
if (scene && scene->my_handle == in_handle && scene->M_is_enabled)
return scene;
return 0;
}
// 0x1401D6580
int32_t Auth3dManager::create(int32_t uid, const auth_3d_database* auth_3d_db) {
if (uid >= auth_3d_db->uid.size() || !auth_3d_db->uid[uid].enabled)
return -1;
int32_t index = 0;
while (scene_buffer[index].is_valid() || scene_buffer[index].hash
!= hash_murmurhash_empty && scene_buffer[index].hash != -1)
if (++index >= AUTH_3D_DATA_COUNT)
return -1;
scene_buffer[index].init();
if (++magic_number < 0)
magic_number = 1;
int32_t handle = ((magic_number & 0x7FFF) << 16) | index & 0x7FFF;
scene_buffer[index].M_uid = uid;
scene_buffer[index].my_handle = handle;
handle_list.push_back(handle);
return handle;
}
// Added
int32_t Auth3dManager::create(uint32_t hash, void* data,
const object_database* obj_db, const texture_database* tex_db) {
int32_t index = 0;
while (scene_buffer[index].is_valid() || scene_buffer[index].hash
!= hash_murmurhash_empty && scene_buffer[index].hash != -1)
if (++index >= AUTH_3D_DATA_COUNT)
return -1;
auto elem = uid_data_list_modern.find(hash);
if (elem == uid_data_list_modern.end())
elem = uid_data_list_modern.insert({ hash, {} }).first;
UidDataModern* uid_data = &elem->second;
uid_data->ref_count = 0;
uid_data->hash = hash;
uid_data->file_name.clear();
uid_data->file_name.shrink_to_fit();
uid_data->load_state = S_BEFORE_LOADING;
uid_data->name.clear();
uid_data->name.shrink_to_fit();
uid_data->category = 0;
uid_data->data = data;
uid_data->obj_db = obj_db;
uid_data->tex_db = tex_db;
scene_buffer[index].init();
if (++magic_number < 0)
magic_number = 1;
int32_t handle = ((magic_number & 0x7FFF) << 16) | index & 0x7FFF;
scene_buffer[index].hash = hash;
scene_buffer[index].my_handle = handle;
handle_list.push_back(handle);
return handle;
}
// 0x1401D6710
void Auth3dManager::destroy(int32_t in_handle, render_context* rctx) {
Scene* scene = get_work(in_handle);
if (scene && prj::find_and_erase(handle_list, in_handle))
scene->destroy(rctx);
}
// 0x1401D4FD0
int32_t Auth3dManager::get_assign_rob_id(int32_t in_handle) const {
const Scene* scene = get_work(in_handle);
if (scene)
return scene->get_assign_rob_id();
return ROB_ID_NULL;
}
// 0x1401D5290
CategoryData* Auth3dManager::get_category_data(const char* in_name) {
if (!in_name || !category_data_list.size())
return 0;
uint64_t name_hash = hash_utf8_xxh3_64bits(in_name);
for (CategoryData& i : category_data_list)
if (hash_string_xxh3_64bits(i.category_name) == name_hash)
return &i;
return 0;
}
// Added
CategoryData* Auth3dManager::get_category_data_modern(uint32_t in_hash) {
for (auto& i : g_manager->category_data_list_modern)
if (i.second.ar && i.second.ar->has_file(in_hash))
return &i.second;
return 0;
}
// 0x1401C1ED0
Handle Handle::S_init(int32_t in_handle) {
return Handle(in_handle);
}
// Missing
int32_t Handle::get() {
return m_handle;
}
// 0x1401CDC80
Handle Handle::create(int32_t uid, const auth_3d_database* auth_3d_db) {
return Handle(g_manager->create(uid, auth_3d_db));
}
// Added
Handle Handle::create(uint32_t hash, void* data,
const object_database* obj_db, const texture_database* tex_db) {
return Handle(g_manager->create(hash, data, obj_db, tex_db));
}
// 0x1401D0190
void Handle::destroy(render_context* rctx) {
g_manager->destroy(m_handle, rctx);
m_handle = -1;
}
// 0x1401D8BC0
bool Handle::is_valid() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->is_valid();
return false;
}
void Handle::set_invalid() {
// NOT IMPL!
}
// 0x1401D62D0
int32_t Handle::get_uid() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_uid();
return -1;
}
// 0x1401C9230
void Handle::add_event_listener(a3d::EventListener* in_evt_list) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->add_event_listener(in_evt_list);
}
// 0x1401E3420
void Handle::remove_event_listener(a3d::EventListener* in_evt_list) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->remove_event_listener(in_evt_list);
}
// 0x1401E0F80
void Handle::load_req(const auth_3d_database* auth_3d_db) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->load_req(auth_3d_db);
}
// Added
void Handle::load_req_modern() {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->load_req_modern();
}
// 0x1401E0680
bool Handle::load_is_done() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->load_is_done();
return true;
}
// 0x1401E6760
void Handle::set_frame_req(float_t in_frame) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_frame_req(in_frame);
}
// 0x1401E6520
void Handle::set_frame_max(float_t in_frame) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_frame_max(in_frame);
}
// 0x1401D56C0
float_t Handle::get_frame() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_frame();
return 0.0f;
}
// 0x1401D5860
float_t Handle::get_frame_size() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_frame_size();
return 0.0f;
}
// 0x1401D5760
float_t Handle::get_frame_fps() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_frame_fps();
return 60.0f;
}
// 0x1401D5710
float_t Handle::get_frame_begin() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_frame_begin();
return 0.0f;
}
// 0x1401E66C0
void Handle::set_frame_rate_control(FrameRateControl* in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_frame_rate_control(in_value);
}
// 0x1401E6A10
void Handle::set_pause(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_pause(in_value);
}
// 0x1401D5D90
bool Handle::get_pause() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_pause();
return false;
}
// 0x1401E6420
void Handle::set_enabled(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_enabled(in_value);
}
// 0x1401D5580
bool Handle::get_enabled() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_enabled();
return false;
}
// 0x1401E6950
void Handle::set_looped(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_looped(in_value);
}
// 0x1401D5990
bool Handle::get_looped() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_looped();
return false;
}
// 0x1401E65B0
void Handle::set_frame_loop_begin() {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_frame_loop_begin();
}
// 0x1401E6570
void Handle::set_frame_loop_begin(float_t in_frame) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_frame_loop_begin(in_frame);
}
// 0x1401D57C0
float_t Handle::get_frame_loop_begin() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_frame_loop_begin();
return 0.0f;
}
// 0x1401E6650
void Handle::set_frame_loop_end() {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_frame_loop_end();
}
// 0x1401E6610
void Handle::set_frame_loop_end(float_t in_frame) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_frame_loop_end(in_frame);
}
// 0x1401D5810
float_t Handle::get_frame_loop_end() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_frame_loop_end();
return 0.0f;
}
// 0x1401D8AB0
bool Handle::is_finished() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->is_finished();
return false;
}
// 0x1401E62E0
void Handle::set_auto_disable(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_auto_disable(in_value);
}
// 0x1401D51B0
bool Handle::get_auto_disable() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_auto_disable();
return false;
}
// 0x1401E6330
void Handle::set_base_matrix(const mat4& in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_base_matrix(in_value);
}
// 0x1401D5200
const mat4& Handle::get_base_matrix() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_base_matrix();
return bad_matrix;
}
// 0x1401E6A80
void Handle::set_reverse_side(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_reverse_side(in_value);
}
// 0x1401D5E60
bool Handle::get_reverse_side() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_reverse_side();
return false;
}
// 0x1401D5410
size_t Handle::get_chara_size() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_chara_size();
return 0;
}
// 0x1401D53C0
size_t Handle::get_chara_index(const std::string& in_name) const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_chara_index(in_name);
return 0;
}
// Missing
const std::string* Handle::chara_get_name(size_t in_index) const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->chara_get_name(in_index);
return 0;
}
// 0x1401CBEC0
void Handle::chara_bind_rob(size_t in_index, int32_t in_rob_id) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->chara_bind_rob(in_index, in_rob_id);
}
// 0x1401D5C10
size_t Handle::get_object_size() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_object_size();
return 0;
}
// Missing
size_t Handle::get_object_index(const std::string& in_name) const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_object_index(in_name);
return -1;
}
// 0x1401E1FC0
const std::string* Handle::object_get_name(size_t in_index) const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->object_get_name(in_index);
return 0;
}
// Missing
const mat4* Handle::get_object_matrix(size_t in_index) const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_object_matrix(in_index);
return 0;
}
// 0x1401E6B80
void Handle::set_visible(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_visible(in_value);
}
// 0x1401D64A0
bool Handle::get_visible() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_visible();
return false;
}
// 0x1401E6B20
void Handle::set_trnsl(float_t in_value, mdl::ObjFlags in_state) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_trnsl(in_value, in_state);
}
// 0x1401D60D0
float_t Handle::get_trnsl() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_trnsl();
return 1.0f;
}
// 0x1401E6290
void Handle::set_attribute_wall(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->set_attribute_wall(in_value);
}
// 01401D50A0
bool Handle::get_attribute_wall() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_attribute_wall();
return false;
}
// 0x1401E67E0
void Handle::set_item_attr(uint32_t in_id, uint32_t in_attr) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_item_attr(in_id, in_attr);
}
// 0x1401E68A0
void Handle::set_item_texchange(const std::vector<ItemTexChange>& in_list) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->set_item_texchange(in_list);
}
// 0x1401CB580
void Handle::camera_set_enabled(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->camera_set_enabled(in_value);
}
// 0x1401CB4D0
bool Handle::camera_get_enabled() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->camera_get_enabled();
return false;
}
// 0x1401CB5D0
void Handle::camera_set_fov_adjust(float_t in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->camera_set_fov_adjust(in_value);
}
// 0x1401CB520
float_t Handle::camera_get_fov_adjust() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->camera_get_fov_adjust();
return 1.0f;
}
// 0x1401D5140
size_t Handle::get_auth_2d_size() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_auth_2d_size();
return 0;
}
// 0x1401D50F0
size_t Handle::get_auth_2d_index(const std::string& in_name) const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_auth_2d_index(in_name);
return -1;
}
const std::string* Handle::auth_2d_get_name(size_t in_index) const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->auth_2d_get_name(in_index);
return 0;
}
// Missing
void Handle::set_data(size_t in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->set_data(in_value);
}
// Missing
size_t Handle::get_data() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_data();
return 0;
}
// 0x1401E6390
void Handle::set_debug(uint32_t in_debug) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->set_debug(in_debug);
}
// 0x1401D5530
uint32_t Handle::get_debug() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_debug();
return 0;
}
// 0x1401CA840
void Handle::assign_rob_id(int32_t in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->assign_rob_id(in_value);
}
// 0x1401D5050
int32_t Handle::get_assign_rob_id() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_assign_rob_id();
return ROB_ID_NULL;
}
// 0x1401E69A0
void Handle::set_obj_uid(object_info in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return set_obj_uid(in_value);
}
// 0x1401E6AD0
void Handle::set_shadow(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->set_shadow(in_value);
}
// Missing
bool Handle::is_shadow() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->is_shadow();
return false;
}
// 0x1401E34C0
void Handle::replace_chara(int32_t in_cn_src, int32_t in_cn_dst) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->replace_chara(in_cn_src, in_cn_dst);
}
// 0x1401CAD50
void Handle::set_frame_object_hrc(float_t in_frame) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->set_frame_object_hrc(in_frame);
}
// 0x1401CB0F0
void Handle::calc_matrix_hierarchy(const mat4& in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->calc_matrix_hierarchy(in_value);
}
// 0x1401D8C40
void Handle::join(int32_t in_handle, float_t in_blend) {
Scene* scene = g_manager->get_work(m_handle);
if (scene) {
Scene* other_scene = g_manager->get_work(in_handle);
if (other_scene && scene->object_hrc_list.size()
&& scene->object_hrc_list.size() == other_scene->object_hrc_list.size()) {
scene->object_hrc_blend_list = &other_scene->object_hrc_list;
scene->object_hrc_blend = in_blend;
scene->join();
}
else {
scene->object_hrc_blend_list = 0;
scene->object_hrc_blend = 0.0f;
scene->join();
}
}
}
// 0x1401D92D
void Handle::join_lock(int32_t in_handle, float_t in_blend) {
Scene* scene = g_manager->get_work(m_handle);
if (scene) {
Scene* other_scene = g_manager->get_work(in_handle);
if (other_scene && scene->object_hrc_list.size()
&& scene->object_hrc_list.size() == other_scene->object_hrc_list.size()) {
scene->object_hrc_blend_list = &other_scene->object_hrc_list;
scene->object_hrc_blend = in_blend;
scene->join_lock();
}
else {
scene->object_hrc_blend_list = 0;
scene->object_hrc_blend = 0.0f;
scene->join_lock();
}
}
}
// 0x1401E6470
void Handle::set_ex_node_mat(mat4* in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->set_ex_node_mat(in_value);
}
// Missing
bool Handle::is_ex_node_mat() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->is_ex_node_mat();
return false;
}
// 0x1401E12C0
void Handle::lock_set() {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->lock_list_set();
}
// Added
void Handle::set_chara_item(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->set_chara_item(in_value);
}
// Added
bool Handle::get_chara_item() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_chara_item();
return false;
}
// Added
void Handle::set_reflect(bool in_value) {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
scene->set_reflect(in_value);
}
// Added
bool Handle::get_reflect() const {
const Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene->get_reflect();
return false;
}
// Added
Scene* Handle::get_scene() {
Scene* scene = g_manager->get_work(m_handle);
if (scene)
return scene;
return 0;
}
// 0x1401C15B0
void Scene::M_load_exec() {
if (load_state != S_NOW_LOADING)
return;
if (hash == hash_murmurhash_empty) {
data_struct* aft_data = &data_list[DATA_AFT];
auth_3d_database* aft_auth_3d_db = &aft_data->data_ft.auth_3d_db;
object_database* aft_obj_db = &aft_data->data_ft.obj_db;
texture_database* aft_tex_db = &aft_data->data_ft.tex_db;
UidData* uid_data = g_manager->get_uid_data(M_uid, aft_auth_3d_db);
if (uid_data && uid_data->load_is_done()) {
load_state = S_DONE;
time_struct time;
M_loadFromProperties(uid_data->file, aft_obj_db, aft_tex_db);
time.calc_time();
for (a3d::EventListener*& i : my_event_listener) {
Handle handle = to_handle();
i->loadFinished(handle);
}
M_frame = 0.0f;
}
}
else {
UidDataModern* uid_data = g_manager->get_uid_data_modern(hash);
if (uid_data && uid_data->load_is_done()) {
load_state = S_DONE;
a3da_msgpack_read("patch\\AFT\\auth_3d", uid_data->file_name.c_str(), &uid_data->file.prop);
const char* l_str = uid_data->file_name.c_str();
const char* t = strrchr(l_str, '.');
size_t l_len = uid_data->file_name.size();
if (t)
l_len = t - l_str;
uid_data->name.assign(uid_data->file_name.c_str(), l_len);
uid_data->file_name.assign(uid_data->file_name);
file_name.assign(uid_data->file_name);
time_struct time;
M_loadFromProperties(uid_data->file, uid_data->obj_db, uid_data->tex_db);
time.calc_time();
hash = uid_data->hash;
for (a3d::EventListener*& i : my_event_listener) {
Handle handle = to_handle();
i->loadFinished(handle);
}
M_frame = 0.0f;
}
}
}
//Inlined
Handle Scene::to_handle() {
return Handle::S_init(my_handle);
}
// 0x1401CBAB0
void category_free(const char* in_name) {
g_manager->category_free(in_name);
}
// Added
void category_free(uint32_t in_hash) {
g_manager->category_free(in_hash);
}
// 0x1401CBE20
bool category_load_is_done(const char* in_name) {
return g_manager->category_load_is_done(in_name);
}
// Added
bool category_load_is_done(uint32_t in_hash) {
return g_manager->category_load_is_done(in_hash);
}
// 0x1401CBE60
void category_load_req(const char* in_name) {
g_manager->category_load_req(in_name, 0);
}
// 0x1401CBE30
void category_load_req(const char* in_name, const char* in_mdata_dir) {
g_manager->category_load_req(in_name, in_mdata_dir);
}
// Added
void category_load_req(void* data, const char* in_name, uint32_t in_hash) {
g_manager->category_load_req(data, in_name, in_hash);
}
// 0x1401CDCA0
Event* createEvent(const SceneFile& in_file, const a3d::Event& in_e) {
switch (in_e.type) {
case a3d::EVENT_MISC:
default:
return new Event(in_e);
case a3d::EVENT_FLT:
return createEventFilter(in_file, in_e);
case a3d::EVENT_FX:
return createEventFX(in_file, in_e);
case a3d::EVENT_SND:
return new EventSnd(in_e);
case a3d::EVENT_MOT:
return new EventMot(in_e);
case a3d::EVENT_A2D:
return new EventA2d(in_e);
}
}
// 0x1401CDE30
Event* createEventFX(const SceneFile& in_file, const a3d::Event& in_e) {
if (!in_e.param1.compare("SMOOTH"))
return new EventFXSmoothCut(in_e);
return new EventFX(in_e);
}
// 0x1401CDFF0
Event* createEventFilter(const SceneFile& in_file, const a3d::Event& in_e) {
if (!in_e.param1.compare("WHITEIN") || !in_e.param1.compare("WHITEOUT")
|| !in_e.param1.compare("FADEIN") || !in_e.param1.compare("FADEOUT"))
return new EventFilterFade(in_e);
else if (!in_e.param1.compare("TIMESTOP"))
return new EventFilterTimeStop(in_e);
return new Event(in_e);
}
// 0x1401D5BC0
const mat4* get_object_matrix(int32_t in_handle, size_t in_index, bool in_is_hrc) {
return g_manager->get_object_matrix(in_handle, in_index, in_is_hrc);
}
// 0x1401D5010
int32_t get_assign_rob_id(int32_t in_handle) {
return g_manager->get_assign_rob_id(in_handle);
}
// Added
Scene* get_scene(int32_t in_uid) {
return g_manager->get_scene(in_uid);
}
// Added
Scene* get_scene(uint32_t hash) {
return g_manager->get_scene(hash);
}
// 0x1401D6090
int32_t get_scene_object_index(object_info in_obj_uid,
int32_t* out_index, bool* out_is_hrc, int32_t in_instance) {
return g_manager->get_scene_object_index(in_obj_uid, out_index, out_is_hrc, in_instance);
}
// Added
int32_t get_scene_object_index(uint32_t in_file_name_hash, uint32_t in_obj_hash,
int32_t* out_index, bool* out_is_hrc, int32_t in_instance) {
return g_manager->get_scene_object_index(in_file_name_hash, in_obj_hash, out_index, out_is_hrc, in_instance);
}
// 0x1401E7E90
const char* get_name_uid(int32_t in_uid, const auth_3d_database* auth_3d_db) {
return g_manager->get_name_uid(in_uid, auth_3d_db);
}
}
void auth_3d_data_init() {
if (!auth_3d_detail::g_manager)
auth_3d_detail::g_manager = new auth_3d_detail::Auth3dManager;
}
// 0x140248480
void auth_3d_data_get_obj_sets_from_category(std::string& name, std::vector<uint32_t>& obj_sets,
const auth_3d_database* auth_3d_db, const object_database* obj_db) {
obj_sets.clear();
std::vector<int32_t> uids;
auth_3d_db->get_category_uids(name.c_str(), uids);
for (int32_t& i : uids) {
const char* uid_name = auth_3d_detail::get_name_uid(i, auth_3d_db);
if (!uid_name)
continue;
const char* s = strchr(uid_name, '_');
if (!s)
break;
uint32_t obj_set = obj_db->get_object_set_id(std::string(uid_name, s - uid_name).c_str());
if (obj_set != -1)
obj_sets.push_back(obj_set);
break;
}
if (!name.find("ITMPV")) {
int32_t pv_id = atoi(name.substr(5, 3).c_str());
const pv_db_pv_difficulty* diff = task_pv_db_get_pv_difficulty(
pv_id, PV_DIFFICULTY_HARD, PV_EDITION_ORIGINAL);
if (diff)
for (const pv_db_pv_item& i : diff->pv_item) {
if (i.index <= 0)
continue;
object_info info = obj_db->get_object_info(i.name.c_str());
if (info.not_null())
obj_sets.push_back(info.set_id);
}
}
if (!name.find("EFFCHRPV")) {
uint32_t obj_set = obj_db->get_object_set_id(name.c_str());
if (obj_set != -1)
obj_sets.push_back(obj_set);
}
prj::sort_and_erase_non_unique(obj_sets);
std::string stgpv;
size_t stgpv_offset = name.find("STGPV");
if (stgpv_offset != -1)
stgpv = name.substr(stgpv_offset, 8);
size_t stgd2pv_offset = name.find("STGD2PV");
if (stgd2pv_offset != -1)
stgpv = name.substr(stgd2pv_offset, 10);
if (stgpv.size()) {
uint32_t obj_set = obj_db->get_object_set_id(stgpv.c_str());
if (obj_set != -1)
obj_sets.push_back(obj_set);
}
stgpv.append("HRC");
uint32_t obj_set = obj_db->get_object_set_id(stgpv.c_str());
if (obj_set != -1)
obj_sets.push_back(obj_set);
}
void auth_3d_data_load_auth_3d_db(const auth_3d_database* auth_3d_db) {
auth_3d_detail::g_manager->category_data_list.clear();
auth_3d_detail::g_manager->category_data_list.resize(auth_3d_db->category.size());
size_t cat_index = 0;
for (auth_3d_detail::CategoryData& i : auth_3d_detail::g_manager->category_data_list)
i.category_name.assign(auth_3d_db->category[cat_index++].name);
auth_3d_detail::g_manager->uid_data_list.clear();
auth_3d_detail::g_manager->uid_data_list.resize(auth_3d_db->uid.size());
size_t uid_index = 0;
for (auth_3d_detail::UidData& i : auth_3d_detail::g_manager->uid_data_list)
i.uid = (int32_t)(uid_index++);
}
void auth_3d_data_free() {
if (auth_3d_detail::g_manager) {
delete auth_3d_detail::g_manager;
auth_3d_detail::g_manager = 0;
}
}
void task_auth_3d_init() {
if (!auth_3d_detail::task_auth_3d)
auth_3d_detail::task_auth_3d = new auth_3d_detail::TaskAuth3d;
}
bool task_auth_3d_open() {
return auth_3d_detail::task_auth_3d->open("AUTH_3D");
}
bool task_auth_3d_check_alive() {
return auth_3d_detail::task_auth_3d->check_alive();
}
bool task_auth_3d_close() {
return auth_3d_detail::task_auth_3d->close();
}
void task_auth_3d_free() {
if (auth_3d_detail::task_auth_3d) {
delete auth_3d_detail::task_auth_3d;
auth_3d_detail::task_auth_3d = 0;
}
}
namespace auth_3d_detail {
TaskAuth3d::TaskAuth3d() {
}
TaskAuth3d:: ~TaskAuth3d() {
}
bool TaskAuth3d::init() {
return g_manager->init();
}
bool TaskAuth3d::ctrl() {
return g_manager->ctrl();
}
void TaskAuth3d::disp() {
g_manager->disp();
}
FrameRateTimeStop::FrameRateTimeStop() {
}
FrameRateTimeStop::~FrameRateTimeStop() {
}
float_t FrameRateTimeStop::get_delta_frame() {
return 0.0f;
}
// 0x1401D3860
static void event_log(const char* fmt, ...) {
#ifdef DEBUG
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
#endif
}
// 0x1401D4F30
static const char* get_ID_EVENT_TYPE(EVENT_TYPE type) {
switch (type) {
case EVENT_MISC:
return "MISC";
case EVENT_FLT:
return "FLT";
case EVENT_FX:
return "FX";
case EVENT_SND:
return "SND";
case EVENT_MOT:
return "MOT";
case EVENT_A2D:
return "A2D";
default:
return "(unknown)";
}
}
template <class T>
size_t get_index_by_name(const T& in_c, const std::string& in_name) {
size_t index = 0;
for (auto i = in_c.cbegin(); i != in_c.cend(); i++, index++)
if (!i->name.compare(in_name))
return index;
return -1;
}
template <class T, class U, typename... Args>
void list_load(T& in_c, const SceneFile& in_file, const U& in_a, Args... args) {
if (in_a.size()) {
in_c.resize(in_a.size());
for (size_t i = 0; i < in_a.size(); i++)
in_c[i].load(in_file, in_a[i], args...);
}
}
template <class T, class U, typename... Args>
void list_store(const T& in_c, const SceneFile& in_file, U& out_a, Args... args) {
if (in_c.size()) {
out_a.resize(in_c.size());
for (size_t i = 0; i < in_c.size(); i++)
in_c[i].store(in_file, out_a[i], args...);
}
}
}
static bool a3da_msgpack_read_key(a3d::Fcurve& key, msgpack* msg) {
if (msg->read_bool("remove")) {
key = {};
return false;
}
if (msg->read_bool("ignore_tangents") && key.keys.size()) {
float_t ep_pre_val = key.keys.front().l_slope;
float_t ep_post_val = key.keys.back().r_slope;
for (kft3& i : key.keys) {
i.l_slope = 0.0f;
i.r_slope = 0.0f;
}
if (key.ep_type_pre == a3d::EP_TYPE_LINEAR)
key.keys.front().l_slope = ep_pre_val;
if (key.ep_type_post == a3d::EP_TYPE_LINEAR)
key.keys.back().r_slope = ep_post_val;
}
msgpack* max_frame = msg->read("max_frame");
if (max_frame)
key.max_frame = max_frame->read_float_t();
msgpack* change_type = msg->read("change_type");
if (change_type) {
a3d::FC_TYPE type = (a3d::FC_TYPE)change_type->read_int32_t();
switch (type) {
case a3d::FC_TYPE_STATIC_0:
key.keys.clear();
key.type = a3d::FC_TYPE_STATIC_0;
key.value = 0.0f;
return true;
case a3d::FC_TYPE_STATIC_DATA:
key.keys.clear();
key.type = a3d::FC_TYPE_STATIC_DATA;
key.value = msg->read_float_t("value");
return true;
case a3d::FC_TYPE_LINEAR:
case a3d::FC_TYPE_HERMITE:
case a3d::FC_TYPE_NO_INTERPOLATION:
switch (key.type) {
case a3d::FC_TYPE_LINEAR:
case a3d::FC_TYPE_HERMITE:
case a3d::FC_TYPE_NO_INTERPOLATION:
key.type = type;
break;
}
break;
}
}
msgpack* replace_keys = msg->read_array("replace_keys");
if (replace_keys) {
key.keys.clear();
msgpack_array* ptr = replace_keys->data.arr;
for (msgpack& i : *ptr) {
msgpack& _key = i;
msgpack* data = _key.read_array();
if (!data)
continue;
msgpack_array* ptr = data->data.arr;
kft3 k = {};
switch (ptr->size()) {
case 1:
k.frame = (*ptr)[0].read_float_t();
break;
case 2:
k.frame = (*ptr)[0].read_float_t();
k.value = (*ptr)[1].read_float_t();
break;
case 3: {
k.frame = (*ptr)[0].read_float_t();
k.value = (*ptr)[1].read_float_t();
float_t slope = (*ptr)[2].read_float_t();
k.l_slope = slope;
k.r_slope = slope;
} break;
case 4:
k.frame = (*ptr)[0].read_float_t();
k.value = (*ptr)[1].read_float_t();
k.l_slope = (*ptr)[2].read_float_t();
k.r_slope = (*ptr)[3].read_float_t();
break;
}
key.keys.push_back(k);
}
}
return true;
}
static bool a3da_msgpack_read_vec3(a3d::Fcurve3f& vec, msgpack* msg) {
if (msg->read_bool("remove")) {
vec = {};
return false;
}
msgpack* x = msg->read_map("x");
if (x && !a3da_msgpack_read_key(vec.x, x))
vec.x = {};
msgpack* y = msg->read_map("y");
if (y && !a3da_msgpack_read_key(vec.y, y))
vec.y = {};
msgpack* z = msg->read_map("z");
if (z && !a3da_msgpack_read_key(vec.z, z))
vec.z = {};
return true;
}
static bool a3da_msgpack_read_rgba(a3d::FcurveColor4f& col4, msgpack* msg) {
if (msg->read_bool("remove")) {
col4 = {};
return false;
}
msgpack* rgb = msg->read_map("rgb");
if (rgb) {
a3d::Fcurve rgb_key = col4.r;
if (a3da_msgpack_read_key(rgb_key, rgb)) {
col4.r = rgb_key;
col4.g = rgb_key;
col4.b = rgb_key;
col4.has_r = true;
col4.has_g = true;
col4.has_b = true;
}
else {
col4.r = {};
col4.g = {};
col4.b = {};
col4.has_r = false;
col4.has_g = false;
col4.has_b = false;
}
}
msgpack* r = msg->read_map("r");
if (r) {
col4.has_r = true;
if (!a3da_msgpack_read_key(col4.r, r)) {
col4.r = {};
col4.has_r = false;
}
}
msgpack* g = msg->read_map("g");
if (g) {
col4.has_g = true;
if (!a3da_msgpack_read_key(col4.g, g)) {
col4.g = {};
col4.has_g = false;
}
}
msgpack* b = msg->read_map("b");
if (b) {
col4.has_b = true;
if (!a3da_msgpack_read_key(col4.b, b)) {
col4.b = {};
col4.has_b = false;
}
}
msgpack* a = msg->read_map("a");
if (a) {
col4.has_a = true;
if (!a3da_msgpack_read_key(col4.a, a)) {
col4.a = {};
col4.has_a = false;
}
}
return true;
}
static bool a3da_msgpack_read_model_transform(a3d::ModelTransform& mt, msgpack* msg) {
if (msg->read_bool("remove")) {
mt = {};
mt.scale.x.type = a3d::FC_TYPE_STATIC_DATA;
mt.scale.x.value = 1.0f;
mt.scale.y.type = a3d::FC_TYPE_STATIC_DATA;
mt.scale.y.value = 1.0f;
mt.scale.z.type = a3d::FC_TYPE_STATIC_DATA;
mt.scale.z.value = 1.0f;
mt.visibility.type = a3d::FC_TYPE_STATIC_DATA;
mt.visibility.value = 1.0f;
return false;
}
msgpack* trans = msg->read_map("trans");
if (trans && !a3da_msgpack_read_vec3(mt.translation, trans))
mt.translation = {};
msgpack* rot = msg->read_map("rot");
if (rot && !a3da_msgpack_read_vec3(mt.rotation, rot))
mt.rotation = {};
msgpack* scale = msg->read_map("scale");
if (scale && !a3da_msgpack_read_vec3(mt.scale, scale)) {
mt.scale = {};
mt.scale.x.type = a3d::FC_TYPE_STATIC_DATA;
mt.scale.x.value = 1.0f;
mt.scale.y.type = a3d::FC_TYPE_STATIC_DATA;
mt.scale.y.value = 1.0f;
mt.scale.z.type = a3d::FC_TYPE_STATIC_DATA;
mt.scale.z.value = 1.0f;
}
msgpack* visibility = msg->read_map("visibility");
if (visibility && !a3da_msgpack_read_key(mt.visibility, visibility)) {
mt.visibility = {};
mt.visibility.type = a3d::FC_TYPE_STATIC_DATA;
mt.visibility.value = 1.0f;
}
return true;
}
static void a3da_msgpack_read(const char* path, const char* file, a3d::Scene* auth_file) {
if (!path_check_directory_exists(path))
return;
char file_buf[0x80];
for (const char* i = file; *i && *i != '.'; i++) {
char c = *i;
file_buf[i - file] = c;
file_buf[i - file + 1] = 0;
}
char buf[0x200];
sprintf_s(buf, sizeof(buf), "%s\\%s.json", path, file_buf);
if (!path_check_file_exists(buf))
return;
msgpack msg;
file_stream s;
s.open(buf, "rb");
io_json_read(s, &msg);
s.close();
if (msg.type != MSGPACK_MAP) {
printf("Failed to load Auth 3D JSON!\nPath: %s\n", buf);
return;
}
msgpack* curves = msg.read_array("curve");
if (curves) {
msgpack_array* ptr = curves->data.arr;
for (msgpack& i : *ptr) {
msgpack& curve = i;
std::string name = curve.read_string("name");
uint32_t name_hash = hash_string_murmurhash(name);
for (a3d::Curve& j : auth_file->curve) {
if (name_hash != hash_string_murmurhash(j.name))
continue;
msgpack* cv = curve.read_map("cv");
if (cv)
a3da_msgpack_read_key(j.fcurve, cv);
break;
}
}
}
msgpack* m_objhrcs = msg.read_array("m_objhrc");
if (m_objhrcs) {
msgpack_array* ptr = m_objhrcs->data.arr;
for (msgpack& i : *ptr) {
msgpack& m_objhrc = i;
std::string name = m_objhrc.read_string("name");
uint32_t name_hash = hash_string_murmurhash(name);
for (a3d::MObjectHrc& j : auth_file->m_object_hrc) {
if (name_hash != hash_string_murmurhash(j.name))
continue;
msgpack* instances = m_objhrc.read_array("instance");
if (instances) {
msgpack_array* ptr = instances->data.arr;
for (msgpack& k : *ptr) {
msgpack& instance = k;
int32_t index = instance.read_int32_t("index");
if (index < j.instance.size())
j.instance[index].shadow = instance.read_bool("shadow");
}
}
break;
}
}
}
// X/XHD
msgpack* material_lists = msg.read_array("material_list");
if (material_lists) {
msgpack_array* ptr = material_lists->data.arr;
for (msgpack& i : *ptr) {
msgpack& material_list = i;
std::string name = material_list.read_string("name");
uint32_t name_hash = hash_string_murmurhash(name);
auto j_begin = auth_file->material_list.begin();
auto j_end = auth_file->material_list.end();
for (auto j = j_begin; j != j_end; j++) {
if (name_hash != hash_string_murmurhash(j->name))
continue;
bool remove = material_list.read_bool("remove");
if (remove) {
auth_file->material_list.erase(j);
break;
}
msgpack* new_name = material_list.read("new_name");
if (new_name)
j->name.assign(new_name->read_string());
msgpack* blend_color = material_list.read_map("blend_color");
if (blend_color) {
j->flag |= a3d::MaterialList::FLAG_BLEND_COLOR;
if (!a3da_msgpack_read_rgba(j->blend_color, blend_color))
j->flag &= ~a3d::MaterialList::FLAG_BLEND_COLOR;
}
msgpack* emission = material_list.read_map("emission");
if (emission) {
j->flag |= a3d::MaterialList::FLAG_EMISSION;
if (!a3da_msgpack_read_rgba(j->emission, emission))
j->flag &= ~a3d::MaterialList::FLAG_EMISSION;
}
if (!j->flag)
auth_file->material_list.erase(j);
break;
}
}
}
std::vector<std::string> remove_parent_name;
std::vector<std::string> remove_parent_node;
msgpack* objhrcs = msg.read_array("objhrc");
if (objhrcs) {
msgpack_array* ptr = objhrcs->data.arr;
for (msgpack& i : *ptr) {
msgpack& objhrc = i;
std::string name = objhrc.read_string("name");
uint32_t name_hash = hash_string_murmurhash(name);
auto j_begin = auth_file->object_hrc.begin();
auto j_end = auth_file->object_hrc.end();
for (auto j = j_begin; j != j_end; j++) {
if (name_hash != hash_string_murmurhash(j->name))
continue;
bool remove = objhrc.read_bool("remove");
if (remove) {
auto k_begin = auth_file->object_hrc_list.begin();
auto k_end = auth_file->object_hrc_list.end();
for (auto k = k_begin; k != k_end; k++)
if (name_hash == hash_string_murmurhash(*k)) {
auth_file->object_hrc_list.erase(k);
break;
}
remove_parent_name.push_back(j->name);
for (a3d::ObjectNode& k : j->node)
remove_parent_node.push_back(k.name);
auth_file->object_hrc.erase(j);
break;
}
j->shadow = objhrc.read_bool("shadow");
break;
}
}
}
msgpack* objects = msg.read_array("object");
if (objects) {
msgpack_array* ptr = objects->data.arr;
for (msgpack& i : *ptr) {
msgpack& object = i;
std::string name = object.read_string("name");
uint32_t name_hash = hash_string_murmurhash(name);
auto j_begin = auth_file->object.begin();
auto j_end = auth_file->object.end();
for (auto j = j_begin; j != j_end; j++) {
if (name_hash != hash_string_murmurhash(j->name))
continue;
bool remove = object.read_bool("remove");
if (remove) {
auto k_begin = auth_file->object_list.begin();
auto k_end = auth_file->object_list.end();
for (auto k = k_begin; k != k_end; k++)
if (name_hash == hash_string_murmurhash(*k)) {
auth_file->object_list.erase(k);
break;
}
remove_parent_name.push_back(j->name);
auth_file->object.erase(j);
break;
}
bool remove_morph = object.read_bool("remove_morph");
if (remove_morph) {
j->morph.assign("");
j->morph_offset = 0.0f;
}
a3da_msgpack_read_model_transform(j->model_transform, &object);
break;
}
}
}
msgpack* play_control = msg.read_map("play_control");
if (play_control) {
msgpack* begin = play_control->read("begin");
if (begin)
auth_file->play_control.begin = begin->read_float_t();
msgpack* fps = play_control->read("fps");
if (fps)
auth_file->play_control.begin = fps->read_float_t();
msgpack* size = play_control->read("size");
if (size)
auth_file->play_control.size = size->read_float_t();
}
while (remove_parent_name.size() || remove_parent_node.size()) {
size_t remove_parent_name_size = remove_parent_name.size();
for (size_t i = remove_parent_name_size, i1 = 0; i; i--, i1++) {
uint32_t remove_parent_name_hash = hash_string_murmurhash(remove_parent_name[i1]);
auto j_begin = auth_file->object.begin();
auto j_end = auth_file->object.end();
for (auto j = j_begin; j != j_end; j++)
if (remove_parent_name_hash == hash_string_murmurhash(j->parent_name)) {
remove_parent_name.push_back(j->name);
auth_file->object.erase(j);
break;
}
auto k_begin = auth_file->object_hrc.begin();
auto k_end = auth_file->object_hrc.end();
for (auto k = k_begin; k != k_end; k++)
if (remove_parent_name_hash == hash_string_murmurhash(k->parent_name)) {
remove_parent_name.push_back(k->name);
for (a3d::ObjectNode& l : k->node)
remove_parent_node.push_back(l.name);
auth_file->object_hrc.erase(k);
break;
}
}
remove_parent_name.erase(remove_parent_name.begin(),
remove_parent_name.begin() + remove_parent_name_size);
size_t remove_parent_node_size = remove_parent_node.size();
for (size_t i = remove_parent_node_size, i1 = 0; i; i--, i1++) {
uint32_t remove_parent_node_hash = hash_string_murmurhash(remove_parent_node[i1]);
auto j_begin = auth_file->object.begin();
auto j_end = auth_file->object.end();
for (auto j = j_begin; j != j_end; j++)
if (remove_parent_node_hash == hash_string_murmurhash(j->parent_node)) {
remove_parent_node.push_back(j->name);
auth_file->object.erase(j);
break;
}
auto k_begin = auth_file->object_hrc.begin();
auto k_end = auth_file->object_hrc.end();
for (auto k = k_begin; k != k_end; k++)
if (remove_parent_node_hash == hash_string_murmurhash(k->parent_node)) {
remove_parent_node.push_back(k->name);
for (a3d::ObjectNode& l : k->node)
remove_parent_node.push_back(l.name);
auth_file->object_hrc.erase(k);
break;
}
}
remove_parent_node.erase(remove_parent_node.begin(),
remove_parent_node.begin() + remove_parent_node_size);
};
}
static void auth_3d_set_material_list(auth_3d_detail::Scene& in_scene, render_context* rctx) {
mdl::DispManager& disp_manager = *rctx->disp_manager;
int32_t mat_list_count = 0;
material_list_struct mat_list[MATERIAL_LIST_COUNT];
for (auth_3d_detail::MaterialList& i : in_scene.material_list) {
if (!(i.blend_color.has_color[0] || i.blend_color.has_color[1]
|| i.blend_color.has_color[2] || i.blend_color.has_color[3])
&& !(i.emission.has_color[0] || i.emission.has_color[1]
|| i.emission.has_color[2] || i.emission.has_color[3]))
continue;
vec4& blend_color = mat_list[mat_list_count].blend_color;
bool* has_blend_color = mat_list[mat_list_count].has_blend_color;
if (i.blend_color.has_color[0] || i.blend_color.has_color[1]
|| i.blend_color.has_color[2] || i.blend_color.has_color[3]) {
blend_color = i.blend_color.color;
has_blend_color[0] = i.blend_color.has_color[0];
has_blend_color[1] = i.blend_color.has_color[1];
has_blend_color[2] = i.blend_color.has_color[2];
has_blend_color[3] = i.blend_color.has_color[3];
}
else {
blend_color = 0.0f;
has_blend_color[0] = false;
has_blend_color[1] = false;
has_blend_color[2] = false;
has_blend_color[3] = false;
}
vec4& emission = mat_list[mat_list_count].emission;
bool* has_emission = mat_list[mat_list_count].has_emission;
if (i.emission.has_color[0] || i.emission.has_color[1]
|| i.emission.has_color[2] || i.emission.has_color[3]) {
emission = i.emission.color;
has_emission[0] = i.emission.has_color[0];
has_emission[1] = i.emission.has_color[1];
has_emission[2] = i.emission.has_color[2];
has_emission[3] = i.emission.has_color[3];
}
else {
emission = 0.0f;
has_emission[0] = false;
has_emission[1] = false;
has_emission[2] = false;
has_emission[3] = false;
}
mat_list[mat_list_count].hash = i.hash;
mat_list_count++;
}
disp_manager.set_material_list(mat_list_count, mat_list);
}
Reference in New Issue View Git Blame Copy Permalink