v0.4.0.0

src/CLOUD/Classes/background_color.c

@@ -1,102 +0,0 @@
-/*
-    by korenkonder
-    GitHub/GitLab: korenkonder
-*/
-
-#include "background_color.h"
-#include "../../CRE/microui.h"
-
-extern mu_Context* muctx;
-
-extern int32_t width;
-extern int32_t height;
-
-const char* background_color_window_title = "Background Color";
-
-background_color_struct background_color;
-
-void background_color_dispose() {
-    background_color.enabled = false;
-    background_color.dispose = false;
-    background_color.disposed = true;
-}
-
-void background_color_init() {
-    background_color.enabled = true;
-}
-
-void background_color_control() {
-    if (!background_color.enabled)
-        return;
-}
-
-void background_color_input() {
-    if (!background_color.enabled)
-        return;
-}
-
-void background_color_mui() {
-    if (!background_color.enabled)
-        return;
-    else if (background_color.disposed) {
-        mu_Container* cnt = mu_get_container(muctx, background_color_window_title);
-        muctx->hover_root = muctx->next_hover_root = cnt;
-        cnt->rect = mu_rect(0, 0, 0, 0);
-        cnt->open = true;
-        mu_bring_to_front(muctx, cnt);
-        background_color.disposed = false;
-    }
-
-    int32_t w = min(width / 3, 360);
-    int32_t h = muctx->style->title_height + 104;
-
-    if (!mu_begin_window_ex(muctx, background_color_window_title,
-        mu_rect(0, 0, w, h),
-        0 /*MU_OPT_NOINTERACT | MU_OPT_NOCLOSE*/, false, true, false)) {
-        background_color.dispose = true;
-        return;
-    }
-
-    mu_layout_row(muctx, 2, (int[]) { -78, -1 }, 74);
-
-    mu_layout_begin_column(muctx);
-    mu_layout_row(muctx, 2, (int[]) { 46, -1 }, 0);
-
-    mu_Color c = mu_color_real(background_color.color.x, background_color.color.y, background_color.color.z, 1.0f);
-    mu_label(muctx, "Red:");
-    mu_slider_uint8_t(muctx, &c.r, 0, 255);
-    mu_label(muctx, "Green:");
-    mu_slider_uint8_t(muctx, &c.g, 0, 255);
-    mu_label(muctx, "Blue:");
-    mu_slider_uint8_t(muctx, &c.b, 0, 255);
-    background_color.color.x = c.r;
-    background_color.color.y = c.g;
-    background_color.color.z = c.b;
-    vec3_mult_scalar(background_color.color, 1.0f / 255.0f, background_color.color);
-
-    mu_layout_row(muctx, 1, (int[]) { -1 }, 0);
-    if (mu_button(muctx, "Reset Color"))
-        background_color.color = (vec3){ 0.74117647f, 0.74117647f, 0.74117647f };
-    mu_layout_end_column(muctx);
-
-    mu_Rect r = mu_layout_next(muctx);
-    mu_draw_rect(muctx, r, c);
-    char buf[32];
-    sprintf_s(buf, 32, "#%02X%02X%02X", c.r, c.g, c.b);
-    mu_draw_control_text(muctx, buf, r, MU_COLOR_TEXT, MU_OPT_ALIGNCENTER);
-    mu_end_window(muctx);
-}
-
-void background_color_render() {
-    if (background_color.dispose) {
-        background_color_dispose();
-        return;
-    }
-    else if (!background_color.enabled)
-        return;
-}
-
-void background_color_sound() {
-    if (!background_color.enabled)
-        return;
-}

src/CLOUD/Classes/background_color.h

@@ -1,26 +0,0 @@
-/*
-    by korenkonder
-    GitHub/GitLab: korenkonder
-*/
-
-#pragma once
-
-#include "../../KKdLib/default.h"
-#include "../../KKdLib/vec.h"
-
-typedef struct background_color_struct {
-    bool enabled;
-    bool dispose;
-    bool disposed;
-    vec3 color;
-} background_color_struct;
-
-extern background_color_struct background_color;
-
-extern void background_color_dispose();
-extern void background_color_init();
-extern void background_color_control();
-extern void background_color_input();
-extern void background_color_mui();
-extern void background_color_render();
-extern void background_color_sound();

src/CLOUD/Classes/glitter_editor.h

@@ -5,38 +5,17 @@
 
 #pragma once
 
+#ifdef CLOUD_DEV
 #include "../../KKdLib/default.h"
 #include "../../KKdLib/vec.h"
 #include "../../CRE/Glitter/glitter.h"
 
-typedef struct glitter_editor_struct {
-    bool enabled;
-    bool dispose;
-    bool disposed;
-    bool load;
-    bool save;
-    bool save_big_endian;
-    bool input_play;
-    bool input_stop;
-    bool input_pause;
-    bool input_reload;
-    float_t frame_counter;
-    float_t old_frame_counter;
-    float_t start_frame;
-    float_t end_frame;
-    int32_t random;
-    int32_t counter;
-    glitter_effect_group* effect_group;
-    glitter_scene* scene;
-    wchar_t file[MAX_PATH];
-} glitter_editor_struct;
-
-extern glitter_editor_struct glitter_editor;
+extern bool glitter_editor_enabled;
 
 extern void glitter_editor_dispose();
 extern void glitter_editor_init();
-extern void glitter_editor_control();
+extern void glitter_editor_drop(size_t count, wchar_t** paths);
+extern void glitter_editor_imgui();
 extern void glitter_editor_input();
-extern void glitter_editor_mui();
 extern void glitter_editor_render();
-extern void glitter_editor_sound();
+#endif

src/CLOUD/Classes/glitter_test.c

@@ -1,235 +0,0 @@
-/*
-    by korenkonder
-    GitHub/GitLab: korenkonder
-*/
-
-#include "glitter_test.h"
-#include "../../CRE/Glitter/glitter.h"
-#include "../../CRE/Glitter/effect_group.h"
-#include "../../CRE/Glitter/file_reader.h"
-#include "../../CRE/Glitter/particle_manager.h"
-#include "../../CRE/Glitter/scene.h"
-#include "../../CRE/microui.h"
-#include "../input.h"
-
-extern mu_Context* muctx;
-
-extern int32_t width;
-extern int32_t height;
-extern bool input_reset;
-extern float_t frame_speed;
-
-extern glitter_particle_manager* gpm;
-
-const char* glitter_test_window_title = "Glitter";
-
-glitter_test_struct glitter_test;
-
-void glitter_test_dispose() {
-    vector_ptr_glitter_scene_clear(&gpm->scenes, (void*)glitter_scene_dispose);
-    vector_ptr_glitter_effect_group_clear(&gpm->effect_groups, (void*)glitter_effect_group_dispose);
-
-    vector_ptr_wchar_t_free(&glitter_test.files, 0);
-    glitter_test.file = 0;
-    glitter_test.input_play = false;
-    glitter_test.input_stop = false;
-    glitter_test.input_auto = false;
-    glitter_test.input_pause = false;
-    glitter_test.frame_counter = 0.0f;
-    glitter_test.enabled = false;
-    glitter_test.dispose = false;
-    glitter_test.disposed = true;
-}
-
-void glitter_test_init() {
-    vector_ptr_wchar_t_free(&glitter_test.files, 0);
-    path_wget_files(&glitter_test.files, L"rom\\particle");
-    for (wchar_t** i = glitter_test.files.begin; i != glitter_test.files.end; i++) {
-        wchar_t* temp = 0;
-        if (path_wcheck_ends_with(*i, L".farc"))
-            temp = path_wget_without_extension(*i);
-        free(*i);
-        *i = temp;
-    }
-
-    size_t glitter_test_files_count = 0;
-    for (wchar_t** i = glitter_test.files.begin; i != glitter_test.files.end; i++)
-        if (*i)
-            glitter_test.files.begin[glitter_test_files_count++] = *i;
-    glitter_test.files.end = &glitter_test.files.begin[glitter_test_files_count];
-    glitter_test.enabled = true;
-    gpm->emission = 1.0f;
-}
-
-void glitter_test_control() {
-    if (!glitter_test.enabled)
-        return;
-}
-
-void glitter_test_input() {
-    if (!glitter_test.enabled)
-        return;
-
-    if (input_is_tapped('F'))
-        glitter_test.input_play = true;
-
-    if (input_is_tapped('V'))
-        glitter_test.input_stop = true;
-
-    if (input_is_tapped('T'))
-        glitter_test.input_auto ^= true;
-
-    if (input_is_tapped('G'))
-        glitter_test.input_pause ^= true;
-}
-
-void glitter_test_mui() {
-    if (!glitter_test.enabled)
-        return;
-    else if (glitter_test.disposed) {
-        mu_Container* cnt = mu_get_container(muctx, glitter_test_window_title);
-        muctx->hover_root = muctx->next_hover_root = cnt;
-        cnt->rect = mu_rect(0, 0, 0, 0);
-        cnt->open = true;
-        mu_bring_to_front(muctx, cnt);
-        glitter_test.disposed = false;
-    }
-
-    int32_t w = min(width / 3, 360);
-    int32_t h = 340;
-
-    if (!mu_begin_window_ex(muctx, glitter_test_window_title,
-        mu_rect(0, 0, w, h),
-        0 /*MU_OPT_NOINTERACT | MU_OPT_NOCLOSE*/, false, true, false)) {
-        glitter_test.dispose = true;
-        return;
-    }
-
-    mu_layout_row(muctx, 2, (int[]) { 32, -1 }, 0);
-    mu_label(muctx, "File:");
-    char* glitter_file_temp = wchar_t_string_to_char_string(glitter_test.file);
-    if (mu_button(muctx, glitter_file_temp ? glitter_file_temp : "..."))
-        mu_open_popup(muctx, "glitter file");
-    free(glitter_file_temp);
-
-    if (mu_begin_window_ex(muctx, "glitter file",
-        mu_rect(0, 0, 240, 360),
-        MU_OPT_NOTITLE | MU_OPT_POPUP | MU_OPT_CLOSED, false, true, false)) {
-        mu_Rect body = muctx->layout_stack.items[muctx->layout_stack.idx - 1].body;
-        mu_layout_row(muctx, 1, (int[]) { body.w }, 0);
-        for (wchar_t** i = glitter_test.files.begin; i != glitter_test.files.end; i++) {
-            mu_push_id(muctx, &i, sizeof(i));
-            char* temp = wchar_t_string_to_char_string(*i);
-            if (glitter_test.file && !wcscmp(*i, glitter_test.file))
-                mu_draw_control_text(muctx, temp, mu_layout_next(muctx), MU_COLOR_TEXT, MU_OPT_ALIGNCENTER);
-            else if (mu_button(muctx, temp))
-                glitter_test.file = *i;
-            free(temp);
-            mu_pop_id(muctx);
-        }
-        mu_end_window(muctx);
-    }
-
-    mu_layout_row(muctx, 1, (int[]) { -1 }, 0);
-    if (mu_button(muctx, "Reset Camera (R)"))
-        input_reset = true;
-
-    if (mu_button(muctx, "Play (F)"))
-        glitter_test.input_play = true;
-
-    if (mu_button(muctx, "Stop (V)"))
-        glitter_test.input_stop = true;
-
-    mu_checkbox(muctx, "Auto (T)", &glitter_test.input_auto);
-    mu_checkbox(muctx, "Pause (G)", &glitter_test.input_pause);
-
-    size_t ctrl;
-    size_t disp;
-    float_t frame;
-    float_t life_time;
-    char buf[0x40];
-
-    mu_layout_row(muctx, 1, (int[]) { -1 }, 0);
-    glitter_particle_manager_get_frame(gpm, &frame, &life_time);
-    sprintf_s(buf, sizeof(buf), "%.0f - %.0f/%.0f", glitter_test.frame_counter, frame, life_time);
-    mu_label(muctx, buf);
-
-    mu_layout_row(muctx, 2, (int[]) { 40, -1 }, 0);
-    ctrl = glitter_particle_manager_get_ctrl_count(gpm, GLITTER_PARTICLE_QUAD);
-    disp = glitter_particle_manager_get_disp_count(gpm, GLITTER_PARTICLE_QUAD);
-    mu_label(muctx, "Quad: ");
-    sprintf_s(buf, sizeof(buf), "ctrl%lld, disp%lld", ctrl, disp);
-    mu_label(muctx, buf);
-
-    ctrl = glitter_particle_manager_get_ctrl_count(gpm, GLITTER_PARTICLE_LOCUS);
-    disp = glitter_particle_manager_get_disp_count(gpm, GLITTER_PARTICLE_LOCUS);
-    mu_label(muctx, "Locus: ");
-    sprintf_s(buf, sizeof(buf), "ctrl%lld, disp%lld", ctrl, disp);
-    mu_label(muctx, buf);
-
-    ctrl = glitter_particle_manager_get_ctrl_count(gpm, GLITTER_PARTICLE_LINE);
-    disp = glitter_particle_manager_get_disp_count(gpm, GLITTER_PARTICLE_LINE);
-    mu_label(muctx, "Line: ");
-    sprintf_s(buf, sizeof(buf), "ctrl%lld, disp%lld", ctrl, disp);
-    mu_label(muctx, buf);
-
-    mu_layout_row(muctx, 2, (int[]) { 80, -1 }, 0);
-    mu_label(muctx, "Emission: ");
-    mu_slider_step(muctx, &gpm->emission, 1.0f, 2.0f, 0.01f);
-
-    mu_label(muctx, "Frame Speed: ");
-    mu_slider_step(muctx, &frame_speed, 0.0f, 3.0f, 0.01f);
-    mu_end_window(muctx);
-}
-
-void glitter_test_render() {
-    if (glitter_test.dispose) {
-        glitter_test_dispose();
-        return;
-    }
-    else if (!glitter_test.enabled)
-        return;
-
-    if (!glitter_test.input_pause) {
-        if (gpm->scenes.end != gpm->scenes.begin)
-            glitter_test.frame_counter += get_frame_speed();
-
-        glitter_particle_manager_update_scene(gpm);
-    }
-
-    if (glitter_test.file) {
-        uint64_t hash = gpm->f2
-            ? hash_wchar_t_murmurhash(glitter_test.file, 0, false)
-            : hash_wchar_t_fnv1a64(glitter_test.file);
-        if (glitter_test.input_play || glitter_test.input_stop) {
-            glitter_particle_manager_free_scene(gpm, hash);
-            glitter_test.frame_counter = 0.0f;
-        }
-
-        if (glitter_test.input_auto && !glitter_particle_manager_check_scene(gpm, hash)) {
-            if (glitter_particle_manager_check_effect_group(gpm, hash))
-                goto load;
-            else
-                goto reset;
-        }
-        else if (glitter_test.input_play && !glitter_particle_manager_test_load_scene(gpm, hash)) {
-        reset:
-            vector_ptr_glitter_scene_clear(&gpm->scenes, (void*)glitter_scene_dispose);
-            vector_ptr_glitter_effect_group_clear(&gpm->effect_groups, (void*)glitter_effect_group_dispose);
-
-            glitter_file_reader* fr = glitter_file_reader_init(0, glitter_test.file, gpm->f2, -1.0f);
-            vector_ptr_glitter_file_reader_push_back(&gpm->file_readers, &fr);
-            glitter_particle_manager_update_file_reader(gpm);
-        load:
-            glitter_test.frame_counter = 0.0f;
-            glitter_particle_manager_test_load_scene(gpm, hash);
-        }
-        glitter_test.input_play = false;
-        glitter_test.input_stop = false;
-    }
-}
-
-void glitter_test_sound() {
-    if (!glitter_test.enabled)
-        return;
-}

src/CLOUD/Classes/glitter_test.h

@@ -1,32 +0,0 @@
-/*
-    by korenkonder
-    GitHub/GitLab: korenkonder
-*/
-
-#pragma once
-
-#include "../../KKdLib/default.h"
-#include "../../KKdLib/vector.h"
-
-typedef struct glitter_test_struct {
-    bool enabled;
-    bool dispose;
-    bool disposed;
-    bool input_play;
-    bool input_stop;
-    bool input_auto;
-    bool input_pause;
-    float_t frame_counter;
-    wchar_t* file;
-    vector_ptr_wchar_t files;
-} glitter_test_struct;
-
-extern glitter_test_struct glitter_test;
-
-extern void glitter_test_dispose();
-extern void glitter_test_init();
-extern void glitter_test_control();
-extern void glitter_test_input();
-extern void glitter_test_mui();
-extern void glitter_test_render();
-extern void glitter_test_sound();

src/CLOUD/Classes/post_process.c

@@ -1,257 +0,0 @@
-/*
-    by korenkonder
-    GitHub/GitLab: korenkonder
-*/
-
-#include "post_process.h"
-#include "../../CRE/microui.h"
-#include "../../CRE/post_process.h"
-
-extern mu_Context* muctx;
-
-extern int32_t width;
-extern int32_t height;
-
-const char* post_process_window_title = "Post Process";
-
-extern radius* rad;
-extern intensity* inten;
-extern tone_map_sat_gamma* tmsg;
-extern tone_map_data* tmd;
-
-post_process_struct post_process;
-
-extern void post_process_dispose() {
-    post_process.enabled = false;
-    post_process.dispose = false;
-    post_process.disposed = true;
-}
-
-extern void post_process_init() {
-    post_process.enabled = true;
-}
-
-extern void post_process_control() {
-    if (!post_process.enabled)
-        return;
-}
-
-extern void post_process_input() {
-    if (!post_process.enabled)
-        return;
-}
-
-extern void post_process_mui() {
-    if (!post_process.enabled)
-        return;
-    else if (post_process.disposed) {
-        mu_Container* cnt = mu_get_container(muctx, post_process_window_title);
-        muctx->hover_root = muctx->next_hover_root = cnt;
-        cnt->rect = mu_rect(0, 0, 0, 0);
-        cnt->open = true;
-        mu_bring_to_front(muctx, cnt);
-        post_process.disposed = false;
-    }
-
-    int32_t w = min(width / 3, 360);
-    int32_t h = 540;
-
-    if (!mu_begin_window_ex(muctx, post_process_window_title,
-        mu_rect(0, 0, w, h),
-        0 /*MU_OPT_NOINTERACT | MU_OPT_NOCLOSE*/, false, true, false)) {
-        post_process.dispose = true;
-        return;
-    }
-
-    if (mu_begin_treenode(muctx, "Tone Trans")) {
-        int32_t tw0 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "Start", "End"
-        }, 2);
-        int32_t tw1 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "R:"
-        }, 1);
-        int32_t tw2 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "G:"
-        }, 1);
-        int32_t tw3 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "B:"
-        }, 1);
-        mu_Rect body = muctx->layout_stack.items[muctx->layout_stack.idx - 1].body;
-        int32_t sw = (int)((body.w - (tw0 + 4) - (tw1 + 2) - (tw2 + 2) - (tw3 + 2) - (muctx->style->spacing + 2) * 7) / 3.0f);
-
-        mu_layout_row(muctx, 7, (int[]) { tw0, tw1, sw, tw2, sw, tw3, sw }, 0);
-
-        vec3 tone_trans_start = *tone_map_data_get_tone_trans_start(tmd);
-        mu_label(muctx, "Start");
-        mu_label(muctx, "R:");
-        mu_slider_step(muctx, &tone_trans_start.x, 0.0f, 1.0f, 0.01f);
-        mu_label(muctx, "G:");
-        mu_slider_step(muctx, &tone_trans_start.y, 0.0f, 1.0f, 0.01f);
-        mu_label(muctx, "B:");
-        mu_slider_step(muctx, &tone_trans_start.z, 0.0f, 1.0f, 0.01f);
-        tone_map_data_set_tone_trans_start(tmd, &tone_trans_start);
-
-        vec3 tone_trans_end = *tone_map_data_get_tone_trans_end(tmd);
-        mu_label(muctx, "End");
-        mu_label(muctx, "R:");
-        mu_slider_step(muctx, &tone_trans_end.x, 0.0f, 1.0f, 0.01f);
-        mu_label(muctx, "G:");
-        mu_slider_step(muctx, &tone_trans_end.y, 0.0f, 1.0f, 0.01f);
-        mu_label(muctx, "B:");
-        mu_slider_step(muctx, &tone_trans_end.z, 0.0f, 1.0f, 0.01f);
-        tone_map_data_set_tone_trans_end(tmd, &tone_trans_end);
-        mu_end_treenode(muctx);
-    }
-
-    if (mu_begin_treenode(muctx, "Scene Fade")) {
-        int32_t tw0 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "Alpha:", "Color", "Blend Func:"
-        }, 3);
-        int32_t tw1 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "R:"
-        }, 1);
-        int32_t tw2 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "G:"
-        }, 1);
-        int32_t tw3 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "B:"
-        }, 1);
-        mu_Rect body = muctx->layout_stack.items[muctx->layout_stack.idx - 1].body;
-        int32_t sw = (int)((body.w - (tw0 + 4) - (tw1 + 2) - (tw2 + 2) - (tw3 + 2) - (muctx->style->spacing + 2) * 7) / 3.0f);
-
-        mu_layout_row(muctx, 2, (int[]) { tw0, -1 }, 0);
-
-        float_t scene_fade_alpha = tone_map_data_get_scene_fade_alpha(tmd);
-        mu_label(muctx, "Alpha:");
-        mu_slider_step(muctx, &scene_fade_alpha, 0.0f, 1.0f, 0.01f);
-        tone_map_data_set_scene_fade_alpha(tmd, scene_fade_alpha);
-
-        mu_layout_row(muctx, 7, (int[]) { tw0, tw1, sw, tw2, sw, tw3, sw }, 0);
-
-        vec3 scene_fade_color = *tone_map_data_get_scene_fade_color(tmd);
-        mu_label(muctx, "Color");
-        mu_label(muctx, "R:");
-        mu_slider_step(muctx, &scene_fade_color.x, 0.0f, 1.0f, 0.01f);
-        mu_label(muctx, "G:");
-        mu_slider_step(muctx, &scene_fade_color.y, 0.0f, 1.0f, 0.01f);
-        mu_label(muctx, "B:");
-        mu_slider_step(muctx, &scene_fade_color.z, 0.0f, 1.0f, 0.01f);
-        tone_map_data_set_scene_fade_color(tmd, &scene_fade_color);
-
-        mu_layout_row(muctx, 2, (int[]) { tw0, -1 }, 0);
-
-        const char* blend_func_label;
-        uint8_t scene_fade_blend_func = (uint8_t)tone_map_data_get_scene_fade_blend_func(tmd);
-        switch (scene_fade_blend_func) {
-        case 0:
-        default:
-            blend_func_label = "0: OVER";
-            break;
-        case 1:
-            blend_func_label = "1: MULTI";
-            break;
-        case 2:
-            blend_func_label = "2: PLUS";
-            break;
-        }
-        mu_label(muctx, "Blend Func:");
-        mu_slider_uint8_t_label(muctx, &scene_fade_blend_func, 0, 2, blend_func_label);
-        tone_map_data_set_scene_fade_blend_func(tmd, scene_fade_blend_func);
-        mu_end_treenode(muctx);
-    }
-
-    if (mu_begin_treenode_ex(muctx, "Glow Param", MU_OPT_EXPANDED)) {
-        int32_t tw0 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "Tone Map:", "Exposure:", "Gamma:", "Saturate 1:", "Saturate 2:"
-        }, 5);
-
-        mu_layout_row(muctx, 2, (int[]) { tw0, -1 }, 0);
-
-        const char* tone_map_method_label;
-        uint8_t tone_map_method = (uint8_t)tone_map_data_get_tone_map_method(tmd);
-        switch (tone_map_method) {
-        case 0:
-        default:
-            tone_map_method_label = "YCC EXPONENT";
-            break;
-        case 1:
-            tone_map_method_label = "RGB LINEAR";
-            break;
-        case 2:
-            tone_map_method_label = "RGB LINEAR2";
-            break;
-        }
-        mu_label(muctx, "Tone Map:");
-        mu_slider_uint8_t_label(muctx, &tone_map_method, 0, 2, tone_map_method_label);
-        tone_map_data_set_tone_map_method(tmd, tone_map_method);
-
-        mu_layout_row(muctx, 1, (int[]) { -1 }, 0);
-        bool auto_exposure = tone_map_data_get_auto_exposure(tmd);
-        mu_checkbox(muctx, "Auto Exposure", &auto_exposure);
-        tone_map_data_set_auto_exposure(tmd, auto_exposure);
-
-        mu_layout_row(muctx, 2, (int[]) { tw0, -1 }, 0);
-        float_t exposure = tone_map_data_get_exposure(tmd);
-        mu_label(muctx, "Exposure:");
-        mu_slider_step(muctx, &exposure, 0.0f, 4.0f, 0.02f);
-        tone_map_data_set_exposure(tmd, exposure);
-
-        float_t gamma = tone_map_sat_gamma_get_gamma(tmsg);
-        mu_label(muctx, "Gamma:");
-        mu_slider_step(muctx, &gamma, 0.2f, 2.2f, 0.01f);
-        tone_map_sat_gamma_set_gamma(tmsg, gamma);
-
-        uint8_t saturate1 = tone_map_sat_gamma_get_saturate1(tmsg);
-        mu_label(muctx, "Saturate 1:");
-        mu_slider_uint8_t(muctx, &saturate1, 1, 6);
-        tone_map_sat_gamma_set_saturate1(tmsg, saturate1);
-
-        float_t saturate2 = tone_map_sat_gamma_get_saturate2(tmsg);
-        mu_label(muctx, "Saturate 2:");
-        mu_slider_step(muctx, &saturate2, 0.0f, 1.0f, 0.01f);
-        tone_map_sat_gamma_set_saturate2(tmsg, saturate2);
-        mu_end_treenode(muctx);
-    }
-
-    if (mu_begin_treenode_ex(muctx, "Glare", MU_OPT_EXPANDED)) {
-        int32_t tw0 = mu_misc_get_max_text_width(muctx, (char* []) {
-            "Radius R:", "Radius G:", "Radius B:", "Inten  R:", "Inten  G:", "Inten  B:"
-        }, 6);
-
-        mu_layout_row(muctx, 2, (int[]) { tw0, -1 }, 0);
-
-        vec3 radius = *radius_get(rad);
-        mu_label(muctx, "Radius R:");
-        mu_slider_step(muctx, &radius.x, 1.0f, 3.0f, 0.01f);
-        mu_label(muctx, "Radius G:");
-        mu_slider_step(muctx, &radius.y, 1.0f, 3.0f, 0.01f);
-        mu_label(muctx, "Radius B:");
-        mu_slider_step(muctx, &radius.z, 1.0f, 3.0f, 0.01f);
-        radius_set(rad, &radius);
-
-        vec3 intensity = *intensity_get(inten);
-        mu_label(muctx, "Inten  R:");
-        mu_slider_step(muctx, &intensity.x, 0.0f, 2.0f, 0.01f);
-        mu_label(muctx, "Inten  G:");
-        mu_slider_step(muctx, &intensity.y, 0.0f, 2.0f, 0.01f);
-        mu_label(muctx, "Inten  B:");
-        mu_slider_step(muctx, &intensity.z, 0.0f, 2.0f, 0.01f);
-        intensity_set(inten, &intensity);
-        mu_end_treenode(muctx);
-    }
-    mu_end_window(muctx);
-}
-
-extern void post_process_render() {
-    if (post_process.dispose) {
-        post_process_dispose();
-        return;
-    }
-    else if (!post_process.enabled)
-        return;
-}
-
-extern void post_process_sound() {
-    if (!post_process.enabled)
-        return;
-}

src/CLOUD/Classes/post_process.h

@@ -1,24 +0,0 @@
-/*
-    by korenkonder
-    GitHub/GitLab: korenkonder
-*/
-
-#pragma once
-
-#include "../../KKdLib/default.h"
-
-typedef struct post_process_struct {
-    bool enabled;
-    bool dispose;
-    bool disposed;
-} post_process_struct;
-
-extern post_process_struct post_process;
-
-extern void post_process_dispose();
-extern void post_process_init();
-extern void post_process_control();
-extern void post_process_input();
-extern void post_process_mui();
-extern void post_process_render();
-extern void post_process_sound();

src/CLOUD/classes.c

@@ -0,0 +1,133 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "classes.h"
+
+void classes_process_dispose(classes_struct* classes, const size_t classes_count) {
+    if (!classes || !classes_count)
+        return;
+
+    for (size_t i = 0; i < classes_count; i++) {
+        if (classes[i].dispose) {
+            lock_lock(classes[i].lock);
+            classes[i].dispose();
+            lock_unlock(classes[i].lock);
+        }
+        lock_dispose(classes[i].lock);
+
+        if (classes[i].sub_classes && classes[i].sub_classes_count)
+            classes_process_dispose(classes[i].sub_classes, classes[i].sub_classes_count);
+    }
+}
+
+void classes_process_init(classes_struct* classes, const size_t classes_count) {
+    if (!classes || !classes_count)
+        return;
+
+    for (size_t i = 0; i < classes_count; i++) {
+        lock_init(classes[i].lock);
+        if (classes[i].init && classes[i].flags & CLASSES_INIT_AT_STARTUP) {
+            lock_lock(classes[i].lock);
+            classes[i].init();
+            lock_unlock(classes[i].lock);
+        }
+
+        if (classes[i].sub_classes && classes[i].sub_classes_count)
+            classes_process_init(classes[i].sub_classes, classes[i].sub_classes_count);
+    }
+}
+
+void classes_process_control(classes_struct* classes, const size_t classes_count) {
+    if (!classes || !classes_count)
+        return;
+
+    for (size_t i = 0; i < classes_count; i++) {
+        if (classes[i].lock_init && classes[i].control) {
+            lock_lock(classes[i].lock);
+            classes[i].control();
+            lock_unlock(classes[i].lock);
+        }
+
+        if (classes[i].sub_classes && classes[i].sub_classes_count)
+            classes_process_control(classes[i].sub_classes, classes[i].sub_classes_count);
+    }
+}
+
+void classes_process_drop(classes_struct* classes, size_t classes_count, size_t count, wchar_t** paths) {
+    for (size_t i = 0; i < classes_count; i++) {
+        if (classes[i].lock_init && classes[i].drop) {
+            lock_lock(classes[i].lock);
+            classes[i].drop(count, paths);
+            lock_unlock(classes[i].lock);
+        }
+
+        if (classes[i].sub_classes && classes[i].sub_classes_count)
+            classes_process_drop(classes[i].sub_classes, classes[i].sub_classes_count, count, paths);
+    }
+}
+
+void classes_process_imgui(classes_struct* classes, const size_t classes_count) {
+    if (!classes || !classes_count)
+        return;
+
+    for (size_t i = 0; i < classes_count; i++) {
+        if (classes[i].lock_init && classes[i].imgui) {
+            lock_lock(classes[i].lock);
+            classes[i].imgui();
+            lock_unlock(classes[i].lock);
+        }
+
+        if (classes[i].sub_classes && classes[i].sub_classes_count)
+            classes_process_imgui(classes[i].sub_classes, classes[i].sub_classes_count);
+    }
+}
+
+void classes_process_input(classes_struct* classes, const size_t classes_count) {
+    if (!classes || !classes_count)
+        return;
+
+    for (size_t i = 0; i < classes_count; i++) {
+        if (classes[i].lock_init && classes[i].input) {
+            lock_lock(classes[i].lock);
+            classes[i].input();
+            lock_unlock(classes[i].lock);
+        }
+
+        if (classes[i].sub_classes && classes[i].sub_classes_count)
+            classes_process_input(classes[i].sub_classes, classes[i].sub_classes_count);
+    }
+}
+
+void classes_process_render(classes_struct* classes, const size_t classes_count) {
+    if (!classes || !classes_count)
+        return;
+
+    for (size_t i = 0; i < classes_count; i++) {
+        if (classes[i].lock_init && classes[i].render) {
+            lock_lock(classes[i].lock);
+            classes[i].render();
+            lock_unlock(classes[i].lock);
+        }
+
+        if (classes[i].sub_classes && classes[i].sub_classes_count)
+            classes_process_render(classes[i].sub_classes, classes[i].sub_classes_count);
+    }
+}
+
+void classes_process_sound(classes_struct* classes, const size_t classes_count) {
+    if (!classes || !classes_count)
+        return;
+
+    for (size_t i = 0; i < classes_count; i++) {
+        if (classes[i].lock_init && classes[i].sound) {
+            lock_lock(classes[i].lock);
+            classes[i].sound();
+            lock_unlock(classes[i].lock);
+        }
+
+        if (classes[i].sub_classes && classes[i].sub_classes_count)
+            classes_process_sound(classes[i].sub_classes, classes[i].sub_classes_count);
+    }
+}

src/CLOUD/classes.h

@@ -0,0 +1,42 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../KKdLib/default.h"
+#include "../CRE/lock.h"
+
+typedef enum classes_enum {
+    CLASSES_INIT_AT_STARTUP = 0x01,
+    CLASSES_IN_CONTEXT_MENU = 0x02,
+} classes_enum;
+
+typedef struct classes_struct classes_struct;
+
+struct classes_struct {
+    const char* name;
+    const classes_enum flags;
+    bool* enabled;
+    const void(FASTCALL* dispose)();
+    const void(FASTCALL* init)();
+    const void(FASTCALL* control)();
+    const void(FASTCALL* drop)(size_t count, wchar_t** paths);
+    const void(FASTCALL* imgui)();
+    const void(FASTCALL* input)();
+    const void(FASTCALL* render)();
+    const void(FASTCALL* sound)();
+    lock_val(lock);
+    classes_struct* sub_classes;
+    size_t sub_classes_count;
+};
+
+extern void classes_process_dispose(classes_struct* classes, size_t classes_count);
+extern void classes_process_init   (classes_struct* classes, size_t classes_count);
+extern void classes_process_control(classes_struct* classes, size_t classes_count);
+extern void classes_process_drop   (classes_struct* classes, size_t classes_count, size_t count, wchar_t** paths);
+extern void classes_process_imgui  (classes_struct* classes, size_t classes_count);
+extern void classes_process_input  (classes_struct* classes, size_t classes_count);
+extern void classes_process_render (classes_struct* classes, size_t classes_count);
+extern void classes_process_sound  (classes_struct* classes, size_t classes_count);

src/CLOUD/classes/data_test.c

@@ -0,0 +1,27 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "data_test.h"
+
+bool data_test_enabled = true;
+
+classes_struct data_test_classes[1] = {
+    {
+        .name    = "Glitter Test",
+        .flags   = CLASSES_INIT_AT_STARTUP | CLASSES_IN_CONTEXT_MENU,
+        .enabled = &glitter_test_enabled,
+        .dispose = (void*)glitter_test_dispose,
+        .init    = (void*)glitter_test_init,
+        .control = (void*)0,
+        .drop    = (void*)0,
+        .input   = (void*)glitter_test_input,
+        .imgui   = (void*)glitter_test_imgui,
+        .render  = (void*)glitter_test_render,
+        .sound   = (void*)0,
+        .lock = 0,
+        .sub_classes = 0,
+        .sub_classes_count = 0,
+    },
+};

src/CLOUD/classes/data_test.h

@@ -0,0 +1,12 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../classes.h"
+#include "data_test/glitter_test.h"
+
+extern bool data_test_enabled;
+extern classes_struct data_test_classes[];

src/CLOUD/classes/data_test/glitter_test.c

@@ -0,0 +1,249 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "glitter_test.h"
+#include "../../../KKdLib/io_path.h"
+#include "../../../KKdLib/str_utils.h"
+#include "../../../CRE/Glitter/glitter.h"
+#include "../../../CRE/Glitter/effect_group.h"
+#include "../../../CRE/Glitter/file_reader.h"
+#include "../../../CRE/Glitter/particle_manager.h"
+#include "../../../CRE/Glitter/scene.h"
+#include "../../input.h"
+#include "../imgui_helper.h"
+
+typedef struct glitter_test_struct {
+    bool dispose;
+    bool disposed;
+    bool imgui_focus;
+    bool input_play;
+    bool input_stop;
+    bool input_auto;
+    bool input_pause;
+    float_t frame_counter;
+    char* file;
+    vector_ptr_char files;
+} glitter_test_struct;
+
+extern int32_t width;
+extern int32_t height;
+extern bool input_reset;
+extern bool input_locked;
+extern float_t frame_speed;
+extern bool grid_3d;
+
+extern glitter_particle_manager* gpm;
+extern glitter_type glt_type;
+
+const char* glitter_test_window_title = "Glitter";
+
+#ifdef CLOUD_DEV
+bool glitter_test_enabled = false;
+#else
+bool glitter_test_enabled = true;
+#endif
+static glitter_test_struct glitter_test;
+
+void glitter_test_dispose() {
+    vector_ptr_glitter_scene_free(&gpm->scenes, glitter_scene_dispose);
+    vector_ptr_glitter_effect_group_free(&gpm->effect_groups, glitter_effect_group_dispose);
+
+    vector_ptr_char_free(&glitter_test.files, 0);
+    glitter_test_enabled = false;
+    glitter_test.file = 0;
+    glitter_test.imgui_focus = false;
+    glitter_test.input_play = false;
+    glitter_test.input_stop = false;
+    glitter_test.input_auto = false;
+    glitter_test.input_pause = false;
+    glitter_test.frame_counter = 0.0f;
+    glitter_test.dispose = false;
+    glitter_test.disposed = true;
+}
+
+void glitter_test_init() {
+    if (glitter_test_enabled || glitter_test.dispose)
+        glitter_test_dispose();
+
+    vector_ptr_char_free(&glitter_test.files, 0);
+    path_get_files(&glitter_test.files, "rom\\particle");
+    for (char** i = glitter_test.files.begin; i != glitter_test.files.end;)
+        if (str_utils_check_ends_with(*i, ".farc")) {
+            char* temp = str_utils_get_without_extension(*i);
+            vector_ptr_char_erase(&glitter_test.files, i - glitter_test.files.begin, 0);
+            vector_ptr_char_insert(&glitter_test.files, i - glitter_test.files.begin, &temp);
+            i++;
+        }
+        else
+            vector_ptr_char_erase(&glitter_test.files, i - glitter_test.files.begin, 0);
+
+    glitter_test.file = glitter_test.files.end - glitter_test.files.begin > 0 ? glitter_test.files.begin[0] : 0;
+
+    LARGE_INTEGER time;
+    QueryPerformanceCounter(&time);
+    gpm->counter = (uint32_t)(time.LowPart * 0x0CAD3078LL);
+    glitter_test_enabled = true;
+    gpm->emission = 1.0f;
+    gpm->draw_all = false;
+    gpm->draw_all_mesh = false;
+    glt_type = GLITTER_AFT;
+    grid_3d = false;
+}
+
+void glitter_test_imgui() {
+    if (!glitter_test_enabled) {
+        if (!glitter_test.disposed)
+            glitter_test.dispose = true;
+        return;
+    }
+    else if (glitter_test.disposed)
+        glitter_test.disposed = false;
+
+    float_t w = min((float_t)width / 4.0f, 360.0f);
+    float_t h = min((float_t)height, 348.0f);
+
+    igSetNextWindowPos(ImVec2_Empty, ImGuiCond_Appearing, ImVec2_Empty);
+    igSetNextWindowSize((ImVec2) { w, h }, ImGuiCond_Appearing);
+
+    ImGuiWindowFlags window_flags = 0;
+    window_flags |= ImGuiWindowFlags_NoResize;
+    window_flags |= ImGuiWindowFlags_NoCollapse;
+
+    glitter_test.imgui_focus = false;
+    if (!igBegin(glitter_test_window_title, &glitter_test_enabled, window_flags)) {
+        glitter_test.dispose = true;
+        igEnd();
+        return;
+    }
+
+    int32_t file_index = -1;
+    if (glitter_test.file)
+        for (char** i = glitter_test.files.begin; i != glitter_test.files.end; i++)
+            if (!strcmp(*i, glitter_test.file)) {
+                file_index = (int32_t)(i - glitter_test.files.begin);
+                break;
+            }
+
+    int32_t file_index_old = file_index;
+    imguiColumnComboBox("File", glitter_test.files.begin,
+        glitter_test.files.end - glitter_test.files.begin,
+        &file_index, 0, false, &glitter_test.imgui_focus);
+
+    if (file_index != file_index_old) {
+        glitter_test.file = glitter_test.files.begin[file_index];
+        glitter_test.input_stop = true;
+    }
+
+    if (imguiButton("Reset Camera (R)", ImVec2_Empty))
+        input_reset = true;
+
+    if (imguiButton("Play (F)", ImVec2_Empty) || igIsKeyPressed(GLFW_KEY_F, true))
+        glitter_test.input_play = true;
+
+    if (imguiButton("Stop (V)", ImVec2_Empty) || igIsKeyPressed(GLFW_KEY_V, true))
+        glitter_test.input_stop = true;
+
+    imguiCheckbox("Auto (T)", &glitter_test.input_auto);
+    if (igIsKeyPressed(GLFW_KEY_T, true))
+        glitter_test.input_auto ^= true;
+
+    imguiCheckbox("Pause (G)", &glitter_test.input_pause);
+    if (igIsKeyPressed(GLFW_KEY_G, true))
+        glitter_test.input_pause ^= true;
+
+    igSeparator();
+
+    size_t ctrl;
+    size_t disp;
+    float_t frame;
+    float_t life_time;
+
+    frame = 0.0f;
+    life_time = 0.0f;
+    glitter_particle_manager_get_frame(GPM_VAL, &frame, &life_time);
+    igText("%.0f - %.0f/%.0f", glitter_test.frame_counter, frame, life_time);
+
+    ctrl = glitter_particle_manager_get_ctrl_count(GPM_VAL, GLITTER_PARTICLE_QUAD);
+    disp = glitter_particle_manager_get_disp_count(GPM_VAL, GLITTER_PARTICLE_QUAD);
+    igText(" Quad: ctrl%lld, disp%lld", ctrl, disp);
+
+    ctrl = glitter_particle_manager_get_ctrl_count(GPM_VAL, GLITTER_PARTICLE_LOCUS);
+    disp = glitter_particle_manager_get_disp_count(GPM_VAL, GLITTER_PARTICLE_LOCUS);
+    igText("Locus: ctrl%lld, disp%lld", ctrl, disp);
+
+    ctrl = glitter_particle_manager_get_ctrl_count(GPM_VAL, GLITTER_PARTICLE_LINE);
+    disp = glitter_particle_manager_get_disp_count(GPM_VAL, GLITTER_PARTICLE_LINE);
+    igText(" Line: ctrl%lld, disp%lld", ctrl, disp);
+
+    ctrl = glitter_particle_manager_get_ctrl_count(GPM_VAL, GLITTER_PARTICLE_MESH);
+    disp = glitter_particle_manager_get_disp_count(GPM_VAL, GLITTER_PARTICLE_MESH);
+    igText(" Mesh: ctrl%lld, disp%lld", ctrl, disp);
+
+    igSeparator();
+
+    imguiColumnSliderFloat("Emission", &gpm->emission, 1.0f, 2.0f, "%.2f", 0);
+    imguiColumnSliderFloat("Frame Speed", &frame_speed, 0.0f, 3.0f, "%.2f", 0);
+
+    igSeparator();
+
+    imguiCheckbox("Grid", &grid_3d);
+
+    glitter_test.imgui_focus |= igIsWindowFocused(0);
+    igEnd();
+}
+
+void glitter_test_input() {
+    if (!glitter_test_enabled)
+        return;
+
+    input_locked |= glitter_test.imgui_focus;
+}
+
+void glitter_test_render() {
+    if (glitter_test.dispose) {
+        glitter_test_dispose();
+        return;
+    }
+    else if (!glitter_test_enabled)
+        return;
+
+    if (!glitter_test.input_pause) {
+        if (gpm->scenes.end != gpm->scenes.begin)
+            glitter_test.frame_counter += get_frame_speed();
+
+        glitter_particle_manager_update_scene(GPM_VAL);
+    }
+
+    if (glitter_test.file) {
+        if (glitter_test.input_play || glitter_test.input_stop) {
+            glitter_particle_manager_free_scenes(GPM_VAL);
+            glitter_test.frame_counter = 0.0f;
+        }
+
+        uint64_t hash = glt_type != GLITTER_AFT
+            ? hash_char_murmurhash(glitter_test.file, 0, false)
+            : hash_char_fnv1a64(glitter_test.file);
+        if (glitter_test.input_auto && !glitter_particle_manager_check_scene(GPM_VAL, hash)) {
+            if (glitter_particle_manager_check_effect_group(GPM_VAL, hash))
+                goto load;
+            else
+                goto reset;
+        }
+        else if (glitter_test.input_play && !glitter_particle_manager_test_load_scene(GPM_VAL, hash, true)) {
+        reset:
+            glitter_particle_manager_free_scenes(GPM_VAL);
+            glitter_particle_manager_free_effect_groups(GPM_VAL);
+
+            glitter_file_reader* fr = glitter_file_reader_init(GPM_VAL, 0, glitter_test.file, -1.0f);
+            vector_ptr_glitter_file_reader_push_back(&gpm->file_readers, &fr);
+            glitter_particle_manager_update_file_reader(GPM_VAL);
+        load:
+            glitter_test.frame_counter = 0.0f;
+            glitter_particle_manager_test_load_scene(GPM_VAL, hash, true);
+        }
+        glitter_test.input_play = false;
+        glitter_test.input_stop = false;
+    }
+}

src/CLOUD/classes/data_test/glitter_test.h

@@ -0,0 +1,17 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../../../KKdLib/default.h"
+#include "../../../KKdLib/vector.h"
+
+extern bool glitter_test_enabled;
+
+extern void glitter_test_dispose();
+extern void glitter_test_init();
+extern void glitter_test_imgui();
+extern void glitter_test_input();
+extern void glitter_test_render();

src/CLOUD/classes/graphics.c

@@ -0,0 +1,59 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "graphics.h"
+
+bool graphics_enabled = true;
+
+classes_struct graphics_classes[3] = {
+    {
+        .name    = "Background Color",
+        .flags   = CLASSES_IN_CONTEXT_MENU,
+        .enabled = &background_color_enabled,
+        .dispose = (void*)background_color_dispose,
+        .init    = (void*)background_color_init,
+        .control = (void*)0,
+        .drop    = (void*)0,
+        .imgui   = (void*)background_color_imgui,
+        .input   = (void*)background_color_input,
+        .render  = (void*)background_color_render,
+        .sound   = (void*)0,
+        .lock = 0,
+        .sub_classes = 0,
+        .sub_classes_count = 0,
+    },
+    {
+        .name    = "Post Process",
+        .flags   = CLASSES_IN_CONTEXT_MENU,
+        .enabled = &post_process_enabled,
+        .dispose = (void*)post_process_dispose,
+        .init    = (void*)post_process_init,
+        .control = (void*)0,
+        .drop    = (void*)0,
+        .imgui   = (void*)post_process_imgui,
+        .input   = (void*)post_process_input,
+        .render  = (void*)post_process_render,
+        .sound   = (void*)0,
+        .lock = 0,
+        .sub_classes = 0,
+        .sub_classes_count = 0,
+    },
+    {
+        .name    = "Glitter##Counter",
+        .flags   = CLASSES_IN_CONTEXT_MENU,
+        .enabled = &glitter_counter_enabled,
+        .dispose = (void*)glitter_counter_dispose,
+        .init    = (void*)glitter_counter_init,
+        .control = (void*)0,
+        .drop    = (void*)0,
+        .imgui   = (void*)glitter_counter_imgui,
+        .input   = (void*)glitter_counter_input,
+        .render  = (void*)glitter_counter_render,
+        .sound   = (void*)0,
+        .lock = 0,
+        .sub_classes = 0,
+        .sub_classes_count = 0,
+    },
+};

src/CLOUD/classes/graphics.h

@@ -0,0 +1,14 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../classes.h"
+#include "graphics/background_color.h"
+#include "graphics/glitter_counter.h"
+#include "graphics/post_process.h"
+
+extern bool graphics_enabled;
+extern classes_struct graphics_classes[];

src/CLOUD/classes/graphics/background_color.c

@@ -0,0 +1,97 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "background_color.h"
+#include "../imgui_helper.h"
+
+typedef struct background_color_struct {
+    bool dispose;
+    bool disposed;
+    bool imgui_focus;
+} background_color_struct;
+
+extern int32_t width;
+extern int32_t height;
+extern bool input_locked;
+extern vec3 back3d_color;
+
+const char* background_color_window_title = "Background Color";
+
+bool background_color_enabled = false;
+static background_color_struct background_color;
+
+void background_color_dispose() {
+    background_color_enabled = false;
+    background_color.imgui_focus = false;
+    background_color.dispose = false;
+    background_color.disposed = true;
+}
+
+void background_color_init() {
+    if (background_color_enabled || background_color.dispose)
+        background_color_dispose();
+
+    background_color_enabled = true;
+}
+
+void background_color_imgui() {
+    if (!background_color_enabled) {
+        if (!background_color.disposed)
+            background_color.dispose = true;
+        return;
+    }
+    else if (background_color.disposed)
+        background_color_enabled = true;
+
+    float_t w = min((float_t)width / 4.0f, 360.0f);
+    float_t h = min((float_t)height, 80.0f);
+
+    igSetNextWindowPos(ImVec2_Empty, ImGuiCond_Appearing, ImVec2_Empty);
+    igSetNextWindowSize((ImVec2) { w, h }, ImGuiCond_Appearing);
+
+    ImGuiWindowFlags window_flags = 0;
+    window_flags |= ImGuiWindowFlags_NoResize;
+    window_flags |= ImGuiWindowFlags_NoCollapse;
+
+    background_color.imgui_focus = false;
+    if (!igBegin(background_color_window_title, &background_color_enabled, window_flags)) {
+        background_color.dispose = true;
+        igEnd();
+        return;
+    }
+
+    ImVec2 temp;
+    igGetContentRegionAvail(&temp);
+
+    ImGuiColorEditFlags color_edit_flags = 0;
+    color_edit_flags |= ImGuiColorEditFlags_NoLabel;
+    color_edit_flags |= ImGuiColorEditFlags_NoSidePreview;
+    color_edit_flags |= ImGuiColorEditFlags_NoDragDrop;
+
+    igSetNextItemWidth(temp.x);
+    igColorEdit3("##Background Color", (float_t*)&back3d_color, color_edit_flags);
+
+    if (imguiButton("Reset Color", ImVec2_Empty))
+        back3d_color = (vec3){ 0.74117647f, 0.74117647f, 0.74117647f };
+
+    background_color.imgui_focus |= igIsWindowFocused(0);
+    igEnd();
+}
+
+void background_color_input() {
+    if (!background_color_enabled)
+        return;
+
+    input_locked |= background_color.imgui_focus;
+}
+
+void background_color_render() {
+    if (background_color.dispose) {
+        background_color_dispose();
+        return;
+    }
+    else if (!background_color_enabled)
+        return;
+}

src/CLOUD/classes/graphics/background_color.h

@@ -0,0 +1,17 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../../../KKdLib/default.h"
+#include "../../../KKdLib/vec.h"
+
+extern bool background_color_enabled;
+
+extern void background_color_dispose();
+extern void background_color_init();
+extern void background_color_imgui();
+extern void background_color_input();
+extern void background_color_render();

src/CLOUD/classes/graphics/glitter_counter.c

@@ -0,0 +1,123 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "glitter_counter.h"
+#include "../../../CRE/Glitter/glitter.h"
+#include "../../../CRE/Glitter/particle_manager.h"
+#include "../imgui_helper.h"
+
+typedef struct glitter_counter_struct {
+    bool dispose;
+    bool disposed;
+    bool imgui_focus;
+} glitter_counter_struct;
+
+extern int32_t width;
+extern int32_t height;
+extern bool input_locked;
+
+extern glitter_particle_manager* gpm;
+glitter_type glt_type;
+
+const char* glitter_counter_window_title = "Glitter##Counter";
+
+bool glitter_counter_enabled = false;
+static glitter_counter_struct glitter_counter;
+
+void glitter_counter_dispose() {
+    glitter_counter_enabled = false;
+    glitter_counter.imgui_focus = false;
+    glitter_counter.dispose = false;
+    glitter_counter.disposed = true;
+}
+
+void glitter_counter_init() {
+    if (glitter_counter_enabled || glitter_counter.dispose)
+        glitter_counter_dispose();
+
+    glitter_counter_enabled = true;
+}
+
+void glitter_counter_imgui() {
+    if (!glitter_counter_enabled) {
+        if (!glitter_counter.disposed)
+            glitter_counter.dispose = true;
+        return;
+    }
+    else if (glitter_counter.disposed)
+        glitter_counter_enabled = true;
+
+    float_t w = min((float_t)width / 4.0f, 148.0f);
+    float_t h = min((float_t)height, 204.0f);
+
+    igSetNextWindowPos(ImVec2_Empty, ImGuiCond_Appearing, ImVec2_Empty);
+    igSetNextWindowSize((ImVec2) { w, h }, ImGuiCond_Appearing);
+
+    ImGuiWindowFlags window_flags = 0;
+    window_flags |= ImGuiWindowFlags_NoResize;
+    window_flags |= ImGuiWindowFlags_NoCollapse;
+
+    glitter_counter.imgui_focus = false;
+    if (!igBegin(glitter_counter_window_title, &glitter_counter_enabled, window_flags)) {
+        glitter_counter.dispose = true;
+        igEnd();
+        return;
+    }
+
+    size_t ctrl;
+    size_t disp;
+    size_t total_ctrl = 0;
+    size_t total_disp = 0;
+
+    ctrl = glitter_particle_manager_get_ctrl_count(gpm, glt_type, GLITTER_PARTICLE_QUAD);
+    disp = glitter_particle_manager_get_disp_count(gpm, glt_type, GLITTER_PARTICLE_QUAD);
+    igText("QUAD  (ctrl):%6lld", ctrl);
+    igText("      (disp):%6lld", disp);
+    total_ctrl += ctrl;
+    total_disp += disp;
+
+    ctrl = glitter_particle_manager_get_ctrl_count(gpm, glt_type, GLITTER_PARTICLE_LOCUS);
+    disp = glitter_particle_manager_get_disp_count(gpm, glt_type, GLITTER_PARTICLE_LOCUS);
+    igText("LOCUS (ctrl):%6lld", ctrl);
+    igText("      (disp):%6lld", disp);
+    total_ctrl += ctrl;
+    total_disp += disp;
+
+    ctrl = glitter_particle_manager_get_ctrl_count(gpm, glt_type, GLITTER_PARTICLE_LINE);
+    disp = glitter_particle_manager_get_disp_count(gpm, glt_type, GLITTER_PARTICLE_LINE);
+    igText("LINE  (ctrl):%6lld", ctrl);
+    igText("      (disp):%6lld", disp);
+    total_ctrl += ctrl;
+    total_disp += disp;
+
+    ctrl = glitter_particle_manager_get_ctrl_count(gpm, glt_type, GLITTER_PARTICLE_MESH);
+    disp = glitter_particle_manager_get_disp_count(gpm, glt_type, GLITTER_PARTICLE_MESH);
+    igText("MESH  (ctrl):%6lld", ctrl);
+    igText("      (disp):%6lld", disp);
+    total_ctrl += ctrl;
+    total_disp += disp;
+
+    igText("TOTAL (ctrl):%6lld", total_ctrl);
+    igText("      (disp):%6lld", total_disp);
+
+    glitter_counter.imgui_focus |= igIsWindowFocused(0);
+    igEnd();
+}
+
+void glitter_counter_input() {
+    if (!glitter_counter_enabled)
+        return;
+
+    input_locked |= glitter_counter.imgui_focus;
+}
+
+void glitter_counter_render() {
+    if (glitter_counter.dispose) {
+        glitter_counter_dispose();
+        return;
+    }
+    else if (!glitter_counter_enabled)
+        return;
+}

src/CLOUD/classes/graphics/glitter_counter.h

@@ -0,0 +1,16 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../../../KKdLib/default.h"
+
+extern bool glitter_counter_enabled;
+
+extern void glitter_counter_dispose();
+extern void glitter_counter_init();
+extern void glitter_counter_imgui();
+extern void glitter_counter_input();
+extern void glitter_counter_render();

src/CLOUD/classes/graphics/post_process.c

@@ -0,0 +1,245 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "post_process.h"
+#include "../../../CRE/post_process.h"
+#include "../../../CRE/dof.h"
+#include "../imgui_helper.h"
+
+typedef struct post_process_struct {
+    bool dispose;
+    bool disposed;
+    bool imgui_focus;
+} post_process_struct;
+
+extern int32_t width;
+extern int32_t height;
+extern bool input_locked;
+
+const char* post_process_window_title = "Post Process";
+
+extern dof_struct* dof;
+extern radius* rad;
+extern intensity* inten;
+extern tone_map_sat_gamma* tmsg;
+extern tone_map_data* tmd;
+
+bool post_process_enabled = false;
+static post_process_struct post_process;
+
+extern void post_process_dispose() {
+    post_process_enabled = false;
+    post_process.imgui_focus = false;
+    post_process.dispose = false;
+    post_process.disposed = true;
+}
+
+extern void post_process_init() {
+    if (post_process_enabled || post_process.dispose)
+        post_process_dispose();
+
+    post_process_enabled = true;
+}
+
+extern void post_process_imgui() {
+    if (!post_process_enabled) {
+        if (!post_process.disposed)
+            post_process.dispose = true;
+        return;
+    }
+    else if (post_process.disposed)
+        post_process_enabled = true;
+
+    ImGuiIO* io = igGetIO();
+    ImGuiStyle* style = igGetStyle();
+    ImFont* font = igGetFont();
+
+    float_t w = min((float_t)width / 4.0f, 360.0f);
+    float_t h = min((float_t)height, 740.0f);
+
+    igSetNextWindowPos(ImVec2_Empty, ImGuiCond_Appearing, ImVec2_Empty);
+    igSetNextWindowSize((ImVec2) { w, h }, ImGuiCond_Appearing);
+
+    ImGuiWindowFlags window_flags = 0;
+    window_flags |= ImGuiWindowFlags_NoResize;
+    window_flags |= ImGuiWindowFlags_NoCollapse;
+
+    post_process.imgui_focus = false;
+    if (!igBegin(post_process_window_title, &post_process_enabled, window_flags)) {
+        post_process.dispose = true;
+        igEnd();
+        return;
+    }
+
+    if (igTreeNode_Str("Tone Trans")) {
+        vec3 tone_trans_start = *tone_map_data_get_tone_trans_start(tmd);
+        imguiColumnSliderVec3("Start", &tone_trans_start, 0.0f, 1.0f, "%.2f", 0);
+        tone_map_data_set_tone_trans_start(tmd, &tone_trans_start);
+
+        vec3 tone_trans_end = *tone_map_data_get_tone_trans_end(tmd);
+        imguiColumnSliderVec3("End", &tone_trans_end, 0.0f, 1.0f, "%.2f", 0);
+        tone_map_data_set_tone_trans_end(tmd, &tone_trans_end);
+        igTreePop();
+    }
+
+    if (igTreeNode_Str("Scene Fade")) {
+        float_t scene_fade_alpha = tone_map_data_get_scene_fade_alpha(tmd);
+        imguiColumnSliderFloat("Alpha", &scene_fade_alpha, 0.0f, 1.0f, "%.2f", 0);
+        tone_map_data_set_scene_fade_alpha(tmd, scene_fade_alpha);
+
+        vec3 scene_fade_color = *tone_map_data_get_scene_fade_color(tmd);
+        imguiColumnSliderVec3("Color", &scene_fade_color, 0.0f, 1.0f, "%.2f", 0);
+        tone_map_data_set_scene_fade_color(tmd, &scene_fade_color);
+
+        const char* scene_fade_blend_func_labels[] = {
+            "0: OVER",
+            "1: MULTI",
+            "2: PLUS",
+        };
+
+        int32_t scene_fade_blend_func = tone_map_data_get_scene_fade_blend_func(tmd);
+        imguiColumnComboBox("Blend Func", scene_fade_blend_func_labels, 3,
+            &scene_fade_blend_func, 0, false, &post_process.imgui_focus);
+        tone_map_data_set_scene_fade_blend_func(tmd, scene_fade_blend_func);
+        igTreePop();
+    }
+
+    if (igTreeNodeEx_Str("Glow Param", ImGuiTreeNodeFlags_DefaultOpen)) {
+        const char* tone_map_method_labels[] = {
+            "YCC EXPONENT",
+            "RGB LINEAR",
+            "RGB LINEAR2",
+        };
+
+        int32_t tone_map_method = tone_map_data_get_tone_map_method(tmd);
+        imguiColumnComboBox("Tone Map", tone_map_method_labels, 3,
+            &tone_map_method, 0, false, &post_process.imgui_focus);
+        tone_map_data_set_tone_map_method(tmd, tone_map_method);
+
+        float_t exposure = tone_map_data_get_exposure(tmd);
+        imguiColumnSliderFloat("Exposure", &exposure, 0.0f, 4.0f, "%.2f", 0);
+        exposure = roundf(exposure / 0.02f) * 0.02f;
+        tone_map_data_set_exposure(tmd, exposure);
+
+        bool auto_exposure = tone_map_data_get_auto_exposure(tmd);
+        imguiCheckbox("Auto Exposure", &auto_exposure);
+        tone_map_data_set_auto_exposure(tmd, auto_exposure);
+
+        float_t gamma = tone_map_sat_gamma_get_gamma(tmsg);
+        imguiColumnSliderFloat("Gamma", &gamma, 0.2f, 2.2f, "%.2f", 0);
+        tone_map_sat_gamma_set_gamma(tmsg, gamma);
+
+        int32_t saturate1 = tone_map_sat_gamma_get_saturate1(tmsg);
+        imguiColumnSliderInt("Saturate 1", &saturate1, 1, 6, "%d", 0);
+        tone_map_sat_gamma_set_saturate1(tmsg, saturate1);
+
+        float_t saturate2 = tone_map_sat_gamma_get_saturate2(tmsg);
+        imguiColumnSliderFloat("Saturate 2", &saturate2, 0.0f, 1.0f, "%.2f", 0);
+        tone_map_sat_gamma_set_saturate2(tmsg, saturate2);
+        igTreePop();
+    }
+
+    if (igTreeNodeEx_Str("Glare", ImGuiTreeNodeFlags_DefaultOpen)) {
+        vec3 radius = *radius_get(rad);
+        imguiColumnSliderFloat("Radius R", &radius.x, 1.0f, 3.0f, "%.2f", 0);
+        imguiColumnSliderFloat("Radius G", &radius.y, 1.0f, 3.0f, "%.2f", 0);
+        imguiColumnSliderFloat("Radius B", &radius.z, 1.0f, 3.0f, "%.2f", 0);
+        radius_set(rad, &radius);
+
+        vec3 intensity = *intensity_get(inten);
+        imguiColumnSliderFloat("Inten  R", &intensity.x, 0.0f, 2.0f, "%.2f", 0);
+        imguiColumnSliderFloat("Inten  G", &intensity.y, 0.0f, 2.0f, "%.2f", 0);
+        imguiColumnSliderFloat("Inten  B", &intensity.z, 0.0f, 2.0f, "%.2f", 0);
+        intensity_set(inten, &intensity);
+        igTreePop();
+    }
+
+    if (igTreeNodeEx_Str("DOF", ImGuiTreeNodeFlags_DefaultOpen)) {
+        bool use_ui_params = dof->debug.flags & DOF_DEBUG_USE_UI_PARAMS;
+        bool phys = use_ui_params && dof->debug.flags & DOF_DEBUG_ENABLE_PHYS_DOF;
+        bool f2 = use_ui_params && ~dof->debug.flags & DOF_DEBUG_ENABLE_PHYS_DOF;
+
+        float_t alpha = style->Alpha * imgui_alpha_disabled_scale;
+
+        imguiCheckboxFlags_UintPtr("use UI params", (uint32_t*)&dof->debug.flags, DOF_DEBUG_USE_UI_PARAMS);
+
+        if (!use_ui_params) {
+            igPushItemFlag(ImGuiItemFlags_Disabled, true);
+            igPushStyleVar_Float(ImGuiStyleVar_Alpha, alpha);
+        }
+        imguiCheckboxFlags_UintPtr("enable DOF", (uint32_t*)&dof->debug.flags, DOF_DEBUG_ENABLE_DOF);
+        imguiCheckboxFlags_UintPtr("enable physical DOF", (uint32_t*)&dof->debug.flags, DOF_DEBUG_ENABLE_PHYS_DOF);
+        if (!use_ui_params) {
+            igPopItemFlag();
+            igPopStyleVar(1);
+        }
+
+        if (!phys) {
+            igPushItemFlag(ImGuiItemFlags_Disabled, true);
+            igPushStyleVar_Float(ImGuiStyleVar_Alpha, alpha);
+        }
+        imguiCheckboxFlags_UintPtr("auto focus", (uint32_t*)&dof->debug.flags, DOF_DEBUG_AUTO_FOCUS);
+        if (!phys) {
+            igPopItemFlag();
+            igPopStyleVar(1);
+        }
+
+        imguiSetColumnSpace(16.0f / 31.0f);
+        if (!phys) {
+            igPushItemFlag(ImGuiItemFlags_Disabled, true);
+            igPushStyleVar_Float(ImGuiStyleVar_Alpha, alpha);
+        }
+        imguiColumnSliderFloat("distance to focus[m]", &dof->debug.distance_to_focus, 0.01f, 30.0f, "%.2f", 0);
+        imguiColumnSliderFloat("focal length[mm]", &dof->debug.focal_length, 0.1f, 100.0f, "%.2f", 0);
+        imguiColumnSliderFloat("F-Number", &dof->debug.f_number, 0.1f, 40.0f, "%.2f", 0);
+        if (!phys) {
+            igPopItemFlag();
+            igPopStyleVar(1);
+        }
+
+        if (!f2) {
+            igPushItemFlag(ImGuiItemFlags_Disabled, true);
+            igPushStyleVar_Float(ImGuiStyleVar_Alpha, alpha);
+        }
+        imguiColumnSliderFloat("f2 distance to focus[m]", &dof->debug.f2.distance_to_focus, 0.01f, 30.0f, "%.2f", 0);
+        imguiColumnSliderFloat("f2 focus range[m]", &dof->debug.f2.focus_range, 0.0f, 10.0f, "%.2f", 0);
+        imguiColumnSliderFloat("f2 fuzzing range[m]", &dof->debug.f2.fuzzing_range, 0.0f, 10.0f, "%.2f", 0);
+        imguiColumnSliderFloat("f2 ratio", &dof->debug.f2.ratio, 0.0f, 1.0f, "%.2f", 0);
+        if (!f2) {
+            igPopItemFlag();
+            igPopStyleVar(1);
+        }
+        imguiSetDefaultColumnSpace();
+        igTreePop();
+    }
+
+    if (imguiButton("Reset Post Process", ImVec2_Empty)) {
+        dof_initialize(dof, 0, 0);
+        radius_initialize(rad, (vec3[]) { 2.0f, 2.0f, 2.0f });
+        intensity_initialize(inten, (vec3[]) { 1.0f, 1.0f, 1.0f });
+        tone_map_sat_gamma_initialize(tmsg, 1.0f, 1, 1.0f);
+        tone_map_data_initialize(tmd, 2.0f, true, (vec3[]) { 0.0f, 0.0f, 0.0f}, 0.0f, 0,
+            (vec3[]) { 0.0f, 0.0f, 0.0f }, (vec3[]) { 1.0f, 1.0f, 1.0f }, 0);
+    }
+
+    post_process.imgui_focus |= igIsWindowFocused(0);
+    igEnd();
+}
+
+void post_process_input() {
+    if (!post_process_enabled)
+        return;
+
+    input_locked |= post_process.imgui_focus;
+}
+
+extern void post_process_render() {
+    if (post_process.dispose) {
+        post_process_dispose();
+        return;
+    }
+    else if (!post_process_enabled)
+        return;
+}

src/CLOUD/classes/graphics/post_process.h

@@ -0,0 +1,16 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../../../KKdLib/default.h"
+
+extern bool post_process_enabled;
+
+extern void post_process_dispose();
+extern void post_process_init();
+extern void post_process_imgui();
+extern void post_process_input();
+extern void post_process_render();

src/CLOUD/classes/imgui_helper.h

@@ -0,0 +1,116 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../../KKdLib/default.h"
+#include "../../KKdLib/vec.h"
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include <cimgui.h>
+#include <GLFW/glfw3.h>
+
+extern const ImVec1 ImVec1_Empty;
+extern const ImVec2 ImVec2_Empty;
+extern const ImVec4 ImVec4_Empty;
+extern const ImVec1 ImVec1_Identity;
+extern const ImVec2 ImVec2_Identity;
+extern const ImVec4 ImVec4_Identity;
+extern const float_t imgui_alpha_disabled_scale;
+
+extern bool imguiItemKeyDown(int32_t key);
+extern bool imguiItemKeyPressed(int32_t key, bool repeat);
+extern bool imguiItemKeyReleased(int32_t key);
+extern float_t imguiGetColumnSpace();
+extern void imguiSetColumnSpace(float_t val);
+extern void imguiSetDefaultColumnSpace();
+extern void imguiDisableElementPush(bool enable);
+extern void imguiDisableElementPop(bool enable);
+
+extern const char* imguiStartPropertyColumn(const char* label);
+extern void imguiEndPropertyColumn(const char* temp);
+
+extern bool imguiButton(const char* label, const ImVec2 size);
+extern bool imguiButtonEx(const char* label, const ImVec2 size, ImGuiButtonFlags flags);
+extern bool imguiCheckbox(const char* label, bool* v);
+extern bool imguiCheckboxFlags_IntPtr(const char* label, int* flags, int flags_value);
+extern bool imguiCheckboxFlags_UintPtr(const char* label, unsigned int* flags, unsigned int flags_value);
+extern bool imguiComboBox(const char* label, const char** items, const size_t size,
+    int32_t* selected_idx, ImGuiComboFlags flags, bool include_last, bool* focus);
+extern bool imguiColumnColorEdit3(const char* label, vec3* val, ImGuiColorEditFlags flags);
+extern bool imguiColumnColorEdit4(const char* label, vec4* val, ImGuiColorEditFlags flags);
+extern bool imguiColumnComboBox(const char* label, const char** items, const size_t size,
+    int32_t* selected_idx, ImGuiComboFlags flags, bool include_last, bool* focus);
+extern bool imguiColumnDragFloat(const char* label, float_t* val, float_t speed,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnDragVec2(const char* label, vec2* val, float_t speed,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnDragVec3(const char* label, vec3* val, float_t speed,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnDragVec4(const char* label, vec4* val, float_t speed,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnDragInt(const char* label, int32_t* val, float_t speed,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnDragVec2I(const char* label, vec2i* val, float_t speed,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnDragVec3I(const char* label, vec3i* val, float_t speed,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnDragVec4I(const char* label, vec4i* val, float_t speed,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnInputText(const char* label, char* buf, size_t buf_size,
+    ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data);
+extern bool imguiColumnSliderFloat(const char* label, float_t* val,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnSliderVec2(const char* label, vec2* val,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnSliderVec3(const char* label, vec3* val,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnSliderVec4(const char* label, vec4* val,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnSliderInt(const char* label, int32_t* val,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnSliderVec2I(const char* label, vec2i* val,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnSliderVec3I(const char* label, vec3i* val,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnSliderVec4I(const char* label, vec4i* val,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags);
+extern bool imguiColumnInputFloat(const char* label, float_t* val,
+    float_t step, float_t step_fast, const char* format, ImGuiInputTextFlags flags);
+extern bool imguiColumnInputInt(const char* label, int32_t* val,
+    int32_t step, int32_t step_fast, ImGuiInputTextFlags flags);
+extern bool imguiColumnInputScalar(const char* label, ImGuiDataType data_type, void* p_data,
+    const void* p_step, const void* p_step_fast, const char* format, ImGuiInputTextFlags flags);
+extern bool imguiColumnDragFloatFlag(const char* label, float_t* val, float_t speed,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnDragVec2Flag(const char* label, vec2* val, float_t speed,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnDragVec3Flag(const char* label, vec3* val, float_t speed,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnDragVec4Flag(const char* label, vec4* val, float_t speed,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnDragIntFlag(const char* label, int32_t* val, float_t speed,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnDragVec2IFlag(const char* label, vec2i* val, float_t speed,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnDragVec3IFlag(const char* label, vec3i* val, float_t speed,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnDragVec4IFlag(const char* label, vec4i* val, float_t speed,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnSliderFloatFlag(const char* label, float_t* val,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnSliderVec2Flag(const char* label, vec2* val,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnSliderVec3Flag(const char* label, vec3* val,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnSliderVec4Flag(const char* label, vec4* val,
+    float_t min, float_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnSliderIntFlag(const char* label, int32_t* val,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnSliderVec2IFlag(const char* label, vec2i* val,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnSliderVec3IFlag(const char* label, vec3i* val,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);
+extern bool imguiColumnSliderVec4IFlag(const char* label, vec4i* val,
+    int32_t min, int32_t max, const char* format, ImGuiSliderFlags flags, int32_t bit_flag);

src/CLOUD/control.c

@@ -6,20 +6,16 @@
 #include "control.h"
 #include "input.h"
 #include "../KKdLib/io_path.h"
+#include "../CRE/lock.h"
 #include "../CRE/task.h"
 extern vector_task_render tasks_render;
 extern vector_task_render_draw2d tasks_render_draw2d;
 extern vector_task_render_draw3d tasks_render_draw3d;
 
 extern bool close;
-HANDLE control_lock = 0;
-extern HANDLE input_lock;
-extern HANDLE render_lock;
+HANDLE control_lock;
+lock_extern_val(render_lock);
 extern HWND window_handle;
-extern HANDLE mu_lock;
-extern HANDLE mu_input_lock;
-extern vector_wchar_t mu_input;
-extern vector_char mu_input_ansi;
 
 extern int32_t width;
 extern int32_t height;
@@ -29,77 +25,49 @@ extern float_t frame_speed;
 extern double_t render_freq;
 extern double_t sound_freq;
 extern double_t input_freq;
-extern HANDLE render_freq_lock;
-extern HANDLE sound_freq_lock;
-extern HANDLE input_freq_lock;
+lock_extern_val(render_freq_lock);
+lock_extern_val(sound_freq_lock);
+lock_extern_val(input_freq_lock);
 
 #define FREQ 60
 #include "../CRE/timer.h"
 timer_val(control);
 
-static void mui_process();
-
 int32_t control_main(void* arg) {
     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);
     timer_init(control, "Control");
-    memset(&tasks_render, 0, sizeof(vector_task_render));
 
-    while (!render_lock)
+    while (!lock_check_init(render_lock))
         msleep(control_timer, 0.0625);
 
     while (!close) {
         timer_calc_pre(control);
-        if (input_lock) {
-            WaitForSingleObject(input_lock, INFINITE);
-            if (window_handle == GetForegroundWindow()) {
-                if (input_is_down(VK_CONTROL) && input_is_tapped('C'))
-                    break;
-            }
-            ReleaseMutex(input_lock);
-        }
+        lock_lock(render_lock);
+        lock_unlock(render_lock);
 
-        if (render_lock) {
-            WaitForSingleObject(render_lock, INFINITE);
-            vector_task_render_clear(&tasks_render);
-            if (muctx && mu_lock && input_lock) {
-                WaitForSingleObject(input_lock, INFINITE);
-                WaitForSingleObject(mu_lock, INFINITE);
-                mui_process();
-                ReleaseMutex(mu_lock);
-                ReleaseMutex(input_lock);
-            }
-            ReleaseMutex(render_lock);
-        }
+        classes_process_control(classes, classes_count);
 
-        for (size_t i = 0; i < classes_count; i++)
-            if (classes[i].control)
-                classes[i].control();
+        if (lock_check_init(control_freq_lock) || lock_check_init(render_freq_lock)
+            || lock_check_init(sound_freq_lock) || lock_check_init(input_freq_lock)) {
+            char buf[0x1000];
+            int32_t len = 0;
+            lock_lock(control_freq_lock);
+            len += snprintf(buf + len, sizeof(buf) - len, "Control: %04d ", (int32_t)round(control_freq));
+            lock_unlock(control_freq_lock);
 
-        if (control_freq_lock || render_freq_lock || sound_freq_lock || input_freq_lock) {
-            if (control_freq_lock) {
-                WaitForSingleObject(control_freq_lock, INFINITE);
-                printf("Control: %04d ", (int32_t)round(control_freq));
-                ReleaseMutex(control_freq_lock);
-            }
+            lock_lock(render_freq_lock);
+            len += snprintf(buf + len, sizeof(buf) - len, "Render: %04d ", (int32_t)round(render_freq));
+            lock_unlock(render_freq_lock);
 
-            if (render_freq_lock) {
-                WaitForSingleObject(render_freq_lock, INFINITE);
-                printf("Render: %04d ", (int32_t)round(render_freq));
-                ReleaseMutex(render_freq_lock);
-            }
+            lock_lock(render_freq_lock);
+            len += snprintf(buf + len, sizeof(buf) - len, "Sound: %04d ", (int32_t)round(sound_freq));
+            lock_unlock(render_freq_lock);
 
-            if (sound_freq_lock) {
-                WaitForSingleObject(sound_freq_lock, INFINITE);
-                printf("Sound: %04d ", (int32_t)round(sound_freq));
-                ReleaseMutex(sound_freq_lock);
-            }
-
-            if (input_freq_lock) {
-                WaitForSingleObject(input_freq_lock, INFINITE);
-                printf("Input: %04d ", (int32_t)round(input_freq));
-                ReleaseMutex(input_freq_lock);
-            }
-            printf("\n");
+            lock_lock(input_freq_lock);
+            len += snprintf(buf + len, sizeof(buf) - len, "Input: %04d ", (int32_t)round(input_freq));
+            lock_unlock(input_freq_lock);
+            len += snprintf(buf + len, sizeof(buf) - len, "\n");
+            printf(buf);
         }
 
         double_t cycle_time = timer_calc_post(control);
@@ -119,95 +87,3 @@ static void write_log(const char* text) {
     strcat_s(logbuf, 64000, text);
     logbuf_updated = 1;
 }
-
-static void mui_process() {
-    if (mu_input_lock && window_handle == GetForegroundWindow()) {
-        POINT position = input_mouse_position();
-        double_t scroll_x = input_mouse_scroll_x() * -50.0;
-        double_t scroll_y = input_mouse_scroll_y() * -50.0;
-        input_mouse_reset_scroll();
-        mu_input_mousemove(muctx, position.x, position.y);
-        mu_input_scroll(muctx, (int)round(scroll_x), (int)round(scroll_y));
-
-        if (input_is_tapped(VK_LBUTTON))
-            mu_input_mousedown(muctx, MU_MOUSE_LEFT);
-        else if (input_is_released(VK_LBUTTON))
-            mu_input_mouseup(muctx, MU_MOUSE_LEFT);
-
-        if (input_is_tapped(VK_RBUTTON))
-            mu_input_mousedown(muctx, MU_MOUSE_RIGHT);
-        else if (input_is_released(VK_RBUTTON))
-            mu_input_mouseup(muctx, MU_MOUSE_RIGHT);
-
-        if (input_is_tapped(VK_MBUTTON))
-            mu_input_mousedown(muctx, MU_MOUSE_MIDDLE);
-        else if (input_is_released(VK_MBUTTON))
-            mu_input_mouseup(muctx, MU_MOUSE_MIDDLE);
-
-        if (input_is_tapped(VK_SHIFT) || input_is_tapped(VK_LSHIFT) || input_is_tapped(VK_RSHIFT))
-            mu_input_keydown(muctx, MU_KEY_SHIFT);
-        else if (input_is_released(VK_SHIFT) || input_is_released(VK_SHIFT) || input_is_released(VK_SHIFT))
-            mu_input_keyup(muctx, MU_KEY_SHIFT);
-
-        if (input_is_tapped(VK_CONTROL) || input_is_tapped(VK_LCONTROL) || input_is_tapped(VK_RCONTROL))
-            mu_input_keydown(muctx, MU_KEY_CTRL);
-        else if (input_is_released(VK_CONTROL) || input_is_released(VK_CONTROL) || input_is_released(VK_CONTROL))
-            mu_input_keyup(muctx, MU_KEY_CTRL);
-
-        if (input_is_tapped(VK_MENU) || input_is_tapped(VK_LMENU) || input_is_tapped(VK_RMENU))
-            mu_input_keydown(muctx, MU_KEY_ALT);
-        else if (input_is_released(VK_MENU) || input_is_released(VK_LMENU) || input_is_released(VK_RMENU))
-            mu_input_keyup(muctx, MU_KEY_ALT);
-
-        if (input_is_tapped(VK_RETURN))
-            mu_input_keydown(muctx, MU_KEY_RETURN);
-        else if (input_is_released(VK_RETURN))
-            mu_input_keyup(muctx, MU_KEY_RETURN);
-
-        if (input_is_tapped(VK_BACK))
-            mu_input_keydown(muctx, MU_KEY_BACKSPACE);
-        else if (input_is_released(VK_BACK))
-            mu_input_keyup(muctx, MU_KEY_BACKSPACE);
-        
-        if (input_is_tapped(VK_ESCAPE))
-            muctx->focus = 0;
-
-        WaitForSingleObject(mu_input_lock, INFINITE);
-        mu_input_text(muctx, mu_input_ansi.begin);
-        vector_wchar_t_clear(&mu_input);
-        mu_input.end++;
-        mu_input.end[-1] = 0;
-        vector_char_clear(&mu_input_ansi);
-        mu_input_ansi.end++;
-        mu_input_ansi.end[-1] = 0;
-        ReleaseMutex(mu_input_lock);
-    }
-    
-    mu_begin(muctx);
-    for (size_t i = 0; i < classes_count; i++)
-        if (classes[i].mui)
-            classes[i].mui();
-
-    if (input_is_tapped(VK_RBUTTON))
-        mu_open_popup(muctx, "context menu");
-
-    if (mu_begin_window_ex(muctx, "context menu",
-        mu_rect(0, 0, 180, 120),
-        MU_OPT_NOTITLE | MU_OPT_POPUP | MU_OPT_CLOSED, false, true, false)) {
-        mu_Rect body = muctx->layout_stack.items[muctx->layout_stack.idx - 1].body;
-        mu_layout_row(muctx, 1, (int[]) { body.w }, 0);
-        for (size_t i = 0; i < classes_count; i++) {
-            if (!classes[i].enabled || !classes[i].init || !classes[i].name || ~classes[i].flags & CLASSES_IN_CONTEXT_MENU)
-                continue;
-
-            mu_push_id(muctx, &i, sizeof(i));
-            if (*classes[i].enabled)
-                mu_draw_control_text(muctx, classes[i].name, mu_layout_next(muctx), MU_COLOR_TEXT, 0);
-            else if (mu_button_ex(muctx, classes[i].name, 0, 0))
-                classes[i].init();
-            mu_pop_id(muctx);
-        }
-        mu_end_window(muctx);
-    }
-    mu_end(muctx);
-}

src/CLOUD/input.c

@@ -7,7 +7,8 @@
 
 #include "input.h"
 #include "../KKdLib/vec.h"
-#include "../CRE/microui.h"
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include <cimgui.h>
 
 #define KEYBOARD_KEYS 0xFF
 
@@ -17,8 +18,6 @@ typedef struct key_state {
 
 typedef struct mouse_state {
     POINT position;
-    double_t scroll_x;
-    double_t scroll_y;
 } mouse_state;
 
 key_state input_key_current_state;
@@ -27,17 +26,19 @@ key_state input_key_last_state;
 mouse_state input_mouse_current_state;
 mouse_state input_mouse_last_state;
 
-float_t input_movement_speed = 1.0f;
-float_t input_rotation_sensitivity = 0.5f;
-vec2 input_move;
-vec2 input_rotate;
+double_t input_movement_speed = 0.1;
+double_t input_rotation_sensitivity = 0.5;
+vec2d input_move;
+vec2d input_rotate;
+double_t input_roll;
 bool input_reset;
 bool input_reset_mouse_position;
+bool input_locked;
 
 extern bool close;
-HANDLE input_lock = 0;
+lock_val(input_lock);
+extern HANDLE render_lock;
 extern HANDLE window_handle;
-extern HANDLE mu_input_lock;
 
 void input_poll();
 
@@ -47,19 +48,22 @@ timer_val(input);
 
 int32_t input_main(void* arg) {
     timer_init(input, "Input");
-    input_lock = CreateMutexW(0, 0, L"Input");
-    if (!input_lock)
+    lock_init(input_lock);
+    if (!input_lock_init)
         goto End;
 
+    while (state != RENDER_INITIALIZED)
+        msleep(input_timer, 0.0625);
+
     while (!close) {
         timer_calc_pre(input);
-        WaitForSingleObject(input_lock, INFINITE);
+        lock_lock(input_lock);
         input_poll();
-        ReleaseMutex(input_lock);
+        lock_unlock(input_lock);
         double_t cycle_time = timer_calc_post(input);
         msleep(input_timer, 1000.0 / FREQ - cycle_time);
     }
-    CloseHandle(input_lock);
+    lock_dispose(input_lock);
 
 End:
     timer_dispose(input);
@@ -70,6 +74,7 @@ void input_poll() {
     input_mouse_last_state = input_mouse_current_state;
     input_key_last_state = input_key_current_state;
 
+    ImGuiIO* io = igGetIO();
     for (uint8_t i = 0; i < KEYBOARD_KEYS; i++)
         input_key_current_state.key_states[i] = GetAsyncKeyState(i) < 0;
 
@@ -78,57 +83,69 @@ void input_poll() {
         ScreenToClient(window_handle, &input_mouse_current_state.position);
     }
 
-    input_rotate.x = 0.0f;
-    input_rotate.y = 0.0f;
-    input_move.x = 0.0f;
-    input_move.y = 0.0f;
+    input_move.x = 0.0;
+    input_move.y = 0.0;
+    input_rotate.x = 0.0;
+    input_rotate.y = 0.0;
+    input_roll = 0.0;
 
-    if (!window_handle || window_handle != GetForegroundWindow() || (muctx && muctx->text_input))
+    if (!window_handle || window_handle != GetForegroundWindow())
         return;
 
-    float_t temp_input_movement_speed = input_movement_speed / 10.0f;
-    if (input_is_down(VK_SHIFT))
-        temp_input_movement_speed = input_movement_speed;
-    else if (input_is_down(VK_CONTROL))
-        temp_input_movement_speed = input_movement_speed / 100.0f;
+    input_locked = false;
+    classes_process_input(classes, classes_count);
 
-    if (input_is_down('W'))
-        input_move.x += temp_input_movement_speed;
-    if (input_is_down('A'))
-        input_move.y -= temp_input_movement_speed;
-    if (input_is_down('S'))
-        input_move.x -= temp_input_movement_speed;
-    if (input_is_down('D'))
-        input_move.y += temp_input_movement_speed;
+    if (!input_locked) {
+        double_t speed;
+        if (input_is_down(VK_SHIFT))
+            speed = input_movement_speed * 10.0;
+        else if (input_is_down(VK_CONTROL))
+            speed = input_movement_speed / 10.0;
+        else
+            speed = input_movement_speed;
 
-    temp_input_movement_speed = input_movement_speed;
-    if (input_is_down(VK_SHIFT))
-        temp_input_movement_speed = input_movement_speed * 10.0f;
-    else if (input_is_down(VK_CONTROL))
-        temp_input_movement_speed = input_movement_speed / 10.0f;
+        if (input_is_down('W'))
+            input_move.x += speed;
+        if (input_is_down('S'))
+            input_move.x -= speed;
 
-    if (input_is_down(VK_UP))
-        input_rotate.y += temp_input_movement_speed;
-    if (input_is_down(VK_LEFT))
-        input_rotate.x -= temp_input_movement_speed;
-    if (input_is_down(VK_DOWN))
-        input_rotate.y -= temp_input_movement_speed;
-    if (input_is_down(VK_RIGHT))
-        input_rotate.x += temp_input_movement_speed;
+        if (input_is_down('A'))
+            input_move.y -= speed;
+        if (input_is_down('D'))
+            input_move.y += speed;
 
-    if (input_is_tapped('R'))
-        input_reset = true;
+        if (input_is_down(VK_SHIFT))
+            speed = input_movement_speed * 100.0;
+        else if (input_is_down(VK_CONTROL))
+            speed = input_movement_speed;
+        else
+            speed = input_movement_speed * 10.0;
 
-    for (size_t i = 0; i < classes_count; i++)
-        if (classes[i].input)
-            classes[i].input();
+        if (input_is_down(VK_UP))
+            input_rotate.y += speed;
+        if (input_is_down(VK_DOWN))
+            input_rotate.y -= speed;
 
-    if (input_is_down(VK_MBUTTON)) {
+        if (input_is_down(VK_LEFT))
+            input_rotate.x -= speed;
+        if (input_is_down(VK_RIGHT))
+            input_rotate.x += speed;
+
+        if (input_is_down('Q'))
+            input_roll -= speed;
+        if (input_is_down('E'))
+            input_roll += speed;
+
+        if (input_is_tapped('R'))
+            input_reset = true;
+    }
+
+    if (!io->WantCaptureMouse && input_is_down(VK_MBUTTON)) {
         if (!input_reset_mouse_position) {
             POINT last = input_mouse_last_state.position;
             POINT curr = input_mouse_current_state.position;
-            input_rotate.y += (float_t)(((double_t)last.y - (double_t)curr.y) * input_rotation_sensitivity);
-            input_rotate.x += (float_t)(((double_t)curr.x - (double_t)last.x) * input_rotation_sensitivity);
+            input_rotate.y += ((double_t)last.y - (double_t)curr.y) * input_rotation_sensitivity;
+            input_rotate.x += ((double_t)curr.x - (double_t)last.x) * input_rotation_sensitivity;
         }
         input_reset_mouse_position = false;
     }
@@ -163,24 +180,3 @@ inline bool input_was_up(uint8_t keycode) {
 inline POINT input_mouse_position() {
     return input_mouse_current_state.position;
 }
-
-inline void input_mouse_reset_scroll() {
-    input_mouse_current_state.scroll_x = 0.0f;
-    input_mouse_current_state.scroll_y = 0.0f;
-}
-
-inline double_t input_mouse_scroll_x() {
-    return input_mouse_current_state.scroll_x;
-}
-
-inline double_t input_mouse_scroll_y() {
-    return input_mouse_current_state.scroll_y;
-}
-
-inline void input_mouse_add_scroll_x(double_t value) {
-    input_mouse_current_state.scroll_x += value;
-}
-
-inline void input_mouse_add_scroll_y(double_t value) {
-    input_mouse_current_state.scroll_y += value;
-}

src/CLOUD/input.h

@@ -15,8 +15,3 @@ extern bool input_is_released(uint8_t keycode);
 extern bool input_was_down(uint8_t keycode);
 extern bool input_was_up(uint8_t keycode);
 extern POINT input_mouse_position();
-extern double_t input_mouse_scroll_x();
-extern double_t input_mouse_scroll_y();
-extern void input_mouse_reset_scroll();
-extern void input_mouse_add_scroll_x(double_t value);
-extern void input_mouse_add_scroll_y(double_t value);

src/CLOUD/main.c

@@ -4,15 +4,13 @@
 */
 
 #include "../KKdLib/kkfs.h"
-#include "../KKdLib/f2_struct.h"
-#include "../KKdLib/mat.h"
-#include "../KKdLib/vec.h"
 #include "elf.h"
 #include "main.h"
 #include "unedat.h"
 #include <processthreadsapi.h>
+#include <timeapi.h>
 
-FORCE_INLINE void next_rand_uint8_t_pointer(uint8_t* arr, size_t length, uint32_t* state) {
+static inline void next_rand_uint8_t_pointer(uint8_t* arr, size_t length, uint32_t* state) {
     if (!arr || length < 1)
         return;
 
@@ -96,68 +94,10 @@ typedef struct thread {
 } thread;
 
 int wmain(int argc, wchar_t** argv) {
-    /*stream* s;
-    void* data;
-    size_t length;
-    f2_struct* st;
-    s = io_wopen(L"eff_stgpv832_main!\\eff_stgpv832_main.drs", L"rb");
-    length = s->length;
-    data = force_malloc(length);
-    io_read(s, data, length);
-    io_dispose(s);
-
-    st = f2_struct_init();
-    f2_struct_read_memory(st, data, length);
-    free(data);
-    f2_struct_write_memory(st, &data, &length, true, false);
-    f2_struct_dispose(st);
-
-    s = io_wopen(L"eff_stgpv832_main\\eff_stgpv832_main.drs", L"wb");
-    io_write(s, data, length);
-    io_dispose(s);
-    free(data);
-
-    s = io_wopen(L"eff_stgpv832_main!\\eff_stgpv832_main.dve", L"rb");
-    length = s->length;
-    data = force_malloc(length);
-    io_read(s, data, length);
-    io_dispose(s);
-
-    st = f2_struct_init();
-    f2_struct_read_memory(st, data, length);
-    free(data);
-    f2_struct_write_memory(st, &data, &length, true, false);
-    f2_struct_dispose(st);
-
-    s = io_wopen(L"eff_stgpv832_main\\eff_stgpv832_main.dve", L"wb");
-    io_write(s, data, length);
-    io_dispose(s);
-    free(data);
-
-    s = io_wopen(L"eff_stgpv832_main!\\eff_stgpv832_main.lst", L"rb");
-    length = s->length;
-    data = force_malloc(length);
-    io_read(s, data, length);
-    io_dispose(s);
-
-    st = f2_struct_init();
-    f2_struct_read_memory(st, data, length);
-    free(data);
-    f2_struct_write_memory(st, &data, &length, true, false);
-    f2_struct_dispose(st);
-
-    s = io_wopen(L"eff_stgpv832_main\\eff_stgpv832_main.lst", L"wb");
-    io_write(s, data, length);
-    io_dispose(s);
-    free(data);
-
-    farc* f = farc_init();
-    farc_wwrite(f, argv[1], FARC_COMPRESS_FARC_GZIP_AES);
-    farc_dispose(f);
-    return;*/
-
     //ShowWindow(GetConsoleWindow(), SW_HIDE);
+    timeBeginPeriod(1);
     QueryPerformanceFrequency(&performance_frequency);
+    SetProcessDPIAware();
 
     render_init_struct ris;
     ris.res.x = 0;
@@ -184,6 +124,7 @@ int wmain(int argc, wchar_t** argv) {
         CloseHandle(render.handle);
     if (sound.handle)
         CloseHandle(sound.handle);
+    timeEndPeriod(1);
     return 0;
 }
 

src/CLOUD/render.h

@@ -8,19 +8,6 @@
 #include "shared.h"
 #include "../KKdLib/vec.h"
 #include "../KKdLib/vector.h"
-#include "../CRE/gl_object.h"
-#include "../CRE/hash.h"
-#include "../CRE/shader.h"
-#include "../CRE/task.h"
-#include "../CRE/texture.h"
-#include "../CRE/vertex.h"
-
-typedef enum render_state {
-    RENDER_CLOSED        = -1,
-    RENDER_UNINITIALIZED =  0,
-    RENDER_INITIALIZING  =  1,
-    RENDER_INITIALIZED   =  2,
-} render_state;
 
 typedef struct render_init_struct {
     vec2i res;
@@ -28,19 +15,5 @@ typedef struct render_init_struct {
     float_t scale;
 } render_init_struct;
 
-hash_ptr(gl_object)
-hash(shader_model)
-hash(texture)
-hash(texture_set)
-hash_ptr(vertex)
-
-extern shader_fbo particle_shader;
-
-vector(hash_ptr_gl_object)
-vector(hash_shader_model)
-vector(hash_texture)
-vector(hash_texture_set)
-vector(hash_ptr_vertex)
-
 extern int32_t render_main(void* arg);
 extern void render_set_scale(double_t value);

src/CLOUD/shared.c

@@ -5,58 +5,61 @@
 
 #include "shared.h"
 
-mu_Context* muctx;
-
-const classes_struct classes[] = {
+classes_struct classes[] = {
+#ifndef CLOUD_DEV
     {
-        .name    = "BACKGROUND COLOR",
+        .name    = "Data Test",
         .flags   = CLASSES_IN_CONTEXT_MENU,
-        .enabled = &background_color.enabled,
-        .dispose = (void*)background_color_dispose,
-        .init    = (void*)background_color_init,
-        .control = (void*)background_color_control,
-        .input   = (void*)background_color_input,
-        .mui     = (void*)background_color_mui,
-        .render  = (void*)background_color_render,
-        .sound   = (void*)background_color_sound,
+        .enabled = &data_test_enabled,
+        .dispose = (void*)0,
+        .init    = (void*)0,
+        .control = (void*)0,
+        .drop    = (void*)0,
+        .imgui   = (void*)0,
+        .input   = (void*)0,
+        .render  = (void*)0,
+        .sound   = (void*)0,
+        .lock = 0,
+        .sub_classes = data_test_classes,
+        .sub_classes_count = 1,
     },
-    /*{
-        .name    = "GLITTER TEST",
-        //.flags   = CLASSES_INIT_AT_STARTUP | CLASSES_IN_CONTEXT_MENU,
-        .flags   = 0,
-        .enabled = &glitter_test.enabled,
-        .dispose = (void*)glitter_test_dispose,
-        .init    = (void*)glitter_test_init,
-        .control = (void*)glitter_test_control,
-        .input   = (void*)glitter_test_input,
-        .mui     = (void*)glitter_test_mui,
-        .render  = (void*)glitter_test_render,
-        .sound   = (void*)glitter_test_sound,
-    },*/
+#endif
     {
-        .name    = "POST PROCESS",
+        .name    = "Graphics",
         .flags   = CLASSES_IN_CONTEXT_MENU,
-        .enabled = &post_process.enabled,
-        .dispose = (void*)post_process_dispose,
-        .init    = (void*)post_process_init,
-        .control = (void*)post_process_control,
-        .input   = (void*)post_process_input,
-        .mui     = (void*)post_process_mui,
-        .render  = (void*)post_process_render,
-        .sound   = (void*)post_process_sound,
+        .enabled = &graphics_enabled,
+        .dispose = (void*)0,
+        .init    = (void*)0,
+        .control = (void*)0,
+        .drop    = (void*)0,
+        .imgui   = (void*)0,
+        .input   = (void*)0,
+        .render  = (void*)0,
+        .sound   = (void*)0,
+        .lock = 0,
+        .sub_classes = graphics_classes,
+        .sub_classes_count = 3,
     },
+#ifdef CLOUD_DEV
     {
-        .name    = "GLITTER EDITOR",
+        .name    = "Glitter Editor",
         .flags   = CLASSES_INIT_AT_STARTUP,
-        .enabled = &glitter_editor.enabled,
+        .enabled = &glitter_editor_enabled,
         .dispose = (void*)glitter_editor_dispose,
         .init    = (void*)glitter_editor_init,
-        .control = (void*)glitter_editor_control,
+        .control = (void*)0,
+        .drop    = (void*)glitter_editor_drop,
+        .imgui   = (void*)glitter_editor_imgui,
         .input   = (void*)glitter_editor_input,
-        .mui     = (void*)glitter_editor_mui,
         .render  = (void*)glitter_editor_render,
-        .sound   = (void*)glitter_editor_sound,
+        .sound   = (void*)0,
+        .lock = 0,
+        .sub_classes = 0,
+        .sub_classes_count = 0,
     },
+#endif
 };
 
 const size_t classes_count = sizeof(classes) / sizeof(classes_struct);
+
+render_state state;

src/CLOUD/shared.h

@@ -5,32 +5,21 @@
 
 #pragma once
 
-#include "../KKdLib/default.h"
-#include "../CRE/microui.h"
-#include "Classes/background_color.h"
-#include "Classes/glitter_editor.h"
-#include "Classes/glitter_test.h"
-#include "Classes/post_process.h"
+#include "classes.h"
+#define CIMGUI_DEFINE_ENUMS_AND_STRUCTS
+#include <cimgui.h>
+#include "classes/data_test.h"
+#include "classes/glitter_editor.h"
+#include "classes/graphics.h"
 
-typedef enum classes_enum {
-    CLASSES_INIT_AT_STARTUP = 0x01,
-    CLASSES_IN_CONTEXT_MENU = 0x02,
-} classes_enum;
+typedef enum render_state {
+    RENDER_UNINITIALIZED =  0,
+    RENDER_INITIALIZING  =  1,
+    RENDER_INITIALIZED   =  2,
+    RENDER_DISPOSING     =  3,
+    RENDER_DISPOSED      =  4,
+} render_state;
 
-typedef struct classes_struct {
-    char* name;
-    classes_enum flags;
-    bool* enabled;
-    void(FASTCALL* dispose)();
-    void(FASTCALL* init)();
-    void(FASTCALL* control)();
-    void(FASTCALL* input)();
-    void(FASTCALL* mui)();
-    void(FASTCALL* render)();
-    void(FASTCALL* sound)();
-} classes_struct;
-
-extern mu_Context* muctx;
-
-extern const classes_struct classes[];
+extern classes_struct classes[];
 extern const size_t classes_count;
+extern render_state state;

src/CLOUD/sound.c

@@ -13,11 +13,12 @@ timer_val(sound);
 
 int32_t sound_main(void* arg) {
     timer_init(sound, "Sound");
+    while (state != RENDER_INITIALIZED)
+        msleep(sound_timer, 0.0625);
+
     while (!close) {
         timer_calc_pre(sound);
-        for (size_t i = 0; i < classes_count; i++)
-            if (classes[i].sound)
-                classes[i].sound();
+        classes_process_sound(classes, classes_count);
         double_t cycle_time = timer_calc_post(sound);
         msleep(sound_timer, 1000.0 / FREQ - cycle_time);
     }

src/CRE/Glitter/animation.c

@@ -6,34 +6,107 @@
 #include "animation.h"
 #include "curve.h"
 
-void FASTCALL glitter_animation_parse_file(f2_struct* st, vector_ptr_glitter_curve* vec) {
-    if (!st || !st->header.data_size)
+void FASTCALL glitter_animation_copy(GPM,
+    vector_ptr_glitter_curve* src, vector_ptr_glitter_curve* dst) {
+    if (!dst)
         return;
 
+    vector_ptr_glitter_curve_free(dst, glitter_curve_dispose);
+
+    if (!src)
+        return;
+
+    vector_ptr_glitter_curve_append(dst, src->end - src->begin);
+    for (glitter_curve** i = src->begin; i != src->end; i++)
+        if (*i) {
+            glitter_curve* c = glitter_curve_copy(GPM_VAL, *i);
+            if (c)
+                vector_ptr_glitter_curve_push_back(dst, &c);
+        }
+}
+
+bool FASTCALL glitter_animation_parse_file(GPM, f2_struct* st,
+    vector_ptr_glitter_curve* vec, glitter_curve_type_flags flags) {
+    glitter_curve* c;
+
+    if (!st || !st->header.data_size)
+        return false;
+
     for (f2_struct* i = st->sub_structs.begin; i != st->sub_structs.end; i++) {
         if (!i->header.data_size)
             continue;
 
-        if (i->header.signature == 0x56525543)
-            glitter_curve_parse_file(i, vec);
+        if (i->header.signature == reverse_endianess_uint32_t('CURV')
+            && glitter_curve_parse_file(GPM_VAL, i, st->header.version, &c))
+            if (flags & 1 << (size_t)(int32_t)c->type)
+                vector_ptr_glitter_curve_push_back(vec, &c);
+            else
+                glitter_curve_dispose(c);
     }
+    return true;
 }
 
-bool FASTCALL glitter_animation_unparse_file(f2_struct* st, vector_ptr_glitter_curve* vec, bool use_big_endian) {
+bool FASTCALL glitter_animation_unparse_file(GPM, f2_struct* st,
+    vector_ptr_glitter_curve* vec, glitter_curve_type_flags flags) {
     memset(st, 0, sizeof(f2_struct));
 
     if (vec->end - vec->begin <= 0)
         return false;
 
-    f2_struct* s = f2_struct_init();
-    for (glitter_curve** i = vec->begin; i != vec->end; i++)
-        if (*i) {
-            glitter_curve_unparse_file(s, *i, use_big_endian);
-            vector_f2_struct_push_back(&st->sub_structs, s);
-        }
-    free(s);
+    static const glitter_curve_type order[] = {
+        GLITTER_CURVE_COLOR_A,
+        GLITTER_CURVE_COLOR_R,
+        GLITTER_CURVE_COLOR_G,
+        GLITTER_CURVE_COLOR_B,
+        GLITTER_CURVE_COLOR_RGB_SCALE,
+        GLITTER_CURVE_COLOR_A_2ND,
+        GLITTER_CURVE_COLOR_R_2ND,
+        GLITTER_CURVE_COLOR_G_2ND,
+        GLITTER_CURVE_COLOR_B_2ND,
+        GLITTER_CURVE_COLOR_RGB_SCALE_2ND,
+        GLITTER_CURVE_TRANSLATION_X,
+        GLITTER_CURVE_TRANSLATION_Y,
+        GLITTER_CURVE_TRANSLATION_Z,
+        GLITTER_CURVE_ROTATION_X,
+        GLITTER_CURVE_ROTATION_Y,
+        GLITTER_CURVE_ROTATION_Z,
+        GLITTER_CURVE_SCALE_X,
+        GLITTER_CURVE_SCALE_Y,
+        GLITTER_CURVE_SCALE_Z,
+        GLITTER_CURVE_SCALE_ALL,
+        GLITTER_CURVE_EMISSION_INTERVAL,
+        GLITTER_CURVE_PARTICLES_PER_EMISSION,
+        GLITTER_CURVE_U_SCROLL,
+        GLITTER_CURVE_V_SCROLL,
+        GLITTER_CURVE_U_SCROLL_ALPHA,
+        GLITTER_CURVE_V_SCROLL_ALPHA,
+        GLITTER_CURVE_U_SCROLL_2ND,
+        GLITTER_CURVE_V_SCROLL_2ND,
+        GLITTER_CURVE_U_SCROLL_ALPHA_2ND,
+        GLITTER_CURVE_V_SCROLL_ALPHA_2ND,
+    };
 
-    st->header.signature = 0x4D494E41;
+    for (int32_t i = GLITTER_CURVE_TRANSLATION_X; i <= GLITTER_CURVE_V_SCROLL_ALPHA_2ND; i++) {
+        if (!(flags & 1 << (size_t)order[i]))
+            continue;
+
+        for (glitter_curve** j = vec->begin; j != vec->end; j++) {
+            glitter_curve* c = *j;
+            if (!c || c->type != order[i])
+                continue;
+
+            f2_struct s;
+            if (glitter_curve_unparse_file(GPM_VAL, &s, c)) {
+                vector_f2_struct_push_back(&st->sub_structs, &s);
+                break;
+            }
+        }
+    }
+
+    if (st->sub_structs.end - st->sub_structs.begin < 1)
+        return false;
+
+    st->header.signature = reverse_endianess_uint32_t('ANIM');
     st->header.length = 0x20;
     st->header.use_big_endian = false;
     st->header.use_section_size = true;

src/CRE/Glitter/animation.h

@@ -7,5 +7,9 @@
 
 #include "glitter.h"
 
-extern void FASTCALL glitter_animation_parse_file(f2_struct* st, vector_ptr_glitter_curve* vec);
-extern bool FASTCALL glitter_animation_unparse_file(f2_struct* st, vector_ptr_glitter_curve* vec, bool use_big_endian);
+extern void FASTCALL glitter_animation_copy(GPM,
+    vector_ptr_glitter_curve* src, vector_ptr_glitter_curve* dst);
+extern bool FASTCALL glitter_animation_parse_file(GPM, f2_struct* st,
+    vector_ptr_glitter_curve* vec, glitter_curve_type_flags flags);
+extern bool FASTCALL glitter_animation_unparse_file(GPM, f2_struct* st,
+    vector_ptr_glitter_curve* vec, glitter_curve_type_flags flags);

src/CRE/Glitter/counter.c

@@ -5,18 +5,6 @@
 
 #include "counter.h"
 
-extern glitter_particle_manager* gpm;
-
-int32_t FASTCALL glitter_counter_get() {
-    if (gpm->f2)
-        return gpm->counter & 0xFF;
-    else
-        return gpm->counter & 0xFFF;
-}
-
-void FASTCALL glitter_counter_increment() {
-    if (gpm->f2)
-        gpm->counter++;
-    else
-        gpm->counter++;
+int32_t FASTCALL glitter_counter_get(GPM) {
+    return ++gpm->counter;
 }

src/CRE/Glitter/counter.h

@@ -7,5 +7,4 @@
 
 #include "glitter.h"
 
-extern int32_t FASTCALL glitter_counter_get();
-extern void FASTCALL glitter_counter_increment();
+extern int32_t FASTCALL glitter_counter_get(GPM);

src/CRE/Glitter/curve.h

@@ -7,9 +7,16 @@
 
 #include "glitter.h"
 
-extern glitter_curve* FASTCALL glitter_curve_init();
-extern bool FASTCALL glitter_curve_get_value(glitter_curve* c,
-    float_t frame, float_t* value, int32_t random);
-extern void FASTCALL glitter_curve_parse_file(f2_struct* st, vector_ptr_glitter_curve* vec);
-extern void FASTCALL glitter_curve_unparse_file(f2_struct* st, glitter_curve* c, bool use_big_endian);
+extern glitter_curve* FASTCALL glitter_curve_init(GPM);
+extern glitter_curve* FASTCALL glitter_curve_copy(GPM, glitter_curve* c);
+extern bool FASTCALL glitter_curve_get_value(GPM, glitter_curve* c,
+    float_t frame, float_t* value, int32_t random_value, glitter_random* random);
+extern bool FASTCALL glitter_curve_parse_file(GPM,
+    f2_struct* st, uint32_t version, glitter_curve** c);
+#if defined(CRE_DEV) || defined(CLOUD_DEV)
+extern void FASTCALL glitter_curve_recalculate(GPM,
+    glitter_curve* curve, vector_glitter_curve_key* dest);
+#endif
+extern bool FASTCALL glitter_curve_unparse_file(GPM,
+    f2_struct* st, glitter_curve* c);
 extern void FASTCALL glitter_curve_dispose(glitter_curve* c);

src/CRE/Glitter/curve_get_value.c

@@ -0,0 +1,198 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "curve.h"
+#include "random.h"
+
+static void FASTCALL glitter_curve_get_key_indexes(vector_glitter_curve_key* keys,
+    float_t frame, size_t* curr, size_t* next);
+static float_t FASTCALL glitter_curve_interpolate(GPM, glitter_curve* c, float_t frame,
+    glitter_curve_key* curr, glitter_curve_key* next, glitter_key_type key_type, glitter_random* random);
+static float_t FASTCALL glitter_curve_randomize(GPM,
+    glitter_curve* c, float_t value, glitter_random* random);
+static float_t FASTCALL glitter_curve_randomize_key(GPM,
+    glitter_curve* c, glitter_curve_key* key, glitter_random* random);
+
+bool FASTCALL glitter_curve_get_value(GPM, glitter_curve* c,
+    float_t frame, float_t* value, int32_t random_value, glitter_random* random) {
+    size_t keys_count;
+    int32_t random_val;
+    bool negate;
+    float_t _value;
+
+    keys_count = c->keys.end - c->keys.begin;
+    if (!keys_count)
+        return false;
+
+    random_val = glitter_random_get_value(random);
+    glitter_random_set_value(random, random_value);
+    negate = c->flags & GLITTER_CURVE_NEGATE
+        && glitter_random_get_int_min_max(GPM_VAL, random, 0, 0xFFFF) > 0x7FFF;
+    if (c->flags & GLITTER_CURVE_STEP)
+        glitter_random_set_value(random, random_val + 1);
+
+    if (keys_count == 1) {
+        glitter_curve_key* key = &c->keys.begin[keys_count - 1];
+        _value = glitter_curve_randomize_key(GPM_VAL, c, key, random);
+        goto End;
+    }
+
+    float_t start_time = (float_t)c->start_time;
+    float_t end_time = (float_t)c->end_time;
+    if (c->repeat && (start_time > frame || frame >= end_time)) {
+        float_t t = (frame - start_time) / (end_time - start_time);
+        t = t <= 0.0f ? (float_t)(int32_t)t - 1.0f : (float_t)(int32_t)t;
+        frame -= t * (end_time - start_time);
+    }
+
+    if (end_time <= frame) {
+        glitter_curve_key* key = &c->keys.begin[keys_count - 1];
+        _value = glitter_curve_randomize_key(GPM_VAL, c, key, random);
+    }
+    else if (start_time > frame) {
+        glitter_curve_key* key = &c->keys.begin[0];
+        _value = glitter_curve_randomize_key(GPM_VAL, c, key, random);
+    }
+    else if (c->flags & GLITTER_CURVE_BAKED) {
+        size_t key_index;
+        if (frame >= end_time)
+            key_index = keys_count - 1;
+        else if (frame > start_time) {
+            key_index = (size_t)frame - c->start_time;
+            if (glt_type == GLITTER_F2)
+                key_index /= 2;
+
+            if (key_index >= keys_count)
+                key_index = keys_count - 1;
+        }
+        else
+            key_index = 0;
+
+        glitter_curve_key* key = &c->keys.begin[key_index];
+        _value = glitter_curve_randomize_key(GPM_VAL, c, key, random);
+    }
+    else {
+        size_t curr_key_index = 0;
+        size_t next_key_index = 0;
+        if (keys_count > 3)
+            glitter_curve_get_key_indexes(&c->keys, frame, &curr_key_index, &next_key_index);
+        else if (keys_count == 3 && frame >= c->keys.begin[1].frame) {
+            curr_key_index = 1;
+            next_key_index = 2;
+        }
+        else {
+            curr_key_index = 0;
+            next_key_index = 1;
+        }
+        glitter_curve_key* curr_key = &c->keys.begin[curr_key_index];
+        glitter_curve_key* next_key = &c->keys.begin[next_key_index];
+        _value = glitter_curve_interpolate(GPM_VAL, c, frame, curr_key, next_key, curr_key->type, random);
+    }
+
+End:
+    _value = glitter_curve_randomize(GPM_VAL, c, _value, random);
+    *value = negate ? -_value : _value;
+    glitter_random_set_value(random, random_val + 1);
+    return true;
+}
+
+static void FASTCALL glitter_curve_get_key_indexes(vector_glitter_curve_key* keys,
+    float_t frame, size_t* curr, size_t* next) {
+    size_t v4;
+    glitter_curve_key* v6;
+    size_t count;
+    size_t v9;
+    size_t v10;
+
+    count = keys->end - keys->begin;
+    if (count <= 1) {
+        *curr = 0;
+        *next = 0;
+        return;
+    }
+
+    v4 = 0;
+    v6 = keys->begin;
+    v9 = count - 1;
+    v10 = v9 / 2;
+    while (v4 <= v9) {
+        v10 = (v9 + v4) / 2;
+        if (frame <= v6[(v10 + 1) % count].frame) {
+            if (frame >= v6[v10].frame)
+                goto LABEL_12;
+            v9 = v10 - 1;
+        }
+        else
+            v4 = v10 + 1;
+    }
+
+    if (frame > v6[v10].frame) {
+    LABEL_12:
+        *curr = v10;
+        *next = v10 + 1;
+    }
+    else {
+        *curr = v10 - 1;
+        *next = v10;
+    }
+    *next %= count;
+}
+
+static float_t FASTCALL glitter_curve_interpolate(GPM, glitter_curve* c, float_t frame,
+    glitter_curve_key* curr, glitter_curve_key* next, glitter_key_type key_type, glitter_random* random) {
+    float_t next_val;
+    float_t curr_val;
+    float_t val;
+
+    if (key_type == GLITTER_KEY_CONSTANT)
+        return glitter_curve_randomize_key(GPM_VAL, c, curr, random);
+
+    float_t df = frame - (float_t)curr->frame;
+    float_t t = df / (float_t)(next->frame - curr->frame);
+    if (key_type == GLITTER_KEY_HERMITE) {
+        float_t t_1 = t - 1.0f;
+        next_val = glitter_curve_randomize_key(GPM_VAL, c, next, random);
+        curr_val = glitter_curve_randomize_key(GPM_VAL, c, curr, random);
+        val = glitter_curve_randomize_key(GPM_VAL, c, curr, random);
+        val += t * t * (3.0f - 2.0f * t) * (next_val - curr_val)
+            + (t_1 * curr->tangent2 + t * next->tangent1) * df * t_1;
+    }
+    else {
+        curr_val = glitter_curve_randomize_key(GPM_VAL, c, curr, random);
+        next_val = glitter_curve_randomize_key(GPM_VAL, c, next, random);
+        val = curr_val + (next_val - curr_val) * t;
+    }
+    return val;
+}
+
+static float_t FASTCALL glitter_curve_randomize(GPM,
+    glitter_curve* c, float_t value, glitter_random* random) {
+    float_t rand;
+
+    if (~c->flags & GLITTER_CURVE_RANDOM_RANGE)
+        return value;
+
+    rand = glitter_random_get_float_min_max(GPM_VAL, random,
+        c->flags & GLITTER_CURVE_RANDOM_RANGE_NEGATE ? -c->random_range : 0.0f, c->random_range);
+
+    if (c->flags & GLITTER_CURVE_RANDOM_RANGE_MULT)
+        rand *= value * 0.01f;
+    return rand + value;
+}
+
+static float_t FASTCALL glitter_curve_randomize_key(GPM,
+    glitter_curve* c, glitter_curve_key* key, glitter_random* random) {
+    float_t rand;
+
+    if (~c->flags & GLITTER_CURVE_KEY_RANDOM_RANGE)
+        return key->value;
+
+    rand = glitter_random_get_float_min_max(GPM_VAL, random,
+        c->flags & GLITTER_CURVE_RANDOM_RANGE_NEGATE ? -key->random_range : 0.0f, key->random_range);
+
+    if (c->flags & GLITTER_CURVE_RANDOM_RANGE_MULT)
+        rand *= key->value * 0.01f;
+    return rand + key->value;
+}

src/CRE/Glitter/diva_effect.c

@@ -6,21 +6,19 @@
 #include "diva_effect.h"
 #include "effect_group.h"
 
-extern glitter_particle_manager* gpm;
-
-bool FASTCALL glitter_diva_effect_parse_file(glitter_file_reader* fr, f2_struct* st) {
+bool FASTCALL glitter_diva_effect_parse_file(GPM, glitter_file_reader* fr, f2_struct* st) {
     glitter_effect_group* effect_group;
 
     if (!st || !st->header.data_size)
         return false;
 
-    effect_group = glitter_effect_group_init();
+    effect_group = glitter_effect_group_init(GPM_VAL);
     effect_group->hash = fr->hash;
     effect_group->emission = fr->emission;
-    if (fr->emission <= 0.0)
+    if (fr->emission <= 0.0f)
         effect_group->emission = gpm->emission;
     effect_group->version = st->header.version;
-    if (!glitter_effect_group_parse_file(effect_group, st)) {
+    if (!glitter_effect_group_parse_file(GPM_VAL, effect_group, st)) {
         glitter_effect_group_dispose(effect_group);
         return false;
     }
@@ -28,7 +26,7 @@ bool FASTCALL glitter_diva_effect_parse_file(glitter_file_reader* fr, f2_struct*
     return true;
 }
 
-bool FASTCALL glitter_diva_effect_unparse_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian) {
-    return glitter_effect_group_unparse_file(a1, st, use_big_endian);
+bool FASTCALL glitter_diva_effect_unparse_file(GPM, glitter_effect_group* a1, f2_struct* st) {
+    return glitter_effect_group_unparse_file(GPM_VAL, a1, st);
 }
 

src/CRE/Glitter/diva_effect.h

@@ -7,5 +7,5 @@
 
 #include "glitter.h"
 
-extern bool FASTCALL glitter_diva_effect_parse_file(glitter_file_reader* fr, f2_struct* st);
-extern bool FASTCALL glitter_diva_effect_unparse_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian);
+extern bool FASTCALL glitter_diva_effect_parse_file(GPM, glitter_file_reader* fr, f2_struct* st);
+extern bool FASTCALL glitter_diva_effect_unparse_file(GPM, glitter_effect_group* a1, f2_struct* st);

src/CRE/Glitter/diva_list.c

@@ -25,17 +25,17 @@ bool FASTCALL glitter_diva_list_parse_file(glitter_effect_group* a1, f2_struct*
     return true;
 }
 
-bool FASTCALL glitter_diva_list_unparse_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian) {
+bool FASTCALL glitter_diva_list_unparse_file(glitter_effect_group* a1, f2_struct* st) {
     memset(st, 0, sizeof(f2_struct));
 
-    f2_struct* s = f2_struct_init();
-    if (!glitter_list_pack_file(a1, s, use_big_endian)) {
-        f2_struct_dispose(s);
+    f2_struct s;
+    memset(&s, 0, sizeof(f2_struct));
+    if (!glitter_list_pack_file(a1, &s)) {
+        f2_struct_free(&s);
         return false;
     }
 
-    vector_f2_struct_push_back(&st->sub_structs, s);
-    free(s);
+    vector_f2_struct_push_back(&st->sub_structs, &s);
 
     st->header.signature = 0x5453494C;
     st->header.length = 0x20;

src/CRE/Glitter/diva_list.h

@@ -8,4 +8,4 @@
 #include "glitter.h"
 
 extern bool FASTCALL glitter_diva_list_parse_file(glitter_effect_group* a1, f2_struct* st);
-extern bool FASTCALL glitter_diva_list_unparse_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian);
+extern bool FASTCALL glitter_diva_list_unparse_file(glitter_effect_group* a1, f2_struct* st);

src/CRE/Glitter/diva_resource.c

@@ -25,17 +25,17 @@ bool FASTCALL glitter_diva_resource_parse_file(glitter_effect_group* a1, f2_stru
     return true;
 }
 
-bool FASTCALL glitter_diva_resource_unparse_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian) {
+bool FASTCALL glitter_diva_resource_unparse_file(glitter_effect_group* a1, f2_struct* st) {
     memset(st, 0, sizeof(f2_struct));
 
-    f2_struct* s = f2_struct_init();
-    if (!glitter_texture_resource_pack_file(a1, s, use_big_endian)) {
-        f2_struct_dispose(s);
+    f2_struct s;
+    memset(&s, 0, sizeof(f2_struct));
+    if (!glitter_texture_resource_pack_file(a1, &s)) {
+        f2_struct_free(&s);
         return false;
     }
 
-    vector_f2_struct_push_back(&st->sub_structs, s);
-    free(s);
+    vector_f2_struct_push_back(&st->sub_structs, &s);
 
     st->header.signature = 0x53525644;
     st->header.length = 0x20;

src/CRE/Glitter/diva_resource.h

@@ -8,4 +8,4 @@
 #include "glitter.h"
 
 extern bool FASTCALL glitter_diva_resource_parse_file(glitter_effect_group* a1, f2_struct* st);
-extern bool FASTCALL glitter_diva_resource_unparse_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian);
+extern bool FASTCALL glitter_diva_resource_unparse_file(glitter_effect_group* a1, f2_struct* st);

src/CRE/Glitter/effect.c

@@ -8,28 +8,58 @@
 #include "curve.h"
 #include "emitter.h"
 
-extern glitter_particle_manager* gpm;
+static bool FASTCALL glitter_effect_pack_file(GPM, f2_struct* st, glitter_effect* a3);
+static bool FASTCALL glitter_effect_unpack_file(GPM,
+    void* data, glitter_effect* a3, bool use_big_endian);
 
-static bool FASTCALL glitter_effect_pack_file(f2_struct* st, glitter_effect* a3, bool use_big_endian);
-static bool FASTCALL glitter_effect_unpack_file(int32_t* data, glitter_effect* a3, bool use_big_endian);
-
-glitter_effect* FASTCALL glitter_effect_init() {
+glitter_effect* FASTCALL glitter_effect_init(GPM) {
     glitter_effect* e = force_malloc(sizeof(glitter_effect));
-    e->data.name_hash = gpm->f2 ? 0x0CAD3078 : 0xCBF29CE44FD0BFC1;
+    e->scale = vec3_identity;
+    e->data.start_time = 0;
+    e->data.ext_anim = 0;
+    e->data.flags = 0;
+    e->data.name_hash = glt_type != GLITTER_AFT ? hash_murmurhash_empty : hash_fnv1a64_empty;
+    e->data.seed = 0;
     return e;
 }
 
-bool FASTCALL glitter_effect_parse_file(glitter_effect_group* a1,
-    f2_struct* st, vector_ptr_glitter_effect* vec) {
+glitter_effect* FASTCALL glitter_effect_copy(GPM, glitter_effect* e) {
+    if (!e)
+        return 0;
+
+    glitter_effect* ec = force_malloc(sizeof(glitter_effect));
+    *ec = *e;
+
+    if (e->data.ext_anim) {
+        ec->data.ext_anim = force_malloc(sizeof(glitter_effect_ext_anim));
+        memcpy(ec->data.ext_anim, e->data.ext_anim, sizeof(glitter_effect_ext_anim));
+    }
+
+    ec->emitters = (vector_ptr_glitter_emitter){ 0, 0, 0 };
+    vector_ptr_glitter_emitter_append(&ec->emitters, e->emitters.end - e->emitters.begin);
+    for (glitter_emitter** i = e->emitters.begin; i != e->emitters.end; i++)
+        if (*i) {
+            glitter_emitter* e = glitter_emitter_copy(GPM_VAL, *i);
+            if (e)
+                vector_ptr_glitter_emitter_push_back(&ec->emitters, &e);
+        }
+
+    ec->curve = (vector_ptr_glitter_curve){ 0, 0, 0 };
+    glitter_animation_copy(GPM_VAL, &e->curve, &ec->curve);
+    return ec;
+}
+
+bool FASTCALL glitter_effect_parse_file(GPM,
+    glitter_effect_group* a1, f2_struct* st, vector_ptr_glitter_effect* vec) {
     f2_struct* i;
     glitter_effect* effect;
 
     if (!st || !st->header.data_size)
         return false;
 
-    effect = glitter_effect_init();
+    effect = glitter_effect_init(GPM_VAL);
     effect->version = st->header.version;
-    if (!glitter_effect_unpack_file(st->data, effect, st->header.use_big_endian)) {
+    if (!glitter_effect_unpack_file(GPM_VAL, st->data, effect, st->header.use_big_endian)) {
         glitter_effect_dispose(effect);
         return false;
     }
@@ -38,253 +68,439 @@ bool FASTCALL glitter_effect_parse_file(glitter_effect_group* a1,
         if (!i->header.data_size)
             continue;
 
-        if (i->header.signature == 0x4D494E41)
-            glitter_animation_parse_file(i, &effect->curve);
-        else if (i->header.signature == 0x54494D45)
-            glitter_emitter_parse_file(a1, i, &effect->emitters, effect);
+        if (i->header.signature == reverse_endianess_uint32_t('ANIM'))
+            glitter_animation_parse_file(GPM_VAL, i, &effect->curve, glitter_effect_curve_flags);
+        else if (i->header.signature == reverse_endianess_uint32_t('EMIT'))
+            glitter_emitter_parse_file(GPM_VAL, a1, i, &effect->emitters, effect);
     }
     vector_ptr_glitter_effect_push_back(vec, &effect);
     return true;
 }
 
-bool FASTCALL glitter_effect_unparse_file(glitter_effect_group* a1,
-    f2_struct* st, glitter_effect* a3, bool use_big_endian) {
-    if (!glitter_effect_pack_file(st, a3, use_big_endian))
+bool FASTCALL glitter_effect_unparse_file(GPM,
+    glitter_effect_group* a1, f2_struct* st, glitter_effect* a3) {
+    if (!glitter_effect_pack_file(GPM_VAL, st, a3))
         return false;
 
     f2_struct s;
-    if (glitter_animation_unparse_file(&s, &a3->curve, use_big_endian))
+    if (glitter_animation_unparse_file(GPM_VAL, &s, &a3->curve, glitter_effect_curve_flags))
         vector_f2_struct_push_back(&st->sub_structs, &s);
 
-    for (glitter_emitter** i = a3->emitters.begin; i != a3->emitters.end; i++)
-        if (*i && glitter_emitter_unparse_file(a1, &s, *i, a3, use_big_endian))
+    for (glitter_emitter** i = a3->emitters.begin; i != a3->emitters.end; i++) {
+        if (!*i)
+            continue;
+
+        f2_struct s;
+        if (glitter_emitter_unparse_file(GPM_VAL, a1, &s, *i, a3))
             vector_f2_struct_push_back(&st->sub_structs, &s);
+    }
     return true;
 }
 
 void FASTCALL glitter_effect_dispose(glitter_effect* e) {
-    free(e->data.a3da);
-    vector_ptr_glitter_curve_free(&e->curve, (void*)glitter_curve_dispose);
-    vector_ptr_glitter_emitter_free(&e->emitters, (void*)glitter_emitter_dispose);
+    free(e->data.ext_anim);
+    vector_ptr_glitter_curve_free(&e->curve, glitter_curve_dispose);
+    vector_ptr_glitter_emitter_free(&e->emitters, glitter_emitter_dispose);
     free(e);
 }
 
-static bool FASTCALL glitter_effect_pack_file(f2_struct* st, glitter_effect* a2, bool use_big_endian) {
+static bool FASTCALL glitter_effect_pack_file(GPM, f2_struct* st, glitter_effect* a2) {
     size_t l;
-    int32_t* d;
-    glitter_effect_a3da* a3da;
+    size_t d;
+    glitter_effect_ext_anim* ext_anim;
     glitter_effect_file_flag flags;
 
     if (a2->version != 6 && a2->version != 7)
         return false;
 
-    a3da = a2->data.a3da;
+    ext_anim = a2->data.ext_anim;
     memset(st, 0, sizeof(f2_struct));
-    l = 52;
+    l = 0;
 
-    if (a2->version == 7)
-        l += 4;
+    uint32_t o;
+    vector_enrs_entry e = { 0, 0, 0 };
+    enrs_entry ee;
 
-    if (a2->data.flags & GLITTER_EFFECT_FLAG_LOCAL)
-        l += 4;
-    else if (a3da)
-        if (a3da->flags & GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_BY_OBJECT_INDEX)
-            l += 16;
-        else
-            l += 144;
-
-    l = align_val(l, 0x10);
-    d = force_malloc(l);
-    st->length = l;
-    st->data = d;
-
-    flags = 0;
-    if (a2->data.flags & GLITTER_EFFECT_FLAG_ALPHA)
-        flags |= GLITTER_EFFECT_FILE_FLAG_ALPHA;
-
-    if (a2->data.flags & GLITTER_EFFECT_FLAG_FOG)
-        flags |= GLITTER_EFFECT_FILE_FLAG_FOG;
-    else if (a2->data.flags & GLITTER_EFFECT_FLAG_FOG_HEIGHT)
-        flags |= GLITTER_EFFECT_FILE_FLAG_FOG_HEIGHT;
-
-    if (a2->data.flags & GLITTER_EFFECT_FLAG_EMISSION)
-        flags |= GLITTER_EFFECT_FILE_FLAG_EMISSION;
-
-    if (use_big_endian) {
-        *(uint64_t*)d = reverse_endianess_uint64_t(a2->data.name_hash);
-        d[2] = reverse_endianess_int32_t((int32_t)roundf(a2->data.appear_time));
-        d[3] = reverse_endianess_int32_t((int32_t)roundf(a2->data.life_time));
-        d[4] = reverse_endianess_int32_t((int32_t)roundf(a2->data.start_time));
-        d[5] = 0xFFFFFFFF;
-        d[6] = reverse_endianess_int32_t(a2->data.flags & GLITTER_EFFECT_FLAG_LOOP ? 1 : 0);
-        *(float_t*)&d[7] = reverse_endianess_float_t(a2->translation.x);
-        *(float_t*)&d[8] = reverse_endianess_float_t(a2->translation.y);
-        *(float_t*)&d[9] = reverse_endianess_float_t(a2->translation.z);
-        *(float_t*)&d[10] = reverse_endianess_float_t(a2->rotation.x);
-        *(float_t*)&d[11] = reverse_endianess_float_t(a2->rotation.y);
-        *(float_t*)&d[12] = reverse_endianess_float_t(a2->rotation.z);
-        d[13] = reverse_endianess_int32_t(flags);
-    }
-    else {
-        *(uint64_t*)d = a2->data.name_hash;
-        d[2] = (int32_t)roundf(a2->data.appear_time);
-        d[3] = (int32_t)roundf(a2->data.life_time);
-        d[4] = (int32_t)roundf(a2->data.start_time);
-        d[5] = 0xFFFFFFFF;
-        d[6] = a2->data.flags & GLITTER_EFFECT_FLAG_LOOP ? 1 : 0;
-        *(vec3*)&d[7] = a2->translation;
-        *(vec3*)&d[10] = a2->rotation;
-        d[13] = flags;
-    }
+    ee = (enrs_entry){ 0, 2, 56, 1, { 0, 0, 0 } };
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 1, ENRS_TYPE_QWORD });
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 12, ENRS_TYPE_DWORD });
+    vector_enrs_entry_push_back(&e, &ee);
+    l += o = 56;
 
     if (a2->version == 7) {
-        if (use_big_endian)
-            *(float_t*)&d[14] = reverse_endianess_float_t(a2->data.emission);
-        else
-            *(float_t*)&d[14] = a2->data.emission;
-        d++;
+        ee = (enrs_entry){ 0, 1, 4, 1, { 0, 0, 0 } };
+        vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 1, ENRS_TYPE_DWORD });
+        vector_enrs_entry_push_back(&e, &ee);
+        l += o = 4;
     }
 
-    if (a2->data.flags & GLITTER_EFFECT_FLAG_LOCAL)
-        d[14] = 1;
-    else if (a3da)
-        if (a3da->flags & GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_BY_OBJECT_INDEX) {
-            d[14] = 2;
-            d += 15;
-            glitter_effect_a3da_flag a3da_flag = a3da->flags & ~GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_BY_OBJECT_INDEX;
-            if (use_big_endian) {
-                d[0] = reverse_endianess_int32_t(a3da->object_index);
-                d[1] = reverse_endianess_int32_t(a3da_flag);
-                d[2] = reverse_endianess_int32_t(a3da->index);
-            }
-            else {
-                d[0] = a3da->object_index;
-                d[1] = a3da_flag;
-                d[2] = a3da->index;
-            }
+    ee = (enrs_entry){ 0, 1, 4, 1, { 0, 0, 0 } };
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 1, ENRS_TYPE_DWORD });
+    vector_enrs_entry_push_back(&e, &ee);
+    l += o = 4;
+
+    if (~a2->data.flags & GLITTER_EFFECT_LOCAL && ext_anim)
+        if (ext_anim->flags & GLITTER_EFFECT_EXT_ANIM_CHARA_ANIM) {
+            ee = (enrs_entry){ 0, 1, 12, 1, { 0, 0, 0 } };
+            vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 3, ENRS_TYPE_DWORD });
+            vector_enrs_entry_push_back(&e, &ee);
+            l += o = 12;
         }
         else {
-            d[14] = 3;
-            d += 15;
-            if (use_big_endian) {
-                *(uint64_t*)d = reverse_endianess_uint64_t(a3da->object_hash);
-                d[2] = reverse_endianess_int32_t(a3da->flags);
-            }
-            else {
-                *(uint64_t*)d = a3da->object_hash;
-                d[2] = a3da->flags;
-                a3da->flags = d[2];
-            }
-            memcpy((char*)(d + 12), a3da->mesh_name, 128);
+            ee = (enrs_entry){ 0, 2, 140, 1, { 0, 0, 0 } };
+            vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 1, ENRS_TYPE_QWORD });
+            vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 1, ENRS_TYPE_DWORD });
+            vector_enrs_entry_push_back(&e, &ee);
+            l += o = 140;
         }
 
-    st->header.signature = 0x54434645;
+    l = align_val(l, 0x10);
+    d = (size_t)force_malloc(l);
+    st->length = l;
+    st->data = (void*)d;
+    st->enrs = e;
+
+    flags = 0;
+    if (a2->data.flags & GLITTER_EFFECT_ALPHA)
+        flags |= GLITTER_EFFECT_FILE_ALPHA;
+
+    if (a2->data.flags & GLITTER_EFFECT_FOG)
+        flags |= GLITTER_EFFECT_FILE_FOG;
+    else if (a2->data.flags & GLITTER_EFFECT_FOG_HEIGHT)
+        flags |= GLITTER_EFFECT_FILE_FOG_HEIGHT;
+
+    if (a2->data.flags & GLITTER_EFFECT_EMISSION)
+        flags |= GLITTER_EFFECT_FILE_EMISSION;
+
+    *(uint64_t*)d = glt_type != GLITTER_AFT
+        ? hash_char_murmurhash(a2->name, 0, false) : hash_char_fnv1a64(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;
+    *(int32_t*)(d + 20) = 0xFFFFFFFF;
+    *(int32_t*)(d + 24) = a2->data.flags & GLITTER_EFFECT_LOOP ? 1 : 0;
+    *(vec3*)(d + 28) = a2->translation;
+    *(vec3*)(d + 40) = a2->rotation;
+    *(int32_t*)(d + 52) = flags;
+    d += 56;
+
+    if (a2->version == 7) {
+        *(float_t*)d = a2->data.emission;
+        d += 4;
+    }
+
+    if (a2->data.flags & GLITTER_EFFECT_LOCAL) {
+        *(int32_t*)d = 1;
+        d += 4;
+    }
+    else if (ext_anim)
+        if (ext_anim->flags & GLITTER_EFFECT_EXT_ANIM_CHARA_ANIM) {
+            *(int32_t*)d = 2;
+            d += 4;
+            glitter_effect_ext_anim_flag ext_anim_flag = ext_anim->flags & ~GLITTER_EFFECT_EXT_ANIM_CHARA_ANIM;
+            *(int32_t*)d = ext_anim->index;
+            *(int32_t*)(d + 4) = ext_anim_flag;
+            *(int32_t*)(d + 8) = ext_anim->node_index;
+        }
+        else {
+            *(int32_t*)d = 3;
+            d += 4;
+            *(uint64_t*)d = ext_anim->object_hash;
+            *(int32_t*)(d + 8) = ext_anim->flags;
+            memcpy((char*)(d + 12), ext_anim->mesh_name, 128);
+        }
+    else {
+        *(int32_t*)d = 0;
+        d += 4;
+    }
+
+    st->header.signature = reverse_endianess_uint32_t('EFCT');
     st->header.length = 0x20;
-    st->header.use_big_endian = use_big_endian ? true : false;
+    st->header.use_big_endian = false;
     st->header.use_section_size = true;
     st->header.version = a2->version;
     return true;
 }
 
-static bool FASTCALL glitter_effect_unpack_file(int32_t* data, glitter_effect* a2, bool use_big_endian) {
-    glitter_effect_a3da* a3da;
+static bool FASTCALL glitter_effect_unpack_file(GPM,
+    void* data, glitter_effect* a2, bool use_big_endian) {
+    size_t d;
+    glitter_effect_ext_anim* ext_anim;
     glitter_effect_file_flag flags;
 
-    a2->scale = vec3_identity;
-    a2->data.start_time = 0.0f;
-    a2->data.a3da = 0;
-    a2->data.flags = 0;
-    a2->data.name_hash = gpm->f2 ? 0x0CAD3078 : 0xCBF29CE44FD0BFC1;
-    if (a2->version != 6 && a2->version != 7)
-        return false;
+    if (glt_type == GLITTER_X) {
+        a2->scale = vec3_identity;
+        a2->data.start_time = 0;
+        a2->data.ext_anim = 0;
+        a2->data.flags = 0;
+        a2->data.name_hash = hash_murmurhash_empty;
+        a2->data.seed = 0;
 
-    if (use_big_endian) {
-        a2->data.name_hash = reverse_endianess_uint64_t(*(uint64_t*)data);
-        a2->data.appear_time = (float_t)reverse_endianess_int32_t(data[2]);
-        a2->data.life_time = (float_t)reverse_endianess_int32_t(data[3]);
-        a2->data.start_time = (float_t)reverse_endianess_int32_t(data[4]);
-        if (reverse_endianess_int32_t(data[6]))
-            a2->data.flags |= GLITTER_EFFECT_FLAG_LOOP;
-        a2->translation.x = reverse_endianess_float_t(*(float_t*)&data[7]);
-        a2->translation.y = reverse_endianess_float_t(*(float_t*)&data[8]);
-        a2->translation.z = reverse_endianess_float_t(*(float_t*)&data[9]);
-        a2->rotation.x = reverse_endianess_float_t(*(float_t*)&data[10]);
-        a2->rotation.y = reverse_endianess_float_t(*(float_t*)&data[11]);
-        a2->rotation.z = reverse_endianess_float_t(*(float_t*)&data[12]);
-        flags = reverse_endianess_int32_t(data[13]);
-    }
-    else {
-        a2->data.name_hash = *(uint64_t*)data;
-        a2->data.appear_time = (float_t)data[2];
-        a2->data.life_time = (float_t)data[3];
-        a2->data.start_time = (float_t)data[4];
-        if (data[6])
-            a2->data.flags |= GLITTER_EFFECT_FLAG_LOOP;
-        a2->translation = *(vec3*)&data[7];
-        a2->rotation = *(vec3*)&data[10];
-        flags = data[13];
-    }
+        if (a2->version < 8 || a2->version > 12)
+            return false;
 
-    if (flags & GLITTER_EFFECT_FILE_FLAG_ALPHA)
-        a2->data.flags |= GLITTER_EFFECT_FLAG_ALPHA;
-
-    if (flags & GLITTER_EFFECT_FILE_FLAG_FOG)
-        a2->data.flags |= GLITTER_EFFECT_FLAG_FOG;
-    else if (flags & GLITTER_EFFECT_FILE_FLAG_FOG_HEIGHT)
-        a2->data.flags |= GLITTER_EFFECT_FLAG_FOG_HEIGHT;
-
-    if (flags & GLITTER_EFFECT_FILE_FLAG_EMISSION)
-        a2->data.flags |= GLITTER_EFFECT_FLAG_EMISSION;
-
-    if (a2->version == 7) {
-        if (use_big_endian)
-            a2->data.emission = reverse_endianess_float_t(*(float_t*)&data[14]);
-        else
-            a2->data.emission = *(float_t*)&data[14];
-        data++;
-    }
-
-    if (data[14] == 1)
-        a2->data.flags |= GLITTER_EFFECT_FLAG_LOCAL;
-    else if (data[14] == 2) {
-        data += 15;
-        a3da = force_malloc(sizeof(glitter_effect_a3da));
-        a2->data.a3da = a3da;
-        if (a3da) {
-            if (use_big_endian) {
-                a3da->object_index = reverse_endianess_int32_t(data[0]);
-                a3da->flags = reverse_endianess_int32_t(data[1]);
-                a3da->index = reverse_endianess_int32_t(data[2]);
-            }
-            else {
-                a3da->object_index = data[0];
-                a3da->flags = data[1];
-                a3da->index = data[2];
-            }
-            a3da->flags |= GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_BY_OBJECT_INDEX;
-            a3da->mesh_name[0] = 0;
+        d = (size_t)data;
+        if (use_big_endian) {
+            a2->data.name_hash = reverse_endianess_uint64_t(*(uint64_t*)d);
+            a2->data.appear_time = reverse_endianess_int32_t(*(int32_t*)(d + 8));
+            a2->data.life_time = reverse_endianess_int32_t(*(int32_t*)(d + 12));
+            a2->data.start_time = reverse_endianess_int32_t(*(int32_t*)(d + 16));
+            if (reverse_endianess_int32_t(*(int32_t*)(d + 24)))
+                a2->data.flags |= GLITTER_EFFECT_LOOP;
+            a2->translation.x = reverse_endianess_float_t(*(float_t*)(d + 28));
+            a2->translation.y = reverse_endianess_float_t(*(float_t*)(d + 32));
+            a2->translation.z = reverse_endianess_float_t(*(float_t*)(d + 36));
+            a2->rotation.x = reverse_endianess_float_t(*(float_t*)(d + 40));
+            a2->rotation.y = reverse_endianess_float_t(*(float_t*)(d + 44));
+            a2->rotation.z = reverse_endianess_float_t(*(float_t*)(d + 48));
+            flags = reverse_endianess_int32_t(*(int32_t*)(d + 52));
         }
-    }
-    else if (data[14] == 3) {
-        data += 15;
-        //v10 = sub_14045A570(*(uint64_t*)data);
-        //if (v10 != -1) {
-            a3da = force_malloc(sizeof(glitter_effect_a3da));
-            a2->data.a3da = a3da;
-            if (a3da) {
-                //a3da->object_index = v10;
+        else {
+            a2->data.name_hash = *(uint64_t*)data;
+            a2->data.appear_time = *(int32_t*)(d + 8);
+            a2->data.life_time = *(int32_t*)(d + 12);
+            a2->data.start_time = *(int32_t*)(d + 16);
+            if (*(int32_t*)(d + 24))
+                a2->data.flags |= GLITTER_EFFECT_LOOP;
+            a2->translation = *(vec3*)(d + 28);
+            a2->rotation = *(vec3*)(d + 40);
+            flags = *(int32_t*)(d + 52);
+        }
+
+        if (flags & GLITTER_EFFECT_FILE_ALPHA)
+            a2->data.flags |= GLITTER_EFFECT_ALPHA;
+
+        if (flags & GLITTER_EFFECT_FILE_FOG)
+            a2->data.flags |= GLITTER_EFFECT_FOG;
+        else if (flags & GLITTER_EFFECT_FILE_FOG_HEIGHT)
+            a2->data.flags |= GLITTER_EFFECT_FOG_HEIGHT;
+
+        if (flags & GLITTER_EFFECT_FILE_EMISSION)
+            a2->data.flags |= GLITTER_EFFECT_EMISSION;
+
+        if (flags & GLITTER_EFFECT_FILE_USE_SEED)
+            a2->data.flags |= GLITTER_EFFECT_USE_SEED;
+
+        if (a2->version != 8 && flags & 0x20)
+            a2->data.flags |= 0x80;
+
+        if (use_big_endian) {
+            a2->data.emission = reverse_endianess_float_t(*(float_t*)(d + 56));
+            a2->data.seed = reverse_endianess_int32_t(*(int32_t*)(d + 60));
+        }
+        else {
+            a2->data.emission = *(float_t*)(d + 56);
+            a2->data.seed = *(int32_t*)(d + 60);
+        }
+
+        int32_t type = a2->version != 8 ? *(int32_t*)(d + 76) : *(int32_t*)(d + 80);
+        if (use_big_endian)
+            type = reverse_endianess_int32_t(type);
+        d += a2->version != 8 ? 80 : 88;
+
+        if (type == 1)
+            a2->data.flags |= GLITTER_EFFECT_LOCAL;
+        else if (type == 2) {
+            ext_anim = force_malloc(sizeof(glitter_effect_ext_anim));
+            a2->data.ext_anim = ext_anim;
+            if (ext_anim) {
                 if (use_big_endian) {
-                    a3da->object_hash = reverse_endianess_uint64_t(*(uint64_t*)data);
-                    a3da->flags = reverse_endianess_int32_t(data[2]);
+                    ext_anim->index = reverse_endianess_int32_t(*(int32_t*)d);
+                    ext_anim->flags = reverse_endianess_int32_t(*(int32_t*)(d + 4));
+                    ext_anim->node_index = reverse_endianess_int32_t(*(int32_t*)(d + 8));
                 }
                 else {
-                    a3da->object_hash = *(uint64_t*)data;
-                    a3da->flags = data[2];
+                    ext_anim->index = *(int32_t*)d;
+                    ext_anim->flags = *(int32_t*)(d + 4);
+                    ext_anim->node_index = *(int32_t*)(d + 8);
                 }
-                a3da->index = 201;
-                memcpy(a3da->mesh_name, (char*)(data + 12), 128);
+                ext_anim->flags |= GLITTER_EFFECT_EXT_ANIM_CHARA_ANIM;
+                ext_anim->mesh_name[0] = 0;
             }
-        //}
+        }
+        else if (type == 3) {
+            if (a2->version == 8) {
+                ext_anim = force_malloc(sizeof(glitter_effect_ext_anim));
+                a2->data.ext_anim = ext_anim;
+                if (ext_anim) {
+                    if (use_big_endian) {
+                        ext_anim->object_hash = reverse_endianess_uint64_t(*(uint64_t*)d);
+                        ext_anim->flags = reverse_endianess_int32_t(*(int32_t*)(d + 8));
+                    }
+                    else {
+                        ext_anim->object_hash = *(uint64_t*)d;
+                        ext_anim->flags = *(int32_t*)(d + 8);
+                    }
+                    ext_anim->instance_id = 0;
+                    ext_anim->some_hash = 0xCAD3078;
+                    ext_anim->index = -1;
+                    ext_anim->node_index = 18;
+                    if (*(char*)(d + 12)) {
+                        strncpy_s(ext_anim->mesh_name, 0x80, (char*)(d + 20), 0x80);
+                        ext_anim->mesh_name[0x7F] = '\0';
+                    }
+                    else
+                        ext_anim->mesh_name[0] = 0;
+                }
+            }
+            else if (a2->version == 10) {
+                ext_anim = force_malloc(sizeof(glitter_effect_ext_anim));
+                a2->data.ext_anim = ext_anim;
+                if (ext_anim) {
+                    if (use_big_endian) {
+                        ext_anim->object_hash = reverse_endianess_uint64_t(*(uint64_t*)d);
+                        ext_anim->flags = reverse_endianess_int32_t(*(int32_t*)(d + 8));
+                    }
+                    else {
+                        ext_anim->object_hash = *(uint64_t*)d;
+                        ext_anim->flags = *(int32_t*)(d + 8);
+                    }
+                    ext_anim->instance_id = 0;
+                    ext_anim->some_hash = 0xCAD3078;
+                    ext_anim->index = -1;
+                    ext_anim->node_index = 18;
+                    if (*(char*)(d + 16)) {
+                        strncpy_s(ext_anim->mesh_name, 0x80, (char*)(d + 16), 0x80);
+                        ext_anim->mesh_name[0x7F] = '\0';
+                    }
+                    else
+                        ext_anim->mesh_name[0] = 0;
+                }
+            }
+            else {
+                ext_anim = force_malloc(sizeof(glitter_effect_ext_anim));
+                a2->data.ext_anim = ext_anim;
+                if (ext_anim) {
+                    if (use_big_endian) {
+                        ext_anim->object_hash = reverse_endianess_uint64_t(*(uint64_t*)d);
+                        ext_anim->flags = reverse_endianess_int32_t(*(int32_t*)(d + 8));
+                        ext_anim->instance_id = reverse_endianess_int32_t(*(int32_t*)(d + 12));
+                        ext_anim->some_hash = reverse_endianess_uint64_t(*(uint64_t*)(d + 16));
+                    }
+                    else {
+                        ext_anim->object_hash = *(uint64_t*)d;
+                        ext_anim->flags = *(int32_t*)(d + 8);
+                        ext_anim->instance_id = *(int32_t*)(d + 12);
+                        ext_anim->some_hash = *(uint64_t*)(d + 16);
+                    }
+                    ext_anim->index = -1;
+                    ext_anim->node_index = 18;
+                    if (*(char*)(d + 32)) {
+                        strncpy_s(ext_anim->mesh_name, 0x80, (char*)(d + 32), 0x80);
+                        ext_anim->mesh_name[0x7F] = '\0';
+                    }
+                    else
+                        ext_anim->mesh_name[0] = 0;
+                }
+            }
+        }
+    }
+    else {
+        a2->scale = vec3_identity;
+        a2->data.start_time = 0;
+        a2->data.ext_anim = 0;
+        a2->data.flags = 0;
+        a2->data.name_hash = glt_type != GLITTER_AFT ? hash_murmurhash_empty : hash_fnv1a64_empty;
+        a2->data.seed = 0;
+
+        if (a2->version != 6 && a2->version != 7)
+            return false;
+
+        d = (size_t)data;
+        if (use_big_endian) {
+            a2->data.name_hash = reverse_endianess_uint64_t(*(uint64_t*)d);
+            a2->data.appear_time = reverse_endianess_int32_t(*(int32_t*)(d + 8));
+            a2->data.life_time = reverse_endianess_int32_t(*(int32_t*)(d + 12));
+            a2->data.start_time = reverse_endianess_int32_t(*(int32_t*)(d + 16));
+            if (reverse_endianess_int32_t(*(int32_t*)(d + 24)))
+                a2->data.flags |= GLITTER_EFFECT_LOOP;
+            a2->translation.x = reverse_endianess_float_t(*(float_t*)(d + 28));
+            a2->translation.y = reverse_endianess_float_t(*(float_t*)(d + 32));
+            a2->translation.z = reverse_endianess_float_t(*(float_t*)(d + 36));
+            a2->rotation.x = reverse_endianess_float_t(*(float_t*)(d + 40));
+            a2->rotation.y = reverse_endianess_float_t(*(float_t*)(d + 44));
+            a2->rotation.z = reverse_endianess_float_t(*(float_t*)(d + 48));
+            flags = reverse_endianess_int32_t(*(int32_t*)(d + 52));
+        }
+        else {
+            a2->data.name_hash = *(uint64_t*)data;
+            a2->data.appear_time = *(int32_t*)(d + 8);
+            a2->data.life_time = *(int32_t*)(d + 12);
+            a2->data.start_time = *(int32_t*)(d + 16);
+            if (*(int32_t*)(d + 24))
+                a2->data.flags |= GLITTER_EFFECT_LOOP;
+            a2->translation = *(vec3*)(d + 28);
+            a2->rotation = *(vec3*)(d + 40);
+            flags = *(int32_t*)(d + 52);
+        }
+        d += 56;
+
+        if (flags & GLITTER_EFFECT_FILE_ALPHA)
+            a2->data.flags |= GLITTER_EFFECT_ALPHA;
+
+        if (flags & GLITTER_EFFECT_FILE_FOG)
+            a2->data.flags |= GLITTER_EFFECT_FOG;
+        else if (flags & GLITTER_EFFECT_FILE_FOG_HEIGHT)
+            a2->data.flags |= GLITTER_EFFECT_FOG_HEIGHT;
+
+        if (flags & GLITTER_EFFECT_FILE_EMISSION)
+            a2->data.flags |= GLITTER_EFFECT_EMISSION;
+
+        if (a2->version == 7) {
+            if (use_big_endian)
+                a2->data.emission = reverse_endianess_float_t(*(float_t*)d);
+            else
+                a2->data.emission = *(float_t*)d;
+            d += 4;
+        }
+
+        int32_t type = *(int32_t*)d;
+        if (use_big_endian)
+            type = reverse_endianess_int32_t(type);
+        d += 4;
+
+        if (type == 1)
+            a2->data.flags |= GLITTER_EFFECT_LOCAL;
+        else if (type == 2) {
+            ext_anim = force_malloc(sizeof(glitter_effect_ext_anim));
+            a2->data.ext_anim = ext_anim;
+            if (ext_anim) {
+                if (use_big_endian) {
+                    ext_anim->index = reverse_endianess_int32_t(*(int32_t*)d);
+                    ext_anim->flags = reverse_endianess_int32_t(*(int32_t*)(d + 4));
+                    ext_anim->node_index = reverse_endianess_int32_t(*(int32_t*)(d + 8));
+                }
+                else {
+                    ext_anim->index = *(int32_t*)d;
+                    ext_anim->flags = *(int32_t*)(d + 4);
+                    ext_anim->node_index = *(int32_t*)(d + 8);
+                }
+                ext_anim->flags |= GLITTER_EFFECT_EXT_ANIM_CHARA_ANIM;
+                ext_anim->mesh_name[0] = 0;
+            }
+        }
+        else if (type == 3) {
+            ext_anim = force_malloc(sizeof(glitter_effect_ext_anim));
+            a2->data.ext_anim = ext_anim;
+            if (ext_anim) {
+                ext_anim->index = -1;
+                if (use_big_endian) {
+                    ext_anim->object_hash = reverse_endianess_uint64_t(*(uint64_t*)d);
+                    ext_anim->flags = reverse_endianess_int32_t(*(int32_t*)(d + 8));
+                }
+                else {
+                    ext_anim->object_hash = *(uint64_t*)d;
+                    ext_anim->flags = *(int32_t*)(d + 8);
+                }
+                ext_anim->node_index = 18;
+                if (*(char*)(d + 12)) {
+                    strncpy_s(ext_anim->mesh_name, 0x80, (char*)(d + 12), 0x80);
+                    ext_anim->mesh_name[0x7F] = 0;
+                }
+                else
+                    ext_anim->mesh_name[0x00] = 0;
+            }
+        }
     }
     return true;
 }

src/CRE/Glitter/effect.h

@@ -7,9 +7,10 @@
 
 #include "glitter.h"
 
-extern glitter_effect* FASTCALL glitter_effect_init();
-extern bool FASTCALL glitter_effect_parse_file(glitter_effect_group* a1,
-    f2_struct* st, vector_ptr_glitter_effect* vec);
-extern bool FASTCALL glitter_effect_unparse_file(glitter_effect_group* a1,
-    f2_struct* st, glitter_effect* a3, bool use_big_endian);
+extern glitter_effect* FASTCALL glitter_effect_init(GPM);
+extern glitter_effect* FASTCALL glitter_effect_copy(GPM, glitter_effect* e);
+extern bool FASTCALL glitter_effect_parse_file(GPM,
+    glitter_effect_group* a1, f2_struct* st, vector_ptr_glitter_effect* vec);
+extern bool FASTCALL glitter_effect_unparse_file(GPM,
+    glitter_effect_group* a1, f2_struct* st, glitter_effect* a3);
 extern void FASTCALL glitter_effect_dispose(glitter_effect* e);

src/CRE/Glitter/effect_group.c

@@ -8,18 +8,19 @@
 #include "scene.h"
 #include "texture.h"
 
-glitter_effect_group* FASTCALL glitter_effect_group_init() {
+glitter_effect_group* FASTCALL glitter_effect_group_init(GPM) {
     glitter_effect_group* eg = force_malloc(sizeof(glitter_effect_group));
     eg->emission = 1.0f;
+    eg->version = glt_type == GLITTER_X ? 0x0C : 0x09;
     return eg;
 }
 
-bool FASTCALL glitter_effect_group_parse_file(glitter_effect_group* a1, f2_struct* st) {
+bool FASTCALL glitter_effect_group_parse_file(GPM, glitter_effect_group* a1, f2_struct* st) {
     for (f2_struct* i = st->sub_structs.begin; i != st->sub_structs.end; i++) {
         if (!i->header.data_size)
             continue;
 
-        if (i->header.signature == 0x54434645 && !glitter_effect_parse_file(a1, i, &a1->effects))
+        if (i->header.signature == 0x54434645 && !glitter_effect_parse_file(GPM_VAL, a1, i, &a1->effects))
             return false;
         else if (i->header.signature == 0x53525644 && !glitter_texture_hashes_unpack_file(a1, i))
             return false;
@@ -27,21 +28,23 @@ bool FASTCALL glitter_effect_group_parse_file(glitter_effect_group* a1, f2_struc
     return true;
 }
 
-bool FASTCALL glitter_effect_group_unparse_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian) {
+bool FASTCALL glitter_effect_group_unparse_file(GPM, glitter_effect_group* a1, f2_struct* st) {
     memset(st, 0, sizeof(f2_struct));
 
-    f2_struct* s = f2_struct_init();
-    for (glitter_effect** i = a1->effects.begin; i != a1->effects.end; i++)
-        if (*i && glitter_effect_unparse_file(a1, s, *i, use_big_endian))
-            vector_f2_struct_push_back(&st->sub_structs, s);
+    for (glitter_effect** i = a1->effects.begin; i != a1->effects.end; i++) {
+        if (!*i)
+            continue;
 
-    if (!glitter_texture_hashes_pack_file(a1, s, use_big_endian)) {
-        f2_struct_dispose(s);
-        return false;
+        f2_struct s;
+        memset(&s, 0, sizeof(f2_struct));
+        if (glitter_effect_unparse_file(GPM_VAL, a1, &s, *i))
+            vector_f2_struct_push_back(&st->sub_structs, &s);
     }
 
-    vector_f2_struct_push_back(&st->sub_structs, s);
-    free(s);
+    f2_struct s;
+    memset(&s, 0, sizeof(f2_struct));
+    if (glitter_texture_hashes_pack_file(a1, &s))
+        vector_f2_struct_push_back(&st->sub_structs, &s);
 
     st->header.signature = 0x46455644;
     st->header.length = 0x20;
@@ -52,12 +55,9 @@ bool FASTCALL glitter_effect_group_unparse_file(glitter_effect_group* a1, f2_str
 }
 
 void FASTCALL glitter_effect_group_dispose(glitter_effect_group* eg) {
-    vector_ptr_glitter_effect_free(&eg->effects, (void*)glitter_effect_dispose);
-    free(eg->resource_hashes);
-    if (eg->resources)
-        glDeleteTextures(eg->resources_count, eg->resources);
-    free(eg->resources);
-    if (eg->resources_tex)
-        txp_dispose(eg->resources_tex);
+    vector_ptr_glitter_effect_free(&eg->effects, glitter_effect_dispose);
+    vector_uint64_t_free(&eg->resource_hashes);
+    glitter_texture_unload(eg);
+    tex_set_free(&eg->resources_tex);
     free(eg);
 }

src/CRE/Glitter/effect_group.h

@@ -7,7 +7,7 @@
 
 #include "glitter.h"
 
-extern glitter_effect_group* FASTCALL glitter_effect_group_init();
-extern bool FASTCALL glitter_effect_group_parse_file(glitter_effect_group* a1, f2_struct* st);
-extern bool FASTCALL glitter_effect_group_unparse_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian);
+extern glitter_effect_group* FASTCALL glitter_effect_group_init(GPM);
+extern bool FASTCALL glitter_effect_group_parse_file(GPM, glitter_effect_group* a1, f2_struct* st);
+extern bool FASTCALL glitter_effect_group_unparse_file(GPM, glitter_effect_group* a1, f2_struct* st);
 extern void FASTCALL glitter_effect_group_dispose(glitter_effect_group* eg);

src/CRE/Glitter/effect_inst.c

@@ -4,19 +4,24 @@
 */
 
 #include "effect_inst.h"
+#include "counter.h"
 #include "curve.h"
 #include "emitter_inst.h"
 #include "random.h"
-#include "scene.h"
+#include "render_group.h"
 
-static int32_t FASTCALL glitter_effect_inst_get_a3da_index(int32_t index);
+static void FASTCALL glitter_effect_inst_get_ext_anim(GPM, glitter_effect_inst* a1);
+static int32_t FASTCALL glitter_aft_effect_inst_get_ext_anim_bone_index(int32_t index);
+static int32_t FASTCALL glitter_f2_effect_inst_get_ext_anim_bone_index(int32_t index);
+static void FASTCALL glitter_effect_inst_get_value(GPM, glitter_effect_inst* a1, float_t frame);
+static void FASTCALL glitter_effect_inst_reset_sub(GPM, glitter_effect_inst* a1, float_t emission);
 
-glitter_effect_inst* FASTCALL glitter_effect_inst_init(glitter_effect* a1,
-    glitter_scene* a2, size_t id, bool appear_now) {
+glitter_effect_inst* FASTCALL glitter_effect_inst_init(GPM,
+    glitter_effect* a1, size_t id, float_t emission, bool appear_now) {
+    glitter_effect_inst_ext_anim* inst_ext_anim;
+    glitter_effect_ext_anim* ext_anim;
     glitter_emitter** i;
-    glitter_effect_inst_a3da* inst_a3da;
-    glitter_effect_a3da* a3da;
-    glitter_emitter_inst* emitter;
+    glitter_emitter_inst* emitter_inst;
 
     glitter_effect_inst* ei = force_malloc(sizeof(glitter_effect_inst));
     ei->effect = a1;
@@ -24,145 +29,260 @@ glitter_effect_inst* FASTCALL glitter_effect_inst_init(glitter_effect* a1,
     ei->color = vec4_identity;
     ei->scale_all = 1.0f;
     ei->id = id;
-    glitter_random_set(ei->data.name_hash % glitter_random_get_max());
     ei->translation = a1->translation;
     ei->rotation = a1->rotation;
     ei->scale = a1->scale;
+    glitter_random_reset(&ei->random_shared);
+    glitter_random_reset(&ei->random);
 
     if (appear_now)
-        ei->data.appear_time = 0.0f;
+        ei->frame = 0.0f;
     else
-        ei->frame = -ei->data.appear_time;
+        ei->frame = (float_t)-ei->data.appear_time;
 
-    if (ei->data.a3da) {
-        inst_a3da = force_malloc(sizeof(glitter_effect_inst_a3da));
-        inst_a3da->dword00 = -1;
-        inst_a3da->object_index = -1;
-        inst_a3da->index = -1;
-        inst_a3da->mat = mat4_identity;
+    if (~a1->data.flags & GLITTER_EFFECT_LOCAL && ei->data.ext_anim) {
+        inst_ext_anim = force_malloc(sizeof(glitter_effect_inst_ext_anim));
+        inst_ext_anim->dword00 = -1;
+        inst_ext_anim->object_hash = glt_type != GLITTER_AFT
+            ? hash_murmurhash_empty : hash_fnv1a64_empty;
+        inst_ext_anim->chara_index = -1;
+        inst_ext_anim->node_index = -1;
+        inst_ext_anim->mat = mat4_identity;
 
-        if (inst_a3da) {
-            a3da = ei->data.a3da;
-            if (a3da->flags & GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_ONCE)
-                ei->flags |= GLITTER_EFFECT_INST_FLAG_SET_A3DA_ONCE;
-            if (a3da->flags & GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_TRANS_ONLY)
-                ei->flags |= GLITTER_EFFECT_INST_FLAG_SET_A3DA_TRANS_ONLY;
-            if (a3da->flags & GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_BY_OBJECT_INDEX) {
-                inst_a3da->index = glitter_effect_inst_get_a3da_index(a3da->index);
-                ei->flags |= GLITTER_EFFECT_INST_FLAG_SET_A3DA_BY_OBJECT_INDEX;
+        if (inst_ext_anim) {
+            ext_anim = ei->data.ext_anim;
+            if (ext_anim->flags & GLITTER_EFFECT_EXT_ANIM_SET_EXT_ANIM_ONCE)
+                ei->flags |= GLITTER_EFFECT_INST_SET_EXT_ANIM_ONCE;
+            if (ext_anim->flags & GLITTER_EFFECT_EXT_ANIM_EXT_ANIM_TRANS_ONLY)
+                ei->flags |= GLITTER_EFFECT_INST_EXT_ANIM_TRANS_ONLY;
+
+            if (ext_anim->flags & GLITTER_EFFECT_EXT_ANIM_CHARA_ANIM) {
+                inst_ext_anim->chara_index = ext_anim->index;
+                inst_ext_anim->node_index = glt_type == GLITTER_AFT
+                    ? glitter_aft_effect_inst_get_ext_anim_bone_index(ext_anim->node_index)
+                    : glitter_f2_effect_inst_get_ext_anim_bone_index(ext_anim->node_index);
+                ei->flags |= GLITTER_EFFECT_INST_CHARA_ANIM;
+            }
+            else {
+                inst_ext_anim->object_hash = ext_anim->object_hash;
+                inst_ext_anim->some_hash = ext_anim->some_hash;
+                inst_ext_anim->instance_id = ext_anim->instance_id;
             }
-            
-            inst_a3da->object_index = a3da->object_index;
 
-            size_t mesh_name_len = strlen(a3da->mesh_name);
-            if (mesh_name_len) {
-                inst_a3da->mesh_name = force_malloc(mesh_name_len + 1);
-                memcpy(inst_a3da->mesh_name, a3da->mesh_name, mesh_name_len);
+            size_t name_len = strlen(ext_anim->mesh_name);
+            if (name_len) {
+                inst_ext_anim->name = force_malloc(name_len + 1);
+                memcpy(inst_ext_anim->name, ext_anim->mesh_name, name_len);
             }
             else
-                inst_a3da->mesh_name = 0;
+                inst_ext_anim->name = 0;
         }
-        ei->a3da = inst_a3da;
-        ei->flags |= GLITTER_EFFECT_INST_FLAG_HAS_A3DA;
-        ei->flags |= GLITTER_EFFECT_INST_FLAG_HAS_A3DA_NON_INIT;
-        ei->flags |= GLITTER_EFFECT_INST_FLAG_SET_A3DA_BY_OBJECT_NAME;
+        ei->ext_anim = inst_ext_anim;
+        ei->flags |= GLITTER_EFFECT_INST_HAS_EXT_ANIM;
+        ei->flags |= GLITTER_EFFECT_INST_HAS_EXT_ANIM_NON_INIT;
+        ei->flags |= GLITTER_EFFECT_INST_SET_EXT_ANIM_BY_OBJECT_NAME;
     }
 
+    glitter_random_set_value(&ei->random_shared, ei->data.name_hash % glitter_random_get_max(GPM_VAL));
+    ei->random.value = glitter_random_get_value(&ei->random_shared);
+
     ei->mat = mat4_identity;
-    ei->random = glitter_random_get();
-    vector_ptr_glitter_emitter_inst_resize(&ei->emitters, a1->emitters.end - a1->emitters.begin);
+    vector_ptr_glitter_emitter_inst_append(&ei->emitters, a1->emitters.end - a1->emitters.begin);
     for (i = a1->emitters.begin; i != a1->emitters.end; i++) {
         if (!*i)
             continue;
 
-        emitter = glitter_emitter_inst_init(*i, a2, ei);
-        vector_ptr_glitter_emitter_inst_push_back(&ei->emitters, &emitter);
+        emitter_inst = glitter_emitter_inst_init(GPM_VAL, *i, ei, emission);
+        vector_ptr_glitter_emitter_inst_push_back(&ei->emitters, &emitter_inst);
     }
-    glitter_effect_inst_reset_sub(ei, a2);
+    glitter_effect_inst_reset_sub(GPM_VAL, ei, emission);
     return ei;
 }
 
-void FASTCALL glitter_effect_inst_copy(glitter_effect_inst* a1,
-    glitter_effect_inst* a2, glitter_scene* a3) {
-    int64_t emitters_count; // rbp
-    int64_t i; // rbx
+void FASTCALL glitter_effect_inst_calc_draw(GPM, glitter_effect_inst* a1,
+    bool(FASTCALL* render_add_list_func)(glitter_particle_mesh*, vec4*, mat4*, mat4*)) {
+    glitter_render_group** i;
+    glitter_render_group* render_group;
 
-    a2->frame = a1->frame;
-    a2->color = a1->color;
-    a2->translation = a1->translation;
-    a2->rotation = a1->rotation;
-    a2->scale = a1->scale;
-    a2->mat = a1->mat;
-    a2->random = a1->random;
+    for (i = a1->render_groups.begin; i != a1->render_groups.end; i++) {
+        if (!*i)
+            continue;
 
-    emitters_count = a1->emitters.end - a1->emitters.begin;
-    if (emitters_count != a2->emitters.end - a2->emitters.begin)
+        render_group = *i;
+        if (render_group && (!glitter_render_group_cannot_draw(render_group) || gpm->draw_all))
+            glitter_render_group_calc_draw(GPM_VAL, render_group, render_add_list_func);
+    }
+}
+
+void FASTCALL glitter_effect_inst_draw(GPM, glitter_effect_inst* a1, int32_t alpha) {
+    glitter_render_group** i;
+    glitter_render_group* render_group;
+
+    for (i = a1->render_groups.begin; i != a1->render_groups.end; i++) {
+        if (!*i)
+            continue;
+
+        render_group = *i;
+        if (render_group && (render_group)->alpha == alpha
+            && (!glitter_render_group_cannot_draw(render_group) || gpm->draw_all))
+            glitter_render_group_draw(GPM_VAL, render_group);
+    }
+}
+
+int32_t FASTCALL glitter_effect_inst_get_alpha(glitter_effect_inst* a1) {
+    return (a1->data.flags & GLITTER_EFFECT_ALPHA) ? 2 : 1;
+}
+
+size_t FASTCALL glitter_effect_inst_get_ctrl_count(glitter_effect_inst* a1, glitter_particle_type type) {
+    glitter_render_group** i;
+    glitter_render_group* render_group;
+    size_t ctrl;
+
+    ctrl = 0;
+    for (i = a1->render_groups.begin; i != a1->render_groups.end; i++) {
+        if (!*i)
+            continue;
+
+        render_group = *i;
+        if (render_group->type == type)
+            ctrl += render_group->ctrl;
+    }
+    return ctrl;
+}
+
+size_t FASTCALL glitter_effect_inst_get_disp_count(glitter_effect_inst* a1, glitter_particle_type type) {
+    glitter_render_group** i;
+    glitter_render_group* render_group;
+    size_t disp;
+
+    disp = 0;
+    for (i = a1->render_groups.begin; i != a1->render_groups.end; i++) {
+        if (!*i)
+            continue;
+
+        render_group = *i;
+        if (render_group->type == type)
+            disp += render_group->disp;
+    }
+    return disp;
+}
+
+int32_t FASTCALL glitter_effect_inst_get_fog(glitter_effect_inst* a1) {
+    if (a1->data.flags & GLITTER_EFFECT_FOG)
+        return 1;
+    else if (a1->data.flags & GLITTER_EFFECT_FOG_HEIGHT)
+        return 2;
+    else
+        return 0;
+}
+
+bool FASTCALL glitter_effect_inst_has_ended(glitter_effect_inst* effect, bool a2) {
+    glitter_emitter_inst** i;
+
+    if (~effect->flags & GLITTER_EFFECT_INST_FREE)
+        return false;
+    else if (!a2)
+        return true;
+
+    for (i = effect->emitters.begin; i != effect->emitters.end; i++)
+        if (!glitter_emitter_inst_has_ended(*i, a2))
+            return false;
+    return true;
+}
+
+void FASTCALL glitter_effect_inst_reset(GPM, glitter_effect_inst* a1, float_t emission) {
+    glitter_emitter_inst** i;
+
+    a1->frame = (float_t)-a1->data.appear_time;
+    a1->flags = 0;
+    for (i = a1->emitters.begin; i != a1->emitters.end; i++)
+        glitter_emitter_inst_reset(*i);
+    glitter_effect_inst_reset_sub(GPM_VAL, a1, emission);
+}
+
+void FASTCALL glitter_effect_inst_update_value_frame(GPM,
+    glitter_effect_inst* effect, float_t delta_frame, float_t emission) {
+    vec3 scale;
+    glitter_emitter_inst** i;
+    glitter_render_group** j;
+    mat4 mat;
+    vec3 translation;
+    vec3 rotation;
+
+    glitter_effect_inst_get_ext_anim(GPM_VAL, effect);
+    glitter_effect_inst_get_value(GPM_VAL, effect, effect->frame);
+    vec3_mult_scalar(effect->scale, effect->scale_all, scale);
+    rotation = effect->rotation;
+    if (effect->flags & GLITTER_EFFECT_INST_HAS_EXT_ANIM_TRANS && effect->ext_anim) {
+        vec3_add(effect->translation, effect->ext_anim->translation, translation);
+        mat4_translate_mult(&effect->ext_anim->mat, translation.x, translation.y, translation.z, &mat);
+    }
+    else {
+        translation = effect->translation;
+        mat4_translate(translation.x, translation.y, translation.z, &mat);
+    }
+
+    mat4_rot(&mat, rotation.x, rotation.y, rotation.z, &mat);
+    mat4_scale_rot(&mat, scale.x, scale.y, scale.z, &effect->mat);
+    for (i = effect->emitters.begin; i != effect->emitters.end; ++i)
+        if (*i)
+            glitter_emitter_inst_update_value_frame(GPM_VAL, *i, effect, delta_frame);
+
+    if (effect->frame >= 0.0f)
+        if (effect->frame < (float_t)effect->data.life_time) {
+            for (i = effect->emitters.begin; i != effect->emitters.end; i++)
+                if (*i)
+                    glitter_emitter_inst_emit(GPM_VAL, *i, delta_frame, emission);
+        }
+        else if (effect->data.flags & GLITTER_EFFECT_LOOP)
+            effect->frame -= (float_t)effect->data.life_time;
+        else {
+            effect->flags |= GLITTER_EFFECT_INST_FREE;
+            for (i = effect->emitters.begin; i != effect->emitters.end; ++i)
+                if (*i)
+                    glitter_emitter_inst_free(GPM_VAL, *i, emission);
+        }
+
+    for (j = effect->render_groups.begin; j != effect->render_groups.end; j++)
+        if (*j)
+            glitter_render_group_get_value(GPM_VAL, *j, delta_frame, true);
+    effect->frame += delta_frame;
+}
+
+void FASTCALL glitter_effect_inst_dispose(glitter_effect_inst* ei) {
+    if (ei->ext_anim) {
+        free(ei->ext_anim->name);
+        free(ei->ext_anim);
+    }
+
+    vector_ptr_glitter_render_group_free(&ei->render_groups, glitter_render_group_dispose);
+    vector_ptr_glitter_emitter_inst_free(&ei->emitters, glitter_emitter_inst_dispose);
+    free(ei);
+}
+
+static void FASTCALL glitter_effect_inst_get_ext_anim(GPM, glitter_effect_inst* a1) {
+    glitter_effect_inst_ext_anim* ext_anim;
+
+    if (!a1->ext_anim)
         return;
 
-    for (i = 0; i < emitters_count; i++)
-        glitter_emitter_inst_copy(a1->emitters.begin[i], a2->emitters.begin[i], a3);
-}
+    ext_anim = a1->ext_anim;
+    ext_anim->mat = mat4_identity;
+    ext_anim->translation = vec3_null;
 
-void FASTCALL glitter_effect_inst_emit(glitter_effect_inst* a1, glitter_scene* a2, float_t delta_frame) {
-    glitter_emitter_inst** i; // rbx
+    if (~a1->flags & GLITTER_EFFECT_INST_HAS_EXT_ANIM
+        || (a1->flags & GLITTER_EFFECT_INST_SET_EXT_ANIM_ONCE
+            && a1->flags & GLITTER_EFFECT_INST_HAS_EXT_ANIM_TRANS))
+        return;
 
-    if (a1->frame >= 0.0f) {
-        if (a1->frame < a1->data.life_time)
-            for (i = a1->emitters.begin; i != a1->emitters.end; ++i)
-                glitter_emitter_inst_emit_step(*i, a2, a1, delta_frame);
-        else if (a1->data.flags & GLITTER_EFFECT_FLAG_LOOP)
-            a1->frame -= a1->data.life_time;
-        else
-            glitter_effect_inst_free(a1, a2, false);
-    }
-    a1->frame += delta_frame;
-}
-
-void FASTCALL glitter_effect_inst_emit_init(glitter_effect_inst* a1, glitter_scene* a2, float_t delta_frame) {
-    glitter_emitter_inst** i;
-
-    if (a1->frame >= 0.0f) {
-        if (a1->frame < a1->data.life_time)
-            for (i = a1->emitters.begin; i != a1->emitters.end; i++)
-                glitter_emitter_inst_emit_init(*i, a2, a1, delta_frame);
-        else if (a1->data.flags & GLITTER_EFFECT_FLAG_LOOP)
-            a1->frame -= a1->data.life_time;
-        else
-            glitter_effect_inst_free(a1, a2, 0);
-
-        for (i = a1->emitters.begin; i != a1->emitters.end; i++)
-            glitter_emitter_inst_render_group_init(*i, delta_frame);
-    }
-    a1->frame += delta_frame;
-}
-
-void FASTCALL glitter_effect_inst_free(glitter_effect_inst* a1, glitter_scene* a2, bool free) {
-    glitter_emitter_inst** i;
-
-    a1->flags |= GLITTER_EFFECT_INST_FLAG_FREE;
-    for (i = a1->emitters.begin; i != a1->emitters.end; ++i)
-        glitter_emitter_inst_free(*i, a2, free);
-}
-
-void FASTCALL glitter_effect_inst_get_a3da(glitter_effect_inst* a1) {
-    glitter_effect_inst_a3da* v3; // rax
-    char* v4; // rax
-    int64_t v6; // rbx
-    mat4* v15; // r8
-    int64_t v24; // rsi
-    int32_t v26; // ebx
-    char* v27; // r14
-    int64_t v43; // rbx
+    /*char* v4;
+    int64_t v6;
+    mat4* v15;
+    int64_t v24;
+    int32_t chara_index;
+    int64_t v43;
     vec3 a2;
-    mat4 mat0;
-    mat4 mat1;
-
-    if (~a1->flags & GLITTER_EFFECT_INST_FLAG_HAS_A3DA || !a1->a3da
-        || (a1->flags & GLITTER_EFFECT_INST_FLAG_SET_A3DA_ONCE
-            && a1->flags & GLITTER_EFFECT_INST_FLAG_HAS_A3DA_TRANS))
-        return;
-
-    return;
+    mat4 mat;
 
     int32_t(FASTCALL * sub_1401D5010)(int32_t a1)
         = (void*)0x00000001401D5010;
@@ -185,295 +305,105 @@ void FASTCALL glitter_effect_inst_get_a3da(glitter_effect_inst* a1) {
     mat4* (FASTCALL * sub_140516750)(int64_t a1)
         = (void*)0x0000000140516750;
 
-    v3 = a1->a3da;
-    if (a1->flags & GLITTER_EFFECT_INST_FLAG_SET_A3DA_BY_OBJECT_INDEX) {
+    if (a1->flags & GLITTER_EFFECT_INST_CHARA_ANIM) {
         v4 = sub_1405320E0();
-        if (v4 && sub_1405327B0(v4, v3->object_index) && (v6 = sub_140532030(v4, v3->object_index))) {
-            mat0 = *sub_140516750(v6);
-            vec4_length(mat0.row0, a2.x);
-            vec4_length(mat0.row1, a2.y);
+        if (v4 && sub_1405327B0(v4, ext_anim->chara_index) && (v6 = sub_140532030(v4, ext_anim->chara_index))) {
+            mat = *sub_140516750(v6);
+            vec4_length(mat.row0, a2.x);
+            vec4_length(mat.row1, a2.y);
             vec2_sub(*(vec2*)&a2, vec2_identity, *(vec2*)&a2);
             a2.z = 0.0f;
-            a1->a3da_scale = a2;
-            a1->flags |= GLITTER_EFFECT_INST_FLAG_HAS_A3DA_SCALE;
-            if (v3->index != 201) {
-                v15 = sub_140516730(v6, v3->index);
-                if (v15) {
-                    mat1 = *v15;
-                    mat4_mult(&mat0, &mat1, &mat0);
-                    if (a1->flags & GLITTER_EFFECT_INST_FLAG_SET_A3DA_TRANS_ONLY) {
-                        v3->mat = mat4_identity;
-                        v3->translation = *(vec3*)&mat0.row3;
-                    }
-                    else
-                        v3->mat = mat0;
-                    goto SetFlags;
-                }
-            }
-            else {
-                if (a1->flags & GLITTER_EFFECT_INST_FLAG_SET_A3DA_TRANS_ONLY) {
-                    v3->mat = mat4_identity;
-                    v3->translation = *(vec3*)&mat0.row3;
-                }
-                else
-                    v3->mat = mat0;
-                goto SetFlags;
+            a1->ext_anim_scale = a2;
+            a1->flags |= GLITTER_EFFECT_INST_HAS_EXT_ANIM_SCALE;
+            if (ext_anim->node_index == 201)
+                goto set_mat;
+            else if (v15 = sub_140516730(v6, ext_anim->node_index)) {
+                mat4_mult(&mat, v15, &mat);
+                goto set_mat;
             }
         }
     }
-    else if (~a1->flags & GLITTER_EFFECT_INST_FLAG_SET_A3DA_BY_OBJECT_NAME) {
-        if (v3->index < 0) {
-            if (!v3->mesh_name)
+    else if (~a1->flags & GLITTER_EFFECT_INST_SET_EXT_ANIM_BY_OBJECT_NAME) {
+        if (ext_anim->node_index < 0) {
+            if (!ext_anim->name)
                 return;
 
-            v3->index = sub_140459DE0(v3->object_index, v3->mesh_name);
+            ext_anim->node_index = sub_140459DE0(ext_anim->object_hash, ext_anim->name);
         }
 
-        if (v3->index >= 0) {
-            v43 = sub_140459D40(v3->object_index, v3->index);
+        if (ext_anim->node_index >= 0) {
+            v43 = sub_140459D40(ext_anim->object_hash, ext_anim->node_index);
             if (v43) {
-                v3->translation = *(vec3*)(v43 + 4);
-                goto SetFlags;
+                ext_anim->translation = *(vec3*)(v43 + 4);
+                goto set_flags;
             }
         }
     }
     else {
-        if (v3->dword00 == -1 || !(v24 = sub_1401D5BC0(v3->dword00, v3->dword08, v3->object_is_hrc))) {
-            v3->dword00 = sub_1401D6090(v3->object_index, &v3->dword08, &v3->object_is_hrc);
-            if (v3->dword00 == -1)
+        if (ext_anim->dword00 == -1 || !(v24 = sub_1401D5BC0(ext_anim->dword00,
+            ext_anim->dword08, ext_anim->object_is_hrc))) {
+            ext_anim->dword00 = sub_1401D6090(ext_anim->object_hash,
+                &ext_anim->dword08, &ext_anim->object_is_hrc);
+            if (ext_anim->dword00 == -1)
                 return;
 
-            v3->index = -1;
-            v24 = sub_1401D5BC0(v3->dword00, v3->dword08, v3->object_is_hrc);
+            ext_anim->node_index = -1;
+            v24 = sub_1401D5BC0(ext_anim->dword00, ext_anim->dword08, ext_anim->object_is_hrc);
             if (!v24)
                 return;
         }
 
-        mat0 = mat4_identity;
-        v26 = sub_1401D5010(v3->dword00);
-        if (v26 >= 0 && v26 <= 5) {
-            v27 = sub_1405320E0();
-            if (sub_1405327B0(v27, v26)) {
-                mat0 = *sub_140516750(sub_140532030(v27, v26));
-                vec4_length(mat0.row0, a2.x);
-                vec4_length(mat0.row1, a2.y);
+        mat = mat4_identity;
+        chara_index = sub_1401D5010(ext_anim->dword00);
+        if (chara_index >= 0 && chara_index <= 5) {
+            v4 = sub_1405320E0();
+            if (sub_1405327B0(v4, chara_index) && (v6 = sub_140532030(v4, chara_index))) {
+                mat = *sub_140516750(v6);
+                vec4_length(mat.row0, a2.x);
+                vec4_length(mat.row1, a2.y);
                 vec2_sub(*(vec2*)&a2, vec2_identity, *(vec2*)&a2);
                 a2.z = 0.0f;
-                a1->a3da_scale = a2;
-                a1->flags |= GLITTER_EFFECT_INST_FLAG_HAS_A3DA_SCALE;
+                a1->ext_anim_scale = a2;
+                a1->flags |= GLITTER_EFFECT_INST_HAS_EXT_ANIM_SCALE;
             }
         }
 
-        mat1 = *(mat4*)v24;
-        if (v3->mesh_name) {
-            if (v3->index < 0) {
-                v3->index = sub_140459DE0(v3->object_index, v3->mesh_name);
-            }
+        if (ext_anim->name) {
+            if (ext_anim->node_index < 0)
+                ext_anim->node_index = sub_140459DE0(ext_anim->object_hash, ext_anim->name);
 
-            if (v3->index >= 0) {
-                v43 = sub_140459D40(v3->object_index, v3->index);
+            if (ext_anim->node_index >= 0) {
+                v43 = sub_140459D40(ext_anim->object_hash, ext_anim->node_index);
                 if (v43) {
-                    mat4_mult(&mat0, &mat1, &v3->mat);
-                    v3->translation = *(vec3*)(v43 + 4);
-                    goto SetFlags;
+                    mat4_mult(&mat, (mat4*)v24, &ext_anim->mat);
+                    ext_anim->translation = *(vec3*)(v43 + 4);
+                    goto set_flags;
                 }
             }
         }
         else {
-            mat4_mult(&mat0, &mat1, &mat0);
-            if (a1->flags & GLITTER_EFFECT_INST_FLAG_SET_A3DA_TRANS_ONLY) {
-                v3->mat = mat4_identity;
-                v3->translation = *(vec3*)&mat0.row3;
-            }
-            else
-                v3->mat = mat0;
-            goto SetFlags;
+            mat4_mult(&mat, (mat4*)v24, &mat);
+            goto set_mat;
         }
     }
     return;
 
-SetFlags:
-    if (a1->flags & GLITTER_EFFECT_INST_FLAG_HAS_A3DA_NON_INIT) {
-        a1->flags &= ~GLITTER_EFFECT_INST_FLAG_HAS_A3DA_NON_INIT;
-        a1->flags |= GLITTER_EFFECT_INST_FLAG_HAS_A3DA_TRANS;
+set_mat:
+    if (a1->flags & GLITTER_EFFECT_INST_EXT_ANIM_TRANS_ONLY) {
+        ext_anim->mat = mat4_identity;
+        mat4_get_translation(&mat, ext_anim->translation);
     }
-}
-
-int32_t FASTCALL glitter_effect_inst_get_alpha(glitter_effect_inst* a1) {
-    return (a1->data.flags & GLITTER_EFFECT_FLAG_ALPHA) ? 2 : 1;
-}
-
-int32_t FASTCALL glitter_effect_inst_get_fog(glitter_effect_inst* a1) {
-    if (a1->data.flags & GLITTER_EFFECT_FLAG_FOG)
-        return 1;
-    else if (a1->data.flags & GLITTER_EFFECT_FLAG_FOG_HEIGHT)
-        return 2;
     else
-        return 0;
+        ext_anim->mat = mat;
+
+set_flags:
+    if (a1->flags & GLITTER_EFFECT_INST_HAS_EXT_ANIM_NON_INIT) {
+        a1->flags &= ~GLITTER_EFFECT_INST_HAS_EXT_ANIM_NON_INIT;
+        a1->flags |= GLITTER_EFFECT_INST_HAS_EXT_ANIM_TRANS;
+    }*/
 }
 
-void FASTCALL glitter_effect_inst_get_value(glitter_effect_inst* a1, float_t frame, int32_t random) {
-    int64_t length;
-    glitter_curve* curve;
-    float_t value;
-
-    length = a1->effect->curve.end - a1->effect->curve.begin;
-    if (!length)
-        return;
-
-    for (int32_t i = 0; i < length; i++) {
-        curve = a1->effect->curve.begin[i];
-        if (!glitter_curve_get_value(curve, frame, &value, random + i))
-            continue;
-
-        switch (curve->type) {
-        case GLITTER_CURVE_TRANSLATION_X:
-            a1->translation.x = value;
-            break;
-        case GLITTER_CURVE_TRANSLATION_Y:
-            a1->translation.y = value;
-            break;
-        case GLITTER_CURVE_TRANSLATION_Z:
-            a1->translation.z = value;
-            break;
-        case GLITTER_CURVE_ROTATION_X:
-            a1->rotation.x = value;
-            break;
-        case GLITTER_CURVE_ROTATION_Y:
-            a1->rotation.y = value;
-            break;
-        case GLITTER_CURVE_ROTATION_Z:
-            a1->rotation.z = value;
-            break;
-        case GLITTER_CURVE_SCALE_X:
-            a1->scale.x = value;
-            break;
-        case GLITTER_CURVE_SCALE_Y:
-            a1->scale.y = value;
-            break;
-        case GLITTER_CURVE_SCALE_Z:
-            a1->scale.z = value;
-            break;
-        case GLITTER_CURVE_SCALE_ALL:
-            a1->scale_all = value;
-            break;
-        case GLITTER_CURVE_COLOR_R:
-            a1->color.x = value;
-            break;
-        case GLITTER_CURVE_COLOR_G:
-            a1->color.y = value;
-            break;
-        case GLITTER_CURVE_COLOR_B:
-            a1->color.z = value;
-            break;
-        case GLITTER_CURVE_COLOR_A:
-            a1->color.w = value;
-            break;
-        }
-    }
-}
-
-bool FASTCALL glitter_effect_inst_has_ended(glitter_effect_inst* effect, bool a2) {
-    glitter_emitter_inst** i;
-
-    if (~effect->flags & GLITTER_EFFECT_INST_FLAG_FREE)
-        return false;
-    else if (!a2)
-        return true;
-
-    for (i = effect->emitters.begin; i != effect->emitters.end; i++)
-        if (!glitter_emitter_inst_has_ended(*i, a2))
-            return false;
-    return true;
-}
-
-void FASTCALL glitter_effect_inst_reset(glitter_effect_inst* a1, glitter_scene* a2) {
-    glitter_emitter_inst** i;
-
-    a1->frame = -a1->data.appear_time;
-    a1->flags = 0;
-    for (i = a1->emitters.begin; i != a1->emitters.end; i++)
-        glitter_emitter_inst_reset(*i);
-    glitter_effect_inst_reset_sub(a1, a2);
-}
-
-void FASTCALL glitter_effect_inst_reset_sub(glitter_effect_inst* a1, glitter_scene* a2) {
-    float_t delta_frame;
-    float_t start_time;
-
-    if (a1->data.start_time <= 0.0f)
-        return;
-
-    delta_frame = 2.0f;
-    for (start_time = a1->data.start_time; start_time > 0.0f; start_time -= delta_frame) {
-        a1->flags |= GLITTER_EFFECT_INST_FLAG_JUST_INIT;
-        if (start_time < delta_frame)
-            delta_frame -= start_time;
-        glitter_effect_inst_update_value_init(a1, delta_frame);
-        glitter_effect_inst_emit_init(a1, a2, delta_frame);
-    }
-    glitter_effect_inst_update_mat(a1);
-}
-
-void FASTCALL glitter_effect_inst_update_mat(glitter_effect_inst* a1) {
-    glitter_emitter_inst** i;
-    vec3 scale;
-
-    if (a1->flags & GLITTER_EFFECT_INST_FLAG_JUST_INIT) {
-        mat4_translate(a1->translation.x, a1->translation.y, a1->translation.z, &a1->mat);
-        mat4_rot(&a1->mat, a1->rotation.x, a1->rotation.y, a1->rotation.z, &a1->mat);
-        vec3_mult_scalar(a1->scale, a1->scale_all, scale);
-        mat4_scale_rot(&a1->mat, scale.x, scale.y, scale.z, &a1->mat);
-        for (i = a1->emitters.begin; i != a1->emitters.end; ++i)
-            glitter_emitter_inst_update_mat(*i, a1);
-        a1->flags &= ~GLITTER_EFFECT_INST_FLAG_JUST_INIT;
-    }
-}
-
-void FASTCALL glitter_effect_inst_update_value_frame(glitter_effect_inst* effect, float_t delta_frame) {
-    vec3 scale;
-    glitter_emitter_inst** i;
-    mat4 mat;
-    vec3 translation;
-
-    glitter_effect_inst_get_value(effect, effect->frame, effect->random);
-    vec3_mult_scalar(effect->scale, effect->scale_all, scale);
-    glitter_effect_inst_get_a3da(effect);
-    if (~effect->flags & GLITTER_EFFECT_INST_FLAG_HAS_A3DA_TRANS || !effect->a3da)
-        translation = effect->translation;
-    else
-        vec3_add(effect->translation, effect->a3da->translation, translation);
-
-    mat4_translate(translation.x, translation.y, translation.z, &mat);
-    mat4_rot(&mat, effect->rotation.x, effect->rotation.y, effect->rotation.z, &mat);
-    mat4_scale_rot(&mat, scale.x, scale.y, scale.z, &mat);
-    effect->mat = mat;
-    for (i = effect->emitters.begin; i != effect->emitters.end; ++i)
-        glitter_emitter_inst_update_value_frame(*i, effect, delta_frame);
-}
-
-void FASTCALL glitter_effect_inst_update_value_init(glitter_effect_inst* a1, float_t delta_frame) {
-    glitter_emitter_inst** i;
-
-    if (a1->frame < 0.0f)
-        return;
-
-    glitter_effect_inst_get_value(a1, a1->frame, a1->random);
-    for (i = a1->emitters.begin; i != a1->emitters.end; ++i)
-        glitter_emitter_inst_update_value_init(*i, a1->frame, delta_frame);
-}
-
-void FASTCALL glitter_effect_inst_dispose(glitter_effect_inst* ei) {
-    if (ei->a3da) {
-        free(ei->a3da->mesh_name);
-        free(ei->a3da);
-    }
-
-    vector_ptr_glitter_emitter_inst_free(&ei->emitters, (void*)glitter_emitter_inst_dispose);
-    free(ei);
-}
-
-static int32_t FASTCALL glitter_effect_inst_get_a3da_index(int32_t index) {
+static int32_t FASTCALL glitter_aft_effect_inst_get_ext_anim_bone_index(int32_t index) {
     switch (index) {
     case 0:
         return 15;
@@ -515,3 +445,143 @@ static int32_t FASTCALL glitter_effect_inst_get_a3da_index(int32_t index) {
         return 201;
     }
 }
+
+static int32_t FASTCALL glitter_f2_effect_inst_get_ext_anim_bone_index(int32_t index) {
+    switch (index) {
+    case 0:
+        return 15;
+    case 1:
+        return 54;
+    case 2:
+        return 0;
+    case 3:
+        return 7;
+    case 4:
+        return 98;
+    case 5:
+        return 100;
+    case 6:
+        return 101;
+    case 7:
+        return 115;
+    case 8:
+        return 132;
+    case 9:
+        return 136;
+    case 10:
+        return 137;
+    case 11:
+        return 151;
+    case 12:
+        return 186;
+    case 13:
+        return 176;
+    case 14:
+        return 175;
+    case 15:
+        return 189;
+    case 16:
+        return 183;
+    case 17:
+        return 182;
+    default:
+        return 193;
+    }
+}
+
+static void FASTCALL glitter_effect_inst_get_value(GPM, glitter_effect_inst* a1, float_t frame) {
+    int64_t length;
+    glitter_curve* curve;
+    float_t value;
+
+    length = a1->effect->curve.end - a1->effect->curve.begin;
+    if (!length)
+        return;
+
+    for (int32_t i = 0; i < length; i++) {
+        curve = a1->effect->curve.begin[i];
+        if (!glitter_curve_get_value(GPM_VAL, curve, frame, &value, a1->random.value + i, &a1->random_shared))
+            continue;
+
+        switch (curve->type) {
+        case GLITTER_CURVE_TRANSLATION_X:
+            a1->translation.x = value;
+            break;
+        case GLITTER_CURVE_TRANSLATION_Y:
+            a1->translation.y = value;
+            break;
+        case GLITTER_CURVE_TRANSLATION_Z:
+            a1->translation.z = value;
+            break;
+        case GLITTER_CURVE_ROTATION_X:
+            a1->rotation.x = value;
+            break;
+        case GLITTER_CURVE_ROTATION_Y:
+            a1->rotation.y = value;
+            break;
+        case GLITTER_CURVE_ROTATION_Z:
+            a1->rotation.z = value;
+            break;
+        case GLITTER_CURVE_SCALE_X:
+            a1->scale.x = value;
+            break;
+        case GLITTER_CURVE_SCALE_Y:
+            a1->scale.y = value;
+            break;
+        case GLITTER_CURVE_SCALE_Z:
+            a1->scale.z = value;
+            break;
+        case GLITTER_CURVE_SCALE_ALL:
+            a1->scale_all = value;
+            break;
+        /*case GLITTER_CURVE_COLOR_R:
+            a1->color.x = value;
+            break;
+        case GLITTER_CURVE_COLOR_G:
+            a1->color.y = value;
+            break;
+        case GLITTER_CURVE_COLOR_B:
+            a1->color.z = value;
+            break;
+        case GLITTER_CURVE_COLOR_A:
+            a1->color.w = value;
+            break;*/
+        }
+    }
+}
+
+static void FASTCALL glitter_effect_inst_reset_sub(GPM, glitter_effect_inst* a1, float_t emission) {
+    glitter_emitter_inst** i;
+    glitter_render_group** j;
+    vec3 scale;
+    float_t delta_frame;
+    float_t start_time;
+
+    if (a1->data.start_time <= 0)
+        return;
+
+    delta_frame = 2.0f;
+    for (start_time = (float_t)a1->data.start_time; start_time > 0.0f; start_time -= delta_frame) {
+        if (start_time < delta_frame)
+            delta_frame -= start_time;
+
+        glitter_effect_inst_get_value(GPM_VAL, a1, a1->frame);
+        mat4_translate(a1->translation.x, a1->translation.y, a1->translation.z, &a1->mat);
+        mat4_rot(&a1->mat, a1->rotation.x, a1->rotation.y, a1->rotation.z, &a1->mat);
+        vec3_mult_scalar(a1->scale, a1->scale_all, scale);
+        mat4_scale_rot(&a1->mat, scale.x, scale.y, scale.z, &a1->mat);
+
+        for (i = a1->emitters.begin; i != a1->emitters.end; ++i) {
+            if (!*i)
+                continue;
+
+            glitter_emitter_inst_update_value_init(GPM_VAL, *i, a1, delta_frame);
+            glitter_emitter_inst_emit(GPM_VAL, *i, delta_frame, emission);
+        }
+
+        for (j = a1->render_groups.begin; j != a1->render_groups.end; j++)
+            if (*j)
+                glitter_render_group_get_value(GPM_VAL, *j, delta_frame, true);
+        a1->frame += delta_frame;
+    }
+}

src/CRE/Glitter/effect_inst.h

@@ -7,23 +7,17 @@
 
 #include "glitter.h"
 
-extern glitter_effect_inst* FASTCALL glitter_effect_inst_init(glitter_effect* a1,
-    glitter_scene* a2, size_t id, bool appear_now);
-extern void FASTCALL glitter_effect_inst_copy(glitter_effect_inst* a1,
-    glitter_effect_inst* a2, glitter_scene* a3);
-extern void FASTCALL glitter_effect_inst_emit(glitter_effect_inst* a1,
-    glitter_scene* a2, float_t delta_frame);
-extern void FASTCALL glitter_effect_inst_emit_init(glitter_effect_inst* a1,
-    glitter_scene* a2, float_t delta_frame);
-extern void FASTCALL glitter_effect_inst_free(glitter_effect_inst* a1, glitter_scene* a2, bool a3);
-extern void FASTCALL glitter_effect_inst_get_a3da(glitter_effect_inst* a1);
+extern glitter_effect_inst* FASTCALL glitter_effect_inst_init(GPM,
+    glitter_effect* a1, size_t id, float_t emission, bool appear_now);
+extern void FASTCALL glitter_effect_inst_calc_draw(GPM, glitter_effect_inst* a1,
+    bool(FASTCALL* render_add_list_func)(glitter_particle_mesh*, vec4*, mat4*, mat4*));
+extern void FASTCALL glitter_effect_inst_draw(GPM, glitter_effect_inst* a1, int32_t alpha);
 extern int32_t FASTCALL glitter_effect_inst_get_alpha(glitter_effect_inst* a1);
+extern size_t FASTCALL glitter_effect_inst_get_ctrl_count(glitter_effect_inst* a1, glitter_particle_type type);
+extern size_t FASTCALL glitter_effect_inst_get_disp_count(glitter_effect_inst* a1, glitter_particle_type type);
 extern int32_t FASTCALL glitter_effect_inst_get_fog(glitter_effect_inst* a1);
-extern void FASTCALL glitter_effect_inst_get_value(glitter_effect_inst* a1, float_t frame, int32_t random);
 extern bool FASTCALL glitter_effect_inst_has_ended(glitter_effect_inst* effect, bool a2);
-extern void FASTCALL glitter_effect_inst_reset(glitter_effect_inst* a1, glitter_scene* a2);
-extern void FASTCALL glitter_effect_inst_reset_sub(glitter_effect_inst* a1, glitter_scene* a2);
-extern void FASTCALL glitter_effect_inst_update_mat(glitter_effect_inst* a1);
-extern void FASTCALL glitter_effect_inst_update_value_frame(glitter_effect_inst* a1, float_t delta_frame);
-extern void FASTCALL glitter_effect_inst_update_value_init(glitter_effect_inst* a1, float_t delta_frame);
+extern void FASTCALL glitter_effect_inst_reset(GPM, glitter_effect_inst* a1, float_t emission);
+extern void FASTCALL glitter_effect_inst_update_value_frame(GPM, glitter_effect_inst* a1,
+    float_t delta_frame, float_t emission);
 extern void FASTCALL glitter_effect_inst_dispose(glitter_effect_inst* ei);

src/CRE/Glitter/emitter.c

@@ -8,15 +8,37 @@
 #include "curve.h"
 #include "particle.h"
 
-static bool FASTCALL glitter_emitter_pack_file(f2_struct* st, glitter_emitter* a2, bool use_big_endian);
-static bool FASTCALL glitter_emitter_unpack_file(int32_t* data, glitter_emitter* a2, bool use_big_endian);
+static bool FASTCALL glitter_emitter_pack_file(GPM, f2_struct* st, glitter_emitter* a2);
+static bool FASTCALL glitter_emitter_unpack_file(GPM, int32_t* data, glitter_emitter* a2, bool use_big_endian);
 
-glitter_emitter* FASTCALL glitter_emitter_init() {
+glitter_emitter* FASTCALL glitter_emitter_init(GPM) {
     glitter_emitter* e = force_malloc(sizeof(glitter_emitter));
+    e->version = glt_type == GLITTER_X ? 0x04 : 0x02;
     return e;
 }
 
-bool FASTCALL glitter_emitter_parse_file(glitter_effect_group* a1,
+glitter_emitter* FASTCALL glitter_emitter_copy(GPM, glitter_emitter* e) {
+    if (!e)
+        return 0;
+
+    glitter_emitter* ec = force_malloc(sizeof(glitter_emitter));
+    *ec = *e;
+
+    ec->particles = (vector_ptr_glitter_particle){ 0, 0, 0 };
+    vector_ptr_glitter_particle_append(&ec->particles, e->particles.end - e->particles.begin);
+    for (glitter_particle** i = e->particles.begin; i != e->particles.end; i++)
+        if (*i) {
+            glitter_particle* p = glitter_particle_copy(GPM_VAL, *i);
+            if (p)
+                vector_ptr_glitter_particle_push_back(&ec->particles, &p);
+        }
+
+    ec->curve = (vector_ptr_glitter_curve){ 0, 0, 0 };
+    glitter_animation_copy(GPM_VAL, &e->curve, &ec->curve);
+    return ec;
+}
+
+bool FASTCALL glitter_emitter_parse_file(GPM, glitter_effect_group* a1,
     f2_struct* st, vector_ptr_glitter_emitter* vec, glitter_effect* effect) {
     f2_struct* i;
     glitter_emitter* emitter;
@@ -24,9 +46,9 @@ bool FASTCALL glitter_emitter_parse_file(glitter_effect_group* a1,
     if (!st || !st->header.data_size)
         return false;
 
-    emitter = glitter_emitter_init();
+    emitter = glitter_emitter_init(GPM_VAL);
     emitter->version = st->header.version;
-    if (!glitter_emitter_unpack_file(st->data, emitter, st->header.use_big_endian)) {
+    if (!glitter_emitter_unpack_file(GPM_VAL, st->data, emitter, st->header.use_big_endian)) {
         glitter_emitter_dispose(emitter);
         return false;
     }
@@ -35,294 +57,393 @@ bool FASTCALL glitter_emitter_parse_file(glitter_effect_group* a1,
         if (!i->header.data_size)
             continue;
 
-        if (i->header.signature == 0x4D494E41)
-            glitter_animation_parse_file(i, &emitter->curve);
-        else if (i->header.signature == 0x4C435450)
-            glitter_particle_parse_file(a1, i, &emitter->particles, effect);
+        if (i->header.signature == reverse_endianess_uint32_t('ANIM'))
+            glitter_animation_parse_file(GPM_VAL, i, &emitter->curve, glitter_emitter_curve_flags);
+        else if (i->header.signature == reverse_endianess_uint32_t('PTCL'))
+            glitter_particle_parse_file(GPM_VAL, a1, i, &emitter->particles, effect);
     }
     vector_ptr_glitter_emitter_push_back(vec, &emitter);
     return true;
 }
 
-bool FASTCALL glitter_emitter_unparse_file(glitter_effect_group* a1,
-    f2_struct* st, glitter_emitter* a3, glitter_effect* effect, bool use_big_endian) {
-    if (!glitter_emitter_pack_file(st, a3, use_big_endian))
+bool FASTCALL glitter_emitter_unparse_file(GPM, glitter_effect_group* a1,
+    f2_struct* st, glitter_emitter* a3, glitter_effect* effect) {
+    if (!glitter_emitter_pack_file(GPM_VAL, st, a3))
         return false;
 
     f2_struct s;
-    if (glitter_animation_unparse_file(&s, &a3->curve, use_big_endian))
+    if (glitter_animation_unparse_file(GPM_VAL, &s, &a3->curve, glitter_emitter_curve_flags))
         vector_f2_struct_push_back(&st->sub_structs, &s);
 
-    for (glitter_particle** i = a3->particles.begin; i != a3->particles.end; i++)
-        if (*i && glitter_particle_unparse_file(a1, &s, *i, effect, use_big_endian))
+    for (glitter_particle** i = a3->particles.begin; i != a3->particles.end; i++) {
+        if (!*i)
+            continue;
+
+        f2_struct s;
+        if (glitter_particle_unparse_file(GPM_VAL, a1, &s, *i, effect))
             vector_f2_struct_push_back(&st->sub_structs, &s);
+    }
     return true;
 }
 
 void FASTCALL glitter_emitter_dispose(glitter_emitter* e) {
-    vector_ptr_glitter_curve_free(&e->curve, (void*)glitter_curve_dispose);
-    vector_ptr_glitter_particle_free(&e->particles, (void*)glitter_particle_dispose);
+    vector_ptr_glitter_curve_free(&e->curve, glitter_curve_dispose);
+    vector_ptr_glitter_particle_free(&e->particles, glitter_particle_dispose);
     free(e);
 }
 
-static bool FASTCALL glitter_emitter_pack_file(f2_struct* st, glitter_emitter* a2, bool use_big_endian) {
+static bool FASTCALL glitter_emitter_pack_file(GPM, f2_struct* st, glitter_emitter* a2) {
     size_t l;
-    int32_t* d;
+    size_t d;
 
-    if (!a2->version)
+    if (a2->version != 1 && a2->version != 2)
         return false;
 
-    memset(st, 0, sizeof(f2_struct));
-    l = 96;
-
     switch (a2->data.type) {
     case GLITTER_EMITTER_BOX:
-        l += 12;
-        break;
     case GLITTER_EMITTER_CYLINDER:
-        l += 20;
-        break;
     case GLITTER_EMITTER_SPHERE:
-        l += 16;
-        break;
     case GLITTER_EMITTER_POLYGON:
-        l += 8;
         break;
     default:
         return false;
     }
 
+    memset(st, 0, sizeof(f2_struct));
+    l = 0;
+
+    uint32_t o;
+    vector_enrs_entry e = { 0, 0, 0 };
+    enrs_entry ee;
+
+    ee = (enrs_entry){ 0, 5, 96, 1, { 0, 0, 0 } };
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 5, ENRS_TYPE_DWORD });
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 2, ENRS_TYPE_WORD });
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 2, ENRS_TYPE_DWORD });
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 2, ENRS_TYPE_WORD });
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 15, ENRS_TYPE_DWORD });
+    vector_enrs_entry_push_back(&e, &ee);
+    l += o = 96;
+
+    switch (a2->data.type) {
+    case GLITTER_EMITTER_BOX:
+        ee = (enrs_entry){ o, 1, 12, 1, { 0, 0, 0 } };
+        vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 3, ENRS_TYPE_DWORD });
+        vector_enrs_entry_push_back(&e, &ee);
+        l += o = 12;
+        break;
+    case GLITTER_EMITTER_CYLINDER:
+        ee = (enrs_entry){ o, 1, 20, 1, { 0, 0, 0 } };
+        vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 5, ENRS_TYPE_DWORD });
+        vector_enrs_entry_push_back(&e, &ee);
+        l += o = 20;
+        break;
+    case GLITTER_EMITTER_SPHERE:
+        ee = (enrs_entry){ o, 1, 16, 1, { 0, 0, 0 } };
+        vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 4, ENRS_TYPE_DWORD });
+        vector_enrs_entry_push_back(&e, &ee);
+        l += o = 16;
+        break;
+    case GLITTER_EMITTER_POLYGON:
+        ee = (enrs_entry){ o, 1, 8, 1, { 0, 0, 0 } };
+        vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 2, ENRS_TYPE_DWORD });
+        vector_enrs_entry_push_back(&e, &ee);
+        l += o = 8;
+        break;
+    }
+
     l = align_val(l, 0x10);
-    d = force_malloc(l);
+    d = (size_t)force_malloc(l);
     st->length = l;
-    st->data = d;
+    st->data = (void*)d;
+    st->enrs = e;
 
-    if (use_big_endian) {
-        d[0] = reverse_endianess_int32_t((int32_t)roundf(a2->data.start_time));
-        d[1] = reverse_endianess_int32_t((int32_t)roundf(a2->data.life_time));
-        d[2] = reverse_endianess_int32_t((int32_t)roundf(a2->data.loop_start_time));
-        d[3] = reverse_endianess_int32_t((int32_t)roundf(a2->data.loop_end_time));
-        d[4] = reverse_endianess_int32_t(a2->data.flags);
-        *((int16_t*)d + 10) = reverse_endianess_int16_t((int16_t)a2->data.type);
-        *((int16_t*)d + 11) = reverse_endianess_int16_t((int16_t)a2->data.direction);
-        *(float_t*)&d[6] = reverse_endianess_float_t(a2->data.emission_interval);
-        *(float_t*)&d[7] = reverse_endianess_float_t(a2->data.particles_per_emission);
-        //*((int16_t*)data + 16) = reverse_endianess_int16_t((int16_t)a3->data.dword2C);
-        /*if (a2->version > 1)
-            *((int16_t*)data + 17) = reverse_endianess_uint16_t((int16_t)a3->data.dword30);*/
+    *(int32_t*)d = a2->data.start_time;
+    *(int32_t*)(d + 4) = a2->data.life_time;
+    *(int32_t*)(d + 8) = a2->data.loop_start_time;
+    *(int32_t*)(d + 12) = a2->data.loop_end_time;
+    *(int32_t*)(d + 16) = a2->data.flags;
+    *(int16_t*)(d + 20) = (int16_t)a2->data.type;
+    *(int16_t*)(d + 22) = (int16_t)a2->data.direction;
+    *(float_t*)(d + 24) = a2->data.emission_interval;
+    *(float_t*)(d + 28) = a2->data.particles_per_emission;
+    *(int16_t*)(d + 32) = 0;
+    *(int16_t*)(d + 34) = 0;
 
-        *(float_t*)&d[9] = reverse_endianess_float_t(a2->translation.x);
-        *(float_t*)&d[10] = reverse_endianess_float_t(a2->translation.y);
-        *(float_t*)&d[11] = reverse_endianess_float_t(a2->translation.z);
-        *(float_t*)&d[12] = reverse_endianess_float_t(a2->rotation.x);
-        *(float_t*)&d[13] = reverse_endianess_float_t(a2->rotation.y);
-        *(float_t*)&d[14] = reverse_endianess_float_t(a2->rotation.z);
-        *(float_t*)&d[15] = reverse_endianess_float_t(a2->scale.x);
-        *(float_t*)&d[16] = reverse_endianess_float_t(a2->scale.y);
-        *(float_t*)&d[17] = reverse_endianess_float_t(a2->scale.z);
-        *(float_t*)&d[18] = reverse_endianess_float_t(a2->data.rotation_add.x);
-        *(float_t*)&d[19] = reverse_endianess_float_t(a2->data.rotation_add.y);
-        *(float_t*)&d[20] = reverse_endianess_float_t(a2->data.rotation_add.z);
-        *(float_t*)&d[21] = reverse_endianess_float_t(a2->data.rotation_add_random.x);
-        *(float_t*)&d[22] = reverse_endianess_float_t(a2->data.rotation_add_random.y);
-        *(float_t*)&d[23] = reverse_endianess_float_t(a2->data.rotation_add_random.z);
+    *(vec3*)(d + 36) = a2->translation;
+    *(vec3*)(d + 48) = a2->rotation;
+    *(vec3*)(d + 60) = a2->scale;
+    *(vec3*)(d + 72) = a2->data.rotation_add;
+    *(vec3*)(d + 84) = a2->data.rotation_add_random;
+    d += 96;
+
+    switch (a2->data.type) {
+    case GLITTER_EMITTER_BOX:
+        *(vec3*)d = a2->data.box.size;
+        break;
+    case GLITTER_EMITTER_CYLINDER:
+        *(float_t*)d = a2->data.cylinder.radius;
+        *(float_t*)(d + 4) = a2->data.cylinder.height;
+        *(float_t*)(d + 8) = a2->data.cylinder.start_angle;
+        *(float_t*)(d + 12) = a2->data.cylinder.end_angle;
+        *(int32_t*)(d + 16) = ((int32_t)a2->data.cylinder.direction << 1)
+            | (a2->data.cylinder.on_edge ? 1 : 0);
+        break;
+    case GLITTER_EMITTER_SPHERE:
+        *(float_t*)d = a2->data.sphere.radius;
+        *(float_t*)(d + 4) = a2->data.sphere.latitude;
+        *(float_t*)(d + 8) = a2->data.sphere.longitude;
+        *(int32_t*)(d + 12) = ((int32_t)a2->data.sphere.direction << 1)
+            | (a2->data.sphere.on_edge ? 1 : 0);
+        break;
+    case GLITTER_EMITTER_POLYGON:
+        *(float_t*)d = a2->data.polygon.size;
+        *(int32_t*)(d + 4) = a2->data.polygon.count;
+        break;
     }
-    else {
-        d[0] = (int32_t)roundf(a2->data.start_time);
-        d[1] = (int32_t)roundf(a2->data.life_time);
-        d[2] = (int32_t)roundf(a2->data.loop_start_time);
-        d[3] = (int32_t)roundf(a2->data.loop_end_time);
-        d[4] = a2->data.flags;
-        *((int16_t*)d + 10) = (int16_t)a2->data.type;
-        *((int16_t*)d + 11) = (int16_t)a2->data.direction;
-        *(float_t*)&d[6] = a2->data.emission_interval;
-        *(float_t*)&d[7] = a2->data.particles_per_emission;
-        //*((int16_t*)data + 16) = (int16_t)a3->data.dword2C;
-        /*if (a2->version > 1)
-            *((int16_t*)data + 17) = (int16_t)a3->data.dword30;*/
 
-        *(vec3*)&d[9] = a2->translation;
-        *(vec3*)&d[12] = a2->rotation;
-        *(vec3*)&d[15] = a2->scale;
-        *(vec3*)&d[18] = a2->data.rotation_add;
-        *(vec3*)&d[21] = a2->data.rotation_add_random;
-    }
-    d += 24;
-
-    if (use_big_endian)
-        switch (a2->data.type) {
-        case GLITTER_EMITTER_BOX:
-            *(float_t*)&d[0] = reverse_endianess_float_t(a2->data.box.size.x);
-            *(float_t*)&d[1] = reverse_endianess_float_t(a2->data.box.size.y);
-            *(float_t*)&d[2] = reverse_endianess_float_t(a2->data.box.size.z);
-            break;
-        case GLITTER_EMITTER_CYLINDER:
-            *(float_t*)&d[0] = reverse_endianess_float_t(a2->data.cylinder.radius);
-            *(float_t*)&d[1] = reverse_endianess_float_t(a2->data.cylinder.height);
-            *(float_t*)&d[2] = reverse_endianess_float_t(a2->data.cylinder.start_angle);
-            *(float_t*)&d[3] = reverse_endianess_float_t(a2->data.cylinder.end_angle);
-            d[4] = reverse_endianess_int32_t(((int32_t)a2->data.cylinder.direction << 1)
-                | (a2->data.cylinder.plain ? 1 : 0));
-            break;
-        case GLITTER_EMITTER_SPHERE:
-            *(float_t*)&d[0] = reverse_endianess_float_t(a2->data.sphere.radius);
-            *(float_t*)&d[1] = reverse_endianess_float_t(a2->data.sphere.latitude);
-            *(float_t*)&d[2] = reverse_endianess_float_t(a2->data.sphere.longitude);
-            d[3] = reverse_endianess_int32_t(((int32_t)a2->data.cylinder.direction << 1)
-                | (a2->data.cylinder.plain ? 1 : 0));
-            break;
-        case GLITTER_EMITTER_POLYGON:
-            *(float_t*)&d[0] = reverse_endianess_float_t(a2->data.polygon.scale);
-            d[1] = reverse_endianess_int32_t(a2->data.polygon.count);
-            break;
-        }
-    else
-        switch (a2->data.type) {
-        case GLITTER_EMITTER_BOX:
-            *(vec3*)&d[0] = a2->data.box.size;
-            break;
-        case GLITTER_EMITTER_CYLINDER:
-            *(float_t*)&d[0] = a2->data.cylinder.radius;
-            *(float_t*)&d[1] = a2->data.cylinder.height;
-            *(float_t*)&d[2] = a2->data.cylinder.start_angle;
-            *(float_t*)&d[3] = a2->data.cylinder.end_angle;
-            d[4] = ((int32_t)a2->data.cylinder.direction << 1)
-                | (a2->data.cylinder.plain ? 1 : 0);
-            break;
-        case GLITTER_EMITTER_SPHERE:
-            *(float_t*)&d[0] = a2->data.sphere.radius;
-            *(float_t*)&d[1] = a2->data.sphere.latitude;
-            *(float_t*)&d[2] = a2->data.sphere.longitude;
-            d[3] = ((int32_t)a2->data.cylinder.direction << 1)
-                | (a2->data.cylinder.plain ? 1 : 0);
-            break;
-        case GLITTER_EMITTER_POLYGON:
-            *(float_t*)&d[0] = a2->data.polygon.scale;
-            d[1] = a2->data.polygon.count;
-            break;
-        }
-
-    st->header.signature = 0x54494D45;
+    st->header.signature = reverse_endianess_uint32_t('EMIT');
     st->header.length = 0x20;
-    st->header.use_big_endian = use_big_endian ? true : false;
+    st->header.use_big_endian = false;
     st->header.use_section_size = true;
     st->header.version = a2->version;
     return true;
 }
 
-static bool FASTCALL glitter_emitter_unpack_file(int32_t* data, glitter_emitter* a2, bool use_big_endian) {
-    if (use_big_endian) {
-        a2->data.start_time = (float_t)reverse_endianess_int32_t(data[0]);
-        a2->data.life_time = (float_t)reverse_endianess_int32_t(data[1]);
-        a2->data.loop_start_time = (float_t)reverse_endianess_int32_t(data[2]);
-        a2->data.loop_end_time = (float_t)reverse_endianess_int32_t(data[3]);
-        a2->data.flags = reverse_endianess_int32_t(data[4]);
+static bool FASTCALL glitter_emitter_unpack_file(GPM,
+    int32_t* data, glitter_emitter* a2, bool use_big_endian) {
+    if (glt_type == GLITTER_X) {
+        if (use_big_endian) {
+            a2->data.start_time = reverse_endianess_int32_t(data[0]);
+            a2->data.life_time = reverse_endianess_int32_t(data[1]);
+            a2->data.loop_start_time = reverse_endianess_int32_t(data[2]);
+            a2->data.loop_end_time = reverse_endianess_int32_t(data[3]);
+            a2->data.flags = reverse_endianess_int32_t(data[4]);
+        }
+        else {
+            a2->data.start_time = data[0];
+            a2->data.life_time = data[1];
+            a2->data.loop_start_time = data[2];
+            a2->data.loop_end_time = data[3];
+            a2->data.flags = data[4];
+        }
+
+        if (a2->version != 3 && a2->version != 4)
+            return false;
+
+        if (use_big_endian) {
+            a2->data.type = reverse_endianess_int16_t(*((int16_t*)data + 10));
+            a2->data.direction = reverse_endianess_int16_t(*((int16_t*)data + 11));
+            a2->data.emission_interval = reverse_endianess_float_t(*(float_t*)&data[6]);
+            a2->data.particles_per_emission = reverse_endianess_float_t(*(float_t*)&data[7]);
+            a2->data.timer = reverse_endianess_int16_t(*((int16_t*)data + 16));
+            a2->data.seed = reverse_endianess_int32_t(data[9]);
+        }
+        else {
+            a2->data.type = *((int16_t*)data + 10);
+            a2->data.direction = *((int16_t*)data + 11);
+            a2->data.emission_interval = *(float_t*)&data[6];
+            a2->data.particles_per_emission = *(float_t*)&data[7];
+            a2->data.timer = *((int16_t*)data + 16);
+            a2->data.seed = data[9];
+        }
+        data += a2->version == 3 ? 14 : 13;
+
+        if (use_big_endian) {
+            a2->translation.x = reverse_endianess_float_t(*(float_t*)&data[0]);
+            a2->translation.y = reverse_endianess_float_t(*(float_t*)&data[1]);
+            a2->translation.z = reverse_endianess_float_t(*(float_t*)&data[2]);
+            a2->rotation.x = reverse_endianess_float_t(*(float_t*)&data[3]);
+            a2->rotation.y = reverse_endianess_float_t(*(float_t*)&data[4]);
+            a2->rotation.z = reverse_endianess_float_t(*(float_t*)&data[5]);
+            a2->scale.x = reverse_endianess_float_t(*(float_t*)&data[6]);
+            a2->scale.y = reverse_endianess_float_t(*(float_t*)&data[7]);
+            a2->scale.z = reverse_endianess_float_t(*(float_t*)&data[8]);
+            a2->data.rotation_add.x = reverse_endianess_float_t(*(float_t*)&data[9]);
+            a2->data.rotation_add.y = reverse_endianess_float_t(*(float_t*)&data[10]);
+            a2->data.rotation_add.z = reverse_endianess_float_t(*(float_t*)&data[11]);
+            a2->data.rotation_add_random.x = reverse_endianess_float_t(*(float_t*)&data[12]);
+            a2->data.rotation_add_random.y = reverse_endianess_float_t(*(float_t*)&data[13]);
+            a2->data.rotation_add_random.z = reverse_endianess_float_t(*(float_t*)&data[14]);
+        }
+        else {
+            a2->translation = *(vec3*)&data[0];
+            a2->rotation = *(vec3*)&data[3];
+            a2->scale = *(vec3*)&data[6];
+            a2->data.rotation_add = *(vec3*)&data[9];
+            a2->data.rotation_add_random = *(vec3*)&data[12];
+        }
+        data += 15;
+
+        if (use_big_endian)
+            switch (a2->data.type) {
+            case GLITTER_EMITTER_BOX:
+                a2->data.box.size.x = reverse_endianess_float_t(*(float_t*)&data[0]);
+                a2->data.box.size.y = reverse_endianess_float_t(*(float_t*)&data[1]);
+                a2->data.box.size.z = reverse_endianess_float_t(*(float_t*)&data[2]);
+                return true;
+            case GLITTER_EMITTER_CYLINDER:
+                a2->data.cylinder.radius = reverse_endianess_float_t(*(float_t*)&data[0]);
+                a2->data.cylinder.height = reverse_endianess_float_t(*(float_t*)&data[1]);
+                a2->data.cylinder.start_angle = reverse_endianess_float_t(*(float_t*)&data[2]);
+                a2->data.cylinder.end_angle = reverse_endianess_float_t(*(float_t*)&data[3]);
+                a2->data.cylinder.on_edge = reverse_endianess_int32_t(data[4]) & 1 ? true : false;
+                a2->data.cylinder.direction = reverse_endianess_int32_t(data[4]) >> 1;
+                return true;
+            case GLITTER_EMITTER_SPHERE:
+                a2->data.sphere.radius = reverse_endianess_float_t(*(float_t*)&data[0]);
+                a2->data.sphere.latitude = reverse_endianess_float_t(*(float_t*)&data[1]);
+                a2->data.sphere.longitude = reverse_endianess_float_t(*(float_t*)&data[2]);
+                a2->data.sphere.on_edge = reverse_endianess_int32_t(data[3]) & 1 ? true : false;
+                a2->data.sphere.direction = reverse_endianess_int32_t(data[3]) >> 1;
+                return true;
+            case GLITTER_EMITTER_POLYGON:
+                a2->data.polygon.size = reverse_endianess_float_t(*(float_t*)&data[0]);
+                a2->data.polygon.count = reverse_endianess_int32_t(data[1]);
+                a2->data.polygon.direction = reverse_endianess_int32_t(data[2]) >> 1;
+                return true;
+            default:
+                return false;
+            }
+        else
+            switch (a2->data.type) {
+            case GLITTER_EMITTER_BOX:
+                a2->data.box.size = *(vec3*)&data[0];
+                return true;
+            case GLITTER_EMITTER_CYLINDER:
+                a2->data.cylinder.radius = *(float_t*)&data[0];
+                a2->data.cylinder.height = *(float_t*)&data[1];
+                a2->data.cylinder.start_angle = *(float_t*)&data[2];
+                a2->data.cylinder.end_angle = *(float_t*)&data[3];
+                a2->data.cylinder.on_edge = data[4] & 1 ? true : false;
+                a2->data.cylinder.direction = data[4] >> 1;
+                return true;
+            case GLITTER_EMITTER_SPHERE:
+                a2->data.sphere.radius = *(float_t*)&data[0];
+                a2->data.sphere.latitude = *(float_t*)&data[1];
+                a2->data.sphere.longitude = *(float_t*)&data[2];
+                a2->data.sphere.on_edge = data[3] & 1 ? true : false;
+                a2->data.sphere.direction = data[3] >> 1;
+                return true;
+            case GLITTER_EMITTER_POLYGON:
+                a2->data.polygon.size = *(float_t*)&data[0];
+                a2->data.polygon.count = data[1];
+                a2->data.polygon.direction = data[2] >> 1;
+                return true;
+            default:
+                return false;
+            }
     }
     else {
-        a2->data.start_time = (float_t)data[0];
-        a2->data.life_time = (float_t)data[1];
-        a2->data.loop_start_time = (float_t)data[2];
-        a2->data.loop_end_time = (float_t)data[3];
-        a2->data.flags = data[4];
-    }
-
-    //a3->data.dword30 = 0;
-    if (!a2->version)
-        return false;
-
-    if (use_big_endian) {
-        a2->data.type = reverse_endianess_int16_t(*((int16_t*)data + 10));
-        a2->data.direction = reverse_endianess_int16_t(*((int16_t*)data + 11));
-        a2->data.emission_interval = reverse_endianess_float_t(*(float_t*)&data[6]);
-        a2->data.particles_per_emission = reverse_endianess_float_t(*(float_t*)&data[7]);
-        //a3->data.dword2C = reverse_endianess_int16_t(*((int16_t*)data + 16));
-        /*if (a2->version > 1)
-            a3->data.dword30 = reverse_endianess_uint16_t(*((uint16_t*)data + 17));*/
-
-        a2->translation.x = reverse_endianess_float_t(*(float_t*)&data[9]);
-        a2->translation.y = reverse_endianess_float_t(*(float_t*)&data[10]);
-        a2->translation.z = reverse_endianess_float_t(*(float_t*)&data[11]);
-        a2->rotation.x = reverse_endianess_float_t(*(float_t*)&data[12]);
-        a2->rotation.y = reverse_endianess_float_t(*(float_t*)&data[13]);
-        a2->rotation.z = reverse_endianess_float_t(*(float_t*)&data[14]);
-        a2->scale.x = reverse_endianess_float_t(*(float_t*)&data[15]);
-        a2->scale.y = reverse_endianess_float_t(*(float_t*)&data[16]);
-        a2->scale.z = reverse_endianess_float_t(*(float_t*)&data[17]);
-        a2->data.rotation_add.x = reverse_endianess_float_t(*(float_t*)&data[18]);
-        a2->data.rotation_add.y = reverse_endianess_float_t(*(float_t*)&data[19]);
-        a2->data.rotation_add.z = reverse_endianess_float_t(*(float_t*)&data[20]);
-        a2->data.rotation_add_random.x = reverse_endianess_float_t(*(float_t*)&data[21]);
-        a2->data.rotation_add_random.y = reverse_endianess_float_t(*(float_t*)&data[22]);
-        a2->data.rotation_add_random.z = reverse_endianess_float_t(*(float_t*)&data[23]);
-    }
-    else {
-        a2->data.type = *((int16_t*)data + 10);
-        a2->data.direction = *((int16_t*)data + 11);
-        a2->data.emission_interval = *(float_t*)&data[6];
-        a2->data.particles_per_emission = *(float_t*)&data[7];
-        //a3->data.dword2C = *((int16_t*)data + 16);
-        /*if (emit_version > 1)
-            a3->data.dword30 = *((uint16_t*)data + 17);*/
-
-        a2->translation = *(vec3*)&data[9];
-        a2->rotation = *(vec3*)&data[12];
-        a2->scale = *(vec3*)&data[15];
-        a2->data.rotation_add = *(vec3*)&data[18];
-        a2->data.rotation_add_random = *(vec3*)&data[21];
-    }
-    data += 24;
-
-    if (use_big_endian)
-        switch (a2->data.type) {
-        case GLITTER_EMITTER_BOX:
-            a2->data.box.size.x = reverse_endianess_float_t(*(float_t*)&data[0]);
-            a2->data.box.size.y = reverse_endianess_float_t(*(float_t*)&data[1]);
-            a2->data.box.size.z = reverse_endianess_float_t(*(float_t*)&data[2]);
-            return true;
-        case GLITTER_EMITTER_CYLINDER:
-            a2->data.cylinder.radius = reverse_endianess_float_t(*(float_t*)&data[0]);
-            a2->data.cylinder.height = reverse_endianess_float_t(*(float_t*)&data[1]);
-            a2->data.cylinder.start_angle = reverse_endianess_float_t(*(float_t*)&data[2]);
-            a2->data.cylinder.end_angle = reverse_endianess_float_t(*(float_t*)&data[3]);
-            a2->data.cylinder.plain = reverse_endianess_int32_t(data[4]) & 1 ? true : false;
-            a2->data.cylinder.direction = reverse_endianess_int32_t(data[4]) >> 1;
-            return true;
-        case GLITTER_EMITTER_SPHERE:
-            a2->data.sphere.radius = reverse_endianess_float_t(*(float_t*)&data[0]);
-            a2->data.sphere.latitude = reverse_endianess_float_t(*(float_t*)&data[1]);
-            a2->data.sphere.longitude = reverse_endianess_float_t(*(float_t*)&data[2]);
-            a2->data.sphere.plain = reverse_endianess_int32_t(data[3]) & 1 ? true : false;
-            a2->data.sphere.direction = reverse_endianess_int32_t(data[3]) >> 1;
-            return true;
-        case GLITTER_EMITTER_POLYGON:
-            a2->data.polygon.scale = reverse_endianess_float_t(*(float_t*)&data[0]);
-            a2->data.polygon.count = reverse_endianess_int32_t(data[1]);
-            return true;
+        if (use_big_endian) {
+            a2->data.start_time = reverse_endianess_int32_t(data[0]);
+            a2->data.life_time = reverse_endianess_int32_t(data[1]);
+            a2->data.loop_start_time = reverse_endianess_int32_t(data[2]);
+            a2->data.loop_end_time = reverse_endianess_int32_t(data[3]);
+            a2->data.flags = reverse_endianess_int32_t(data[4]);
         }
-    else
-        switch (a2->data.type) {
-        case GLITTER_EMITTER_BOX:
-            a2->data.box.size = *(vec3*)&data[0];
-            return true;
-        case GLITTER_EMITTER_CYLINDER:
-            a2->data.cylinder.radius = *(float_t*)&data[0];
-            a2->data.cylinder.height = *(float_t*)&data[1];
-            a2->data.cylinder.start_angle = *(float_t*)&data[2];
-            a2->data.cylinder.end_angle = *(float_t*)&data[3];
-            a2->data.cylinder.plain = data[4] & 1 ? true : false;
-            a2->data.cylinder.direction = data[4] >> 1;
-            return true;
-        case GLITTER_EMITTER_SPHERE:
-            a2->data.sphere.radius = *(float_t*)&data[0];
-            a2->data.sphere.latitude = *(float_t*)&data[1];
-            a2->data.sphere.longitude = *(float_t*)&data[2];
-            a2->data.sphere.plain = data[3] & 1 ? true : false;
-            a2->data.sphere.direction = data[3] >> 1;
-            return true;
-        case GLITTER_EMITTER_POLYGON:
-            a2->data.polygon.scale = *(float_t*)&data[0];
-            a2->data.polygon.count = data[1];
-            return true;
+        else {
+            a2->data.start_time = data[0];
+            a2->data.life_time = data[1];
+            a2->data.loop_start_time = data[2];
+            a2->data.loop_end_time = data[3];
+            a2->data.flags = data[4];
         }
-    return false;
+
+        a2->data.timer = GLITTER_EMITTER_TIMER_BY_TIME;
+        a2->data.seed = 0;
+        if (a2->version != 1 && a2->version != 2)
+            return false;
+
+        if (use_big_endian) {
+            a2->data.type = reverse_endianess_int16_t(*((int16_t*)data + 10));
+            a2->data.direction = reverse_endianess_int16_t(*((int16_t*)data + 11));
+            a2->data.emission_interval = reverse_endianess_float_t(*(float_t*)&data[6]);
+            a2->data.particles_per_emission = reverse_endianess_float_t(*(float_t*)&data[7]);
+            a2->translation.x = reverse_endianess_float_t(*(float_t*)&data[9]);
+            a2->translation.y = reverse_endianess_float_t(*(float_t*)&data[10]);
+            a2->translation.z = reverse_endianess_float_t(*(float_t*)&data[11]);
+            a2->rotation.x = reverse_endianess_float_t(*(float_t*)&data[12]);
+            a2->rotation.y = reverse_endianess_float_t(*(float_t*)&data[13]);
+            a2->rotation.z = reverse_endianess_float_t(*(float_t*)&data[14]);
+            a2->scale.x = reverse_endianess_float_t(*(float_t*)&data[15]);
+            a2->scale.y = reverse_endianess_float_t(*(float_t*)&data[16]);
+            a2->scale.z = reverse_endianess_float_t(*(float_t*)&data[17]);
+            a2->data.rotation_add.x = reverse_endianess_float_t(*(float_t*)&data[18]);
+            a2->data.rotation_add.y = reverse_endianess_float_t(*(float_t*)&data[19]);
+            a2->data.rotation_add.z = reverse_endianess_float_t(*(float_t*)&data[20]);
+            a2->data.rotation_add_random.x = reverse_endianess_float_t(*(float_t*)&data[21]);
+            a2->data.rotation_add_random.y = reverse_endianess_float_t(*(float_t*)&data[22]);
+            a2->data.rotation_add_random.z = reverse_endianess_float_t(*(float_t*)&data[23]);
+        }
+        else {
+            a2->data.type = *((int16_t*)data + 10);
+            a2->data.direction = *((int16_t*)data + 11);
+            a2->data.emission_interval = *(float_t*)&data[6];
+            a2->data.particles_per_emission = *(float_t*)&data[7];
+            a2->translation = *(vec3*)&data[9];
+            a2->rotation = *(vec3*)&data[12];
+            a2->scale = *(vec3*)&data[15];
+            a2->data.rotation_add = *(vec3*)&data[18];
+            a2->data.rotation_add_random = *(vec3*)&data[21];
+        }
+        data += 24;
+
+        if (use_big_endian)
+            switch (a2->data.type) {
+            case GLITTER_EMITTER_BOX:
+                a2->data.box.size.x = reverse_endianess_float_t(*(float_t*)&data[0]);
+                a2->data.box.size.y = reverse_endianess_float_t(*(float_t*)&data[1]);
+                a2->data.box.size.z = reverse_endianess_float_t(*(float_t*)&data[2]);
+                return true;
+            case GLITTER_EMITTER_CYLINDER:
+                a2->data.cylinder.radius = reverse_endianess_float_t(*(float_t*)&data[0]);
+                a2->data.cylinder.height = reverse_endianess_float_t(*(float_t*)&data[1]);
+                a2->data.cylinder.start_angle = reverse_endianess_float_t(*(float_t*)&data[2]);
+                a2->data.cylinder.end_angle = reverse_endianess_float_t(*(float_t*)&data[3]);
+                a2->data.cylinder.on_edge = reverse_endianess_int32_t(data[4]) & 1 ? true : false;
+                a2->data.cylinder.direction = reverse_endianess_int32_t(data[4]) >> 1;
+                return true;
+            case GLITTER_EMITTER_SPHERE:
+                a2->data.sphere.radius = reverse_endianess_float_t(*(float_t*)&data[0]);
+                a2->data.sphere.latitude = reverse_endianess_float_t(*(float_t*)&data[1]);
+                a2->data.sphere.longitude = reverse_endianess_float_t(*(float_t*)&data[2]);
+                a2->data.sphere.on_edge = reverse_endianess_int32_t(data[3]) & 1 ? true : false;
+                a2->data.sphere.direction = reverse_endianess_int32_t(data[3]) >> 1;
+                return true;
+            case GLITTER_EMITTER_POLYGON:
+                a2->data.polygon.size = reverse_endianess_float_t(*(float_t*)&data[0]);
+                a2->data.polygon.count = reverse_endianess_int32_t(data[1]);
+                return true;
+            default:
+                return false;
+            }
+        else
+            switch (a2->data.type) {
+            case GLITTER_EMITTER_BOX:
+                a2->data.box.size = *(vec3*)&data[0];
+                return true;
+            case GLITTER_EMITTER_CYLINDER:
+                a2->data.cylinder.radius = *(float_t*)&data[0];
+                a2->data.cylinder.height = *(float_t*)&data[1];
+                a2->data.cylinder.start_angle = *(float_t*)&data[2];
+                a2->data.cylinder.end_angle = *(float_t*)&data[3];
+                a2->data.cylinder.on_edge = data[4] & 1 ? true : false;
+                a2->data.cylinder.direction = data[4] >> 1;
+                return true;
+            case GLITTER_EMITTER_SPHERE:
+                a2->data.sphere.radius = *(float_t*)&data[0];
+                a2->data.sphere.latitude = *(float_t*)&data[1];
+                a2->data.sphere.longitude = *(float_t*)&data[2];
+                a2->data.sphere.on_edge = data[3] & 1 ? true : false;
+                a2->data.sphere.direction = data[3] >> 1;
+                return true;
+            case GLITTER_EMITTER_POLYGON:
+                a2->data.polygon.size = *(float_t*)&data[0];
+                a2->data.polygon.count = data[1];
+                return true;
+            default:
+                return false;
+            }
+    }
 }

src/CRE/Glitter/emitter.h

@@ -7,9 +7,10 @@
 
 #include "glitter.h"
 
-extern glitter_emitter* FASTCALL glitter_emitter_init();;
-extern bool FASTCALL glitter_emitter_parse_file(glitter_effect_group* a1,
+extern glitter_emitter* FASTCALL glitter_emitter_init(GPM);;
+extern glitter_emitter* FASTCALL glitter_emitter_copy(GPM, glitter_emitter* e);
+extern bool FASTCALL glitter_emitter_parse_file(GPM, glitter_effect_group* a1,
     f2_struct* st, vector_ptr_glitter_emitter* vec, glitter_effect* effect);
-extern bool FASTCALL glitter_emitter_unparse_file(glitter_effect_group* a1,
-    f2_struct* st, glitter_emitter* a3, glitter_effect* effect, bool use_big_endian);
+extern bool FASTCALL glitter_emitter_unparse_file(GPM, glitter_effect_group* a1,
+    f2_struct* st, glitter_emitter* a3, glitter_effect* effect);
 extern void FASTCALL glitter_emitter_dispose(glitter_emitter* e);

src/CRE/Glitter/emitter_inst.c

@@ -5,19 +5,40 @@
 
 #include "emitter_inst.h"
 #include "curve.h"
-#include "effect_inst.h"
 #include "particle_inst.h"
 #include "random.h"
+#include "../camera.h"
 
-glitter_emitter_inst* FASTCALL glitter_emitter_inst_init(glitter_emitter* a1,
-    glitter_scene* a2, glitter_effect_inst* a3) {
+extern camera* cam;
+
+static void FASTCALL glitter_emitter_inst_emit_particle(GPM,
+    glitter_emitter_inst* a1, float_t emission);
+static void FASTCALL glitter_emitter_inst_get_value(GPM,
+    glitter_emitter_inst* a1, float_t frame);
+static void FASTCALL glitter_emitter_inst_update_mat(GPM,
+    glitter_emitter_inst* a1, glitter_effect_inst* a2);
+
+glitter_emitter_inst* FASTCALL glitter_emitter_inst_init(GPM,
+    glitter_emitter* a1, glitter_effect_inst* a2, float_t emission) {
     glitter_particle** i;
     glitter_particle_inst* particle;
 
+    switch (a1->data.type) {
+    case GLITTER_EMITTER_BOX:
+    case GLITTER_EMITTER_CYLINDER:
+    case GLITTER_EMITTER_SPHERE:
+    case GLITTER_EMITTER_POLYGON:
+        break;
+    default:
+        return 0;
+    }
+
     glitter_emitter_inst* ei = force_malloc(sizeof(glitter_emitter_inst));
     ei->emitter = a1;
 
     ei->data = a1->data;
+    ei->random_ptr = &a2->random_shared;
+    ei->random.step = 1;
     ei->translation = a1->translation;
     ei->rotation = a1->rotation;
     ei->scale = a1->scale;
@@ -26,56 +47,239 @@ glitter_emitter_inst* FASTCALL glitter_emitter_inst_init(glitter_emitter* a1,
     ei->scale_all = 1.0f;
     ei->emission_interval = ei->data.emission_interval;
     ei->particles_per_emission = ei->data.particles_per_emission;
-    ei->frame = -ei->data.start_time;
+    ei->frame = (float_t)-ei->data.start_time;
     if (ei->data.emission_interval >= -0.000001f)
         ei->emission = fabs(ei->data.emission_interval) <= 0.000001f
         ? GLITTER_EMITTER_EMISSION_ON_START : GLITTER_EMITTER_EMISSION_ON_TIMER;
     else
         ei->emission = GLITTER_EMITTER_EMISSION_ON_END;
-    ei->loop = ei->data.flags & GLITTER_EMITTER_FLAG_LOOP ? true : false;
+    ei->loop = ei->data.flags & GLITTER_EMITTER_LOOP ? true : false;
 
-    vector_ptr_glitter_particle_inst_resize(&ei->particles, a1->particles.end - a1->particles.begin);
+    vector_ptr_glitter_particle_inst_append(&ei->particles, a1->particles.end - a1->particles.begin);
     for (i = a1->particles.begin; i != a1->particles.end; i++) {
         if (!*i)
             continue;
 
-        particle = glitter_particle_inst_init(*i, a2, a3);
+        particle = glitter_particle_inst_init(GPM_VAL, *i, a2, ei, ei->random_ptr, emission);
         vector_ptr_glitter_particle_inst_push_back(&ei->particles, &particle);
     }
 
-    ei->random = glitter_random_get();
-    glitter_random_set(glitter_random_get() + 1);
+    ei->random.value = glitter_random_get_value(ei->random_ptr);
+    glitter_random_step_value(ei->random_ptr);
     return ei;
 }
 
-void FASTCALL glitter_emitter_inst_copy(glitter_emitter_inst* a1, glitter_emitter_inst* a2, glitter_scene* a3) {
-    int64_t particles_count; // rbp
-    int64_t i; // rbx
+void FASTCALL glitter_emitter_inst_free(GPM, glitter_emitter_inst* a1, float_t emission) {
+    glitter_particle_inst** i;
 
-    a2->translation = a1->translation;
-    a2->rotation = a1->rotation;
-    a2->scale = a1->scale;
-    a2->mat = a1->mat;
-    a2->mat_no_scale = a1->mat_no_scale;
-    a2->scale_all = a1->scale_all;
-    a2->emission_timer = a1->emission_timer;
-    a2->emission_interval = a1->emission_interval;
-    a2->particles_per_emission = a1->particles_per_emission;
-    a2->random = a1->random;
-    a2->loop = a1->loop;
-    a2->emission = a1->emission;
-    a2->frame = a1->frame;
-    a2->ended = a1->ended;
-
-    particles_count = a1->particles.end - a1->particles.begin;
-    if (particles_count != a2->particles.end - a2->particles.begin)
+    if (a1->ended)
         return;
 
-    for (i = 0; i < particles_count; ++i)
-        glitter_particle_inst_copy(a1->particles.begin[i], a2->particles.begin[i], a3);
+    if (a1->emission == GLITTER_EMITTER_EMISSION_ON_END) {
+        glitter_emitter_inst_emit_particle(GPM_VAL, a1, emission);
+        a1->emission = GLITTER_EMITTER_EMISSION_EMITTED;
+    }
+
+    if (a1->loop && a1->data.loop_end_time >= 0.0f)
+        a1->loop = false;
+
+    a1->ended = true;
+    if (a1->data.flags & GLITTER_EMITTER_KILL_ON_END)
+        for (i = a1->particles.begin; i != a1->particles.end; ++i)
+            glitter_particle_inst_free(*i, true);
+    else
+        for (i = a1->particles.begin; i != a1->particles.end; ++i)
+            glitter_particle_inst_free(*i, false);
 }
 
-void FASTCALL glitter_emitter_inst_emit(glitter_emitter_inst* a1, glitter_scene* a2) {
+void FASTCALL glitter_emitter_inst_emit(GPM,
+    glitter_emitter_inst* a1, float_t delta_frame, float_t emission) {
+    if (a1->frame < 0.0f) {
+        a1->frame += delta_frame;
+        return;
+    }
+
+    if (!a1->ended) {
+        if (a1->emission == GLITTER_EMITTER_EMISSION_ON_TIMER) {
+            if (a1->emission_timer >= 0.0f || a1->emission_interval >= 0.0f) {
+                a1->emission_timer -= delta_frame;
+                while (a1->emission_timer <= 0.0) {
+                    glitter_emitter_inst_emit_particle(GPM_VAL, a1, emission);
+                    if (a1->emission_interval > 0.0f)
+                        a1->emission_timer += a1->emission_interval;
+                    else
+                        a1->emission_timer = -1.0;
+                }
+            }
+        }
+        else if (a1->emission == GLITTER_EMITTER_EMISSION_ON_START && a1->data.timer == GLITTER_EMITTER_TIMER_BY_TIME) {
+            a1->emission_timer -= delta_frame;
+            if (a1->emission_timer < 0.0) {
+                glitter_emitter_inst_emit_particle(GPM_VAL, a1, emission);
+                a1->emission = GLITTER_EMITTER_EMISSION_EMITTED;
+            }
+        }
+    }
+
+    if (!a1->loop && a1->frame >= a1->data.life_time)
+        glitter_emitter_inst_free(GPM_VAL, a1, emission);
+    a1->frame += delta_frame;
+}
+
+void FASTCALL glitter_emitter_inst_get_mesh_by_type(GPM, glitter_emitter_inst* a1,
+    int32_t index, vec3* scale, vec3* base_translation, vec3* direction, glitter_random* random) {
+    float_t radius;
+    float_t angle;
+    float_t longitude;
+    float_t latitude;
+    vec3 dir;
+
+    switch (a1->data.type) {
+    case GLITTER_EMITTER_BOX:
+        vec3_mult(a1->data.box.size, *scale, dir);
+        vec3_mult_scalar(dir, 0.5f, dir);
+        glitter_random_get_vec3(GPM_VAL, random, &dir, base_translation);
+        break;
+    case GLITTER_EMITTER_CYLINDER:
+        radius = a1->data.cylinder.radius * scale->x;
+        if (!a1->data.cylinder.on_edge)
+            radius = glitter_random_get_float_min_max(GPM_VAL, random, 0.0f, radius);
+        angle = glitter_random_get_float_min_max(GPM_VAL, random,
+            a1->data.cylinder.start_angle, a1->data.cylinder.end_angle);
+        dir.x = cosf(angle);
+        dir.y = 0.0f;
+        dir.z = sinf(angle);
+        base_translation->x = dir.x * radius;
+        base_translation->y = glitter_random_get_float(GPM_VAL, random,
+            a1->data.cylinder.height * scale->y * 0.5f);
+        base_translation->z = dir.z * radius;
+        if (a1->data.cylinder.direction == GLITTER_EMITTER_EMISSION_DIRECTION_OUTWARD)
+            *direction = dir;
+        else if (a1->data.cylinder.direction == GLITTER_EMITTER_EMISSION_DIRECTION_INWARD)
+            vec3_xor(dir, ((vec3){ -0.0f, 0.0f, -0.0f }), *direction);
+        break;
+    case GLITTER_EMITTER_SPHERE:
+        radius = a1->data.sphere.radius * scale->x;
+        if (!a1->data.sphere.on_edge)
+            radius = glitter_random_get_float_min_max(GPM_VAL, random, 0.0f, radius);
+        longitude = glitter_random_get_float_min_max(GPM_VAL, random,
+            a1->data.sphere.longitude * -0.5f, a1->data.sphere.longitude * 0.5f);
+        latitude = (float_t)M_PI_2 - glitter_random_get_float_min_max(GPM_VAL, random,
+            0.0f, a1->data.sphere.latitude);
+        dir.x = sinf(longitude) * cosf(latitude);
+        dir.y = sinf(latitude);
+        dir.z = cosf(longitude) * cosf(latitude);
+        vec3_mult_scalar(dir, radius, *base_translation);
+        if (a1->data.sphere.direction == GLITTER_EMITTER_EMISSION_DIRECTION_OUTWARD)
+            *direction = dir;
+        else if (a1->data.sphere.direction == GLITTER_EMITTER_EMISSION_DIRECTION_INWARD)
+            vec3_negate(dir, *direction);
+        break;
+    case GLITTER_EMITTER_POLYGON:
+        base_translation->x = sinf((float_t)index / (float_t)a1->data.polygon.count * 2.0f
+            * (float_t)M_PI + (float_t)M_PI_2) * a1->data.polygon.size * scale->x;
+        base_translation->y = 0.0f;
+        break;
+    }
+}
+
+bool FASTCALL glitter_emitter_inst_has_ended(glitter_emitter_inst* emitter, bool a2) {
+    glitter_particle_inst** i;
+
+    if (!emitter->ended)
+        return false;
+    else if (!a2)
+        return true;
+
+    for (i = emitter->particles.begin; i != emitter->particles.end; i++)
+        if (!glitter_particle_inst_has_ended(*i, a2))
+            return false;
+    return true;
+}
+
+uint8_t FASTCALL glitter_emitter_inst_random_get_step(glitter_emitter_inst* emitter) {
+    emitter->random.step++;
+    emitter->random.step++;
+    return (uint8_t)(emitter->random.step % 60);
+}
+
+void FASTCALL glitter_emitter_inst_reset(glitter_emitter_inst* a1) {
+    glitter_particle_inst** i;
+
+    a1->loop = a1->data.flags & GLITTER_EMITTER_LOOP ? true : false;
+    a1->frame = (float_t)-a1->data.start_time;
+    a1->ended = false;
+    a1->emission_timer = 0.0f;
+    if (a1->emission_interval >= -0.000001f)
+        a1->emission = fabsf(a1->emission_interval) <= 0.000001f
+        ? GLITTER_EMITTER_EMISSION_ON_START : GLITTER_EMITTER_EMISSION_ON_TIMER;
+    else
+        a1->emission = GLITTER_EMITTER_EMISSION_ON_END;
+
+    for (i = a1->particles.begin; i != a1->particles.end; ++i)
+        glitter_particle_inst_reset(*i);
+}
+
+void FASTCALL glitter_emitter_inst_update_value_frame(GPM,
+    glitter_emitter_inst* a1, glitter_effect_inst* a2, float_t delta_frame) {
+    vec3 rotation_add;
+
+    if (a1->frame < 0.0f)
+        return;
+
+    if (a1->loop) {
+        if (a1->data.loop_end_time < 0.0f || a1->frame < a1->data.loop_end_time) {
+            if (a1->frame >= a1->data.life_time) {
+                a1->frame -= a1->data.life_time;
+                if (a1->emission == GLITTER_EMITTER_EMISSION_EMITTED && a1->emission_interval > 0.0f)
+                    a1->emission = GLITTER_EMITTER_EMISSION_ON_TIMER;
+            }
+        }
+        else
+            while (a1->frame > a1->data.loop_end_time)
+                a1->frame -= a1->data.loop_end_time - a1->data.loop_start_time;
+    }
+
+    glitter_emitter_inst_get_value(GPM_VAL, a1, a1->frame);
+    vec3_mult_scalar(a1->data.rotation_add, delta_frame, rotation_add);
+    vec3_add(a1->rotation, rotation_add, a1->rotation);
+    glitter_emitter_inst_update_mat(GPM_VAL, a1, a2);
+}
+
+void FASTCALL glitter_emitter_inst_update_value_init(GPM,
+    glitter_emitter_inst* a1, glitter_effect_inst* a2, float_t delta_frame) {
+    vec3 rotation_add;
+
+    a1->has_distance = false;
+    if (a1->frame < 0.0f)
+        return;
+
+    if (a1->loop) {
+        if (a1->data.loop_end_time < 0.0f || a1->frame < a1->data.loop_end_time) {
+            if (a1->frame >= a1->data.life_time)
+                a1->frame -= a1->data.life_time;
+        }
+        else
+            while (a1->frame > a1->data.loop_end_time)
+                a1->frame -= a1->data.loop_end_time - a1->data.loop_start_time;
+    }
+
+    if (a1->frame < 0.0f)
+        return;
+
+    glitter_emitter_inst_get_value(GPM_VAL, a1, a1->frame);
+    vec3_mult_scalar(a1->data.rotation_add, delta_frame, rotation_add);
+    vec3_add(a1->rotation, rotation_add, a1->rotation);
+    glitter_emitter_inst_update_mat(GPM_VAL, a1, a2);
+}
+
+void FASTCALL glitter_emitter_inst_dispose(glitter_emitter_inst* ei) {
+    vector_ptr_glitter_particle_inst_free(&ei->particles, glitter_particle_inst_dispose);
+    free(ei);
+}
+
+static void FASTCALL glitter_emitter_inst_emit_particle(GPM,
+    glitter_emitter_inst* a1, float_t emission) {
     int32_t count;
     glitter_particle_inst** i;
 
@@ -85,173 +289,11 @@ void FASTCALL glitter_emitter_inst_emit(glitter_emitter_inst* a1, glitter_scene*
         count = 1;
 
     for (i = a1->particles.begin; i != a1->particles.end; ++i)
-        glitter_particle_inst_emit(*i, a2, a1, (int32_t)a1->particles_per_emission, count);
+        glitter_particle_inst_emit(GPM_VAL, *i, (int32_t)roundf(a1->particles_per_emission), count, emission);
 }
 
-void FASTCALL glitter_emitter_inst_emit_init(glitter_emitter_inst* a1,
-    glitter_scene* a2, glitter_effect_inst* a3, float_t delta_frame) {
-    if (a1->frame < 0.0f) {
-        a1->frame += delta_frame;
-        return;
-    }
-
-    if (!a1->ended) {
-        if (a1->emission == GLITTER_EMITTER_EMISSION_ON_TIMER) {
-            if (a1->emission_timer >= 0.0f || a1->emission_interval >= 0.0f) {
-                a1->emission_timer -= delta_frame;
-                if (a1->emission_timer <= 0.0f) {
-                    glitter_effect_inst_update_mat(a3);
-                    glitter_emitter_inst_emit(a1, a2);
-                    if (a1->emission_interval > 0.0f)
-                        a1->emission_timer += a1->emission_interval;
-                    else
-                        a1->emission_timer = -1.0f;
-                }
-            }
-        }
-        else if (a1->emission == GLITTER_EMITTER_EMISSION_ON_START) {
-            glitter_effect_inst_update_mat(a3);
-            glitter_emitter_inst_emit(a1, a2);
-            a1->emission = GLITTER_EMITTER_EMISSION_EMITTED;
-        }
-    }
-
-    if (!a1->loop && a1->data.life_time <= a1->frame)
-        glitter_emitter_inst_free(a1, a2, 0);
-
-    a1->frame += delta_frame;
-}
-
-void FASTCALL glitter_emitter_inst_emit_step(glitter_emitter_inst* a1,
-    glitter_scene* a2, glitter_effect_inst* a3, float_t delta_frame) {
-    if (a1->frame < 0.0f) {
-        a1->frame += delta_frame;
-        return;
-    }
-
-    if (!a1->ended) {
-        if (a1->emission == GLITTER_EMITTER_EMISSION_ON_TIMER) {
-            if (a1->emission_timer >= 0.0f || a1->emission_interval >= 0.0f) {
-                a1->emission_timer -= delta_frame;
-                if (a1->emission_timer <= 0.0f) {
-                    glitter_emitter_inst_emit(a1, a2);
-                    if (a1->emission_interval > 0.0f)
-                        a1->emission_timer += a1->emission_interval;
-                    else
-                        a1->emission_timer = -1.0f;
-                }
-            }
-        }
-        else if (a1->emission == GLITTER_EMITTER_EMISSION_ON_START) {
-            a1->emission_timer -= delta_frame;
-            if (a1->emission_timer <= 0.0f) {
-                glitter_emitter_inst_emit(a1, a2);
-                a1->emission = GLITTER_EMITTER_EMISSION_EMITTED;
-            }
-        }
-    }
-
-    if (!a1->loop && a1->data.life_time <= a1->frame)
-        glitter_emitter_inst_free(a1, a2, 0);
-
-    a1->frame += delta_frame;
-}
-
-void FASTCALL glitter_emitter_inst_free(glitter_emitter_inst* a1, glitter_scene* a2, bool free) {
-    glitter_particle_inst** i;
-
-    if (a1->ended) {
-        if (free)
-            for (i = a1->particles.begin; i != a1->particles.end; ++i)
-                glitter_particle_inst_free(*i, true);
-    }
-    else {
-        if (a1->emission == GLITTER_EMITTER_EMISSION_ON_END) {
-            glitter_emitter_inst_emit(a1, a2);
-            a1->emission = GLITTER_EMITTER_EMISSION_EMITTED;
-        }
-
-        if (a1->loop && a1->data.loop_end_time >= 0.0f)
-            a1->loop = false;
-
-        a1->ended = true;
-        for (i = a1->particles.begin; i != a1->particles.end; ++i)
-            glitter_particle_inst_free(*i, false);
-    }
-}
-
-void FASTCALL glitter_emitter_inst_get_mesh_by_type(glitter_emitter_inst* a1,
-    int32_t index, vec3* scale, vec3* base_translation, vec3* direction) {
-    float_t radius; // xmm8_4
-    float_t angle; // xmm6_4
-    float_t v15; // xmm7_4
-    float_t v16; // xmm0_4
-    float_t v17; // xmm2_4
-    float_t v18; // xmm7_4
-    float_t v19; // xmm6_4
-    float_t longitude; // xmm8_4
-    float_t latitude; // xmm6_4
-    float_t v26; // xmm7_4
-    vec3 v27;
-
-    switch (a1->data.type) {
-    case GLITTER_EMITTER_BOX:
-        base_translation->x = glitter_random_get_float_clamp_min_max(a1->data.box.size.x * scale->x * 0.5f);
-        base_translation->y = glitter_random_get_float_clamp_min_max(a1->data.box.size.y * scale->y * 0.5f);
-        base_translation->z = glitter_random_get_float_clamp_min_max(a1->data.box.size.z * scale->z * 0.5f);
-        break;
-    case GLITTER_EMITTER_CYLINDER:
-        radius = a1->data.cylinder.radius * scale->x;
-        if (!a1->data.cylinder.plain)
-            radius = glitter_random_get_float_clamp(0.0f, radius);
-        angle = glitter_random_get_float_clamp(a1->data.cylinder.start_angle, a1->data.cylinder.end_angle);
-        v15 = cosf(angle);
-        v16 = sinf(angle);
-        v17 = 1.0f / sqrtf(v16 * v16 + v15 * v15);
-        v18 = v15 * v17;
-        v19 = v16 * v17;
-        base_translation->x = v18 * radius;
-        base_translation->y = glitter_random_get_float_clamp_min_max(a1->data.cylinder.height * scale->y * 0.5f);
-        base_translation->z = v19 * radius;
-        if (a1->data.cylinder.direction == GLITTER_EMITTER_EMISSION_DIRECTION_INWARD) {
-            direction->x = v18;
-            direction->y = 0.0f;
-            direction->z = v19;
-        }
-        else if(a1->data.cylinder.direction == GLITTER_EMITTER_EMISSION_DIRECTION_OUTWARD) {
-            direction->x = -v18;
-            direction->y = 0.0f;
-            direction->z = -v19;
-        }
-        break;
-    case GLITTER_EMITTER_SPHERE:
-        radius = a1->data.sphere.radius * scale->x;
-        if (!a1->data.sphere.plain)
-            radius = glitter_random_get_float_clamp(0.0f, radius);
-        longitude = glitter_random_get_float_clamp(a1->data.sphere.longitude * -0.5f,
-            a1->data.sphere.longitude * 0.5f);
-        latitude = (float_t)M_PI_2 - glitter_random_get_float_clamp(0.0f, a1->data.sphere.latitude);
-        v26 = cosf(latitude);
-        v27.x = sinf(longitude) * v26;
-        v27.y = sinf(latitude);
-        v27.z = cosf(longitude) * v26;
-        vec3_mult_scalar(v27, radius, *base_translation);
-        if (a1->data.sphere.direction == GLITTER_EMITTER_EMISSION_DIRECTION_INWARD)
-            *direction = v27;
-        else if (a1->data.sphere.direction == GLITTER_EMITTER_EMISSION_DIRECTION_OUTWARD)
-            vec3_negate(v27, *direction);
-        break;
-    case GLITTER_EMITTER_MESH:
-        break;
-    case GLITTER_EMITTER_POLYGON:
-        base_translation->x = sinf(((float_t)index / (float_t)a1->data.polygon.count * 2.0f)
-            / (float_t)M_PI + (float_t)M_PI_2) * a1->data.polygon.scale * scale->x;
-        base_translation->y = 0.0f;
-        break;
-    }
-}
-
-void FASTCALL glitter_emitter_inst_get_value(glitter_emitter_inst* a1, float_t frame, int32_t random) {
+static void FASTCALL glitter_emitter_inst_get_value(GPM,
+    glitter_emitter_inst* a1, float_t frame) {
     int64_t length;
     glitter_curve* curve;
     float_t value;
@@ -262,7 +304,7 @@ void FASTCALL glitter_emitter_inst_get_value(glitter_emitter_inst* a1, float_t f
 
     for (int32_t i = 0; i < length; i++) {
         curve = a1->emitter->curve.begin[i];
-        if (!glitter_curve_get_value(curve, frame, &value, random + i))
+        if (!glitter_curve_get_value(GPM_VAL, curve, frame, &value, a1->random.value + i, a1->random_ptr))
             continue;
 
         switch (curve->type) {
@@ -306,208 +348,49 @@ void FASTCALL glitter_emitter_inst_get_value(glitter_emitter_inst* a1, float_t f
     }
 }
 
-bool FASTCALL glitter_emitter_inst_has_ended(glitter_emitter_inst* emitter, bool a2) {
-    glitter_particle_inst** i;
-
-    if (!emitter->ended)
-        return false;
-    else if (!a2)
-        return true;
-
-    for (i = emitter->particles.begin; i != emitter->particles.end; i++)
-        if (!glitter_particle_inst_has_ended(*i, a2))
-            return false;
-    return true;
-}
-
-void FASTCALL glitter_emitter_inst_render_group_init(glitter_emitter_inst* emitter, float_t delta_frame) {
-    glitter_particle_inst** i;
-
-    for (i = emitter->particles.begin; i != emitter->particles.end; ++i)
-        glitter_particle_inst_render_group_init(*i, delta_frame);
-}
-
-void FASTCALL glitter_emitter_inst_reset(glitter_emitter_inst* a1) {
-    glitter_particle_inst** i; // rbx
-
-    a1->loop = a1->data.flags & GLITTER_EMITTER_FLAG_LOOP ? true : false;
-    a1->frame = 0.0f;
-    a1->ended = false;
-    if (a1->emission_interval >= -0.000001f)
-        a1->emission = fabsf(a1->emission_interval) <= 0.000001f
-        ? GLITTER_EMITTER_EMISSION_ON_START : GLITTER_EMITTER_EMISSION_ON_TIMER;
-    else
-        a1->emission = GLITTER_EMITTER_EMISSION_ON_END;
-
-    for (i = a1->particles.begin; i != a1->particles.end; ++i)
-        glitter_particle_inst_reset(*i);
-}
-
-void FASTCALL glitter_emitter_inst_update_mat(glitter_emitter_inst* a1, glitter_effect_inst* a2) {
+static void FASTCALL glitter_emitter_inst_update_mat(GPM,
+    glitter_emitter_inst* a1, glitter_effect_inst* a2) {
+    bool mult;
+    vec3 trans;
+    vec3 rot;
     vec3 scale;
-    bool v12; // bl
-    int64_t v14; // rax
-    int64_t v15; // r14
-    glitter_particle_inst* v17; // rbx
-    mat4 mat1;
-    mat4 mat2;
+    mat4 mat;
+    mat4 direction_mat;
 
+    trans = a1->translation;
+    rot = a1->rotation;
     vec3_mult_scalar(a1->scale, a1->scale_all, scale);
-    mat1 = a2->mat;
 
-    v12 = true;
+    mult = true;
     switch (a1->data.direction) {
-    case GLITTER_DIRECTION_BILLBOARD:
-        mat2 = cam->view;
-        mat2.row3 = (vec4){ 0.0f, 0.0f, 0.0f, 1.0f };
-        mat4_inverse(&mat2, &mat2);
-        mat4_mult(&mat1, &mat2, &mat2);
-        mat2.row3 = (vec4){ 0.0f, 0.0f, 0.0f, 1.0f };
-        break;
+    case GLITTER_DIRECTION_BILLBOARD: {
+        mat4_invrot(&cam->view, &direction_mat);
+        direction_mat.row3 = (vec4){ 0.0f, 0.0f, 0.0f, 1.0f };
+        mat4_mult(&a2->mat, &direction_mat, &direction_mat);
+        direction_mat.row3 = (vec4){ 0.0f, 0.0f, 0.0f, 1.0f };
+    } break;
     case GLITTER_DIRECTION_Y_AXIS:
-        mat4_rotate_y((float_t)-M_PI_2, &mat2);
+        mat4_rotate_y((float_t)-M_PI_2, &direction_mat);
         break;
     case GLITTER_DIRECTION_X_AXIS:
-        mat4_rotate_x((float_t)-M_PI_2, &mat2);
+        mat4_rotate_x((float_t)-M_PI_2, &direction_mat);
         break;
     case GLITTER_DIRECTION_Z_AXIS:
-        mat4_rotate_z((float_t)-M_PI_2, &mat2);
+        mat4_rotate_z((float_t)-M_PI_2, &direction_mat);
         break;
     case GLITTER_DIRECTION_BILLBOARD_Y_ONLY:
-        mat4_rotate_y(cam->rotation.y, &mat2);
+        mat4_rotate_y(cam->rotation.y, &direction_mat);
         break;
     default:
-        v12 = false;
+        mult = false;
         break;
     }
 
-    mat4_translate_mult(&mat1, a1->translation.x, a1->translation.y, a1->translation.z, &mat1);
-    mat4_normalize_rotation(&mat1, &mat1);
-    if (v12)
-        mat4_mult(&mat2, &mat1, &mat1);
-    mat4_rot(&mat1, a1->rotation.x, a1->rotation.y, a1->rotation.z, &mat1);
-    a1->mat_no_scale = mat1;
-    mat4_scale_rot(&mat1, scale.x, scale.y, scale.z, &a1->mat);
-
-    v14 = a1->particles.end - a1->particles.begin;
-    for (v15 = 0; v14 > 0; v15++, v14--) {
-        if (!a1->particles.begin[v15])
-            continue;
-
-        v17 = a1->particles.begin[v15];
-        v17->mat = a1->mat;
-        v17->mat_no_scale = a1->mat_no_scale;
-        v17->mat_no_scale.row3 = (vec4){ 0.0f, 0.0f, 0.0f, 1.0f };
-        glitter_particle_inst_set_mat(v17);
-    }
-}
-
-void FASTCALL glitter_emitter_inst_update_value_frame(glitter_emitter_inst* a1,
-    glitter_effect_inst* a2, float_t delta_frame) {
-    int64_t v7; // r14
-    vec3 rotation_add;
-    vec3 scale;
-    bool v22; // si
-    int64_t v24; // rbp
-    glitter_particle_inst* v26; // rsi
-    mat4 mat1;
-    mat4 mat2;
-
-    if (a1->frame < 0.0f)
-        return;
-
-    if (a1->loop) {
-        if (a1->data.loop_end_time < 0.0f || a1->frame < a1->data.loop_end_time) {
-            if (a1->frame >= a1->data.life_time) {
-                a1->frame -= a1->data.life_time;
-                if (a1->emission == GLITTER_EMITTER_EMISSION_EMITTED && a1->emission_interval > 0.0f)
-                    a1->emission = GLITTER_EMITTER_EMISSION_ON_TIMER;
-            }
-        }
-        else
-            while (a1->frame > a1->data.loop_end_time)
-                a1->frame -= a1->data.loop_end_time - a1->data.loop_start_time;
-    }
-
-    glitter_emitter_inst_get_value(a1, a1->frame, a1->random);
-    vec3_mult_scalar(a1->data.rotation_add, delta_frame, rotation_add);
-    vec3_add(a1->rotation, rotation_add, a1->rotation);
-
-    vec3_mult_scalar(a1->scale, a1->scale_all, scale);
-    mat1 = a2->mat;
-
-    v22 = true;
-    switch (a1->data.direction) {
-    case GLITTER_DIRECTION_BILLBOARD:
-        mat2 = cam->view;
-        mat2.row3 = (vec4){ 0.0f, 0.0f, 0.0f, 1.0f };
-        mat4_inverse(&mat2, &mat2);
-        mat4_mult(&mat1, &mat2, &mat2);
-        mat2.row3 = (vec4){ 0.0f, 0.0f, 0.0f, 1.0f };
-        break;
-    case GLITTER_DIRECTION_Y_AXIS:
-        mat4_rotate_y((float_t)-M_PI_2, &mat2);
-        break;
-    case GLITTER_DIRECTION_X_AXIS:
-        mat4_rotate_x((float_t)-M_PI_2, &mat2);
-        break;
-    case GLITTER_DIRECTION_Z_AXIS:
-        mat4_rotate_z((float_t)-M_PI_2, &mat2);
-        break;
-    case GLITTER_DIRECTION_BILLBOARD_Y_ONLY:
-        mat4_rotate_y(cam->rotation.y, &mat2);
-        break;
-    default:
-        v22 = false;
-        break;
-    }
-
-    mat4_translate_mult(&mat1, a1->translation.x, a1->translation.y, a1->translation.z, &mat1);
-    mat4_normalize_rotation(&mat1, &mat1);
-    if (v22)
-        mat4_mult(&mat2, &mat1, &mat1);
-    mat4_rot(&mat1, a1->rotation.x, a1->rotation.y, a1->rotation.z, &mat1);
-    a1->mat_no_scale = mat1;
-    mat4_scale_rot(&mat1, scale.x, scale.y, scale.z, &a1->mat);
-
-    v24 = a1->particles.end - a1->particles.begin;
-    for (v7 = 0; v24 > 0; v7++, v24--) {
-        if (!a1->particles.begin[v7])
-            continue;
-
-        v26 = a1->particles.begin[v7];
-        v26->mat = a1->mat;
-        v26->mat_no_scale = a1->mat_no_scale;
-        v26->mat_no_scale.row3 = (vec4){ 0.0f, 0.0f, 0.0f, 1.0f };
-        glitter_particle_inst_set_mat(v26);
-    }
-}
-
-void FASTCALL glitter_emitter_inst_update_value_init(glitter_emitter_inst* a1, float_t frame, float_t delta_frame) {
-    vec3 rotation_add;
-
-    if (a1->frame < 0.0f)
-        return;
-
-    if (a1->loop) {
-        if (a1->data.loop_end_time < 0.0f || a1->frame < a1->data.loop_end_time) {
-            if (a1->frame >= a1->data.life_time)
-                a1->frame = a1->frame - a1->data.life_time;
-        }
-        else
-            while (a1->frame > a1->data.loop_end_time)
-                a1->frame -= a1->data.loop_end_time - a1->data.loop_start_time;
-    }
-
-    if (a1->frame < 0.0f)
-        return;
-
-    glitter_emitter_inst_get_value(a1, a1->frame, a1->random);
-    vec3_mult_scalar(a1->data.rotation_add, delta_frame, rotation_add);
-    vec3_add(a1->rotation, rotation_add, a1->rotation);
-}
-
-void FASTCALL glitter_emitter_inst_dispose(glitter_emitter_inst* ei) {
-    vector_ptr_glitter_particle_inst_free(&ei->particles, (void*)glitter_particle_inst_dispose);
-    free(ei);
+    mat4_translate_mult(&a2->mat, trans.x, trans.y, trans.z, &mat);
+    mat4_normalize_rotation(&mat, &mat);
+    if (mult)
+        mat4_mult(&direction_mat, &mat, &mat);
+    mat4_rot(&mat, rot.x, rot.y, rot.z, &mat);
+    mat4_scale_rot(&mat, scale.x, scale.y, scale.z, &a1->mat);
+    a1->mat_no_scale = mat;
 }

src/CRE/Glitter/emitter_inst.h

@@ -7,25 +7,19 @@
 
 #include "glitter.h"
 
-extern glitter_emitter_inst* FASTCALL glitter_emitter_inst_init(glitter_emitter* a1,
-    glitter_scene* a2, glitter_effect_inst* a3);
-extern void FASTCALL glitter_emitter_inst_copy(glitter_emitter_inst* a1,
-    glitter_emitter_inst* a2, glitter_scene* a3);
-extern void FASTCALL glitter_emitter_inst_emit(glitter_emitter_inst* a1, glitter_scene* a2);
-extern void FASTCALL glitter_emitter_inst_emit_init(glitter_emitter_inst* a1,
-    glitter_scene* a2, glitter_effect_inst* a3, float_t delta_frame);
-extern void FASTCALL glitter_emitter_inst_emit_step(glitter_emitter_inst* a1,
-    glitter_scene* a2, glitter_effect_inst* a3, float_t delta_frame);
-extern void FASTCALL glitter_emitter_inst_free(glitter_emitter_inst* a1, glitter_scene* a2, bool free);
-extern void FASTCALL glitter_emitter_inst_get_mesh_by_type(glitter_emitter_inst* a1,
-    int32_t index, vec3* scale, vec3* base_translation, vec3* direction);
-extern void FASTCALL glitter_emitter_inst_get_value(glitter_emitter_inst* a1, float_t frame, int32_t random);
+extern glitter_emitter_inst* FASTCALL glitter_emitter_inst_init(GPM,
+    glitter_emitter* a1, glitter_effect_inst* a2, float_t emission);
+extern void FASTCALL glitter_emitter_inst_free(GPM,
+    glitter_emitter_inst* a1, float_t emission);
+extern void FASTCALL glitter_emitter_inst_emit(GPM,
+    glitter_emitter_inst* a1, float_t delta_frame, float_t emission);
+extern void FASTCALL glitter_emitter_inst_get_mesh_by_type(GPM, glitter_emitter_inst* a1,
+    int32_t index, vec3* scale, vec3* base_translation, vec3* direction, glitter_random* random);
 extern bool FASTCALL glitter_emitter_inst_has_ended(glitter_emitter_inst* emitter, bool a2);
-extern void FASTCALL glitter_emitter_inst_render_group_init(glitter_emitter_inst* emitter, float_t delta_frame);
+extern uint8_t FASTCALL glitter_emitter_inst_random_get_step(glitter_emitter_inst* emitter);
 extern void FASTCALL glitter_emitter_inst_reset(glitter_emitter_inst* a1);
-extern void FASTCALL glitter_emitter_inst_update_mat(glitter_emitter_inst* a1, glitter_effect_inst* a2);
-extern void FASTCALL glitter_emitter_inst_update_value_frame(glitter_emitter_inst* a1,
-    glitter_effect_inst* a2, float_t delta_frame);
-extern void FASTCALL glitter_emitter_inst_update_value_init(glitter_emitter_inst* a1,
-    float_t frame, float_t delta_frame);
+extern void FASTCALL glitter_emitter_inst_update_value_frame(GPM,
+    glitter_emitter_inst* a1, glitter_effect_inst* a2, float_t delta_frame);
+extern void FASTCALL glitter_emitter_inst_update_value_init(GPM,
+    glitter_emitter_inst* a1, glitter_effect_inst* a2, float_t delta_frame);
 extern void FASTCALL glitter_emitter_inst_dispose(glitter_emitter_inst* ei);

src/CRE/Glitter/file_reader.c

@@ -11,79 +11,82 @@
 #include "particle_manager.h"
 #include "scene.h"
 
-glitter_file_reader* FASTCALL glitter_file_reader_init(wchar_t* path,
-    wchar_t* file, bool f2, float_t emission) {
+glitter_file_reader* FASTCALL glitter_file_reader_init(GPM,
+    char* path, char* file, float_t emission) {
     glitter_file_reader* fr = force_malloc(sizeof(glitter_file_reader));
-    fr->path = path_wadd_extension(path ? path : L"rom\\particle\\", 0);
-    fr->file = path_wadd_extension(file ? file : 0, 0);
+    fr->path = char_string_to_wchar_t_string(path ? path : "rom\\particle\\");
+    fr->file = char_string_to_wchar_t_string(file ? file : 0);
     fr->emission = emission;
-    fr->hash = f2
-        ? hash_wchar_t_murmurhash(file, 0, false)
-        : hash_wchar_t_fnv1a64(file);
+    fr->hash = glt_type != GLITTER_AFT
+        ? hash_wchar_t_murmurhash(fr->file, 0, false)
+        : hash_wchar_t_fnv1a64(fr->file);
     return fr;
 }
 
-bool FASTCALL glitter_file_reader_read(glitter_file_reader* fr) {
+glitter_file_reader* FASTCALL glitter_file_reader_winit(GPM,
+    wchar_t* path, wchar_t* file, float_t emission) {
+    glitter_file_reader* fr = force_malloc(sizeof(glitter_file_reader));
+    fr->path = str_utils_wcopy(path ? path : L"rom\\particle\\");
+    fr->file = str_utils_wcopy(file);
+    fr->emission = emission;
+    fr->hash = glt_type != GLITTER_AFT
+        ? hash_wchar_t_murmurhash(fr->file, 0, false)
+        : hash_wchar_t_fnv1a64(fr->file);
+    return fr;
+}
+
+bool FASTCALL glitter_file_reader_read(GPM, glitter_file_reader* fr) {
     farc* f = farc_init();
-    wchar_t* path_temp0;
-    wchar_t* path_temp1;
-    path_temp0 = path_wadd_extension(fr->file, L".farc");
-    path_temp1 = path_wadd_extension(fr->path, path_temp0);
-    free(path_temp0);
-    farc_wread(f, path_temp1, true, false);
-    free(path_temp1);
+    wchar_t* file_temp;
+    wchar_t* path_temp;
+    file_temp = str_utils_wadd(fr->file, L".farc");
+    path_temp = str_utils_wadd(fr->path, file_temp);
+    free(file_temp);
+    farc_wread(f, path_temp, true, false);
+    free(path_temp);
 
     farc_file* ff;
     bool ret = false;
-    path_temp0 = path_wadd_extension(fr->file, L".dve");
-    ff = farc_wread_file(f, path_temp0);
-    free(path_temp0);
+    file_temp = str_utils_wadd(fr->file, L".dve");
+    ff = farc_wread_file(f, file_temp);
+    free(file_temp);
     if (!ff)
         goto End;
 
-    f2_struct* st;
-    st = f2_struct_init();
-    f2_struct_read_memory(st, ff->data, ff->size_uncompressed);
-    if (st->header.signature == 0x46455644)
-        ret = glitter_diva_effect_parse_file(fr, st);
+    f2_struct st;
+    f2_struct_read_memory(&st, ff->data, ff->size);
+    if (st.header.signature == 0x46455644)
+        ret = glitter_diva_effect_parse_file(GPM_VAL, fr, &st);
     else
         ret = false;
-    f2_struct_dispose(st);
+    f2_struct_free(&st);
 
     if (!ret)
         goto End;
 
-    path_temp0 = path_wadd_extension(fr->file, L".drs");
-    ff = farc_wread_file(f, path_temp0);
-    free(path_temp0);
+    file_temp = str_utils_wadd(fr->file, L".drs");
+    ff = farc_wread_file(f, file_temp);
+    free(file_temp);
 
-    ret = false;
-    if (!ff)
-        goto End;
+    if (ff) {
+        f2_struct st;
+        f2_struct_read_memory(&st, ff->data, ff->size);
+        if (st.header.signature == 0x53525644)
+            glitter_diva_resource_parse_file(fr->effect_group, &st);
+        f2_struct_free(&st);
+    }
 
-    st = f2_struct_init();
-    f2_struct_read_memory(st, ff->data, ff->size_uncompressed);
-    if (st->header.signature == 0x53525644)
-        ret = glitter_diva_resource_parse_file(fr->effect_group, st);
-    else
-        ret = false;
-    f2_struct_dispose(st);
+    file_temp = str_utils_wadd(fr->file, L".lst");
+    ff = farc_wread_file(f, file_temp);
+    free(file_temp);
 
-    if (!ret)
-        goto End;
-
-    path_temp0 = path_wadd_extension(fr->file, L".lst");
-    ff = farc_wread_file(f, path_temp0);
-    free(path_temp0);
-
-    if (!ff)
-        goto End;
-
-    st = f2_struct_init();
-    f2_struct_read_memory(st, ff->data, ff->size_uncompressed);
-    if (st->header.signature == 0x5453494C)
-        glitter_diva_list_parse_file(fr->effect_group, st);
-    f2_struct_dispose(st);
+    if (ff) {
+        f2_struct st;
+        f2_struct_read_memory(&st, ff->data, ff->size);
+        if (st.header.signature == 0x5453494C)
+            glitter_diva_list_parse_file(fr->effect_group, &st);
+        f2_struct_free(&st);
+    }
 
 End:
     farc_dispose(f);

src/CRE/Glitter/file_reader.h

@@ -7,7 +7,9 @@
 
 #include "glitter.h"
 
-extern glitter_file_reader* FASTCALL glitter_file_reader_init(wchar_t* path,
-    wchar_t* file, bool f2, float_t emission);
-extern bool FASTCALL glitter_file_reader_read(glitter_file_reader* fr);
+extern glitter_file_reader* FASTCALL glitter_file_reader_init(GPM,
+    char* path, char* file, float_t emission);
+extern glitter_file_reader* FASTCALL glitter_file_reader_winit(GPM,
+    wchar_t* path, wchar_t* file, float_t emission);
+extern bool FASTCALL glitter_file_reader_read(GPM, glitter_file_reader* fr);
 extern void FASTCALL glitter_file_reader_dispose(glitter_file_reader* fr);

src/CRE/Glitter/glitter.c

@@ -18,3 +18,37 @@ vector_ptr_func(glitter_particle)
 vector_ptr_func(glitter_particle_inst)
 vector_ptr_func(glitter_render_group)
 vector_ptr_func(glitter_scene)
+
+const float_t glitter_min_emission = 0.01f;
+
+const glitter_curve_type_flags glitter_effect_curve_flags = 0
+    | GLITTER_CURVE_TYPE_TRANSLATION_XYZ
+    | GLITTER_CURVE_TYPE_ROTATION_XYZ
+    | GLITTER_CURVE_TYPE_SCALE_XYZ
+    | GLITTER_CURVE_TYPE_SCALE_ALL;
+
+const glitter_curve_type_flags glitter_emitter_curve_flags = 0
+    | GLITTER_CURVE_TYPE_TRANSLATION_XYZ
+    | GLITTER_CURVE_TYPE_ROTATION_XYZ
+    | GLITTER_CURVE_TYPE_SCALE_XYZ
+    | GLITTER_CURVE_TYPE_SCALE_ALL
+    | GLITTER_CURVE_TYPE_EMISSION_INTERVAL
+    | GLITTER_CURVE_TYPE_PARTICLES_PER_EMISSION;
+
+const glitter_curve_type_flags glitter_particle_curve_flags = 0
+    | GLITTER_CURVE_TYPE_TRANSLATION_XYZ
+    | GLITTER_CURVE_TYPE_ROTATION_XYZ
+    | GLITTER_CURVE_TYPE_SCALE_XYZ
+    | GLITTER_CURVE_TYPE_SCALE_ALL
+    | GLITTER_CURVE_TYPE_COLOR_RGBA
+    | GLITTER_CURVE_TYPE_UV_SCROLL;
+
+const glitter_curve_type_flags glitter_particle_x_curve_flags = 0
+    | GLITTER_CURVE_TYPE_TRANSLATION_XYZ
+    | GLITTER_CURVE_TYPE_ROTATION_XYZ
+    | GLITTER_CURVE_TYPE_SCALE_XYZ
+    | GLITTER_CURVE_TYPE_SCALE_ALL
+    | GLITTER_CURVE_TYPE_COLOR_RGBA
+    | GLITTER_CURVE_TYPE_COLOR_RGB_SCALE
+    | GLITTER_CURVE_TYPE_UV_SCROLL
+    | GLITTER_CURVE_TYPE_UV_SCROLL_2ND;

src/CRE/Glitter/glitter.h

@@ -8,14 +8,14 @@
 #include "shared.h"
 
 typedef enum glitter_curve_flag {
-    GLITTER_CURVE_FLAG_RANDOMIZE       = 0x01,
-    GLITTER_CURVE_FLAG_RANDOM_RANGE    = 0x02,
-    GLITTER_CURVE_FLAG_NEGATIVE_RANDOM = 0x04,
-    GLITTER_CURVE_FLAG_ABSOLUTE        = 0x04,
-    GLITTER_CURVE_FLAG_STEP            = 0x08,
-    GLITTER_CURVE_FLAG_NEGATE          = 0x10,
-    GLITTER_CURVE_FLAG_MULT            = 0x20,
-    GLITTER_CURVE_FLAG_PLAIN           = 0x40,
+    GLITTER_CURVE_RANDOM_RANGE        = 0x01,
+    GLITTER_CURVE_KEY_RANDOM_RANGE    = 0x02,
+    GLITTER_CURVE_RANDOM_RANGE_NEGATE = 0x04,
+    GLITTER_CURVE_STEP                = 0x08,
+    GLITTER_CURVE_NEGATE              = 0x10,
+    GLITTER_CURVE_RANDOM_RANGE_MULT   = 0x20,
+    GLITTER_CURVE_BAKED               = 0x40,
+    GLITTER_CURVE_BAKED_FULL          = 0x80,
 } glitter_curve_flag;
 
 typedef enum glitter_curve_type {
@@ -33,70 +33,129 @@ typedef enum glitter_curve_type {
     GLITTER_CURVE_COLOR_G                = 11,
     GLITTER_CURVE_COLOR_B                = 12,
     GLITTER_CURVE_COLOR_A                = 13,
-    GLITTER_CURVE_UNK14                  = 14,
-    GLITTER_CURVE_UNK15                  = 15,
-    GLITTER_CURVE_UNK16                  = 16,
-    GLITTER_CURVE_UNK17                  = 17,
-    GLITTER_CURVE_UNK18                  = 18,
-    GLITTER_CURVE_UNK19                  = 19,
+    GLITTER_CURVE_COLOR_RGB_SCALE        = 14,
+    GLITTER_CURVE_COLOR_R_2ND            = 15,
+    GLITTER_CURVE_COLOR_G_2ND            = 16,
+    GLITTER_CURVE_COLOR_B_2ND            = 17,
+    GLITTER_CURVE_COLOR_A_2ND            = 18,
+    GLITTER_CURVE_COLOR_RGB_SCALE_2ND    = 19,
     GLITTER_CURVE_EMISSION_INTERVAL      = 20,
     GLITTER_CURVE_PARTICLES_PER_EMISSION = 21,
     GLITTER_CURVE_U_SCROLL               = 22,
     GLITTER_CURVE_V_SCROLL               = 23,
+    GLITTER_CURVE_U_SCROLL_ALPHA         = 24,
+    GLITTER_CURVE_V_SCROLL_ALPHA         = 25,
+    GLITTER_CURVE_U_SCROLL_2ND           = 26,
+    GLITTER_CURVE_V_SCROLL_2ND           = 27,
+    GLITTER_CURVE_U_SCROLL_ALPHA_2ND     = 28,
+    GLITTER_CURVE_V_SCROLL_ALPHA_2ND     = 29,
 } glitter_curve_type;
 
+typedef enum glitter_curve_type_flags {
+    GLITTER_CURVE_TYPE_TRANSLATION_X          = 0x00000001,
+    GLITTER_CURVE_TYPE_TRANSLATION_Y          = 0x00000002,
+    GLITTER_CURVE_TYPE_TRANSLATION_Z          = 0x00000004,
+    GLITTER_CURVE_TYPE_ROTATION_X             = 0x00000008,
+    GLITTER_CURVE_TYPE_ROTATION_Y             = 0x00000010,
+    GLITTER_CURVE_TYPE_ROTATION_Z             = 0x00000020,
+    GLITTER_CURVE_TYPE_SCALE_X                = 0x00000040,
+    GLITTER_CURVE_TYPE_SCALE_Y                = 0x00000080,
+    GLITTER_CURVE_TYPE_SCALE_Z                = 0x00000100,
+    GLITTER_CURVE_TYPE_SCALE_ALL              = 0x00000200,
+    GLITTER_CURVE_TYPE_COLOR_R                = 0x00000400,
+    GLITTER_CURVE_TYPE_COLOR_G                = 0x00000800,
+    GLITTER_CURVE_TYPE_COLOR_B                = 0x00001000,
+    GLITTER_CURVE_TYPE_COLOR_A                = 0x00002000,
+    GLITTER_CURVE_TYPE_COLOR_RGB_SCALE        = 0x00004000,
+    GLITTER_CURVE_TYPE_COLOR_R_2ND            = 0x00008000,
+    GLITTER_CURVE_TYPE_COLOR_G_2ND            = 0x00010000,
+    GLITTER_CURVE_TYPE_COLOR_B_2ND            = 0x00020000,
+    GLITTER_CURVE_TYPE_COLOR_A_2ND            = 0x00040000,
+    GLITTER_CURVE_TYPE_COLOR_RGB_SCALE_2ND    = 0x00080000,
+    GLITTER_CURVE_TYPE_EMISSION_INTERVAL      = 0x00100000,
+    GLITTER_CURVE_TYPE_PARTICLES_PER_EMISSION = 0x00200000,
+    GLITTER_CURVE_TYPE_U_SCROLL               = 0x00400000,
+    GLITTER_CURVE_TYPE_V_SCROLL               = 0x00800000,
+    GLITTER_CURVE_TYPE_U_SCROLL_ALPHA         = 0x01000000,
+    GLITTER_CURVE_TYPE_V_SCROLL_ALPHA         = 0x02000000,
+    GLITTER_CURVE_TYPE_U_SCROLL_2ND           = 0x04000000,
+    GLITTER_CURVE_TYPE_V_SCROLL_2ND           = 0x08000000,
+    GLITTER_CURVE_TYPE_U_SCROLL_ALPHA_2ND     = 0x10000000,
+    GLITTER_CURVE_TYPE_V_SCROLL_ALPHA_2ND     = 0x20000000,
+
+    GLITTER_CURVE_TYPE_TRANSLATION_XYZ     = 0x00000001 | 0x00000002 | 0x00000004,
+    GLITTER_CURVE_TYPE_ROTATION_XYZ        = 0x00000008 | 0x00000010 | 0x00000020,
+    GLITTER_CURVE_TYPE_SCALE_XYZ           = 0x00000040 | 0x00000080 | 0x00000100,
+    GLITTER_CURVE_TYPE_COLOR_RGBA          = 0x00000400 | 0x00000800 | 0x00001000 | 0x00002000,
+    GLITTER_CURVE_TYPE_COLOR_RGBA_2ND      = 0x00008000 | 0x00010000 | 0x00020000 | 0x00040000,
+    GLITTER_CURVE_TYPE_UV_SCROLL           = 0x00400000 | 0x00800000,
+    GLITTER_CURVE_TYPE_UV_SCROLL_ALPHA     = 0x01000000 | 0x02000000,
+    GLITTER_CURVE_TYPE_UV_SCROLL_2ND       = 0x04000000 | 0x08000000,
+    GLITTER_CURVE_TYPE_UV_SCROLL_ALPHA_2ND = 0x10000000 | 0x20000000,
+} glitter_curve_type_flags;
+
 typedef enum glitter_direction {
     GLITTER_DIRECTION_BILLBOARD         = 0,
     GLITTER_DIRECTION_EMITTER_DIRECTION = 1,
-    GLITTER_DIRECTION_TYPE_2_DIR_ANGLE  = 2,
-    GLITTER_DIRECTION_TYPE_3_DIR_ANGLE  = 3,
+    GLITTER_DIRECTION_PREV_POSITION     = 2,
+    GLITTER_DIRECTION_POSITION          = 3,
     GLITTER_DIRECTION_Y_AXIS            = 4,
     GLITTER_DIRECTION_X_AXIS            = 5,
     GLITTER_DIRECTION_Z_AXIS            = 6,
     GLITTER_DIRECTION_BILLBOARD_Y_ONLY  = 7,
-    GLITTER_DIRECTION_TYPE_8_DIR_ANGLE  = 8,
+    GLITTER_DIRECTION_PREV_POSITION_DUP = 8,
     GLITTER_DIRECTION_EMITTER_ROTATION  = 9,
     GLITTER_DIRECTION_EFFECT_ROTATION   = 10,
     GLITTER_DIRECTION_PARTICLE_ROTATION = 11,
 } glitter_direction;
 
-typedef enum glitter_effect_a3da_flag {
-    GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_ONCE            = 0x00001,
-    GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_TRANS_ONLY      = 0x00002,
-    GLITTER_EFFECT_A3DA_FLAG_SET_A3DA_BY_OBJECT_INDEX = 0x10000,
-} glitter_effect_a3da_flag;
+typedef enum glitter_effect_ext_anim_flag {
+    GLITTER_EFFECT_EXT_ANIM_SET_EXT_ANIM_ONCE   = 0x00001,
+    GLITTER_EFFECT_EXT_ANIM_EXT_ANIM_TRANS_ONLY = 0x00002,
+    GLITTER_EFFECT_EXT_ANIM_NO_TRANS_X          = 0x00004,
+    GLITTER_EFFECT_EXT_ANIM_NO_TRANS_Y          = 0x00008,
+    GLITTER_EFFECT_EXT_ANIM_NO_TRANS_Z          = 0x00010,
+    GLITTER_EFFECT_EXT_ANIM_NO_DRAW_IF_NO_DATA  = 0x00020,
+    GLITTER_EFFECT_EXT_ANIM_GET_THEN_UPDATE     = 0x00040,
+    GLITTER_EFFECT_EXT_ANIM_CHARA_ANIM          = 0x10000,
+} glitter_effect_ext_anim_flag;
 
 typedef enum glitter_effect_flag {
-    GLITTER_EFFECT_FLAG_NONE       = 0x00,
-    GLITTER_EFFECT_FLAG_LOOP       = 0x01,
-    GLITTER_EFFECT_FLAG_LOCAL      = 0x02,
-    GLITTER_EFFECT_FLAG_ALPHA      = 0x04,
-    GLITTER_EFFECT_FLAG_FOG        = 0x08,
-    GLITTER_EFFECT_FLAG_FOG_HEIGHT = 0x10,
-    GLITTER_EFFECT_FLAG_EMISSION   = 0x20,
+    GLITTER_EFFECT_NONE       = 0x00,
+    GLITTER_EFFECT_LOOP       = 0x01,
+    GLITTER_EFFECT_LOCAL      = 0x02,
+    GLITTER_EFFECT_ALPHA      = 0x04,
+    GLITTER_EFFECT_FOG        = 0x08,
+    GLITTER_EFFECT_FOG_HEIGHT = 0x10,
+    GLITTER_EFFECT_EMISSION   = 0x20,
+    GLITTER_EFFECT_USE_SEED   = 0x40,
 } glitter_effect_flag;
 
 typedef enum glitter_effect_file_flag {
-    GLITTER_EFFECT_FILE_FLAG_ALPHA      = 0x01,
-    GLITTER_EFFECT_FILE_FLAG_FOG        = 0x02,
-    GLITTER_EFFECT_FILE_FLAG_FOG_HEIGHT = 0x04,
-    GLITTER_EFFECT_FILE_FLAG_EMISSION   = 0x08,
+    GLITTER_EFFECT_FILE_ALPHA      = 0x01,
+    GLITTER_EFFECT_FILE_FOG        = 0x02,
+    GLITTER_EFFECT_FILE_FOG_HEIGHT = 0x04,
+    GLITTER_EFFECT_FILE_EMISSION   = 0x08,
+    GLITTER_EFFECT_FILE_USE_SEED   = 0x10,
 } glitter_effect_file_flag;
 
 typedef enum glitter_effect_inst_flag {
-    GLITTER_EFFECT_INST_FLAG_NONE                     = 0x000,
-    GLITTER_EFFECT_INST_FLAG_FREE                     = 0x001,
-    GLITTER_EFFECT_INST_FLAG_JUST_INIT                = 0x002,
-    GLITTER_EFFECT_INST_FLAG_HAS_A3DA                 = 0x004,
-    GLITTER_EFFECT_INST_FLAG_HAS_A3DA_TRANS           = 0x008,
-    GLITTER_EFFECT_INST_FLAG_HAS_A3DA_NON_INIT        = 0x010,
-    GLITTER_EFFECT_INST_FLAG_SET_A3DA_BY_OBJECT_INDEX = 0x020,
-    GLITTER_EFFECT_INST_FLAG_SET_A3DA_BY_OBJECT_NAME  = 0x040,
-    GLITTER_EFFECT_INST_FLAG_SET_A3DA_ONCE            = 0x080,
-    GLITTER_EFFECT_INST_FLAG_SET_A3DA_TRANS_ONLY      = 0x100,
-    GLITTER_EFFECT_INST_FLAG_SET_MIN_COLOR            = 0x200,
-    GLITTER_EFFECT_INST_FLAG_SET_ADD_MIN_COLOR        = 0x400,
-    GLITTER_EFFECT_INST_FLAG_HAS_A3DA_SCALE           = 0x800,
+    GLITTER_EFFECT_INST_NONE                        = 0x0000,
+    GLITTER_EFFECT_INST_FREE                        = 0x0001,
+    GLITTER_EFFECT_INST_JUST_INIT                   = 0x0002,
+    GLITTER_EFFECT_INST_HAS_EXT_ANIM                = 0x0004,
+    GLITTER_EFFECT_INST_HAS_EXT_ANIM_TRANS          = 0x0008,
+    GLITTER_EFFECT_INST_HAS_EXT_ANIM_NON_INIT       = 0x0010,
+    GLITTER_EFFECT_INST_CHARA_ANIM                  = 0x0020,
+    GLITTER_EFFECT_INST_SET_EXT_ANIM_BY_OBJECT_NAME = 0x0040,
+    GLITTER_EFFECT_INST_SET_EXT_ANIM_ONCE           = 0x0080,
+    GLITTER_EFFECT_INST_EXT_ANIM_TRANS_ONLY         = 0x0100,
+    GLITTER_EFFECT_INST_HAS_EXT_ANIM_SCALE          = 0x0200,
+    GLITTER_EFFECT_INST_NO_EXT_ANIM_TRANS_X         = 0x0400,
+    GLITTER_EFFECT_INST_NO_EXT_ANIM_TRANS_Y         = 0x0800,
+    GLITTER_EFFECT_INST_NO_EXT_ANIM_TRANS_Z         = 0x1000,
+    GLITTER_EFFECT_INST_NO_EXT_ANIM_MAT             = 0x2000,
+    GLITTER_EFFECT_INST_GET_EXT_ANIM_THEN_UPDATE    = 0x4000,
 } glitter_effect_inst_flag;
 
 typedef enum glitter_emitter_emission {
@@ -107,16 +166,23 @@ typedef enum glitter_emitter_emission {
 } glitter_emitter_emission;
 
 typedef enum glitter_emitter_emission_direction {
-    GLITTER_EMITTER_EMISSION_DIRECTION_PARTICLE_VELOCITY = 0,
-    GLITTER_EMITTER_EMISSION_DIRECTION_INWARD            = 1,
-    GLITTER_EMITTER_EMISSION_DIRECTION_OUTWARD           = 2,
+    GLITTER_EMITTER_EMISSION_DIRECTION_NONE    = 0,
+    GLITTER_EMITTER_EMISSION_DIRECTION_OUTWARD = 1,
+    GLITTER_EMITTER_EMISSION_DIRECTION_INWARD  = 2,
 } glitter_emitter_emission_direction;
 
 typedef enum glitter_emitter_flag {
-    GLITTER_EMITTER_FLAG_NONE = 0x00,
-    GLITTER_EMITTER_FLAG_LOOP = 0x01,
+    GLITTER_EMITTER_NONE        = 0x00,
+    GLITTER_EMITTER_LOOP        = 0x01,
+    GLITTER_EMITTER_KILL_ON_END = 0x02,
+    GLITTER_EMITTER_USE_SEED    = 0x04,
 } glitter_emitter_flag;
 
+typedef enum glitter_emitter_timer_type {
+    GLITTER_EMITTER_TIMER_BY_TIME     = 0,
+    GLITTER_EMITTER_TIMER_BY_DISTANCE = 1,
+} glitter_emitter_timer_type;
+
 typedef enum glitter_emitter_type {
     GLITTER_EMITTER_BOX      = 0,
     GLITTER_EMITTER_CYLINDER = 1,
@@ -140,28 +206,36 @@ typedef enum glitter_particle_blend {
     GLITTER_PARTICLE_BLEND_PUNCH_THROUGH = 5,
 } glitter_particle_blend;
 
+typedef enum glitter_particle_draw_flags {
+    GLITTER_PARTICLE_DRAW_NONE              = 0x0,
+    GLITTER_PARTICLE_DRAW_NO_BILLBOARD_CULL = 0x1,
+} glitter_particle_draw_flags;
+
 typedef enum glitter_particle_flag {
-    GLITTER_PARTICLE_FLAG_NONE                 = 0x00000,
-    GLITTER_PARTICLE_FLAG_LOOP                 = 0x00001,
-    GLITTER_PARTICLE_FLAG_USE_MODEL_MAT        = 0x00004,
-    GLITTER_PARTICLE_FLAG_SCALE_Y_BY_X         = 0x00010,
-    GLITTER_PARTICLE_FLAG_REBOUND_PLANE        = 0x00020,
-    GLITTER_PARTICLE_FLAG_TRANSLATE_BY_EMITTER = 0x00040,
-    GLITTER_PARTICLE_FLAG_SCALE                = 0x00080,
-    GLITTER_PARTICLE_FLAG_SECOND_TEXTURE       = 0x00100,
-    GLITTER_PARTICLE_FLAG_LOCAL                = 0x10000,
-    GLITTER_PARTICLE_FLAG_EMISSION             = 0x20000,
+    GLITTER_PARTICLE_NONE              = 0x00000,
+    GLITTER_PARTICLE_LOOP              = 0x00001,
+    GLITTER_PARTICLE_EMITTER_LOCAL     = 0x00004,
+    GLITTER_PARTICLE_SCALE_Y_BY_X      = 0x00010,
+    GLITTER_PARTICLE_REBOUND_PLANE     = 0x00020,
+    GLITTER_PARTICLE_ROTATE_BY_EMITTER = 0x00040,
+    GLITTER_PARTICLE_SCALE             = 0x00080,
+    GLITTER_PARTICLE_SECOND_TEXTURE    = 0x00100,
+    GLITTER_PARTICLE_DEPTH_TEST        = 0x00200,
+    GLITTER_PARTICLE_ROTATE_LOCUS      = 0x00800,
+    GLITTER_PARTICLE_LOCAL             = 0x10000,
+    GLITTER_PARTICLE_EMISSION          = 0x20000,
 } glitter_particle_flag;
 
 typedef enum glitter_particle_inst_flag {
-    GLITTER_PARTICLE_INST_FLAG_NONE     = 0x00,
-    GLITTER_PARTICLE_INST_FLAG_ENDED    = 0x01,
-    GLITTER_PARTICLE_INST_FLAG_NO_CHILD = 0x02,
+    GLITTER_PARTICLE_INST_NONE = 0x00,
+    GLITTER_PARTICLE_INST_ENDED = 0x01,
+    GLITTER_PARTICLE_INST_NO_CHILD = 0x02,
 } glitter_particle_inst_flag;
 
 typedef enum glitter_particle_sub_flag {
-    GLITTER_PARTICLE_SUB_FLAG_NONE      = 0x00000000,
-    GLITTER_PARTICLE_SUB_FLAG_USE_CURVE = 0x40000000,
+    GLITTER_PARTICLE_SUB_NONE             = 0x00000000,
+    GLITTER_PARTICLE_SUB_USE_SECONDARY_UV = 0x00400000,
+    GLITTER_PARTICLE_SUB_USE_CURVE        = 0x40000000,
 } glitter_particle_sub_flag;
 
 typedef enum glitter_particle_type {
@@ -183,6 +257,12 @@ typedef enum glitter_pivot {
     GLITTER_PIVOT_BOTTOM_RIGHT  = 8,
 } glitter_pivot;
 
+typedef enum glitter_type {
+    GLITTER_AFT = 0,
+    GLITTER_F2  = 1,
+    GLITTER_X   = 2,
+} glitter_type;
+
 typedef enum glitter_uv_index_type {
     GLITTER_UV_INDEX_FIXED                  = 0,
     GLITTER_UV_INDEX_INITIAL_RANDOM_FIXED   = 1,
@@ -197,11 +277,11 @@ typedef enum glitter_uv_index_type {
 typedef struct glitter_buffer glitter_buffer;
 typedef struct glitter_curve_key glitter_curve_key;
 typedef struct glitter_curve glitter_curve;
-typedef struct glitter_effect_a3da glitter_effect_a3da;
 typedef struct glitter_effect_data glitter_effect_data;
+typedef struct glitter_effect_ext_anim glitter_effect_ext_anim;
 typedef struct glitter_effect glitter_effect;
 typedef struct glitter_effect_group glitter_effect_group;
-typedef struct glitter_effect_inst_a3da glitter_effect_inst_a3da;
+typedef struct glitter_effect_inst_ext_anim glitter_effect_inst_ext_anim;
 typedef struct glitter_effect_inst glitter_effect_inst;
 typedef struct glitter_emitter_box glitter_emitter_box;
 typedef struct glitter_emitter_cylinder glitter_emitter_cylinder;
@@ -214,16 +294,19 @@ typedef struct glitter_file_reader glitter_file_reader;
 typedef struct glitter_particle_manager glitter_particle_manager;
 typedef struct glitter_locus_history glitter_locus_history;
 typedef struct glitter_locus_history_data glitter_locus_history_data;
+typedef struct glitter_particle_mesh glitter_particle_mesh;
 typedef struct glitter_particle_data glitter_particle_data;
-typedef struct glitter_particle_sub glitter_particle_sub;
 typedef struct glitter_particle glitter_particle;
 typedef struct glitter_particle_inst_data glitter_particle_inst_data;
 typedef struct glitter_particle_inst glitter_particle_inst;
-typedef struct glitter_render_group_sub glitter_render_group_sub;
+typedef struct glitter_random glitter_random;
+typedef struct glitter_render_element glitter_render_element;
 typedef struct glitter_render_group glitter_render_group;
-typedef struct glitter_scene_sub glitter_scene_sub;
 typedef struct glitter_scene glitter_scene;
 
+#define GPM glitter_particle_manager* gpm, glitter_type glt_type
+#define GPM_VAL gpm, glt_type
+
 vector(glitter_curve_key)
 vector_ptr(glitter_curve)
 vector_ptr(glitter_effect)
@@ -238,10 +321,22 @@ vector_ptr(glitter_particle_inst)
 vector_ptr(glitter_render_group)
 vector_ptr(glitter_scene)
 
+extern const float_t glitter_min_emission;
+extern const glitter_curve_type_flags glitter_effect_curve_flags;
+extern const glitter_curve_type_flags glitter_emitter_curve_flags;
+extern const glitter_curve_type_flags glitter_particle_curve_flags;
+extern const glitter_curve_type_flags glitter_particle_x_curve_flags;
+
+struct glitter_random {
+    uint32_t value;
+    uint8_t step;
+};
+
 struct glitter_buffer {
     vec3 position;
     vec2 uv;
-    vec4 color;
+    vec3 color;
+    float_t alpha;
 };
 
 struct glitter_curve_key {
@@ -256,31 +351,37 @@ struct glitter_curve_key {
 struct glitter_curve {
     glitter_curve_type type;
     bool repeat;
-    float_t start_time;
-    float_t end_time;
+    int32_t start_time;
+    int32_t end_time;
     glitter_curve_flag flags;
-    float_t max_rand;
+    float_t random_range;
     vector_glitter_curve_key keys;
+#if defined(CRE_DEV) || defined(CLOUD_DEV)
+    vector_glitter_curve_key keys_rev;
+#endif
     uint32_t version;
     uint32_t keys_version;
 };
 
-struct glitter_effect_a3da {
-    uint64_t object_hash;
-    int32_t object_index;
-    glitter_effect_a3da_flag flags;
-    int32_t index;
-    char mesh_name[128];
-};
-
 struct glitter_effect_data {
     uint64_t name_hash;
-    float_t appear_time;
-    float_t life_time;
-    float_t start_time;
-    glitter_effect_a3da* a3da;
+    int32_t appear_time;
+    int32_t life_time;
+    int32_t start_time;
+    glitter_effect_ext_anim* ext_anim;
     glitter_effect_flag flags;
     float_t emission;
+    int32_t seed;
+};
+
+struct glitter_effect_ext_anim {
+    uint64_t object_hash;
+    glitter_effect_ext_anim_flag flags;
+    int32_t instance_id;
+    uint64_t some_hash;
+    int32_t index;
+    int32_t node_index;
+    char mesh_name[128];
 };
 
 struct glitter_effect {
@@ -299,22 +400,25 @@ struct glitter_effect_group {
     uint64_t hash;
     float_t emission;
     uint32_t resources_count;
-    int64_t* resource_hashes;
-    int32_t* resources;
-    txp* resources_tex;
+    vector_uint64_t resource_hashes;
+    vector_txp resources_tex;
+    vector_int32_t resources;
     bool scene_init;
     bool buffer_init;
     uint32_t version;
 };
 
-struct glitter_effect_inst_a3da {
+struct glitter_effect_inst_ext_anim {
     int32_t dword00;
     int64_t dword08;
-    int32_t object_index;
-    int32_t index;
+    int32_t instance_id;
+    uint64_t some_hash;
+    uint64_t object_hash;
+    int32_t chara_index;
+    int32_t node_index;
     mat4 mat;
     vec3 translation;
-    char* mesh_name;
+    char* name;
     bool object_is_hrc;
 };
 
@@ -328,13 +432,15 @@ struct glitter_effect_inst {
     vec3 scale;
     float_t scale_all;
     mat4 mat;
+    mat4 mat_ext_anim;
     vector_ptr_glitter_emitter_inst emitters;
-    int32_t random;
+    glitter_random random_shared;
     glitter_effect_inst_flag flags;
     size_t id;
-    glitter_effect_inst_a3da* a3da;
-    vec4 min_color;
-    vec3 a3da_scale;
+    glitter_effect_inst_ext_anim* ext_anim;
+    vec3 ext_anim_scale;
+    vector_ptr_glitter_render_group render_groups;
+    glitter_random random;
 };
 
 struct glitter_emitter_box {
@@ -346,34 +452,34 @@ struct glitter_emitter_cylinder {
     float_t height;
     float_t start_angle;
     float_t end_angle;
-    bool plain;
+    bool on_edge;
     glitter_emitter_emission_direction direction;
 };
 
 struct glitter_emitter_polygon {
-    float_t scale;
+    float_t size;
     int32_t count;
+    glitter_emitter_emission_direction direction;
 };
 
 struct glitter_emitter_sphere {
     float_t radius;
     float_t latitude;
     float_t longitude;
-    bool plain;
+    bool on_edge;
     glitter_emitter_emission_direction direction;
 };
 
 
 struct glitter_emitter_data {
-    float_t start_time;
-    float_t life_time;
-    float_t loop_start_time;
-    float_t loop_end_time;
+    int32_t start_time;
+    int32_t life_time;
+    int32_t loop_start_time;
+    int32_t loop_end_time;
     glitter_emitter_flag flags;
     vec3 rotation_add;
     vec3 rotation_add_random;
-    //int32_t dword2C;
-    //int32_t dword30;
+    glitter_emitter_timer_type timer;
     float_t emission_interval;
     float_t particles_per_emission;
     glitter_direction direction;
@@ -382,6 +488,7 @@ struct glitter_emitter_data {
     glitter_emitter_cylinder cylinder;
     glitter_emitter_sphere sphere;
     glitter_emitter_polygon polygon;
+    int32_t seed;
 };
 
 
@@ -408,11 +515,14 @@ struct glitter_emitter_inst {
     glitter_emitter_data data;
     float_t emission_interval;
     float_t particles_per_emission;
-    int32_t random;
+    glitter_random* random_ptr;
     bool loop;
     glitter_emitter_emission emission;
     float_t frame;
     bool ended;
+    bool has_distance;
+    uint32_t counter;
+    glitter_random random;
 };
 
 struct glitter_file_reader {
@@ -429,9 +539,9 @@ struct glitter_particle_manager {
     vector_ptr_glitter_effect_group effect_groups;
     float_t delta_frame;
     float_t emission;
-    uint32_t random;
     uint32_t counter;
-    bool f2;
+    bool draw_all;
+    bool draw_all_mesh;
 };
 
 struct glitter_locus_history {
@@ -439,14 +549,26 @@ struct glitter_locus_history {
 };
 
 struct glitter_locus_history_data {
-    vec3 translation;
     vec4 color;
+    vec3 translation;
     float_t scale;
 };
 
+struct glitter_particle_mesh {
+    uint64_t object_name_hash;
+    uint64_t object_file_hash;
+    char object_mesh_name[64];
+    uint64_t some_hash;
+};
+
 struct glitter_particle_data {
     glitter_particle_flag flags;
-    float_t life_time;
+    int32_t life_time;
+    int32_t life_time_random;
+    int32_t fade_in;
+    int32_t fade_in_random;
+    int32_t fade_out;
+    int32_t fade_out_random;
     glitter_particle_type type;
     glitter_pivot pivot;
     glitter_direction draw_type;
@@ -463,21 +585,23 @@ struct glitter_particle_data {
     float_t speed_random;
     float_t deceleration;
     float_t deceleration_random;
-    vec3 gravitational_acceleration;
-    vec3 external_acceleration;
-    vec3 external_acceleration_random;
+    vec3 gravity;
+    vec3 acceleration;
+    vec3 acceleration_random;
     float_t reflection_coeff;
     float_t reflection_coeff_random;
     float_t rebound_plane_y;
     vec4 color;
     glitter_uv_index_type uv_index_type;
     int32_t uv_index;
-    float_t frame_step_uv;
+    int32_t frame_step_uv;
     int32_t uv_index_start;
     int32_t uv_index_end;
     int32_t uv_index_count;
     vec2 uv_scroll_add;
     float_t uv_scroll_add_scale;
+    vec2 uv_scroll_2nd_add;
+    float_t uv_scroll_2nd_add_scale;
     vec2 split_uv;
     uint8_t split_u;
     uint8_t split_v;
@@ -487,23 +611,18 @@ struct glitter_particle_data {
     int32_t count;
     int32_t locus_history_size;
     int32_t locus_history_size_random;
-    //int32_t dword118;
+    glitter_particle_draw_flags draw_flags;
     float_t emission;
     uint64_t tex_hash0;
     uint64_t tex_hash1;
     int32_t texture0;
     int32_t texture1;
-    //char dword138[0x20];
-};
-
-struct glitter_particle_sub {
-    glitter_particle_data data;
-    int32_t max_count;
+    glitter_particle_mesh mesh;
 };
 
 struct glitter_particle {
     vector_ptr_glitter_curve curve;
-    glitter_particle_sub data;
+    glitter_particle_data data;
     int32_t version;
 };
 
@@ -511,32 +630,33 @@ struct glitter_particle_inst_data {
     glitter_particle_data data;
     glitter_particle_inst_flag flags;
     glitter_render_group* render_group;
-    glitter_effect_inst* effect_inst;
+    glitter_random* random_ptr;
+    glitter_effect_inst* effect;
+    glitter_emitter_inst* emitter;
     glitter_particle_inst* parent;
     glitter_particle* particle;
-    vector_ptr_glitter_particle_inst particle_insts;
+    vector_ptr_glitter_particle_inst children;
 };
 
 struct glitter_particle_inst {
     glitter_particle* particle;
-    mat4 mat;
-    mat4 mat_no_scale;
-    glitter_particle_inst_data sub;
+    glitter_particle_inst_data data;
 };
 
-struct glitter_render_group_sub {
+struct glitter_render_element {
     bool alive;
     uint8_t uv_index;
-    int32_t random;
+    bool draw;
     float_t frame;
     float_t life_time;
-    float_t rebound_time;
+    float_t rebound_frame;
     float_t frame_step_uv;
     float_t speed;
     float_t deceleration;
     vec2 uv;
     vec4 color;
     vec3 base_translation;
+    vec3 base_direction;
     vec3 translation;
     vec3 translation_prev;
     vec3 direction;
@@ -545,12 +665,14 @@ struct glitter_render_group_sub {
     vec3 scale;
     vec3 rotation;
     vec3 rotation_add;
-    float_t rot_z_cos;
-    float_t rot_z_sin;
     float_t scale_all;
     vec2 uv_scroll;
+    vec2 uv_scroll_2nd;
+    float_t fade_out_frames;
+    float_t fade_in_frames;
     mat4 mat;
     glitter_locus_history* locus_history;
+    glitter_random random;
 };
 
 struct glitter_render_group {
@@ -564,34 +686,30 @@ struct glitter_render_group {
     int32_t split_v;
     vec2 split_uv;
     float_t z_offset;
-    int32_t count;
-    int32_t ctrl;
+    size_t count;
+    size_t ctrl;
+    size_t disp;
     int32_t texture0;
     int32_t texture1;
-    //char dword48[32];
     float_t frame;
     mat4 mat;
     mat4 mat_no_scale;
-    int32_t has_texture1;
-    glitter_render_group_sub* sub;
+    mat4 mat_draw;
+    glitter_render_element* elements;
     glitter_buffer* buffer;
-    int32_t max_count;
-    glitter_particle_inst* particle_inst;
+    size_t max_count;
+    glitter_particle_inst* particle;
+    glitter_random* random_ptr;
     int32_t alpha;
     int32_t fog;
-    int32_t buffer_index;
     int32_t vao;
+    int32_t vbo;
+    int32_t ebo;
     float_t emission;
-};
-
-struct glitter_scene_sub {
-    vector_ptr_glitter_render_group render_groups;
-    int32_t disp_quad;
-    int32_t disp_locus;
-    int32_t disp_line;
-    int32_t ctrl_quad;
-    int32_t ctrl_locus;
-    int32_t ctrl_line;
+    vector_int32_t vec_key;
+    vector_int32_t vec_val;
+    bool use_culling;
+    bool update_data;
 };
 
 struct glitter_scene {
@@ -599,5 +717,4 @@ struct glitter_scene {
     uint64_t hash;
     float_t emission;
     glitter_effect_group* effect_group;
-    glitter_scene_sub sub;
 };

src/CRE/Glitter/list.c

@@ -5,8 +5,8 @@
 
 #include "texture.h"
 
-bool FASTCALL glitter_list_pack_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian) {
-    char* data;
+bool FASTCALL glitter_list_pack_file(glitter_effect_group* a1, f2_struct* st) {
+    size_t data;
     glitter_effect** i;
     size_t length;
 
@@ -15,30 +15,35 @@ bool FASTCALL glitter_list_pack_file(glitter_effect_group* a1, f2_struct* st, bo
 
     memset(st, 0, sizeof(f2_struct));
 
+    vector_enrs_entry e = { 0, 0, 0 };
+    enrs_entry ee;
+
+    ee = (enrs_entry){ 0, 1, 4, 1, { 0, 0, 0 } };
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 1, ENRS_TYPE_DWORD });
+    vector_enrs_entry_push_back(&e, &ee);
+
     length = 0;
     for (i = a1->effects.begin; i != a1->effects.end; i++)
         if (*i)
             length++;
 
-    data = force_malloc(0x10 + 0x80 * length);
-    st->data = data;
+    data = (size_t)force_malloc(0x10 + 0x80 * length);
+    st->data = (void*)data;
     st->length = 0x10 + 0x80 * length;
+    st->enrs = e;
 
-    if (use_big_endian)
-        *(uint32_t*)data = reverse_endianess_uint32_t((uint32_t)length);
-    else
-        *(uint32_t*)data = (uint32_t)length;
-    data += 0x04;
+    *(uint32_t*)data = (uint32_t)length;
+    data += 4;
 
     for (i = a1->effects.begin; i != a1->effects.end; i++)
         if (*i) {
-            memcpy(data, (*i)->name, 0x80);
+            memcpy((void*)data, (*i)->name, 0x80);
             data += 0x80;
         }
 
     st->header.signature = 0x46464547;
     st->header.length = 0x20;
-    st->header.use_big_endian = use_big_endian ? true : false;
+    st->header.use_big_endian = false;
     st->header.use_section_size = true;
     return true;
 }

src/CRE/Glitter/list.h

@@ -7,5 +7,5 @@
 
 #include "glitter.h"
 
-extern bool FASTCALL glitter_list_pack_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian);
+extern bool FASTCALL glitter_list_pack_file(glitter_effect_group* a1, f2_struct* st);
 extern bool FASTCALL glitter_list_unpack_file(glitter_effect_group* a1, f2_struct* st);

src/CRE/Glitter/locus_history.c

@@ -7,48 +7,51 @@
 
 glitter_locus_history* FASTCALL glitter_locus_history_init(size_t size) {
     glitter_locus_history* lh = force_malloc(sizeof(glitter_locus_history));
-    vector_glitter_locus_history_data_resize(&lh->data, size);
+    vector_glitter_locus_history_data_append(&lh->data, size);
     return lh;
 }
 
-void FASTCALL glitter_locus_history_append(glitter_locus_history* a1,
-    glitter_render_group_sub* a2, glitter_particle_inst* a3) {
-    glitter_locus_history_data* v5;
-    int64_t size;
-    int64_t i;
+void FASTCALL glitter_locus_history_append(GPM, glitter_locus_history* a1,
+    glitter_render_element* a2, glitter_particle_inst* a3) {
+    glitter_locus_history_data* data;
     glitter_locus_history_data locus_history;
+    glitter_emitter_inst* emitter;
+    ssize_t size;
+    ssize_t i;
     vec3 temp;
     vec3 temp1;
 
-    v5 = a1->data.begin;
+    data = a1->data.begin;
     size = a1->data.end - a1->data.begin;
-    if (a3->sub.data.flags & GLITTER_PARTICLE_FLAG_USE_MODEL_MAT)
-        temp = *(vec3*)&a3->mat.row3;
-    else
-        temp = a2->translation;
+    temp = a2->translation;
+    if (a3->data.data.flags & GLITTER_PARTICLE_EMITTER_LOCAL && (emitter = a3->data.emitter)) {
+        vec3 emit_trans;
+        mat4_get_translation(&emitter->mat, &emit_trans);
+        vec3_add(temp, emit_trans, temp);
+    }
 
-    locus_history.translation = temp;
     locus_history.color = a2->color;
+    locus_history.translation = temp;
     locus_history.scale = a2->scale_particle.x * a2->scale.x * a2->scale_all;
     if (size < 1)
         vector_glitter_locus_history_data_push_back(&a1->data, &locus_history);
     else if (size == 1) {
-        locus_history.translation = v5->translation;
+        locus_history.translation = data->translation;
         if (a1->data.capacity_end - a1->data.begin > 1)
             vector_glitter_locus_history_data_push_back(&a1->data, &locus_history);
-        v5->translation = temp;
+        data->translation = temp;
     }
     else {
-        temp1 = v5[size - 1].translation;
+        temp1 = data[size - 1].translation;
 
         for (i = size - 1; i > 0; i--)
-            v5[i].translation = v5[i - 1].translation;
+            data[i].translation = data[i - 1].translation;
 
         if (size < a1->data.capacity_end - a1->data.begin) {
             locus_history.translation = temp1;
             vector_glitter_locus_history_data_push_back(&a1->data, &locus_history);
         }
-        v5->translation = temp;
+        data->translation = temp;
     }
 }
 

src/CRE/Glitter/locus_history.h

@@ -8,6 +8,6 @@
 #include "glitter.h"
 
 extern glitter_locus_history* FASTCALL glitter_locus_history_init(size_t size);
-extern void FASTCALL glitter_locus_history_append(glitter_locus_history* a1,
-    glitter_render_group_sub* a2, glitter_particle_inst* a3);
+extern void FASTCALL glitter_locus_history_append(GPM, glitter_locus_history* a1,
+    glitter_render_element* a2, glitter_particle_inst* a3);
 extern void FASTCALL glitter_locus_history_dispose(glitter_locus_history* lh);

src/CRE/Glitter/particle.h

@@ -7,9 +7,10 @@
 
 #include "glitter.h"
 
-extern glitter_particle* FASTCALL glitter_particle_init();
-extern bool FASTCALL glitter_particle_parse_file(glitter_effect_group* a1,
+extern glitter_particle* FASTCALL glitter_particle_init(GPM);
+extern glitter_particle* FASTCALL glitter_particle_copy(GPM, glitter_particle* p);
+extern bool FASTCALL glitter_particle_parse_file(GPM, glitter_effect_group* a1,
     f2_struct* st, vector_ptr_glitter_particle* vec, glitter_effect* effect);
-extern bool FASTCALL glitter_particle_unparse_file(glitter_effect_group* a1,
-    f2_struct* st, glitter_particle* a3, glitter_effect* effect, bool use_big_endian);
+extern bool FASTCALL glitter_particle_unparse_file(GPM, glitter_effect_group* a1,
+    f2_struct* st, glitter_particle* a3, glitter_effect* effect);
 extern void FASTCALL glitter_particle_dispose(glitter_particle* p);

src/CRE/Glitter/particle_inst.c

@@ -4,291 +4,153 @@
 */
 
 #include "particle_inst.h"
-#include "curve.h"
 #include "effect_inst.h"
-#include "random.h"
 #include "render_group.h"
 
-glitter_particle_inst* FASTCALL glitter_particle_inst_init(glitter_particle* a1,
-    glitter_scene* a2, glitter_effect_inst* a3) {
+static glitter_particle_inst* FASTCALL glitter_particle_inst_init_child(GPM,
+    glitter_particle_inst* a1, float_t emission);
+
+glitter_particle_inst* FASTCALL glitter_particle_inst_init(GPM, glitter_particle* a1,
+    glitter_effect_inst* a2, glitter_emitter_inst* a3, glitter_random* random, float_t emission) {
     glitter_render_group* render_group;
 
     glitter_particle_inst* pi = force_malloc(sizeof(glitter_particle_inst));
     pi->particle = a1;
-    pi->mat = mat4_identity;
-    pi->mat_no_scale = mat4_identity;
-    pi->sub.effect_inst = a3;
-    pi->sub.particle = a1;
-    pi->sub.data = a1->data.data;
+    pi->data.effect = a2;
+    pi->data.emitter = a3;
+    pi->data.particle = a1;
+    pi->data.data = a1->data;
+    pi->data.random_ptr = random;
 
-    if (pi->sub.data.type != GLITTER_PARTICLE_LOCUS) {
-        render_group = glitter_particle_inst_init_render_group(&a2->sub, pi);
-        render_group->alpha = glitter_effect_inst_get_alpha(a3);
-        render_group->fog = glitter_effect_inst_get_fog(a3);
-        if (pi->sub.data.blend_mode0 == GLITTER_PARTICLE_BLEND_PUNCH_THROUGH && pi->sub.data.type == GLITTER_PARTICLE_QUAD)
+    if (pi->data.data.type != GLITTER_PARTICLE_LOCUS) {
+        render_group = glitter_render_group_init(GPM_VAL, pi);
+        render_group->alpha = glitter_effect_inst_get_alpha(a2);
+        render_group->fog = glitter_effect_inst_get_fog(a2);
+        if (pi->data.data.blend_mode0 == GLITTER_PARTICLE_BLEND_PUNCH_THROUGH
+            && pi->data.data.type == GLITTER_PARTICLE_QUAD)
             render_group->alpha = 0;
 
-        if (pi->sub.data.emission >= 0.0099999998f)
-            render_group->emission = pi->sub.data.emission;
-        else if (a3->data.emission >= 0.0099999998f)
-            render_group->emission = a3->data.emission;
+        if (pi->data.data.draw_flags & GLITTER_PARTICLE_DRAW_NO_BILLBOARD_CULL)
+            render_group->use_culling = false;
         else
-            render_group->emission = a2->emission;
-        pi->sub.render_group = render_group;
+            render_group->use_culling = true;
+
+        if (pi->data.data.emission >= glitter_min_emission)
+            render_group->emission = pi->data.data.emission;
+        else if (a2->data.emission >= glitter_min_emission)
+            render_group->emission = a2->data.emission;
+        else
+            render_group->emission = emission;
+        pi->data.render_group = render_group;
+        vector_ptr_glitter_render_group_push_back(&a2->render_groups, &render_group);
     }
     else
-        pi->sub.flags |= GLITTER_PARTICLE_INST_FLAG_NO_CHILD;
+        pi->data.flags |= GLITTER_PARTICLE_INST_NO_CHILD;
     return pi;
 }
 
-void FASTCALL glitter_particle_inst_copy(glitter_particle_inst* a1, glitter_particle_inst* a2, glitter_scene* a3) {
+void FASTCALL glitter_particle_inst_emit(GPM,
+    glitter_particle_inst* a2, int32_t a3, int32_t count, float_t emission) {
     glitter_particle_inst* particle;
-    glitter_particle_inst** i;
 
-    a2->mat = a1->mat;
-    a2->mat_no_scale = a1->mat_no_scale;
-    a2->sub.flags = a1->sub.flags;
-    if (a1->sub.render_group && a2->sub.render_group)
-        glitter_render_group_copy(a1->sub.render_group, a2->sub.render_group);
-
-    vector_ptr_glitter_particle_inst_clear(&a2->sub.particle_insts, (void*)glitter_particle_inst_dispose);
-    for (i = a1->sub.particle_insts.begin; i != a1->sub.particle_insts.end; i++) {
-        particle = glitter_particle_inst_init_child(a3, a1);
-        vector_ptr_glitter_particle_inst_push_back(&a2->sub.particle_insts, &particle);
-
-        particle->mat = a1->mat;
-        particle->mat_no_scale = a1->mat_no_scale;
-        glitter_particle_inst_copy(*i, particle, a3);
-    }
-}
-
-void FASTCALL glitter_particle_inst_emit(glitter_particle_inst* a1,
-    glitter_scene* a2, glitter_emitter_inst* a3, int32_t a4, int32_t count) {
-    glitter_particle_inst* particle_inst;
-
-    if (a1->sub.flags & GLITTER_PARTICLE_INST_FLAG_ENDED)
+    if (a2->data.flags & GLITTER_PARTICLE_INST_ENDED)
         return;
 
-    while (!a1->sub.parent && a1->sub.flags & GLITTER_PARTICLE_INST_FLAG_NO_CHILD) {
-        particle_inst = glitter_particle_inst_init_child(a2, a1);
-        vector_ptr_glitter_particle_inst_push_back(&a1->sub.particle_insts, &particle_inst);
-        particle_inst->mat = a1->mat;
-        particle_inst->mat_no_scale = a1->mat_no_scale;
-        a1 = particle_inst;
-        if (particle_inst->sub.flags & GLITTER_PARTICLE_INST_FLAG_ENDED)
+    while (!a2->data.parent && a2->data.flags & GLITTER_PARTICLE_INST_NO_CHILD) {
+        particle = glitter_particle_inst_init_child(GPM_VAL, a2, emission);
+        vector_ptr_glitter_particle_inst_push_back(&a2->data.children, &particle);
+        a2 = particle;
+        if (particle->data.flags & GLITTER_PARTICLE_INST_ENDED)
             return;
     }
 
-    if (a1->sub.render_group)
-        glitter_render_group_emit(a1->sub.render_group, &a1->sub, a3, a4, count);
+    if (a2->data.render_group)
+        glitter_render_group_emit(GPM_VAL, a2->data.render_group, &a2->data, a2->data.emitter, a3, count);
 }
 
 void FASTCALL glitter_particle_inst_free(glitter_particle_inst* a1, bool free) {
     glitter_particle_inst** i;
 
-    a1->sub.flags |= GLITTER_PARTICLE_INST_FLAG_ENDED;
-    if (free && a1->sub.render_group)
-        glitter_render_group_free(a1->sub.render_group);
+    a1->data.flags |= GLITTER_PARTICLE_INST_ENDED;
+    if (free && a1->data.render_group)
+        glitter_render_group_free(a1->data.render_group);
 
-    for (i = a1->sub.particle_insts.begin; i != a1->sub.particle_insts.end; i++)
+    for (i = a1->data.children.begin; i != a1->data.children.end; i++)
         glitter_particle_inst_free(*i, free);
 }
 
-bool FASTCALL glitter_particle_inst_get_value(glitter_particle_inst* a1,
-    glitter_render_group_sub* a2, float_t frame) {
-    vec3 translation;
-    bool v4; // r13
-    int64_t length; // rbp
-    glitter_curve* curve; // rdi
-    float_t value; // [rsp+40h] [rbp-39h] BYREF
-    bool visible;
-
-    visible = true;
-    value = 0.0f;
-    v4 = false;
-    translation = vec3_null;
-    length = a1->particle->curve.end - a1->particle->curve.begin;
-    if (length) {
-        for (int32_t i = 0; i < length; i++) {
-            curve = a1->particle->curve.begin[i];
-            if (!glitter_curve_get_value(curve, frame, &value, a2->random + i))
-                continue;
-
-            switch (curve->type) {
-            case GLITTER_CURVE_TRANSLATION_X:
-                translation.x = value;
-                v4 = true;
-                break;
-            case GLITTER_CURVE_TRANSLATION_Y:
-                translation.y = value;
-                v4 = true;
-                break;
-            case GLITTER_CURVE_TRANSLATION_Z:
-                translation.z = value;
-                v4 = true;
-                break;
-            case GLITTER_CURVE_ROTATION_X:
-                a2->rotation.x = value;
-                break;
-            case GLITTER_CURVE_ROTATION_Y:
-                a2->rotation.y = value;
-                break;
-            case GLITTER_CURVE_ROTATION_Z:
-                a2->rotation.z = value;
-                break;
-            case GLITTER_CURVE_SCALE_X:
-                a2->scale.x = value;
-                break;
-            case GLITTER_CURVE_SCALE_Y:
-                a2->scale.y = value;
-                break;
-            case GLITTER_CURVE_SCALE_Z:
-                a2->scale.z = value;
-                break;
-            case GLITTER_CURVE_SCALE_ALL:
-                a2->scale_all = value;
-                break;
-            case GLITTER_CURVE_COLOR_R:
-                a2->color.x = value;
-                break;
-            case GLITTER_CURVE_COLOR_G:
-                a2->color.y = value;
-                break;
-            case GLITTER_CURVE_COLOR_B:
-                a2->color.z = value;
-                break;
-            case GLITTER_CURVE_COLOR_A:
-                a2->color.w = value;
-                if (value < 0.0099999998f)
-                    visible = false;
-                break;
-            case GLITTER_CURVE_U_SCROLL:
-                a2->uv_scroll.x = value;
-                break;
-            case GLITTER_CURVE_V_SCROLL:
-                a2->uv_scroll.y = value;
-                break;
-            }
-        }
-    }
-
-    if (a1->sub.data.flags & GLITTER_PARTICLE_FLAG_TRANSLATE_BY_EMITTER || v4) {
-        vec3_add(translation, a2->base_translation, translation);
-        if (a1->sub.data.flags & GLITTER_PARTICLE_FLAG_TRANSLATE_BY_EMITTER) {
-            mat4_mult_vec3(&a2->mat, &translation, &translation);
-            vec3_add(translation, *(vec3*)&a2->mat.row3, translation);
-        }
-        a2->translation = translation;
-    }
-    return visible;
-}
-
 bool FASTCALL glitter_particle_inst_has_ended(glitter_particle_inst* particle, bool a2) {
     glitter_particle_inst** i;
 
-    if (~particle->sub.flags & GLITTER_PARTICLE_INST_FLAG_ENDED)
+    if (~particle->data.flags & GLITTER_PARTICLE_INST_ENDED)
         return false;
     else if (!a2)
         return true;
 
-    if (~particle->sub.flags & GLITTER_PARTICLE_INST_FLAG_NO_CHILD || particle->sub.parent) {
-        if (particle->sub.render_group && particle->sub.render_group->ctrl > 0)
+    if (~particle->data.flags & GLITTER_PARTICLE_INST_NO_CHILD || particle->data.parent) {
+        if (particle->data.render_group && particle->data.render_group->ctrl > 0)
             return false;
         return true;
     }
 
-    for (i = particle->sub.particle_insts.begin; i != particle->sub.particle_insts.end; i++)
+    for (i = particle->data.children.begin; i != particle->data.children.end; i++)
         if (!glitter_particle_inst_has_ended(*i, a2))
             return false;
     return true;
 }
 
-glitter_particle_inst* FASTCALL glitter_particle_inst_init_child(glitter_scene* a1, glitter_particle_inst* a2) {
+void FASTCALL glitter_particle_inst_dispose(glitter_particle_inst* pi) {
+    if (pi->data.render_group) {
+        glitter_render_group_delete_buffers(pi->data.render_group, true);
+        pi->data.render_group = 0;
+    }
+
+    vector_ptr_glitter_particle_inst_free(&pi->data.children, glitter_particle_inst_dispose);
+    free(pi);
+}
+
+void FASTCALL glitter_particle_inst_reset(glitter_particle_inst* a1) {
+    glitter_particle_inst** i;
+
+    a1->data.flags = 0;
+    if (a1->data.render_group)
+        glitter_render_group_free(a1->data.render_group);
+
+    for (i = a1->data.children.begin; i != a1->data.children.end; ++i)
+        glitter_particle_inst_reset(*i);
+}
+
+glitter_particle_inst* FASTCALL glitter_particle_inst_init_child(GPM,
+    glitter_particle_inst* a1, float_t emission) {
     glitter_render_group* render_group;
     glitter_effect_inst* effect;
 
     glitter_particle_inst* pi = force_malloc(sizeof(glitter_particle_inst));
-    pi->particle = a2->particle;
-    pi->mat = mat4_identity;
-    pi->mat_no_scale = mat4_identity;
-    pi->sub.parent = a2;
-    vector_ptr_glitter_particle_inst_resize(&pi->sub.particle_insts, 0x200);
+    pi->particle = a1->particle;
+    pi->data.effect = a1->data.effect;
+    pi->data.emitter = a1->data.emitter;
+    pi->data.parent = a1;
+    vector_ptr_glitter_particle_inst_append(&pi->data.children, 0x200);
 
-    pi->sub.data = a2->sub.data;
+    pi->data.random_ptr = a1->data.random_ptr;
+    pi->data.data = a1->data.data;
 
-    pi->sub.particle = a2->sub.particle;
-    render_group = glitter_particle_inst_init_render_group(&a1->sub, pi);
-    effect = a2->sub.effect_inst;
+    pi->data.particle = a1->data.particle;
+    render_group = glitter_render_group_init(GPM_VAL, pi);
+    effect = a1->data.effect;
     render_group->alpha = glitter_effect_inst_get_alpha(effect);
     render_group->fog = glitter_effect_inst_get_fog(effect);
-    if (pi->sub.data.blend_mode0 == GLITTER_PARTICLE_BLEND_PUNCH_THROUGH && pi->sub.data.type == GLITTER_PARTICLE_QUAD)
+    if (pi->data.data.blend_mode0 == GLITTER_PARTICLE_BLEND_PUNCH_THROUGH
+        && pi->data.data.type == GLITTER_PARTICLE_QUAD)
         render_group->alpha = 0;
-    if (effect->data.emission >= 0.0099999998f)
+    if (effect->data.emission >= glitter_min_emission)
         render_group->emission = effect->data.emission;
     else
-        render_group->emission = a1->emission;
-    pi->sub.render_group = render_group;
+        render_group->emission = emission;
+    pi->data.render_group = render_group;
+    vector_ptr_glitter_render_group_push_back(&a1->data.effect->render_groups, &render_group);
 
-    if (pi->sub.data.type == GLITTER_PARTICLE_LOCUS)
-        pi->sub.flags |= GLITTER_PARTICLE_INST_FLAG_NO_CHILD;
+    if (pi->data.data.type == GLITTER_PARTICLE_LOCUS)
+        pi->data.flags |= GLITTER_PARTICLE_INST_NO_CHILD;
     return pi;
 }
-
-glitter_render_group* FASTCALL glitter_particle_inst_init_render_group(glitter_scene_sub* a1,
-    glitter_particle_inst* a2) {
-    int32_t count;
-    glitter_render_group* render_group;
-
-    count = a2->sub.data.count;
-    if (count < 1) {
-        count = 250;
-        if (a2->sub.data.type == GLITTER_PARTICLE_LOCUS)
-            count = 30;
-    }
-
-    render_group = glitter_render_group_init(count, a2);
-    vector_ptr_glitter_render_group_push_back(&a1->render_groups, &render_group);
-    return render_group;
-}
-
-void FASTCALL glitter_particle_inst_dispose(glitter_particle_inst* pi) {
-    if (pi->sub.render_group) {
-        glitter_render_group_delete_buffers(pi->sub.render_group, true);
-        pi->sub.render_group = 0;
-    }
-
-    vector_ptr_glitter_particle_inst_free(&pi->sub.particle_insts, (void*)glitter_particle_inst_dispose);
-    free(pi);
-}
-
-void FASTCALL glitter_particle_inst_render_group_init(glitter_particle_inst* particle, float_t delta_frame) {
-    glitter_particle_inst** i;
-
-    if (~particle->sub.flags & GLITTER_PARTICLE_INST_FLAG_NO_CHILD || particle->sub.parent) {
-        if (particle->sub.render_group)
-            glitter_render_group_copy_from_particle(particle->sub.render_group, delta_frame, false);
-    }
-    else
-        for (i = particle->sub.particle_insts.begin; i != particle->sub.particle_insts.end; i++)
-            glitter_particle_inst_render_group_init(*i, delta_frame);
-}
-
-void FASTCALL glitter_particle_inst_reset(glitter_particle_inst* a1) {
-    glitter_particle_inst** i; // rbx
-
-    a1->sub.flags = 0;
-    if (a1->sub.render_group)
-        glitter_render_group_free(a1->sub.render_group);
-
-    for (i = a1->sub.particle_insts.begin; i != a1->sub.particle_insts.end; ++i)
-        glitter_particle_inst_reset(*i);
-}
-
-void FASTCALL glitter_particle_inst_set_mat(glitter_particle_inst* a1) {
-    glitter_particle_inst** i;
-
-    for (i = a1->sub.particle_insts.begin; i != a1->sub.particle_insts.end; i++) {
-        (*i)->mat = a1->mat;
-        (*i)->mat_no_scale = a1->mat_no_scale;
-    }
-}

src/CRE/Glitter/particle_inst.h

@@ -7,21 +7,11 @@
 
 #include "glitter.h"
 
-extern glitter_particle_inst* FASTCALL glitter_particle_inst_init(glitter_particle* a1,
-    glitter_scene* a2, glitter_effect_inst* a3);
-extern void FASTCALL glitter_particle_inst_copy(glitter_particle_inst* a1,
-    glitter_particle_inst* a2, glitter_scene* a3);
-extern void FASTCALL glitter_particle_inst_emit(glitter_particle_inst* a1,
-    glitter_scene* a2, glitter_emitter_inst* a3, int32_t a4, int32_t count);
+extern glitter_particle_inst* FASTCALL glitter_particle_inst_init(GPM, glitter_particle* a1,
+    glitter_effect_inst* a2, glitter_emitter_inst* a3, glitter_random* random, float_t emission);
+extern void FASTCALL glitter_particle_inst_emit(GPM,
+    glitter_particle_inst* a1, int32_t a3, int32_t count, float_t emission);
 extern void FASTCALL glitter_particle_inst_free(glitter_particle_inst* a1, bool free);
-extern bool FASTCALL glitter_particle_inst_get_value(glitter_particle_inst* a1,
-    glitter_render_group_sub* a2, float_t frame);
 extern bool FASTCALL glitter_particle_inst_has_ended(glitter_particle_inst* particle, bool a2);
-extern glitter_particle_inst* FASTCALL glitter_particle_inst_init_child(glitter_scene* a1,
-    glitter_particle_inst* a2);
-extern glitter_render_group* FASTCALL glitter_particle_inst_init_render_group(glitter_scene_sub* a1,
-    glitter_particle_inst* a2);
-extern void FASTCALL glitter_particle_inst_render_group_init(glitter_particle_inst* particle, float_t delta_frame);
 extern void FASTCALL glitter_particle_inst_reset(glitter_particle_inst* a1);
-extern void FASTCALL glitter_particle_inst_set_mat(glitter_particle_inst* a1);
 extern void FASTCALL glitter_particle_inst_dispose(glitter_particle_inst* pi);

src/CRE/Glitter/particle_manager.c

@@ -9,19 +9,47 @@
 #include "file_reader.h"
 #include "render_group.h"
 #include "scene.h"
+#include "../GlitterX/effect_inst_x.h"
 
 glitter_particle_manager* FASTCALL glitter_particle_manager_init() {
     glitter_particle_manager* gpm = force_malloc(sizeof(glitter_particle_manager));
     gpm->delta_frame = 2.0f;
     gpm->emission = 1.0f;
-    vector_ptr_glitter_scene_resize(&gpm->scenes, 0x100);
-    vector_ptr_glitter_file_reader_resize(&gpm->file_readers, 0x100);
-    vector_ptr_glitter_effect_group_resize(&gpm->effect_groups, 0x100);
+    vector_ptr_glitter_scene_append(&gpm->scenes, 0x100);
+    vector_ptr_glitter_file_reader_append(&gpm->file_readers, 0x100);
+    vector_ptr_glitter_effect_group_append(&gpm->effect_groups, 0x100);
     return gpm;
 }
 
-bool FASTCALL glitter_particle_manager_check_effect_group(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash) {
+void FASTCALL glitter_particle_manager_calc_draw(GPM,
+    bool(FASTCALL* render_add_list_func)(glitter_particle_mesh*, vec4*, mat4*, mat4*)) {
+    glitter_scene** i;
+    glitter_scene* scene;
+    glitter_effect_inst** j;
+
+    /*if (glt_type == GLITTER_X)
+        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++) {
+            if (!*i)
+                continue;
+
+            scene = *i;
+            for (j = scene->effects.begin; j != scene->effects.end; j++)
+                if (*j)
+                    glitter_x_effect_inst_calc_draw(GPM_VAL, *j, render_add_list_func);
+        }
+    else*/
+        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++) {
+            if (!*i)
+                continue;
+
+            scene = *i;
+            for (j = scene->effects.begin; j != scene->effects.end; j++)
+                if (*j)
+                    glitter_effect_inst_calc_draw(GPM_VAL, *j, render_add_list_func);
+        }
+}
+
+bool FASTCALL glitter_particle_manager_check_effect_group(GPM, uint64_t effect_group_hash) {
     glitter_effect_group** i;
 
     for (i = gpm->effect_groups.begin; i != gpm->effect_groups.end; i++) {
@@ -32,8 +60,7 @@ bool FASTCALL glitter_particle_manager_check_effect_group(glitter_particle_manag
     return i != gpm->effect_groups.end;
 }
 
-bool FASTCALL glitter_particle_manager_check_file_reader(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash) {
+bool FASTCALL glitter_particle_manager_check_file_reader(GPM, uint64_t effect_group_hash) {
     glitter_file_reader** i;
 
     for (i = gpm->file_readers.begin; i != gpm->file_readers.end; i++) {
@@ -44,8 +71,7 @@ bool FASTCALL glitter_particle_manager_check_file_reader(glitter_particle_manage
     return i != gpm->file_readers.end;
 }
 
-bool FASTCALL glitter_particle_manager_check_scene(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash) {
+bool FASTCALL glitter_particle_manager_check_scene(GPM, uint64_t effect_group_hash) {
     glitter_scene** i;
 
     for (i = gpm->scenes.begin; i != gpm->scenes.end; i++) {
@@ -56,20 +82,34 @@ bool FASTCALL glitter_particle_manager_check_scene(glitter_particle_manager* gpm
     return i != gpm->scenes.end;
 }
 
-void FASTCALL glitter_particle_manager_draw(glitter_particle_manager* gpm, int32_t alpha) {
-    for (glitter_scene** i = gpm->scenes.begin; i != gpm->scenes.end; i++) {
-        if (!*i)
-            continue;
+void FASTCALL glitter_particle_manager_draw(GPM, int32_t alpha) {
+    glitter_scene** i;
+    glitter_scene* scene;
+    glitter_effect_inst** j;
 
-        glitter_scene_sub* scene = &(*i)->sub;
-        for (glitter_render_group** j = scene->render_groups.begin; j != scene->render_groups.end; j++)
-            if (*j && (*j)->alpha == alpha)
-                glitter_render_group_draw(scene, *j);
-    }
+    /*if (glt_type == GLITTER_X)
+        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++) {
+            if (!*i)
+                continue;
+
+            scene = *i;
+            for (j = scene->effects.begin; j != scene->effects.end; j++)
+                if (*j)
+                    glitter_x_effect_inst_draw(GPM_VAL, *j, alpha);
+        }
+    else*/
+        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++) {
+            if (!*i)
+                continue;
+
+            scene = *i;
+            for (j = scene->effects.begin; j != scene->effects.end; j++)
+                if (*j)
+                    glitter_effect_inst_draw(GPM_VAL, *j, alpha);
+        }
 }
 
-bool FASTCALL glitter_particle_manager_free_effect_group(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash) {
+bool FASTCALL glitter_particle_manager_free_effect_group(GPM, uint64_t effect_group_hash) {
     glitter_effect_group** i;
     glitter_effect_group* effect_group;
 
@@ -80,17 +120,18 @@ bool FASTCALL glitter_particle_manager_free_effect_group(glitter_particle_manage
             continue;
         }
 
-        if (effect_group)
-            glitter_effect_group_dispose(effect_group);
-        memmove(i, i + 1, sizeof(glitter_effect_group**) * (gpm->effect_groups.end - (i + 1)));
-        gpm->effect_groups.end--;
+        vector_ptr_glitter_effect_group_erase(&gpm->effect_groups,
+            i - gpm->effect_groups.begin, glitter_effect_group_dispose);
         break;
     }
     return i != gpm->effect_groups.end;
 }
 
-bool FASTCALL glitter_particle_manager_free_scene(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash) {
+void FASTCALL glitter_particle_manager_free_effect_groups(GPM) {
+    vector_ptr_glitter_effect_group_clear(&gpm->effect_groups, glitter_effect_group_dispose);
+}
+
+bool FASTCALL glitter_particle_manager_free_scene(GPM, uint64_t effect_group_hash) {
     glitter_scene** i;
     glitter_scene* scene;
 
@@ -101,61 +142,55 @@ bool FASTCALL glitter_particle_manager_free_scene(glitter_particle_manager* gpm,
             continue;
         }
 
-        glitter_scene_dispose(scene);
-        memmove(i, i + 1, sizeof(glitter_scene**) * (gpm->scenes.end - (i + 1)));
-        gpm->scenes.end--;
+        vector_ptr_glitter_scene_erase(&gpm->scenes, i - gpm->scenes.begin, glitter_scene_dispose);
         break;
     }
     return i != gpm->scenes.end;
 }
 
-size_t FASTCALL glitter_particle_manager_get_ctrl_count(glitter_particle_manager* gpm,
-    glitter_particle_type type) {
+void FASTCALL glitter_particle_manager_free_scenes(GPM) {
+    vector_ptr_glitter_scene_clear(&gpm->scenes, glitter_scene_dispose);
+}
+
+size_t FASTCALL glitter_particle_manager_get_ctrl_count(GPM, glitter_particle_type ptcl_type) {
     size_t ctrl;
     glitter_scene** i;
+    glitter_scene* scene;
+    glitter_effect_inst** j;
 
     ctrl = 0;
-    switch (type) {
-    case GLITTER_PARTICLE_QUAD:
-        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++)
-            ctrl += (*i)->sub.ctrl_quad;
-        break;
-    case GLITTER_PARTICLE_LINE:
-        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++)
-            ctrl += (*i)->sub.ctrl_line;
-        break;
-    case GLITTER_PARTICLE_LOCUS:
-        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++)
-            ctrl += (*i)->sub.ctrl_locus;
-        break;
+    for (i = gpm->scenes.begin; i != gpm->scenes.end; i++) {
+        if (!*i)
+            continue;
+
+        scene = *i;
+        for (j = scene->effects.begin; j != scene->effects.end; j++)
+            if (*j)
+                ctrl += glitter_effect_inst_get_ctrl_count(*j, ptcl_type);
     }
     return ctrl;
 }
 
-size_t FASTCALL glitter_particle_manager_get_disp_count(glitter_particle_manager* gpm,
-    glitter_particle_type type) {
+size_t FASTCALL glitter_particle_manager_get_disp_count(GPM, glitter_particle_type ptcl_type) {
     size_t disp;
     glitter_scene** i;
+    glitter_scene* scene;
+    glitter_effect_inst** j;
 
     disp = 0;
-    switch (type) {
-    case GLITTER_PARTICLE_QUAD:
-        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++)
-            disp += (*i)->sub.disp_quad;
-        break;
-    case GLITTER_PARTICLE_LINE:
-        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++)
-            disp += (*i)->sub.disp_line;
-        break;
-    case GLITTER_PARTICLE_LOCUS:
-        for (i = gpm->scenes.begin; i != gpm->scenes.end; i++)
-            disp += (*i)->sub.disp_locus;
-        break;
+    for (i = gpm->scenes.begin; i != gpm->scenes.end; i++) {
+        if (!*i)
+            continue;
+
+        scene = *i;
+        for (j = scene->effects.begin; j != scene->effects.end; j++)
+            if (*j)
+                disp += glitter_effect_inst_get_disp_count(*j, ptcl_type);
     }
     return disp;
 }
 
-void glitter_particle_manager_get_frame(glitter_particle_manager* gpm, float_t* frame, float_t* life_time) {
+void glitter_particle_manager_get_frame(GPM, float_t* frame, float_t* life_time) {
     glitter_scene* scene;
     glitter_effect_inst** i;
     glitter_effect_inst* effect;
@@ -172,15 +207,15 @@ void glitter_particle_manager_get_frame(glitter_particle_manager* gpm, float_t*
     scene = *gpm->scenes.begin;
     for (i = scene->effects.begin; i != scene->effects.end; i++) {
         effect = *i;
-        if (effect && frame && life_time && effect->data.life_time > *life_time) {
+        if (effect && frame && life_time && (float_t)effect->data.life_time > *life_time) {
             if (*frame < effect->frame)
                 *frame = effect->frame;
-            *life_time = effect->data.life_time;
+            *life_time = (float_t)effect->data.life_time;
         }
     }
 }
 
-void glitter_particle_manager_get_start_end_frame(glitter_particle_manager* gpm, float_t* start_frame, float_t* end_frame) {
+void glitter_particle_manager_get_start_end_frame(GPM, float_t* start_frame, float_t* end_frame) {
     glitter_scene* scene;
     glitter_effect_inst** i;
     glitter_effect_inst* effect;
@@ -206,9 +241,9 @@ void glitter_particle_manager_get_start_end_frame(glitter_particle_manager* gpm,
             continue;
 
         effect = *i;
-        life_time = effect->data.life_time;
-        if (start_frame && effect->data.appear_time < *start_frame)
-            *start_frame = effect->data.appear_time;
+        life_time = (float_t)effect->data.life_time;
+        if (start_frame && (float_t)effect->data.appear_time < *start_frame)
+            *start_frame = (float_t)effect->data.appear_time;
 
         for (j = effect->emitters.begin; j != effect->emitters.end; j++) {
             if (!*j)
@@ -216,18 +251,17 @@ void glitter_particle_manager_get_start_end_frame(glitter_particle_manager* gpm,
 
             emitter = *j;
             if (life_time < emitter->data.life_time)
-                life_time = emitter->data.life_time;
+                life_time = (float_t)emitter->data.life_time;
         }
 
-        life_time += effect->data.appear_time;
+        life_time += (float_t)effect->data.appear_time;
 
         if (end_frame && life_time > *end_frame)
             *end_frame = life_time;
     }
 }
 
-bool FASTCALL glitter_particle_manager_load_effect(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash, uint64_t effect_hash) {
+bool FASTCALL glitter_particle_manager_load_effect(GPM, uint64_t effect_group_hash, uint64_t effect_hash) {
     glitter_effect_group** i;
     glitter_effect_group* effect_group;
     glitter_scene** j;
@@ -255,15 +289,14 @@ bool FASTCALL glitter_particle_manager_load_effect(glitter_particle_manager* gpm
         for (k = effect_group->effects.begin, id = 1; k != effect_group->effects.end; k++, id++) {
             effect = *k;
             if (effect && effect->data.name_hash == effect_hash)
-                glitter_scene_init_effect(scene, effect, id, false);
+                glitter_scene_init_effect(GPM_VAL, scene, effect, id, false);
         }
         break;
     }
     return i != gpm->effect_groups.end;
 }
 
-bool FASTCALL glitter_particle_manager_load_scene(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash) {
+bool FASTCALL glitter_particle_manager_load_scene(GPM, uint64_t effect_group_hash) {
     glitter_effect_group** i;
     glitter_effect_group* effect_group;
     glitter_scene** j;
@@ -288,61 +321,50 @@ bool FASTCALL glitter_particle_manager_load_scene(glitter_particle_manager* gpm,
         }
 
         for (k = effect_group->effects.begin, id = 1; k != effect_group->effects.end; k++, id++)
-            glitter_scene_init_effect(scene, *k, id, false);
+            glitter_scene_init_effect(GPM_VAL, scene, *k, id, false);
         break;
     }
     return i != gpm->effect_groups.end;
 }
 
-void FASTCALL glitter_particle_manager_reset_scene_disp_counter(glitter_particle_manager* gpm) {
-    for (glitter_scene** i = gpm->scenes.begin; i != gpm->scenes.end; i++) {
-        if (!*i)
-            continue;
-
-        glitter_scene* scene = *i;
-        scene->sub.disp_quad = 0;
-        scene->sub.disp_locus = 0;
-        scene->sub.disp_line = 0;
-    }
-}
-
-void FASTCALL glitter_particle_manager_set_frame(glitter_particle_manager* gpm, glitter_effect_group* effect_group,
-    glitter_scene** scene, float_t curr_frame, float_t prev_frame, uint32_t random, uint32_t counter, bool reset) {
+void FASTCALL glitter_particle_manager_set_frame(GPM, glitter_effect_group* effect_group,
+    glitter_scene** scene, float_t curr_frame, float_t prev_frame, uint32_t counter, bool reset) {
     if (curr_frame < prev_frame || reset) {
-        for (glitter_scene** i = gpm->scenes.begin; i != gpm->scenes.end; )
-            if (!*i)
-                vector_ptr_glitter_scene_erase(&gpm->scenes, i - gpm->scenes.begin);
-            else
+        for (glitter_scene** i = gpm->scenes.begin; i != gpm->scenes.end; ) {
+            if (*i != *scene) {
                 i++;
+                continue;
+            }
 
-        gpm->random = random;
+            vector_ptr_glitter_scene_erase(&gpm->scenes, i - gpm->scenes.begin, glitter_scene_dispose);
+        }
         gpm->counter = counter;
 
+        glitter_scene* s = glitter_scene_init(effect_group);
+        vector_ptr_glitter_scene_push_back(&gpm->scenes, &s);
         glitter_effect_group* eg = effect_group;
         glitter_effect** i;
         size_t id = 1;
         for (i = eg->effects.begin, id = 1; i != eg->effects.end; i++, id++)
             if (*i)
-                glitter_scene_init_effect(*scene, *i, id, false);
+                glitter_scene_init_effect(GPM_VAL, s, *i, id, false);
+        *scene = s;
         prev_frame = 0.0f;
     }
 
     float_t delta = curr_frame - prev_frame;
-    float_t delta_frame = 2.0f;
+    float_t delta_frame = 1.0f;
     for (; delta > 0.0f; delta -= delta_frame) {
         if (delta_frame > delta)
             delta_frame = delta;
 
         glitter_scene* s = *scene;
-        if (s && !glitter_scene_has_ended(s, true)) {
-            glitter_scene_update_value_frame(s, delta_frame);
-            glitter_scene_emit(s, delta_frame);
-            glitter_scene_update_scene(s, delta_frame);
-        }
+        if (s && !glitter_scene_has_ended(s, true))
+            glitter_scene_update_value_frame(GPM_VAL, s, delta_frame);
     }
 }
 
-bool FASTCALL glitter_particle_manager_test_load_effect(glitter_particle_manager* gpm,
+bool FASTCALL glitter_particle_manager_test_load_effect(GPM,
     uint64_t effect_group_hash, uint64_t effect_hash) {
     glitter_effect_group** i;
     glitter_effect_group* effect_group;
@@ -371,15 +393,14 @@ bool FASTCALL glitter_particle_manager_test_load_effect(glitter_particle_manager
         for (k = effect_group->effects.begin, id = 1; k != effect_group->effects.end; k++, id++) {
             effect = *k;
             if (effect && effect->data.name_hash == effect_hash)
-                glitter_scene_init_effect(scene, effect, id, true);
+                glitter_scene_init_effect(GPM_VAL, scene, effect, id, true);
         }
         break;
     }
     return i != gpm->effect_groups.end;
 }
 
-bool FASTCALL glitter_particle_manager_test_load_scene(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash) {
+bool FASTCALL glitter_particle_manager_test_load_scene(GPM, uint64_t effect_group_hash, bool appear_now) {
     glitter_effect_group** i;
     glitter_effect_group* effect_group;
     glitter_scene** j;
@@ -404,17 +425,17 @@ bool FASTCALL glitter_particle_manager_test_load_scene(glitter_particle_manager*
         }
 
         for (k = effect_group->effects.begin, id = 1; k != effect_group->effects.end; k++, id++)
-            glitter_scene_init_effect(scene, *k, id, true);
+            glitter_scene_init_effect(GPM_VAL, scene, *k, id, appear_now);
         break;
     }
     return i != gpm->effect_groups.end;
 }
 
-void FASTCALL glitter_particle_manager_update_file_reader(glitter_particle_manager* gpm) {
+void FASTCALL glitter_particle_manager_update_file_reader(GPM) {
     for (glitter_file_reader** i = gpm->file_readers.begin; i != gpm->file_readers.end;) {
         if (*i) {
             glitter_file_reader* file_reader = *i;
-            if (glitter_file_reader_read(file_reader)) {
+            if (glitter_file_reader_read(GPM_VAL, file_reader)) {
                 file_reader->effect_group->emission = file_reader->emission;
                 if (file_reader->emission <= 0.0)
                     file_reader->effect_group->emission = gpm->emission;
@@ -422,37 +443,28 @@ void FASTCALL glitter_particle_manager_update_file_reader(glitter_particle_manag
             }
             else if (file_reader->effect_group)
                 glitter_effect_group_dispose(file_reader->effect_group);
-            glitter_file_reader_dispose(file_reader);
         }
-        vector_ptr_glitter_file_reader_erase(&gpm->file_readers, i - gpm->file_readers.begin);
+        vector_ptr_glitter_file_reader_erase(&gpm->file_readers,
+            i - gpm->file_readers.begin, glitter_file_reader_dispose);
     }
 }
 
-void FASTCALL glitter_particle_manager_update_scene(glitter_particle_manager* gpm) {
+void FASTCALL glitter_particle_manager_update_scene(GPM) {
     gpm->delta_frame = get_frame_speed();
     for (glitter_scene** i = gpm->scenes.begin; i != gpm->scenes.end;) {
         glitter_scene* scene = *i;
-        if (!scene)
-            goto copy_scenes;
-
-        if (glitter_scene_has_ended(scene, true)) {
-            glitter_scene_dispose(scene);
-
-        copy_scenes:
-            vector_ptr_glitter_scene_erase(&gpm->scenes, i - gpm->scenes.begin);
-        }
-        else {
-            glitter_scene_update_value_frame(scene, gpm->delta_frame);
-            glitter_scene_emit(scene, gpm->delta_frame);
-            glitter_scene_update_scene(scene, gpm->delta_frame);
+        if (scene && !glitter_scene_has_ended(scene, true)) {
+            glitter_scene_update_value_frame(GPM_VAL, scene, gpm->delta_frame);
             i++;
         }
+        else
+            vector_ptr_glitter_scene_erase(&gpm->scenes, i - gpm->scenes.begin, glitter_scene_dispose);
     }
 }
 
 void FASTCALL glitter_particle_manager_dispose(glitter_particle_manager* gpm) {
-    vector_ptr_glitter_scene_free(&gpm->scenes, (void*)glitter_scene_dispose);
-    vector_ptr_glitter_file_reader_free(&gpm->file_readers, (void*)glitter_file_reader_dispose);
-    vector_ptr_glitter_effect_group_free(&gpm->effect_groups, (void*)glitter_effect_group_dispose);
+    vector_ptr_glitter_scene_free(&gpm->scenes, glitter_scene_dispose);
+    vector_ptr_glitter_file_reader_free(&gpm->file_readers, glitter_file_reader_dispose);
+    vector_ptr_glitter_effect_group_free(&gpm->effect_groups, glitter_effect_group_dispose);
     free(gpm);
 }

src/CRE/Glitter/particle_manager.h

@@ -8,37 +8,28 @@
 #include "glitter.h"
 
 extern glitter_particle_manager* FASTCALL glitter_particle_manager_init();
-extern bool FASTCALL glitter_particle_manager_check_effect_group(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash);
-extern bool FASTCALL glitter_particle_manager_check_file_reader(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash);
-extern bool FASTCALL glitter_particle_manager_check_scene(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash);
-extern void FASTCALL glitter_particle_manager_draw(glitter_particle_manager* gpm, int32_t alpha);
-extern bool FASTCALL glitter_particle_manager_free_scene(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash);
-extern bool FASTCALL glitter_particle_manager_free_effect_group(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash);
-extern size_t FASTCALL glitter_particle_manager_get_ctrl_count(glitter_particle_manager* gpm,
-    glitter_particle_type type);
-extern size_t FASTCALL glitter_particle_manager_get_disp_count(glitter_particle_manager* gpm,
-    glitter_particle_type type);
-extern void glitter_particle_manager_get_frame(glitter_particle_manager* gpm,
-    float_t* frame, float_t* life_time);
-extern void glitter_particle_manager_get_start_end_frame(glitter_particle_manager* gpm,
-    float_t* start_frame, float_t* end_frame);
-extern bool FASTCALL glitter_particle_manager_load_effect(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash, uint64_t effect_hash);
-extern bool FASTCALL glitter_particle_manager_load_scene(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash);
-extern void FASTCALL glitter_particle_manager_reset_scene_disp_counter(glitter_particle_manager* gpm);
-extern void FASTCALL glitter_particle_manager_set_frame(glitter_particle_manager* gpm,
+extern void FASTCALL glitter_particle_manager_calc_draw(GPM,
+    bool(FASTCALL* render_add_list_func)(glitter_particle_mesh*, vec4*, mat4*, mat4*));
+extern bool FASTCALL glitter_particle_manager_check_effect_group(GPM, uint64_t effect_group_hash);
+extern bool FASTCALL glitter_particle_manager_check_file_reader(GPM, uint64_t effect_group_hash);
+extern bool FASTCALL glitter_particle_manager_check_scene(GPM, uint64_t effect_group_hash);
+extern void FASTCALL glitter_particle_manager_draw(GPM, int32_t alpha);
+extern bool FASTCALL glitter_particle_manager_free_effect_group(GPM, uint64_t effect_group_hash);
+extern void FASTCALL glitter_particle_manager_free_effect_groups(GPM);
+extern bool FASTCALL glitter_particle_manager_free_scene(GPM, uint64_t effect_group_hash);
+extern void FASTCALL glitter_particle_manager_free_scenes(GPM);
+extern size_t FASTCALL glitter_particle_manager_get_ctrl_count(GPM, glitter_particle_type ptcl_type);
+extern size_t FASTCALL glitter_particle_manager_get_disp_count(GPM, glitter_particle_type ptcl_type);
+extern void glitter_particle_manager_get_frame(GPM, float_t* frame, float_t* life_time);
+extern void glitter_particle_manager_get_start_end_frame(GPM, float_t* start_frame, float_t* end_frame);
+extern bool FASTCALL glitter_particle_manager_load_effect(GPM, uint64_t effect_group_hash, uint64_t effect_hash);
+extern bool FASTCALL glitter_particle_manager_load_scene(GPM, uint64_t effect_group_hash);
+extern void FASTCALL glitter_particle_manager_set_frame(GPM,
     glitter_effect_group* effect_group, glitter_scene** scene, float_t curr_frame,
-    float_t prev_frame, uint32_t random, uint32_t counter, bool reset);
-extern bool FASTCALL glitter_particle_manager_test_load_effect(glitter_particle_manager* gpm,
+    float_t prev_frame, uint32_t counter, bool reset);
+extern bool FASTCALL glitter_particle_manager_test_load_effect(GPM,
     uint64_t effect_group_hash, uint64_t effect_hash);
-extern bool FASTCALL glitter_particle_manager_test_load_scene(glitter_particle_manager* gpm,
-    uint64_t effect_group_hash);
-extern void FASTCALL glitter_particle_manager_update_file_reader(glitter_particle_manager* gpm);
-extern void FASTCALL glitter_particle_manager_update_scene(glitter_particle_manager* gpm);
+extern bool FASTCALL glitter_particle_manager_test_load_scene(GPM, uint64_t effect_group_hash, bool appear_now);
+extern void FASTCALL glitter_particle_manager_update_file_reader(GPM);
+extern void FASTCALL glitter_particle_manager_update_scene(GPM);
 extern void FASTCALL glitter_particle_manager_dispose(glitter_particle_manager* gpm);

src/CRE/Glitter/random.c

@@ -1105,67 +1105,278 @@ static const uint16_t glitter_short_int_table[] = {
     0x31EB, 0x3F4F, 0x08A1, 0x5EC1, 0xD52D, 0xDAE8, 0x2363, 0x7A22,
 };
 
-extern glitter_particle_manager* gpm;
+static const uint32_t glitter_x_float_table[] = {
+    0x3ED6C16C, 0x3E444444, 0x3EFA4FA5, 0x3ECFA4FA, 0x3F271C72, 0x3F244444,
+    0x3F1E93E9, 0x3F016C17, 0x3E527D28, 0x3E777777, 0x3E9DDDDE, 0x3F7D27D2,
+    0x3F666666, 0x3EF60B61, 0x3E7A4FA5, 0x3E4CCCCD, 0x3F4E38E4, 0x3F4B60B6,
+    0x3E0B60B6, 0x3E360B61, 0x3E666666, 0x3F51C71C, 0x3F47D27D, 0x3F19999A,
+    0x3F64FA50, 0x3F355555, 0x3F3A4FA5, 0x3F4FA4FA, 0x3F7F49F5, 0x3EE4FA50,
+    0x3DF49F4A, 0x3F177777, 0x3DC16C17, 0x3EDF49F5, 0x3F6B60B6, 0x3ECB60B6,
+    0x3F088889, 0x3F4EEEEF, 0x3F638E39, 0x3E749F4A, 0x3F49F49F, 0x3F36C16C,
+    0x3D4CCCCD, 0x3E000000, 0x3E5B05B0, 0x3F5BBBBC, 0x3EF49F4A, 0x3E24FA50,
+    0x3D088888, 0x3EEC16C1, 0x3E9F49F5, 0x3F58E38E, 0x3F11C71C, 0x3E7D27D2,
+    0x3F7E93E9, 0x3ECE38E4, 0x3C638E39, 0x3F7A4FA5, 0x3DCCCCCD, 0x3F0AAAAB,
+    0x3F533333, 0x3F416C17, 0x3C360B61, 0x3EB05B06, 0x3F4C16C1, 0x3EE7D27D,
+    0x3F488889, 0x3F511111, 0x3F111111, 0x3F0CCCCD, 0x3F160B61, 0x3F1A4FA5,
+    0x3F705B06, 0x3F105B06, 0x3DAAAAAB, 0x3EF33333, 0x3F400000, 0x3EAC16C1,
+    0x3F5F49F5, 0x3E927D28, 0x3F493E94, 0x3EF05B06, 0x3EAD82D8, 0x3EDB05B0,
+    0x3E8CCCCD, 0x3E89F49F, 0x3F45B05B, 0x3F155555, 0x3EFD27D2, 0x3F29F49F,
+    0x3F0FA4FA, 0x3F555555, 0x3CB60B61, 0x3E911111, 0x3E93E93F, 0x3ED9999A,
+    0x3E96C16C, 0x3F40B60B, 0x3E9B05B0, 0x3EF8E38E, 0x3F711111, 0x3F133333,
+    0x3EEEEEEF, 0x3F727D28, 0x3F093E94, 0x3F0B60B6, 0x3EFE93E9, 0x3F6EEEEF,
+    0x3F733333, 0x3E416C17, 0x3F071C72, 0x3F09F49F, 0x3F238E39, 0x3E3BBBBC,
+    0x3EC00000, 0x3E49F49F, 0x3F360B61, 0x3ECCCCCD, 0x3F305B06, 0x3F67D27D,
+    0x3F200000, 0x3EF1C71C, 0x3F4D82D8, 0x3F582D83, 0x3EDDDDDE, 0x3D93E93F,
+    0x3F327D28, 0x3ED82D83, 0x3F00B60B, 0x3F25B05B, 0x3F3DDDDE, 0x3EBA4FA5,
+    0x3E333333, 0x3E5DDDDE, 0x3EE0B60B, 0x3D8E38E3, 0x3F0E38E4, 0x3E222222,
+    0x3D82D82E, 0x3EDC71C7, 0x3F7DDDDE, 0x3EE93E94, 0x3E0E38E4, 0x3EA66666,
+    0x3F022222, 0x3E2AAAAB, 0x3E111111, 0x3EC71C72, 0x3CE38E39, 0x3E982D83,
+    0x3F288889, 0x3D582D83, 0x3E16C16C, 0x3E471C72, 0x3E800000, 0x3ED3E93F,
+    0x3EA93E94, 0x3EA38E39, 0x3F382D83, 0x3F38E38E, 0x3F3BBBBC, 0x3F293E94,
+    0x3F3B05B0, 0x3D99999A, 0x3F0D82D8, 0x3E1F49F5, 0x3F4CCCCD, 0x3F22D82E,
+    0x3F577777, 0x3E02D82E, 0x3DE38E39, 0x3DD27D28, 0x3EE66666, 0x3F6CCCCD,
+    0x3F149F4A, 0x3F44FA50, 0x3F600000, 0x3EC16C17, 0x3F2EEEEF, 0x3EB33333,
+    0x3F333333, 0x3F2C16C1, 0x3F5C71C7, 0x3F066666, 0x3F466666, 0x3EB60B61,
+    0x3F182D83, 0x3B360B62, 0x3F2AAAAB, 0x3C9F49F4, 0x3F2FA4FA, 0x3F3F49F5,
+    0x3DB60B61, 0x3F311111, 0x3F755555, 0x3ED55555, 0x3EC2D82E, 0x3F622222,
+    0x3EC5B05B, 0x3F7C71C7, 0x3F13E93F, 0x3F18E38E, 0x3D2AAAAB, 0x3E2D82D8,
+    0x3F377777, 0x3F038E39, 0x3F5E93E9, 0x3DC71C72, 0x3F59999A, 0x3F222222,
+    0x3DA4FA50, 0x3F53E93F, 0x3F1D27D2, 0x3BB60B62, 0x3EB8E38E, 0x3DBBBBBC,
+    0x3F422222, 0x3E582D83, 0x3EAAAAAB, 0x3F644444, 0x3F0C16C1, 0x3D1F49F5,
+    0x3DE93E94, 0x3F671C72, 0x3F04FA50, 0x3EE22222, 0x3CFA4FA5, 0x3F31C71C,
+    0x3EC44444, 0x3E05B05B, 0x3F2CCCCD, 0x3E9C71C7, 0x3DB05B06, 0x3E99999A,
+    0x3E8FA4FA, 0x3EA7D27D, 0x3F5A4FA5, 0x3F000000, 0x3E955555, 0x3E888889,
+    0x3F5D27D2, 0x3E871C72, 0x3DEEEEEF, 0x3F2E38E4, 0x3D638E39, 0x3EFBBBBC,
+    0x3F24FA50, 0x3F69F49F, 0x3E1C71C7, 0x3EBE93E9, 0x3D6EEEEF, 0x3DFA4FA5,
+    0x3E6EEEEF, 0x3F6C16C1, 0x3F6D82D8, 0x3F71C71C, 0x3F505B06, 0x3D416C17,
+    0x3DD82D83, 0x3F4AAAAB, 0x3F782D83, 0x3F349F4A, 0x3EB1C71C, 0x3F42D82E,
+    0x3EBBBBBC, 0x3F1B05B0, 0x3F1F49F5, 0x3E816C17, 0x3D9F49F5, 0x3EC88889,
+    0x3F127D28, 0x3F60B60B, 0x3F07D27D, 0x3E19999A, 0x3E693E94, 0x3EA22222,
+    0x3ED27D28, 0x3E27D27D, 0x3F39999A, 0x3EB77777, 0x3E844444, 0x3E8B60B6,
+    0x3D7A4FA5, 0x3E4FA4FA, 0x3EAEEEEF, 0x3F6AAAAB, 0x3F05B05B, 0x3F438E39,
+    0x3E60B60B, 0x3F56C16C, 0x3EE38E39, 0x3E3E93E9, 0x3F549F4A, 0x3E555555,
+    0x3EA0B60B, 0x3F2B60B6, 0x3F7BBBBC, 0x3F33E93F, 0x3EBD27D2, 0x3E71C71C,
+    0x3F6FA4FA, 0x3E305B06, 0x3E38E38E, 0x3EED82D8, 0x3F65B05B, 0x3D13E93F,
+    0x3F616C17, 0x3F0EEEEF, 0x3F1C71C7, 0x3E13E93F, 0x3DDDDDDE, 0x3F6E38E4,
+    0x3F27D27D, 0x3ED11111, 0x3F777777, 0x3EEAAAAB, 0x3F1BBBBC, 0x3F1DDDDE,
+    0x3F216C17, 0x3F78E38E, 0x3C888889, 0x3F3C71C7, 0x3F7B05B0, 0x3F3D27D2,
+    0x3F79999A, 0x3F688889, 0x3E82D82E, 0x3EF77777, 0x3F2D82D8, 0x3F471C72,
+    0x3C088888, 0x3F560B61, 0x3E088889, 0x3CCCCCCD, 0x3F266666, 0x3F20B60B,
+    0x3F527D28, 0x3F02D82E, 0x3F760B61, 0x3F044444, 0x3F73E93F, 0x3F749F4A,
+    0x3F76C16C, 0x3F693E94, 0x3E85B05B, 0x3F16C16C, 0x3F5B05B0, 0x3E638E39,
+    0x3D360B61, 0x3F5DDDDE, 0x3F800000, 0x3F3E93E9, 0x3E6C16C1, 0x3F62D82E,
+    0x3E8E38E4, 0x3EB49F4A, 0x3EA4FA50, 0x3D888889, 0x3EC9F49F, 0x3F444444,
+    0x00000000,
+};
 
-int32_t FASTCALL glitter_random_get() {
-    if (gpm->f2)
-        return gpm->random & 0xFF;
-    else
-        return gpm->random & 0xFFF;
+static const uint32_t glitter_x_int_table[] = {
+    0x01663B, 0x0093BA, 0x00B6DF, 0x0055FA, 0x00056F, 0x0171E9,
+    0x0178BD, 0x011C5E, 0x00C875, 0x015832, 0x015785, 0x00C379,
+    0x0037A2, 0x000FF8, 0x015A7B, 0x000E5C, 0x00AAE9, 0x00FD61,
+    0x017CC5, 0x015F51, 0x005FF9, 0x00C80E, 0x0126BB, 0x002AAF,
+    0x000819, 0x003108, 0x01558D, 0x017865, 0x008D3E, 0x012244,
+    0x018678, 0x00D564, 0x005E24, 0x015636, 0x00A338, 0x0122E0,
+    0x01514C, 0x014F2D, 0x0068E0, 0x013B24, 0x00E6D9, 0x011423,
+    0x013816, 0x01781F, 0x00EF31, 0x003FAD, 0x00BEC7, 0x007246,
+    0x0075B9, 0x006AEE, 0x000F74, 0x01359E, 0x00DC34, 0x004403,
+    0x001824, 0x00EBE9, 0x015E3F, 0x00ED52, 0x0126D1, 0x016D82,
+    0x0091B7, 0x006BF1, 0x00BFEA, 0x001196, 0x011653, 0x001449,
+    0x0141B7, 0x00411C, 0x015AB9, 0x00801A, 0x00A886, 0x006090,
+    0x006D66, 0x01158A, 0x009F27, 0x01445E, 0x00A906, 0x00AB11,
+    0x00D04E, 0x017DB5, 0x0158C4, 0x016426, 0x006C1E, 0x009A72,
+    0x00282E, 0x000FA1, 0x017C80, 0x00C25A, 0x003199, 0x0173A9,
+    0x004F33, 0x015650, 0x00490F, 0x007A69, 0x0059BF, 0x016CD1,
+    0x0055EB, 0x012437, 0x00844E, 0x0090D4, 0x01556B, 0x00FD65,
+    0x00B7CD, 0x001B58, 0x017541, 0x011A31, 0x015541, 0x0127FE,
+    0x0145F8, 0x00217F, 0x00455F, 0x00FDD8, 0x01274D, 0x00A8B1,
+    0x001FF4, 0x001FB8, 0x004E42, 0x016D7F, 0x005B3C, 0x009095,
+    0x00164C, 0x0100CB, 0x0002AB, 0x0142A3, 0x01069B, 0x0006EB,
+    0x008435, 0x01515E, 0x0007F2, 0x018338, 0x014AAC, 0x00EE95,
+    0x014270, 0x01142A, 0x0096B8, 0x00B296, 0x010F88, 0x004CD4,
+    0x006AE6, 0x0171D5, 0x00AD6A, 0x00CCD6, 0x010438, 0x006666,
+    0x001999, 0x004F4B, 0x014C6C, 0x007EB4, 0x00E148, 0x013BE6,
+    0x000043, 0x016EEE, 0x009CE8, 0x0061EB, 0x00490F, 0x011738,
+    0x00C02B, 0x00B9ED, 0x00EE7A, 0x00D519, 0x011F19, 0x0075D6,
+    0x000F80, 0x0060D9, 0x004F77, 0x017B63, 0x007703, 0x0098D1,
+    0x00C6F4, 0x014926, 0x00E2B6, 0x00BBBF, 0x001F02, 0x00C3AA,
+    0x009C82, 0x0100A9, 0x00EA47, 0x0096D8, 0x012610, 0x018129,
+    0x012C41, 0x00F131, 0x00F16E, 0x015509, 0x00D544, 0x011686,
+    0x012F14, 0x016F80, 0x0012D6, 0x008D8D, 0x006245, 0x0155AF,
+    0x007E83, 0x00B8E7, 0x002165, 0x016124, 0x01190D, 0x00D764,
+    0x0127F5, 0x00163B, 0x0043C1, 0x010F0C, 0x00C855, 0x002D18,
+    0x014DA5, 0x0176B9, 0x0017B8, 0x01351C, 0x011656, 0x00D94F,
+    0x00FDAF, 0x015F3B, 0x00B41D, 0x013BAB, 0x0151CB, 0x00D8D3,
+    0x00FFF2, 0x003DE4, 0x000D45, 0x0148C2, 0x016F76, 0x01661C,
+    0x007CF7, 0x006069, 0x009101, 0x006D63, 0x00A21D, 0x006F29,
+    0x00E4D9, 0x00A2EF, 0x010C9B, 0x0172E4, 0x002BB3, 0x016C4E,
+    0x00C257, 0x010995, 0x0141F2, 0x013BE8, 0x005100, 0x01459E,
+    0x00DE88, 0x00FB44, 0x00F02D, 0x0050CA, 0x004BF9, 0x014505,
+    0x00083F, 0x006644, 0x008898, 0x00E94B, 0x005EB3, 0x0094D1,
+    0x008948, 0x0180C8, 0x00D50F, 0x01372D, 0x00204E, 0x00D42A,
+    0x0062EF, 0x001055, 0x00C41D, 0x0039A3, 0x002732, 0x004493,
+    0x01070E, 0x015484, 0x0068F3, 0x0084F1, 0x00A7E4, 0x00ABE7,
+    0x015650, 0x0063B1, 0x00A3C2, 0x00B8DD, 0x0128E3, 0x006306,
+    0x012526, 0x0104BD, 0x007589, 0x005E02, 0x008BB4, 0x00DDD3,
+    0x003A2C, 0x012687, 0x010E85, 0x017A83, 0x00F342, 0x00B1C4,
+    0x006B1F, 0x016D1E, 0x00FA31, 0x0039B6, 0x012987, 0x0006B8,
+    0x01319A, 0x009296, 0x0152B6, 0x007B87, 0x00E665, 0x012124,
+    0x004CF2, 0x0133C8, 0x01838B, 0x009530, 0x017C0A, 0x01196B,
+    0x0124EC, 0x01512F, 0x000008, 0x01019B, 0x00CA28, 0x00D76F,
+    0x001882, 0x002191, 0x015356, 0x00499B, 0x013138, 0x0170E2,
+    0x00F046, 0x01480E, 0x013456, 0x017BCB, 0x003691, 0x0004F3,
+    0x00ECAE, 0x004AEA, 0x01460E, 0x0053CA, 0x000D17, 0x011A78,
+    0x000869, 0x00C190, 0x0130BB, 0x00FFEF, 0x013B73, 0x0103DB,
+    0x00885A, 0x00A503, 0x0038BC, 0x005B4A, 0x0150B5, 0x016CAB,
+    0x0167AF, 0x006396, 0x00528E, 0x00156C, 0x016428, 0x00D508,
+    0x0178F0, 0x00512B, 0x005CFC, 0x004098, 0x005897, 0x001F27,
+    0x0073DA, 0x00F12C, 0x016CBA, 0x007417, 0x009A1C, 0x00D3D0,
+    0x000001,
+};
+
+int32_t FASTCALL glitter_random_get_value(glitter_random* random) {
+    return random->value;
 }
 
-float_t FASTCALL glitter_random_get_float_clamp(float_t min, float_t max) {
+float_t FASTCALL glitter_random_get_float(GPM, glitter_random* random, float_t value) {
+    float_t val;
+
+    switch (glt_type) {
+    default:
+    case GLITTER_AFT:
+        val = *(float_t*)&glitter_full_float_table[random->value % 0x1000];
+        break;
+    case GLITTER_F2:
+        val = *(float_t*)&glitter_short_float_table[random->value % 0x100];
+        break;
+    case GLITTER_X:
+        val = *(float_t*)&glitter_x_float_table[random->value % 0x169];
+        break;
+    }
+    random->value += random->step;
+    return val * (value * 2.0f) - value;
+}
+
+float_t FASTCALL glitter_random_get_float_min_max(GPM, glitter_random* random, float_t min, float_t max) {
     float_t value;
 
-    if (gpm->f2)
-        value = *(float_t*)&glitter_short_float_table[gpm->random++ & 0xFF];
-    else
-        value = *(float_t*)&glitter_full_float_table[gpm->random++ & 0xFFF];
+    switch (glt_type) {
+    default:
+    case GLITTER_AFT:
+        value = *(float_t*)&glitter_full_float_table[random->value % 0x1000];
+        break;
+    case GLITTER_F2:
+        value = *(float_t*)&glitter_short_float_table[random->value % 0x100];
+        break;
+    case GLITTER_X:
+        value = *(float_t*)&glitter_x_float_table[random->value % 0x169];
+        break;
+    }
+    random->value += random->step;
     return value * (max - min) + min;
 }
 
-float_t FASTCALL glitter_random_get_float_clamp_min_max(float_t value) {
-    return glitter_random_get_float_clamp(-value, value);
+void FASTCALL glitter_random_get_vec3(GPM, glitter_random* random, vec3* src, vec3* dst) {
+    vec3 val;
+    vec3 t;
+
+    switch (glt_type) {
+    default:
+    case GLITTER_AFT:
+        val.x = *(float_t*)&glitter_full_float_table[random->value % 0x1000];
+        random->value += random->step;
+        val.y = *(float_t*)&glitter_full_float_table[random->value % 0x1000];
+        random->value += random->step;
+        val.z = *(float_t*)&glitter_full_float_table[random->value % 0x1000];
+        random->value += random->step;
+        break;
+    case GLITTER_F2:
+        val.x = *(float_t*)&glitter_short_float_table[random->value % 0x100];
+        random->value += random->step;
+        val.y = *(float_t*)&glitter_short_float_table[random->value % 0x100];
+        random->value += random->step;
+        val.z = *(float_t*)&glitter_short_float_table[random->value % 0x100];
+        random->value += random->step;
+        break;
+    case GLITTER_X:
+        val.x = *(float_t*)&glitter_x_float_table[random->value % 0x169];
+        random->value += random->step;
+        val.y = *(float_t*)&glitter_x_float_table[random->value % 0x169];
+        random->value += random->step;
+        val.z = *(float_t*)&glitter_x_float_table[random->value % 0x169];
+        random->value += random->step;
+        break;
+    }
+    t = *src;
+    vec3_add(t, t, t);
+    vec3_mult(val, t, t);
+    vec3_sub(t, *src, *dst);
 }
 
-void FASTCALL glitter_random_get_float_vec3_clamp(vec3* src, vec3* dst) {
-    dst->x = glitter_random_get_float_clamp_min_max(src->x);
-    dst->y = glitter_random_get_float_clamp_min_max(src->y);
-    dst->z = glitter_random_get_float_clamp_min_max(src->z);
-}
-
-int32_t FASTCALL glitter_random_get_int(int32_t value) {
+int32_t FASTCALL glitter_random_get_int(GPM, glitter_random* random, int32_t value) {
     int32_t val;
-    if (gpm->f2)
-        val = glitter_short_int_table[gpm->random++ & 0xFF];
-    else
-        val = glitter_full_int_table[gpm->random++ & 0xFFF];
+    switch (glt_type) {
+    default:
+    case GLITTER_AFT:
+        val = glitter_full_int_table[random->value % 0x1000];
+        break;
+    case GLITTER_F2:
+        val = glitter_short_int_table[random->value % 0x100];
+        break;
+    case GLITTER_X:
+        val = glitter_x_int_table[random->value % 0x169];
+        break;
+    }
+    random->value += random->step;
     return val % value;
 }
 
-int32_t FASTCALL glitter_random_get_int_clamp(int32_t min, int32_t max) {
+int32_t FASTCALL glitter_random_get_int_min_max(GPM, glitter_random* random, int32_t min, int32_t max) {
     int32_t value;
 
     if (max == min)
         return min;
 
-    if (gpm->f2)
-        value = glitter_short_int_table[gpm->random++ & 0xFF];
-    else
-        value = glitter_full_int_table[gpm->random++ & 0xFFF];
+    switch (glt_type) {
+    default:
+    case GLITTER_AFT:
+        value = glitter_full_int_table[random->value % 0x1000];
+        break;
+    case GLITTER_F2:
+        value = glitter_short_int_table[random->value % 0x100];
+        break;
+    case GLITTER_X:
+        value = glitter_x_int_table[random->value % 0x169];
+        break;
+    }
+    random->value += random->step;
     return value % (max - min) + min;
 }
 
-int32_t FASTCALL glitter_random_get_max() {
-    if (gpm->f2)
-        return 0x100;
-    else
+int32_t FASTCALL glitter_random_get_max(GPM) {
+    switch (glt_type) {
+    default:
+    case GLITTER_AFT:
         return 0x1000;
+    case GLITTER_F2:
+        return 0x100;
+    case GLITTER_X:
+        return 0x169;
+    }
 }
 
-void FASTCALL glitter_random_set(int32_t value) {
-    if (gpm->f2)
-        gpm->random = value & 0xFF;
-    else
-        gpm->random = value & 0xFFF;
+void FASTCALL glitter_random_reset(glitter_random* random) {
+    random->value = 0;
+    random->step = 1;
+}
+
+void FASTCALL glitter_random_set_step(glitter_random* random, uint8_t step) {
+    random->step = step;
+}
+
+void FASTCALL glitter_random_set_value(glitter_random* random, int32_t value) {
+    random->value = value;
+}
+
+void FASTCALL glitter_random_step_value(glitter_random* random) {
+    random->value += random->step;
 }

src/CRE/Glitter/random.h

@@ -7,11 +7,19 @@
 
 #include "glitter.h"
 
-extern int32_t FASTCALL glitter_random_get();
-extern float_t FASTCALL glitter_random_get_float_clamp(float_t min, float_t max);
-extern float_t FASTCALL glitter_random_get_float_clamp_min_max(float_t value);
-extern void FASTCALL glitter_random_get_float_vec3_clamp(vec3* src, vec3* dst);
-extern int32_t FASTCALL glitter_random_get_int(int32_t value);
-extern int32_t FASTCALL glitter_random_get_int_clamp(int32_t min, int32_t max);
-extern int32_t FASTCALL glitter_random_get_max();
-extern void FASTCALL glitter_random_set(int32_t value);
+extern int32_t FASTCALL glitter_random_get_value(glitter_random* random);
+extern float_t FASTCALL glitter_random_get_float(GPM,
+    glitter_random* random, float_t value);
+extern float_t FASTCALL glitter_random_get_float_min_max(GPM,
+    glitter_random* random, float_t min, float_t max);
+extern void FASTCALL glitter_random_get_vec3(GPM,
+    glitter_random* random, vec3* src, vec3* dst);
+extern int32_t FASTCALL glitter_random_get_int(GPM,
+    glitter_random* random, int32_t value);
+extern int32_t FASTCALL glitter_random_get_int_min_max(GPM,
+    glitter_random* random, int32_t min, int32_t max);
+extern int32_t FASTCALL glitter_random_get_max(GPM);
+extern void FASTCALL glitter_random_reset(glitter_random* random);
+extern void FASTCALL glitter_random_set_step(glitter_random* random, uint8_t step);
+extern void FASTCALL glitter_random_set_value(glitter_random* random, int32_t value);
+extern void FASTCALL glitter_random_step_value(glitter_random* random);

src/CRE/Glitter/render_element.c

@@ -0,0 +1,468 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "render_element.h"
+#include "counter.h"
+#include "curve.h"
+#include "emitter_inst.h"
+#include "locus_history.h"
+#include "particle_inst.h"
+#include "random.h"
+
+static void FASTCALL glitter_render_element_accelerate(GPM, glitter_particle_inst* a1,
+    glitter_render_element* a2, float_t delta_frame, glitter_random* random);
+static void FASTCALL glitter_render_element_step_uv(GPM, glitter_particle_inst* a1,
+    glitter_render_element* a2, float_t delta_frame, glitter_random* random);
+
+void FASTCALL glitter_render_element_emit(GPM,
+    glitter_particle_inst* a1, glitter_render_element* a2, glitter_emitter_inst* a3,
+    glitter_particle_inst_data* a4, int32_t index, uint8_t step, glitter_random* random) {
+    float_t speed;
+    float_t deceleration;
+    vec3 direction;
+    vec3 base_translation;
+    vec3 scale;
+    vec3 external_acceleration;
+    vec3 direction_random;
+    int32_t max_uv;
+    bool copy_mat;
+
+    a2->random.value = glitter_random_get_value(random);
+    a2->random.step = step;
+    a2->frame = 0.0f;
+    a2->rebound_frame = 0.0f;
+    a2->uv = vec2_null;
+    a2->uv_index = a4->data.uv_index;
+
+    a2->fade_in_frames = 0.0f;
+    a2->fade_out_frames = 0.0f;
+    a2->life_time = (float_t)a4->data.life_time;
+
+    a2->color = a4->data.color;
+    if (a4->data.draw_type == GLITTER_DIRECTION_PARTICLE_ROTATION) {
+        a2->rotation.x = glitter_random_get_float(GPM_VAL, random, a4->data.rotation_random.x)
+            + a4->data.rotation.x;
+        a2->rotation_add.x = glitter_random_get_float(GPM_VAL, random, a4->data.rotation_add_random.x)
+            + a4->data.rotation_add.x;
+        a2->rotation.y = glitter_random_get_float(GPM_VAL, random, a4->data.rotation_random.y)
+            + a4->data.rotation.y;
+        a2->rotation_add.y = glitter_random_get_float(GPM_VAL, random, a4->data.rotation_add_random.y)
+            + a4->data.rotation_add.y;
+    }
+    else {
+        a2->rotation.x = 0.0f;
+        a2->rotation.y = 0.0f;
+        a2->rotation_add.x = 0.0f;
+        a2->rotation_add.y = 0.0f;
+    }
+    a2->rotation.z = glitter_random_get_float(GPM_VAL, random, a4->data.rotation_random.z)
+        + a4->data.rotation.z;
+    a2->rotation_add.z = glitter_random_get_float(GPM_VAL, random, a4->data.rotation_add_random.z)
+        + a4->data.rotation_add.z;
+    a2->uv_scroll = vec2_null;
+    a2->uv_scroll_2nd = vec2_null;
+    a2->scale = vec3_identity;
+    a2->scale_all = 1.0f;
+    a2->frame_step_uv = (float_t)a4->data.frame_step_uv;
+
+    a2->scale_particle.x = glitter_random_get_float(GPM_VAL, random, a4->data.scale_random.x)
+        + a4->data.scale.x;
+    if (a4->data.flags & GLITTER_PARTICLE_SCALE_Y_BY_X)
+        a2->scale_particle.y = a2->scale_particle.x;
+    else
+        a2->scale_particle.y = glitter_random_get_float(GPM_VAL, random, a4->data.scale_random.y)
+        + a4->data.scale.y;
+
+    max_uv = a4->data.split_u * a4->data.split_v;
+    if (max_uv > 1 && a4->data.uv_index_count > 1) {
+        switch (a4->data.uv_index_type) {
+        case GLITTER_UV_INDEX_INITIAL_RANDOM_FIXED:
+        case GLITTER_UV_INDEX_INITIAL_RANDOM_FORWARD:
+        case GLITTER_UV_INDEX_INITIAL_RANDOM_REVERSE:
+            a2->uv_index += glitter_random_get_int(GPM_VAL, random, a4->data.uv_index_count);
+            break;
+        }
+        a2->uv_index = min(a2->uv_index, a4->data.uv_index_end);
+        a2->uv.x = (float_t)(a2->uv_index % a1->data.data.split_u) * a1->data.data.split_uv.x;
+        a2->uv.y = (float_t)(a2->uv_index / a1->data.data.split_u) * a1->data.data.split_uv.y;
+    }
+
+    if (a4->data.flags & (GLITTER_PARTICLE_EMITTER_LOCAL | GLITTER_PARTICLE_ROTATE_BY_EMITTER))
+        a2->base_translation = vec3_null;
+    else
+        mat4_get_translation(&a3->mat, &a2->base_translation);
+
+    direction = a4->data.direction;
+    base_translation = vec3_null;
+    if (a4->data.flags & GLITTER_PARTICLE_EMITTER_LOCAL) {
+        scale = vec3_identity;
+        glitter_emitter_inst_get_mesh_by_type(GPM_VAL, a3, index, &scale, &base_translation, &direction, random);
+    }
+    else {
+        vec3_mult_scalar(a3->scale, a3->scale_all, scale);
+        glitter_emitter_inst_get_mesh_by_type(GPM_VAL, a3, index, &scale, &base_translation, &direction, random);
+        mat4_mult_vec3(&a3->mat_no_scale, &base_translation, &base_translation);
+    }
+
+    vec3_add(a2->base_translation, base_translation, a2->base_translation);
+    a2->translation = a2->base_translation;
+    a2->translation_prev = a2->base_translation;
+    glitter_random_get_vec3(GPM_VAL, random, &a4->data.direction_random, &direction_random);
+    vec3_add(direction, direction_random, direction);
+    vec3_normalize(direction, direction);
+
+    if (~a4->data.flags & GLITTER_PARTICLE_EMITTER_LOCAL)
+        mat4_mult_vec3(&a3->mat_no_scale, &direction, &direction);
+    a2->base_direction = direction;
+    a2->direction = direction;
+
+    speed = glitter_random_get_float(GPM_VAL, random, a4->data.speed_random) + a4->data.speed;
+    deceleration = glitter_random_get_float(GPM_VAL, random, a4->data.deceleration_random) + a4->data.deceleration;
+    a2->speed = speed * 60.0f;
+    a2->deceleration = max(deceleration * 60.0f, 0.0f);
+
+    glitter_random_get_vec3(GPM_VAL, random, &a4->data.acceleration_random, &external_acceleration);
+    vec3_add(external_acceleration, a4->data.acceleration, external_acceleration);
+    vec3_add(external_acceleration, a4->data.gravity, a2->acceleration);
+
+    copy_mat = false;
+    if (a4->data.flags & GLITTER_PARTICLE_ROTATE_BY_EMITTER
+        || a4->data.draw_type == GLITTER_DIRECTION_EMITTER_ROTATION) {
+        switch (a3->data.type) {
+        case GLITTER_EMITTER_CYLINDER:
+            if (a3->data.cylinder.direction != GLITTER_EMITTER_EMISSION_DIRECTION_NONE) {
+                float_t length;
+                vec3_length(a2->direction, length);
+                copy_mat = length <= 0.000001f;
+            }
+            else
+                copy_mat = true;
+            break;
+        case GLITTER_EMITTER_SPHERE:
+            if (a3->data.sphere.direction != GLITTER_EMITTER_EMISSION_DIRECTION_NONE) {
+                float_t length;
+                vec3_length(a2->direction, length);
+                copy_mat = length <= 0.000001f;
+            }
+            else
+                copy_mat = true;
+            break;
+        default:
+            copy_mat = true;
+            break;
+        }
+    }
+
+    if (copy_mat) {
+        a2->mat = a3->mat;
+        if (a4->data.flags & GLITTER_PARTICLE_EMITTER_LOCAL)
+            a2->mat.row3 = (vec4){ 0.0f, 0.0f, 0.0f, 1.0f };
+    }
+    else
+        a2->mat = mat4_identity;
+
+    if (a1->data.data.type == GLITTER_PARTICLE_LOCUS) {
+        uint32_t locus_history_size = glitter_random_get_int_min_max(GPM_VAL, random,
+            -a1->data.data.locus_history_size_random, a1->data.data.locus_history_size_random)
+            + a1->data.data.locus_history_size;
+        a2->locus_history = glitter_locus_history_init(locus_history_size);
+    }
+    glitter_random_step_value(random);
+}
+
+void FASTCALL glitter_render_element_free(glitter_render_element* a1) {
+    a1->alive = false;
+    if (a1->locus_history) {
+        glitter_locus_history_dispose(a1->locus_history);
+        a1->locus_history = 0;
+    }
+}
+
+void FASTCALL glitter_render_element_get_value(GPM,
+    glitter_render_group* a1, glitter_render_element* a2, float_t delta_frame) {
+    glitter_particle_inst* v4;
+    vec2 uv_scroll;
+    vec2 uv_scroll_2nd;
+    vec3 translation;
+    bool has_translation;
+    size_t length;
+    glitter_curve* curve;
+    float_t value;
+    float_t color_scale;
+    
+    glitter_random_set_step(a1->random_ptr, 1);
+    v4 = a1->particle;
+    if (!v4 || !((v4->data.data.flags & GLITTER_PARTICLE_LOOP
+        && !glitter_particle_inst_has_ended(v4, false)) || a2->frame <= a2->life_time)) {
+        a1->ctrl--;
+        a2->alive = false;
+        if (a2->locus_history) {
+            glitter_locus_history_dispose(a2->locus_history);
+            a2->locus_history = 0;
+        }
+        return;
+    }
+
+    glitter_render_element_accelerate(GPM_VAL, v4, a2, delta_frame, a1->random_ptr);
+    if (v4->data.data.draw_type == GLITTER_DIRECTION_PARTICLE_ROTATION) {
+        a2->rotation.x += a2->rotation_add.x * delta_frame;
+        a2->rotation.y += a2->rotation_add.y * delta_frame;
+    }
+    a2->rotation.z += a2->rotation_add.z * delta_frame;
+    vec2_mult_scalar(v4->data.data.uv_scroll_add,
+        v4->data.data.uv_scroll_add_scale * delta_frame, uv_scroll);
+    vec2_add(a2->uv_scroll, uv_scroll, a2->uv_scroll);
+    vec2_mult_scalar(v4->data.data.uv_scroll_2nd_add,
+        v4->data.data.uv_scroll_2nd_add_scale * delta_frame, uv_scroll_2nd);
+    vec2_add(a2->uv_scroll_2nd, uv_scroll_2nd, a2->uv_scroll_2nd);
+    glitter_render_element_step_uv(GPM_VAL, v4, a2, delta_frame, a1->random_ptr);
+    a2->color = (vec4){ -1.0f, -1.0f, -1.0f, -1.0f };
+    color_scale = -1.0f;
+    a2->draw = true;
+
+    if (v4->data.data.sub_flags & GLITTER_PARTICLE_SUB_USE_CURVE) {
+        value = 0.0f;
+        has_translation = false;
+        translation = vec3_null;
+
+        vector_ptr_glitter_curve curv = v4->particle->curve;
+        length = curv.end - curv.begin;
+        for (size_t i = 0; i < length; i++) {
+            curve = curv.begin[i];
+            if (!glitter_curve_get_value(GPM_VAL, curve, a2->frame, &value,
+                (int32_t)(a2->random.value + i), a1->random_ptr))
+                continue;
+
+            switch (curve->type) {
+            case GLITTER_CURVE_TRANSLATION_X:
+                translation.x = value;
+                has_translation = true;
+                break;
+            case GLITTER_CURVE_TRANSLATION_Y:
+                translation.y = value;
+                has_translation = true;
+                break;
+            case GLITTER_CURVE_TRANSLATION_Z:
+                translation.z = value;
+                has_translation = true;
+                break;
+            case GLITTER_CURVE_ROTATION_X:
+                a2->rotation.x = value;
+                break;
+            case GLITTER_CURVE_ROTATION_Y:
+                a2->rotation.y = value;
+                break;
+            case GLITTER_CURVE_ROTATION_Z:
+                a2->rotation.z = value;
+                break;
+            case GLITTER_CURVE_SCALE_X:
+                a2->scale.x = value;
+                if (fabsf(value) < 0.000001f)
+                    a2->draw = false;
+                break;
+            case GLITTER_CURVE_SCALE_Y:
+                a2->scale.y = value;
+                if (fabsf(value) < 0.000001f)
+                    a2->draw = false;
+                break;
+            case GLITTER_CURVE_SCALE_Z:
+                a2->scale.z = value;
+                if (fabsf(value) < 0.000001f)
+                    a2->draw = false;
+                break;
+            case GLITTER_CURVE_SCALE_ALL:
+                a2->scale_all = value;
+                if (fabsf(value) < 0.000001f)
+                    a2->draw = false;
+                break;
+            case GLITTER_CURVE_COLOR_R:
+                a2->color.x = value;
+                break;
+            case GLITTER_CURVE_COLOR_G:
+                a2->color.y = value;
+                break;
+            case GLITTER_CURVE_COLOR_B:
+                a2->color.z = value;
+                break;
+            case GLITTER_CURVE_COLOR_A:
+                a2->color.w = value;
+                if (value < 0.01f)
+                    a2->draw = false;
+                break;
+            case GLITTER_CURVE_U_SCROLL:
+                a2->uv_scroll.x = value;
+                break;
+            case GLITTER_CURVE_V_SCROLL:
+                a2->uv_scroll.y = value;
+                break;
+            }
+        }
+
+        if (v4->data.data.flags & GLITTER_PARTICLE_ROTATE_BY_EMITTER || has_translation) {
+            vec3_add(translation, a2->base_translation, translation);
+            if (v4->data.data.flags & GLITTER_PARTICLE_ROTATE_BY_EMITTER)
+                mat4_mult_vec3_trans(&a2->mat, &translation, &translation);
+            a2->translation = translation;
+        }
+    }
+
+    if (a2->draw) {
+        if (a2->color.x < 0.0f)
+            a2->color.x = v4->data.data.color.x;
+        if (a2->color.y < 0.0f)
+            a2->color.y = v4->data.data.color.y;
+        if (a2->color.z < 0.0f)
+            a2->color.z = v4->data.data.color.z;
+        if (a2->color.w < 0.0f)
+            a2->color.w = v4->data.data.color.w;
+
+        if (color_scale >= 0.0f)
+            vec3_mult_scalar(*(vec3*)&a2->color, color_scale, *(vec3*)&a2->color);
+
+        if (a2->fade_in_frames > 0.0 && (a2->life_time - a2->frame) < a2->fade_in_frames)
+            a2->color.w *= (a2->life_time - a2->frame) / a2->fade_in_frames;
+        else if (a2->fade_out_frames > 0.0 && a2->frame < a2->fade_out_frames)
+            a2->color.w *= a2->frame / a2->fade_out_frames;
+
+        if (a2->color.w < 0.01f)
+            a2->draw = false;
+    }
+
+    if (v4->data.data.type == GLITTER_PARTICLE_LOCUS)
+        glitter_locus_history_append(GPM_VAL, a2->locus_history, a2, v4);
+
+    a2->frame += delta_frame;
+    if (v4->data.data.flags & GLITTER_PARTICLE_LOOP && a2->frame >= a2->life_time)
+        a2->frame -= a2->life_time;
+}
+
+void FASTCALL glitter_render_element_rotate_to_position(mat3* mat,
+    glitter_render_group* a2, glitter_render_element* a3) {
+    vec3 vec1;
+    vec3 vec2;
+    float_t angle;
+    vec3 axis;
+
+    if (a2->flags & GLITTER_PARTICLE_EMITTER_LOCAL)
+        vec2 = a3->translation;
+    else {
+        mat4_get_translation(&a2->mat, &vec2);
+        vec3_sub(vec2, a3->translation, vec2);
+    }
+    vec3_normalize(vec2, vec2);
+
+    if (fabsf(vec2.y) >= 0.000001f) {
+        *mat = mat3_identity;
+        vec1 = (vec3){ 0.0f, 0.0f, 1.0f };
+        axis_angle_from_vectors(&axis, &angle, &vec1, &vec2);
+        mat3_mult_axis_angle(mat, mat, &axis, angle);
+    }
+    else
+        mat3_rotate_z((float_t)M_PI, mat);
+}
+
+void FASTCALL glitter_render_element_rotate_to_prev_position(mat3* mat,
+    glitter_render_group* a2, glitter_render_element* a3) {
+    vec3 vec1;
+    vec3 vec2;
+    float_t angle;
+    vec3 axis;
+    float_t length;
+
+    vec3_sub(a3->translation, a3->translation_prev, vec2);
+    vec3_length_squared(vec2, length);
+    if (length < 0.000001f)
+        vec2 = a3->translation;
+    vec3_normalize(vec2, vec2);
+
+    if (fabsf(vec2.y) >= 0.000001f) {
+        mat3_rotate_z((float_t)M_PI, mat);
+        vec1 = (vec3){ 0.0f, 1.0f, 0.0f };
+        axis_angle_from_vectors(&axis, &angle, &vec1, &vec2);
+        mat3_mult_axis_angle(mat, mat, &axis, angle);
+    }
+    else
+        mat3_rotate_z((float_t)M_PI, mat);
+}
+
+static void FASTCALL glitter_render_element_accelerate(GPM, glitter_particle_inst* a1,
+    glitter_render_element* a2, float_t delta_frame, glitter_random* random) {
+    vec3 acceleration;
+    vec3 direction;
+    float_t diff_time;
+    float_t delta_time;
+    float_t reflection_coeff;
+    float_t speed;
+
+    a2->translation_prev = a2->translation;
+    delta_time = delta_frame * (float_t)(1.0 / 60.0);
+    diff_time = (a2->frame - a2->rebound_frame - delta_frame) * (float_t)(1.0 / 60.0);
+    vec3_mult_scalar(a2->acceleration, delta_time * (delta_time * 0.5f + diff_time), acceleration);
+    speed = a2->deceleration * delta_time * (delta_time * 0.5f - diff_time) + a2->speed;
+    if (speed >= 0.01f) {
+        vec3_mult_scalar(a2->direction, speed * delta_time, direction);
+        vec3_add(acceleration, direction, acceleration);
+    }
+    vec3_add(a2->translation, acceleration, a2->translation);
+    vec3_add(a2->base_translation, acceleration, a2->base_translation);
+    if (a1->data.data.flags & GLITTER_PARTICLE_REBOUND_PLANE
+        && a2->translation_prev.y > a1->data.data.rebound_plane_y
+        && a2->translation.y <= a1->data.data.rebound_plane_y) {
+        reflection_coeff = glitter_random_get_float(GPM_VAL, random,
+            a1->data.data.reflection_coeff_random) + a1->data.data.reflection_coeff;
+        a2->rebound_frame = a2->frame;
+        vec3_sub(a2->translation, a2->translation_prev, direction);
+        vec3_mult_scalar(direction, reflection_coeff * 60.0f, direction);
+        vec3_xor(direction, ((vec3){ 0.0f, -0.0f, 0.0f }), a2->direction);
+        a2->translation.y = a2->translation_prev.y;
+    }
+}
+
+static void FASTCALL glitter_render_element_get_color(glitter_particle_inst* a1,
+    float_t* r, float_t* g, float_t* b, float_t* a) {
+    glitter_effect_inst* effect;
+
+    effect = a1->data.effect;
+    if (!effect) {
+        if (!a1->data.parent)
+            return;
+        effect = a1->data.parent->data.effect;
+        if (!effect)
+            return;
+    }
+}
+
+static void FASTCALL glitter_render_element_step_uv(GPM, glitter_particle_inst* a1,
+    glitter_render_element* a2, float_t delta_frame, glitter_random* random) {
+    if (a1->data.data.frame_step_uv <= 0.0f)
+        return;
+
+    int32_t max_uv = a1->data.data.split_u * a1->data.data.split_v;
+    if (max_uv)
+        max_uv--;
+
+    while (a2->frame_step_uv <= 0.0f) {
+        switch (a1->data.data.uv_index_type) {
+        case GLITTER_UV_INDEX_RANDOM:
+            a2->uv_index = a1->data.data.uv_index_start;
+            if (a1->data.data.uv_index_count > 1)
+                a2->uv_index += glitter_random_get_int(GPM_VAL, random, a1->data.data.uv_index_count);
+            break;
+        case GLITTER_UV_INDEX_FORWARD:
+        case GLITTER_UV_INDEX_INITIAL_RANDOM_FORWARD:
+            a2->uv_index = (uint8_t)(max_uv & (a2->uv_index + 1));
+            break;
+        case GLITTER_UV_INDEX_REVERSE:
+        case GLITTER_UV_INDEX_INITIAL_RANDOM_REVERSE:
+            a2->uv_index = (uint8_t)(max_uv & (a2->uv_index - 1));
+            break;
+        }
+
+        a2->uv.x = (float_t)(a2->uv_index % a1->data.data.split_u) * a1->data.data.split_uv.x;
+        a2->uv.y = (float_t)(a2->uv_index / a1->data.data.split_u) * a1->data.data.split_uv.y;
+        a2->frame_step_uv += a1->data.data.frame_step_uv;
+    }
+    a2->frame_step_uv -= delta_frame;
+}

src/CRE/Glitter/render_element.h

@@ -0,0 +1,23 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "glitter.h"
+
+extern void FASTCALL glitter_render_element_emit(GPM,
+    glitter_particle_inst* a1, glitter_render_element* a2, glitter_emitter_inst* a3,
+    glitter_particle_inst_data* a4, int32_t index, uint8_t step, glitter_random* random);
+extern void FASTCALL glitter_render_element_free(glitter_render_element* a1);
+extern void FASTCALL glitter_render_element_get_value(GPM, glitter_render_group* a1,
+    glitter_render_element* a2, float_t delta_frame);
+extern void FASTCALL glitter_render_element_rotate_to_position(mat3* mat,
+    glitter_render_group* a2, glitter_render_element* a3);
+extern void FASTCALL glitter_render_element_rotate_to_prev_position(mat3* mat,
+    glitter_render_group* a2, glitter_render_element* a3);
+extern void FASTCALL glitter_render_element_x_rotate_to_position(mat3* mat,
+    glitter_render_group* a2, glitter_render_element* a3, vec3* pos, vec3* direction);
+extern void FASTCALL glitter_render_element_x_rotate_to_prev_position(mat3* mat,
+    glitter_render_group* a2, glitter_render_element* a3, vec3* pos, vec3* direction);

src/CRE/Glitter/render_group.h

@@ -7,42 +7,15 @@
 
 #include "glitter.h"
 
-extern glitter_render_group* FASTCALL glitter_render_group_init(int32_t count, glitter_particle_inst* a2);
-extern glitter_render_group_sub* FASTCALL glitter_render_group_add_control(glitter_render_group* a1,
-    glitter_render_group_sub* a2);
-extern void FASTCALL glitter_render_group_copy(glitter_render_group* a1, glitter_render_group* a2);
-extern void FASTCALL glitter_render_group_copy_from_particle(glitter_render_group* render_group,
-    float_t delta_frame, bool copy_mats);
+extern glitter_render_group* FASTCALL glitter_render_group_init(GPM, glitter_particle_inst* a1);
+extern void FASTCALL glitter_render_group_calc_draw(GPM, glitter_render_group* a1,
+    bool(FASTCALL* render_add_list_func)(glitter_particle_mesh*, vec4*, mat4*, mat4*));
+extern bool FASTCALL glitter_render_group_cannot_draw(glitter_render_group* a1);
 extern void FASTCALL glitter_render_group_delete_buffers(glitter_render_group* a1, bool a2);
-extern void FASTCALL glitter_render_group_draw(glitter_scene_sub* a1, glitter_render_group* a2);
-extern void FASTCALL glitter_render_group_draw_line(glitter_scene_sub* a1, glitter_render_group* a2);
-extern void FASTCALL glitter_render_group_draw_locus(glitter_scene_sub* a1, glitter_render_group* a2);
-extern void FASTCALL glitter_render_group_draw_quad(glitter_scene_sub* a1, glitter_render_group* a2);
-extern void FASTCALL glitter_render_group_draw_quad_rotate_to_prev_position(mat4* mat,
-    glitter_render_group* a2, glitter_render_group_sub* a3);
-extern void FASTCALL glitter_render_group_draw_quad_rotate_to_position(mat4* mat,
-    glitter_render_group* a2, glitter_render_group_sub* a3);
-extern void FASTCALL glitter_render_group_draw_quad_sub1(glitter_scene_sub* a1,
-    glitter_render_group* a2, mat4* a3, mat4* a4);
-extern void FASTCALL glitter_render_group_draw_quad_sub2(glitter_scene_sub* a1,
-    glitter_render_group* a2, mat4* a3, mat4* a4,
-    void(FASTCALL* a5)(mat4*, glitter_render_group*, glitter_render_group_sub*));
-extern void FASTCALL glitter_render_group_draw_quads(glitter_scene_sub* a1, int32_t count);
-extern void FASTCALL glitter_render_group_draw_set_pivot(glitter_pivot pivot,
-    float_t a2, float_t a3, float_t* v00, float_t* v01, float_t* v10, float_t* v11);
-extern void FASTCALL glitter_render_group_emit(glitter_render_group* a1,
+extern void FASTCALL glitter_render_group_draw(GPM, glitter_render_group* a1);
+extern void FASTCALL glitter_render_group_emit(GPM, glitter_render_group* a1,
     glitter_particle_inst_data* a2, glitter_emitter_inst* a3, int32_t a4, int32_t count);
 extern void FASTCALL glitter_render_group_free(glitter_render_group* a1);
-extern bool FASTCALL glitter_render_group_get_a3da_scale(glitter_render_group* a1, vec3* a2);
-extern void FASTCALL glitter_render_group_sub_accelerate(glitter_particle_inst* a1,
-    glitter_render_group_sub* a2, float_t rebound_time, float_t delta_frame);
-extern void FASTCALL glitter_render_group_sub_clamp_color(glitter_particle_inst* a1,
-    float_t* r, float_t* g, float_t* b, float_t* a);
-extern void FASTCALL glitter_render_group_sub_emit(glitter_particle_inst* a1,
-    glitter_render_group_sub* a2, glitter_emitter_inst* a3, glitter_particle_inst_data* a4, int32_t a5);
-extern void FASTCALL glitter_render_group_sub_get_color(glitter_particle_inst* a1, glitter_render_group_sub* a2);
-extern void FASTCALL glitter_render_group_sub_get_value(glitter_render_group* a1,
-    glitter_render_group_sub* a2, float_t delta_frame);
-extern void FASTCALL glitter_render_group_sub_step_uv(glitter_particle_inst* a1,
-    glitter_render_group_sub* a2, float_t delta_frame);
+extern void FASTCALL glitter_render_group_get_value(GPM,
+    glitter_render_group* render_group, float_t delta_frame, bool copy_mats);
 extern void FASTCALL glitter_render_group_dispose(glitter_render_group* rg);

src/CRE/Glitter/scene.c

@@ -5,43 +5,20 @@
 
 #include "scene.h"
 #include "effect_inst.h"
-#include "render_group.h"
+#include "../GlitterX/effect_inst_x.h"
 
 glitter_scene* FASTCALL glitter_scene_init(glitter_effect_group* eg) {
     glitter_scene* s = force_malloc(sizeof(glitter_scene));
     s->emission = 1.0f;
     s->effect_group = eg;
     s->hash = eg->hash;
-    vector_ptr_glitter_render_group_resize(&s->sub.render_groups, 0x40);
     if (eg) {
-        vector_ptr_glitter_effect_inst_resize(&s->effects, eg->effects.end - eg->effects.begin);
+        vector_ptr_glitter_effect_inst_append(&s->effects, eg->effects.end - eg->effects.begin);
         s->emission = eg->emission;
     }
     return s;
 }
 
-bool FASTCALL glitter_scene_copy(glitter_scene* a1, glitter_effect_inst* a2, glitter_scene* a3) {
-    glitter_effect_inst** i;
-
-    if (a1->effects.begin == a1->effects.end)
-        return false;
-
-    for (i = a1->effects.begin; i != a1->effects.end; i++)
-        if (*i && (*i)->id == a2->id) {
-            glitter_effect_inst_copy(*i, a2, a3);
-            return true;
-        }
-    return false;
-}
-
-void FASTCALL glitter_scene_emit(glitter_scene* a1, float_t frame_speed) {
-    glitter_effect_inst** i;
-
-    for (i = a1->effects.begin; i != a1->effects.end; ++i)
-        if (*i)
-            glitter_effect_inst_emit(*i, a1, frame_speed);
-}
-
 bool FASTCALL glitter_scene_has_ended(glitter_scene* scene, bool a2) {
     glitter_effect_inst** i;
 
@@ -51,7 +28,7 @@ bool FASTCALL glitter_scene_has_ended(glitter_scene* scene, bool a2) {
     return true;
 }
 
-void FASTCALL glitter_scene_init_effect(glitter_scene* a1,
+void FASTCALL glitter_scene_init_effect(GPM, glitter_scene* a1,
     glitter_effect* a2, size_t id, bool appear_now) {
     glitter_effect_inst** i;
     glitter_effect_inst* effect;
@@ -59,55 +36,51 @@ void FASTCALL glitter_scene_init_effect(glitter_scene* a1,
     if (!a2)
         return;
 
-    for (i = a1->effects.begin; i != a1->effects.end; i++)
-        if (*i && (*i)->id == id) {
-            glitter_effect_inst_reset(*i, a1);
-            return;
-        }
+    /*if (glt_type == GLITTER_X) {
+        for (i = a1->effects.begin; i != a1->effects.end; i++)
+            if (*i && (*i)->id == id) {
+                glitter_x_effect_inst_reset(GPM_VAL, *i, a1->emission);
+                return;
+            }
 
-    effect = glitter_effect_inst_init(a2, a1, id, appear_now);
-    vector_ptr_glitter_effect_inst_push_back(&a1->effects, &effect);
-}
+        effect = glitter_x_effect_inst_init(GPM_VAL, a2, id, a1->emission, appear_now);
+        vector_ptr_glitter_effect_inst_push_back(&a1->effects, &effect);
+    }
+    else*/ {
+        for (i = a1->effects.begin; i != a1->effects.end; i++)
+            if (*i && (*i)->id == id) {
+                glitter_effect_inst_reset(GPM_VAL, *i, a1->emission);
+                return;
+            }
 
-void FASTCALL glitter_scene_update_scene(glitter_scene* a1, float_t delta_frame) {
-    glitter_render_group** i;
-    glitter_render_group* render_group;
-    glitter_scene_sub* sub;
-
-    sub = &a1->sub;
-    sub->ctrl_quad = 0;
-    sub->ctrl_line = 0;
-    sub->ctrl_locus = 0;
-    for (i = sub->render_groups.begin; i != sub->render_groups.end; i++) {
-        if (!*i)
-            continue;
-
-        render_group = *i;
-        switch (render_group->type) {
-        case GLITTER_PARTICLE_QUAD:
-            sub->ctrl_quad += render_group->ctrl;
-            break;
-        case GLITTER_PARTICLE_LINE:
-            sub->ctrl_line += render_group->ctrl;
-            break;
-        case GLITTER_PARTICLE_LOCUS:
-            sub->ctrl_locus += render_group->ctrl;
-            break;
-        }
-        glitter_render_group_copy_from_particle(render_group, delta_frame, true);
+        effect = glitter_effect_inst_init(GPM_VAL, a2, id, a1->emission, appear_now);
+        vector_ptr_glitter_effect_inst_push_back(&a1->effects, &effect);
     }
 }
 
-void FASTCALL glitter_scene_update_value_frame(glitter_scene* a1, float_t delta_frame) {
+void FASTCALL glitter_scene_update_value_frame(GPM, glitter_scene* a1, float_t delta_frame) {
     glitter_effect_inst** i;
+    glitter_effect_inst* effect;
 
-    for (i = a1->effects.begin; i != a1->effects.end; ++i)
-        if (*i)
-            glitter_effect_inst_update_value_frame(*i, delta_frame);
+    /*if (glt_type == GLITTER_X)
+        for (i = a1->effects.begin; i != a1->effects.end; ++i) {
+            if (!*i)
+                continue;
+
+            effect = *i;
+            glitter_x_effect_inst_update_value_frame(GPM_VAL, effect, delta_frame, a1->emission);
+        }
+    else*/
+        for (i = a1->effects.begin; i != a1->effects.end; ++i) {
+            if (!*i)
+                continue;
+
+            effect = *i;
+            glitter_effect_inst_update_value_frame(GPM_VAL, effect, delta_frame, a1->emission);
+        }
 }
 
 void FASTCALL glitter_scene_dispose(glitter_scene* s) {
-    vector_ptr_glitter_effect_inst_free(&s->effects, (void*)glitter_effect_inst_dispose);
-    vector_ptr_glitter_render_group_free(&s->sub.render_groups, (void*)glitter_render_group_dispose);
+    vector_ptr_glitter_effect_inst_free(&s->effects, glitter_effect_inst_dispose);
     free(s);
 }

src/CRE/Glitter/scene.h

@@ -8,11 +8,8 @@
 #include "glitter.h"
 
 extern glitter_scene* FASTCALL glitter_scene_init(glitter_effect_group* eg);
-extern bool FASTCALL glitter_scene_copy(glitter_scene* a1, glitter_effect_inst* a2, glitter_scene* a3);
-extern void FASTCALL glitter_scene_emit(glitter_scene* a1, float_t frame_speed);
 extern bool FASTCALL glitter_scene_has_ended(glitter_scene* scene, bool a2);
-extern void FASTCALL glitter_scene_init_effect(glitter_scene* a1,
+extern void FASTCALL glitter_scene_init_effect(GPM, glitter_scene* a1,
     glitter_effect* a2, size_t id, bool appear_now);
-extern void FASTCALL glitter_scene_update_scene(glitter_scene* a1, float_t delta_frame);
-extern void FASTCALL glitter_scene_update_value_frame(glitter_scene* a1, float_t delta_frame);
+extern void FASTCALL glitter_scene_update_value_frame(GPM, glitter_scene* a1, float_t delta_frame);
 extern void FASTCALL glitter_scene_dispose(glitter_scene* s);

src/CRE/Glitter/shared.c

@@ -9,8 +9,6 @@ float_t frame_speed = 1.0f;
 float_t target_fps = 60.0f;
 extern double_t render_freq;
 
-int32_t glitter_shader_flags[4];
-
 float_t get_frame_speed() {
     return (float_t)(clamp(target_fps / render_freq, 0.0, 1.0) * frame_speed);
 }
@@ -40,6 +38,21 @@ void FASTCALL axis_angle_from_vectors(vec3* axis, float_t* angle, vec3* vec1, ve
         *angle = (float_t)M_PI - *angle;
 }
 
+void FASTCALL mat3_mult_axis_angle(mat3* src, mat3* dst, vec3* axis, float_t angle) {
+    quat q1;
+    quat q2;
+    quat q3;
+
+    quat_from_mat3(src->row0.x, src->row0.y, src->row0.z, src->row1.x,
+        src->row1.y, src->row1.z, src->row2.x, src->row2.y, src->row2.z, &q1);
+    quat_from_axis_angle(axis, angle, &q2);
+    q3.x = q1.x * q2.w - q1.y * q2.z + q1.z * q2.y + q1.w * q2.x;
+    q3.y = q1.x * q2.z + q1.y * q2.w - q1.z * q2.x + q1.w * q2.y;
+    q3.z = -q1.x * q2.y + q1.y * q2.x + q1.z * q2.w + q1.w * q2.z;
+    q3.w = -q1.x * q2.x - q1.y * q2.y - q1.z * q2.z + q1.w * q2.w;
+    mat3_from_quat(&q3, dst);
+}
+
 void FASTCALL mat4_mult_axis_angle(mat4* src, mat4* dst, vec3* axis, float_t angle) {
     quat q1;
     quat q2;
@@ -57,4 +70,8 @@ void FASTCALL mat4_mult_axis_angle(mat4* src, mat4* dst, vec3* axis, float_t ang
     *(vec3*)&dst->row0 = yt.row0;
     *(vec3*)&dst->row1 = yt.row1;
     *(vec3*)&dst->row2 = yt.row2;
+    dst->row0.w = src->row0.w;
+    dst->row1.w = src->row2.w;
+    dst->row2.w = src->row3.w;
+    dst->row3 = src->row3;
 }

src/CRE/Glitter/shared.h

@@ -10,14 +10,13 @@
 #include "../../KKdLib/f2_struct.h"
 #include "../../KKdLib/farc.h"
 #include "../../KKdLib/hash.h"
-#include "../../KKdLib/io_path.h"
 #include "../../KKdLib/mat.h"
 #include "../../KKdLib/quat.h"
+#include "../../KKdLib/str_utils.h"
 #include "../../KKdLib/txp.h"
 #include "../../KKdLib/utf8.h"
 #include "../../KKdLib/vec.h"
 #include "../../KKdLib/vector.h"
-#include "../camera.h"
 #define GLEW_STATIC
 #include <GLEW/glew.h>
 
@@ -25,9 +24,7 @@ extern float_t frame_speed;
 extern float_t target_fps;
 extern float_t current_fps;
 
-extern int32_t glitter_shader_flags[4];
-extern camera* cam;
-
 extern float_t get_frame_speed();
 extern void FASTCALL axis_angle_from_vectors(vec3* axis, float_t* angle, vec3* vec0, vec3* vec1);
+extern void FASTCALL mat3_mult_axis_angle(mat3* src, mat3* dst, vec3* axis, float_t angle);
 extern void FASTCALL mat4_mult_axis_angle(mat4* src, mat4* dst, vec3* axis, float_t angle);

src/CRE/Glitter/texture.c

@@ -4,47 +4,46 @@
 */
 
 #include "texture.h"
+#include "../texture.h"
 
-static void load_texture_data(txp_sub_data* data, int32_t mipmap);
-
-bool FASTCALL glitter_texture_hashes_pack_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian) {
-    char* data;
+bool FASTCALL glitter_texture_hashes_pack_file(glitter_effect_group* a1, f2_struct* st) {
+    size_t l;
+    size_t d;
     size_t count;
-    uint64_t* resource_hashes;
-    size_t i;
 
-    if (!a1->effects.begin)
+    if (a1->effects.end - a1->effects.begin < 1 || !a1->resources_count
+        || a1->resource_hashes.end - a1->resource_hashes.begin < 1)
         return false;
 
-    memset(st, 0, sizeof(f2_struct));
     count = a1->resources_count;
-    data = force_malloc(align_val(0x08 + 0x08 * count, 0x10));
-    st->data = data;
-    st->length = align_val(0x08 + 0x08 * count, 0x10);
 
-    if (use_big_endian)
-        *(int32_t*)data = reverse_endianess_int32_t((int32_t)count);
-    else
-        *(int32_t*)data = (int32_t)count;
-    data += 0x04;
-    *(int32_t*)data = 0;
-    data += 0x04;
+    memset(st, 0, sizeof(f2_struct));
+    l = 0;
 
-    if (count) {
-        resource_hashes = a1->resource_hashes;
-        if (!resource_hashes)
-            return false;
+    vector_enrs_entry e = { 0, 0, 0 };
+    enrs_entry ee;
 
-        if (use_big_endian)
-            for (i = 0; i < count; i++, data += sizeof(uint64_t))
-                *(uint64_t*)data = reverse_endianess_uint64_t(resource_hashes[i]);
-        else
-            memcpy(data, resource_hashes, sizeof(uint64_t) * count);
-    }
+    ee = (enrs_entry){ 0, 2, (uint32_t)(8 + count * 8), 1, { 0, 0, 0 } };
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 0, 1, ENRS_TYPE_DWORD });
+    vector_enrs_sub_entry_push_back(&ee.sub, &(enrs_sub_entry){ 4, (uint32_t)count, ENRS_TYPE_QWORD });
+    vector_enrs_entry_push_back(&e, &ee);
+    l += 8 + count * 8;
+
+    l = align_val(l, 0x10);
+    d = (size_t)force_malloc(l);
+    st->data = (void*)d;
+    st->length = l;
+    st->enrs = e;
+
+    *(int32_t*)d = (int32_t)count;
+    *(int32_t*)(d + 4) = 0;
+    d += 8;
+
+    memcpy((void*)d, a1->resource_hashes.begin, sizeof(uint64_t) * count);
 
     st->header.signature = 0x53525644;
     st->header.length = 0x20;
-    st->header.use_big_endian = use_big_endian ? true : false;
+    st->header.use_big_endian = false;
     st->header.use_section_size = true;
     return true;
 }
@@ -55,7 +54,7 @@ bool FASTCALL glitter_texture_hashes_unpack_file(glitter_effect_group* a1, f2_st
     uint64_t* resource_hashes;
     size_t i;
 
-    if (a1->resource_hashes)
+    if (a1->resources_count && a1->resource_hashes.end - a1->resource_hashes.begin > 0)
         return true;
 
     if (!st || !st->header.data_size)
@@ -73,8 +72,10 @@ bool FASTCALL glitter_texture_hashes_unpack_file(glitter_effect_group* a1, f2_st
 
     a1->resources_count = count;
     if (count) {
-        resource_hashes = force_malloc_s(sizeof(uint64_t), count);
-        a1->resource_hashes = resource_hashes;
+        resource_hashes = force_malloc_s(uint64_t, count);
+        a1->resource_hashes.begin = resource_hashes;
+        a1->resource_hashes.end = resource_hashes + count;
+        a1->resource_hashes.capacity_end = resource_hashes + count;
         if (!resource_hashes)
             return false;
 
@@ -87,154 +88,95 @@ bool FASTCALL glitter_texture_hashes_unpack_file(glitter_effect_group* a1, f2_st
     return true;
 }
 
-bool FASTCALL glitter_texture_resource_pack_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian) {
-    if (!a1->resources_tex)
+bool FASTCALL glitter_texture_resource_pack_file(glitter_effect_group* a1, f2_struct* st) {
+    if (a1->resources_tex.end - a1->resources_tex.begin < 1)
         return false;
 
     memset(st, 0, sizeof(f2_struct));
 
-    txp_pack_file(a1->resources_tex, &st->data, &st->length, use_big_endian);
+    if (!tex_set_produce_enrs(&a1->resources_tex, &st->enrs))
+        return false;
+
+    tex_set_pack_file(&a1->resources_tex, &st->data, &st->length, false);
 
     st->header.signature = 0x43505854;
     st->header.length = 0x20;
-    st->header.use_big_endian = use_big_endian ? true : false;
+    st->header.use_big_endian = false;
     st->header.use_section_size = true;
     return true;
 }
 
 bool FASTCALL glitter_texture_resource_unpack_file(glitter_effect_group* a1, f2_struct* st) {
-    size_t i;
-    size_t j;
-    size_t k;
-    txp_data* tex_data;
-    txp_sub_data** tex_sub_data;
-    txp_sub_data* tex_sub_sub_data;
-    glitter_effect** l;
-    glitter_effect* effect;
-    glitter_emitter** m;
-    glitter_emitter* emitter;
-    glitter_particle** n;
-    glitter_particle* particle;
-
     if (!st || !st->header.data_size)
         return false;
 
-    txp* t = txp_init();
-    if (!txp_unpack_file(t, st->data, st->header.use_big_endian) || !a1->resources_count || a1->resources_count != t->count)
-        goto End;
-    
-    if (!a1->resources) {
-        a1->resources = force_malloc_s(sizeof(int32_t), a1->resources_count);
-        glGenTextures(a1->resources_count, a1->resources);
+    tex_set_unpack_file(&a1->resources_tex, st->data, st->header.use_big_endian);
+    return glitter_texture_load(a1);
+}
 
-        tex_data = t->data;
-        for (i = 0; i < t->count; i++, tex_data++) {
-            glBindTexture(GL_TEXTURE_2D, a1->resources[i]);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
-                tex_data->mipmaps_count > 1 ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, tex_data->mipmaps_count - 1);
-            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY, 16.0f);
-            tex_sub_data = tex_data->data;
-            for (j = 0; j < tex_data->array_size; j++, tex_sub_data++) {
-                tex_sub_sub_data = *tex_sub_data;
-                for (k = 0; k < tex_data->mipmaps_count; k++, tex_sub_sub_data++)
-                    load_texture_data(tex_sub_sub_data, (int32_t)k);
-                break;
-            }
-            glGenerateMipmap(GL_TEXTURE_2D);
-        }
-        glBindTexture(GL_TEXTURE_2D, 0);
-    }
+bool FASTCALL glitter_texture_load(glitter_effect_group* a1) {
+    if (!a1->resources_count)
+        return false;
 
-    for (i = 0; i < a1->resources_count; i++)
-        for (l = a1->effects.begin; l != a1->effects.end; l++) {
-            effect = *l;
-            if (!effect)
+    size_t count = a1->resources_tex.end - a1->resources_tex.begin;
+
+    if (!count || !a1->resources_count || a1->resources_count != count)
+        return false;
+
+    if (!texture_txp_load(&a1->resources_tex, &a1->resources))
+        return false;
+
+    for (glitter_effect** l = a1->effects.begin; l != a1->effects.end; l++) {
+        if (!*l)
+            continue;
+
+        glitter_effect* effect = *l;
+        for (glitter_emitter** m = effect->emitters.begin; m != effect->emitters.end; m++) {
+            if (!*m)
                 continue;
 
-            for (m = effect->emitters.begin; m != effect->emitters.end; m++) {
-                emitter = *m;
-                if (!emitter)
+            glitter_emitter* emitter = *m;
+            for (glitter_particle** n = emitter->particles.begin; n != emitter->particles.end; n++) {
+                if (!*n)
                     continue;
 
-                for (n = emitter->particles.begin; n != emitter->particles.end; n++) {
-                    particle = *n;
-                    if (!particle)
+                glitter_particle* particle = *n;
+                particle->data.texture0 = 0;
+                particle->data.texture1 = 0;
+            }
+        }
+    }
+
+    for (size_t i = 0; i < a1->resources_count; i++)
+        for (glitter_effect** l = a1->effects.begin; l != a1->effects.end; l++) {
+            if (!*l)
+                continue;
+
+            glitter_effect* effect = *l;
+            for (glitter_emitter** m = effect->emitters.begin; m != effect->emitters.end; m++) {
+                if (!*m)
+                    continue;
+
+                glitter_emitter* emitter = *m;
+                for (glitter_particle** n = emitter->particles.begin; n != emitter->particles.end; n++) {
+                    if (!*n)
                         continue;
 
-                    if (particle->data.data.tex_hash0 == a1->resource_hashes[i])
-                        particle->data.data.texture0 = a1->resources[i];
-                    if (particle->data.data.tex_hash1 == a1->resource_hashes[i])
-                        particle->data.data.texture1 = a1->resources[i];
+                    glitter_particle* particle = *n;
+                    if (particle->data.type == GLITTER_PARTICLE_LINE
+                        || particle->data.type == GLITTER_PARTICLE_MESH)
+                        continue;
+
+                    if (particle->data.tex_hash0 == a1->resource_hashes.begin[i])
+                        particle->data.texture0 = a1->resources.begin[i];
+                    if (particle->data.tex_hash1 == a1->resource_hashes.begin[i])
+                        particle->data.texture1 = a1->resources.begin[i];
                 }
             }
         }
-End:
-    a1->resources_tex = t;
     return true;
 }
 
-static void load_texture_data(txp_sub_data* data, int32_t mipmap) {
-    switch (data->format) {
-    case TXP_A8:
-        glTexImage2D(GL_TEXTURE_2D, mipmap, GL_ALPHA8, data->width, data->height,
-            0, GL_ALPHA, GL_UNSIGNED_BYTE, data->data);
-        break;
-    case TXP_RGB8:
-        glTexImage2D(GL_TEXTURE_2D, mipmap, GL_RGB8, data->width, data->height,
-            0, GL_RGB, GL_UNSIGNED_BYTE, data->data);
-        break;
-    case TXP_RGBA8:
-        glTexImage2D(GL_TEXTURE_2D, mipmap, GL_RGBA8, data->width, data->height,
-            0, GL_RGBA, GL_UNSIGNED_BYTE, data->data);
-        break;
-    case TXP_RGB5:
-        glTexImage2D(GL_TEXTURE_2D, mipmap, GL_RGB5, data->width, data->height,
-            0, GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, data->data);
-        break;
-    case TXP_RGB5A1:
-        glTexImage2D(GL_TEXTURE_2D, mipmap, GL_RGB5_A1, data->width, data->height,
-            0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, data->data);
-        break;
-    case TXP_RGBA4:
-        glTexImage2D(GL_TEXTURE_2D, mipmap, GL_RGBA4, data->width, data->height,
-            0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, data->data);
-        break;
-    case TXP_DXT1:
-        glCompressedTexImage2D(GL_TEXTURE_2D, mipmap, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
-            data->width, data->height, 0, data->size, data->data);
-        break;
-    case TXP_DXT1a:
-        glCompressedTexImage2D(GL_TEXTURE_2D, mipmap, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
-            data->width, data->height, 0, data->size, data->data);
-        break;
-    case TXP_DXT3:
-        glCompressedTexImage2D(GL_TEXTURE_2D, mipmap, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
-            data->width, data->height, 0, data->size, data->data);
-        break;
-    case TXP_DXT5:
-        glCompressedTexImage2D(GL_TEXTURE_2D, mipmap, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
-            data->width, data->height, 0, data->size, data->data);
-        break;
-    case TXP_ATI1:
-        glCompressedTexImage2D(GL_TEXTURE_2D, mipmap, GL_COMPRESSED_RED_RGTC1_EXT,
-            data->width, data->height, 0, data->size, data->data);
-        break;
-    case TXP_ATI2:
-        glCompressedTexImage2D(GL_TEXTURE_2D, mipmap, GL_COMPRESSED_RED_GREEN_RGTC2_EXT,
-            data->width, data->height, 0, data->size, data->data);
-        break;
-    case TXP_L8:
-        glTexImage2D(GL_TEXTURE_2D, mipmap, GL_LUMINANCE8, data->width, data->height,
-            0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data->data);
-        break;
-    case TXP_L8A8:
-        glTexImage2D(GL_TEXTURE_2D, mipmap, GL_LUMINANCE8_ALPHA8, data->width, data->height,
-            0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, data->data);
-        break;
-    }
+void FASTCALL glitter_texture_unload(glitter_effect_group* a1) {
+    texture_txp_unload(&a1->resources);
 }

src/CRE/Glitter/texture.h

@@ -7,7 +7,9 @@
 
 #include "glitter.h"
 
-extern bool FASTCALL glitter_texture_hashes_pack_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian);
+extern bool FASTCALL glitter_texture_hashes_pack_file(glitter_effect_group* a1, f2_struct* st);
 extern bool FASTCALL glitter_texture_hashes_unpack_file(glitter_effect_group* a1, f2_struct* st);
-extern bool FASTCALL glitter_texture_resource_pack_file(glitter_effect_group* a1, f2_struct* st, bool use_big_endian);
+extern bool FASTCALL glitter_texture_resource_pack_file(glitter_effect_group* a1, f2_struct* st);
 extern bool FASTCALL glitter_texture_resource_unpack_file(glitter_effect_group* a1, f2_struct* st);
+extern bool FASTCALL glitter_texture_load(glitter_effect_group* a1);
+extern void FASTCALL glitter_texture_unload(glitter_effect_group* a1);

src/CRE/GlitterX/curve_x.h

@@ -0,0 +1,11 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../Glitter/glitter.h"
+
+extern bool FASTCALL glitter_x_curve_get_value(GPM, glitter_curve* c,
+    float_t frame, float_t* value, int32_t random_value, glitter_random* random);

src/CRE/GlitterX/curve_x_get_value.c

@@ -0,0 +1,198 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "curve_x.h"
+#include "../Glitter/random.h"
+
+static void FASTCALL glitter_x_curve_get_key_indexes(vector_glitter_curve_key* keys,
+    float_t frame, size_t* curr, size_t* next);
+static float_t FASTCALL glitter_x_curve_interpolate(GPM, glitter_curve* c, float_t frame,
+    glitter_curve_key* curr, glitter_curve_key* next, glitter_key_type key_type, glitter_random* random);
+static float_t FASTCALL glitter_x_curve_randomize(GPM,
+    glitter_curve* c, float_t value, glitter_random* random);
+static float_t FASTCALL glitter_x_curve_randomize_key(GPM,
+    glitter_curve* c, glitter_curve_key* key, glitter_random* random);
+
+bool FASTCALL glitter_x_curve_get_value(GPM, glitter_curve* c,
+    float_t frame, float_t* value, int32_t random_value, glitter_random* random) {
+    size_t keys_count;
+    int32_t random_val;
+    bool negate;
+    float_t _value;
+
+    keys_count = c->keys.end - c->keys.begin;
+    if (!keys_count)
+        return false;
+
+    random_val = glitter_random_get_value(random);
+    glitter_random_set_value(random, random_value);
+    negate = c->flags & GLITTER_CURVE_NEGATE
+        && glitter_random_get_int_min_max(GPM_VAL, random, 0, 0xFFFF) > 0x7FFF;
+    if (c->flags & GLITTER_CURVE_STEP)
+        glitter_random_set_value(random, random_val + 1);
+
+    if (keys_count == 1) {
+        glitter_curve_key* curr_key = &c->keys.begin[keys_count - 1];
+        _value = glitter_x_curve_randomize_key(GPM_VAL, c, curr_key, random);
+        goto End;
+    }
+
+    float_t start_time = (float_t)c->start_time;
+    float_t end_time = (float_t)c->end_time;
+    if (c->repeat && (start_time > frame || frame >= end_time)) {
+        float_t t = (frame - start_time) / (end_time - start_time);
+        t = t <= 0.0f ? (float_t)(int32_t)t - 1.0f : (float_t)(int32_t)t;
+        frame -= t * (end_time - start_time);
+    }
+
+    if (end_time <= frame) {
+        glitter_curve_key* key = &c->keys.begin[keys_count - 1];
+        _value = glitter_x_curve_randomize_key(GPM_VAL, c, key, random);
+    }
+    else if (start_time > frame) {
+        glitter_curve_key* key = &c->keys.begin[0];
+        _value = glitter_x_curve_randomize_key(GPM_VAL, c, key, random);
+    }
+    else if (c->flags & GLITTER_CURVE_BAKED) {
+        size_t key_index;
+        if (frame >= end_time)
+            key_index = keys_count - 1;
+        else if (frame > start_time) {
+            key_index = (size_t)frame - c->start_time;
+            if (~c->flags & GLITTER_CURVE_BAKED_FULL)
+                key_index /= 2;
+
+            if (key_index >= keys_count)
+                key_index = keys_count - 1;
+        }
+        else
+            key_index = 0;
+
+        glitter_curve_key* key = &c->keys.begin[key_index];
+        _value = glitter_x_curve_randomize_key(GPM_VAL, c, key, random);
+    }
+    else {
+        size_t curr_key_index = 0;
+        size_t next_key_index = 0;
+        if (keys_count > 3)
+            glitter_x_curve_get_key_indexes(&c->keys, frame, &curr_key_index, &next_key_index);
+        else if (keys_count == 3 && frame >= c->keys.begin[1].frame) {
+            curr_key_index = 1;
+            next_key_index = 2;
+        }
+        else {
+            curr_key_index = 0;
+            next_key_index = 1;
+        }
+        glitter_curve_key* curr_key = &c->keys.begin[curr_key_index];
+        glitter_curve_key* next_key = &c->keys.begin[next_key_index];
+        _value = glitter_x_curve_interpolate(GPM_VAL, c, frame, curr_key, next_key, curr_key->type, random);
+    }
+
+End:
+    _value = glitter_x_curve_randomize(GPM_VAL, c, _value, random);
+    *value = negate ? -_value : _value;
+    glitter_random_set_value(random, random_val + 1);
+    return true;
+}
+
+static void FASTCALL glitter_x_curve_get_key_indexes(vector_glitter_curve_key* keys,
+    float_t frame, size_t* curr, size_t* next) {
+    size_t v4;
+    glitter_curve_key* v6;
+    size_t count;
+    size_t v9;
+    size_t v10;
+
+    count = keys->end - keys->begin;
+    if (count <= 1) {
+        *curr = 0;
+        *next = 0;
+        return;
+    }
+
+    v4 = 0;
+    v6 = keys->begin;
+    v9 = count - 1;
+    v10 = v9 / 2;
+    while (v4 <= v9) {
+        v10 = (v9 + v4) / 2;
+        if (frame <= v6[(v10 + 1) % count].frame) {
+            if (frame >= v6[v10].frame)
+                goto LABEL_12;
+            v9 = v10 - 1;
+        }
+        else
+            v4 = v10 + 1;
+    }
+
+    if (frame > v6[v10].frame) {
+    LABEL_12:
+        *curr = v10;
+        *next = v10 + 1;
+    }
+    else {
+        *curr = v10 - 1;
+        *next = v10;
+    }
+    *next %= count;
+}
+
+static float_t FASTCALL glitter_x_curve_interpolate(GPM, glitter_curve* c, float_t frame,
+    glitter_curve_key* curr, glitter_curve_key* next, glitter_key_type key_type, glitter_random* random) {
+    float_t next_val;
+    float_t curr_val;
+    float_t val;
+
+    if (key_type == GLITTER_KEY_CONSTANT)
+        return glitter_x_curve_randomize_key(GPM_VAL, c, curr, random);
+
+    float_t df = frame - (float_t)curr->frame;
+    float_t t = df / (float_t)(next->frame - curr->frame);
+    if (key_type == GLITTER_KEY_HERMITE) {
+        float_t t_1 = t - 1.0f;
+        next_val = glitter_x_curve_randomize_key(GPM_VAL, c, next, random);
+        curr_val = glitter_x_curve_randomize_key(GPM_VAL, c, curr, random);
+        val = glitter_x_curve_randomize_key(GPM_VAL, c, curr, random);
+        val += t * t * (3.0f - 2.0f * t) * (next_val - curr_val)
+            + (t_1 * curr->tangent2 + t * next->tangent1) * df * t_1;
+    }
+    else {
+        curr_val = glitter_x_curve_randomize_key(GPM_VAL, c, curr, random);
+        next_val = glitter_x_curve_randomize_key(GPM_VAL, c, next, random);
+        val = curr_val + (next_val - curr_val) * t;
+    }
+    return val;
+}
+
+static float_t FASTCALL glitter_x_curve_randomize(GPM,
+    glitter_curve* c, float_t value, glitter_random* random) {
+    float_t rand;
+
+    if (~c->flags & GLITTER_CURVE_RANDOM_RANGE)
+        return value;
+
+    rand = glitter_random_get_float_min_max(GPM_VAL, random,
+        c->flags & GLITTER_CURVE_RANDOM_RANGE_NEGATE ? -c->random_range : 0.0f, c->random_range);
+
+    if (c->flags & GLITTER_CURVE_RANDOM_RANGE_MULT)
+        rand *= value * 0.01f;
+    return rand + value;
+}
+
+static float_t FASTCALL glitter_x_curve_randomize_key(GPM,
+    glitter_curve* c, glitter_curve_key* key, glitter_random* random) {
+    float_t rand;
+
+    if (~c->flags & GLITTER_CURVE_KEY_RANDOM_RANGE)
+        return key->value;
+
+    rand = glitter_random_get_float_min_max(GPM_VAL, random,
+        c->flags & GLITTER_CURVE_RANDOM_RANGE_NEGATE ? -key->random_range : 0.0f, key->random_range);
+
+    if (c->flags & GLITTER_CURVE_RANDOM_RANGE_MULT)
+        rand *= key->value * 0.01f;
+    return rand + key->value;
+}

src/CRE/GlitterX/effect_inst_x.c

@@ -0,0 +1,56 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "effect_inst_x.h"
+#include "../Glitter/counter.h"
+#include "../Glitter/random.h"
+#include "curve_x.h"
+#include "emitter_inst_x.h"
+#include "render_group_x.h"
+
+static int32_t FASTCALL glitter_x_effect_inst_get_ext_anim_bone_index(int32_t index);
+
+static int32_t FASTCALL glitter_x_effect_inst_get_ext_anim_bone_index(int32_t index) {
+    switch (index) {
+    case 0:
+        return 15;
+    case 1:
+        return 54;
+    case 2:
+        return 0;
+    case 3:
+        return 7;
+    case 4:
+        return 98;
+    case 5:
+        return 100;
+    case 6:
+        return 101;
+    case 7:
+        return 115;
+    case 8:
+        return 132;
+    case 9:
+        return 136;
+    case 10:
+        return 137;
+    case 11:
+        return 151;
+    case 12:
+        return 186;
+    case 13:
+        return 176;
+    case 14:
+        return 175;
+    case 15:
+        return 189;
+    case 16:
+        return 183;
+    case 17:
+        return 182;
+    default:
+        return 193;
+    }
+}

src/CRE/GlitterX/effect_inst_x.h

@@ -0,0 +1,8 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../Glitter/glitter.h"

src/CRE/GlitterX/emitter_inst_x.c

@@ -0,0 +1,12 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "emitter_inst_x.h"
+#include "../Glitter/random.h"
+#include "curve_x.h"
+#include "particle_inst_x.h"
+#include "../camera.h"
+
+extern camera* cam;

src/CRE/GlitterX/emitter_inst_x.h

@@ -0,0 +1,8 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../Glitter/glitter.h"

src/CRE/GlitterX/locus_history_x.c

@@ -0,0 +1,64 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "locus_history_x.h"
+
+glitter_locus_history* FASTCALL glitter_x_locus_history_init(size_t size) {
+    glitter_locus_history* lh = force_malloc(sizeof(glitter_locus_history));
+    vector_glitter_locus_history_data_append(&lh->data, size);
+    return lh;
+}
+
+void FASTCALL glitter_x_locus_history_append(GPM, glitter_locus_history* a1,
+    glitter_render_element* a2, glitter_particle_inst* a3) {
+    glitter_locus_history_data* data;
+    glitter_locus_history_data locus_history;
+    glitter_emitter_inst* emitter;
+    ssize_t size;
+    ssize_t i;
+    vec3 temp;
+    vec3 temp1;
+
+    data = a1->data.begin;
+    size = a1->data.end - a1->data.begin;
+    temp = a2->translation;
+    if (a3->data.data.flags & GLITTER_PARTICLE_EMITTER_LOCAL && (emitter = a3->data.emitter)) {
+        vec3 emit_trans;
+        mat4_get_translation(&emitter->mat, &emit_trans);
+        vec3_add(temp, emit_trans, temp);
+        if (glt_type == GLITTER_X && a3->data.emitter
+            && a3->data.data.flags & GLITTER_PARTICLE_ROTATE_LOCUS)
+            mat4_mult_vec3(&a3->data.emitter->mat_no_scale, &temp, &temp);
+    }
+
+    locus_history.color = a2->color;
+    locus_history.translation = temp;
+    locus_history.scale = a2->scale_particle.x * a2->scale.x * a2->scale_all;
+    if (size < 1)
+        vector_glitter_locus_history_data_push_back(&a1->data, &locus_history);
+    else if (size == 1) {
+        locus_history.translation = data->translation;
+        if (a1->data.capacity_end - a1->data.begin > 1)
+            vector_glitter_locus_history_data_push_back(&a1->data, &locus_history);
+        data->translation = temp;
+    }
+    else {
+        temp1 = data[size - 1].translation;
+
+        for (i = size - 1; i > 0; i--)
+            data[i].translation = data[i - 1].translation;
+
+        if (size < a1->data.capacity_end - a1->data.begin) {
+            locus_history.translation = temp1;
+            vector_glitter_locus_history_data_push_back(&a1->data, &locus_history);
+        }
+        data->translation = temp;
+    }
+}
+
+void FASTCALL glitter_x_locus_history_dispose(glitter_locus_history* lh) {
+    vector_glitter_locus_history_data_free(&lh->data);
+    free(lh);
+}

src/CRE/GlitterX/locus_history_x.h

@@ -0,0 +1,13 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../Glitter/glitter.h"
+
+extern glitter_locus_history* FASTCALL glitter_x_locus_history_init(size_t size);
+extern void FASTCALL glitter_x_locus_history_append(GPM, glitter_locus_history* a1,
+    glitter_render_element* a2, glitter_particle_inst* a3);
+extern void FASTCALL glitter_x_locus_history_dispose(glitter_locus_history* lh);

src/CRE/GlitterX/particle_inst_x.c

@@ -0,0 +1,8 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "particle_inst_x.h"
+#include "effect_inst_x.h"
+#include "render_group_x.h"

src/CRE/GlitterX/particle_inst_x.h

@@ -0,0 +1,8 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../Glitter/glitter.h"

src/CRE/GlitterX/render_element_x.c

@@ -0,0 +1,12 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "render_element_x.h"
+#include "../Glitter/counter.h"
+#include "../Glitter/random.h"
+#include "curve_x.h"
+#include "emitter_inst_x.h"
+#include "locus_history_x.h"
+#include "particle_inst_x.h"

src/CRE/GlitterX/render_element_x.h

@@ -0,0 +1,8 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../Glitter/glitter.h"

src/CRE/GlitterX/render_group_x.c

@@ -0,0 +1,16 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "emitter_inst_x.h"
+#include "../Glitter/random.h"
+#include "render_group_x.h"
+#include "render_element_x.h"
+#include "../camera.h"
+#include "../shader.h"
+#include "../shared.h"
+#include "../static_var.h"
+
+extern camera* cam;
+extern shader_fbo particle_shader;

src/CRE/GlitterX/render_group_x.h

@@ -0,0 +1,8 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../Glitter/glitter.h"

src/CRE/camera.c

@@ -10,28 +10,28 @@ camera* camera_init() {
     return c;
 }
 
-void camera_update_focal_length(camera* c);
-void camera_rebuild_projection(camera* c);
-void camera_calculate_rotation(camera* c);
-void camera_calculate(camera* c);
+static void camera_calculate_projection(camera* c);
+static void camera_calculate_view(camera* c);
+static void camera_calculate_forward(camera* c);
 
 void camera_initialize(camera* c, double_t aspect, double_t fov) {
     c->aspect = aspect;
     c->fov = fov;
-    c->up = (vec3){ 0.0f, 1.0f, 0.0f };
-    c->position = vec3_null;
-    c->target = (vec3){ 0.0f, 0.0f, -1.0f };
+    c->view_point = (vec3){ 0.0, 0.0f, 0.0f };
+    c->interest = (vec3){ 0.0f, 0.0f, -1.0f };
     c->view = mat4_identity;
     c->projection = mat4_identity;
     c->view_projection = mat4_identity;
+    c->inv_projection = mat4_identity;
+    c->inv_view = mat4_identity;
     c->min_distance = 0.05;
     c->max_distance = 6000.0;
+    c->changed_proj = true;
+    c->changed_view = true;
     camera_set_pitch(c, 0.0);
     camera_set_yaw(c, 0.0);
     camera_set_roll(c, 0.0);
-    camera_calculate_rotation(c);
-    camera_rebuild_projection(c);
-    camera_calculate(c);
+    camera_update(c);
 }
 
 double_t camera_get_min_distance(camera* c) {
@@ -41,7 +41,7 @@ double_t camera_get_min_distance(camera* c) {
 void camera_set_min_distance(camera* c, double_t value) {
     if (value != c->min_distance) {
         c->min_distance = value;
-        camera_rebuild_projection(c);
+        c->changed_proj = true;
     }
 }
 
@@ -52,63 +52,10 @@ double_t camera_get_max_distance(camera* c) {
 void camera_set_max_distance(camera* c, double_t value) {
     if (value != c->max_distance) {
         c->max_distance = value;
-        camera_rebuild_projection(c);
+        c->changed_proj = true;
     }
 }
 
-double_t camera_get_camera_aperture_w(camera* c) {
-    return c->camera_aperture_w;
-}
-
-void camera_set_camera_aperture_w(camera* c, double_t value) {
-    if (value != c->camera_aperture_w) {
-        c->camera_aperture_w = value;
-        camera_rebuild_projection(c);
-    }
-}
-
-double_t camera_get_camera_aperture_h(camera* c) {
-    return c->camera_aperture_h;
-}
-
-void camera_set_camera_aperture_h(camera* c, double_t value) {
-    if (value != c->camera_aperture_h) {
-        c->camera_aperture_h = value;
-        camera_rebuild_projection(c);
-    }
-}
-
-double_t camera_get_focal_length(camera* c) {
-    return c->focal_length;
-}
-
-void camera_set_focal_length(camera* c, double_t value) {
-    if (value != c->focal_length) {
-        c->focal_length = value;
-        camera_rebuild_projection(c);
-    }
-}
-
-bool camera_get_fov_horizontal(camera* c) {
-    return c->fov_horizontal;
-}
-
-void camera_set_fov_horizontal(camera* c, bool value) {
-    if (value != c->fov_horizontal) {
-        c->fov_horizontal = value;
-        camera_rebuild_projection(c);
-    }
-}
-
-void camera_update_focal_length(camera* c) {
-    camera_set_aspect(c, c->camera_aperture_w / c->camera_aperture_h);
-    if (c->camera_aperture_w == 0 || c->camera_aperture_h == 0 || c->focal_length == 0)
-        return;
-
-    c->fov = atan(c->camera_aperture_h * 12.7 / c->focal_length);
-    camera_set_fov(c, c->fov * 180.0 / M_PI * 2.0);
-}
-
 double_t camera_get_aspect(camera* c) {
     return c->aspect;
 }
@@ -116,7 +63,7 @@ double_t camera_get_aspect(camera* c) {
 void camera_set_aspect(camera* c, double_t value) {
     if (value != c->aspect) {
         c->aspect = value;
-        camera_rebuild_projection(c);
+        c->changed_proj = true;
     }
 }
 
@@ -128,46 +75,24 @@ void camera_set_fov(camera* c, double_t value) {
     value = clamp(value, 1.0, 180.0);
     if (value != c->fov) {
         c->fov = value;
-        camera_rebuild_projection(c);
+        c->changed_proj = true;
     }
 }
 
-void camera_rebuild_projection(camera* c) {
-    double_t fov = c->fov;
-    if (c->fov_horizontal)
-        fov = 2.0 * atan(1.0 / c->aspect * tan(fov * 0.5));
-    fov = fov * M_PI / 180.0;
-
-    double_t max_y = c->min_distance * tan(fov * 0.5);
-    double_t min_y = -max_y;
-    double_t max_x = max_y * c->aspect;
-    double_t min_x = min_y * c->aspect;
-
-    double_t x = max_x - min_x;
-    double_t y = max_y - min_y;
-    double_t a = (max_x + min_x) / x;
-    double_t b = (max_y + min_y) / y;
-    double_t e = c->max_distance - c->min_distance;
-    double_t d = -(2.0f * c->max_distance * c->min_distance) / e;
-
-    x = 2.0f * c->min_distance / x;
-    y = 2.0f * c->min_distance / y;
-    e = -(c->max_distance + c->min_distance) / e;
-
-    c->projection.row0 = (vec4){ (float_t)x, 0.0f, 0.0f, 0.0f };
-    c->projection.row1 = (vec4){ 0.0f, (float_t)y, 0.0f, 0.0f };
-    c->projection.row2 = (vec4){ (float_t)a, (float_t)b, (float_t)e, -1.0f };
-    c->projection.row3 = (vec4){ 0.0f, 0.0f, (float_t)d, 0.0f };
-
-    mat4_mult(&c->view, &c->projection, &c->view_projection);
-}
-
 double_t camera_get_pitch(camera* c) {
     return c->pitch;
 }
 
 void camera_set_pitch(camera* c, double_t value) {
-    c->pitch = clamp(value, -89.5, 89.5);
+    while (value > 180.0)
+        value -= 360.0;
+    while (value < -180.0)
+        value += 360.0;
+    value = clamp(value, -89.5, 89.5);
+    if (c->pitch != value) {
+        c->pitch = value;
+        c->changed_view = true;
+    }
 }
 
 double_t camera_get_yaw(camera* c) {
@@ -179,11 +104,15 @@ void camera_set_yaw(camera* c, double_t value) {
         value -= 360.0;
     while (value < -180.0)
         value += 360.0;
-    c->yaw = value - 90.0;
+    value -= 90.0;
+    if (c->yaw != value) {
+        c->yaw = value;
+        c->changed_view = true;
+    }
 }
 
 double_t camera_get_roll(camera* c) {
-    return c->roll;
+    return -c->roll;
 }
 
 void camera_set_roll(camera* c, double_t value) {
@@ -191,132 +120,181 @@ void camera_set_roll(camera* c, double_t value) {
         value -= 360.0;
     while (value < -180.0)
         value += 360.0;
-    c->roll = value;
+    value = -value;
+    if (c->roll != value) {
+        c->roll = value;
+        c->changed_view = true;
+    }
+}
+
+void camera_get_view_point(camera* c, vec3* value) {
+
+}
+
+void camera_set_view_point(camera* c, vec3* value) {
+    if (c->view_point.x != value->x
+        || c->view_point.y != value->y
+        || c->view_point.z != value->z) {
+        c->view_point = *value;
+        c->changed_view = true;
+    }
+}
+
+void camera_get_interest_point(camera* c, vec3* value) {
+    *value = c->interest;
+}
+
+void camera_set_interest_point(camera* c, vec3* value) {
+    if (c->interest.x != value->x
+        || c->interest.y != value->y
+        || c->interest.z != value->z) {
+        c->interest = *value;
+        c->changed_view = true;
+    }
 }
 
 void camera_reset(camera* c) {
     camera_set_pitch(c, 0.0);
     camera_set_yaw(c, 0.0);
     camera_set_roll(c, 0.0);
-    c->position = vec3_null;
-    camera_calculate_rotation(c);
-    camera_calculate(c);
+    camera_calculate_forward(c);
+    camera_set_position(c, &(vec3){ 0.0, 0.0f, 0.0f});
+    camera_update(c);
 }
 
-void camera_set_point(camera* c, vec3* view_point, vec3* interest_point,
-    vec3* trans, vec3* rot, vec3* scale, double_t roll, double_t fov) {
-    if (fov > 0.0)
-        camera_set_fov(c, fov);
-
-    while (roll > 180.0)
-        roll -= 360.0;
-    while (roll < -180.0)
-        roll += 360.0;
-    c->position = *view_point;
-    c->target = *interest_point;
-    c->up.x = (float_t)sin(-c->roll * 180.0 / M_PI);
-    c->up.y = (float_t)cos(c->roll * 180.0 / M_PI);
-    c->up.z = 0;
-
-    mat4 trans_rot = mat4_identity;
-    mat4_rotate_x_mult(&trans_rot, (float_t)rot->x, &trans_rot);
-    mat4_rotate_y_mult(&trans_rot, (float_t)rot->y, &trans_rot);
-    mat4_rotate_z_mult(&trans_rot, (float_t)rot->z, &trans_rot);
-    trans_rot.row3 = (vec4){ trans->x, trans->y, trans->z, 1.0f };
-
-    /*
-    mat4* cam = mat4::CreateScale(scale) * transRot;
-    c->position = new vec3(new Vector4(c->position, 1) * cam);
-    c->target = new vec3(new Vector4(c->target, 1) * cam);
-    vec3 tempVar(new Vector4(c->up, 1) * cam);
-    c->up = (&tempVar)->NormalizeAlt();*/
-    camera_set(c, &c->position, &c->target, &c->up);
-}
-
-void camera_set(camera* c, vec3* eye, vec3* target, vec3* up) {
-    camera_look_at(c, eye, target, up, &c->view);
-    mat4_mult(&c->view, &c->projection, &c->view_projection);
-}
-
-void camera_rotate_vec2(camera* c, vec2* rotate) {
-    if (rotate->x != 0 || rotate->y != 0) {
-        camera_set_yaw(c, camera_get_yaw(c) + rotate->x);
-        camera_set_pitch(c, camera_get_pitch(c) + rotate->y);
-        camera_calculate_rotation(c);
-        camera_calculate(c);
-    }
-}
-
-void camera_move_vec2(camera* c, vec2* move) {
-    if (move->x != 0 || move->y != 0) {
+void camera_move(camera* c, vec2d* move) {
+    if (move->x != 0.0 || move->y != 0.0) {
         vec3 temp;
-        vec3_cross(c->forward, c->up, temp);
+        vec3 view_point;
+        vec3 interest;
+        vec3_cross(c->forward, ((vec3) { 0.0f, 1.0f, 0.0f}), temp);
         vec3_normalize(temp, temp);
-        vec3_mult_scalar(temp, move->y, temp);
-        vec3_add(c->position, temp, c->position);
-        vec3_mult_scalar(c->forward, move->x, temp);
-        vec3_add(c->position, temp, c->position);
-        camera_calculate(c);
+        vec3_mult_scalar(temp, (float_t)move->y, temp);
+        vec3_add(c->view_point, temp, view_point);
+        vec3_mult_scalar(c->forward, (float_t)move->x, temp);
+        vec3_add(view_point, temp, view_point);
+
+        vec3_add(view_point, c->forward, interest);
+        camera_set_view_point(c, &view_point);
+        camera_set_interest_point(c, &interest);
     }
 }
 
-void camera_move_vec3(camera* c, vec3* move) {
-    if (move->x != 0 || move->y != 0 || move->z != 0) {
-        c->position = *move;
-        camera_calculate(c);
+void camera_rotate(camera* c, vec2d* rotate) {
+    if (rotate->x != 0.0)
+        camera_set_yaw(c, camera_get_yaw(c) + rotate->x);
+
+    if (rotate->y != 0.0)
+        camera_set_pitch(c, camera_get_pitch(c) + rotate->y);
+
+    if (rotate->x != 0.0 || rotate->y != 0.0) {
+        camera_calculate_forward(c);
+
+        vec3 interest;
+        vec3_add(c->view_point, c->forward, interest);
+        camera_set_interest_point(c, &interest);
     }
 }
 
-void camera_calculate_rotation(camera* c) {
-    c->right.x = 0;
-    c->right.y = (float_t)cos(c->pitch * M_PI / 180.0);
-    c->right.z = (float_t)sin(c->pitch * M_PI / 180.0);
-    c->forward.x = (float_t)(cos(c->pitch * M_PI / 180.0) * cos(c->yaw * M_PI / 180.0));
-    c->forward.y = (float_t)sin(c->pitch * M_PI / 180.0);
-    c->forward.z = (float_t)(cos(c->pitch * M_PI / 180.0) * sin(c->yaw * M_PI / 180.0));
-    //c->up.x = (float_t)sin(c->roll * M_PI / 180.0);
-    //c->up.y = (float_t)cos(c->roll * M_PI / 180.0);
-    //c->up.z = 0;
+void camera_roll(camera* c, double_t roll) {
+    if (roll != 0.0f)
+        camera_set_roll(c, camera_get_roll(c) + roll);
 }
 
-void camera_calculate(camera* c) {
-    vec3_add(c->position, c->forward, c->target);
-    camera_look_at(c, &c->position, &c->target, &c->up, &c->view);
-    mat4_mult(&c->view, &c->projection, &c->view_projection);
+void camera_set(camera* c, vec3* view_point, vec3* interest,
+    vec3* trans, vec3* rot, vec3* scale, double_t roll, double_t fov) {
+    vec3 _vp;
+    vec3 _int;
+    double_t _roll;
+    double_t _fov;
+
+    _vp = *view_point;
+    _int = *interest;
+    _roll = roll;
+    _fov = fov;
+    while (_roll > 180.0)
+        _roll -= 360.0;
+    while (_roll < -180.0)
+        _roll += 360.0;
+
+    mat4 cam;
+    mat4_translate(trans->x, trans->y, trans->z, &cam);
+    mat4_rotate_mult(&cam, rot->x, rot->y, rot->z, &cam);
+    mat4_scale_rot(&cam, scale->x, scale->y, scale->z, &cam);
+    mat4_mult_vec3_trans(&cam, &_vp, &_vp);
+    mat4_mult_vec3_trans(&cam, &_int, &_int);
+
+    camera_set_view_point(c, &_vp);
+    camera_set_interest_point(c, &_int);
+    camera_set_roll(c, _roll);
+    camera_set_fov(c, _fov);
 }
 
-void camera_look_at(camera* c, vec3* eye, vec3* target, vec3* up, mat4* view) {
-    vec3 x, y, z;
-    float_t t;
-    vec3 xyz;
+void camera_set_position(camera* c, vec3* pos) {
+    vec3 interest;
+    vec3_add(*pos, c->forward, interest);
+    camera_set_view_point(c, pos);
+    camera_set_interest_point(c, &interest);
+}
 
-    vec3_sub(*eye, *target, z);
-    vec3_normalize(z, z);
+void camera_update(camera* c) {
+    if (c->changed_proj)
+        camera_calculate_projection(c);
 
-    vec3_cross(*up, z, x);
-    vec3_normalize(x, x);
-    vec3_length(x, t);
-    if (t == 0.0f)
-        x = (vec3){ 1.0f, 0.0f, 0.0f };
-    vec3_cross(z, x, y);
-    vec3_normalize(y, y);
+    if (c->changed_view)
+        camera_calculate_view(c);
 
-    vec3_dot(x, *eye, xyz.x);
-    vec3_dot(y, *eye, xyz.y);
-    vec3_dot(z, *eye, xyz.z);
-    view->row0 = (vec4){ x.x, y.x, z.x, 0.0f };
-    view->row1 = (vec4){ x.y, y.y, z.y, 0.0f };
-    view->row2 = (vec4){ x.z, y.z, z.z, 0.0f };
-    *(vec3*)&view->row3 = xyz;
-    view->row3.w = -1.0f;
-    vec4_negate(view->row3, view->row3);
-
-    c->rotation.x = asinf(view->row1.z);
-    c->rotation.y = atan2f(-view->row0.z, view->row2.z);
-    c->rotation.z = atan2f(-view->row1.x, view->row1.y);
-    vec3_negate(c->rotation, c->rotation);
+    if (c->changed_proj || c->changed_view) {
+        mat4_mult(&c->view, &c->projection, &c->view_projection);
+        c->changed_proj = false;
+        c->changed_view = false;
+        c->updated = true;
+    }
+    else
+        c->updated = false;
 }
 
 void camera_dispose(camera* c) {
     free(c);
 }
+
+static void camera_calculate_forward(camera* c) {
+    c->forward.x = (float_t)(cos(c->pitch * DEG_TO_RAD) * cos(c->yaw * DEG_TO_RAD));
+    c->forward.y = (float_t)sin(c->pitch * DEG_TO_RAD);
+    c->forward.z = (float_t)(cos(c->pitch * DEG_TO_RAD) * sin(c->yaw * DEG_TO_RAD));
+}
+
+static void camera_calculate_projection(camera* c) {
+    double_t tan_fov = tan(c->fov * 0.5);
+
+    double_t max_d = c->max_distance;
+    double_t min_d = c->min_distance;
+
+    double_t x = 1.0 / (c->aspect * tan_fov);
+    double_t y = 1.0 / tan_fov;
+    double_t d = -(2.0 * max_d * min_d) / (max_d - min_d);
+    double_t e = -(max_d + min_d) / (max_d - min_d);
+
+    c->projection.row0 = (vec4){ (float_t)x, 0.0f, 0.0f, 0.0f };
+    c->projection.row1 = (vec4){ 0.0f, (float_t)y, 0.0f, 0.0f };
+    c->projection.row2 = (vec4){ 0.0f, 0.0f, (float_t)e, -1.0f };
+    c->projection.row3 = (vec4){ 0.0f, 0.0f, (float_t)d, 0.0f };
+
+    mat4_inverse(&c->projection, &c->inv_projection);
+}
+
+static void camera_calculate_view(camera* c) {
+    vec3 dist;
+    vec3_sub(c->view_point, c->interest, dist);
+    c->rotation.x = atan2f(-dist.y, sqrtf(dist.x * dist.x + dist.z * dist.z));
+    c->rotation.y = atan2f(dist.x, dist.z);
+    c->rotation.z = (float_t)(c->roll * DEG_TO_RAD);
+    c->view = mat4_identity;
+    mat4_rot_z(&c->view, -c->rotation.z, &c->view);
+    mat4_rot_x(&c->view, -c->rotation.x, &c->view);
+    mat4_rot_y(&c->view, -c->rotation.y, &c->view);
+    mat4_translate_mult(&c->view, -c->view_point.x, -c->view_point.y, -c->view_point.z, &c->view);
+    mat4_inverse(&c->view, &c->inv_view);
+    mat3_from_mat4(&c->view, &c->view_mat3);
+    mat3_inverse(&c->view_mat3, &c->inv_view_mat3);
+}

src/CRE/camera.h

@@ -13,23 +13,24 @@ typedef struct camera {
     mat4 view;
     mat4 projection;
     mat4 view_projection;
-    vec3 position;
-    vec3 target;
-    vec3 up;
-    vec3 right;
+    mat4 inv_projection;
+    mat4 inv_view;
+    mat3 view_mat3;
+    mat3 inv_view_mat3;
     vec3 forward;
     vec3 rotation;
+    vec3 view_point;
+    vec3 interest;
     double_t yaw;
     double_t pitch;
     double_t roll;
-    double_t camera_aperture_w;
-    double_t camera_aperture_h;
     double_t aspect;
-    double_t focal_length;
     double_t fov;
-    bool fov_horizontal;
     double_t max_distance;
     double_t min_distance;
+    bool changed_proj;
+    bool changed_view;
+    bool updated;
 } camera;
 
 extern camera* camera_init();
@@ -38,14 +39,6 @@ extern double_t camera_get_min_distance(camera* c);
 extern void camera_set_min_distance(camera* c, double_t value);
 extern double_t camera_get_max_distance(camera* c);
 extern void camera_set_max_distance(camera* c, double_t value);
-extern double_t camera_get_camera_aperture_w(camera* c);
-extern void camera_set_camera_aperture_w(camera* c, double_t value);
-extern double_t camera_get_camera_aperture_h(camera* c);
-extern void camera_set_camera_aperture_h(camera* c, double_t value);
-extern double_t camera_get_focal_length(camera* c);
-extern void camera_set_focal_length(camera* c, double_t value);
-extern bool camera_get_fov_horizontal(camera* c);
-extern void camera_set_fov_horizontal(camera* c, bool value);
 extern double_t camera_get_aspect(camera* c);
 extern void camera_set_aspect(camera* c, double_t value);
 extern double_t camera_get_fov(camera* c);
@@ -56,12 +49,16 @@ extern double_t camera_get_yaw(camera* c);
 extern void camera_set_yaw(camera* c, double_t value);
 extern double_t camera_get_roll(camera* c);
 extern void camera_set_roll(camera* c, double_t value);
+extern void camera_get_view_point(camera* c, vec3* value);
+extern void camera_set_view_point(camera* c, vec3* value);
+extern void camera_get_interest_point(camera* c, vec3* value);
+extern void camera_set_interest_point(camera* c, vec3* value);
 extern void camera_reset(camera* c);
-extern void camera_set_point(camera* c, vec3* view_point, vec3* interest_point,
+extern void camera_move(camera* c, vec2d* move);
+extern void camera_rotate(camera* c, vec2d* rotate);
+extern void camera_roll(camera* c, double_t roll);
+extern void camera_set(camera* c, vec3* view_point, vec3* interest,
     vec3* trans, vec3* rot, vec3* scale, double_t roll, double_t fov);
-extern void camera_set(camera* c, vec3* eye, vec3* target, vec3* up);
-extern void camera_rotate_vec2(camera* c, vec2* rotate);
-extern void camera_move_vec2(camera* c, vec2* move);
-extern void camera_move_vec3(camera* c, vec3* move);
-extern void camera_look_at(camera* c, vec3* eye, vec3* target, vec3* up, mat4* view);
+extern void camera_set_position(camera* c, vec3* pos);
+extern void camera_update(camera* c);
 extern void camera_dispose(camera* c);

src/CRE/dof.c

@@ -0,0 +1,108 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "dof.h"
+
+static const dof_debug dof_debug_default = {
+    .flags = 0,
+    .distance_to_focus = 10.0f,
+    .focal_length = 40.0f,
+    .f_number = 1.4f,
+    .f2 = {
+        .distance_to_focus = 10.0f,
+        .focus_range = 1.0f,
+        .fuzzing_range = 0.5f,
+        .ratio = 1.0f,
+    },
+};
+
+static const dof_pv dof_pv_default = {
+    .enable = false,
+    .f2 = {
+        .distance_to_focus = 10.0f,
+        .focus_range = 1.0f,
+        .fuzzing_range = 0.5f,
+        .ratio = 1.0f,
+    },
+};
+
+static  void dof_calculate(dof_struct* d, size_t height, double_t min_dist, double_t max_dist, double_t fov,
+    float_t dist, float_t focal_length, float_t f_number, float_t focus_range, float_t fuzzing_range, float_t ratio);
+
+dof_struct* dof_init() {
+    dof_struct* d = force_malloc(sizeof(dof_struct));
+    return d;
+}
+
+void dof_initialize(dof_struct* d, dof_debug* debug, dof_pv* pv) {
+    if (debug)
+        d->debug = *debug;
+    else
+        d->debug = dof_debug_default;
+
+    if (pv)
+        d->pv = *pv;
+    else
+        d->pv = dof_pv_default;
+}
+
+void dof_get_dof_debug(dof_struct* d, dof_debug* debug) {
+    if (debug)
+        *debug = d->debug;
+}
+
+void dof_set_dof_debug(dof_struct* d, dof_debug* debug) {
+    if (debug)
+        d->debug = *debug;
+    else
+        d->debug = dof_debug_default;
+}
+
+void dof_get_dof_pv(dof_struct* d, dof_pv* pv) {
+    if (pv)
+        *pv = d->pv;
+}
+
+void dof_set_dof_pv(dof_struct* d, dof_pv* pv) {
+    if (pv)
+        d->pv = *pv;
+    else
+        d->pv = dof_pv_default;
+}
+void dof_calculate_physical(dof_struct* d, size_t height,
+    double_t min_dist, double_t max_dist, double_t fov, float_t dist,
+    float_t focal_length, float_t f_number) {
+    dof_calculate(d, height, min_dist, max_dist, fov, dist, focal_length, f_number, 0.0f, 1.0f, 0.0f);
+}
+
+void dof_calculate_f2(dof_struct* d, size_t height,
+    double_t min_dist, double_t max_dist, double_t fov, float_t dist,
+    float_t focus_range, float_t fuzzing_range, float_t ratio) {
+    dof_calculate(d, height, min_dist, max_dist, fov, dist, 0.0f, 1.0f, focus_range, fuzzing_range, ratio);
+}
+
+void dof_dispose(dof_struct* d) {
+    free(d);
+}
+
+static void dof_calculate(dof_struct* d, size_t height, double_t min_dist, double_t max_dist, double_t fov,
+    float_t dist, float_t focal_length, float_t f_number, float_t focus_range, float_t fuzzing_range, float_t ratio) {
+    double_t fl = (double_t)focal_length;
+    if (dist <= focal_length)
+        fl = (double_t)dist + 0.1;
+    fl = fl * fl * (1.0 / ((dist - fl) * f_number));
+    d->data[0] = (float_t)((min_dist - max_dist) / (min_dist * max_dist));
+    d->data[1] = (float_t)(1.0 / min_dist);
+    d->data[2] = -(float_t)(((fl * dist) * (min_dist - max_dist)) * (1.0 / (min_dist * max_dist)));
+    d->data[3] = (float_t)((1.0 - dist * (1.0 / min_dist)) * fl);
+    d->data[4] = (float_t)((double_t)height / (tan(fov * 0.5) * 2.0 * min_dist));
+    d->data[5] = d->data[4] * (float_t)(1.0 / 3.0);
+    d->data[6] = (float_t)(1.0 / 3.0);
+    d->data[7] = 3.0;
+    d->data[8] = dist;
+    d->data[9] = focus_range;
+    d->data[10] = -4.5f / (fuzzing_range * fuzzing_range);
+    d->data[11] = ratio * 8.0f;
+}

src/CRE/dof.h

@@ -0,0 +1,53 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../KKdLib/default.h"
+#include "../KKdLib/mat.h"
+#include "../KKdLib/vec.h"
+
+typedef enum dof_debug_flags {
+    DOF_DEBUG_USE_UI_PARAMS   = 0x1,
+    DOF_DEBUG_ENABLE_DOF      = 0x2,
+    DOF_DEBUG_ENABLE_PHYS_DOF = 0x4,
+    DOF_DEBUG_AUTO_FOCUS      = 0x8,
+} dof_debug_flags;
+
+typedef struct dof_f2 {
+    float_t distance_to_focus;
+    float_t focus_range;
+    float_t fuzzing_range;
+    float_t ratio;
+} dof_f2;
+
+typedef struct dof_debug {
+    dof_debug_flags flags;
+    float_t distance_to_focus;
+    float_t focal_length;
+    float_t f_number;
+    dof_f2 f2;
+} dof_debug;
+
+typedef struct dof_pv {
+    bool enable;
+    dof_f2 f2;
+} dof_pv;
+
+typedef struct dof_struct {
+    dof_debug debug;
+    dof_pv pv;
+    float_t data[12];
+} dof_struct;
+
+extern dof_struct* dof_init();
+extern void dof_initialize(dof_struct* d, dof_debug* debug, dof_pv* pv);
+extern void dof_calculate_physical(dof_struct* d, size_t height,
+    double_t min_dist, double_t max_dist, double_t fov, float_t dist,
+    float_t focal_length, float_t f_number);
+extern void dof_calculate_f2(dof_struct* d, size_t height,
+    double_t min_dist, double_t max_dist, double_t fov, float_t dist,
+    float_t focus_range, float_t fuzzing_range, float_t ratio);
+extern void dof_dispose(dof_struct* d);