diff --git a/src/CRE/object.cpp b/src/CRE/object.cpp
index 529b1ffb..42f0a1af 100644
--- a/src/CRE/object.cpp
+++ b/src/CRE/object.cpp
@@ -1639,6 +1639,31 @@ inline obj* object_storage_get_obj(object_info obj_info) {
     return 0;
 }
 
+inline obj* object_storage_get_obj_by_index(uint32_t set_id, uint32_t index) {
+    auto elem = object_storage_data.find(set_id);
+    if (elem != object_storage_data.end()) {
+        obj_set* set = elem->second.obj_set;
+        if (!set)
+            return 0;
+
+        if (index < elem->second.obj_set->obj_num)
+            return elem->second.obj_set->obj_data[index];
+        return 0;
+    }
+
+    auto elem_modern = object_storage_data_modern.find(set_id);
+    if (elem_modern != object_storage_data_modern.end()) {
+        obj_set* set = elem_modern->second.obj_set;
+        if (!set)
+            return 0;
+
+        if (index < elem_modern->second.obj_set->obj_num)
+            return elem_modern->second.obj_set->obj_data[index];
+        return 0;
+    }
+    return 0;
+}
+
 inline ObjsetInfo* object_storage_get_objset_info(uint32_t set_id) {
     auto elem = object_storage_data.find(set_id);
     if (elem != object_storage_data.end())
diff --git a/src/CRE/object.hpp b/src/CRE/object.hpp
index 0f0cdbf5..d5416c54 100644
--- a/src/CRE/object.hpp
+++ b/src/CRE/object.hpp
@@ -122,6 +122,7 @@ extern void object_material_msgpack_write(const char* path, const char* set_name
 
 extern void object_storage_init(const object_database* obj_db);
 extern obj* object_storage_get_obj(object_info obj_info);
+extern obj* object_storage_get_obj_by_index(uint32_t set_id, uint32_t index);
 extern ObjsetInfo* object_storage_get_objset_info(uint32_t set_id);
 extern obj_mesh* object_storage_get_obj_mesh(object_info obj_info, const char* mesh_name);
 extern obj_mesh* object_storage_get_obj_mesh_by_index(object_info obj_info, uint32_t index);
diff --git a/src/KKdLib/database/object.cpp b/src/KKdLib/database/object.cpp
index 3a1437ec..4c04efac 100644
--- a/src/KKdLib/database/object.cpp
+++ b/src/KKdLib/database/object.cpp
@@ -288,6 +288,8 @@ void object_database::clear() {
     obj_set_ids.shrink_to_fit();
     obj_set_murmurhashes.clear();
     obj_set_murmurhashes.shrink_to_fit();
+    obj_set_names.clear();
+    obj_set_names.shrink_to_fit();
     obj_infos.clear();
     obj_infos.shrink_to_fit();
     obj_fnv1a64m_hashes.clear();
@@ -307,6 +309,7 @@ void object_database::clear() {
 void object_database::update() {
     obj_set_ids.clear();
     obj_set_murmurhashes.clear();
+    obj_set_names.clear();
     obj_infos.clear();
     obj_fnv1a64m_hashes.clear();
     obj_fnv1a64m_hashes_upper.clear();
@@ -317,10 +320,12 @@ void object_database::update() {
 
     obj_set_ids.reserve(object_set.size());
     obj_set_murmurhashes.reserve(object_set.size());
+    obj_set_names.reserve(object_set.size());
 
     for (object_set_info& i : object_set) {
         obj_set_ids.push_back(i.id, &i);
         obj_set_murmurhashes.push_back(i.name_hash, &i);
+        obj_set_names.push_back(i.name, &i);
 
         obj_infos.reserve(i.object.size());
         obj_fnv1a64m_hashes.reserve(i.object.size());
@@ -343,6 +348,7 @@ void object_database::update() {
 
     obj_set_ids.sort_unique();
     obj_set_murmurhashes.sort_unique();
+    obj_set_names.sort_unique();
     obj_infos.sort_unique();
     obj_fnv1a64m_hashes.sort_unique();
     obj_fnv1a64m_hashes_upper.sort_unique();
@@ -485,6 +491,14 @@ const char* object_database::get_object_name(object_info obj_info) const {
     return 0;
 }
 
+uint32_t object_database::get_object_set_count() const {
+    return (uint32_t)object_set.size();
+}
+
+uint32_t object_database::get_object_set_id(uint32_t set_index) const {
+    return set_index < obj_set_names.size() ? (uint32_t)obj_set_names.data()[set_index].second->id : -1;
+}
+
 static void object_database_file_classic_read_inner(object_database_file* obj_db, stream& s) {
     uint32_t object_set_count = s.read_uint32_t();
     uint32_t max_object_set_id = s.read_uint32_t();
diff --git a/src/KKdLib/database/object.hpp b/src/KKdLib/database/object.hpp
index fcb68d5a..52fd92c8 100644
--- a/src/KKdLib/database/object.hpp
+++ b/src/KKdLib/database/object.hpp
@@ -139,6 +139,7 @@ struct object_database {
     std::vector<object_set_info> object_set;
     prj::vector_pair<uint32_t, object_set_info*> obj_set_ids;
     prj::vector_pair<uint32_t, object_set_info*> obj_set_murmurhashes;
+    prj::vector_pair<std::string, object_set_info*> obj_set_names;
     prj::vector_pair<object_info, object_info_data*> obj_infos;
     prj::vector_pair<uint64_t, object_info_data*> obj_fnv1a64m_hashes;
     prj::vector_pair<uint64_t, object_info_data*> obj_fnv1a64m_hashes_upper;
@@ -167,4 +168,6 @@ struct object_database {
     object_info get_object_info_by_fnv1a64m_hash_upper(uint64_t hash) const;
     object_info get_object_info_by_murmurhash(uint32_t hash) const;
     const char* get_object_name(object_info obj_info) const;
+    uint32_t get_object_set_count() const;
+    uint32_t get_object_set_id(uint32_t set_index) const;
 };
diff --git a/src/ReDIVA/data_test/object_test.cpp b/src/ReDIVA/data_test/object_test.cpp
new file mode 100644
index 00000000..8c4637ef
--- /dev/null
+++ b/src/ReDIVA/data_test/object_test.cpp
@@ -0,0 +1,524 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#include "object_test.hpp"
+#include "../../CRE/clear_color.hpp"
+#include "../../CRE/data.hpp"
+#include "../../CRE/render_context.hpp"
+#include "../../CRE/stage.hpp"
+#include "../dw.hpp"
+#include "../input_state.hpp"
+
+class DataTestObjectManager : public app::Task {
+public:
+    int32_t object_set_index;
+    uint32_t object_set_id;
+    int32_t obj_num;
+    int32_t obj_index;
+    vec3 rotation;
+    mdl::ObjFlags obj_flags;
+    int32_t state;
+
+    DataTestObjectManager();
+    virtual ~DataTestObjectManager() override;
+
+    virtual bool init() override;
+    virtual bool ctrl() override;
+    virtual bool dest() override;
+    virtual void disp() override;
+
+    void del_task();
+
+    int32_t get_obj_num();
+    const obj_bounding_sphere* get_object_bounding_sphere(int32_t obj_index);
+    const char* get_object_name(int32_t obj_index);
+    void set_object_index(int32_t value);
+    void set_object_set_index(int32_t object_set_index);
+    void set_rotation(const vec3& value);
+    void set_shadow(bool value);
+};
+
+class DataTestObjDw : public dw::Shell {
+public:
+    dw::ListBox* objects;
+
+    DataTestObjDw();
+    virtual ~DataTestObjDw();
+
+    virtual void Hide() override;
+
+    virtual void ClearIDs();
+    virtual void AddID(const char* value);
+
+    static void CameraCallback(dw::Widget* data);
+    static void ObjectCallback(dw::Widget* data);
+    static void ObjectSetCallback(dw::Widget* data);
+    static void ShadowCallback(dw::Widget* data);
+    static void StageCallback(dw::Widget* data);
+    static void StageDisplayCallback(dw::Widget* data);
+};
+
+extern render_context* rctx_ptr;
+
+DataTestObjDw* data_test_obj_dw;
+DataTestObjectManager* data_test_object_manager;
+TaskDataTestObj* task_data_test_obj;
+
+static void data_test_obj_dw_init();
+
+TaskDataTestObj::Data::Data() : object_set_index(), curr_object_set_index(), obj_num(),
+curr_obj_num(), cull_camera(), curr_cull_camera(), stage_index(), curr_stage_index(), stage_display() {
+    object_index = -1;
+    curr_object_index = -1;
+    shadow = 1;
+}
+
+TaskDataTestObj::TaskDataTestObj() {
+
+}
+
+TaskDataTestObj::~TaskDataTestObj() {
+
+}
+
+bool TaskDataTestObj::init() {
+    clear_color = 0xFF606060;
+
+    camera* cam = rctx_ptr->camera;
+    cam->set_view_point({ 0.0f, 1.0f, 3.45f });
+    cam->set_interest({ 0.0f, 1.0f, 0.0f });
+
+    data_test_obj_dw_init();
+    task_stage_set_stage_index(data.stage_index);
+    task_stage_current_set_stage_display(true, true);
+    return true;
+}
+
+bool TaskDataTestObj::ctrl() {
+     data_test_object_manager->set_object_set_index(data.object_set_index);
+
+    if (data.object_set_index != data.curr_object_set_index) {
+        data.curr_object_set_index = data.object_set_index;
+        data.object_index = -1;
+
+        data_test_object_manager->del_task();
+    }
+
+    data.obj_num = data_test_object_manager->get_obj_num();
+    if (data.obj_num != data.curr_obj_num) {
+        data.curr_obj_num = data.obj_num;
+
+        data_test_obj_dw->ClearIDs();
+        for (int32_t i = 0; i < data.obj_num; i++)
+            data_test_obj_dw->AddID(data_test_object_manager->get_object_name(i));
+    }
+
+    if (data.object_index != data.curr_object_index) {
+        data.curr_object_index = data.object_index;
+        data_test_object_manager->set_object_index(data.object_index);
+    }
+
+    if (data.cull_camera != data.curr_cull_camera) {
+        data.curr_cull_camera = data.cull_camera;
+
+        if (data.cull_camera) {
+            const obj_bounding_sphere* sphere = data_test_object_manager->get_object_bounding_sphere(data.object_index);
+            if (sphere) {
+                camera* cam = rctx_ptr->camera;
+
+                float_t v13 = tanf(cam->get_fov() * DEG_TO_RAD_FLOAT * 0.5f);
+
+                vec3 view_point;
+                view_point.x = sphere->center.x;
+                view_point.y = sphere->center.y;
+                view_point.z = v13 * sphere->radius + sphere->center.z + 0.2f;
+
+                vec3 interest;
+                interest.x = sphere->center.x;
+                interest.y = sphere->center.y;
+                interest.z = 0.0f;
+
+                cam->set_view_point(view_point);
+                cam->set_interest(interest);
+            }
+        }
+        else {
+            camera* cam = rctx_ptr->camera;
+            cam->set_view_point({ 0.0f, 1.0f, 3.45f });
+            cam->set_interest({ 0.0f, 1.0f, 0.0f });
+        }
+    }
+
+    task_stage_check_not_loaded();
+
+    if (data.stage_index != data.curr_stage_index) {
+        data.curr_stage_index = data.stage_index;
+        task_stage_set_stage_index(data.stage_index);
+    }
+
+    data_test_object_manager->set_shadow(data.shadow != 0);
+
+    switch (data.stage_display) {
+    case 0:
+        task_stage_current_set_stage_display(false, true);
+        break;
+    case 1:
+        task_stage_current_set_stage_display(true, true);
+        break;
+    case 2:
+        task_stage_current_set_stage_display(false, true);
+        break;
+    }
+
+    InputState* input_state = input_state_get(0);
+    if (input_state->CheckDown(39)) {
+        if (input_state->CheckDown(96))
+            data.rotation.y += (float_t)input_state->sub_14018CCC0(10);
+        if (input_state->CheckDown(97))
+            data.rotation.x += (float_t)input_state->sub_14018CCC0(10);
+        if (input_state->CheckDown(98))
+            data.rotation.z += (float_t)input_state->sub_14018CCC0(10);
+
+        data_test_object_manager->set_rotation(data.rotation);
+    }
+
+    if (input_state->CheckDoubleTapped(39))
+        data.rotation = 0.0f;
+    return false;
+}
+
+bool TaskDataTestObj::dest() {
+    data_test_object_manager->del_task();
+    clear_color = color_black;
+    data_test_obj_dw->Hide();
+    return true;
+}
+
+void TaskDataTestObj::disp() {
+    if (data.stage_display != 2)
+        return;
+
+    mdl::EtcObj etc(mdl::ETC_OBJ_GRID);
+    etc.color = color_black;
+    etc.data.grid.w = 40;
+    etc.data.grid.h = 40;
+    etc.data.grid.ws = 40;
+    etc.data.grid.hs = 40;
+    rctx_ptr->disp_manager->entry_obj_etc(&mat4_identity, &etc);
+}
+
+TaskDataTestObj::Data* TaskDataTestObj::get_data() {
+    return &data;
+}
+
+void object_test_init() {
+    if (!data_test_object_manager)
+        data_test_object_manager = new DataTestObjectManager;
+
+    if (!task_data_test_obj)
+        task_data_test_obj = new TaskDataTestObj;
+}
+
+void object_test_free() {
+    if (task_data_test_obj) {
+        delete task_data_test_obj;
+        task_data_test_obj = 0;
+    }
+
+    if (data_test_object_manager) {
+        delete data_test_object_manager;
+        data_test_object_manager = 0;
+    }
+}
+
+DataTestObjectManager::DataTestObjectManager() : obj_num(), obj_flags(), state() {
+    object_set_index = -1;
+    object_set_id = -1;
+    obj_index = -1;
+}
+
+DataTestObjectManager::~DataTestObjectManager() {
+
+}
+
+bool DataTestObjectManager::init() {
+    data_struct* aft_data = &data_list[DATA_AFT];
+    object_database* aft_obj_db = &aft_data->data_ft.obj_db;
+
+    obj_num = 0;
+    obj_index = -1;
+    state = 2;
+
+    if (object_set_index < 0 || (int32_t)aft_obj_db->get_object_set_count() <= object_set_index) {
+        state = 0;
+        return true;
+    }
+
+    if (object_set_id != -1) {
+        object_storage_load_set(aft_data, aft_obj_db, object_set_id);
+        state = 1;
+    }
+
+    object_storage_load_set(aft_data, aft_obj_db, aft_obj_db->get_object_set_id(object_set_index));
+    return true;
+}
+
+bool DataTestObjectManager::ctrl() {
+    data_struct* aft_data = &data_list[DATA_AFT];
+    object_database* aft_obj_db = &aft_data->data_ft.obj_db;
+
+    switch (state) {
+    case 1:
+        if (object_set_id == -1 || !object_storage_load_obj_set_check_not_read(object_set_id))
+            state = 2;
+        break;
+    case 2: {
+        uint32_t obj_set_id = aft_obj_db->get_object_set_id(object_set_index);
+        if (!object_storage_load_obj_set_check_not_read(obj_set_id)) {
+            obj_num = object_storage_get_obj_set(obj_set_id)->obj_num;
+            state = 3;
+        }
+    } break;
+    }
+    return false;
+}
+
+bool DataTestObjectManager::dest() {
+    data_struct* aft_data = &data_list[DATA_AFT];
+    object_database* aft_obj_db = &aft_data->data_ft.obj_db;
+
+    object_storage_unload_set(aft_obj_db->get_object_set_id(object_set_index));
+
+    if (object_set_id != -1)
+        object_storage_unload_set(object_set_id);
+    return true;
+}
+
+void DataTestObjectManager::disp() {
+    if (state != 3 || obj_index < 0 || obj_index >= this->obj_num)
+        return;
+
+    data_struct* aft_data = &data_list[DATA_AFT];
+    object_database* aft_obj_db = &aft_data->data_ft.obj_db;
+
+    uint32_t obj_set_id = aft_obj_db->get_object_set_id(object_set_index);
+    uint32_t obj_id = object_storage_get_obj_by_index(obj_set_id, obj_index)->id;
+    rctx_ptr->disp_manager->set_obj_flags((mdl::ObjFlags)(mdl::OBJ_40 | mdl::OBJ_20 | obj_flags));
+
+    mat4 mat;
+    mat4_rotate_xyz(&rotation, &mat);
+
+    vec3 pos = 0.0f;
+    shadow_ptr_get()->field_1D0[SHADOW_CHARA].push_back(pos);
+
+    rctx_ptr->disp_manager->set_shadow_type(SHADOW_CHARA);
+    rctx_ptr->disp_manager->entry_obj_by_object_info(&mat, { obj_id, obj_set_id });
+    rctx_ptr->disp_manager->set_obj_flags((mdl::ObjFlags)0);
+}
+
+void DataTestObjectManager::del_task() {
+    if (!app::TaskWork::check_task_ready(this))
+        return;
+
+    state = 0;
+    del();
+}
+
+int32_t DataTestObjectManager::get_obj_num() {
+    return obj_num;
+}
+
+const obj_bounding_sphere* DataTestObjectManager::get_object_bounding_sphere(int32_t obj_index) {
+    if (state != 3)
+        return 0;
+
+    data_struct* aft_data = &data_list[DATA_AFT];
+    object_database* aft_obj_db = &aft_data->data_ft.obj_db;
+
+    uint32_t obj_set_id = aft_obj_db->get_object_set_id(object_set_index);
+    const obj* obj = object_storage_get_obj_by_index(obj_set_id, obj_index);
+    if (obj)
+        return &obj->bounding_sphere;
+    return 0;
+}
+
+const char* DataTestObjectManager::get_object_name(int32_t obj_index) {
+    if (state != 3)
+        return "NULL";
+
+    data_struct* aft_data = &data_list[DATA_AFT];
+    object_database* aft_obj_db = &aft_data->data_ft.obj_db;
+
+    uint32_t obj_set_id = aft_obj_db->get_object_set_id(object_set_index);
+    const obj* obj = object_storage_get_obj_by_index(obj_set_id, obj_index);
+    if (obj)
+        return obj->name;
+    return"NULL";
+}
+
+void DataTestObjectManager::set_object_index(int32_t value) {
+    obj_index = value;
+}
+
+void DataTestObjectManager::set_object_set_index(int32_t object_set_index) {
+    if (app::TaskWork::check_task_ready(this))
+        return;
+
+    data_struct* aft_data = &data_list[DATA_AFT];
+    object_database* aft_obj_db = &aft_data->data_ft.obj_db;
+
+    this->object_set_index = object_set_index;
+    object_set_id = -1;
+
+    uint32_t obj_set_id = aft_obj_db->get_object_set_id(object_set_index);
+    std::string obj_set_name(aft_obj_db->get_object_set_name(obj_set_id));
+    if (!obj_set_name.find("STGPV"))
+        obj_set_name.assign(obj_set_name.substr(0, 8));
+    else if (!obj_set_name.find("STGD2PV"))
+        obj_set_name.assign(obj_set_name.substr(0, 10));
+
+    object_set_id = aft_obj_db->get_object_set_id(obj_set_name.c_str());
+    app::TaskWork::add_task(this, "DATA_TEST_OBJECT_MANAGER");;
+    return;
+}
+
+void DataTestObjectManager::set_rotation(const vec3& value) {
+    rotation = value;
+}
+
+void DataTestObjectManager::set_shadow(bool value) {
+    obj_flags = value ? (mdl::ObjFlags)(mdl::OBJ_4 | mdl::OBJ_SHADOW) : (mdl::ObjFlags)0;
+}
+
+DataTestObjDw::DataTestObjDw() {
+    data_struct* aft_data = &data_list[DATA_AFT];
+    object_database* aft_obj_db = &aft_data->data_ft.obj_db;
+    stage_database* aft_stage_data = &aft_data->data_ft.stage_data;
+
+    SetText("OBJECT TEST");
+
+    TaskDataTestObj::Data* obj_data = task_data_test_obj->get_data();
+
+    (new dw::Label(this))->SetText("OBJECT SET");
+
+    dw::ListBox* object_sets = new dw::ListBox(this);
+    object_sets->SetMaxItems(20);
+
+    uint32_t obj_set_count = aft_obj_db->get_object_set_count();
+    for (uint32_t i = obj_set_count, j = 0; i; i--, j++)
+        object_sets->AddItem(aft_obj_db->get_object_set_name(aft_obj_db->get_object_set_id(j)));
+    object_sets->SetItemIndex((uint32_t)obj_data->object_set_index);
+    object_sets->AddSelectionListener(new dw::SelectionListenerOnHook(DataTestObjDw::ObjectSetCallback));
+
+    (new dw::Label(this))->SetText("          OBJECT          ");
+
+    objects = new dw::ListBox(this);
+    objects->SetMaxItems(20);
+    objects->AddSelectionListener(new dw::SelectionListenerOnHook(DataTestObjDw::ObjectCallback));
+
+    (new dw::Label(this))->SetText("CAMERA");
+
+    dw::ListBox* camera = new dw::ListBox(this, dw::MULTISELECT);
+    camera->AddItem("NORMAL");
+    camera->AddItem("CULLING");
+    camera->SetItemIndex(obj_data->cull_camera ? 1 : 0);
+    camera->AddSelectionListener(new dw::SelectionListenerOnHook(DataTestObjDw::CameraCallback));
+
+    (new dw::Label(this))->SetText("SHADOW");
+
+    dw::ListBox* shadow = new dw::ListBox(this, dw::MULTISELECT);
+    shadow->AddItem("OFF");
+    shadow->AddItem("ON");
+    shadow->SetItemIndex(obj_data->shadow);
+    shadow->AddSelectionListener(new dw::SelectionListenerOnHook(DataTestObjDw::ShadowCallback));
+    
+    (new dw::Label(this))->SetText("STAGE HDRI");
+
+    dw::ListBox* stage_hdri = new dw::ListBox(this);
+
+    for (const stage_data& i : aft_stage_data->stage_data)
+        stage_hdri->AddItem(i.name);
+
+    stage_hdri->SetItemIndex(obj_data->stage_index);
+    stage_hdri->AddSelectionListener(new dw::SelectionListenerOnHook(DataTestObjDw::StageCallback));
+
+    (new dw::Label(this))->SetText("STAGE DISPLAY");
+
+    dw::ListBox* stage_display = new dw::ListBox(this, dw::MULTISELECT);
+    stage_display->AddItem("OFF");
+    stage_display->AddItem("ON");
+    stage_display->AddItem("GLID");
+    stage_display->SetItemIndex(obj_data->stage_display);
+    stage_display->AddSelectionListener(new dw::SelectionListenerOnHook(DataTestObjDw::StageDisplayCallback));
+
+    UpdateLayout();
+}
+
+DataTestObjDw::~DataTestObjDw() {
+
+}
+
+void DataTestObjDw::Hide() {
+    SetDisp();
+}
+
+void DataTestObjDw::ClearIDs() {
+    objects->ClearItems();
+}
+
+void DataTestObjDw::AddID(const char* value) {
+    objects->AddItem(value);
+}
+
+void DataTestObjDw::CameraCallback(dw::Widget* data) {
+    TaskDataTestObj::Data* obj_data = task_data_test_obj->get_data();
+    dw::ListBox* list_box = dynamic_cast<dw::ListBox*>(data);
+    if (list_box)
+        obj_data->cull_camera = !!list_box->list->selected_item;
+}
+
+void DataTestObjDw::ObjectCallback(dw::Widget* data) {
+    TaskDataTestObj::Data* obj_data = task_data_test_obj->get_data();
+    dw::ListBox* list_box = dynamic_cast<dw::ListBox*>(data);
+    if (list_box)
+        obj_data->object_index = (int32_t)list_box->list->selected_item;
+}
+
+void DataTestObjDw::ObjectSetCallback(dw::Widget* data) {
+    TaskDataTestObj::Data* obj_data = task_data_test_obj->get_data();
+    dw::ListBox* list_box = dynamic_cast<dw::ListBox*>(data);
+    if (list_box)
+        obj_data->object_set_index = (int32_t)list_box->list->selected_item;
+}
+
+void DataTestObjDw::ShadowCallback(dw::Widget* data) {
+    TaskDataTestObj::Data* obj_data = task_data_test_obj->get_data();
+    dw::ListBox* list_box = dynamic_cast<dw::ListBox*>(data);
+    if (list_box)
+        obj_data->shadow = (int32_t)list_box->list->selected_item;
+}
+
+void DataTestObjDw::StageCallback(dw::Widget* data) {
+    TaskDataTestObj::Data* obj_data = task_data_test_obj->get_data();
+    dw::ListBox* list_box = dynamic_cast<dw::ListBox*>(data);
+    if (list_box)
+        obj_data->stage_index = (int32_t)list_box->list->selected_item;
+}
+
+void DataTestObjDw::StageDisplayCallback(dw::Widget* data) {
+    TaskDataTestObj::Data* obj_data = task_data_test_obj->get_data();
+    dw::ListBox* list_box = dynamic_cast<dw::ListBox*>(data);
+    if (list_box)
+        obj_data->stage_display = (int32_t)list_box->list->selected_item;
+}
+
+static void data_test_obj_dw_init() {
+    if (!data_test_obj_dw) {
+        data_test_obj_dw = new DataTestObjDw;
+        data_test_obj_dw->sub_1402F38B0();
+    }
+    else
+        data_test_obj_dw->Disp();
+}
diff --git a/src/ReDIVA/data_test/object_test.hpp b/src/ReDIVA/data_test/object_test.hpp
new file mode 100644
index 00000000..6b7f3b8e
--- /dev/null
+++ b/src/ReDIVA/data_test/object_test.hpp
@@ -0,0 +1,48 @@
+/*
+    by korenkonder
+    GitHub/GitLab: korenkonder
+*/
+
+#pragma once
+
+#include "../../KKdLib/default.hpp"
+#include "../../KKdLib/vec.hpp"
+#include "../../CRE/task.hpp"
+
+class TaskDataTestObj : public app::Task {
+public:
+    struct Data {
+        int32_t object_set_index;
+        int32_t curr_object_set_index;
+        int32_t obj_num;
+        int32_t curr_obj_num;
+        int32_t object_index;
+        int32_t curr_object_index;
+        bool cull_camera;
+        bool curr_cull_camera;
+        int32_t stage_index;
+        int32_t curr_stage_index;
+        int32_t shadow;
+        int32_t stage_display;
+        vec3 rotation;
+
+        Data();
+    };
+
+    Data data;
+
+    TaskDataTestObj();
+    virtual ~TaskDataTestObj() override;
+
+    virtual bool init() override;
+    virtual bool ctrl() override;
+    virtual bool dest() override;
+    virtual void disp() override;
+
+    virtual Data* get_data();
+};
+
+extern TaskDataTestObj* task_data_test_obj;
+
+extern void object_test_init();
+extern void object_test_free();
diff --git a/src/ReDIVA/game_state.cpp b/src/ReDIVA/game_state.cpp
index de7b3a56..02e7bbda 100644
--- a/src/ReDIVA/game_state.cpp
+++ b/src/ReDIVA/game_state.cpp
@@ -15,6 +15,7 @@
 #include "data_test/auth_3d_test.hpp"
 #include "data_test/glitter_test.hpp"
 #include "data_test/motion_test.hpp"
+#include "data_test/object_test.hpp"
 #include "data_test/rob_osage_test.hpp"
 #include "data_test/selector.hpp"
 #include "data_test/stage_test.hpp"
@@ -1543,6 +1544,8 @@ bool SubGameState::DataTestMisc::Dest() {
 }
 
 bool SubGameState::DataTestObj::Init() {
+    app::TaskWork::add_task(task_data_test_obj, "DATA_TEST_OBJ");
+    task_stage_add_task("DATA_TEST_OBJ_STAGE");
     return true;
 }
 
@@ -1551,6 +1554,8 @@ bool SubGameState::DataTestObj::Ctrl() {
 }
 
 bool SubGameState::DataTestObj::Dest() {
+    task_data_test_obj->del();
+    task_stage_del_task();
     return true;
 }
 
diff --git a/src/ReDIVA/render.cpp b/src/ReDIVA/render.cpp
index 7155cf4d..08ed90d7 100644
--- a/src/ReDIVA/render.cpp
+++ b/src/ReDIVA/render.cpp
@@ -52,6 +52,7 @@
 #include "data_test/equip_test.hpp"
 #include "data_test/glitter_test.hpp"
 #include "data_test/motion_test.hpp"
+#include "data_test/object_test.hpp"
 #include "data_test/rob_osage_test.hpp"
 #include "data_test/selector.hpp"
 #include "data_test/stage_test.hpp"
@@ -634,6 +635,7 @@ static render_context* render_context_load() {
     dtm_aet_init();
     dtm_stg_init();
     motion_test_init();
+    object_test_init();
     equip_test_init();
     rob_osage_test_init();
     task_data_test_glitter_particle_init();
@@ -1294,6 +1296,7 @@ static void render_context_dispose(render_context* rctx) {
     task_data_test_glitter_particle_free();
     rob_osage_test_free();
     equip_test_free();
+    object_test_free();
     motion_test_free();
     dtm_stg_free();
     dtm_aet_free();