Temp commit. Song Effect Attach Fixes

src/CLOUD/classes/data_test/auth_3d_test.c

@@ -237,34 +237,31 @@ void data_test_auth_3d_test_ctrl(class_data* data) {
                 }
             }
 
-            string obj = string_empty;
+            std::string obj;
             for (size_t i = 0; i < name_len && name_len - i >= 8; i++)
                 if (!memcmp(&name_str[i], "STGPV", 5)) {
-                    string_free(&obj);
-                    string_init_length(&obj, &name_str[i], 8);
+                    obj = std::string(&name_str[i], 8);
                     break;
                 }
 
             for (size_t i = 0; i < name_len && name_len - i >= 10; i++)
                 if (!memcmp(&name_str[i], "STGD2PV", 7)) {
-                    string_free(&obj);
-                    string_init_length(&obj, &name_str[i], 10);
+                    obj = std::string(&name_str[i], 10);
                     break;
                 }
 
-            uint32_t set_id = obj_db->get_object_set_id(string_data(&obj));
+            uint32_t set_id = obj_db->get_object_set_id(obj.c_str());
             if (set_id != (uint32_t)-1) {
                 object_storage_load_set(aft_data, obj_db, set_id);
                 vector_old_uint32_t_push_back(&auth_3d_test->obj_set_id, &set_id);
             }
 
-            string_add_length(&obj, "HRC", 3);
-            uint32_t hrc_set_id = obj_db->get_object_set_id(string_data(&obj));
+            obj += "HRC";
+            uint32_t hrc_set_id = obj_db->get_object_set_id(obj.c_str());
             if (hrc_set_id != (uint32_t)-1) {
                 object_storage_load_set(aft_data, obj_db, hrc_set_id);
                 vector_old_uint32_t_push_back(&auth_3d_test->obj_set_id, &hrc_set_id);
             }
-            string_free(&obj);
         }
 
         auth_3d_data_load_category(cat->name);

src/CLOUD/classes/data_view/auth_3d.c

@@ -918,7 +918,7 @@ static void data_view_auth_3d_imgui_auth_3d_object_texture_transform(auth_3d_obj
     if (ott->flags & AUTH_3D_OBJECT_TEXTURE_TRANSFORM_TRANSLATE_FRAME_U)
         data_view_auth_3d_imgui_auth_3d_key(&ott->translate_frame_u, "Translate Frame U:", false);
     if (ott->flags & AUTH_3D_OBJECT_TEXTURE_TRANSFORM_TRANSLATE_FRAME_V)
-        data_view_auth_3d_imgui_auth_3d_key(&ott->translate_frame_v, "Translate Frame V:", false);;
+        data_view_auth_3d_imgui_auth_3d_key(&ott->translate_frame_v, "Translate Frame V:", false);
     ImGui::TreePop();
 }
 

src/CLOUD/classes/data_view/draw_task.c

@@ -6,6 +6,7 @@
 #include "draw_task.h"
 #include "../../../CRE/render_context.hpp"
 #include "../../../KKdLib/hash.hpp"
+#include "../../../KKdLib/sort.hpp"
 #include "../imgui_helper.h"
 
 static const char* draw_object_type_name[] = {
@@ -63,6 +64,7 @@ extern int32_t height;
 
 const char* data_view_draw_task_window_title = "Draw Task##Data Viewer";
 
+static int draw_task_sort_sort(void const* src1, void const* src2);
 static void data_view_draw_task_imgui_draw_object(draw_object* object);
 
 bool data_view_draw_task_init(class_data* data, render_context* rctx) {
@@ -134,18 +136,13 @@ void data_view_draw_task_imgui(class_data* data) {
         for (draw_task*& j : draw_tasks) {
             draw_task_sort draw_task;
             draw_task.first = j;
-            draw_task.second.first = hash_murmurhash((void*)j, 8, 0, true);
+            draw_task.second.first = hash_murmurhash(&j, 8, 0, true);
             draw_task.second.second = (uint32_t)(&j - draw_tasks.data());
             draw_tasks_sort.push_back(draw_task);
         }
 
-        for (auto i = draw_tasks_sort.begin(); i != draw_tasks_sort.end() - 1; i++)
-            for (auto j = i + 1; j != draw_tasks_sort.end(); j++)
-                if (*i > *j) {
-                    draw_task_sort temp = *i;
-                    *i = *j;
-                    *j = temp;
-                }
+        quicksort_custom(draw_tasks_sort.data(), draw_tasks_sort.size(),
+            sizeof(draw_task_sort), draw_task_sort_sort);
 
         ImGui::Text("       Hash;    Index; Type");
 
@@ -229,7 +226,13 @@ data_view_draw_task::~data_view_draw_task() {
 
 }
 
+static int draw_task_sort_sort(void const* src1, void const* src2) {
+    float_t d1 = ((draw_task_sort*)src1)->first->depth;
+    float_t d2 = ((draw_task_sort*)src2)->first->depth;
+    return d1 > d2 ? -1 : (d1 < d2 ? 1 : 0);
+}
+
 static void data_view_draw_task_imgui_draw_object(draw_object* object) {
     ImGui::Text("Mesh Name: %s", object->mesh->name);
-    ImGui::Text("Sub Mesh Index: %lld", object->sub_mesh - object->mesh->sub_meshes);
+    ImGui::Text("Sub Mesh Index: %lld", object->sub_mesh - object->mesh->submesh_array);
 }

src/CLOUD/classes/glitter_editor.c

@@ -4046,9 +4046,9 @@ static void glitter_editor_property_particle(glitter_editor_struct* glt_edt, cla
         obj* obj = 0;
         if (handler && handler->obj_set) {
             obj_set* set = handler->obj_set;
-            for (uint32_t i = 0; i < set->objects_count; i++)
-                if (set->objects[i].id == obj_id) {
-                    obj = &set->objects[i];
+            for (uint32_t i = 0; i < set->obj_num; i++)
+                if (set->obj_data[i].id == obj_id) {
+                    obj = &set->obj_data[i];
                     break;
                 }
         }
@@ -4058,8 +4058,8 @@ static void glitter_editor_property_particle(glitter_editor_struct* glt_edt, cla
             if (set_id != -1 && handler && handler->set_id == set_id && handler->obj_set) {
                 obj_set* set = handler->obj_set;
                 ssize_t obj_index = -1;
-                for (uint32_t i = 0; i < set->objects_count; i++)
-                    if (set->objects[i].id == obj_id) {
+                for (uint32_t i = 0; i < set->obj_num; i++)
+                    if (set->obj_data[i].id == obj_id) {
                         obj_index = i;
                         break;
                     }
@@ -4071,9 +4071,9 @@ static void glitter_editor_property_particle(glitter_editor_struct* glt_edt, cla
                     obj_index = -1;
                 ImGui::PopID();
 
-                for (uint32_t i = 0; i < set->objects_count; i++) {
+                for (uint32_t i = 0; i < set->obj_num; i++) {
                     ImGui::PushID(i);
-                    ::obj* obj = &set->objects[i];
+                    ::obj* obj = &set->obj_data[i];
                     if (ImGui::Selectable(string_data(&obj->name), obj->id == obj_id)
                         || imguiItemKeyPressed(GLFW_KEY_ENTER, true)
                         || (ImGui::IsItemFocused() && obj->id != obj_id))
@@ -4081,10 +4081,10 @@ static void glitter_editor_property_particle(glitter_editor_struct* glt_edt, cla
                     ImGui::PopID();
                 }
 
-                if (obj_index == -1 || obj_index >= set->objects_count)
+                if (obj_index == -1 || obj_index >= set->obj_num)
                     obj_id = -1;
                 else
-                    obj_id = set->objects[obj_index].id;
+                    obj_id = set->obj_data[obj_index].id;
 
                 if (mesh->object_name_hash != obj_id) {
                     mesh->object_name_hash = obj_id;
@@ -6869,24 +6869,23 @@ static void glitter_editor_gl_draw_wireframe_draw_mesh(glitter_editor_struct* gl
 
             int32_t ttc = 0;
             texture_transform_struct* tt = object_data->texture_transform_array;
-            for (uint32_t i = 0; i < obj->meshes_count; i++) {
-                obj_mesh* mesh = &obj->meshes[i];
+            for (uint32_t i = 0; i < obj->num_mesh; i++) {
+                obj_mesh* mesh = &obj->mesh_array[i];
 
                 if (object_data->object_culling && !object_bounding_sphere_check_visibility(
                     &mesh->bounding_sphere, object_data, rctx->camera, &mat))
                     continue;
 
-                for (uint32_t j = 0; j < mesh->sub_meshes_count; j++) {
-                    obj_sub_mesh* sub_mesh = &mesh->sub_meshes[j];
+                for (uint32_t j = 0; j < mesh->num_submesh; j++) {
+                    obj_sub_mesh* sub_mesh = &mesh->submesh_array[j];
 
-                    if (sub_mesh->flags & OBJ_SUB_MESH_FLAG_8)
+                    if (sub_mesh->attrib.m.flag_3)
                         continue;
 
                     if (object_data->object_culling) {
                         int32_t v32 = object_bounding_sphere_check_visibility(
                             &sub_mesh->bounding_sphere, object_data, rctx->camera, &mat);
-                        if (v32 != 2 || (~mesh->flags & OBJ_MESH_BILLBOARD &&
-                            ~mesh->flags & OBJ_MESH_BILLBOARD_Y_AXIS)) {
+                        if (v32 != 2 || (!mesh->attrib.m.billboard && !mesh->attrib.m.billboard_y_axis)) {
                             if (v32 == 2) {
                                 if (object_data->object_bounding_sphere_check_func)
                                     v32 = 1;
@@ -6922,7 +6921,7 @@ static void glitter_editor_gl_draw_wireframe_draw_mesh(glitter_editor_struct* gl
                     GLuint array_buffer = obj_mesh_vertex_buffer_get_buffer(&obj_vertex_buffer[i]);
                     gl_state_bind_array_buffer(array_buffer);
                     glEnableVertexAttribArray(0);
-                    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, mesh->vertex_size, (void*)0);
+                    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, mesh->size_vertex, (void*)0);
                     gl_state_bind_array_buffer(0);
 
                     GLuint element_array_buffer = obj_index_buffer[i].buffer;

src/CLOUD/render.c

@@ -744,12 +744,12 @@ static render_context* render_load() {
     charas[0] = CHARA_MEIKO;
 
     int32_t modules[6];
-    modules[5] = 186;
-    modules[1] = 46;
-    modules[2] = 39;
+    modules[5] = 168;
+    modules[1] = 0;//46;
+    modules[2] = 0;//39;
     modules[3] = 41;
     modules[4] = 40;
-    modules[0] = 31;
+    modules[0] = 0;//31;
     x_pv_game_data.Load(822, 22, charas, modules);
 
     shader_env_vert_set_ptr(&shaders_ft, 3, (vec4*)&vec4_identity);
@@ -831,7 +831,6 @@ static void render_ctrl(render_context* rctx) {
             camera_roll(cam, input_roll);
         }
     }
-    camera_update(cam);
 
     classes_process_ctrl(classes, classes_count);
 
@@ -903,7 +902,6 @@ static void cube_line_draw(shader_glsl* shader, camera* cam, vec3* trans, float_
 }
 
 static int cube_line_points_sort(void const* src1, void const* src2) {
-    std::pair<vec3, float_t>* t2 = (std::pair<vec3, float_t>*)src2;
     float_t d1 = ((std::pair<vec3, float_t>*)src1)->second;
     float_t d2 = ((std::pair<vec3, float_t>*)src2)->second;
     return d1 > d2 ? -1 : (d1 < d2 ? 1 : 0);
@@ -951,6 +949,8 @@ static void render_draw(render_context* rctx) {
         glClearBufferfv(GL_COLOR, 0, (GLfloat*)&color);
     }
 
+    camera_update(cam);
+
     rctx->disp();
 
     int32_t screen_x_offset = (width - internal_2d_res.x) / 2 + (width - internal_2d_res.x) % 2;
@@ -1070,8 +1070,10 @@ static void render_dispose(render_context* rctx) {
     ImGui::DestroyContext(imgui_context);
     lock_free(&imgui_context_lock);
 
+    task_rob_manager_free_task();
     x_pv_game_data.SetDest();
     Glitter::glt_particle_manager.SetDest();
+    task_auth_3d_free_task();
 
     //rob_chara_array_free_chara_id(0);
     timer_reset(&render_timer);
@@ -1127,15 +1129,12 @@ static void render_imgui(render_context* rctx) {
 }
 
 static bool render_load_shaders(void* data, const char* path, const char* file, uint32_t hash) {
-    string s;
-    string_init(&s, path);
-    string_add(&s, file);
+    std::string s = path + std::string(file);
 
     farc f;
-    f.read(string_data(&s), true, false);
+    f.read(s.c_str(), true, false);
     shader_ft_load((shader_set_data*)data, &f, false);
 
-    string_free(&s);
     return true;
 }
 

src/CLOUD/x_pv_game.cpp

@@ -10,6 +10,7 @@
 #include "x_pv_game.hpp"
 #include "../CRE/Glitter/glitter.hpp"
 #include "../CRE/light_param/light.h"
+#include "../CRE/light_param.hpp"
 #include "../CRE/data.hpp"
 #include "../CRE/object.hpp"
 #include "../CRE/stage_modern.hpp"
@@ -193,8 +194,10 @@ static int32_t expression_id_to_mottbl_index(int32_t expression_id);
 static int32_t hand_anim_id_to_mottbl_index(int32_t hand_anim_id);
 static int32_t look_anim_id_to_mottbl_index(int32_t look_anim_id);
 static int32_t mouth_anim_id_to_mottbl_index(int32_t mouth_anim_id);
+static void x_pv_game_change_field(x_pv_game* xpvgm, int32_t field, int64_t dsc_time, int64_t curr_time);
 static bool x_pv_game_dsc_process(x_pv_game* xpvgm, int64_t curr_time);
 static void x_pv_game_map_auth_3d_to_mot(x_pv_game* xpvgm);
+static void x_pv_game_reset_field(x_pv_game* xpvgm);
 static void x_pv_game_stage_effect_ctrl(x_pv_game* xpvgm);
 static void x_pv_game_stage_effect_start(x_pv_game* xpvgm, pvsr_stage_effect* stage_effect);
 static void x_pv_game_stage_effect_stop(x_pv_game* xpvgm,
@@ -275,9 +278,10 @@ bool x_pv_game::Init() {
 }
 
 bool x_pv_game::Ctrl() {
-    if (state == 0)
+    switch (state) {
+    case 0:
         return false;
-    else if (state == 1) {
+    case 1: {
         bool wait_load = false;
         for (int32_t i = 0; i < ROB_CHARA_COUNT; i++)
             if (rob_chara_ids[i] != -1)
@@ -285,80 +289,11 @@ bool x_pv_game::Ctrl() {
 
         if (!wait_load)
             state = 2;
-    }
-    else if (state == 2) {
-        bool pv_glt = pv_glitter->hash != hash_murmurhash_empty;
-        bool stg_glt = stage_glitter->hash != hash_murmurhash_empty;
-        if ((!pv_glt || Glitter::glt_particle_manager.CheckNoFileReaders(pv_glitter->hash))
-            && (!stg_glt || Glitter::glt_particle_manager.CheckNoFileReaders(stage_glitter->hash))) {
-            data_struct* x_data = &data_list[DATA_X];
-
-            bool wait_load = false;
-            if (pv_glt) {
-                Glitter::EffectGroup* pv_eff_group
-                    = Glitter::glt_particle_manager.GetEffectGroup(pv_glitter->hash);
-                if (pv_eff_group && pv_eff_group->CheckModel()) {
-                    pv_eff_group->LoadModel(x_data);
-                    wait_load = true;
-                }
-            }
-
-            if (stg_glt) {
-                Glitter::EffectGroup* stage_eff_group
-                    = Glitter::glt_particle_manager.GetEffectGroup(stage_glitter->hash);
-                if (stage_eff_group && stage_eff_group->CheckModel()) {
-                    stage_eff_group->LoadModel(x_data);
-                    wait_load = true;
-                }
-            }
-
-            state = wait_load ? 3 : 4;
-        }
-    }
-    else if (state == 3) {
-        bool wait_load = false;
-        Glitter::EffectGroup* pv_eff_group
-            = Glitter::glt_particle_manager.GetEffectGroup(pv_glitter->hash);
-        if (pv_eff_group && pv_eff_group->CheckLoadModel())
-            wait_load = true;
-
-        Glitter::EffectGroup* stage_eff_group
-            = Glitter::glt_particle_manager.GetEffectGroup(stage_glitter->hash);
-        if (stage_eff_group && stage_eff_group->CheckLoadModel())
-            wait_load = true;
-
-        if (!wait_load)
-            state = 4;
-    }
-    else if (state == 4) {
-        for (uint32_t& i : objset_load)
-            if (object_storage_get_obj_set_handler(i)
-                && object_storage_load_obj_set_check_not_read(i, &obj_db, &tex_db))
-                return false;
-
-        state = 8;
-    }
-    else if (state == 8) {
-        for (uint32_t& i : objset_load) {
-            obj_set* set = object_storage_get_obj_set(i);
-            if (!set)
-                continue;
-
-            for (uint32_t i = 0; i < set->objects_count; i++) {
-                obj* obj = &set->objects[i];
-                for (uint32_t j = 0; j < obj->materials_count; j++) {
-                    obj_material* material = &obj->materials[j].material;
-                    vec3 spec = { 0.5f, 0.5f, 0.5f };
-                    if (!memcmp(&material->specular, &spec, sizeof(vec3)))
-                        *(vec3*)&material->specular = vec3_null;
-                    else if (memcmp(&material->specular, &vec3_null, sizeof(vec3)))
-                        *(vec3*)&material->specular = { 0.1f, 0.1f, 0.1f };
-                }
-            }
-        }
-
+    } break;
+    case 2: {
         data_struct* x_data = &data_list[DATA_X];
 
+        light_param_storage_data_set_pv_id(pv_id);
         task_stage_modern_set_data(x_data, &obj_db, &tex_db, &stage_data);
         task_stage_modern_set_stage_hashes(&stage_hashes, &stages_data);
 
@@ -371,18 +306,76 @@ bool x_pv_game::Ctrl() {
             if (i.chara_effect_init)
                 for (pvpp_chara_effect_a3da& j : i.chara_effect.effect_a3da)
                     auth_3d_data_load_category(x_data, camera_category.c_str(), camera_category_hash);
-        state = 9;
-    }
-    else if (state == 9) {
+
+        bool pv_glt = pv_glitter->hash != hash_murmurhash_empty;
+        bool stg_glt = stage_glitter->hash != hash_murmurhash_empty;
+        if (pv_glt && Glitter::glt_particle_manager.CheckNoFileReaders(pv_glitter->hash)
+            || stg_glt && Glitter::glt_particle_manager.CheckNoFileReaders(stage_glitter->hash)) {
+            if (pv_glt) {
+                Glitter::EffectGroup* pv_eff_group
+                    = Glitter::glt_particle_manager.GetEffectGroup(pv_glitter->hash);
+                if (pv_eff_group && pv_eff_group->CheckModel())
+                    pv_eff_group->LoadModel(x_data);
+            }
+
+            if (stg_glt) {
+                Glitter::EffectGroup* stage_eff_group
+                    = Glitter::glt_particle_manager.GetEffectGroup(stage_glitter->hash);
+                if (stage_eff_group && stage_eff_group->CheckModel())
+                    stage_eff_group->LoadModel(x_data);
+            }
+        }
+        state = 3;
+    } break;
+    case 3: {
+        bool wait_load = task_stage_modern_check_not_loaded();
+
+        for (uint32_t& i : objset_load)
+            if (object_storage_get_obj_set_handler(i)
+                && object_storage_load_obj_set_check_not_read(i, &obj_db, &tex_db))
+                wait_load = true;
+
         for (std::pair<std::string, uint32_t>& i : category_load)
             if (!auth_3d_data_check_category_loaded(i.second))
-                return false;
+                wait_load = true;
 
         if (!auth_3d_data_check_category_loaded(light_category.c_str()))
-            return false;
+            wait_load = true;
 
+        Glitter::EffectGroup* pv_eff_group
+            = Glitter::glt_particle_manager.GetEffectGroup(pv_glitter->hash);
+        if (pv_eff_group && pv_eff_group->CheckLoadModel())
+            wait_load = true;
+
+        Glitter::EffectGroup* stage_eff_group
+            = Glitter::glt_particle_manager.GetEffectGroup(stage_glitter->hash);
+        if (stage_eff_group && stage_eff_group->CheckLoadModel())
+            wait_load = true;
+
+        if (!wait_load)
+            state = 9;
+    } break;
+    case 9: {
         data_struct* x_data = &data_list[DATA_X];
 
+        for (uint32_t& i : objset_load) {
+            obj_set* set = object_storage_get_obj_set(i);
+            if (!set)
+                continue;
+
+            for (uint32_t i = 0; i < set->obj_num; i++) {
+                obj* obj = &set->obj_data[i];
+                for (uint32_t j = 0; j < obj->num_material; j++) {
+                    obj_material* material = &obj->material_array[j].material;
+                    vec3 spec = { 0.5f, 0.5f, 0.5f };
+                    if (!memcmp(&material->color.specular, &spec, sizeof(vec3)))
+                        *(vec3*)&material->color.specular = vec3_null;
+                    else if (memcmp(&material->color.specular, &vec3_null, sizeof(vec3)))
+                        *(vec3*)&material->color.specular = { 0.1f, 0.1f, 0.1f };
+                }
+            }
+        }
+
         for (std::string i : pv_auth_3d_names) {
             uint32_t hash = hash_string_murmurhash(&i);
             int32_t id = auth_3d_data_load_hash(hash, pv_category_hash,
@@ -584,6 +577,15 @@ bool x_pv_game::Ctrl() {
                         stage_effect, bar_count + bar_count_change, bar });
                     prev_stage_effect = stage_effect;
                 } break;
+                case DSC_X_SONG_EFFECT_ATTACH: {
+                    int32_t effect_id = (int32_t)data[0];
+                    int32_t chara_id = (int32_t)data[1];
+
+                    auto elem = pv_auth_3d_chara_count.find(effect_id);
+                    if (elem == pv_auth_3d_chara_count.end())
+                        elem = pv_auth_3d_chara_count.insert({ effect_id, {} }).first;
+                    elem->second.insert(chara_id);
+                } break;
                 }
             }
 
@@ -649,7 +651,7 @@ bool x_pv_game::Ctrl() {
             if (rob_chr) {
                 playdata[i].rob_chr = rob_chr;
                 rob_chr->frame_speed = anim_frame_speed;
-                rob_chr->data.adjust.step_data.step = anim_frame_speed;
+                rob_chr->data.motion.step_data.step = anim_frame_speed;
                 //sub_1404F3000(i, rob_chr, anim_frame_speed);
             }
             sub_140122770(this, i);
@@ -664,6 +666,8 @@ bool x_pv_game::Ctrl() {
 
         state = 10;
 
+        x_pv_game_change_field(this, 1, -1, -1);
+
         Glitter::glt_particle_manager.SetPause(false);
         extern float_t frame_speed;
         frame_speed = 1.0f;
@@ -736,6 +740,7 @@ bool x_pv_game::Ctrl() {
                 auth_3d_data_set_enable(&id, true);
                 auth_3d_data_set_paused(&id, false);
                 auth_3d_data_set_visibility(&id, false);
+                auth_3d_data_set_req_frame(&id, -1.0f);
                 auth_3d_data_set_frame_rate(&id, &diva_pv_frame_rate);
             }
         }
@@ -746,8 +751,8 @@ bool x_pv_game::Ctrl() {
         }
         else
             pause = true;
-    }
-    else if (state == 10) {
+    } break;
+    case 10: {
         if (step_frame)
             if (pause)
                 pause = false;
@@ -783,10 +788,11 @@ bool x_pv_game::Ctrl() {
 
         if (!play || pv_end)
             state = 11;
-    }
-    else if (state == 11) {
+    } break;
+    case 11: {
         Glitter::glt_particle_manager.FreeScenes();
         SetDest();
+    } break;
     }
     return false;
 }
@@ -801,6 +807,14 @@ bool x_pv_game::Dest() {
     Unload();
     task_stage_modern_unload();
 
+    light_param_storage_data_reset();
+    post_process_tone_map_set_saturate_coeff(rctx_ptr->post_process.tone_map, 1.0f);
+    post_process_tone_map_set_scene_fade(rctx_ptr->post_process.tone_map, (vec4*)&vec4_null);
+    post_process_tone_map_set_scene_fade_blend_func(rctx_ptr->post_process.tone_map, 0);
+    rctx_ptr->post_process.dof->data.pv.enable = false;
+    rctx_ptr->object_data.object_culling = true;
+    rctx_ptr->draw_pass.shadow_ptr->range = 1.0f;
+
     Glitter::glt_particle_manager.SetPause(false);
     extern float_t frame_speed;
     frame_speed = 1.0f;
@@ -1050,6 +1064,7 @@ void x_pv_game::Load(int32_t pv_id, int32_t stage_id, chara_index charas[6], int
     for (pvpp_chara& i : pp->chara) {
         if (i.motion.size()) {
             rob_chara_pv_data pv_data;
+            pv_data.chara_size_index = chara_init_data_get_chara_size_index(charas[chara_index]);
             int32_t chara_id = rob_chara_array_init_chara_index(
                 charas[chara_index], &pv_data, modules[chara_index], true);
             if (chara_id >= 0 && chara_id < ROB_CHARA_COUNT)
@@ -1063,6 +1078,7 @@ void x_pv_game::Load(int32_t pv_id, int32_t stage_id, chara_index charas[6], int
     if (pv_id == 826)
         for (int32_t i = (int32_t)pp->chara.size(); i < ROB_CHARA_COUNT; i++) {
             rob_chara_pv_data pv_data;
+            pv_data.chara_size_index = chara_init_data_get_chara_size_index(charas[i]);
             int32_t chara_id = rob_chara_array_init_chara_index(charas[i], &pv_data, modules[i], true);
             if (chara_id >= 0 && chara_id < ROB_CHARA_COUNT)
                 rob_chara_ids[i] = chara_id;
@@ -1137,6 +1153,8 @@ void x_pv_game::Load(int32_t pv_id, int32_t stage_id, chara_index charas[6], int
     stage_effects_ptr = 0;
     stage_effects_ptr_end = 0;
 
+    pv_auth_3d_chara_count.clear();
+
     dsc_time = 0;
     dsc_data_ptr = 0;
     dsc_data_ptr_end = 0;
@@ -1281,6 +1299,8 @@ void x_pv_game::Unload() {
     stage_effects_ptr = 0;
     stage_effects_ptr_end = 0;
 
+    pv_auth_3d_chara_count.clear();
+
     dsc_time = 0;
     dsc_data_ptr = 0;
     dsc_data_ptr_end = 0;
@@ -1431,6 +1451,10 @@ static void sub_140122B60(x_pv_game* a1, int32_t chara_id, int32_t motion_index,
     }
 }
 
+static void x_pv_game_change_field(x_pv_game* xpvgm, int32_t field, int64_t dsc_time, int64_t curr_time) {
+    light_param_storage_data_set_pv_cut(field);
+}
+
 static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
     dsc_x_func func = (dsc_x_func)a1->dsc_data_ptr->func;
     uint32_t* data = a1->dsc_m.get_func_data(a1->dsc_data_ptr);
@@ -1522,8 +1546,8 @@ static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
                 bool v45 = rob_chr->set_motion_id(i.motion_id, i.frame,
                     i.duration, i.field_10, 0, i.blend_type, aft_bone_data, aft_mot_db);
                 rob_chr->set_motion_reset_data(i.motion_id, i.dsc_frame);
-                rob_chr->bone_data->field_758 = i.field_18;
-                rob_chr->data.adjust.step_data.step = i.frame_speed;
+                rob_chr->bone_data->disable_eye_motion = i.disable_eye_motion;
+                rob_chr->data.motion.step_data.step = i.frame_speed;
                 //if (v45)
                 //    pv_expression_array_set_motion(a1->chara_id, i.motion_id);
                 //if (!a1->pv_game->data.pv->disable_calc_motfrm_limit)
@@ -1658,7 +1682,7 @@ static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
         v519.duration = duration;
         v519.field_10 = v11;
         v519.blend_type = MOTION_BLEND_CROSS;
-        v519.field_18 = true;
+        v519.disable_eye_motion = true;
         v519.motion_index = motion_index;
         v519.dsc_time = v56 ? v56->time : a1->dsc_time;
         v519.dsc_frame = dsc_frame;
@@ -1670,8 +1694,8 @@ static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
                 v11, false, MOTION_BLEND_CROSS, aft_bone_data, aft_mot_db);
             rob_chr->set_motion_reset_data(motion_id, dsc_frame);
             rob_chr->set_motion_skin_param(motion_id, dsc_frame);
-            rob_chr->bone_data->field_758 = true;
-            rob_chr->data.adjust.step_data.step = v519.frame_speed;
+            rob_chr->bone_data->disable_eye_motion = true;
+            rob_chr->data.motion.step_data.step = v519.frame_speed;
             //if (v84)
             //    pv_expression_array_set_motion(a1->chara_id, motion_id);
             //if (!a1->pv_game->data.pv->disable_calc_motfrm_limit)
@@ -1680,7 +1704,7 @@ static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
         else {
             playdata->set_motion.clear();
             playdata->set_motion.push_back(v519);
-            rob_chr->data.adjust.step_data.step = v519.frame_speed;
+            rob_chr->data.motion.step_data.step = v519.frame_speed;
         }
     } break;
     case DSC_X_SET_PLAYDATA: {
@@ -1729,7 +1753,11 @@ static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
 
     } break;
     case DSC_X_CHANGE_FIELD: {
-
+        int32_t field = (int32_t)data[0];
+        if (field > 0)
+            x_pv_game_change_field(a1, field, a1->dsc_time, curr_time);
+        else
+            x_pv_game_reset_field(a1);
     } break;
     case DSC_X_HIDE_FIELD: {
 
@@ -2221,9 +2249,16 @@ static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
         int32_t chara_size_index;
         if (chara_size == 0)
             chara_size_index = chara_init_data_get_chara_size_index(rob_chr->chara_index);
-        else if (chara_size == 1)
-            chara_size_index = chara_init_data_get_chara_size_index(rob_chr->chara_index
-                /*pv_db_pv_get_performer_chara(a1->pv_game->data.pv, a1->chara_id)*/);
+        else if (chara_size == 1) {
+            chara_index chara_index = CHARA_MIKU;
+            if (a1->chara_id < a1->pp->chara.size())
+                chara_index = (::chara_index)a1->pp->chara[a1->chara_id].chara_effect.base_chara;
+            else if (a1->pv_id == 826)
+                chara_index = rob_chara_array_get(a1->chara_id)->chara_index;
+
+            //chara_index chara_index = pv_db_pv::get_performer_chara(a1->pv_game->data.pv, a1->chara_id);
+            chara_size_index = chara_init_data_get_chara_size_index(chara_index);
+        }
         else if (chara_size == 2)
             chara_size_index = 1;
         else if (chara_size == 3)
@@ -2496,7 +2531,7 @@ static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
 
             for (pvsr_glitter& i : effect.glitter) {
                 uint32_t effect_hash = hash_string_murmurhash(&i.name);
-                Glitter::glt_particle_manager.LoadScene(hash_murmurhash_empty, effect_hash, true);
+                Glitter::glt_particle_manager.LoadScene(hash_murmurhash_empty, effect_hash);
                 Glitter::glt_particle_manager.SetSceneName(hash, a1->stage_glitter->name.c_str());
                 Glitter::glt_particle_manager.SetSceneEffectName(
                     hash_murmurhash_empty, effect_hash, i.name.c_str());
@@ -2531,7 +2566,7 @@ static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
 
             for (pvpp_glitter& i : effect.glitter) {
                 uint32_t effect_hash = hash_string_murmurhash(&i.name);
-                Glitter::glt_particle_manager.LoadScene(hash_murmurhash_empty, effect_hash, true);
+                Glitter::glt_particle_manager.LoadScene(hash_murmurhash_empty, effect_hash);
                 Glitter::glt_particle_manager.SetSceneName(hash, a1->pv_glitter->name.c_str());
                 Glitter::glt_particle_manager.SetSceneEffectName(
                     hash_murmurhash_empty, effect_hash, i.name.c_str());
@@ -2557,7 +2592,9 @@ static bool x_pv_game_dsc_process(x_pv_game* a1, int64_t curr_time) {
         if (effect_id >= a1->pp->effect.size())
             break;
 
-        uint32_t hash = a1->pv_glitter->hash;
+        auto elem = a1->pv_auth_3d_chara_count.find(effect_id);
+        if (elem != a1->pv_auth_3d_chara_count.end() && elem->second.size())
+            chara_id = -1;
 
         pvpp_effect& effect = a1->pp->effect[effect_id];
         for (pvpp_a3da& i : effect.a3da) {
@@ -2999,11 +3036,15 @@ static void x_pv_game_map_auth_3d_to_mot(x_pv_game* xpvgm) {
         mat4_get_translation(&oh->node[a2m.j_asi_r_wj].model_transform.mat, &data[0]);
         data[1] = vec3_null;
         set_bone_key_set_data(bone_data, MOTION_BONE_CL_MOMO_R, key_set, data, 2);
-
-        printf("");
     }
 }
 
+static void x_pv_game_reset_field(x_pv_game* xpvgm) {
+    task_stage_modern_info v14;
+    task_stage_modern_set_stage(&v14);
+    Glitter::glt_particle_manager.FreeScenes();
+}
+
 static void x_pv_game_stage_effect_ctrl(x_pv_game* xpvgm) {
     x_pv_game_stage_effect& stage_effect = xpvgm->stage_effect;
 
@@ -3088,7 +3129,7 @@ static void x_pv_game_stage_effect_start(x_pv_game* xpvgm, pvsr_stage_effect* st
 
     for (pvsr_glitter& i : stage_effect->glitter) {
         uint32_t effect_hash = hash_string_murmurhash(&i.name);
-        Glitter::glt_particle_manager.LoadScene(hash_murmurhash_empty, effect_hash, true);
+        Glitter::glt_particle_manager.LoadScene(hash_murmurhash_empty, effect_hash);
         Glitter::glt_particle_manager.SetSceneName(hash, xpvgm->stage_glitter->name.c_str());
         Glitter::glt_particle_manager.SetSceneEffectName(
             hash_murmurhash_empty, effect_hash, i.name.c_str());

src/CLOUD/x_pv_game.hpp

@@ -35,7 +35,7 @@ struct pv_play_data_set_motion {
     float_t duration;
     bool field_10;
     MotionBlendType blend_type;
-    bool field_18;
+    bool disable_eye_motion;
     int32_t motion_index;
     int64_t dsc_time;
     float_t dsc_frame;
@@ -210,6 +210,8 @@ public:
     x_pv_game_stage_effect_init* stage_effects_ptr;
     x_pv_game_stage_effect_init* stage_effects_ptr_end;
 
+    std::map<int32_t, std::set<int32_t>> pv_auth_3d_chara_count;
+
     bool play;
     bool success;
     int32_t chara_id;

src/CRE/Glitter/effect.cpp

@@ -93,34 +93,34 @@ static bool glitter_effect_pack_file(GLT, f2_struct* st, glitter_effect* a2) {
     enrs_entry ee;
 
     ee = { 0, 2, 56, 1 };
-    ee.sub.push_back({ 0, 1, ENRS_QWORD });
-    ee.sub.push_back({ 0, 12, ENRS_DWORD });
+    ee.append(0, 1, ENRS_QWORD);
+    ee.append(0, 12, ENRS_DWORD);
     e.vec.push_back(ee);
     l += o = 56;
 
     if (a2->version == 7) {
         ee = { 0, 1, 4, 1 };
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
+        ee.append(0, 1, ENRS_DWORD);
         e.vec.push_back(ee);
         l += o = 4;
     }
 
     ee = { 0, 1, 4, 1 };
-    ee.sub.push_back({ 0, 1, ENRS_DWORD });
+    ee.append(0, 1, ENRS_DWORD);
     e.vec.push_back(ee);
     l += o = 4;
 
     if (~a2->data.flags & EFFECT_LOCAL && ext_anim)
         if (ext_anim->flags & EFFECT_EXT_ANIM_CHARA_ANIM) {
             ee = { 0, 1, 12, 1 };
-            ee.sub.push_back({ 0, 3, ENRS_DWORD });
+            ee.append(0, 3, ENRS_DWORD);
             e.vec.push_back(ee);
             l += o = 12;
         }
         else {
             ee = { 0, 2, 140, 1 };
-            ee.sub.push_back({ 0, 1, ENRS_QWORD });
-            ee.sub.push_back({ 0, 1, ENRS_DWORD });
+            ee.append(0, 1, ENRS_QWORD);
+            ee.append(0, 1, ENRS_DWORD);
             e.vec.push_back(ee);
             l += o = 140;
         }
@@ -144,7 +144,7 @@ static bool glitter_effect_pack_file(GLT, f2_struct* st, glitter_effect* a2) {
 
     *(uint64_t*)d = GLT_VAL != Glitter::FT
         ? hash_utf8_murmurhash(a2->name)
-        : hash_utf8_fnv1a64m(a2->name);;
+        : hash_utf8_fnv1a64m(a2->name);
     *(int32_t*)(d + 8) = a2->data.appear_time;
     *(int32_t*)(d + 12) = a2->data.life_time;
     *(int32_t*)(d + 16) = a2->data.start_time;

src/CRE/Glitter/effect_group.cpp

@@ -55,12 +55,13 @@ namespace Glitter {
                 if (!set)
                     continue;
 
-                for (uint32_t i = 0; i < set->objects_count; i++) {
-                    obj* obj = &set->objects[i];
-                    for (uint32_t j = 0; j < obj->materials_count; j++) {
-                        obj_material* mat = &obj->materials[j].material;
-                        if (!memcmp(&mat->emission, &vec3_null, sizeof(vec3)) && mat->emission.w == 1.0f)
-                            mat->emission = vec4u_identity;
+                for (uint32_t i = 0; i < set->obj_num; i++) {
+                    obj* obj = &set->obj_data[i];
+                    for (uint32_t j = 0; j < obj->num_material; j++) {
+                        obj_material* mat = &obj->material_array[j].material;
+                        if (!memcmp(&mat->color.emission, &vec3_null, sizeof(vec3))
+                            && mat->color.emission.w == 1.0f)
+                            mat->color.emission = vec4u_identity;
                     }
                 }
             }

src/CRE/Glitter/effect_inst.cpp

@@ -24,6 +24,7 @@ namespace Glitter {
         mat = mat4_identity;
         flags = (EffectInstFlag)0;
         random = 0;
+        min_color = vec4u_null;
 
         if (appear_now)
             data.appear_time = 0;
@@ -313,7 +314,7 @@ namespace Glitter {
         mat4 mat;
         int32_t chara_id;
 
-        if (this->flags & EFFECT_INST_CHARA_ANIM) {
+        if (flags & EFFECT_INST_CHARA_ANIM) {
             rob_chara* rob_chr = rob_chara_array_get(ext_anim->chara_index);
             if (!rob_chr)
                 return;
@@ -322,13 +323,13 @@ namespace Glitter {
 
             vec3 scale;
             mat4_get_scale(&mat, &scale);
-            vec3_sub_scalar(scale, 1.0f, this->ext_anim_scale);
-            this->ext_anim_scale.z = 0.0f;
-            enum_or(this->flags, EFFECT_INST_HAS_EXT_ANIM_SCALE);
+            vec3_sub_scalar(scale, 1.0f, ext_anim_scale);
+            ext_anim_scale.z = 0.0f;
+            enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_SCALE);
 
             int32_t bone_index = ext_anim->bone_index;
             if (bone_index == -1) {
-                if (this->flags & EFFECT_INST_EXT_ANIM_TRANS_ONLY) {
+                if (flags & EFFECT_INST_EXT_ANIM_TRANS_ONLY) {
                     ext_anim->mat = mat4_identity;
                     mat4_get_translation(&mat, &ext_anim->translation);
                 }
@@ -341,7 +342,7 @@ namespace Glitter {
                     return;
 
                 mat4_mult(bone_mat, &mat, &mat);
-                if (this->flags & EFFECT_INST_EXT_ANIM_TRANS_ONLY) {
+                if (flags & EFFECT_INST_EXT_ANIM_TRANS_ONLY) {
                     ext_anim->mat = mat4_identity;
                     mat4_get_translation(&mat, &ext_anim->translation);
                 }
@@ -351,7 +352,7 @@ namespace Glitter {
             goto SetFlags;
         }
 
-        if (~this->flags & EFFECT_INST_GET_EXT_ANIM_MAT) {
+        if (~flags & EFFECT_INST_GET_EXT_ANIM_MAT) {
             if (ext_anim->mesh_index == -1) {
                 if (!ext_anim->mesh_name)
                     return;
@@ -397,9 +398,9 @@ namespace Glitter {
 
                 vec3 scale;
                 mat4_get_scale(&mat, &scale);
-                vec3_sub_scalar(scale, 1.0f, this->ext_anim_scale);
-                this->ext_anim_scale.z = 0.0f;
-                enum_or(this->flags, EFFECT_INST_HAS_EXT_ANIM_SCALE);
+                vec3_sub_scalar(scale, 1.0f, ext_anim_scale);
+                ext_anim_scale.z = 0.0f;
+                enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_SCALE);
             }
         }
 
@@ -421,7 +422,7 @@ namespace Glitter {
         }
         else {
             mat4_mult(obj_mat, &mat, &mat);
-            if (this->flags & EFFECT_INST_EXT_ANIM_TRANS_ONLY) {
+            if (flags & EFFECT_INST_EXT_ANIM_TRANS_ONLY) {
                 ext_anim->mat = mat4_identity;
                 mat4_get_translation(&mat, &ext_anim->translation);
             }
@@ -432,9 +433,9 @@ namespace Glitter {
         return;
 
     SetFlags:
-        if (this->flags & EFFECT_INST_HAS_EXT_ANIM_NON_INIT) {
-            enum_and(this->flags, ~EFFECT_INST_HAS_EXT_ANIM_NON_INIT);
-            enum_or(this->flags, EFFECT_INST_HAS_EXT_ANIM_TRANS);
+        if (flags & EFFECT_INST_HAS_EXT_ANIM_NON_INIT) {
+            enum_and(flags, ~EFFECT_INST_HAS_EXT_ANIM_NON_INIT);
+            enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_TRANS);
         }
     }
 
@@ -450,51 +451,82 @@ namespace Glitter {
 
             switch (curve->type) {
             case CURVE_TRANSLATION_X:
-                this->translation.x = value;
+                translation.x = value;
                 break;
             case CURVE_TRANSLATION_Y:
-                this->translation.y = value;
+                translation.y = value;
                 break;
             case CURVE_TRANSLATION_Z:
-                this->translation.z = value;
+                translation.z = value;
                 break;
             case CURVE_ROTATION_X:
-                this->rotation.x = value;
+                rotation.x = value;
                 break;
             case CURVE_ROTATION_Y:
-                this->rotation.y = value;
+                rotation.y = value;
                 break;
             case CURVE_ROTATION_Z:
-                this->rotation.z = value;
+                rotation.z = value;
                 break;
             case CURVE_SCALE_X:
-                this->scale.x = value;
+                scale.x = value;
                 break;
             case CURVE_SCALE_Y:
-                this->scale.y = value;
+                scale.y = value;
                 break;
             case CURVE_SCALE_Z:
-                this->scale.z = value;
+                scale.z = value;
                 break;
             case CURVE_SCALE_ALL:
-                this->scale_all = value;
+                scale_all = value;
                 break;
             //case CURVE_COLOR_R:
-            //    this->color.x = value;
+            //    color.x = value;
             //    break;
             //case CURVE_COLOR_G:
-            //    this->color.y = value;
+            //    color.y = value;
             //    break;
             //case CURVE_COLOR_B:
-            //    this->color.z = value;
+            //    color.z = value;
             //    break;
             //case CURVE_COLOR_A:
-            //    this->color.w = value;
+            //    color.w = value;
             //    break;
             }
         }
     }
 
+    void F2EffectInst::SetMinColor(float_t& r, float_t& g, float_t& b, float_t& a) {
+        if (~flags & EFFECT_INST_SET_ADD_MIN_COLOR)
+            return;
+
+        if (flags & EFFECT_INST_SET_MIN_COLOR) {
+            if (min_color.x >= 0.0f)
+                r = min_color.x;
+            if (min_color.y >= 0.0f)
+                g = min_color.y;
+            if (min_color.z >= 0.0f)
+                b = min_color.z;
+            if (min_color.w >= 0.0f)
+                a = min_color.w;
+        }
+        else {
+            r = min_color.x + r;
+            g = min_color.y + g;
+            b = min_color.z + b;
+            a = min_color.w + a;
+        }
+
+        if (r < 0.0f)
+            r = 0.0f;
+        if (g < 0.0f)
+            g = 0.0f;
+        if (b < 0.0f)
+            b = 0.0f;
+        if (a < 0.0f)
+            a = 0.0f;
+    }
+
     int32_t EffectInst::GetExtAnimBoneIndex(EffectExtAnimCharaNode node) {
         if (node < EFFECT_EXT_ANIM_CHARA_HEAD || node > EFFECT_EXT_ANIM_CHARA_RIGHT_TOE)
             return -1;
@@ -527,9 +559,9 @@ namespace Glitter {
             "kl_toe_r_wj"
         };
 
-        const char* bone_name = bone_names[node];
+        uint64_t bone_name_hash = hash_utf8_fnv1a64m(bone_names[node]);
         for (std::string& i : *motion_bone_names)
-            if (!str_utils_compare(bone_name, i.c_str()))
+            if (bone_name_hash == hash_string_fnv1a64m(&i))
                 return (int32_t)(&i - motion_bone_names->data());
         return -1;
     }
@@ -1026,4 +1058,39 @@ namespace Glitter {
         enum_or(flags, EFFECT_INST_HAS_EXT_ANIM_TRANS);
         this->flags = flags;
     }
+
+    void XEffectInst::SetMinColor(float_t& r, float_t& g, float_t& b, float_t& a) {
+        if (~flags & EFFECT_INST_SET_ADD_MIN_COLOR)
+            return;
+
+        if (flags & EFFECT_INST_SET_MIN_COLOR) {
+            if (min_color.x >= 0.0f)
+                r = min_color.x;
+            if (min_color.y >= 0.0f)
+                g = min_color.y;
+            if (min_color.z >= 0.0f)
+                b = min_color.z;
+            if (min_color.w >= 0.0f)
+                a = min_color.w;
+        }
+        else {
+            if (min_color.x >= 0.0f)
+                r *= min_color.x;
+            if (min_color.y >= 0.0f)
+                g *= min_color.y;
+            if (min_color.z >= 0.0f)
+                b *= min_color.z;
+            if (min_color.w >= 0.0f)
+                a *= min_color.w;
+        }
+
+        if (r < 0.0f)
+            r = 0.0f;
+        if (g < 0.0f)
+            g = 0.0f;
+        if (b < 0.0f)
+            b = 0.0f;
+        if (a < 0.0f)
+            a = 0.0f;
+    }
 }

src/CRE/Glitter/emitter.cpp

@@ -72,36 +72,36 @@ static bool glitter_emitter_pack_file(GLT, f2_struct* st, glitter_emitter* a2) {
     enrs_entry ee;
 
     ee = { 0, 5, 96, 1 };
-    ee.sub.push_back({ 0, 5, ENRS_DWORD });
-    ee.sub.push_back({ 0, 2, ENRS_WORD });
-    ee.sub.push_back({ 0, 2, ENRS_DWORD });
-    ee.sub.push_back({ 0, 2, ENRS_WORD });
-    ee.sub.push_back({ 0, 15, ENRS_DWORD });
+    ee.append(0, 5, ENRS_DWORD);
+    ee.append(0, 2, ENRS_WORD);
+    ee.append(0, 2, ENRS_DWORD);
+    ee.append(0, 2, ENRS_WORD);
+    ee.append(0, 15, ENRS_DWORD);
     e.vec.push_back(ee);
     l += o = 96;
 
     switch (a2->data.type) {
     case EMITTER_BOX:
         ee = { o, 1, 12, 1 };
-        ee.sub.push_back({ 0, 3, ENRS_DWORD });
+        ee.append(0, 3, ENRS_DWORD);
         e.vec.push_back(ee);
         l += o = 12;
         break;
     case EMITTER_CYLINDER:
         ee = { o, 1, 20, 1 };
-        ee.sub.push_back({ 0, 5, ENRS_DWORD });
+        ee.append(0, 5, ENRS_DWORD);
         e.vec.push_back(ee);
         l += o = 20;
         break;
     case EMITTER_SPHERE:
         ee = { o, 1, 16, 1 };
-        ee.sub.push_back({ 0, 4, ENRS_DWORD });
+        ee.append(0, 4, ENRS_DWORD);
         e.vec.push_back(ee);
         l += o = 16;
         break;
     case EMITTER_POLYGON:
         ee = { o, 1, 8, 1 };
-        ee.sub.push_back({ 0, 2, ENRS_DWORD });
+        ee.append(0, 2, ENRS_DWORD);
         e.vec.push_back(ee);
         l += o = 8;
         break;

src/CRE/Glitter/emitter_inst.cpp

@@ -4,6 +4,7 @@
 */
 
 #include "glitter.hpp"
+#include "../render_context.hpp"
 
 namespace Glitter {
     EmitterInst::EmitterInst(Emitter* emit, Random* random) : emission_timer(), flags(), random() {
@@ -142,7 +143,7 @@ namespace Glitter {
         mat4 dir_mat;
         switch (data.direction) {
         case DIRECTION_BILLBOARD:
-            mat4_from_mat3(&GPM_VAL->cam_inv_view_mat3, &dir_mat);
+            mat4_from_mat3(&((render_context*)GPM_VAL->rctx)->camera->inv_view_mat3, &dir_mat);
             mat4_mult(&eff_inst->mat, &dir_mat, &dir_mat);
             mat4_clear_trans(&dir_mat, &dir_mat);
             break;
@@ -156,7 +157,7 @@ namespace Glitter {
             mat4_rotate_z((float_t)-M_PI_2, &dir_mat);
             break;
         case DIRECTION_BILLBOARD_Y_AXIS:
-            mat4_rotate_y(GPM_VAL->cam_rotation_y, &dir_mat);
+            mat4_rotate_y(((render_context*)GPM_VAL->rctx)->camera->rotation.y, &dir_mat);
             break;
         default:
             mult = false;
@@ -575,7 +576,7 @@ namespace Glitter {
         switch (data.direction) {
         case DIRECTION_BILLBOARD:
             if (eff_inst->data.flags & EFFECT_LOCAL) {
-                dir_mat = GPM_VAL->cam_view;
+                dir_mat = ((render_context*)GPM_VAL->rctx)->camera->view;
                 mat4_clear_trans(&dir_mat, &dir_mat);
                 mat4_mult(&dir_mat, &mat, &dir_mat);
             }
@@ -583,7 +584,7 @@ namespace Glitter {
                 dir_mat = mat;
 
             mat4 inv_view_mat;
-            mat4_from_mat3(&GPM_VAL->cam_inv_view_mat3, &inv_view_mat);
+            mat4_from_mat3(&((render_context*)GPM_VAL->rctx)->camera->inv_view_mat3, &inv_view_mat);
             mat4_mult(&dir_mat, &inv_view_mat, &dir_mat);
             mat4_clear_trans(&dir_mat, &dir_mat);
             break;
@@ -594,7 +595,7 @@ namespace Glitter {
             mat4_rotate_x((float_t)-M_PI_2, &dir_mat);
             break;
         case DIRECTION_BILLBOARD_Y_AXIS:
-            mat4_rotate_y(GPM_VAL->cam_rotation_y, &dir_mat);
+            mat4_rotate_y(((render_context*)GPM_VAL->rctx)->camera->rotation.y, &dir_mat);
             break;
         default:
             mult = false;

src/CRE/Glitter/file_reader.cpp

@@ -292,8 +292,8 @@ namespace Glitter {
         enrs_entry ee;
 
         ee = { 0, 2, 32, 1 };
-        ee.sub.push_back({ 0, 4, ENRS_DWORD });
-        ee.sub.push_back({ 0, 3, ENRS_WORD });
+        ee.append(0, 4, ENRS_DWORD);
+        ee.append(0, 3, ENRS_WORD);
         e.vec.push_back(ee);
         l += o = 32;
 
@@ -1123,14 +1123,14 @@ namespace Glitter {
             key_type = keys->front().type;
             if (key_type == KEY_HERMITE) {
                 ee = { 0, 2, 20, 1 };
-                ee.sub.push_back({ 0, 2, ENRS_WORD });
-                ee.sub.push_back({ 0, 4, ENRS_DWORD });
+                ee.append(0, 2, ENRS_WORD);
+                ee.append(0, 4, ENRS_DWORD);
                 l = 20;
             }
             else {
                 ee = { 0, 2, 12, 1 };
-                ee.sub.push_back({ 0, 2, ENRS_WORD });
-                ee.sub.push_back({ 0, 2, ENRS_DWORD });
+                ee.append(0, 2, ENRS_WORD);
+                ee.append(0, 2, ENRS_DWORD);
                 l = 12;
             }
 
@@ -1151,13 +1151,13 @@ namespace Glitter {
                 o = (uint32_t)((key_type == KEY_HERMITE ? 20 : 12) * count);
                 if (i->type == KEY_HERMITE) {
                     ee = { o, 2, 20, 1 };
-                    ee.sub.push_back({ 0, 2, ENRS_WORD });
-                    ee.sub.push_back({ 0, 4, ENRS_DWORD });
+                    ee.append(0, 2, ENRS_WORD);
+                    ee.append(0, 4, ENRS_DWORD);
                 }
                 else {
                     ee = { o, 2, 12, 1 };
-                    ee.sub.push_back({ 0, 2, ENRS_WORD });
-                    ee.sub.push_back({ 0, 2, ENRS_DWORD });
+                    ee.append(0, 2, ENRS_WORD);
+                    ee.append(0, 2, ENRS_DWORD);
                 }
                 key_type = i->type;
             }
@@ -1166,14 +1166,14 @@ namespace Glitter {
             key_type = keys->front().type;
             if (key_type == KEY_HERMITE) {
                 ee = { 0, 2, 16, 1 };
-                ee.sub.push_back({ 0, 2, ENRS_WORD });
-                ee.sub.push_back({ 0, 3, ENRS_DWORD });
+                ee.append(0, 2, ENRS_WORD);
+                ee.append(0, 3, ENRS_DWORD);
                 l = 16;
             }
             else {
                 ee = { 0, 2, 8, 1 };
-                ee.sub.push_back({ 0, 2, ENRS_WORD });
-                ee.sub.push_back({ 0, 1, ENRS_DWORD });
+                ee.append(0, 2, ENRS_WORD);
+                ee.append(0, 1, ENRS_DWORD);
                 l = 8;
             }
 
@@ -1194,13 +1194,13 @@ namespace Glitter {
                 o = (uint32_t)((key_type == KEY_HERMITE ? 16 : 8) * count);
                 if (i->type == KEY_HERMITE) {
                     ee = { o, 2, 16, 1 };
-                    ee.sub.push_back({ 0, 2, ENRS_WORD });
-                    ee.sub.push_back({ 0, 3, ENRS_DWORD });
+                    ee.append(0, 2, ENRS_WORD);
+                    ee.append(0, 3, ENRS_DWORD);
                 }
                 else {
                     ee = { o, 2, 8, 1 };
-                    ee.sub.push_back({ 0, 2, ENRS_WORD });
-                    ee.sub.push_back({ 0, 1, ENRS_DWORD });
+                    ee.append(0, 2, ENRS_WORD);
+                    ee.append(0, 1, ENRS_DWORD);
                 }
                 key_type = i->type;
             }
@@ -1354,7 +1354,7 @@ namespace Glitter {
         enrs_entry ee;
 
         ee = { 0, 1, 4, 1 };
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
+        ee.append(0, 1, ENRS_DWORD);
         e.vec.push_back(ee);
 
         length = 0;
@@ -1511,8 +1511,8 @@ namespace Glitter {
         enrs_entry ee;
 
         ee = { 0, 2, (uint32_t)(8 + count * 8), 1 };
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
-        ee.sub.push_back({ 4, (uint32_t)count, ENRS_QWORD });
+        ee.append(0, 1, ENRS_DWORD);
+        ee.append(4, (uint32_t)count, ENRS_QWORD);
         e.vec.push_back(ee);
         l += 8 + count * 8;
 

src/CRE/Glitter/glitter.hpp

@@ -772,6 +772,7 @@ namespace Glitter {
         EffectInstFlag flags;
         size_t id;
         uint32_t random;
+        vec4u min_color;
 
         EffectInst(GPM, GLT, Effect* eff,
             size_t id, float_t emission, bool appear_now);
@@ -837,6 +838,7 @@ namespace Glitter {
         void CtrlInit(GPM, GLT, float_t emission);
         void GetExtAnim();
         void GetValue(GLT);
+        void SetMinColor(float_t& r, float_t& g, float_t& b, float_t& a);
     };
 
     class XEffectInst : public EffectInst {
@@ -890,6 +892,7 @@ namespace Glitter {
         void GetExtAnim();
         void GetValue();
         void SetExtAnim(mat4* a2, mat4* a3, vec3* trans, bool set_flags);
+        void SetMinColor(float_t& r, float_t& g, float_t& b, float_t& a);
     };
 
     class Emitter : public Node {
@@ -1191,10 +1194,12 @@ namespace Glitter {
         void Emit(GPM, GLT, int32_t dup_count, int32_t count, float_t emission);
         void EmitParticle(GPM, GLT, RenderElement* rend_elem, F2EmitterInst* emit_inst,
             F2ParticleInst::Data* ptcl_inst_data, int32_t index, Random* random);
-        void GetValue(GLT, RenderElement* rend_elem, float_t frame, Random* random);
+        void GetColor(Glitter::RenderElement* rend_elem);
+        bool GetValue(GLT, RenderElement* rend_elem, float_t frame, Random* random);
         void Free(bool free);
         bool HasEnded(bool a2);
         void Reset();
+        void SetMinColor(float_t& r, float_t& g, float_t& b, float_t& a);
         void StepUVParticle(GLT, RenderElement* rend_elem, float_t delta_frame, Random* random);
     };
 
@@ -1226,10 +1231,12 @@ namespace Glitter {
         void Emit(int32_t dup_count, int32_t count, float_t emission);
         void EmitParticle(RenderElement* rend_elem, XEmitterInst* emit_inst,
             XParticleInst::Data* ptcl_inst_data, int32_t index, uint8_t step, Random* random);
-        void GetValue(RenderElement* rend_elem, float_t frame, Random* random, float_t* color_scale);
+        void GetColor(Glitter::RenderElement* rend_elem, float_t color_scale);
+        bool GetValue(RenderElement* rend_elem, float_t frame, Random* random, float_t* color_scale);
         void Free(bool free);
         bool HasEnded(bool a2);
         void Reset();
+        void SetMinColor(float_t& r, float_t& g, float_t& b, float_t& a);
         void StepUVParticle(RenderElement* rend_elem, float_t delta_frame, Random* random);
     };
 
@@ -1404,12 +1411,6 @@ namespace Glitter {
         uint32_t texture_counter;
         Random random;
         uint32_t counter;
-        mat4 cam_projection;
-        mat4 cam_view;
-        mat4 cam_inv_view;
-        mat3 cam_inv_view_mat3;
-        vec3 cam_view_point;
-        float_t cam_rotation_y;
         bool draw_all;
         bool draw_all_mesh;
         bool draw_selected;

src/CRE/Glitter/particle.cpp

@@ -88,33 +88,33 @@ static bool glitter_particle_pack_file(GLT,
     enrs_entry ee;
 
     ee = { 0, 1, 204, 1 };
-    ee.sub.push_back({ 0, 51, ENRS_DWORD });
+    ee.append(0, 51, ENRS_DWORD);
     e.vec.push_back(ee);
     l += o = 204;
 
     if (a3->version == 3) {
         ee = { o, 1, 8, 1 };
-        ee.sub.push_back({ 0, 2, ENRS_DWORD });
+        ee.append(0, 2, ENRS_DWORD);
         e.vec.push_back(ee);
         l += o = 8;
     }
 
     if (a3->data.type == PARTICLE_LOCUS || a3->data.type == PARTICLE_MESH) {
         ee = { o, 1, 4, 1 };
-        ee.sub.push_back({ 0, 2, ENRS_WORD });
+        ee.append(0, 2, ENRS_WORD);
         e.vec.push_back(ee);
         l += o = 4;
     }
 
     ee = { o, 4, 44, 1 };
-    ee.sub.push_back({ 0, 1, ENRS_QWORD });
-    ee.sub.push_back({ 4, 5, ENRS_DWORD });
-    ee.sub.push_back({ 0, 2, ENRS_WORD });
-    ee.sub.push_back({ 0, 2, ENRS_DWORD });
+    ee.append(0, 1, ENRS_QWORD);
+    ee.append(4, 5, ENRS_DWORD);
+    ee.append(0, 2, ENRS_WORD);
+    ee.append(0, 2, ENRS_DWORD);
     if (a1->version >= 7) {
         ee.count++;
         ee.size += 4;
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
+        ee.append.push_back(0, 1, ENRS_DWORD);
         e.vec.push_back(ee);
         l += o = 48;
     }
@@ -124,8 +124,8 @@ static bool glitter_particle_pack_file(GLT,
     }
 
     ee = { o, 2, 12, 1 };
-    ee.sub.push_back({ 0, 1, ENRS_QWORD });
-    ee.sub.push_back({ 0, 1, ENRS_DWORD });
+    ee.append.push_back(0, 1, ENRS_QWORD);
+    ee.append.push_back(0, 1, ENRS_DWORD);
     e.vec.push_back(ee);
     l += o = 12;
 

src/CRE/Glitter/particle_inst.cpp

@@ -130,6 +130,13 @@ namespace Glitter {
         }
     }
 
+    void F2ParticleInst::SetMinColor(float_t& r, float_t& g, float_t& b, float_t& a) {
+        if (data.effect)
+            data.effect->SetMinColor(r, g, b, a);
+        else if (data.parent && data.parent->data.effect)
+            data.parent->data.effect->SetMinColor(r, g, b, a);
+    }
+
     void F2ParticleInst::Copy(F2ParticleInst* dst, float_t emission) {
         dst->data.flags = data.flags;
         if (data.render_group && dst->data.render_group)
@@ -289,7 +296,35 @@ namespace Glitter {
             i->Free(free);
     }
 
-    void F2ParticleInst::GetValue(GLT, RenderElement* rend_elem, float_t frame, Random* random) {
+    void F2ParticleInst::GetColor(Glitter::RenderElement* rend_elem) {
+        float_t r = rend_elem->color.x;
+        if (r < 0.0f)
+            r = data.data.color.x;
+
+        float_t g = rend_elem->color.y;
+        if (g < 0.0f)
+            g = data.data.color.y;
+
+        float_t b = rend_elem->color.z;
+        if (b < 0.0f)
+            b = data.data.color.z;
+
+        float_t a = rend_elem->color.w;
+        if (a < 0.0f)
+            a = data.data.color.w;
+
+        SetMinColor(r, g, b, a);
+
+        rend_elem->color.x = r;
+        rend_elem->color.y = g;
+        rend_elem->color.z = b;
+        rend_elem->color.w = a;
+
+        if (a < 0.01f)
+            rend_elem->disp = false;
+    }
+
+    bool F2ParticleInst::GetValue(GLT, RenderElement* rend_elem, float_t frame, Random* random) {
         float_t value = 0.0f;
         bool has_translation = false;
         vec3 translation = vec3_null;
@@ -349,7 +384,7 @@ namespace Glitter {
                 rend_elem->color.w = value;
                 if (value < 0.01f) {
                     rend_elem->disp = false;
-                    return;
+                    return false;
                 }
                 break;
             case CURVE_U_SCROLL:
@@ -367,6 +402,7 @@ namespace Glitter {
                 mat4_mult_vec3_trans(&rend_elem->mat, &translation, &translation);
             rend_elem->translation = translation;
         }
+        return true;
     }
 
     bool F2ParticleInst::HasEnded(bool a2) {
@@ -552,8 +588,31 @@ namespace Glitter {
         rend_elem->speed = max(speed, 0.0f);
     }
 
-    void XParticleInst::Copy(XParticleInst* dst, float_t emission) {
+    void XParticleInst::SetMinColor(float_t& r, float_t& g, float_t& b, float_t& a) {
+        if (data.effect)
+            data.effect->SetMinColor(r, g, b, a);
+        else if (data.parent && data.parent->data.effect)
+            data.parent->data.effect->SetMinColor(r, g, b, a);
+    }
 
+    void XParticleInst::Copy(XParticleInst* dst, float_t emission) {
+        dst->data.flags = data.flags;
+        if (data.render_group && dst->data.render_group)
+            data.render_group->Copy(dst->data.render_group);
+
+        for (XParticleInst*& i : dst->data.children)
+            if (i) {
+                delete i;
+                i = 0;
+            }
+        dst->data.children.clear();
+
+        for (XParticleInst*& i : data.children)
+            if (i) {
+                XParticleInst* child = new XParticleInst(this, emission);
+                dst->data.children.push_back(child);
+                i->Copy(child, emission);
+            }
     }
 
     void XParticleInst::Emit(int32_t dup_count, int32_t count, float_t emission) {
@@ -706,7 +765,47 @@ namespace Glitter {
         random->XStepValue();
     }
 
-    void XParticleInst::GetValue(RenderElement* rend_elem, float_t frame, Random* random, float_t* color_scale) {
+    void XParticleInst::GetColor(Glitter::RenderElement* rend_elem, float_t color_scale) {
+        float_t r = rend_elem->color.x;
+        if (r < 0.0f)
+            r = data.data.color.x;
+
+        float_t g = rend_elem->color.y;
+        if (g < 0.0f)
+            g = data.data.color.y;
+
+        float_t b = rend_elem->color.z;
+        if (b < 0.0f)
+            b = data.data.color.z;
+
+        float_t a = rend_elem->color.w;
+        if (a < 0.0f)
+            a = data.data.color.w;
+
+        if (color_scale >= 0.0f) {
+            r *= color_scale;
+            g *= color_scale;
+            b *= color_scale;
+        }
+
+        if (rend_elem->fade_out_frames > 0.0f
+            && rend_elem->life_time < (rend_elem->frame + rend_elem->fade_out_frames))
+            a *= (rend_elem->life_time - rend_elem->frame) / rend_elem->fade_out_frames;
+        else if (rend_elem->fade_in_frames > 0.0f && rend_elem->frame < rend_elem->fade_in_frames)
+            a *= rend_elem->frame / rend_elem->fade_in_frames;
+
+        SetMinColor(r, g, b, a);
+
+        rend_elem->color.x = r;
+        rend_elem->color.y = g;
+        rend_elem->color.z = b;
+        rend_elem->color.w = a;
+
+        if (a < 0.01f)
+            rend_elem->disp = false;
+    }
+
+    bool XParticleInst::GetValue(RenderElement* rend_elem, float_t frame, Random* random, float_t* color_scale) {
         float_t value = 0.0f;
         vec3 translation = vec3_null;
         bool has_translation = false;
@@ -742,15 +841,31 @@ namespace Glitter {
                 break;
             case CURVE_SCALE_X:
                 rend_elem->scale.x = value;
+                if (fabsf(value) <= 0.000001f) {
+                    rend_elem->disp = false;
+                    return false;
+                }
                 break;
             case CURVE_SCALE_Y:
                 rend_elem->scale.y = value;
+                if (fabsf(value) <= 0.000001f) {
+                    rend_elem->disp = false;
+                    return false;
+                }
                 break;
             case CURVE_SCALE_Z:
                 rend_elem->scale.z = value;
+                if (fabsf(value) <= 0.000001f) {
+                    rend_elem->disp = false;
+                    return false;
+                }
                 break;
             case CURVE_SCALE_ALL:
                 rend_elem->scale_all = value;
+                if (fabsf(value) <= 0.000001f) {
+                    rend_elem->disp = false;
+                    return false;
+                }
                 break;
             case CURVE_COLOR_R:
                 rend_elem->color.x = value;
@@ -763,8 +878,10 @@ namespace Glitter {
                 break;
             case CURVE_COLOR_A:
                 rend_elem->color.w = value;
-                if (value < 0.01f)
+                if (value < 0.01f) {
                     rend_elem->disp = false;
+                    return false;
+                }
                 break;
             case CURVE_COLOR_RGB_SCALE:
                 *color_scale = value;
@@ -790,6 +907,7 @@ namespace Glitter {
                 mat4_mult_vec3_trans(&rend_elem->mat, &translation, &translation);
             rend_elem->translation = translation;
         }
+        return true;
     }
 
     void XParticleInst::Free(bool free) {

src/CRE/Glitter/particle_manager.cpp

@@ -8,8 +8,7 @@
 namespace Glitter {
     GltParticleManager::GltParticleManager() :scene(), effect(), emitter(), particle(), rctx(),
     bone_data(), frame_rate(), flags(), scene_load_counter(), emission(1.5f), delta_frame(2.0f),
-    texture_counter(), random(), counter(), cam_projection(), cam_view(), cam_inv_view(), cam_inv_view_mat3(),
-    cam_view_point(), cam_rotation_y(), draw_all(true), draw_all_mesh(true), draw_selected() {
+    texture_counter(), random(), counter(), draw_all(true), draw_all_mesh(true), draw_selected() {
         scenes.reserve(0x100);
         file_readers.reserve(0x100);
     }

src/CRE/Glitter/render_group.cpp

@@ -205,25 +205,15 @@ namespace Glitter {
         vec2_add(rend_elem->uv_scroll, uv_scroll, rend_elem->uv_scroll);
 
         particle->StepUVParticle(GLT_VAL, rend_elem, delta_frame, random_ptr);
-        rend_elem->color = { -1.0f, -1.0f, -1.0f, -1.0f };
         rend_elem->disp = true;
+        rend_elem->color = { -1.0f, -1.0f, -1.0f, -1.0f };
 
+        bool disp = true;
         if (particle->data.data.sub_flags & PARTICLE_SUB_USE_CURVE)
-            particle->GetValue(GLT_VAL, rend_elem, rend_elem->frame, random_ptr);
+            disp = particle->GetValue(GLT_VAL, rend_elem, rend_elem->frame, random_ptr);
 
-        if (rend_elem->disp) {
-            if (rend_elem->color.x < 0.0f)
-                rend_elem->color.x = particle->data.data.color.x;
-            if (rend_elem->color.y < 0.0f)
-                rend_elem->color.y = particle->data.data.color.y;
-            if (rend_elem->color.z < 0.0f)
-                rend_elem->color.z = particle->data.data.color.z;
-            if (rend_elem->color.w < 0.0f)
-                rend_elem->color.w = particle->data.data.color.w;
-
-            if (rend_elem->color.w < 0.01f)
-                rend_elem->disp = false;
-        }
+        if (disp)
+            particle->GetColor(rend_elem);
 
         if (particle->data.data.type == PARTICLE_LOCUS)
             rend_elem->locus_history->Append(rend_elem, particle);
@@ -559,35 +549,16 @@ namespace Glitter {
         }
 
         particle->StepUVParticle(rend_elem, delta_frame, random_ptr);
-        rend_elem->color = { -1.0f, -1.0f, -1.0f, -1.0f };
         rend_elem->disp = true;
+        rend_elem->color = { -1.0f, -1.0f, -1.0f, -1.0f };
 
+        bool disp = true;
         float_t color_scale = -1.0f;
         if (particle->data.data.sub_flags & PARTICLE_SUB_USE_CURVE)
-            particle->GetValue(rend_elem, rend_elem->frame, random_ptr, &color_scale);
+            disp = particle->GetValue(rend_elem, rend_elem->frame, random_ptr, &color_scale);
 
-        if (rend_elem->disp) {
-            if (rend_elem->color.x < 0.0f)
-                rend_elem->color.x = particle->data.data.color.x;
-            if (rend_elem->color.y < 0.0f)
-                rend_elem->color.y = particle->data.data.color.y;
-            if (rend_elem->color.z < 0.0f)
-                rend_elem->color.z = particle->data.data.color.z;
-            if (rend_elem->color.w < 0.0f)
-                rend_elem->color.w = particle->data.data.color.w;
-
-            if (color_scale >= 0.0f)
-                vec3_mult_scalar(*(vec3*)&rend_elem->color, color_scale, *(vec3*)&rend_elem->color);
-
-            if (rend_elem->fade_out_frames > 0.0
-                && (rend_elem->life_time - rend_elem->frame) < rend_elem->fade_out_frames)
-                rend_elem->color.w *= (rend_elem->life_time - rend_elem->frame) / rend_elem->fade_out_frames;
-            else if (rend_elem->fade_in_frames > 0.0 && rend_elem->frame < rend_elem->fade_in_frames)
-                rend_elem->color.w *= rend_elem->frame / rend_elem->fade_in_frames;
-
-            if (rend_elem->color.w < 0.01f)
-                rend_elem->disp = false;
-        }
+        if (disp)
+            particle->GetColor(rend_elem, color_scale);
 
         if (particle->data.data.type == PARTICLE_LOCUS)
             rend_elem->locus_history->Append(rend_elem, particle);

src/CRE/Glitter/render_scene.cpp

@@ -281,9 +281,9 @@ namespace Glitter {
         vec3 x_vec = { 1.0f, 0.0f, 0.0f };
         if (rend_group->flags & PARTICLE_LOCAL) {
             mat4 mat;
-            mat4_mult(&GPM_VAL->cam_inv_view, &rend_group->mat, &mat);
-            mat4_mult(&GPM_VAL->cam_view, &mat, &mat);
-            mat4_mult(&mat, &GPM_VAL->cam_inv_view, &rend_group->mat_draw);
+            mat4_mult(&((render_context*)GPM_VAL->rctx)->camera->inv_view, &rend_group->mat, &mat);
+            mat4_mult(&((render_context*)GPM_VAL->rctx)->camera->view, &mat, &mat);
+            mat4_mult(&mat, &((render_context*)GPM_VAL->rctx)->camera->inv_view, &rend_group->mat_draw);
         }
         else
             rend_group->mat_draw = mat4_identity;
@@ -311,7 +311,7 @@ namespace Glitter {
         else
             model_mat = mat3_identity;
 
-        mat3_mult_vec(&GPM_VAL->cam_inv_view_mat3, &x_vec, &x_vec);
+        mat3_mult_vec(&((render_context*)GPM_VAL->rctx)->camera->inv_view_mat3, &x_vec, &x_vec);
 
         gl_state_bind_array_buffer(rend_group->vbo);
         Buffer* buf = (Buffer*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
@@ -411,13 +411,13 @@ namespace Glitter {
         if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
             model_mat = rend_group->mat;
             mat4_normalize_rotation(&model_mat, &view_mat);
-            mat4_mult(&view_mat, &GPM_VAL->cam_view, &view_mat);
+            mat4_mult(&view_mat, &((render_context*)GPM_VAL->rctx)->camera->view, &view_mat);
             mat4_inverse(&view_mat, &inv_view_mat);
         }
         else {
             model_mat = mat4_identity;
-            view_mat = GPM_VAL->cam_view;
-            inv_view_mat = GPM_VAL->cam_inv_view;
+            view_mat = ((render_context*)GPM_VAL->rctx)->camera->view;
+            inv_view_mat = ((render_context*)GPM_VAL->rctx)->camera->inv_view;
         }
 
         if (rend_group->flags & PARTICLE_LOCAL) {
@@ -426,7 +426,7 @@ namespace Glitter {
             mat4_inverse(&view_mat, &inv_view_mat);
         }
 
-        mat4_mult(&view_mat, &GPM_VAL->cam_inv_view, &rend_group->mat_draw);
+        mat4_mult(&view_mat, &((render_context*)GPM_VAL->rctx)->camera->inv_view, &rend_group->mat_draw);
 
         mat4 dir_mat;
         switch (rend_group->draw_type) {
@@ -456,7 +456,7 @@ namespace Glitter {
             mat4_rotate_z((float_t)-M_PI_2, &dir_mat);
             break;
         case DIRECTION_BILLBOARD_Y_AXIS:
-            mat4_rotate_y(GPM_VAL->cam_rotation_y, &dir_mat);
+            mat4_rotate_y(((render_context*)GPM_VAL->rctx)->camera->rotation.y, &dir_mat);
             break;
         default:
             dir_mat = mat4_identity;
@@ -607,7 +607,7 @@ namespace Glitter {
         if (fabsf(rend_group->z_offset) > 0.000001f) {
             use_z_offset = true;
             mat4_get_translation(model_mat, &dist_to_cam);
-            vec3_sub(GPM_VAL->cam_view_point, dist_to_cam, dist_to_cam);
+            vec3_sub(((render_context*)GPM_VAL->rctx)->camera->view_point, dist_to_cam, dist_to_cam);
             if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
                 mat4_normalize_rotation(model_mat, &z_offset_inv_mat);
                 mat4_inverse(&z_offset_inv_mat, &z_offset_inv_mat);
@@ -1007,7 +1007,8 @@ namespace Glitter {
 
         shader_state_material_set_emission(&shaders_ft, false, emission, emission, emission, 1.0f);
         shader_state_matrix_set_mvp_separate(&shaders_ft,
-            &rend_group->mat_draw, &GPM_VAL->cam_view, &GPM_VAL->cam_projection);
+            &rend_group->mat_draw, &((render_context*)GPM_VAL->rctx)->camera->view,
+            &((render_context*)GPM_VAL->rctx)->camera->projection);
         shader_state_matrix_set_texture(&shaders_ft, 0, (mat4*)&mat4_identity);
         shader_state_matrix_set_texture(&shaders_ft, 1, (mat4*)&mat4_identity);
         shader_env_vert_set_ptr(&shaders_ft, 3, (vec4*)&vec4_identity);
@@ -1254,9 +1255,9 @@ namespace Glitter {
         vec3 x_vec = { 1.0f, 0.0f, 0.0f };
         if (rend_group->flags & PARTICLE_LOCAL) {
             mat4 mat;
-            mat4_mult(&GPM_VAL->cam_inv_view, &rend_group->mat, &mat);
-            mat4_mult(&GPM_VAL->cam_view, &mat, &mat);
-            mat4_mult(&mat, &GPM_VAL->cam_inv_view, &rend_group->mat_draw);
+            mat4_mult(&((render_context*)GPM_VAL->rctx)->camera->inv_view, &rend_group->mat, &mat);
+            mat4_mult(&((render_context*)GPM_VAL->rctx)->camera->view, &mat, &mat);
+            mat4_mult(&mat, &((render_context*)GPM_VAL->rctx)->camera->inv_view, &rend_group->mat_draw);
         }
         else
             rend_group->mat_draw = mat4_identity;
@@ -1282,7 +1283,7 @@ namespace Glitter {
         else
             model_mat = mat3_identity;
 
-        mat3_mult_vec(&GPM_VAL->cam_inv_view_mat3, &x_vec, &x_vec);
+        mat3_mult_vec(&((render_context*)GPM_VAL->rctx)->camera->inv_view_mat3, &x_vec, &x_vec);
 
         gl_state_bind_array_buffer(rend_group->vbo);
         Buffer* buf = (Buffer*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
@@ -1385,7 +1386,7 @@ namespace Glitter {
         if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
             model_mat = rend_group->mat;
             mat4_normalize_rotation(&model_mat, &view_mat);
-            mat4_mult(&view_mat, &GPM_VAL->cam_view, &view_mat);
+            mat4_mult(&view_mat, &((render_context*)GPM_VAL->rctx)->camera->view, &view_mat);
             mat4_inverse(&view_mat, &inv_view_mat);
 
             emitter_local = true;
@@ -1398,8 +1399,8 @@ namespace Glitter {
         }
         else {
             model_mat = mat4_identity;
-            view_mat = GPM_VAL->cam_view;
-            inv_view_mat = GPM_VAL->cam_inv_view;
+            view_mat = ((render_context*)GPM_VAL->rctx)->camera->view;
+            inv_view_mat = ((render_context*)GPM_VAL->rctx)->camera->inv_view;
         }
 
         bool draw_local = false;
@@ -1409,7 +1410,7 @@ namespace Glitter {
             mat4_inverse(&view_mat, &inv_view_mat);
             draw_local = true;
         }
-        mat4_mult(&view_mat, &GPM_VAL->cam_inv_view, &rend_group->mat_draw);
+        mat4_mult(&view_mat, &((render_context*)GPM_VAL->rctx)->camera->inv_view, &rend_group->mat_draw);
 
         mat4 dir_mat = mat4_identity;
         vec3 up_vec = { 0.0f, 0.0f, 1.0f };
@@ -1440,7 +1441,7 @@ namespace Glitter {
             mat4_rotate_x((float_t)-M_PI_2, &dir_mat);
             break;
         case DIRECTION_BILLBOARD_Y_AXIS:
-            mat4_rotate_y(GPM_VAL->cam_rotation_y, &dir_mat);
+            mat4_rotate_y(((render_context*)GPM_VAL->rctx)->camera->rotation.y, &dir_mat);
             break;
         case DIRECTION_EMITTER_ROTATION:
             emitter_rotation = true;
@@ -1514,19 +1515,19 @@ namespace Glitter {
                 object_data->texture_pattern_count = 0;
                 int32_t ttc = 0;
                 texture_transform_struct* tt = object_data->texture_transform_array;
-                for (uint32_t i = 0; i < obj->meshes_count; i++) {
-                    obj_mesh* mesh = &obj->meshes[i];
-                    for (uint32_t j = 0; j < mesh->sub_meshes_count; j++) {
-                        obj_sub_mesh* sub_mesh = &mesh->sub_meshes[j];
-                        obj_material* material = &obj->materials[sub_mesh->material_index].material;
+                for (uint32_t i = 0; i < obj->num_mesh; i++) {
+                    obj_mesh* mesh = &obj->mesh_array[i];
+                    for (uint32_t j = 0; j < mesh->num_submesh; j++) {
+                        obj_sub_mesh* sub_mesh = &mesh->submesh_array[j];
+                        obj_material* material = &obj->material_array[sub_mesh->material_index].material;
 
                         int32_t l = 0;
-                        for (obj_material_texture& k : material->textures) {
-                            obj_material_texture* texture = &k;
-                            if (texture->texture_flags.type != OBJ_MATERIAL_TEXTURE_COLOR)
+                        for (obj_material_texture_data& k : material->texdata) {
+                            obj_material_texture_data* texture = &k;
+                            if (texture->shader_info.m.tex_type != OBJ_MATERIAL_TEXTURE_COLOR)
                                 continue;
 
-                            tt->id = texture->texture_id;
+                            tt->id = texture->tex_index;
                             tt->mat = uv_mat[l];
                             ttc++;
                             tt++;
@@ -1545,7 +1546,7 @@ namespace Glitter {
                 object_data->texture_transform_count = ttc;
 
                 if (rend_group->flags & PARTICLE_LOCAL)
-                    mat4_mult(&mat, &GPM_VAL->cam_inv_view, &mat);
+                    mat4_mult(&mat, &((render_context*)GPM_VAL->rctx)->camera->inv_view, &mat);
 
                 vec4u color = elem->color;
                 if (draw_task_add_draw_object_by_object_info_color(rctx, &mat,
@@ -1576,13 +1577,13 @@ namespace Glitter {
                 mat4_clear_rot(&rend_group->mat, &view_mat);
             else
                 mat4_normalize_rotation(&rend_group->mat, &view_mat);
-            mat4_mult(&view_mat, &GPM_VAL->cam_view, &view_mat);
+            mat4_mult(&view_mat, &((render_context*)GPM_VAL->rctx)->camera->view, &view_mat);
             mat4_inverse(&view_mat, &inv_view_mat);
         }
         else {
             model_mat = mat4_identity;
-            view_mat = GPM_VAL->cam_view;
-            inv_view_mat = GPM_VAL->cam_inv_view;
+            view_mat = ((render_context*)GPM_VAL->rctx)->camera->view;
+            inv_view_mat = ((render_context*)GPM_VAL->rctx)->camera->inv_view;
         }
 
         if (rend_group->flags & PARTICLE_LOCAL) {
@@ -1590,7 +1591,7 @@ namespace Glitter {
             mat4_mult(&view_mat, &inv_view_mat, &view_mat);
             mat4_inverse(&view_mat, &inv_view_mat);
         }
-        mat4_mult(&view_mat, &GPM_VAL->cam_inv_view, &rend_group->mat_draw);
+        mat4_mult(&view_mat, &((render_context*)GPM_VAL->rctx)->camera->inv_view, &rend_group->mat_draw);
 
         switch (rend_group->draw_type) {
         case DIRECTION_BILLBOARD:
@@ -1608,7 +1609,7 @@ namespace Glitter {
             mat4_rotate_x((float_t)-M_PI_2, &dir_mat);
             break;
         case DIRECTION_BILLBOARD_Y_AXIS:
-            mat4_rotate_y(GPM_VAL->cam_rotation_y, &dir_mat);
+            mat4_rotate_y(((render_context*)GPM_VAL->rctx)->camera->rotation.y, &dir_mat);
             break;
         default:
             dir_mat = mat4_identity;
@@ -1760,7 +1761,7 @@ namespace Glitter {
         if (fabsf(rend_group->z_offset) > 0.000001f) {
             use_z_offset = true;
             mat4_get_translation(model_mat, &dist_to_cam);
-            vec3_sub(GPM_VAL->cam_view_point, dist_to_cam, dist_to_cam);
+            vec3_sub(((render_context*)GPM_VAL->rctx)->camera->view_point, dist_to_cam, dist_to_cam);
             if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
                 mat4_normalize_rotation(model_mat, &z_offset_inv_mat);
                 mat4_inverse(&z_offset_inv_mat, &z_offset_inv_mat);
@@ -2153,7 +2154,8 @@ namespace Glitter {
 
         shader_state_material_set_emission(&shaders_ft, false, emission, emission, emission, 1.0f);
         shader_state_matrix_set_mvp_separate(&shaders_ft,
-            &rend_group->mat_draw, &GPM_VAL->cam_view, &GPM_VAL->cam_projection);
+            &rend_group->mat_draw, &((render_context*)GPM_VAL->rctx)->camera->view,
+            &((render_context*)GPM_VAL->rctx)->camera->projection);
         shader_state_matrix_set_texture(&shaders_ft, 0, (mat4*)&mat4_identity);
         shader_state_matrix_set_texture(&shaders_ft, 1, (mat4*)&mat4_identity);
 

src/CRE/auth_3d.cpp

@@ -9,6 +9,7 @@
 #include "../KKdLib/str_utils.h"
 #include "draw_task.h"
 #include "object.hpp"
+#include "rob.hpp"
 
 namespace auth_3d_detail {
     class TaskAuth3d : public Task {
@@ -1187,7 +1188,7 @@ void auth_3d_object::reset() {
     children_object_hrc.shrink_to_fit();
     model_transform.reset();
     morph.reset();
-    object_info = ::object_info();
+    object_info = {};
     object_hash = (uint32_t)-1;
     name.clear();
     name.shrink_to_fit();
@@ -1256,7 +1257,7 @@ void auth_3d_object_hrc::reset() {
         i.reset();
     node.clear();
     node.shrink_to_fit();
-    object_info = ::object_info();
+    object_info = {};
     object_hash = (uint32_t)-1;
     parent_name.clear();
     parent_name.shrink_to_fit();
@@ -1285,7 +1286,7 @@ void auth_3d_object_instance::reset() {
     name.shrink_to_fit();
     object_bone_indices.clear();
     object_bone_indices.shrink_to_fit();
-    object_info = ::object_info();
+    object_info = {};
     object_hash = (uint32_t)-1;
     shadow = false;
     uid_name.clear();
@@ -1366,7 +1367,7 @@ auth_3d_object_texture_transform::~auth_3d_object_texture_transform() {
 }
 
 void auth_3d_object_texture_transform::reset() {
-    flags = (auth_3d_object_texture_transform_flags)0;;
+    flags = (auth_3d_object_texture_transform_flags)0;
     coverage_u.reset();
     coverage_v.reset();
     mat = mat4u_identity;
@@ -2229,10 +2230,6 @@ void auth_3d_data_unload_category(uint32_t category_hash) {
     auth_3d_data_struct_unload_category(auth_3d_data, category_hash);
 }
 
-void task_auth_3d_append_task() {
-    TaskWork::AppendTask(&task_auth_3d, "AUTH_3D");
-}
-
 void auth_3d_data_unload_id(int32_t id, render_context* rctx) {
     if (id < 0 || (id & 0x7FFF) >= AUTH_3D_DATA_COUNT)
         return;
@@ -2257,6 +2254,14 @@ void auth_3d_data_free() {
     delete auth_3d_data;
 }
 
+void task_auth_3d_append_task() {
+    TaskWork::AppendTask(&task_auth_3d, "AUTH_3D");
+}
+
+void task_auth_3d_free_task() {
+    task_auth_3d.SetDest();
+}
+
 auth_3d_detail::TaskAuth3d::TaskAuth3d() {
 
 }
@@ -3324,7 +3329,7 @@ static void auth_3d_material_list_load(auth_3d* auth, auth_3d_material_list* ml,
 static void auth_3d_material_list_restore_prev_value(auth_3d_material_list* ml) {
     if (ml->flags_init & AUTH_3D_MATERIAL_LIST_INCANDESCENCE) {
         if (ml->material)
-            ml->material->emission = ml->incandescence_init;
+            ml->material->color.emission = ml->incandescence_init;
     }
     material_change_storage_unload(ml->name.c_str());
 }
@@ -3350,7 +3355,7 @@ static void auth_3d_material_list_set(auth_3d_material_list* ml) {
     if (ml->flags & AUTH_3D_MATERIAL_LIST_INCANDESCENCE) {
         if (~ml->flags_init & AUTH_3D_MATERIAL_LIST_INCANDESCENCE) {
             if (ml->material)
-                ml->incandescence_init = ml->material->emission;
+                ml->incandescence_init = ml->material->color.emission;
             else
                 ml->incandescence_init = vec4_identity;
             enum_or(ml->flags_init, AUTH_3D_MATERIAL_LIST_INCANDESCENCE);
@@ -3366,7 +3371,7 @@ static void auth_3d_material_list_set(auth_3d_material_list* ml) {
         if (ml->incandescence.flags & AUTH_3D_RGBA_A)
             incandescence.w = ml->incandescence.value.w;
         if (ml->material)
-            ml->material->emission = incandescence;
+            ml->material->color.emission = incandescence;
     }
 
     material_change* mat_chg = material_change_storage_get(ml->name.c_str());
@@ -3446,15 +3451,33 @@ static void auth_3d_object_curve_load(auth_3d* auth, auth_3d_object_curve* oc,
 }
 
 static void auth_3d_object_disp(auth_3d_object* o, auth_3d* auth, render_context* rctx) {
-    if (!auth->visible || !o->model_transform.visible)
+    if (!o->model_transform.visible)
         return;
 
+    if (!auth->visible) {
+        for (auth_3d_object*& i : o->children_object)
+            auth_3d_object_disp(i, auth, rctx);
+        for (auth_3d_object_hrc*& i : o->children_object_hrc)
+            auth_3d_object_hrc_disp(i, auth, rctx);
+        return;
+    }
+
     mat4 mat = o->model_transform.mat;
 
     object_data* object_data = &rctx->object_data;
     object_database* obj_db = auth->obj_db;
     texture_database* tex_db = auth->tex_db;
 
+    if (auth->chara_id >= 0 && auth->chara_id < ROB_CHARA_COUNT)
+        if (rob_chara_pv_data_array_check_chara_id(auth->chara_id)) {
+            rob_chara* rob_chr = rob_chara_array_get(auth->chara_id);
+            mat4 m;
+            mat4_mult(&rob_chr->data.miku_rot.field_6C,
+                &rob_chr->data.adjust_data.mat, (mat4u*)&m);
+            mat4_mult(&m, &mat, &mat);
+            object_data->set_shadow_type(auth->chara_id ? SHADOW_STAGE : SHADOW_CHARA);
+        }
+
     draw_task_flags flags = (draw_task_flags)0;
     if (auth->shadow)
         enum_or(flags, DRAW_TASK_4 | DRAW_TASK_SHADOW);
@@ -3642,11 +3665,20 @@ static void auth_3d_object_hrc_disp(auth_3d_object_hrc* oh, auth_3d* auth, rende
     if (auth->alpha < 1.0f)
         enum_or(flags, auth->draw_task_flags);
 
-    object_data->set_draw_task_flags((draw_task_flags)flags);
+    object_data->set_draw_task_flags(flags);
     object_data->set_shadow_type(SHADOW_CHARA);
 
-    shadow* shad = rctx->draw_pass.shadow_ptr;
-    if (shad && flags & DRAW_TASK_SHADOW) {
+    mat4 mat = mat4_identity;
+    if (auth->chara_id >= 0 && auth->chara_id < ROB_CHARA_COUNT) {
+        if (rob_chara_pv_data_array_check_chara_id(auth->chara_id)) {
+            rob_chara* rob_chr = rob_chara_array_get(auth->chara_id);
+            mat4_mult(&rob_chr->data.miku_rot.field_6C,
+                &rob_chr->data.adjust_data.mat, (mat4u*)&mat);
+            if (auth->chara_id)
+                object_data->set_shadow_type(SHADOW_STAGE);
+        }
+    }
+    else if (flags & DRAW_TASK_SHADOW) {
         object_data->set_shadow_type(SHADOW_STAGE);
 
         mat4u* m = &oh->node[0].model_transform.mat;
@@ -3656,16 +3688,17 @@ static void auth_3d_object_hrc_disp(auth_3d_object_hrc* oh, auth_3d* auth, rende
                 break;
             }
 
-        vec3 pos = *(vec3*)&m->row3;
-        pos.y -= 0.2f;
-        shad->field_1D0[SHADOW_STAGE].push_back(pos);
+        shadow* shad = rctx->draw_pass.shadow_ptr;
+        if (shad) {
+            vec3 pos = *(vec3*)&m->row3;
+            pos.y -= 0.2f;
+            shad->field_1D0[SHADOW_STAGE].push_back(pos);
+        }
     }
 
-    if (oh->mats.size() > 0) {
-        mat4 mat = mat4_identity;
+    if (oh->mats.size() > 0)
         draw_task_add_draw_object_by_object_info_object_skin(rctx,
             oh->object_info, 0, 0, auth->alpha, oh->mats.data(), 0, 0, &mat);
-    }
 
     object_data->set_draw_task_flags();
     object_data->set_shadow_type(SHADOW_CHARA);
@@ -4276,7 +4309,8 @@ static void auth_3d_data_struct_unload_category(
         return;
 
     auth_3d_farc_unload(&elem->second);
-    auth_3d_data->farcs_modern.erase(elem);
+    if (elem->second.load_count <= 0)
+        auth_3d_data->farcs_modern.erase(elem);
 }
 
 static void auth_3d_farc_free_data(auth_3d_farc* a3da_farc) {
@@ -4330,7 +4364,7 @@ static void auth_3d_farc_read_file(auth_3d_farc* a3da_farc, const char* mdata_di
     a3da_farc->file = a3da_farc->name + ".farc";
 
     if (a3da_farc->file_handler.read_file(rctx_ptr->data, a3da_farc->path.c_str(), a3da_farc->file.c_str()))
-        a3da_farc->file_handler.set_read_free_func_data(0,
+        a3da_farc->file_handler.set_callback_data(0,
             (void(*)(void*, void*, size_t))auth_3d_farc_read_func, a3da_farc);
     else
         a3da_farc->state = 2;
@@ -4347,7 +4381,7 @@ static void auth_3d_farc_read_file_modern(auth_3d_farc* a3da_farc, void* data) {
     a3da_farc->file = a3da_farc->name + ".farc";
 
     if (a3da_farc->file_handler.read_file(data, a3da_farc->path.c_str(), a3da_farc->file.c_str()))
-        a3da_farc->file_handler.set_read_free_func_data(0,
+        a3da_farc->file_handler.set_callback_data(0,
             (void(*)(void*, void*, size_t))auth_3d_farc_read_func, a3da_farc);
     else
         a3da_farc->state = 2;

src/CRE/auth_3d.hpp

@@ -747,7 +747,7 @@ struct auth_3d_farc {
     size_t size;
 
     auth_3d_farc();
-    ~auth_3d_farc();
+    virtual ~auth_3d_farc();
 };
 
 struct auth_3d_uid_file {
@@ -839,3 +839,4 @@ extern void auth_3d_data_unload_id(int32_t id, render_context* rctx);
 extern void auth_3d_data_free();
 
 extern void task_auth_3d_append_task();
+extern void task_auth_3d_free_task();

src/CRE/draw_pass.c

@@ -211,7 +211,7 @@ static void draw_pass_shadow(render_context* rctx, draw_pass* a1) {
             glScissor(1, 1, tex->width - 2, tex->height - 2);
 
             float_t v15 = 0.0f;
-            float_t v16 = shad->field_170 * shad->field_174;
+            float_t v16 = shad->view_region * shad->range;
             vec3* interest;
             vec3* view_point;
             if (shad->field_2F5) {
@@ -992,7 +992,7 @@ static void draw_pass_3d_shadow_set(shadow* shad, render_context* rctx) {
         rctx->draw_state.light = true;
         uniform_value[U_LIGHT_1] = shad->field_2EC > 1 ? 1 : 0;
 
-        float_t v7 = shad->field_170 * shad->field_174;
+        float_t v7 = shad->view_region * shad->range;
         for (int32_t i = 0; i < 2; i++) {
             float_t v6 = 0.0f;
             vec3* interest;

src/CRE/draw_task.c

@@ -285,16 +285,16 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
     }
     object_data->passed.objects++;
 
-    for (uint32_t i = 0; i < object->meshes_count; i++) {
-        obj_mesh* mesh = &object->meshes[i];
+    for (uint32_t i = 0; i < object->num_mesh; i++) {
+        obj_mesh* mesh = &object->mesh_array[i];
         obj_mesh* mesh_morph = 0;
         if (obj_vertex_buf && obj_morph_vertex_buf) {
             if (obj_mesh_vertex_buffer_get_size(&obj_vertex_buf[i])
                 != obj_mesh_vertex_buffer_get_size(&obj_morph_vertex_buf[i]))
                 continue;
 
-            if (object_morph && i < object_morph->meshes_count)
-                mesh_morph = &object_morph->meshes[i];
+            if (object_morph && i < object_morph->num_mesh)
+                mesh_morph = &object_morph->mesh_array[i];
         }
 
         if (object_data->object_culling && !instances_count && !bone_mat
@@ -309,17 +309,16 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
         draw_object* translucent_priority[40];
         int32_t translucent_priority_count = 0;
 
-        for (uint32_t j = 0; j < mesh->sub_meshes_count; j++) {
-            obj_sub_mesh* sub_mesh = &mesh->sub_meshes[j];
+        for (uint32_t j = 0; j < mesh->num_submesh; j++) {
+            obj_sub_mesh* sub_mesh = &mesh->submesh_array[j];
             obj_sub_mesh* sub_mesh_morph = 0;
-            if (sub_mesh->flags & OBJ_SUB_MESH_FLAG_8)
+            if (sub_mesh->attrib.m.flag_3)
                 continue;
 
             if (object_data->object_culling && !instances_count && !bone_mat) {
                 int32_t v32 = object_bounding_sphere_check_visibility(
                     &sub_mesh->bounding_sphere, object_data, rctx->camera, mat);
-                if (v32 != 2 || (~mesh->flags & OBJ_MESH_BILLBOARD &&
-                    ~mesh->flags & OBJ_MESH_BILLBOARD_Y_AXIS)) {
+                if (v32 != 2 || (!mesh->attrib.m.billboard && !mesh->attrib.m.billboard_y_axis)) {
                     if (v32 == 2) {
                         if (object_data->object_bounding_sphere_check_func)
                             v32 = 1;
@@ -329,14 +328,14 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
                     }
 
                     if (!v32) {
-                        if (!mesh_morph || j >= mesh_morph->sub_meshes_count) {
-                            object_data->culled.sub_meshes++;
+                        if (!mesh_morph || j >= mesh_morph->num_submesh) {
+                            object_data->culled.submesh_array++;
                             continue;
                         }
 
-                        sub_mesh_morph = &mesh_morph->sub_meshes[j];
+                        sub_mesh_morph = &mesh_morph->submesh_array[j];
                         if (!sub_mesh_morph) {
-                            object_data->culled.sub_meshes++;
+                            object_data->culled.submesh_array++;
                             continue;
                         }
 
@@ -351,13 +350,13 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
                         }
 
                         if (!v32) {
-                            object_data->culled.sub_meshes++;
+                            object_data->culled.submesh_array++;
                             continue;
                         }
                     }
                 }
             }
-            object_data->passed.sub_meshes++;
+            object_data->passed.submesh_array++;
 
             int32_t bone_indices_count = sub_mesh->bone_indices_count;
             uint16_t* bone_indices = sub_mesh->bone_indices;
@@ -377,7 +376,7 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
                 bone_indices_count = 0;
             }
 
-            obj_material_data* material = &object->materials[sub_mesh->material_index];
+            obj_material_data* material = &object->material_array[sub_mesh->material_index];
             draw_task* task = rctx->object_data.buffer.add_draw_task(DRAW_TASK_TYPE_OBJECT);
             if (!task)
                 continue;
@@ -412,14 +411,14 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
                 continue;
             }
 
-            obj_material_blend_flags blend_flags = material->material.blend_flags;
+            obj_material_attrib_member attrib = material->material.attrib.m;
             if (draw_task_flags & (DRAW_TASK_10000 | DRAW_TASK_20000 | DRAW_TASK_40000)
                 && task->data.object.blend_color.w < 1.0f) {
                 if (~draw_task_flags | DRAW_TASK_NO_TRANSLUCENCY) {
-                    if (blend_flags.flag_28 || (blend_flags.punch_through
-                        || !(blend_flags.alpha_texture | blend_flags.alpha_material))
-                        && ~sub_mesh->flags & OBJ_SUB_MESH_TRANSPARENT) {
-                        if (!blend_flags.punch_through) {
+                    if (attrib.flag_28 || (attrib.punch_through
+                        || !(attrib.alpha_texture | attrib.alpha_material))
+                        && !sub_mesh->attrib.m.transparent) {
+                        if (!attrib.punch_through) {
                             if (draw_task_flags & DRAW_TASK_10000)
                                 draw_task_add(rctx, DRAW_OBJECT_OPAQUE_TYPE_20, task);
                             else if (draw_task_flags & DRAW_TASK_20000)
@@ -449,9 +448,9 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
                 }
             }
             else {
-                if (blend_flags.flag_28 || task->data.object.blend_color.w >= 1.0f
-                    && (blend_flags.punch_through || !(blend_flags.alpha_texture | blend_flags.alpha_material))
-                    && ~sub_mesh->flags & OBJ_SUB_MESH_TRANSPARENT) {
+                if (attrib.flag_28 || task->data.object.blend_color.w >= 1.0f
+                    && (attrib.punch_through || !(attrib.alpha_texture | attrib.alpha_material))
+                    && !sub_mesh->attrib.m.transparent) {
                     if (draw_task_flags & DRAW_TASK_SHADOW)
                         draw_task_add(rctx, (draw_object_type)(DRAW_OBJECT_SHADOW_CHARA
                             + object_data->shadow_type), task);
@@ -459,7 +458,7 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
                     if (draw_task_flags & DRAW_TASK_SSS)
                         draw_task_add(rctx, DRAW_OBJECT_SSS, task);
 
-                    if (material->material.blend_flags.punch_through) {
+                    if (material->material.attrib.m.punch_through) {
                         if (~draw_task_flags & DRAW_TASK_NO_TRANSLUCENCY)
                             draw_task_add(rctx, DRAW_OBJECT_TRANSPARENT, task);
 
@@ -494,8 +493,8 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
                     continue;
                 }
                 else if (~draw_task_flags & DRAW_TASK_NO_TRANSLUCENCY) {
-                    if (!blend_flags.translucent_priority)
-                        if (mesh->flags & OBJ_MESH_TRANSLUCENT_NO_SHADOW
+                    if (!attrib.translucent_priority)
+                        if (mesh->attrib.m.translucent_no_shadow
                             || draw_task_flags & DRAW_TASK_TRANSLUCENT_NO_SHADOW)
                             draw_task_add(rctx, DRAW_OBJECT_TRANSLUCENT_NO_SHADOW, task);
                         else
@@ -532,7 +531,7 @@ bool draw_task_add_draw_object(render_context* rctx, obj* object,
         for (int32_t j = 62; j; j--)
             for (int32_t k = 0; k < translucent_priority_count; k++) {
                 draw_object* object = translucent_priority[k];
-                if (object->material->material.blend_flags.translucent_priority != j)
+                if (object->material->material.attrib.m.translucent_priority != j)
                     continue;
 
                 object_translucent.objects[object_translucent.count] = object;
@@ -682,10 +681,9 @@ void draw_task_sort(render_context* rctx, draw_object_type type, int32_t compare
         vec3 center;
         mat4_get_translation(&mat, &center);
         if (task->type == DRAW_TASK_TYPE_OBJECT) {
-            obj_mesh_flags mesh_flags = task->data.object.mesh->flags;
-            if (mesh_flags & OBJ_MESH_BILLBOARD) {
+            if (task->data.object.mesh->attrib.m.billboard) {
                 model_mat_face_camera_view(&rctx->camera->view, &mat, &mat);}
-            else if (mesh_flags & OBJ_MESH_BILLBOARD_Y_AXIS)
+            else if (task->data.object.mesh->attrib.m.billboard_y_axis)
                 model_mat_face_camera_position(&rctx->camera->view, &mat, &mat);
             else {
                 obj_sub_mesh* sub_mesh = task->data.object.sub_mesh;

src/CRE/fbo.cpp

@@ -6,12 +6,13 @@
 #include "fbo.hpp"
 #include "gl_state.h"
 
-fbo::fbo() {
+fbo::fbo() : flags(), width(), height(), buffer(), count(), textures() {
 
 }
 
 fbo::fbo(int32_t width, int32_t height,
-    GLuint* color_textures, int32_t count, GLuint depth_texture) : fbo() {
+    GLuint* color_textures, int32_t count, GLuint depth_texture) : flags(),
+    width(), height(), buffer(), count(), textures() {
     if (buffer) {
         glDeleteFramebuffers(1, &buffer);
         buffer = 0;
@@ -56,8 +57,11 @@ fbo::~fbo() {
         glDeleteFramebuffers(1, &buffer);
         buffer = 0;
     }
-    free(textures);
-    textures = 0;
+
+    if (textures) {
+        free(textures);
+        textures = 0;
+    }
 }
 
 void fbo::blit(GLuint src_fbo, GLuint dst_fbo,

src/CRE/file_handler.cpp

@@ -51,7 +51,7 @@ static void file_handler_storage_ctrl_list();
 static void file_handler_storage_thread_ctrl();
 
 file_handler::file_handler() : count(), not_ready(true),
-reading(), cache(), read_free_func(), size(), data(), ds() {
+reading(), cache(), callback(), size(), data(), ds() {
 
 }
 
@@ -59,20 +59,20 @@ file_handler::~file_handler() {
     free(data);
 }
 
-void file_handler::call_read_free_func(int32_t index) {
+void file_handler::call_callback(int32_t index) {
     if (index >= 2)
         return;
 
     std::unique_lock<std::mutex> u_lock(mtx);
     void* data = this->data;
-    void(*read_free_func_func)(void*, void*, size_t) = this->read_free_func[index].func;
-    void* read_free_func_data = this->read_free_func[index].data;
-    bool ready = this->read_free_func[index].ready;
-    this->read_free_func[index].ready = true;
+    void(*callback_func)(void*, void*, size_t) = this->callback[index].func;
+    void* callback_data = this->callback[index].data;
+    bool ready = this->callback[index].ready;
+    this->callback[index].ready = true;
     u_lock.unlock();
 
-    if (!ready && read_free_func_func)
-        read_free_func_func(read_free_func_data, data, this->size);
+    if (!ready && callback_func)
+        callback_func(callback_data, data, this->size);
 }
 
 void file_handler::set_file(const char* file) {
@@ -94,12 +94,12 @@ void file_handler::set_path(const char* path) {
     u_lock.unlock();
 }
 
-void file_handler::set_read_free_func_data(int32_t index, void(* func)(void*, void*, size_t), void* data) {
+void file_handler::set_callback_data(int32_t index, void(* func)(void*, void*, size_t), void* data) {
     std::unique_lock<std::mutex> u_lock(mtx);
     if (index < 2) {
-        read_free_func[index].func = func;
-        read_free_func[index].data = data;
-        read_free_func[index].ready = false;
+        callback[index].func = func;
+        callback[index].data = data;
+        callback[index].ready = false;
     }
     u_lock.unlock();
 }
@@ -287,8 +287,8 @@ static void file_handler_storage_ctrl_list() {
             i = file_handler_storage_data->list.erase(i);
         }
         else {
-            if (!pfhndl->not_ready && !pfhndl->read_free_func[0].ready)
-                pfhndl->call_read_free_func(0);
+            if (!pfhndl->not_ready && !pfhndl->callback[0].ready)
+                pfhndl->call_callback(0);
             i++;
         }
     }
@@ -339,7 +339,7 @@ p_file_handler::~p_file_handler() {
 
 void p_file_handler::call_free_func_free_data() {
     if (ptr)
-        ptr->call_read_free_func(1);
+        ptr->call_callback(1);
     free_data();
 }
 
@@ -349,7 +349,7 @@ bool p_file_handler::check_not_ready() {
     else if (ptr->not_ready)
         return true;
     else
-        return !ptr->read_free_func[0].ready;
+        return !ptr->callback[0].ready;
 }
 
 void p_file_handler::free_data() {
@@ -358,7 +358,7 @@ void p_file_handler::free_data() {
 
     if (ptr->mtx.try_lock()) {
         for (int32_t i = 0; i < 2; i++)
-            ptr->read_free_func[i] = {};
+            ptr->callback[i] = {};
         ptr->mtx.unlock();
     }
     ptr->free_data_lock();
@@ -479,7 +479,7 @@ void p_file_handler::read_now() {
     }
 }
 
-void p_file_handler::set_read_free_func_data(int32_t index, void(*func)(void*, void*, size_t), void* data) {
+void p_file_handler::set_callback_data(int32_t index, void(*func)(void*, void*, size_t), void* data) {
     if (ptr)
-        ptr->set_read_free_func_data(index, func, data);
+        ptr->set_callback_data(index, func, data);
 }

src/CRE/file_handler.hpp

@@ -28,7 +28,7 @@ struct file_handler {
     std::string farc_file;
     std::string file;
     bool cache;
-    file_handler_read_func_data read_free_func[2];
+    file_handler_read_func_data callback[2];
     ssize_t size;
     void* data;
     void* ds;
@@ -36,12 +36,12 @@ struct file_handler {
     file_handler();
     virtual ~file_handler();
 
-    void call_read_free_func(int32_t index);
+    void call_callback(int32_t index);
     void free_data_lock();
     void set_file(const char* file);
     void set_farc_file(const char* farc_file, bool cache);
     void set_path(const char* path);
-    void set_read_free_func_data(int32_t index, void(*func)(void*, void*, size_t), void* data);
+    void set_callback_data(int32_t index, void(*func)(void*, void*, size_t), void* data);
 };
 
 struct p_file_handler {
@@ -59,7 +59,7 @@ struct p_file_handler {
     bool read_file(void* data, const char* path, const char* file);
     bool read_file(void* data, const char* path, uint32_t hash, const char* ext);
     void read_now();
-    void set_read_free_func_data(int32_t index, void(* func)(void*, void*, size_t), void* data);
+    void set_callback_data(int32_t index, void(* func)(void*, void*, size_t), void* data);
 };
 
 extern void file_handler_storage_init();

src/CRE/item_table.cpp

@@ -59,14 +59,9 @@ bool item_table_array_load_file(void* data, const char* path, const char* file,
     if (t)
         file_len = t - file;
 
-    string s;
-    string_init(&s, path);
-    string_add_length(&s, file, file_len);
+    std::string s = path + std::string(file, file_len);
 
-    bool ret = item_table_array_read((data_struct*)data, string_data(&s));
-
-    string_free(&s);
-    return ret;
+    return item_table_array_read((data_struct*)data, s.c_str());
 }
 
 void item_table_array_free() {

src/CRE/light_param.cpp

@@ -20,7 +20,10 @@ static void light_param_storage_load_stages(light_param_data_storage* a1, std::v
 static void light_param_storage_load_stages(light_param_data_storage* a1,
     std::vector<uint32_t>* stage_hashes, stage_database* stage_data);
 static int32_t light_param_storage_load_file(light_param_data_storage* a1, bool read_now);
+static void light_param_storage_reset(light_param_data_storage* a1);
 static void light_param_storage_set_default_light_param(light_param_data_storage* a1, int32_t stage_index);
+static void light_param_storage_set_pv_cut(light_param_data_storage* a1,
+    std::map<int32_t, light_param_data>::iterator* elem, int32_t cut_id);
 static void light_param_storage_set_stage(light_param_data_storage* a1,
     std::map<int32_t, light_param_data>::iterator* elem, int32_t stage_index);
 
@@ -28,7 +31,7 @@ light_param_data_storage* light_param_data_storage_data;
 
 extern render_context* rctx_ptr;
 
-light_param_data::light_param_data() : not_loaded() {
+light_param_data::light_param_data() : pv() {
 
 }
 
@@ -37,7 +40,7 @@ light_param_data::~light_param_data() {
 }
 
 int32_t light_param_data_load_file() {
-    return light_param_storage_load_file(light_param_data_storage_data, 0);
+    return light_param_storage_load_file(light_param_data_storage_data, false);
 }
 
 light_param_data_storage::light_param_data_storage() :  textures(),
@@ -52,7 +55,7 @@ light_param_data_storage::~light_param_data_storage() {
 void light_param_data_storage::load(data_struct* data) {
     glGenTextures(5, light_param_data_storage_data->textures);
     light_param_storage_data_load_stage(0);
-    while (light_param_storage_load_file(light_param_data_storage_data, 1));
+    while (light_param_storage_load_file(light_param_data_storage_data, true));
     light_param_storage_set_default_light_param(light_param_data_storage_data, 0);
 }
 
@@ -92,10 +95,23 @@ void light_param_storage_data_load_stages(
     light_param_storage_load_stages(light_param_data_storage_data, stage_hashes, stage_data);
 }
 
+void light_param_storage_data_reset() {
+    light_param_storage_reset(light_param_data_storage_data);
+}
+
 void light_param_storage_data_set_default_light_param() {
     light_param_data_set(&light_param_data_storage_data->default_light_param, light_param_data_storage_data);
 }
 
+void light_param_storage_data_set_pv_id(int32_t pv_id) {
+    light_param_data_storage_data->pv_id = pv_id;
+}
+
+void light_param_storage_data_set_pv_cut(int32_t cut_id) {
+    std::map<int32_t, light_param_data>::iterator elem;
+    light_param_storage_set_pv_cut(light_param_data_storage_data, &elem, cut_id);
+}
+
 void light_param_storage_data_set_stage(int32_t stage_id) {
     std::map<int32_t, light_param_data>::iterator elem;
     light_param_storage_set_stage(light_param_data_storage_data, &elem, stage_id);
@@ -172,7 +188,7 @@ static int32_t light_param_storage_load_file(light_param_data_storage* a1, bool
 
 static void light_param_data_get_stage_name_string(std::string* str, int32_t stage_index) {
     str->clear();
-    str->shrink_to_fit();;
+    str->shrink_to_fit();
     stage_database* data = &rctx_ptr->data->data_ft.stage_data;
     const char* stage_name = stage_index < data->stage_data.size()
         ? data->stage_data[stage_index].name.c_str() : 0;
@@ -207,7 +223,7 @@ static void light_param_data_get_stage_name_string(std::string* str, int32_t sta
 static void light_param_data_get_stage_name_string(std::string* str,
     uint32_t stage_hash, stage_database* stage_data) {
     str->clear();
-    str->shrink_to_fit();;
+    str->shrink_to_fit();
     const char* stage_name = 0;
     for (stage_data_modern& i : stage_data->stage_modern) {
         if (i.hash != stage_hash)
@@ -386,7 +402,14 @@ static void light_param_data_load_file_pv_cut(std::map<int32_t, light_param_data
         if (elem != tree->end())
             light_param = &elem->second;
         else {
-            light_param = &tree->insert({ cut_id, *default_light_param }).first->second;;
+            light_param = &tree->insert({ cut_id, *default_light_param }).first->second;
+            light_param->ibl.ready = false;
+            light_param->light.ready = false;
+            light_param->fog.ready = false;
+            light_param->glow.ready = false;
+            light_param->wind.ready = false;
+            light_param->face.ready = false;
+            light_param->pv = true;
             light_param_data_load_pv_cut_file_names(light_param, cut_id, &pv_str);
         }
 
@@ -500,10 +523,10 @@ static void light_param_storage_load_stages(light_param_data_storage* a1, std::v
         if (elem != a1->stage.end())
             light_param = &elem->second;
         else
-            light_param = &a1->stage.insert({ i, a1->default_light_param }).first->second;;
+            light_param = &a1->stage.insert({ i, a1->default_light_param }).first->second;
 
         light_param_data_load_stage_file_names(light_param, &name);
-        light_param->not_loaded = 0;
+        light_param->pv = false;
     }
     a1->stage_light_param_iterator = a1->stage.begin();
     a1->state = a1->stage.size() ? 1 : 0;
@@ -533,15 +556,24 @@ static void light_param_storage_load_stages(light_param_data_storage* a1,
         if (elem != a1->stage.end())
             light_param = &elem->second;
         else
-            light_param = &a1->stage.insert({ i, a1->default_light_param }).first->second;;
+            light_param = &a1->stage.insert({ i, a1->default_light_param }).first->second;
 
         light_param_data_load_stage_file_names(light_param, &name);
-        light_param->not_loaded = 0;
+        light_param->pv = false;
     }
     a1->stage_light_param_iterator = a1->stage.begin();
     a1->state = a1->stage.size() ? 1 : 0;
 }
 
+static void light_param_storage_reset(light_param_data_storage* a1) {
+    a1->stage.clear();
+    a1->pv_cut.clear();
+    a1->pv_id = 0;
+    for (p_file_handler& i : a1->file_handlers)
+        i.free_data();
+    a1->farc_file_handler.free_data();
+}
+
 static void light_param_storage_set_default_light_param(light_param_data_storage* a1, int32_t stage_index) {
     std::map<int32_t, light_param_data>::iterator elem;
     light_param_storage_set_stage(a1, &elem, stage_index);
@@ -550,30 +582,34 @@ static void light_param_storage_set_default_light_param(light_param_data_storage
 }
 
 static void light_param_data_set(light_param_data* a1, light_param_data_storage* storage) {
-    if (!a1->not_loaded || a1->light.ready)
+    if (!a1->pv || a1->light.ready)
         rctx_ptr->light_param_data_light_set(&a1->light);
-    if (!a1->not_loaded || a1->fog.ready)
+    if (!a1->pv || a1->fog.ready)
         rctx_ptr->light_param_data_fog_set(&a1->fog);
-    if (!a1->not_loaded || a1->glow.ready)
+    if (!a1->pv || a1->glow.ready)
         rctx_ptr->light_param_data_glow_set(&a1->glow);
-    if (!a1->not_loaded || a1->ibl.ready)
+    if (!a1->pv || a1->ibl.ready)
         rctx_ptr->light_param_data_ibl_set(&a1->ibl, storage);
-    if (!a1->not_loaded) {
+    if (!a1->pv) {
         rctx_ptr->light_param_data_wind_set(&a1->wind);
         if (a1->face.ready)
             rctx_ptr->light_param_data_face_set(&a1->face);
     }
 }
 
+static void light_param_storage_set_pv_cut(light_param_data_storage* a1,
+    std::map<int32_t, light_param_data>::iterator* elem, int32_t cut_id) {
+    *elem = a1->pv_cut.find(cut_id);
+    if (*elem != a1->pv_cut.end())
+        light_param_data_set(&(*elem)->second, a1);
+}
+
 static void light_param_storage_set_stage(light_param_data_storage* a1,
     std::map<int32_t, light_param_data>::iterator* elem, int32_t stage_index) {
-    *elem = a1->stage.begin();
-    if (a1->state == 0) {
-        *elem = a1->stage.find(stage_index);
-        if (*elem != a1->stage.end()) {
-            a1->stage_index = stage_index;
-            a1->name = (*elem)->second.name;
-            light_param_data_set(&(*elem)->second, a1);
-        }
+    *elem = a1->stage.find(stage_index);
+    if (*elem != a1->stage.end()) {
+        a1->stage_index = stage_index;
+        a1->name = (*elem)->second.name;
+        light_param_data_set(&(*elem)->second, a1);
     }
 }

src/CRE/light_param.hpp

@@ -25,7 +25,7 @@ struct light_param_data {
     std::string name;
     std::string paths[6];
     std::string files[6];
-    bool not_loaded;
+    bool pv;
     light_param_light light;
     light_param_fog fog;
     light_param_glow glow;
@@ -66,6 +66,9 @@ extern void light_param_storage_data_load_stage(uint32_t stage_hash, stage_datab
 extern void light_param_storage_data_load_stages(std::vector<int32_t>* stage_indices);
 extern void light_param_storage_data_load_stages(
     std::vector<uint32_t>* stage_hashes, stage_database* stage_data);
+extern void light_param_storage_data_reset();
 extern void light_param_storage_data_set_default_light_param();
+extern void light_param_storage_data_set_pv_id(int32_t pv_id);
+extern void light_param_storage_data_set_pv_cut(int32_t cut_id);
 extern void light_param_storage_data_set_stage(int32_t stage_id);
 extern void light_param_storage_data_free();

src/CRE/light_param/light.c

@@ -242,14 +242,16 @@ void light_set_data_set(light_set* set, face* face, light_set_id id) {
         }
         else
             shader_state_light_set_ambient(&shaders_ft, i, 0.0f, 0.0f, 0.0f, 1.0f);
+
         vec4 diffuse = light->diffuse;
         vec4 specular = light->specular;
         shader_state_light_set_diffuse_ptr(&shaders_ft, i, &diffuse);
         shader_state_light_set_specular_ptr(&shaders_ft, i, &specular);
 
-        vec4 light_direction = light->position;
-        light_get_direction_from_position(&light_direction, light, 0);
-        shader_state_light_set_position_ptr(&shaders_ft, i, &light_direction);
+        vec4 light_position = light->position;
+        if (light->type == LIGHT_PARALLEL)
+            light_get_direction_from_position(&light_position, 0, true);
+        shader_state_light_set_position_ptr(&shaders_ft, i, &light_position);
 
         shader_state_light_set_attenuation(&shaders_ft, i,
             light->constant, light->linear, light->quadratic, light->spot_exponent);
@@ -271,7 +273,7 @@ void light_set_data_set(light_set* set, face* face, light_set_id id) {
     vec4 ibl_direction;
     vec4 temp;
     light_get_position_vec4(&set->lights[LIGHT_CHARA], &position);
-    light_get_direction_from_position(&position, &set->lights[LIGHT_CHARA], 0);
+    light_get_direction_from_position(&position, &set->lights[LIGHT_CHARA], false);
     light_get_ibl_specular(&set->lights[LIGHT_CHARA], &ibl_specular);
     light_get_ibl_back(&set->lights[LIGHT_CHARA], &ibl_back);
     light_get_diffuse(&set->lights[LIGHT_CHARA], &diffuse);
@@ -299,7 +301,7 @@ void light_set_data_set(light_set* set, face* face, light_set_id id) {
     shader_env_frag_set_ptr(&shaders_ft, 9, &temp);
 
     light_get_position_vec4(&set->lights[LIGHT_STAGE], &position);
-    light_get_direction_from_position(&position, &set->lights[LIGHT_STAGE], 0);
+    light_get_direction_from_position(&position, &set->lights[LIGHT_STAGE], false);
     light_get_ibl_specular(&set->lights[LIGHT_STAGE], &ibl_specular);
     light_get_diffuse(&set->lights[LIGHT_STAGE], &diffuse);
     light_get_specular(&set->lights[LIGHT_STAGE], &specular);
@@ -348,7 +350,7 @@ void light_set_data_set(light_set* set, face* face, light_set_id id) {
     if (light_get_type(&set->lights[LIGHT_TONE_CURVE]) == LIGHT_PARALLEL) {
         uniform_value[U_TONE_CURVE] = 1;
         light_get_position_vec4(&set->lights[LIGHT_TONE_CURVE], &position);
-        light_get_direction_from_position(&position, &set->lights[LIGHT_TONE_CURVE], 0);
+        light_get_direction_from_position(&position, &set->lights[LIGHT_TONE_CURVE], false);
         light_get_ambient(&set->lights[LIGHT_TONE_CURVE], &ambient);
         light_get_diffuse(&set->lights[LIGHT_TONE_CURVE], &diffuse);
         light_get_specular(&set->lights[LIGHT_TONE_CURVE], &specular);
@@ -392,7 +394,7 @@ void light_set_data_set(light_set* set, face* face, light_set_id id) {
         vec4 spot_direction;
         light_get_spot_direction(&set->lights[LIGHT_REFLECT], (vec3*)&spot_direction);
         vec3_negate(*(vec3*)&spot_direction, *(vec3*)&spot_direction);
-        light_get_direction_from_position(&spot_direction, &set->lights[LIGHT_REFLECT], 1);
+        light_get_direction_from_position(&spot_direction, &set->lights[LIGHT_REFLECT], true);
         light_get_position_vec4(&set->lights[LIGHT_REFLECT], &position);
         vec3_dot(*(vec3*)&position, *(vec3*)&spot_direction, spot_direction.w);
         spot_direction.w = -spot_direction.w;

src/CRE/object.hpp

@@ -33,13 +33,13 @@ struct obj_mesh_vertex_buffer {
 };
 
 struct obj_index_buffer {
-    uint32_t meshes_count;
-    obj_mesh_index_buffer* meshes;
+    uint32_t mesh_num;
+    obj_mesh_index_buffer* mesh_data;
 };
 
 struct obj_vertex_buffer {
-    uint32_t meshes_count;
-    obj_mesh_vertex_buffer* meshes;
+    uint32_t mesh_num;
+    obj_mesh_vertex_buffer* mesh_data;
 };
 
 struct obj_set_handler {
@@ -48,16 +48,16 @@ struct obj_set_handler {
     p_file_handler tex_file_handler;
     bool tex_loaded;
     obj_set* obj_set;
-    std::vector<std::pair<uint32_t, uint32_t>> object_ids;
-    uint32_t textures_count;
-    std::vector<GLuint> textures;
-    std::vector<std::pair<uint32_t, uint32_t>> texture_ids;
-    texture** texture_data;
+    std::vector<std::pair<uint32_t, uint32_t>> obj_id_data;
+    uint32_t tex_num;
+    std::vector<GLuint> gentex;
+    std::vector<std::pair<uint32_t, uint32_t>> tex_id_data;
+    texture** tex_data;
     int32_t set_id;
-    uint32_t vertex_buffers_count;
-    obj_vertex_buffer* vertex_buffers;
-    uint32_t index_buffers_count;
-    obj_index_buffer* index_buffers;
+    uint32_t vertex_buffer_num;
+    obj_vertex_buffer* vertex_buffer_data;
+    uint32_t index_buffer_num;
+    obj_index_buffer* index_buffer_data;
     uint32_t load_count;
     std::string name;
     p_file_handler farc_file_handler;
@@ -67,9 +67,6 @@ struct obj_set_handler {
     virtual ~obj_set_handler();
 };
 
-extern obj_material_shader_lighting_type obj_material_shader_get_lighting_type(
-    obj_material_shader_flags* flags);
-extern int32_t obj_material_texture_get_blend(obj_material_texture* tex);
 extern int32_t obj_material_texture_type_get_texcoord_index(
     obj_material_texture_type type, int32_t index);
 extern int32_t obj_material_texture_type_get_texture_index(

src/CRE/post_process/dof.cpp

@@ -620,7 +620,8 @@ static void post_process_dof_update_data(post_process_dof* dof, float_t min_dist
 static void sub_1405163C0(rob_chara* rob_chr, int32_t a2, mat4* mat);
 
 
-post_process_dof::post_process_dof() {
+post_process_dof::post_process_dof() : data(), width(),
+height(), textures(), fbo(), vao(), program(), ubo() {
     post_process_dof_load_shaders(this);
 }
 
@@ -959,11 +960,6 @@ static void post_process_dof_calculate_texcoords(vec2* data, float_t size) {
 }
 
 static void post_process_dof_free_fbo(post_process_dof* dof) {
-    dof->fbo[0];
-    dof->fbo[1];
-    dof->fbo[2];
-    dof->fbo[3];
-
     if (dof->vao) {
         glDeleteVertexArrays(1, &dof->vao);
         dof->vao = 0;

src/CRE/render_context.cpp

@@ -490,12 +490,6 @@ void render_context::ctrl() {
         rob_chara_array[i].item_equip->shadow_type = SHADOW_CHARA;
     }*/
 
-    Glitter::glt_particle_manager.cam_projection = camera->projection;
-    Glitter::glt_particle_manager.cam_view = camera->view;
-    Glitter::glt_particle_manager.cam_inv_view = camera->inv_view;
-    Glitter::glt_particle_manager.cam_inv_view_mat3 = camera->inv_view_mat3;
-    Glitter::glt_particle_manager.cam_view_point = camera->view_point;
-    Glitter::glt_particle_manager.cam_rotation_y = camera->rotation.y;
     Glitter::glt_particle_manager.rctx = this;
 
     rctx_ptr = this;
@@ -645,7 +639,7 @@ void render_context::light_param_data_glow_set(light_param_glow* glow) {
 }
 
 void render_context::light_param_data_ibl_set(
-    light_param_ibl * ibl, light_param_data_storage * storage) {
+    light_param_ibl * ibl, light_param_data_storage* storage) {
     if (!ibl->ready)
         return;
 
@@ -742,8 +736,8 @@ void render_context::light_param_data_face_set(light_param_face* face) {
 
 shadow::shadow() : field_8(), field_158(), view_point(), interest(),
 field_1A8(), view_point_shared(), interest_shared(), field_2F0() {
-    field_170 = 1.2f;
-    field_174 = 1.0f;
+    view_region = 1.2f;
+    range = 1.0f;
     for (int32_t i = 0; i < 2; i++) {
         view_point[i] = vec3_identity;
         field_1C0[i] = 0.0f;
@@ -799,9 +793,9 @@ void shadow::ctrl(render_context* rctx) {
         vec3_negate(direction, direction);
         vec3_length(direction, length);
         if (length < 0.000001)
-            direction = { 0.0f, 1.0f, 0.0f };
+            this->direction = { 0.0f, 1.0f, 0.0f };
         else
-            vec3_mult_scalar(direction, 1.0f / length, direction);
+            vec3_mult_scalar(direction, 1.0f / length, this->direction);
 
         for (int32_t i = 0; i < 2; i++)
             if (draw_task_get_count(rctx, (draw_object_type)((int32_t)DRAW_OBJECT_SHADOW_CHARA + i)))
@@ -884,7 +878,7 @@ void shadow::ctrl(render_context* rctx) {
 
         float_t v2 = max(field_1C8[0], field_1C8[1]);
         field_2F5 = false;
-        field_170 = v2 + 1.2f;
+        view_region = v2 + 1.2f;
         field_200[0] = 0;
         field_200[1] = 1;
         if (field_2EC >= 2) {
@@ -908,11 +902,11 @@ void shadow::ctrl(render_context* rctx) {
                 v16 = 0.0f;
 
             if (v16 > 1.2f) {
-                field_170 = v2 + 2.4f;
+                view_region = v2 + 2.4f;
                 field_2F5 = true;
             }
             else
-                field_170 = v2 + 1.2f + v16;
+                view_region = v2 + 1.2f + v16;
 
             float_t t3;
             float_t t4;
@@ -996,7 +990,7 @@ void shadow::ctrl(render_context* rctx) {
 
             vec3 view_point = vec3_null;
             vec3 interest = vec3_null;
-            int32_t count = 0;;
+            int32_t count = 0;
             for (int32_t i = 0; i < 2; i++) {
                 int32_t c = (int32_t)field_1D0[i].size();
                 vec3 view_point_temp;
@@ -1015,7 +1009,7 @@ void shadow::ctrl(render_context* rctx) {
         float_t v2 = 0.0;
         float_t v67 = max(field_1C8[0], field_1C8[1]);
         field_2F5 = false;
-        field_170 = v67 + 1.2f;
+        view_region = v67 + 1.2f;
         field_200[0] = 0;
         field_200[1] = 1;
         if (field_2EC >= 2) {
@@ -1055,11 +1049,11 @@ void shadow::ctrl(render_context* rctx) {
                 v79 = v70;
 
             if (v79 > v67 + 1.2f) {
-                field_170 = v67 + 2.4f;
+                view_region = v67 + 2.4f;
                 field_2F5 = true;
             }
             else
-                field_170 = v79 + 1.2f;
+                view_region = v79 + 1.2f;
 
             vec3 interest_chara;
             vec3 interest_stage;
@@ -1076,7 +1070,7 @@ void shadow::ctrl(render_context* rctx) {
         }
     }
 
-    for (std::vector<vec3> i : field_1D0)
+    for (std::vector<vec3>& i : field_1D0)
         i.clear();
 }
 

src/CRE/render_context.hpp

@@ -410,7 +410,7 @@ struct object_data_buffer {
 struct object_data_culling_info {
     int32_t objects;
     int32_t meshes;
-    int32_t sub_meshes;
+    int32_t submesh_array;
 };
 
 struct object_data {
@@ -507,8 +507,8 @@ struct render_context {
 struct shadow {
     render_texture field_8[7];
     render_texture* field_158[3];
-    float_t field_170;
-    float_t field_174;
+    float_t view_region;
+    float_t range;
     vec3 view_point[2];
     vec3 interest[2];
     vec3 field_1A8[2];

src/CRE/rob.hpp

@@ -39,6 +39,211 @@ enum eyes_base_adjust_type {
     EYES_BASE_ADJUST_OFF       = 2,
 };
 
+enum mot_bone_index {
+    MOT_BONE_N_HARA_CP               = 0x00,
+    MOT_BONE_KG_HARA_Y               = 0x01,
+    MOT_BONE_KL_HARA_XZ              = 0x02,
+    MOT_BONE_KL_HARA_ETC             = 0x03,
+    MOT_BONE_N_HARA                  = 0x04,
+    MOT_BONE_CL_MUNE                 = 0x05,
+    MOT_BONE_J_MUNE_WJ               = 0x06,
+    MOT_BONE_E_MUNE_CP               = 0x07,
+    MOT_BONE_N_MUNE_B                = 0x08,
+    MOT_BONE_KL_MUNE_B_WJ            = 0x09,
+    MOT_BONE_KL_KUBI                 = 0x0A,
+    MOT_BONE_N_KAO                   = 0x0B,
+    MOT_BONE_CL_KAO                  = 0x0C,
+    MOT_BONE_J_KAO_WJ                = 0x0D,
+    MOT_BONE_E_KAO_CP                = 0x0E,
+    MOT_BONE_FACE_ROOT               = 0x0F,
+    MOT_BONE_N_AGO                   = 0x10,
+    MOT_BONE_KL_AGO_WJ               = 0x11,
+    MOT_BONE_N_TOOTH_UNDER           = 0x12,
+    MOT_BONE_TL_TOOTH_UNDER_WJ       = 0x13,
+    MOT_BONE_N_EYE_L                 = 0x14,
+    MOT_BONE_KL_EYE_L                = 0x15,
+    MOT_BONE_N_EYE_L_WJ_EX           = 0x16,
+    MOT_BONE_KL_HIGHLIGHT_L_WJ       = 0x17,
+    MOT_BONE_N_EYE_R                 = 0x18,
+    MOT_BONE_KL_EYE_R                = 0x19,
+    MOT_BONE_N_EYE_R_WJ_EX           = 0x1A,
+    MOT_BONE_KL_HIGHLIGHT_R_WJ       = 0x1B,
+    MOT_BONE_N_EYELID_L_A            = 0x1C,
+    MOT_BONE_TL_EYELID_L_A_WJ        = 0x1D,
+    MOT_BONE_N_EYELID_L_B            = 0x1E,
+    MOT_BONE_TL_EYELID_L_B_WJ        = 0x1F,
+    MOT_BONE_N_EYELID_R_A            = 0x20,
+    MOT_BONE_TL_EYELID_R_A_WJ        = 0x21,
+    MOT_BONE_N_EYELID_R_B            = 0x22,
+    MOT_BONE_TL_EYELID_R_B_WJ        = 0x23,
+    MOT_BONE_N_KUTI_D                = 0x24,
+    MOT_BONE_TL_KUTI_D_WJ            = 0x25,
+    MOT_BONE_N_KUTI_D_L              = 0x26,
+    MOT_BONE_TL_KUTI_D_L_WJ          = 0x27,
+    MOT_BONE_N_KUTI_D_R              = 0x28,
+    MOT_BONE_TL_KUTI_D_R_WJ          = 0x29,
+    MOT_BONE_N_KUTI_DS_L             = 0x2A,
+    MOT_BONE_TL_KUTI_DS_L_WJ         = 0x2B,
+    MOT_BONE_N_KUTI_DS_R             = 0x2C,
+    MOT_BONE_TL_KUTI_DS_R_WJ         = 0x2D,
+    MOT_BONE_N_KUTI_L                = 0x2E,
+    MOT_BONE_TL_KUTI_L_WJ            = 0x2F,
+    MOT_BONE_N_KUTI_M_L              = 0x30,
+    MOT_BONE_TL_KUTI_M_L_WJ          = 0x31,
+    MOT_BONE_N_KUTI_M_R              = 0x32,
+    MOT_BONE_TL_KUTI_M_R_WJ          = 0x33,
+    MOT_BONE_N_KUTI_R                = 0x34,
+    MOT_BONE_TL_KUTI_R_WJ            = 0x35,
+    MOT_BONE_N_KUTI_U                = 0x36,
+    MOT_BONE_TL_KUTI_U_WJ            = 0x37,
+    MOT_BONE_N_KUTI_U_L              = 0x38,
+    MOT_BONE_TL_KUTI_U_L_WJ          = 0x39,
+    MOT_BONE_N_KUTI_U_R              = 0x3A,
+    MOT_BONE_TL_KUTI_U_R_WJ          = 0x3B,
+    MOT_BONE_N_MABU_L_D_A            = 0x3C,
+    MOT_BONE_TL_MABU_L_D_A_WJ        = 0x3D,
+    MOT_BONE_N_MABU_L_D_B            = 0x3E,
+    MOT_BONE_TL_MABU_L_D_B_WJ        = 0x3F,
+    MOT_BONE_N_MABU_L_D_C            = 0x40,
+    MOT_BONE_TL_MABU_L_D_C_WJ        = 0x41,
+    MOT_BONE_N_MABU_L_U_A            = 0x42,
+    MOT_BONE_TL_MABU_L_U_A_WJ        = 0x43,
+    MOT_BONE_N_MABU_L_U_B            = 0x44,
+    MOT_BONE_TL_MABU_L_U_B_WJ        = 0x45,
+    MOT_BONE_N_EYELASHES_L           = 0x46,
+    MOT_BONE_TL_EYELASHES_L_WJ       = 0x47,
+    MOT_BONE_N_MABU_L_U_C            = 0x48,
+    MOT_BONE_TL_MABU_L_U_C_WJ        = 0x49,
+    MOT_BONE_N_MABU_R_D_A            = 0x4A,
+    MOT_BONE_TL_MABU_R_D_A_WJ        = 0x4B,
+    MOT_BONE_N_MABU_R_D_B            = 0x4C,
+    MOT_BONE_TL_MABU_R_D_B_WJ        = 0x4D,
+    MOT_BONE_N_MABU_R_D_C            = 0x4E,
+    MOT_BONE_TL_MABU_R_D_C_WJ        = 0x4F,
+    MOT_BONE_N_MABU_R_U_A            = 0x50,
+    MOT_BONE_TL_MABU_R_U_A_WJ        = 0x51,
+    MOT_BONE_N_MABU_R_U_B            = 0x52,
+    MOT_BONE_TL_MABU_R_U_B_WJ        = 0x53,
+    MOT_BONE_N_EYELASHES_R           = 0x54,
+    MOT_BONE_TL_EYELASHES_R_WJ       = 0x55,
+    MOT_BONE_N_MABU_R_U_C            = 0x56,
+    MOT_BONE_TL_MABU_R_U_C_WJ        = 0x57,
+    MOT_BONE_N_MAYU_L                = 0x58,
+    MOT_BONE_TL_MAYU_L_WJ            = 0x59,
+    MOT_BONE_N_MAYU_L_B              = 0x5A,
+    MOT_BONE_TL_MAYU_L_B_WJ          = 0x5B,
+    MOT_BONE_N_MAYU_L_C              = 0x5C,
+    MOT_BONE_TL_MAYU_L_C_WJ          = 0x5D,
+    MOT_BONE_N_MAYU_R                = 0x5E,
+    MOT_BONE_TL_MAYU_R_WJ            = 0x5F,
+    MOT_BONE_N_MAYU_R_B              = 0x60,
+    MOT_BONE_TL_MAYU_R_B_WJ          = 0x61,
+    MOT_BONE_N_MAYU_R_C              = 0x62,
+    MOT_BONE_TL_MAYU_R_C_WJ          = 0x63,
+    MOT_BONE_N_TOOTH_UPPER           = 0x64,
+    MOT_BONE_TL_TOOTH_UPPER_WJ       = 0x65,
+    MOT_BONE_N_KUBI_WJ_EX            = 0x66,
+    MOT_BONE_N_WAKI_L                = 0x67,
+    MOT_BONE_KL_WAKI_L_WJ            = 0x68,
+    MOT_BONE_TL_UP_KATA_L            = 0x69,
+    MOT_BONE_C_KATA_L                = 0x6A,
+    MOT_BONE_J_KATA_L_WJ_CU          = 0x6B,
+    MOT_BONE_J_UDE_L_WJ              = 0x6C,
+    MOT_BONE_E_UDE_L_CP              = 0x6D,
+    MOT_BONE_KL_TE_L_WJ              = 0x6E,
+    MOT_BONE_N_HITO_L_EX             = 0x6F,
+    MOT_BONE_NL_HITO_L_WJ            = 0x70,
+    MOT_BONE_NL_HITO_B_L_WJ          = 0x71,
+    MOT_BONE_NL_HITO_C_L_WJ          = 0x72,
+    MOT_BONE_N_KO_L_EX               = 0x73,
+    MOT_BONE_NL_KO_L_WJ              = 0x74,
+    MOT_BONE_NL_KO_B_L_WJ            = 0x75,
+    MOT_BONE_NL_KO_C_L_WJ            = 0x76,
+    MOT_BONE_N_KUSU_L_EX             = 0x77,
+    MOT_BONE_NL_KUSU_L_WJ            = 0x78,
+    MOT_BONE_NL_KUSU_B_L_WJ          = 0x79,
+    MOT_BONE_NL_KUSU_C_L_WJ          = 0x7A,
+    MOT_BONE_N_NAKA_L_EX             = 0x7B,
+    MOT_BONE_NL_NAKA_L_WJ            = 0x7C,
+    MOT_BONE_NL_NAKA_B_L_WJ          = 0x7D,
+    MOT_BONE_NL_NAKA_C_L_WJ          = 0x7E,
+    MOT_BONE_N_OYA_L_EX              = 0x7F,
+    MOT_BONE_NL_OYA_L_WJ             = 0x80,
+    MOT_BONE_NL_OYA_B_L_WJ           = 0x81,
+    MOT_BONE_NL_OYA_C_L_WJ           = 0x82,
+    MOT_BONE_N_STE_L_WJ_EX           = 0x83,
+    MOT_BONE_N_SUDE_L_WJ_EX          = 0x84,
+    MOT_BONE_N_SUDE_B_L_WJ_EX        = 0x85,
+    MOT_BONE_N_HIJI_L_WJ_EX          = 0x86,
+    MOT_BONE_N_UP_KATA_L_EX          = 0x87,
+    MOT_BONE_N_SKATA_L_WJ_CD_EX      = 0x88,
+    MOT_BONE_N_SKATA_B_L_WJ_CD_CU_EX = 0x89,
+    MOT_BONE_N_SKATA_C_L_WJ_CD_CU_EX = 0x8A,
+    MOT_BONE_N_WAKI_R                = 0x8B,
+    MOT_BONE_KL_WAKI_R_WJ            = 0x8C,
+    MOT_BONE_TL_UP_KATA_R            = 0x8D,
+    MOT_BONE_C_KATA_R                = 0x8E,
+    MOT_BONE_J_KATA_R_WJ_CU          = 0x8F,
+    MOT_BONE_J_UDE_R_WJ              = 0x90,
+    MOT_BONE_E_UDE_R_CP              = 0x91,
+    MOT_BONE_KL_TE_R_WJ              = 0x92,
+    MOT_BONE_N_HITO_R_EX             = 0x93,
+    MOT_BONE_NL_HITO_R_WJ            = 0x94,
+    MOT_BONE_NL_HITO_B_R_WJ          = 0x95,
+    MOT_BONE_NL_HITO_C_R_WJ          = 0x96,
+    MOT_BONE_N_KO_R_EX               = 0x97,
+    MOT_BONE_NL_KO_R_WJ              = 0x98,
+    MOT_BONE_NL_KO_B_R_WJ            = 0x99,
+    MOT_BONE_NL_KO_C_R_WJ            = 0x9A,
+    MOT_BONE_N_KUSU_R_EX             = 0x9B,
+    MOT_BONE_NL_KUSU_R_WJ            = 0x9C,
+    MOT_BONE_NL_KUSU_B_R_WJ          = 0x9D,
+    MOT_BONE_NL_KUSU_C_R_WJ          = 0x9E,
+    MOT_BONE_N_NAKA_R_EX             = 0x9F,
+    MOT_BONE_NL_NAKA_R_WJ            = 0xA0,
+    MOT_BONE_NL_NAKA_B_R_WJ          = 0xA1,
+    MOT_BONE_NL_NAKA_C_R_WJ          = 0xA2,
+    MOT_BONE_N_OYA_R_EX              = 0xA3,
+    MOT_BONE_NL_OYA_R_WJ             = 0xA4,
+    MOT_BONE_NL_OYA_B_R_WJ           = 0xA5,
+    MOT_BONE_NL_OYA_C_R_WJ           = 0xA6,
+    MOT_BONE_N_STE_R_WJ_EX           = 0xA7,
+    MOT_BONE_N_SUDE_R_WJ_EX          = 0xA8,
+    MOT_BONE_N_SUDE_B_R_WJ_EX        = 0xA9,
+    MOT_BONE_N_HIJI_R_WJ_EX          = 0xAA,
+    MOT_BONE_N_UP_KATA_R_EX          = 0xAB,
+    MOT_BONE_N_SKATA_R_WJ_CD_EX      = 0xAC,
+    MOT_BONE_N_SKATA_B_R_WJ_CD_CU_EX = 0xAD,
+    MOT_BONE_N_SKATA_C_R_WJ_CD_CU_EX = 0xAE,
+    MOT_BONE_KL_KOSI_Y               = 0xAF,
+    MOT_BONE_KL_KOSI_XZ              = 0xB0,
+    MOT_BONE_KL_KOSI_ETC_WJ          = 0xB1,
+    MOT_BONE_CL_MOMO_L               = 0xB2,
+    MOT_BONE_J_MOMO_L_WJ             = 0xB3,
+    MOT_BONE_J_SUNE_L_WJ             = 0xB4,
+    MOT_BONE_E_SUNE_L_CP             = 0xB5,
+    MOT_BONE_KL_ASI_L_WJ_CO          = 0xB6,
+    MOT_BONE_KL_TOE_L_WJ             = 0xB7,
+    MOT_BONE_N_HIZA_L_WJ_EX          = 0xB8,
+    MOT_BONE_CL_MOMO_R               = 0xB9,
+    MOT_BONE_J_MOMO_R_WJ             = 0xBA,
+    MOT_BONE_J_SUNE_R_WJ             = 0xBB,
+    MOT_BONE_E_SUNE_R_CP             = 0xBC,
+    MOT_BONE_KL_ASI_R_WJ_CO          = 0xBD,
+    MOT_BONE_KL_TOE_R_WJ             = 0xBE,
+    MOT_BONE_N_HIZA_R_WJ_EX          = 0xBF,
+    MOT_BONE_N_MOMO_A_L_WJ_CD_EX     = 0xC0,
+    MOT_BONE_N_MOMO_B_L_WJ_EX        = 0xC1,
+    MOT_BONE_N_MOMO_C_L_WJ_EX        = 0xC2,
+    MOT_BONE_N_MOMO_A_R_WJ_CD_EX     = 0xC3,
+    MOT_BONE_N_MOMO_B_R_WJ_EX        = 0xC4,
+    MOT_BONE_N_MOMO_C_R_WJ_EX        = 0xC5,
+    MOT_BONE_N_HARA_CD_EX            = 0xC6,
+    MOT_BONE_N_HARA_B_WJ_EX          = 0xC7,
+    MOT_BONE_N_HARA_C_WJ_EX          = 0xC8,
+    MOT_BONE_MAX                     = 0xC9,
+};
+
 enum mothead_data_type {
     MOTHEAD_DATA_TYPE_0                      = 0x00,
     MOTHEAD_DATA_TYPE_1                      = 0x01,
@@ -113,11 +318,11 @@ enum mothead_data_type {
     MOTHEAD_DATA_TYPE_70                     = 0x46,
     MOTHEAD_DATA_OSAGE_MOVE_CANCEL           = 0x47,
     MOTHEAD_DATA_TYPE_72                     = 0x48,
-    MOTHEAD_DATA_HAND_ADJUST                 = 0x49,
+    MOTHEAD_DATA_ROB_HAND_ADJUST             = 0x49,
     MOTHEAD_DATA_TYPE_74                     = 0x4A,
-    MOTHEAD_DATA_TYPE_75                     = 0x4B,
-    MOTHEAD_DATA_TYPE_76                     = 0x4C,
-    MOTHEAD_DATA_TYPE_77                     = 0x4D,
+    MOTHEAD_DATA_ROB_ADJUST_GLOBAL           = 0x4B,
+    MOTHEAD_DATA_ROB_ARM_ADJUST              = 0x4C,
+    MOTHEAD_DATA_DISABLE_EYE_MOTION          = 0x4D,
     MOTHEAD_DATA_TYPE_78                     = 0x4E,
     MOTHEAD_DATA_ROB_CHARA_COLI_RING         = 0x4F,
     MOTHEAD_DATA_ADJUST_GET_GLOBAL_TRANS     = 0x50,
@@ -700,7 +905,7 @@ struct bone_data {
     bone_node* node;
     float_t ik_segment_length[2];
     float_t ik_2nd_segment_length[2];
-    float_t field_2E0;
+    float_t arm_length;
     float_t eyes_xrot_adjust_neg;
     float_t eyes_xrot_adjust_pos;
 
@@ -737,6 +942,8 @@ struct mot_play_frame_data {
     float_t field_24;
     bool field_28;
     int32_t field_2C;
+
+    void reset();
 };
 
 struct mot_play_data {
@@ -746,6 +953,8 @@ struct mot_play_data {
     float_t field_38;
     float_t* field_40;
     float_t* field_48;
+
+    void reset();
 };
 
 struct struc_308 {
@@ -890,6 +1099,8 @@ struct motion_blend_mot {
 
     motion_blend_mot();
     virtual ~motion_blend_mot();
+
+    void reset();
 };
 
 struct rob_chara_bone_data_ik_scale {
@@ -910,6 +1121,8 @@ struct mot_blend {
 
     mot_blend();
     ~mot_blend();
+
+    void reset();
 };
 
 struct struc_241 {
@@ -1004,9 +1217,7 @@ struct struc_242 {
     float_t field_10;
     float_t field_14;
     float_t field_18;
-    int32_t field_1C;
-    float_t field_20;
-    float_t field_24;
+    vec3 field_1C;
     float_t field_28;
 };
 
@@ -1020,8 +1231,8 @@ struct struc_312 {
     vec3 field_74;
     vec3 field_80;
     float_t field_8C;
-    std::vector<bone_data>* field_90;
-    float_t field_98;
+    std::vector<bone_data>* bones;
+    float_t step;
 };
 
 struct rob_chara_bone_data {
@@ -1047,16 +1258,17 @@ struct rob_chara_bone_data {
     mot_blend mouth;
     mot_blend eyes;
     mot_blend eyelid;
-    bool field_758;
+    bool disable_eye_motion;
     rob_chara_bone_data_ik_scale ik_scale;
-    vec3 field_76C;
-    vec3 field_778;
+    vec3 field_76C[2];
     int32_t field_784;
     struc_258 field_788;
     struc_312 field_958;
 
     rob_chara_bone_data();
     virtual ~rob_chara_bone_data();
+
+    void reset();
 };
 
 union rob_chara_pv_data_customize_items {
@@ -1080,7 +1292,7 @@ struct rob_chara_pv_data {
     struc_242 field_18;
     struc_242 field_44;
     int32_t field_70;
-    int32_t field_74[10];
+    int32_t motion_face_ids[10];
     int32_t chara_size_index;
     bool height_adjust;
     rob_chara_pv_data_customize_items customize_items;
@@ -1459,6 +1671,8 @@ struct rob_osage {
 
     rob_osage();
     ~rob_osage();
+
+    void reset();
 };
 
 class ExOsageBlock : public ExNodeBlock {
@@ -1673,7 +1887,7 @@ struct rob_chara_item_equip {
     std::vector<texture_pattern_struct> texture_pattern;
     object_info field_D0;
     int32_t field_D4;
-    bool field_D8;
+    bool disable_update;
     int32_t field_DC;
     vec4u texture_color_coeff;
     float_t wet;
@@ -1715,6 +1929,8 @@ struct rob_chara_item_equip {
 
     rob_chara_item_equip();
     virtual ~rob_chara_item_equip();
+
+    void reset();
 };
 
 struct item_cos_texture_change_tex {
@@ -2111,7 +2327,7 @@ struct struc_405 {
     void Reset();
 };
 
-struct rob_chara_data_parts_adjust {
+struct rob_chara_data_adjust {
     bool enable;
     float_t frame;
     float_t transition_frame;
@@ -2124,9 +2340,9 @@ struct rob_chara_data_parts_adjust {
     int32_t type;
     int32_t cycle_type;
     bool ignore_gravity;
-    vec3 external_force_min;
-    vec3 external_force_strength;
     vec3 external_force;
+    vec3 external_force_cycle_strength;
+    vec3 external_force_cycle;
     float_t cycle;
     float_t phase;
     float_t force;
@@ -2142,32 +2358,34 @@ struct rob_chara_data_hand_adjust {
     rob_chara_data_hand_adjust_type type;
     float_t current_scale;
     float_t scale;
-    float_t transition_time;
+    float_t duration;
     float_t current_time;
     float_t rotation_blend;
-    float_t offset_blend;
+    float_t scale_blend;
     bool enable_scale;
     bool disable_x;
     bool disable_y;
     bool disable_z;
     vec3 offset;
     vec3 field_30;
-    float_t field_3C;
+    float_t arm_length;
     int32_t field_40;
 
     void reset();
 };
 
-struct struc_222 {
-    bool field_0;
-    float_t field_4;
-    float_t field_8;
-    float_t field_C;
+struct rob_chara_data_arm_adjust {
+    bool enable;
+    float_t value;
+    float_t prev_value;
+    float_t next_value;
     float_t duration;
     float_t frame;
+
+    void reset();
 };
 
-struct rob_chara_adjust {
+struct rob_chara_motion {
     int32_t motion_id;
     int32_t prev_motion_id;
     struc_389 frame_data;
@@ -2194,15 +2412,18 @@ struct rob_chara_adjust {
     object_info hand_l_object;
     object_info hand_r_object;
     struc_405 field_3B0;
-    rob_chara_data_parts_adjust parts_adjust[13];
-    rob_chara_data_parts_adjust parts_adjust_prev[13];
-    rob_chara_data_parts_adjust field_10D8[2];
+    rob_chara_data_adjust parts_adjust[13];
+    rob_chara_data_adjust parts_adjust_prev[13];
+    rob_chara_data_adjust adjust_global;
+    rob_chara_data_adjust adjust_global_prev;
     rob_chara_data_hand_adjust hand_adjust[2];
     rob_chara_data_hand_adjust hand_adjust_prev[2];
-    struc_222 field_12C8[2];
+    rob_chara_data_arm_adjust arm_adjust[2];
 
-    rob_chara_adjust();
-    ~rob_chara_adjust();
+    rob_chara_motion();
+    ~rob_chara_motion();
+
+    void reset();
 };
 
 struct struc_228 {
@@ -2472,6 +2693,8 @@ struct rob_chara_data_miku_rot {
     int32_t field_64;
     int32_t field_68;
     mat4u field_6C;
+
+    void reset();
 };
 
 struct rob_chara_adjust_data {
@@ -2490,6 +2713,8 @@ struct rob_chara_adjust_data {
     float_t right_hand_scale;
     float_t left_hand_scale_default;
     float_t right_hand_scale_default;
+
+    void reset();
 };
 
 struct struc_195 {
@@ -2647,7 +2872,7 @@ struct rob_chara_data {
     int32_t field_4;
     struc_264 field_8;
     RobSubAction rob_sub_action;
-    rob_chara_adjust adjust;
+    rob_chara_motion motion;
     struc_223 field_1588;
     rob_chara_data_miku_rot miku_rot;
     rob_chara_adjust_data adjust_data;
@@ -2676,6 +2901,8 @@ struct rob_chara_data {
 
     rob_chara_data();
     ~rob_chara_data();
+
+    void reset();
 };
 
 struct struc_307 {
@@ -2772,8 +2999,8 @@ extern rob_chara_pv_data* rob_chara_pv_data_array;
 extern const chara_init_data* chara_init_data_get(chara_index chara_index);
 extern int32_t chara_init_data_get_chara_size_index(chara_index chara_index);
 
-extern float_t chara_pos_adjust_y_table_get_value(uint32_t a1);
-extern float_t chara_size_table_get_value(uint32_t a1);
+extern float_t chara_pos_adjust_y_table_get_value(uint32_t index);
+extern float_t chara_size_table_get_value(uint32_t index);
 
 extern void motion_set_load_mothead(uint32_t set, std::string* mdata_dir, motion_database* mot_db);
 extern void motion_set_load_motion(uint32_t set, std::string* mdata_dir, motion_database* mot_db);
@@ -2798,6 +3025,7 @@ extern bool pv_osage_manager_array_ptr_get_disp();
 
 extern void task_rob_manager_append_task();
 extern bool task_rob_manager_check_chara_loaded(int32_t chara_id);
+extern void task_rob_manager_free_task();
 
 extern void motion_storage_init();
 extern bool motion_storage_check_mot_file_not_ready(uint32_t set_id);

src/CRE/stage.cpp

@@ -50,8 +50,6 @@ static void task_stage_set_ring(task_stage_info* stg_info, bool value);
 static void task_stage_set_sky(task_stage_info* stg_info, bool value);
 static void task_stage_set_stage_display(task_stage_info* stg_info, bool value);
 
-const task_stage_info task_stage_info_null = { -1, 0 };
-
 stage_detail::TaskStage task_stage;
 DtmStg dtm_stg;
 
@@ -218,12 +216,26 @@ static void stage_detail::TaskStage_CtrlInner(stage_detail::TaskStage* a1) {
     else if (a1->state == 5/* && !sub_1403446E0()*/) {
         std::vector<task_stage_info> vec;
         stage_detail::TaskStage_GetLoadedStageInfos(a1, &vec);
-        if (vec.size())
+        if (vec.size()) {
             stage_detail::TaskStage_SetStage(a1, vec[0]);
+
+            stage* s = stage_detail::TaskStage_GetStage(a1, vec[0]);
+            data_struct* data = rctx_ptr->data;
+            auth_3d_database* auth_3d_db = &data->data_ft.auth_3d_db;
+            for (int32_t& i : s->stage_data->auth_3d_ids) {
+                int32_t id = auth_3d_data_load_uid(i, auth_3d_db);
+                if (id == -1)
+                    continue;
+
+                auth_3d_data_read_file(&id, auth_3d_db);
+                s->auth_3d_ids.push_back(id);
+            }
+        }
         a1->state = 6;
     }
-    else if (a1->state >= 7 && a1->state <= 9)
+    else if (a1->state >= 7 && a1->state <= 9) {
         stage_detail::TaskStage_Unload(a1);
+    }
 }
 
 static void stage_detail::TaskStage_DispShadow(stage_detail::TaskStage* a1) {
@@ -249,7 +261,7 @@ static stage* stage_detail::TaskStage_GetStage(stage_detail::TaskStage* a1, task
 
 static void stage_detail::TaskStage_GetTaskStageInfo(stage_detail::TaskStage* a1,
     task_stage_info* stg_info, size_t index) {
-    *stg_info = task_stage_info_null;
+    *stg_info = {};
     if (index >= 0 && index < TASK_STAGE_STAGE_COUNT) {
         stg_info->load_index = (int16_t)index;
         stg_info->load_counter = a1->stages[index].counter;
@@ -325,7 +337,7 @@ static void stage_detail::TaskStage_Unload(stage_detail::TaskStage* a1) {
     }
     else if (a1->state == 5 || a1->state == 6) {
         if (a1->state == 6)
-            stage_detail::TaskStage_SetStage(a1, task_stage_info_null);
+            stage_detail::TaskStage_SetStage(a1, {});
 
         for (int32_t i = 0; i < TASK_STAGE_STAGE_COUNT; i++)
             stage_free(&a1->stages[i]);
@@ -364,7 +376,7 @@ static bool object_bounding_sphere_check_visibility_shadow(obj_bounding_sphere*
     float_t radius = sphere->radius;
 
     shadow* shad = rctx_ptr->draw_pass.shadow_ptr;
-    float_t v9 = shad->field_170 * shad->field_174;
+    float_t v9 = shad->view_region * shad->range;
     if ((center.x + radius) < -v9
         || (center.x - radius) > v9
         || (center.y + radius) < -v9
@@ -401,6 +413,7 @@ static bool stage_ctrl(stage* s) {
 
     for (int32_t& i : s->auth_3d_ids) {
         auth_3d_data_set_enable(&i, true);
+        auth_3d_data_set_paused(&i, false);
         auth_3d_data_set_visibility(&i, s->effect_display);
         auth_3d_data_set_frame_rate(&i, 0);
     }
@@ -569,17 +582,6 @@ static void stage_load(stage* s) {
             rctx_ptr->post_process.movie_texture_set(
                 texture_storage_get_texture(s->stage_data->movie_texture));
         s->state = 6;
-
-        data_struct* data = rctx_ptr->data;
-        auth_3d_database* auth_3d_db = &data->data_ft.auth_3d_db;
-        for (int32_t& i : s->stage_data->auth_3d_ids) {
-            int32_t id = auth_3d_data_load_uid(i, auth_3d_db);
-            if (id == -1)
-                continue;
-
-            auth_3d_data_read_file(&id, auth_3d_db);
-            s->auth_3d_ids.push_back(id);
-        }
     }
 }
 
@@ -806,6 +808,11 @@ void stage_detail::TaskStage::Disp() {
         stage_disp(s);
 }
 
+task_stage_info::task_stage_info() {
+    load_index = -1;
+    load_counter = 0;
+}
+
 DtmStg::DtmStg() : stage_index(), load_stage_index() {
 
 }

src/CRE/stage.hpp

@@ -64,6 +64,8 @@ namespace stage_detail {
 struct task_stage_info {
     int16_t load_index;
     uint16_t load_counter;
+
+    task_stage_info();
 };
 
 class DtmStg : public Task {

src/CRE/stage_modern.cpp

@@ -50,8 +50,6 @@ static void task_stage_modern_set_ground(task_stage_modern_info* stg_info, bool
 static void task_stage_modern_set_sky(task_stage_modern_info* stg_info, bool value);
 static void task_stage_modern_set_stage_display(task_stage_modern_info* stg_info, bool value);
 
-const task_stage_modern_info task_stage_modern_info_null = { -1, 0 };
-
 stage_detail::TaskStageModern task_stage_modern;
 
 extern render_context* rctx_ptr;
@@ -208,12 +206,28 @@ static void stage_detail::TaskStageModern_CtrlInner(stage_detail::TaskStageModer
     else if (a1->state == 5/* && !sub_1403446E0()*/) {
         std::vector<task_stage_modern_info> vec;
         stage_detail::TaskStageModern_GetLoadedStageInfos(a1, &vec);
-        if (vec.size())
+        if (vec.size()) {
             stage_detail::TaskStageModern_SetStage(a1, vec[0]);
+
+            stage_modern* s = stage_detail::TaskStageModern_GetStage(a1, vec[0]);
+            for (uint32_t& i : s->stage_data->auth_3d_ids) {
+                int32_t id = auth_3d_data_load_hash(i, s->stage_data->auth_3d_name_hash,
+                    s->stage_data->auth_3d_name.c_str(), a1->data, a1->obj_db, a1->tex_db);
+                if (id == -1)
+                    continue;
+
+                auth_3d_data_read_file_modern(&id);
+                auth_3d_data_set_enable(&id, true);
+                auth_3d_data_set_paused(&id, false);
+                auth_3d_data_set_frame_rate(&id, 0);
+                s->auth_3d_ids.push_back(id);
+            }
+        }
         a1->state = 6;
     }
-    else if (a1->state >= 7 && a1->state <= 9)
+    else if (a1->state >= 7 && a1->state <= 9) {
         stage_detail::TaskStageModern_Unload(a1);
+    }
 }
 
 static void stage_detail::TaskStageModern_DispShadow(stage_detail::TaskStageModern* a1) {
@@ -240,7 +254,7 @@ static stage_modern* stage_detail::TaskStageModern_GetStage(stage_detail::TaskSt
 
 static void stage_detail::TaskStageModern_GetTaskStageModernInfo(stage_detail::TaskStageModern* a1,
     task_stage_modern_info* stg_info, size_t index) {
-    *stg_info = task_stage_modern_info_null;
+    *stg_info = {};
     if (index >= 0 && index < TASK_STAGE_STAGE_COUNT) {
         stg_info->load_index = (int16_t)index;
         stg_info->load_counter = a1->stages[index].counter;
@@ -317,7 +331,7 @@ static void stage_detail::TaskStageModern_Unload(stage_detail::TaskStageModern*
     }
     else if (a1->state == 5 || a1->state == 6) {
         if (a1->state == 6)
-            stage_detail::TaskStageModern_SetStage(a1, task_stage_modern_info_null);
+            stage_detail::TaskStageModern_SetStage(a1, {});
 
         for (int32_t i = 0; i < TASK_STAGE_STAGE_COUNT; i++)
             stage_modern_free(&a1->stages[i]);
@@ -356,7 +370,7 @@ static bool object_bounding_sphere_check_visibility_shadow(obj_bounding_sphere*
     float_t radius = sphere->radius;
 
     shadow* shad = rctx_ptr->draw_pass.shadow_ptr;
-    float_t v9 = shad->field_170 * shad->field_174;
+    float_t v9 = shad->view_region * shad->range;
     if ((center.x + radius) < -v9
         || (center.x - radius) > v9
         || (center.y + radius) < -v9
@@ -539,18 +553,6 @@ static void stage_modern_load(stage_modern* s, void* data, object_database* obj_
             rctx_ptr->post_process.movie_texture_set(
                 texture_storage_get_texture(s->stage_data->movie_texture));
         s->state = 6;
-
-        for (uint32_t& i : s->stage_data->auth_3d_ids) {
-            int32_t id = auth_3d_data_load_hash(i, s->stage_data->auth_3d_name_hash,
-                s->stage_data->auth_3d_name.c_str(), data, obj_db, tex_db);
-            if (id == -1)
-                continue;
-
-            auth_3d_data_read_file_modern(&id);
-            auth_3d_data_set_enable(&id, true);
-            auth_3d_data_set_frame_rate(&id, 0);
-            s->auth_3d_ids.push_back(id);
-        }
     }
 }
 
@@ -731,3 +733,8 @@ void stage_detail::TaskStageModern::Disp() {
     if (s)
         stage_modern_disp(s);
 }
+
+task_stage_modern_info::task_stage_modern_info() {
+    load_index = -1;
+    load_counter = 0;
+}

src/CRE/stage_modern.hpp

@@ -68,6 +68,8 @@ namespace stage_detail {
 struct task_stage_modern_info {
     int16_t load_index;
     uint16_t load_counter;
+
+    task_stage_modern_info();
 };
 
 extern bool task_stage_modern_check_not_loaded();

src/CRE/texture.cpp

@@ -200,7 +200,7 @@ inline texture* texture_storage_create_texture(texture_id id) {
             return i;
         }
 
-    texture* tex = new texture();;
+    texture* tex = new texture();
     tex->init_count = 1;
     tex->id = id;
     texture_storage.push_back(tex);

src/DivaGL/bone_data.c

@@ -1821,7 +1821,7 @@ static void sub_140505C90(struc_264* a1) {
     a1->field_94 = 0;
     a1->field_98 = 0;
     a1->field_9C = 0;
-    a1->field_A0 = 0;;
+    a1->field_A0 = 0;
     a1->field_A4 = 0;
     a1->field_A5 = 0;
     a1->field_A8 = 0;

src/KKdLib/a3da.cpp

@@ -2744,7 +2744,7 @@ static void key_val_write_a3da_key(stream* s, char* buf,
     }
 
     if (value.type == A3DA_KEY_NONE) {
-        key_val::write_int32_t(s, buf, offset, ".type", 6, 0);;
+        key_val::write_int32_t(s, buf, offset, ".type", 6, 0);
         return;
     }
     else if (value.type == A3DA_KEY_STATIC) {

src/KKdLib/database/bone.cpp

@@ -920,13 +920,13 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
     if (!is_x) {
         uint32_t pos;
         ee = { 0, 1, 16, 1 };
-        ee.sub.push_back({ 0, 4, ENRS_DWORD });
+        ee.append(0, 4, ENRS_DWORD);
         e.vec.push_back(ee);
         pos = off = 16;
 
         skeleton_count *= 2;
         ee = { off, 1, (uint32_t)(skeleton_count * 4ULL), 1 };
-        ee.sub.push_back({ 0, skeleton_count, ENRS_DWORD });
+        ee.append(0, skeleton_count, ENRS_DWORD);
         e.vec.push_back(ee);
         pos += off = (uint32_t)(skeleton_count * 4ULL);
         skeleton_count /= 2;
@@ -940,7 +940,7 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
             uint32_t motion_bone_count = (uint32_t)skel->motion_bone.size();
 
             ee = { off, 1, 56, 1 };
-            ee.sub.push_back({ 0, 14, ENRS_DWORD });
+            ee.append(0, 14, ENRS_DWORD);
             e.vec.push_back(ee);
             pos += off = 56;
 
@@ -948,7 +948,7 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
             off += 8;
             pos += 8;
             ee = { off, 1, 12, bone_count };
-            ee.sub.push_back({ 0, 1, ENRS_DWORD });
+            ee.append(0, 1, ENRS_DWORD);
             e.vec.push_back(ee);
             off = (uint32_t)(bone_count * 12ULL);
             if (pos + off % 0x10)
@@ -957,25 +957,25 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
             bone_count--;
 
             ee = { off, 1, 12, position_count };
-            ee.sub.push_back({ 0, 3, ENRS_DWORD });
+            ee.append(0, 3, ENRS_DWORD);
             e.vec.push_back(ee);
             off = (uint32_t)(position_count * 12ULL);
             pos += off = align_val(off, 0x10);
 
             ee = { off, 1, 4, 1 };
-            ee.sub.push_back({ 0, 1, ENRS_DWORD });
+            ee.append(0, 1, ENRS_DWORD);
             e.vec.push_back(ee);
             pos += off = 4;
 
             object_bone_count += motion_bone_count;
             ee = { off, 1, (uint32_t)(object_bone_count * 4ULL), 1 };
-            ee.sub.push_back({ 0, object_bone_count, ENRS_DWORD });
+            ee.append(0, object_bone_count, ENRS_DWORD);
             e.vec.push_back(ee);
             pos += off = (uint32_t)(object_bone_count * 4ULL);
             object_bone_count -= motion_bone_count;
 
             ee = { off, 1, (uint32_t)(motion_bone_count * 2ULL), 1 };
-            ee.sub.push_back({ 0, motion_bone_count, ENRS_WORD });
+            ee.append(0, motion_bone_count, ENRS_WORD);
             e.vec.push_back(ee);
             off = (uint32_t)(motion_bone_count * 2ULL);
             pos += off = align_val(off, 0x04);
@@ -983,21 +983,21 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
     }
     else {
         ee = { 0, 2, 24, 1 };
-        ee.sub.push_back({ 0, 2, ENRS_DWORD });
-        ee.sub.push_back({ 0, 2, ENRS_QWORD });
+        ee.append(0, 2, ENRS_DWORD);
+        ee.append(0, 2, ENRS_QWORD);
         e.vec.push_back(ee);
         off = 24;
         off = align_val(off, 0x10);
 
         if (skeleton_count % 2) {
             ee = { off, 1, (uint32_t)(skeleton_count * 8ULL), 1 };
-            ee.sub.push_back({ 0, skeleton_count, ENRS_QWORD });
+            ee.append(0, skeleton_count, ENRS_QWORD);
             e.vec.push_back(ee);
             off = (uint32_t)(skeleton_count * 8ULL);
             off = align_val(off, 0x10);
 
             ee = { off, 1, (uint32_t)(skeleton_count * 8ULL), 1 };
-            ee.sub.push_back({ 0, skeleton_count, ENRS_QWORD });
+            ee.append(0, skeleton_count, ENRS_QWORD);
             e.vec.push_back(ee);
             off = (uint32_t)(skeleton_count * 8ULL);
             off = align_val(off, 0x10);
@@ -1005,7 +1005,7 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
         else {
             skeleton_count *= 2;
             ee = { off, 1, (uint32_t)(skeleton_count * 8ULL), 1 };
-            ee.sub.push_back({ 0, skeleton_count, ENRS_QWORD });
+            ee.append(0, skeleton_count, ENRS_QWORD);
             e.vec.push_back(ee);
             off = (uint32_t)(skeleton_count * 8ULL);
             off = align_val(off, 0x10);
@@ -1013,13 +1013,13 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
         }
 
         ee = { off, 7, 112, skeleton_count };
-        ee.sub.push_back({ 0, 1, ENRS_QWORD });
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
-        ee.sub.push_back({ 4, 2, ENRS_QWORD });
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
-        ee.sub.push_back({ 4, 1, ENRS_QWORD });
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
-        ee.sub.push_back({ 4, 7, ENRS_QWORD });
+        ee.append(0, 1, ENRS_QWORD);
+        ee.append(0, 1, ENRS_DWORD);
+        ee.append(4, 2, ENRS_QWORD);
+        ee.append(0, 1, ENRS_DWORD);
+        ee.append(4, 1, ENRS_QWORD);
+        ee.append(0, 1, ENRS_DWORD);
+        ee.append(4, 7, ENRS_QWORD);
         e.vec.push_back(ee);
         off = (uint32_t)(skeleton_count * 112ULL);
         off = align_val(off, 0x10);
@@ -1035,26 +1035,26 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
             bone_count++;
             off += 8;
             ee = { off, 1, 16, bone_count };
-            ee.sub.push_back({ 0, 1, ENRS_QWORD });
+            ee.append(0, 1, ENRS_QWORD);
             e.vec.push_back(ee);
             off = (uint32_t)(bone_count * 16ULL);
             bone_count--;
 
             ee = { off, 1, 12, position_count };
-            ee.sub.push_back({ 0, 3, ENRS_DWORD });
+            ee.append(0, 3, ENRS_DWORD);
             e.vec.push_back(ee);
             off = (uint32_t)(position_count * 12ULL);
             off = align_val(off, 0x10);
 
             ee = { off, 1, 4, 1 };
-            ee.sub.push_back({ 0, 1, ENRS_DWORD });
+            ee.append(0, 1, ENRS_DWORD);
             e.vec.push_back(ee);
             off = 4;
             off = align_val(off, 0x10);
 
             if (object_bone_count % 1) {
                 ee = { off, 1, 12, position_count };
-                ee.sub.push_back({ 0, 3, ENRS_DWORD });
+                ee.append(0, 3, ENRS_DWORD);
                 e.vec.push_back(ee);
                 off = (uint32_t)(position_count * 12ULL);
                 off = align_val(off, 0x10);
@@ -1062,13 +1062,13 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
 
             if (skeleton_count % 2) {
                 ee = { off, 1, (uint32_t)(object_bone_count * 8ULL), 1 };
-                ee.sub.push_back({ 0, object_bone_count, ENRS_QWORD });
+                ee.append(0, object_bone_count, ENRS_QWORD);
                 e.vec.push_back(ee);
                 off = (uint32_t)(object_bone_count * 8ULL);
                 off = align_val(off, 0x10);
 
                 ee = { off, 1, (uint32_t)(motion_bone_count * 8ULL), 1 };
-                ee.sub.push_back({ 0, motion_bone_count, ENRS_QWORD });
+                ee.append(0, motion_bone_count, ENRS_QWORD);
                 e.vec.push_back(ee);
                 off = (uint32_t)(motion_bone_count * 8ULL);
                 off = align_val(off, 0x10);
@@ -1076,7 +1076,7 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
             else {
                 object_bone_count += motion_bone_count;
                 ee = { off, 1, (uint32_t)(object_bone_count * 8ULL), 1 };
-                ee.sub.push_back({ 0, object_bone_count, ENRS_QWORD });
+                ee.append(0, object_bone_count, ENRS_QWORD);
                 e.vec.push_back(ee);
                 off = (uint32_t)(object_bone_count * 8ULL);
                 off = align_val(off, 0x10);
@@ -1084,7 +1084,7 @@ static void bone_database_modern_write_inner(bone_database* bone_data, stream* s
             }
 
             ee = { off, 1, (uint32_t)(motion_bone_count * 2ULL), 1 };
-            ee.sub.push_back({ 0, motion_bone_count, ENRS_WORD });
+            ee.append(0, motion_bone_count, ENRS_WORD);
             e.vec.push_back(ee);
             off = (uint32_t)(motion_bone_count * 2ULL);
             off = align_val(off, 0x10);

src/KKdLib/database/item_table.cpp

@@ -117,27 +117,6 @@ bool itm_table::load_file(void* data, const char* path, const char* file, uint32
     return itm_tbl->ready;
 }
 
-const char* chara_index_get_name(chara_index chara_index) {
-    if (chara_index < CHARA_MIKU || chara_index > CHARA_TETO)
-        return 0;
-
-    const char* chara_names[] = {
-        "MIKU",
-        "RIN",
-        "LEN",
-        "LUKA",
-        "NERU",
-        "HAKU",
-        "KAITO",
-        "MEIKO",
-        "SAKINE",
-        "TETO",
-        "EXTRA",
-    };
-
-    return chara_names[chara_index];
-}
-
 const char* chara_index_get_auth_3d_name(chara_index chara_index) {
     if (chara_index < CHARA_MIKU || chara_index > CHARA_TETO)
         return 0;
@@ -159,6 +138,69 @@ const char* chara_index_get_auth_3d_name(chara_index chara_index) {
     return chara_names[chara_index];
 }
 
+const char* chara_index_get_chara_name(chara_index chara_index) {
+    if (chara_index < CHARA_MIKU || chara_index > CHARA_TETO)
+        return 0;
+
+    const char* chara_names[] = {
+        "MIK",
+        "RIN",
+        "LEN",
+        "LUK",
+        "NER",
+        "HAK",
+        "KAI",
+        "MEI",
+        "SAK",
+        "TET",
+        "EXT",
+    };
+
+    return chara_names[chara_index];
+}
+
+const char* chara_index_get_face_mot_name(chara_index chara_index) {
+    if (chara_index < CHARA_MIKU || chara_index > CHARA_TETO)
+        return 0;
+
+    const char* chara_names[] = {
+        "MIK",
+        "RIN",
+        "LEN",
+        "LUK",
+        "NER",
+        "HAK",
+        "KAI",
+        "MEI",
+        "SAK",
+        "TET",
+        "EXT",
+    };
+
+    return chara_names[chara_index];
+}
+
+const char* chara_index_get_name(chara_index chara_index) {
+    if (chara_index < CHARA_MIKU || chara_index > CHARA_TETO)
+        return 0;
+
+    const char* chara_names[] = {
+        "MIKU",
+        "RIN",
+        "LEN",
+        "LUKA",
+        "NERU",
+        "HAKU",
+        "KAITO",
+        "MEIKO",
+        "SAKINE",
+        "TETO",
+        "EXTRA",
+    };
+
+    return chara_names[chara_index];
+}
+
 itm_table_item_data_tex::itm_table_item_data_tex() {
 
 }

src/KKdLib/database/item_table.hpp

@@ -193,5 +193,7 @@ struct itm_table {
     static bool load_file(void* data, const char* path, const char* file, uint32_t hash);
 };
 
-extern const char* chara_index_get_name(chara_index chara_index);
 extern const char* chara_index_get_auth_3d_name(chara_index chara_index);
+extern const char* chara_index_get_chara_name(chara_index chara_index);
+extern const char* chara_index_get_face_mot_name(chara_index chara_index);
+extern const char* chara_index_get_name(chara_index chara_index);

src/KKdLib/database/object.cpp

@@ -667,42 +667,42 @@ static void object_database_modern_write_inner(object_database* obj_db, stream*
 
     if (!is_x) {
         ee = { 0, 1, 1, 1 };
-        ee.sub.push_back({ 0, 6, ENRS_DWORD });
+        ee.append(0, 6, ENRS_DWORD);
         e.vec.push_back(ee);
         off = 32;
 
         ee = { off, 1, 36, object_set_count };
-        ee.sub.push_back({ 0, 5, ENRS_DWORD });
+        ee.append(0, 5, ENRS_DWORD);
         e.vec.push_back(ee);
         off = (uint32_t)(object_set_count * 36ULL);
         off = align_val(off, 0x10);
 
         ee = { off, 1, 12, object_count };
-        ee.sub.push_back({ 0, 3, ENRS_DWORD });
+        ee.append(0, 3, ENRS_DWORD);
         e.vec.push_back(ee);
         off = (uint32_t)(object_count * 12ULL);
         off = align_val(off, 0x10);
     }
     else {
         ee = { 0, 4, 48, 1 };
-        ee.sub.push_back({ 0, 3, ENRS_DWORD });
-        ee.sub.push_back({ 4, 1, ENRS_QWORD });
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
-        ee.sub.push_back({ 4, 1, ENRS_QWORD });
+        ee.append(0, 3, ENRS_DWORD);
+        ee.append(4, 1, ENRS_QWORD);
+        ee.append(0, 1, ENRS_DWORD);
+        ee.append(4, 1, ENRS_QWORD);
         e.vec.push_back(ee);
         off = 48;
 
         ee = { off, 3, 56, object_set_count };
-        ee.sub.push_back({ 0, 1, ENRS_QWORD });
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
-        ee.sub.push_back({ 4, 3, ENRS_QWORD });
+        ee.append(0, 1, ENRS_QWORD);
+        ee.append(0, 1, ENRS_DWORD);
+        ee.append(4, 3, ENRS_QWORD);
         e.vec.push_back(ee);
         off = (uint32_t)(object_set_count * 56ULL);
         off = align_val(off, 0x10);
 
         ee = { off, 2, 16, object_count };
-        ee.sub.push_back({ 0, 2, ENRS_DWORD });
-        ee.sub.push_back({ 0, 1, ENRS_QWORD });
+        ee.append(0, 2, ENRS_DWORD);
+        ee.append(0, 1, ENRS_QWORD);
         e.vec.push_back(ee);
         off = (uint32_t)(object_count * 16ULL);
         off = align_val(off, 0x10);

src/KKdLib/database/texture.cpp

@@ -383,21 +383,21 @@ static void texture_database_modern_write_inner(texture_database* tex_db, stream
 
     if (!is_x) {
         ee = { 0, 2, 8, textures_count };
-        ee.sub.push_back({ 0, 9, ENRS_DWORD });
+        ee.append(0, 9, ENRS_DWORD);
         e.vec.push_back(ee);
         off = 8;
         off = align_val(off, 0x10);
 
         ee = { off, 2, 8, textures_count };
-        ee.sub.push_back({ 0, 2, ENRS_DWORD });
+        ee.append(0, 2, ENRS_DWORD);
         e.vec.push_back(ee);
         off = (uint32_t)(textures_count * 16ULL);
     }
     else {
         textures_count++;
         ee = { 0, 2, 16, textures_count };
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
-        ee.sub.push_back({ 4, 1, ENRS_QWORD });
+        ee.append(0, 1, ENRS_DWORD);
+        ee.append(4, 1, ENRS_QWORD);
         e.vec.push_back(ee);
         off = (uint32_t)(textures_count * 16ULL);
         textures_count--;

src/KKdLib/dsc.cpp

@@ -2907,7 +2907,7 @@ void dsc::unparse(void** data, size_t* size) {
         enrs_entry ee;
 
         ee = { 0, 1, 4, (uint32_t)s };
-        ee.sub.push_back({ 0, 1, ENRS_DWORD });
+        ee.append(0, 1, ENRS_DWORD);
         e.vec.push_back(ee);
 
         st.enrs = e;

src/KKdLib/f2/enrs.cpp

@@ -34,6 +34,14 @@ enrs_entry::~enrs_entry() {
 
 }
 
+void enrs_entry::append(uint32_t skip_bytes, uint32_t repeat_count, enrs_type type) {
+    sub.push_back({ skip_bytes, repeat_count, type });
+}
+
+void enrs_entry::append(enrs_sub_entry&& data) {
+    sub.push_back(data);
+}
+
 enrs::enrs() {
 
 }

src/KKdLib/f2/enrs.hpp

@@ -32,6 +32,9 @@ struct enrs_entry {
     enrs_entry();
     enrs_entry(uint32_t offset, uint32_t count, uint32_t size, uint32_t repeat_count);
     ~enrs_entry();
+
+    void append(uint32_t skip_bytes, uint32_t repeat_count, enrs_type type);
+    void append(enrs_sub_entry&& data);
 };
 
 struct enrs {

src/KKdLib/f2/struct.cpp

@@ -187,7 +187,7 @@ static void f2_struct_read_data(stream* s, f2_struct* st, f2_header* h) {
             st->enrs.read(s);
             io_set_position(s, pos + l, SEEK_SET);
         }
-        else if ((sig & 0xF0FFFFFF) == 'POF0') {
+        else if ((sig & 0xFFFFFFF0) == 'POF0') {
             size_t pos = io_get_position(s);
             st->pof.read(s, sig == 'POF1');
             io_set_position(s, pos + l, SEEK_SET);

src/KKdLib/key_val.cpp

@@ -327,14 +327,11 @@ void key_val::get_lexicographic_order(std::vector<int32_t>* vec, int32_t length)
 }
 
 bool key_val::load_file(void* data, const char* path, const char* file, uint32_t hash) {
-    string s;
-    string_init(&s, path);
-    string_add(&s, file);
+    std::string s = path + std::string(file);
 
     key_val* kv = (key_val*)data;
-    kv->file_read(string_data(&s));
+    kv->file_read(s.c_str());
 
-    string_free(&s);
     return kv->buf ? true : false;
 }
 

src/KKdLib/light_param/wind.cpp

@@ -98,14 +98,11 @@ bool light_param_wind::load_file(void* data, const char* path, const char* file,
     if (t)
         file_len = t - file;
 
-    string s;
-    string_init(&s, path);
-    string_add_length(&s, file, file_len);
+    std::string s = path + std::string(file, file_len);
 
     light_param_wind* wind = (light_param_wind*)data;
-    wind->read(string_data(&s));
+    wind->read(s.c_str());
 
-    string_free(&s);
     return wind->ready;
 }
 

src/KKdLib/mat.h

@@ -138,7 +138,7 @@ extern void mat4_scale_x_mult(const mat4* x, float_t y, mat4* z);
 extern void mat4_scale_y_mult(const mat4* x, float_t y, mat4* z);
 extern void mat4_scale_z_mult(const mat4* x, float_t y, mat4* z);
 extern void mat4_scale_w_mult(const mat4* x, float_t y, mat4* z);
-extern void mat4_scale_rot(const mat4* s, float_t x, float_t y, float_t z, mat4* d);;
+extern void mat4_scale_rot(const mat4* s, float_t x, float_t y, float_t z, mat4* d);
 extern void mat4_scale_x_rot(const mat4* x, float_t y, mat4* z);
 extern void mat4_scale_y_rot(const mat4* x, float_t y, mat4* z);
 extern void mat4_scale_z_rot(const mat4* x, float_t y, mat4* z);

src/KKdLib/mot.cpp

@@ -308,8 +308,8 @@ static void mot_modern_read_inner(mot_set* ms, stream* s) {
     }
 
     mot_data* m = &ms->vec[0];
-    m->div_frames = io_read_uint16_t_stream_reverse_endianness(&s_motc);;
-    m->div_count = io_read_uint8_t(&s_motc);;
+    m->div_frames = io_read_uint16_t_stream_reverse_endianness(&s_motc);
+    m->div_count = io_read_uint8_t(&s_motc);
 
     io_read_string_null_terminated_offset(&s_motc, mh.name_offset, &m->name);
 
@@ -414,28 +414,28 @@ static void mot_modern_write_inner(mot_set* ms, stream* s) {
 
         if (!ms->is_x) {
             ee = { 0, 3, 48, 1 };
-            ee.sub.push_back({ 0, 1, ENRS_QWORD });
-            ee.sub.push_back({ 0, 7, ENRS_DWORD });
-            ee.sub.push_back({ 0, 1, ENRS_WORD });
+            ee.append(0, 1, ENRS_QWORD);
+            ee.append(0, 7, ENRS_DWORD);
+            ee.append(0, 1, ENRS_WORD);
             e.vec.push_back(ee);
             o = 48;
         }
         else {
             ee = { 0, 3, 64, 1 };
-            ee.sub.push_back({ 0, 7, ENRS_QWORD });
-            ee.sub.push_back({ 0, 1, ENRS_DWORD });
-            ee.sub.push_back({ 0, 1, ENRS_WORD });
+            ee.append(0, 7, ENRS_QWORD);
+            ee.append(0, 1, ENRS_DWORD);
+            ee.append(0, 1, ENRS_WORD);
             e.vec.push_back(ee);
             o = 64;
         };
 
         ee = { o, 1, 4, 1 };
-        ee.sub.push_back({ 0, 2, ENRS_WORD });
+        ee.append(0, 2, ENRS_WORD);
         e.vec.push_back(ee);
         o = 4;
 
         ee = { o, 1, (uint32_t)((m->key_set_count + 3ULL) / 4), 1 };
-        ee.sub.push_back({ 0, (uint32_t)((m->key_set_count + 7ULL) / 8), ENRS_WORD });
+        ee.append(0, (uint32_t)((m->key_set_count + 7ULL) / 8), ENRS_WORD);
         e.vec.push_back(ee);
         o = (m->key_set_count + 3) / 4;
         o = align_val(o, 4);
@@ -444,7 +444,7 @@ static void mot_modern_write_inner(mot_set* ms, stream* s) {
             mot_key_set_data* mks = &m->key_set[j];
             if (mks->type == MOT_KEY_SET_STATIC) {
                 ee = { o, 1, 4, 1 };
-                ee.sub.push_back({ 0, 1, ENRS_DWORD });
+                ee.append(0, 1, ENRS_DWORD);
                 e.vec.push_back(ee);
                 o = 4;
             }
@@ -469,16 +469,16 @@ static void mot_modern_write_inner(mot_set* ms, stream* s) {
                 o = align_val(o, 4);
                 ee.size = o;
 
-                ee.sub.push_back({ 0, 2, ENRS_WORD });
+                ee.append(0, 2, ENRS_WORD);
                 if (has_tangents)
-                    ee.sub.push_back({ 0, keys_count, ENRS_DWORD });
+                    ee.append(0, keys_count, ENRS_DWORD);
                 if (data_type == MOT_KEY_SET_DATA_F16) {
-                    ee.sub.push_back({ 0, keys_count, ENRS_WORD });
-                    ee.sub.push_back({ keys_count % 2 == 1 ? 2u : 0u, keys_count, ENRS_WORD });
+                    ee.append(0, keys_count, ENRS_WORD);
+                    ee.append(keys_count % 2 == 1 ? 2u : 0u, keys_count, ENRS_WORD);
                 }
                 else {
-                    ee.sub.push_back({ 0, keys_count, ENRS_DWORD });
-                    ee.sub.push_back({ 0, keys_count, ENRS_WORD });
+                    ee.append(0, keys_count, ENRS_DWORD);
+                    ee.append(0, keys_count, ENRS_WORD);
                 }
                 e.vec.push_back(ee);
             }
@@ -487,20 +487,20 @@ static void mot_modern_write_inner(mot_set* ms, stream* s) {
 
         if (!ms->is_x) {
             ee = { o, 1, (uint32_t)(m->bone_info_count * 4ULL), 1 };
-            ee.sub.push_back({ 0, (uint32_t)m->bone_info_count, ENRS_DWORD });
+            ee.append(0, (uint32_t)m->bone_info_count, ENRS_DWORD);
             e.vec.push_back(ee);
             o = m->bone_info_count * 4;
         }
         else {
             ee = { o, 1, (uint32_t)(m->bone_info_count * 8ULL), 1 };
-            ee.sub.push_back({ 0, (uint32_t)m->bone_info_count, ENRS_QWORD });
+            ee.append(0, (uint32_t)m->bone_info_count, ENRS_QWORD);
             e.vec.push_back(ee);
             o = m->bone_info_count * 8;
         }
         o = align_val(o, 16);
 
         ee = { o, 1,(uint32_t)(m->bone_info_count * 8ULL), 1 };
-        ee.sub.push_back({ 0, (uint32_t)m->bone_info_count, ENRS_QWORD });
+        ee.append(0, (uint32_t)m->bone_info_count, ENRS_QWORD);
         e.vec.push_back(ee);
         o = m->bone_info_count * 8;
 

src/KKdLib/msgpack.cpp

@@ -16,7 +16,7 @@ msgpack::msgpack() : data() {
     type = MSGPACK_NULL;
 }
 
-msgpack::msgpack(const msgpack& m) : msgpack() {
+msgpack::msgpack(const msgpack& m) {
     if (this == &m)
         return;
 
@@ -105,7 +105,7 @@ msgpack::msgpack(const msgpack& m) : msgpack() {
     name = m.name;
 }
 
-msgpack::msgpack(const char* name, bool array, size_t length) : msgpack() {
+msgpack::msgpack(const char* name, bool array, size_t length) {
     type = array ? MSGPACK_ARRAY : MSGPACK_MAP;
     MSGPACK_ALLOCATE_PTR(msgpack_array, this);
     if (name)
@@ -116,7 +116,7 @@ msgpack::msgpack(const char* name, bool array, size_t length) : msgpack() {
     ptr->resize(length);
 }
 
-msgpack::msgpack(const char* name, bool array, msgpack_array& val) : msgpack() {
+msgpack::msgpack(const char* name, bool array, msgpack_array& val) {
     type = array ? MSGPACK_ARRAY : MSGPACK_MAP;
     MSGPACK_ALLOCATE_PTR(msgpack_array, this);
     if (name)
@@ -126,13 +126,13 @@ msgpack::msgpack(const char* name, bool array, msgpack_array& val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name) : msgpack() {
+msgpack::msgpack(const char* name) {
     type = MSGPACK_NULL;
     if (name)
         this->name = std::string(name);
 }
 
-msgpack::msgpack(const char* name, bool val) : msgpack() {
+msgpack::msgpack(const char* name, bool val) {
     type = MSGPACK_BOOL;
     MSGPACK_ALLOCATE_PTR(bool, this);
     if (name)
@@ -142,7 +142,7 @@ msgpack::msgpack(const char* name, bool val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, int8_t val) : msgpack() {
+msgpack::msgpack(const char* name, int8_t val) {
     type = MSGPACK_INT8;
     MSGPACK_ALLOCATE_PTR(int8_t, this);
     if (name)
@@ -152,7 +152,7 @@ msgpack::msgpack(const char* name, int8_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, uint8_t val) : msgpack() {
+msgpack::msgpack(const char* name, uint8_t val) {
     type = MSGPACK_UINT8;
     MSGPACK_ALLOCATE_PTR(uint8_t, this);
     if (name)
@@ -162,7 +162,7 @@ msgpack::msgpack(const char* name, uint8_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, int16_t val) : msgpack() {
+msgpack::msgpack(const char* name, int16_t val) {
     type = MSGPACK_INT16;
     MSGPACK_ALLOCATE_PTR(int16_t, this);
     if (name)
@@ -172,7 +172,7 @@ msgpack::msgpack(const char* name, int16_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, uint16_t val) : msgpack() {
+msgpack::msgpack(const char* name, uint16_t val) {
     type = MSGPACK_UINT16;
     MSGPACK_ALLOCATE_PTR(uint16_t, this);
     if (name)
@@ -182,7 +182,7 @@ msgpack::msgpack(const char* name, uint16_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, int32_t val) : msgpack() {
+msgpack::msgpack(const char* name, int32_t val) {
     type = MSGPACK_INT32;
     MSGPACK_ALLOCATE_PTR(int32_t, this);
     if (name)
@@ -192,7 +192,7 @@ msgpack::msgpack(const char* name, int32_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, uint32_t val) : msgpack() {
+msgpack::msgpack(const char* name, uint32_t val) {
     type = MSGPACK_UINT32;
     MSGPACK_ALLOCATE_PTR(uint32_t, this);
     if (name)
@@ -202,7 +202,7 @@ msgpack::msgpack(const char* name, uint32_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, int64_t val) : msgpack() {
+msgpack::msgpack(const char* name, int64_t val) {
     type = MSGPACK_INT64;
     MSGPACK_ALLOCATE_PTR(int64_t, this);
     if (name)
@@ -212,7 +212,7 @@ msgpack::msgpack(const char* name, int64_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, uint64_t val) : msgpack() {
+msgpack::msgpack(const char* name, uint64_t val) {
     type = MSGPACK_UINT64;
     MSGPACK_ALLOCATE_PTR(uint64_t, this);
     if (name)
@@ -222,7 +222,7 @@ msgpack::msgpack(const char* name, uint64_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, float_t val) : msgpack() {
+msgpack::msgpack(const char* name, float_t val) {
     type = MSGPACK_FLOAT;
     MSGPACK_ALLOCATE_PTR(float_t, this);
     if (name)
@@ -232,7 +232,7 @@ msgpack::msgpack(const char* name, float_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, double_t val) : msgpack() {
+msgpack::msgpack(const char* name, double_t val) {
     type = MSGPACK_DOUBLE;
     MSGPACK_ALLOCATE_PTR(double_t, this);
     if (name)
@@ -242,7 +242,7 @@ msgpack::msgpack(const char* name, double_t val) : msgpack() {
     *ptr = val;
 }
 
-msgpack::msgpack(const char* name, const char* val) : msgpack() {
+msgpack::msgpack(const char* name, const char* val) {
     type = MSGPACK_STRING;
     MSGPACK_ALLOCATE_PTR(std::string, this);
     if (name)
@@ -253,7 +253,7 @@ msgpack::msgpack(const char* name, const char* val) : msgpack() {
         *ptr = std::string(val);
 }
 
-msgpack::msgpack(const char* name, const wchar_t* val) : msgpack() {
+msgpack::msgpack(const char* name, const wchar_t* val) {
     char* temp = utf16_to_utf8(val);
     type = MSGPACK_STRING;
     MSGPACK_ALLOCATE_PTR(std::string, this);
@@ -266,7 +266,7 @@ msgpack::msgpack(const char* name, const wchar_t* val) : msgpack() {
     free(temp);
 }
 
-msgpack::msgpack(const char* name, string* val) : msgpack() {
+msgpack::msgpack(const char* name, string* val) {
     type = MSGPACK_STRING;
     MSGPACK_ALLOCATE_PTR(std::string, this);
     if (name)
@@ -277,7 +277,7 @@ msgpack::msgpack(const char* name, string* val) : msgpack() {
         *ptr = std::string(string_data(val), val->length);
 }
 
-msgpack::msgpack(const char* name, std::string* val) : msgpack() {
+msgpack::msgpack(const char* name, std::string* val) {
     type = MSGPACK_STRING;
     MSGPACK_ALLOCATE_PTR(std::string, this);
     if (name)
@@ -288,7 +288,7 @@ msgpack::msgpack(const char* name, std::string* val) : msgpack() {
         *ptr = *val;
 }
 
-msgpack::msgpack(const char* name, wstring* val) : msgpack() {
+msgpack::msgpack(const char* name, wstring* val) {
     char* temp = utf16_to_utf8(wstring_data(val));
     type = MSGPACK_STRING;
     MSGPACK_ALLOCATE_PTR(std::string, this);
@@ -301,7 +301,7 @@ msgpack::msgpack(const char* name, wstring* val) : msgpack() {
     free(temp)
 }
 
-msgpack::msgpack(const char* name, std::wstring* val) : msgpack() {
+msgpack::msgpack(const char* name, std::wstring* val) {
     char* temp = utf16_to_utf8(val->c_str());
     type = MSGPACK_STRING;
     MSGPACK_ALLOCATE_PTR(std::string, this);

src/KKdLib/obj.hpp

@@ -50,25 +50,6 @@ enum obj_material_color_source_type : uint32_t {
     OBJ_MATERIAL_COLOR_SOURCE_VERTEX_MORPH   = 2,
 };
 
-enum obj_material_flags : uint32_t {
-    OBJ_MATERIAL_COLOR          = 0x0001,
-    OBJ_MATERIAL_COLOR_ALPHA    = 0x0002,
-    OBJ_MATERIAL_COLOR_L1       = 0x0004,
-    OBJ_MATERIAL_COLOR_L1_ALPHA = 0x0008,
-    OBJ_MATERIAL_COLOR_L2       = 0x0010,
-    OBJ_MATERIAL_COLOR_L2_ALPHA = 0x0020,
-    OBJ_MATERIAL_TRANSPARENCY   = 0x0040,
-    OBJ_MATERIAL_SPECULAR       = 0x0080,
-    OBJ_MATERIAL_NORMAL         = 0x0100,
-    OBJ_MATERIAL_NORMALALT      = 0x0200,
-    OBJ_MATERIAL_ENVIRONMENT    = 0x0400,
-    OBJ_MATERIAL_COLOR_L3       = 0x0800,
-    OBJ_MATERIAL_COLOR_L3_ALPHA = 0x1000,
-    OBJ_MATERIAL_TRANSLUCENCY   = 0x2000,
-    OBJ_MATERIAL_FLAG_14        = 0x4000,
-    OBJ_MATERIAL_OVERRIDE_IBL   = 0x8000,
-};
-
 enum obj_material_shader_lighting_type : uint32_t {
     OBJ_MATERIAL_SHADER_LIGHTING_LAMBERT  = 0x00,
     OBJ_MATERIAL_SHADER_LIGHTING_CONSTANT = 0x01,
@@ -106,14 +87,6 @@ enum obj_material_vertex_translation_type : uint32_t {
     OBJ_MATERIAL_VERTEX_TRANSLATION_MORPHING = 2,
 };
 
-enum obj_mesh_flags : uint32_t {
-    OBJ_MESH_FLAG_1                = 0x01,
-    OBJ_MESH_BILLBOARD_Y_AXIS      = 0x02,
-    OBJ_MESH_TRANSLUCENT_NO_SHADOW = 0x04,
-    OBJ_MESH_BILLBOARD             = 0x08,
-    OBJ_MESH_COMPRESSED            = 0x10, // Own stuff
-};
-
 enum obj_primitive_type : uint32_t {
     OBJ_PRIMITIVE_POINTS         = 0x00,
     OBJ_PRIMITIVE_LINES          = 0x01,
@@ -158,31 +131,20 @@ enum obj_skin_osage_root_coli_type {
     OBJ_SKIN_OSAGE_ROOT_COLI_TYPE_ELLIPSE  = 0x04,
 };
 
-enum obj_sub_mesh_flags : uint32_t {
-    OBJ_SUB_MESH_RECIEVE_SHADOW = 0x01,
-    OBJ_SUB_MESH_CAST_SHADOW    = 0x02,
-    OBJ_SUB_MESH_TRANSPARENT    = 0x04,
-    OBJ_SUB_MESH_FLAG_8         = 0x08,
-    OBJ_SUB_MESH_FLAG_10        = 0x10,
-    OBJ_SUB_MESH_FLAG_20        = 0x20,
-    OBJ_SUB_MESH_FLAG_40        = 0x40,
-    OBJ_SUB_MESH_FLAG_80        = 0x80,
-};
-
-enum obj_vertex_flags : uint32_t {
-    OBJ_VERTEX_NONE      = 0x000,
-    OBJ_VERTEX_POSITION  = 0x001,
-    OBJ_VERTEX_NORMAL    = 0x002,
-    OBJ_VERTEX_TANGENT   = 0x004,
-    OBJ_VERTEX_BINORMAL  = 0x008,
-    OBJ_VERTEX_TEXCOORD0 = 0x010,
-    OBJ_VERTEX_TEXCOORD1 = 0x020,
-    OBJ_VERTEX_TEXCOORD2 = 0x040,
-    OBJ_VERTEX_TEXCOORD3 = 0x080,
-    OBJ_VERTEX_COLOR0    = 0x100,
-    OBJ_VERTEX_COLOR1    = 0x200,
-    OBJ_VERTEX_BONE_DATA = 0x400,
-    OBJ_VERTEX_UNKNOWN   = 0x800,
+enum obj_vertex_format : uint32_t {
+    OBJ_VERTEX_FORMAT_NONE      = 0x000,
+    OBJ_VERTEX_FORMAT_POSITION  = 0x001,
+    OBJ_VERTEX_FORMAT_NORMAL    = 0x002,
+    OBJ_VERTEX_FORMAT_TANGENT   = 0x004,
+    OBJ_VERTEX_FORMAT_BINORMAL  = 0x008,
+    OBJ_VERTEX_FORMAT_TEXCOORD0 = 0x010,
+    OBJ_VERTEX_FORMAT_TEXCOORD1 = 0x020,
+    OBJ_VERTEX_FORMAT_TEXCOORD2 = 0x040,
+    OBJ_VERTEX_FORMAT_TEXCOORD3 = 0x080,
+    OBJ_VERTEX_FORMAT_COLOR0    = 0x100,
+    OBJ_VERTEX_FORMAT_COLOR1    = 0x200,
+    OBJ_VERTEX_FORMAT_BONE_DATA = 0x400,
+    OBJ_VERTEX_FORMAT_UNKNOWN   = 0x800,
 };
 
 struct obj_axis_aligned_bounding_box {
@@ -200,16 +162,114 @@ struct obj_bounding_sphere {
     float_t radius;
 };
 
-struct obj_material_blend_flags {
+struct obj_shader_compo_member {
+    uint32_t color : 1;
+    uint32_t color_a : 1;
+    uint32_t color_l1 : 1;
+    uint32_t color_l1_a : 1;
+    uint32_t color_l2 : 1;
+    uint32_t color_l2_a : 1;
+    uint32_t transparency : 1;
+    uint32_t specular : 1;
+    uint32_t normal_01 : 1;
+    uint32_t normal_02 : 1;
+    uint32_t envmap : 1;
+    uint32_t color_l3 : 1;
+    uint32_t color_l3_a : 1;
+    uint32_t translucency : 1;
+    uint32_t flag_14 : 1;
+    uint32_t override_ibl : 1;
+    uint32_t dummy : 16;
+};
+
+union obj_shader_compo {
+    obj_shader_compo_member m;
+    uint32_t w;
+};
+
+struct obj_material_shader_attrib_member {
+    obj_material_vertex_translation_type vtx_trans_type : 2;
+    obj_material_color_source_type col_src : 2;
+    uint32_t is_lgt_diffuse : 1;
+    uint32_t is_lgt_specular : 1;
+    uint32_t is_lgt_per_pixel : 1;
+    uint32_t is_lgt_double : 1;
+    obj_material_bump_map_type bump_map_type : 2;
+    uint32_t fresnel_type : 4;
+    uint32_t line_light : 4;
+    uint32_t recieve_shadow : 1;
+    uint32_t cast_shadow : 1;
+    obj_material_specular_quality specular_quality : 1;
+    obj_material_aniso_direction aniso_direction : 2;
+    uint32_t dummy : 9;
+};
+
+union obj_material_shader_attrib {
+    obj_material_shader_attrib_member m;
+    uint32_t w;
+
+    obj_material_shader_lighting_type get_lighting_type();
+};
+
+struct obj_texture_attrib_member {
+    uint32_t repeat_u : 1;
+    uint32_t repeat_v : 1;
+    uint32_t mirror_u : 1;
+    uint32_t mirror_v : 1;
+    uint32_t ignore_alpha : 1;
+    uint32_t blend : 5;
+    uint32_t alpha_blend : 5;
+    uint32_t border : 1;
+    uint32_t clamp2edge : 1;
+    uint32_t filter : 3;
+    uint32_t mipmap : 2;
+    uint32_t mipmap_bias : 7;
+    uint32_t flag_29 : 1;
+    uint32_t anisotropic_filter : 2;
+};
+
+union obj_texture_attrib {
+    obj_texture_attrib_member m;
+    uint32_t w;
+
+    int32_t get_blend();
+};
+
+struct obj_texture_shader_attrib_member {
+    obj_material_texture_type tex_type : 4;
+    int32_t uv_idx : 4;
+    obj_material_texture_coordinate_translation_type texcoord_trans : 3;
+    uint32_t dummy : 21;
+};
+
+union obj_texture_shader_attrib {
+    obj_texture_shader_attrib_member m;
+    uint32_t w;
+};
+
+struct obj_material_texture_data {
+    obj_texture_attrib attrib;
+    uint32_t tex_index;
+    obj_texture_shader_attrib shader_info;
+    char ex_shader[8];
+    float_t weight;
+    mat4u tex_coord_mat;
+    union {
+        uint32_t reserved[8];
+        int32_t texture_index;
+    };
+};
+
+struct obj_material_attrib_member {
     uint32_t alpha_texture : 1;
     uint32_t alpha_material : 1;
     uint32_t punch_through : 1;
     uint32_t double_sided : 1;
-    uint32_t normal_direction_light : 1;
+    uint32_t normal_dir_light : 1;
     obj_material_blend_factor src_blend_factor : 4;
     obj_material_blend_factor dst_blend_factor : 4;
     uint32_t blend_operation : 3;
-    uint32_t z_bias : 4;
+    uint32_t zbias : 4;
     uint32_t no_fog : 1;
     uint32_t translucent_priority : 6;
     uint32_t has_fog_height : 1;
@@ -219,94 +279,60 @@ struct obj_material_blend_flags {
     uint32_t flag_31 : 1;
 };
 
-struct obj_material_shader_flags {
-    obj_material_vertex_translation_type vertex_translation_type : 2;
-    obj_material_color_source_type color_source_type : 2;
-    uint32_t lambert_shading : 1;
-    uint32_t phong_shading : 1;
-    uint32_t per_pixel_shading : 1;
-    uint32_t double_shading : 1;
-    obj_material_bump_map_type bump_map_type : 2;
-    uint32_t fresnel : 4;
-    uint32_t line_light : 4;
-    uint32_t recieve_shadow : 1;
-    uint32_t cast_shadow : 1;
-    obj_material_specular_quality specular_quality : 1;
-    obj_material_aniso_direction aniso_direction : 2;
+union obj_material_attrib {
+    obj_material_attrib_member m;
+    uint32_t w;
 };
 
-struct obj_material_texture_flags {
-    obj_material_texture_type type : 4;
-    uint32_t tex_coord_index : 4;
-    obj_material_texture_coordinate_translation_type tex_coord_trans_type : 4;
-};
-
-struct obj_material_texture_sampler_flags {
-    uint32_t repeat_u : 1;
-    uint32_t repeat_v : 1;
-    uint32_t mirror_u : 1;
-    uint32_t mirror_v : 1;
-    uint32_t ignore_alpha : 1;
-    uint32_t blend : 5;
-    uint32_t alpha_blend : 5;
-    uint32_t border : 1;
-    uint32_t clamp_to_edge : 1;
-    uint32_t filter : 3;
-    uint32_t mip_map : 2;
-    uint32_t mip_map_bias : 7;
-    uint32_t flag_29 : 1;
-    uint32_t anisotropic_filter : 2;
-};
-
-struct obj_material_texture_texture_flags {
-    obj_material_texture_type type : 4;
-    uint32_t tex_coord_index : 4;
-    obj_material_texture_coordinate_translation_type tex_coord_trans_type : 3;
-};
-
-struct obj_material_texture {
-    obj_material_texture_sampler_flags sampler_flags;
-    uint32_t texture_id;
-    obj_material_texture_texture_flags texture_flags;
-    char shader_name[8];
-    float_t weight;
-    mat4u tex_coord_mat;
-    union {
-        int32_t reserved[8];
-        int32_t texture_index;
-    };
-};
-
-struct obj_material {
-    obj_material_flags flags;
-    union {
-        char name[8];
-        int32_t index;
-    } shader;
-    obj_material_shader_flags shader_flags;
-    obj_material_texture textures[8];
-    obj_material_blend_flags blend_flags;
+struct obj_material_color {
     vec4u diffuse;
     vec4u ambient;
     vec4u specular;
     vec4u emission;
     float_t shininess;
     float_t intensity;
-    obj_bounding_sphere reserved_sphere;
+};
+
+struct obj_material {
+    obj_shader_compo shader_compo;
+    union {
+        char name[8];
+        int32_t index;
+    } shader;
+    obj_material_shader_attrib shader_info;
+    obj_material_texture_data texdata[8];
+    obj_material_attrib attrib;
+    obj_material_color color;
+    vec3 center;
+    float_t radius;
     char name[64];
     float_t bump_depth;
     uint32_t reserved[15];
 };
 
 struct obj_material_data {
-    uint32_t textures_count;
+    uint32_t num_of_texture;
     obj_material material;
 };
 
+struct obj_sub_mesh_attrib_member {
+    uint32_t recieve_shadow : 1;
+    uint32_t cast_shadow : 1;
+    uint32_t transparent : 1;
+    uint32_t flag_3 : 1;
+    uint32_t dummy : 28;
+};
+
+union obj_sub_mesh_attrib {
+    obj_sub_mesh_attrib_member m;
+    uint32_t w;
+};
+
 struct obj_sub_mesh {
+    uint32_t flags;
     obj_bounding_sphere bounding_sphere;
     uint32_t material_index;
-    uint8_t texcoord_indices[8];
+    uint8_t uv_index[8];
     uint16_t* bone_indices;
     uint32_t bone_indices_count;
     uint32_t bones_per_vertex;
@@ -314,7 +340,7 @@ struct obj_sub_mesh {
     obj_index_format index_format;
     uint32_t* indices;
     uint32_t indices_count;
-    obj_sub_mesh_flags flags;
+    obj_sub_mesh_attrib attrib;
     union {
         obj_axis_aligned_bounding_box axis_aligned_bounding_box;
         obj_bounding_box bounding_box;
@@ -340,15 +366,31 @@ struct obj_vertex_data {
     vec4u unknown;
 };
 
+struct obj_mesh_attrib_member {
+    uint32_t flag_0 : 1;
+    uint32_t billboard_y_axis : 1;
+    uint32_t translucent_no_shadow : 1;
+    uint32_t billboard : 1;
+    uint32_t dummy : 27; // 28
+    uint32_t compressed : 1; // Own stuff
+};
+
+union obj_mesh_attrib {
+    obj_mesh_attrib_member m;
+    uint32_t w;
+};
+
 struct obj_mesh {
+    uint32_t flags;
     obj_bounding_sphere bounding_sphere;
-    obj_sub_mesh* sub_meshes;
-    uint32_t sub_meshes_count;
+    uint32_t num_submesh;
+    obj_sub_mesh* submesh_array;
+    obj_vertex_format vertex_format;
+    uint32_t size_vertex;
+    uint32_t num_vertex;
     obj_vertex_data* vertex;
-    uint32_t vertex_count;
-    uint32_t vertex_size;
-    obj_vertex_flags vertex_flags;
-    obj_mesh_flags flags;
+    obj_mesh_attrib attrib;
+    uint32_t reserved[6];
     char name[0x40];
 };
 
@@ -563,14 +605,7 @@ struct obj_skin_ex_data {
     uint32_t bone_names_count;
     obj_skin_osage_sibling_info* osage_sibling_infos;
     uint32_t osage_sibling_infos_count;
-    int64_t field_24;
-    int64_t field_28;
-    int64_t field_2C;
-    int64_t field_30;
-    int64_t field_34;
-    int64_t field_38;
-    int64_t field_3C;
-    int64_t field_40;
+    int64_t reserved[7];
 };
 
 struct obj_skin_bone {
@@ -589,11 +624,12 @@ struct obj_skin {
 
 struct obj {
     obj_bounding_sphere bounding_sphere;
-    obj_mesh* meshes;
-    uint32_t meshes_count;
-    obj_material_data* materials;
-    uint32_t materials_count;
+    obj_mesh* mesh_array;
+    uint32_t num_mesh;
+    obj_material_data* material_array;
+    uint32_t num_material;
     uint8_t flags;
+    uint32_t reserved[10];
     obj_skin skin;
     bool skin_init;
     string name;
@@ -606,10 +642,11 @@ struct obj_set {
     bool modern;
     bool is_x;
 
-    obj* objects;
-    uint32_t objects_count;
-    uint32_t* texture_ids;
-    uint32_t texture_ids_count;
+    obj* obj_data;
+    uint32_t obj_num;
+    uint32_t* tex_id_data;
+    uint32_t tex_id_num;
+    uint32_t reserved[2];
 
     obj_set();
     virtual ~obj_set();

src/KKdLib/pv_exp.cpp

@@ -0,0 +1,234 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "pv_exp.hpp"
+#include "f2/struct.hpp"
+#include "io/path.h"
+#include "io/stream.h"
+#include "str_utils.h"
+
+static void pv_exp_classic_read_inner(pv_exp* exp, stream* s);
+static void pv_exp_classic_write_inner(pv_exp* exp, stream* s);
+static void pv_exp_modern_read_inner(pv_exp* exp, stream* s, uint32_t header_length);
+static void pv_exp_modern_write_inner(pv_exp* exp, stream* s);
+
+pv_exp_mot::pv_exp_mot() : face_data(), face_cl_data() {
+
+}
+
+pv_exp_mot::~pv_exp_mot() {
+    if (face_data) {
+        delete[] face_data;
+        face_data = 0;
+    }
+
+    if (face_cl_data) {
+        delete[] face_cl_data;
+        face_cl_data = 0;
+    }
+}
+
+pv_exp::pv_exp() : ready(), modern(), is_x() {
+
+}
+
+pv_exp::~pv_exp() {
+
+}
+
+void pv_exp::read(const char* path, bool modern) {
+    if (!path)
+        return;
+
+    if (!modern) {
+        char* path_bin = str_utils_add(path, ".bin");
+        if (path_check_file_exists(path_bin)) {
+            stream s;
+            io_open(&s, path_bin, "rb");
+            if (s.io.stream) {
+                uint8_t* data = force_malloc_s(uint8_t, s.length);
+                io_read(&s, data, s.length);
+                stream s_bin;
+                io_open(&s_bin, data, s.length);
+                pv_exp_classic_read_inner(this, &s_bin);
+                io_free(&s_bin);
+                free(data);
+            }
+            io_free(&s);
+        }
+        free(path_bin);
+    }
+    else {
+        char* path_dex = str_utils_add(path, ".dex");
+        if (path_check_file_exists(path_dex)) {
+            f2_struct st;
+            st.read(path_dex);
+            if (st.header.signature == reverse_endianness_uint32_t('EXPC')) {
+                stream s_expc;
+                io_open(&s_expc, &st.data);
+                s_expc.is_big_endian = st.header.use_big_endian;
+                pv_exp_modern_read_inner(this, &s_expc, st.header.length);
+                io_free(&s_expc);
+            }
+        }
+        free(path_dex);
+    }
+}
+
+void pv_exp::read(const wchar_t* path, bool modern) {
+    if (!path)
+        return;
+
+    if (!modern) {
+        wchar_t* path_bin = str_utils_add(path, L".bin");
+        if (path_check_file_exists(path_bin)) {
+            stream s;
+            io_open(&s, path_bin, L"rb");
+            if (s.io.stream) {
+                uint8_t* data = force_malloc_s(uint8_t, s.length);
+                io_read(&s, data, s.length);
+                stream s_bin;
+                io_open(&s_bin, data, s.length);
+                pv_exp_classic_read_inner(this, &s_bin);
+                io_free(&s_bin);
+                free(data);
+            }
+            io_free(&s);
+        }
+        free(path_bin);
+    }
+    else {
+        wchar_t* path_dex = str_utils_add(path, L".dex");
+        if (path_check_file_exists(path_dex)) {
+            f2_struct st;
+            st.read(path_dex);
+            if (st.header.signature == reverse_endianness_uint32_t('EXPC')) {
+                stream s_expc;
+                io_open(&s_expc, &st.data);
+                s_expc.is_big_endian = st.header.use_big_endian;
+                pv_exp_modern_read_inner(this, &s_expc, st.header.length);
+                io_free(&s_expc);
+            }
+        }
+        free(path_dex);
+    }
+}
+
+void pv_exp::read(const void* data, size_t size, bool modern) {
+    if (!data || !size)
+        return;
+
+    if (!modern) {
+        stream s;
+        io_open(&s, data, size);
+        pv_exp_classic_read_inner(this, &s);
+        io_free(&s);
+    }
+    else {
+        f2_struct st;
+        st.read(data, size);
+        if (st.header.signature == reverse_endianness_uint32_t('EXPC')) {
+            stream s_expc;
+            io_open(&s_expc, &st.data);
+            s_expc.is_big_endian = st.header.use_big_endian;
+            pv_exp_modern_read_inner(this, &s_expc, st.header.length);
+            io_free(&s_expc);
+        }
+    }
+}
+
+void pv_exp::write(const char* path) {
+    if (!path || !ready)
+        return;
+
+    if (!modern) {
+        char* path_bin = str_utils_add(path, ".bin");
+        stream s;
+        io_open(&s, path_bin, "wb");
+        if (s.io.stream)
+            pv_exp_classic_write_inner(this, &s);
+        io_free(&s);
+        free(path_bin);
+    }
+    else {
+        char* path_dex = str_utils_add(path, ".dex");
+        stream s;
+        io_open(&s, path_dex, "wb");
+        if (s.io.stream)
+            pv_exp_modern_write_inner(this, &s);
+        io_free(&s);
+        free(path_dex);
+    }
+}
+
+void pv_exp::write(const wchar_t* path) {
+    if (!path || !ready)
+        return;
+
+    if (!modern) {
+        wchar_t* path_bin = str_utils_add(path, L".bin");
+        stream s;
+        io_open(&s, path_bin, L"wb");
+        if (s.io.stream)
+            pv_exp_classic_write_inner(this, &s);
+        io_free(&s);
+        free(path_bin);
+    }
+    else {
+        wchar_t* path_dex = str_utils_add(path, L".dex");
+        stream s;
+        io_open(&s, path_dex, L"wb");
+        if (s.io.stream)
+            pv_exp_modern_write_inner(this, &s);
+        io_free(&s);
+        free(path_dex);
+    }
+}
+
+void pv_exp::write(void** data, size_t* size) {
+    if (!data || !size || !ready)
+        return;
+
+    stream s;
+    io_open(&s);
+    if (!modern)
+        pv_exp_classic_write_inner(this, &s);
+    else
+        pv_exp_modern_write_inner(this, &s);
+    io_align_write(&s, 0x10);
+    io_copy(&s, data, size);
+    io_free(&s);
+}
+
+bool pv_exp::load_file(void* data, const char* path, const char* file, uint32_t hash) {
+    size_t file_len = utf8_length(file);
+
+    const char* t = strrchr(file, '.');
+    if (t)
+        file_len = t - file;
+
+    std::string s = path + std::string(file, file_len);
+
+    pv_exp* exp = (pv_exp*)data;
+    exp->read(s.c_str(), exp->modern);
+
+    return exp->ready;
+}
+
+static void pv_exp_classic_read_inner(pv_exp* exp, stream* s) {
+
+}
+
+static void pv_exp_classic_write_inner(pv_exp* exp, stream* s) {
+
+}
+
+static void pv_exp_modern_read_inner(pv_exp* exp, stream* s, uint32_t header_length) {
+
+}
+
+static void pv_exp_modern_write_inner(pv_exp* exp, stream* s) {
+
+}

src/KKdLib/pv_exp.hpp

@@ -0,0 +1,47 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include "default.h"
+
+struct pv_exp_data {
+    float_t frame;
+    int16_t type;
+    int16_t id;
+    float_t value;
+    float_t trans;
+};
+
+struct pv_exp_mot {
+    pv_exp_data* face_data;
+    pv_exp_data* face_cl_data;
+    std::string name;
+
+    pv_exp_mot();
+    ~pv_exp_mot();
+};
+
+struct pv_exp {
+    bool ready;
+    bool modern;
+    bool is_x;
+
+    std::vector<pv_exp_mot> motion_data;
+
+    pv_exp();
+    ~pv_exp();
+
+    void read(const char* path, bool modern);
+    void read(const wchar_t* path, bool modern);
+    void read(const void* data, size_t size, bool modern);
+    void write(const char* path);
+    void write(const wchar_t* path);
+    void write(void** data, size_t* size);
+
+    static bool load_file(void* data, const char* path, const char* file, uint32_t hash);
+};

src/KKdLib/str_utils.c

@@ -424,7 +424,7 @@ wchar_t* str_utils_copy(const wchar_t* str) {
 }
 
 inline int32_t str_utils_compare(const char* str0, const char* str1) {
-    int32_t diff = 0;;
+    int32_t diff = 0;
     char c0;
     char c1;
     do
@@ -438,7 +438,7 @@ inline int32_t str_utils_compare(const char* str0, const char* str1) {
 }
 
 inline int32_t str_utils_compare(const wchar_t* str0, const wchar_t* str1) {
-    int32_t diff = 0;;
+    int32_t diff = 0;
     wchar_t c0;
     wchar_t c1;
     do
@@ -457,7 +457,7 @@ inline int32_t str_utils_compare_length(const char* str0, size_t str0_len, const
     else if (!str1_len)
         return *str0;
 
-    int32_t diff = 0;;
+    int32_t diff = 0;
     char c0;
     char c1;
     do
@@ -476,7 +476,7 @@ inline int32_t str_utils_compare_length(const wchar_t* str0, size_t str0_len, co
     else if (!str1_len)
         return *str0;
 
-    int32_t diff = 0;;
+    int32_t diff = 0;
     wchar_t c0;
     wchar_t c1;
     do

src/KKdLib/txp.cpp

@@ -287,24 +287,24 @@ bool txp_set::produce_enrs(enrs* enrs) {
     enrs_entry ee;
 
     ee = { 0, 1, 12, 1 };
-    ee.sub.push_back({ 0, 3, ENRS_DWORD });
+    ee.append(0, 3, ENRS_DWORD);
     enrs->vec.push_back(ee);
     l += o = 12;
 
     ee = { o, 1, (uint32_t)(count * 4), 1 };
-    ee.sub.push_back({ 0, (uint32_t)count, ENRS_DWORD });
+    ee.append(0, (uint32_t)count, ENRS_DWORD);
     enrs->vec.push_back(ee);
     l += (size_t)(o = (uint32_t)(count * 4ULL));
 
     tex = textures.data();
     for (size_t i = 0; i < count; i++, tex++) {
         ee = { o, 1, 12, 1 };
-        ee.sub.push_back({ 0, 3, ENRS_DWORD });
+        ee.append(0, 3, ENRS_DWORD);
         enrs->vec.push_back(ee);
         l += o = 12;
 
         ee = { o, 1, tex->array_size * 4, tex->mipmaps_count };
-        ee.sub.push_back({ 0, tex->array_size, ENRS_DWORD });
+        ee.append(0, tex->array_size, ENRS_DWORD);
         enrs->vec.push_back(ee);
         l += (size_t)(o = (uint32_t)((size_t)tex->array_size * tex->mipmaps_count * 4));
 
@@ -312,7 +312,7 @@ bool txp_set::produce_enrs(enrs* enrs) {
         for (size_t j = 0; j < tex->array_size; j++) {
             for (size_t k = 0; k < tex->mipmaps_count; k++, tex_mipmap++) {
                 ee = { o, 1, 24, 1 };
-                ee.sub.push_back({ 0, 6, ENRS_DWORD });
+                ee.append(0, 6, ENRS_DWORD);
                 enrs->vec.push_back(ee);
                 l += (size_t)(o = (uint32_t)(24 + tex_mipmap->size));
             }