diff --git a/src/CRE/effect.cpp b/src/CRE/effect.cpp
index 0a62793e..7f3f00f8 100644
--- a/src/CRE/effect.cpp
+++ b/src/CRE/effect.cpp
@@ -436,7 +436,7 @@ struct ripple_emit_draw_data {
 };
 
 struct RippleRobColli {
-    ROB_COLLI_ID colli_id;
+    CB cb;
     vec3 old_pos;
 
     RippleRobColli();
@@ -606,7 +606,7 @@ public:
 class ParticleEmitterRob : public ParticleEmitter {
 private:
     ROB_ID m_rob_id;
-    ROB_COLLI_ID m_colli_id;
+    CB m_cb;
     vec3 m_old_pos;
     vec3 m_velocity;
     vec3 m_old_velocity;
@@ -628,7 +628,7 @@ public:
     void get_trans();
     void reset_data();
     void reset_data_base();
-    void set_chara(ROB_ID rob_id, ROB_COLLI_ID colli_id, bool in_water);
+    void set_chara(ROB_ID rob_id, CB cb, bool in_water);
     void set_emit_num(int32_t value);
     void set_emission_ratio_attn(float_t value);
     void set_emission_velocity_scale(float_t value);
@@ -3187,7 +3187,7 @@ ripple_emit_draw_data::ripple_emit_draw_data() : data() {
 }
 
 RippleRobColli::RippleRobColli() {
-    colli_id = ROB_COLLI_ID_DUMMY;
+    cb = CB_NONE;
 }
 
 EffectRipple::Params::Params() {
@@ -3383,12 +3383,12 @@ void EffectRipple::set_stage_index(int32_t stage_index) {
 }
 
 void EffectRipple::set_stage_indices(const std::vector<int32_t>& stage_indices) {
-    static const ROB_COLLI_ID ripple_colli_id[] = {
-       ROB_COLLI_ID_KOSHI, ROB_COLLI_ID_MUNE_L, ROB_COLLI_ID_MUNE_R, ROB_COLLI_ID_KAO,
-       ROB_COLLI_ID_KATA_L1, ROB_COLLI_ID_KATA_R1, ROB_COLLI_ID_UDE_L1, ROB_COLLI_ID_UDE_R1,
-       ROB_COLLI_ID_TE_L, ROB_COLLI_ID_TE_R,  ROB_COLLI_ID_MOMO_L1, ROB_COLLI_ID_MOMO_R1,
-       ROB_COLLI_ID_SUNE_L1, ROB_COLLI_ID_SUNE_R1,
-       ROB_COLLI_ID_ASI_L, ROB_COLLI_ID_ASI_R, ROB_COLLI_ID_TOE_L, ROB_COLLI_ID_TOE_R
+    static const CB ripple_cb[] = {
+       CB_KOSI, CB_MUNE1, CB_MUNE2, CB_KAO,
+       CB_KATA_L1, CB_KATA_R1, CB_UDE_L1, CB_UDE_R1,
+       CB_TE_L, CB_TE_R,  CB_MOMO_L1, CB_MOMO_R1,
+       CB_SUNE_L1, CB_SUNE_R1,
+       CB_ASI_L, CB_ASI_R, CB_TOE_L, CB_TOE_R
     };
 
     stage_set = false;
@@ -3426,7 +3426,7 @@ void EffectRipple::set_stage_indices(const std::vector<int32_t>& stage_indices)
     num_rob_colli = 18;
     for (auto& i : rob_colli)
         for (int32_t j = 0; j < num_rob_colli; j++) {
-            i[j].colli_id = ripple_colli_id[j];
+            i[j].cb = ripple_cb[j];
             i[j].old_pos = 0.0f;
         }
 
@@ -3617,7 +3617,7 @@ void EffectRipple::sub_14035AED0() {
         for (int32_t j = 0; j < num_rob_colli; j++) {
             RippleRobColli& rob_colli = i[j];
             vec3 pos = 0.0f;
-            float_t scale = rob_chr->get_pos_scale(rob_colli.colli_id, pos);
+            float_t scale = rob_chr->get_pos_scale(rob_colli.cb, pos);
             if (pos.y - ground_y < scale) {
                 if (use_float_ripplemap)
                     sub_1403587C0(pos, rob_colli.old_pos, scale, v2.data, v3.data);
@@ -3958,7 +3958,7 @@ void ParticleEmitter::reset_data() {
     m_initial_size = 1.0f;
 }
 
-ParticleEmitterRob::ParticleEmitterRob() : m_rob_id(), m_colli_id(),
+ParticleEmitterRob::ParticleEmitterRob() : m_rob_id(), m_cb(),
 m_emit_num(), m_emission_ratio(), m_emission_ratio_attn(),
 m_emission_velocity_scale(), m_flag_in_water(), m_set_old_pos() {
     reset_data();
@@ -4065,7 +4065,7 @@ void ParticleEmitterRob::restart() {
 
 void ParticleEmitterRob::get_trans() {
     vec3 pos;
-    get_rob_management()->get_rob(m_rob_id)->get_pos_scale(m_colli_id, pos);
+    get_rob_management()->get_rob(m_rob_id)->get_pos_scale(m_cb, pos);
 
     if (m_set_old_pos) {
         m_old_pos = pos;
@@ -4084,7 +4084,7 @@ void ParticleEmitterRob::get_velocity(float_t delta_time) {
 
 void ParticleEmitterRob::reset_data() {
     m_rob_id = (ROB_ID)0;
-    m_colli_id = ROB_COLLI_ID_DUMMY;
+    m_cb = CB_NONE;
     m_old_pos = 0.0f;
     m_velocity = 0.0f;
     m_old_velocity = 0.0f;
@@ -4100,12 +4100,12 @@ void ParticleEmitterRob::reset_data_base() {
     ParticleEmitter::reset_data();
 }
 
-void ParticleEmitterRob::set_chara(ROB_ID rob_id, ROB_COLLI_ID colli_id, bool in_water) {
+void ParticleEmitterRob::set_chara(ROB_ID rob_id, CB cb, bool in_water) {
     reset_data_base();
     reset_data();
 
     m_rob_id = rob_id;
-    m_colli_id = colli_id;
+    m_cb = cb;
     m_old_pos = 0.0f;
     m_velocity = 0.0f;
     m_old_velocity = 0.0f;
@@ -4440,12 +4440,12 @@ void EffectSplashParticle::disp() {
 }
 
 bool EffectSplashParticle::init(int32_t splash_tex_id, object_info splash_obj_id, bool in_water, bool blink) {
-    static const ROB_COLLI_ID  splash_colli_id[] = {
-        ROB_COLLI_ID_TOE_L, ROB_COLLI_ID_TOE_R,
-        ROB_COLLI_ID_TE_L, ROB_COLLI_ID_TE_R, ROB_COLLI_ID_KOSHI,
+    static const CB  splash_cb[] = {
+        CB_TOE_L, CB_TOE_R,
+        CB_TE_L, CB_TE_R, CB_KOSI,
     };
 
-    static const int32_t splash_colli_id_count = sizeof(splash_colli_id) / sizeof(BONE_ID);
+    static const int32_t splash_cb_count = sizeof(splash_cb) / sizeof(BONE_ID);
 
     splash_count = 1;
     splash = new splash_particle[splash_count];
@@ -4453,7 +4453,7 @@ bool EffectSplashParticle::init(int32_t splash_tex_id, object_info splash_obj_id
     if (!splash)
         return false;
 
-    emitter_rob_count = splash_colli_id_count * ROB_ID_MAX;
+    emitter_rob_count = splash_cb_count * ROB_ID_MAX;
     emitter_rob = new ParticleEmitterRob[emitter_rob_count];
 
     if (!emitter_rob)
@@ -4469,9 +4469,9 @@ bool EffectSplashParticle::init(int32_t splash_tex_id, object_info splash_obj_id
         splash[i].init(5000);
 
     for (int32_t rob_id = 0, j = 0; rob_id < ROB_ID_MAX; rob_id++)
-        for (const ROB_COLLI_ID colli_id : splash_colli_id) {
+        for (const CB cb : splash_cb) {
             ParticleEmitterRob& ptcl_emit_rob = emitter_rob[j++];
-            ptcl_emit_rob.set_chara((ROB_ID)rob_id, colli_id, in_water);
+            ptcl_emit_rob.set_chara((ROB_ID)rob_id, cb, in_water);
             ptcl_emit_rob.set_splash(splash);
         }
 
@@ -4483,16 +4483,16 @@ bool EffectSplashParticle::init(int32_t splash_tex_id, object_info splash_obj_id
     if (splash_obj_id.not_null()) {
         splash_object.init(100);
 
-        object_emitter_rob_count = splash_colli_id_count * ROB_ID_MAX;
+        object_emitter_rob_count = splash_cb_count * ROB_ID_MAX;
         object_emitter_rob = new ParticleEmitterRob[object_emitter_rob_count];
 
         if (!object_emitter_rob)
             return false;
 
         for (int32_t rob_id = 0, j = 0; rob_id < ROB_ID_MAX; rob_id++)
-            for (const ROB_COLLI_ID colli_id : splash_colli_id) {
+            for (const CB cb : splash_cb) {
                 ParticleEmitterRob& ptcl_emit_rob = object_emitter_rob[j++];
-                ptcl_emit_rob.set_chara((ROB_ID)rob_id, colli_id, in_water);
+                ptcl_emit_rob.set_chara((ROB_ID)rob_id, cb, in_water);
                 ptcl_emit_rob.set_splash(&splash_object);
                 ptcl_emit_rob.set_emit_num(10);
                 ptcl_emit_rob.set_initial_life(1.0f);
diff --git a/src/CRE/mdl/disp_manager.cpp b/src/CRE/mdl/disp_manager.cpp
index 7c7dc2c9..718b30b2 100644
--- a/src/CRE/mdl/disp_manager.cpp
+++ b/src/CRE/mdl/disp_manager.cpp
@@ -38,6 +38,8 @@ static const GLuint      BONE_INDEX_INDEX = 15;
 
 static void sub_140436760(const cam_data& cam);
 
+extern int32_t get_texcoord(TextureAttributeTextureType tex_type, int32_t index);
+
 RobSkinCol::RobSkinCol() : type() {
 
 }
@@ -1092,14 +1094,13 @@ namespace mdl {
             if (i.tex_index == -1)
                 continue;
 
-            int32_t texcoord_index = obj_material_texture_type_get_texcoord_index(
-                i.shader_info.m.tex_type, color_tex_index);
+            int32_t texcoord_index = get_texcoord(i.shader_info.m.tex_type, color_tex_index);
             if (texcoord_index < 0)
                 continue;
 
             texcoord_array[texcoord_index] = sub_mesh->uv_index[&i - material->material.texdata];
 
-            if (i.shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR)
+            if (i.shader_info.m.tex_type == TEX_SHDATTR_TEXTURE_COLOR)
                 color_tex_index++;
         }
 
@@ -3047,14 +3048,13 @@ namespace mdl {
             if (i.tex_index == -1)
                 continue;
 
-            int32_t texcoord_index = obj_material_texture_type_get_texcoord_index(
-                i.shader_info.m.tex_type, color_tex_index);
+            int32_t texcoord_index = get_texcoord(i.shader_info.m.tex_type, color_tex_index);
             if (texcoord_index < 0)
                 continue;
 
             texcoord_array[texcoord_index] = sub_mesh->uv_index[&i - material->material.texdata];
 
-            if (i.shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR)
+            if (i.shader_info.m.tex_type == TEX_SHDATTR_TEXTURE_COLOR)
                 color_tex_index++;
         }
 
@@ -3783,8 +3783,8 @@ static void sub_140436760(const cam_data& cam) {
             continue;
         }
 
-        if (i->args.sub_mesh.material->material.attrib.m.src_blend_factor == OBJ_MATERIAL_BLEND_ZERO
-            && i->args.sub_mesh.material->material.attrib.m.dst_blend_factor == OBJ_MATERIAL_BLEND_ONE
+        if (i->args.sub_mesh.material->material.attrib.m.src_blend_factor == MAT_ATTR_BLEND_ZERO
+            && i->args.sub_mesh.material->material.attrib.m.dst_blend_factor == MAT_ATTR_BLEND_ONE
             && aabb->size.y > 2.0f && aabb->size.y < 2.5f) {
             if (strcmp(mesh->name, "STGD2NS064_EFF_DISPLAY_MZ_000") && strcmp(mesh->name, "STGD2NS064_EFF_RAY_B_MZ_000"))
                 continue;
diff --git a/src/CRE/mdl/draw_object.cpp b/src/CRE/mdl/draw_object.cpp
index 5f5f4c6b..a3f9c90e 100644
--- a/src/CRE/mdl/draw_object.cpp
+++ b/src/CRE/mdl/draw_object.cpp
@@ -9,8 +9,16 @@
 #include "../static_var.hpp"
 #include "../texture.hpp"
 
+enum MaterialLightingType {
+    MAT_SHADER_LIGHTING_LAMBERT = 0,
+    MAT_SHADER_LIGHTING_CONSTANT,
+    MAT_SHADER_LIGHTING_PHONG,
+};
+
+static MaterialLightingType get_lighting_type(const obj_material_shader_attrib* attrib);
+
 static bool draw_object_blend_set(render_data_context& rend_data_ctx,
-    const mdl::ObjSubMeshArgs* args, obj_material_shader_lighting_type lighting_type);
+    const mdl::ObjSubMeshArgs* args, MaterialLightingType lighting_type);
 static bool draw_object_blend_set_check_use_default_blend(int32_t index);
 static void draw_object_chara_color_fog_set(render_data_context& rend_data_ctx,
     const mdl::ObjSubMeshArgs* args, bool disable_fog);
@@ -20,7 +28,7 @@ static void draw_object_material_reset_default(
 static void draw_object_material_set_cheap(
     render_data_context& rend_data_ctx, const mdl::ObjSubMeshArgs* args);
 static void draw_object_material_set_default(render_data_context& rend_data_ctx,
-    const mdl::ObjSubMeshArgs* args, bool use_shader);
+    const mdl::ObjSubMeshArgs* args, bool shader_sw);
 static void draw_object_material_set_parameter(
     render_data_context& rend_data_ctx, const obj_material_data* mat_data);
 static void draw_object_material_set_uniform(render_data_context& rend_data_ctx,
@@ -34,6 +42,10 @@ static void draw_object_vertex_attrib_set_default(
 static void draw_object_vertex_attrib_set_cheap(
     render_data_context& rend_data_ctx, const mdl::ObjSubMeshArgs* args);
 
+static int32_t get_tex_unit(TextureAttributeTextureType tex_type, int32_t tex_unit);
+int32_t get_texcoord(TextureAttributeTextureType tex_type, int32_t index);
+static int32_t get_uniform_blend(const obj_texture_attrib* attrib);
+
 extern render_context* rctx_ptr;
 
 namespace mdl {
@@ -166,8 +178,7 @@ namespace mdl {
         const ObjSubMeshArgs* args, const cam_data& cam, const mat4* mat) {
         const obj_material_data* material = args->material;
         draw_object_vertex_attrib_set_cheap(rend_data_ctx, args);
-        obj_material_shader_lighting_type lighting_type
-            = material->material.shader_info.get_lighting_type();
+        MaterialLightingType lighting_type = get_lighting_type(&material->material.shader_info);
         bool disable_fog = draw_object_blend_set(rend_data_ctx, args, lighting_type);
         draw_object_chara_color_fog_set(rend_data_ctx, args, disable_fog);
         draw_object_material_set_cheap(rend_data_ctx, args);
@@ -299,7 +310,7 @@ namespace mdl {
             uint32_t texture_id = -1;
             if (!material->material.shader_compo.m.transparency) {
                 for (int32_t i = 0; i < 8; i++, texdata++)
-                    if (texdata->shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR) {
+                    if (texdata->shader_info.m.tex_type == TEX_SHDATTR_TEXTURE_COLOR) {
                         texture_id = texdata->tex_index;
                         break;
                     }
@@ -307,7 +318,7 @@ namespace mdl {
             }
             else {
                 for (int32_t i = 0; i < 8; i++, texdata++)
-                    if (texdata->shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_TRANSPARENCY) {
+                    if (texdata->shader_info.m.tex_type == TEX_SHDATTR_TEXTURE_TRNSP_MAP) {
                         if (texdata->attrib.m.ignore) {
                             texture_id = texdata->tex_index;
                         }
@@ -408,7 +419,7 @@ namespace mdl {
         switch (material->material.shader.index) {
         case SHADER_FT_CLOTH:
             if (!rctx_ptr->render_manager->npr_param && material->material.color.ambient.w < 1.0f
-                && material->material.shader_info.m.aniso_direction == OBJ_MATERIAL_ANISO_DIRECTION_NORMAL)
+                && material->material.shader_info.m.aniso_direction == MAT_SHDATTR_ANISO_DIRECTION_NORMAL)
                 chara = true;
             break;
         case SHADER_FT_TIGHTS:
@@ -470,7 +481,7 @@ inline void model_mat_face_camera_view(const cam_data& cam, const mat4* src, mat
 }
 
 static bool draw_object_blend_set(render_data_context& rend_data_ctx,
-    const mdl::ObjSubMeshArgs* args, obj_material_shader_lighting_type lighting_type) {
+    const mdl::ObjSubMeshArgs* args, MaterialLightingType lighting_type) {
     static const GLenum blend_factor_table[] = {
         GL_ZERO,
         GL_ONE,
@@ -508,9 +519,9 @@ static bool draw_object_blend_set(render_data_context& rend_data_ctx,
             if (shader_index == -1) {
                 shader_index = material->material.shader.index;
                 if (shader_index == SHADER_FT_BLINN) {
-                    if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_CONSTANT)
+                    if (lighting_type == MAT_SHADER_LIGHTING_CONSTANT)
                         shader_index = SHADER_FT_CONSTANT;
-                    if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_LAMBERT)
+                    if (lighting_type == MAT_SHADER_LIGHTING_LAMBERT)
                         shader_index = SHADER_FT_LAMBERT;
                 }
             }
@@ -653,11 +664,10 @@ static void draw_object_material_set_cheap(
 }
 
 static void draw_object_material_set_default(render_data_context& rend_data_ctx,
-    const mdl::ObjSubMeshArgs* args, bool use_shader) {
+    const mdl::ObjSubMeshArgs* args, bool shader_sw) {
     const std::vector<GLuint>* textures = args->textures;
     const obj_material_data* material = args->material;
-    obj_material_shader_lighting_type lighting_type =
-        material->material.shader_info.get_lighting_type();
+    MaterialLightingType lighting_type = get_lighting_type(&material->material.shader_info);
     bool disable_fog = draw_object_blend_set(rend_data_ctx, args, lighting_type);
     draw_object_material_set_uniform(rend_data_ctx, material, false);
     if (!rctx_ptr->draw_state->rend_data[rend_data_ctx.index].shadow)
@@ -694,38 +704,38 @@ static void draw_object_material_set_default(render_data_context& rend_data_ctx,
         if (tex_id == -1)
             continue;
 
-        int32_t tex_index = obj_material_texture_type_get_texture_index(texdata->shader_info.m.tex_type, j);
-        if (tex_index < 0)
+        int32_t tex_unit = get_tex_unit(texdata->shader_info.m.tex_type, j);
+        if (tex_unit < 0)
             continue;
 
-        obj_material_texture_type tex_type = texdata->shader_info.m.tex_type;
-        if (tex_type == OBJ_MATERIAL_TEXTURE_COLOR)
+        TextureAttributeTextureType tex_type = texdata->shader_info.m.tex_type;
+        if (tex_type == TEX_SHDATTR_TEXTURE_COLOR)
             j++;
 
         if (texdata->attrib.m.ignore) {
             switch (tex_type) {
-            case OBJ_MATERIAL_TEXTURE_NORMAL:
+            case TEX_SHDATTR_TEXTURE_NORMAL_MAP:
                 rend_data_ctx.shader_flags.arr[U_NORMAL] = 0;
                 break;
-            case OBJ_MATERIAL_TEXTURE_SPECULAR:
+            case TEX_SHDATTR_TEXTURE_SPECULAR_MAP:
                 rend_data_ctx.shader_flags.arr[U_SPECULAR] = 0;
                 break;
-            case OBJ_MATERIAL_TEXTURE_TRANSLUCENCY:
+            case TEX_SHDATTR_TEXTURE_TRNSL_MAP:
                 rend_data_ctx.shader_flags.arr[U_TRANSLUCENCY] = 0;
                 break;
-            case OBJ_MATERIAL_TEXTURE_TRANSPARENCY:
+            case TEX_SHDATTR_TEXTURE_TRNSP_MAP:
                 rend_data_ctx.shader_flags.arr[U_TRANSPARENCY] = 0;
                 break;
             }
             continue;
         }
 
-        if (tex_type == OBJ_MATERIAL_TEXTURE_ENVIRONMENT_CUBE) {
-            rend_data_ctx.state.active_bind_texture_cube_map(tex_index, tex_id);
-            rend_data_ctx.state.bind_sampler(tex_index, 0);
+        if (tex_type == TEX_SHDATTR_TEXTURE_ENV_CUBE) {
+            rend_data_ctx.state.active_bind_texture_cube_map(tex_unit, tex_id);
+            rend_data_ctx.state.bind_sampler(tex_unit, 0);
         }
         else {
-            rend_data_ctx.state.active_bind_texture_2d(tex_index, tex_id);
+            rend_data_ctx.state.active_bind_texture_2d(tex_unit, tex_id);
 
             int32_t wrap_s;
             if (texdata->attrib.m.mirror_u)
@@ -744,13 +754,13 @@ static void draw_object_material_set_default(render_data_context& rend_data_ctx,
                 wrap_t = 0;
 
             texture* tex = texture_manager_get_texture(texture_id);
-            rend_data_ctx.state.bind_sampler(tex_index, rctx_ptr->samplers[(wrap_t * 3 + wrap_s) * 2
+            rend_data_ctx.state.bind_sampler(tex_unit, rctx_ptr->samplers[(wrap_t * 3 + wrap_s) * 2
                 + (!tex || tex->max_mipmap_level > 0 ? 1 : 0)]);
         }
 
         if (material->material.shader.index == SHADER_FT_SKY) {
             uniform_name uni_type = U_TEX_0_TYPE;
-            if (tex_index == 1)
+            if (tex_unit == 1)
                 uni_type = U_TEX_1_TYPE;
 
             texture* tex = texture_manager_get_texture(texdata->tex_index);
@@ -764,8 +774,8 @@ static void draw_object_material_set_default(render_data_context& rend_data_ctx,
                 rend_data_ctx.shader_flags.arr[uni_type] = 1;
         }
 
-        if (tex_index >= 0 && tex_index <= 1)
-            rend_data_ctx.shader_flags.arr[U_TEXTURE_BLEND] = texdata->attrib.get_blend();
+        if (tex_unit >= 0 && tex_unit < 2)
+            rend_data_ctx.shader_flags.arr[U_TEXTURE_BLEND] = get_uniform_blend(&texdata->attrib);
     }
 
     if (material->material.attrib.m.double_sided) {
@@ -786,7 +796,7 @@ static void draw_object_material_set_default(render_data_context& rend_data_ctx,
     vec4 specular = { 0.0f, 0.0f, 0.0f, 1.0f };
 
     float_t line_light;
-    if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_PHONG) {
+    if (lighting_type == MAT_SHADER_LIGHTING_PHONG) {
         specular = material->material.color.specular;
 
         float_t luma = vec3::dot(*(vec3*)&specular, { 0.30f, 0.59f, 0.11f });
@@ -810,7 +820,7 @@ static void draw_object_material_set_default(render_data_context& rend_data_ctx,
     vec4 texture_color_offset;
     vec4 texture_specular_coefficients;
     vec4 texture_specular_offset;
-    if (lighting_type != OBJ_MATERIAL_SHADER_LIGHTING_CONSTANT) {
+    if (lighting_type != MAT_SHADER_LIGHTING_CONSTANT) {
         if (material->material.shader.index == SHADER_FT_GLASEYE)
             material_shininess = 10.0f;
         else {
@@ -853,16 +863,16 @@ static void draw_object_material_set_default(render_data_context& rend_data_ctx,
         specular, fresnel_coefficients, texture_color_coefficients, texture_color_offset,
         texture_specular_coefficients, texture_specular_offset, shininess);
 
-    if (!use_shader)
+    if (!shader_sw)
         rend_data_ctx.set_shader(SHADER_FT_SIMPLE);
     else if (rctx_ptr->draw_state->rend_data[rend_data_ctx.index].shader_index != -1)
         rend_data_ctx.set_shader(rctx_ptr->draw_state->rend_data[rend_data_ctx.index].shader_index);
     else if (material->material.shader.index != -1) {
         if (material->material.shader.index != SHADER_FT_BLINN)
             rend_data_ctx.set_shader(material->material.shader.index);
-        else if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_LAMBERT)
+        else if (lighting_type == MAT_SHADER_LIGHTING_LAMBERT)
             rend_data_ctx.set_shader(SHADER_FT_LAMBERT);
-        else if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_PHONG)
+        else if (lighting_type == MAT_SHADER_LIGHTING_PHONG)
             rend_data_ctx.set_shader(SHADER_FT_BLINN);
         else
             rend_data_ctx.set_shader(SHADER_FT_CONSTANT);
@@ -953,7 +963,7 @@ static void draw_object_material_set_uniform(render_data_context& rend_data_ctx,
     if (shader_compo.env_cube)
         rend_data_ctx.shader_flags.arr[U_ENV_MAP] = 1;
 
-    if (shader_info.aniso_direction != OBJ_MATERIAL_ANISO_DIRECTION_NORMAL)
+    if (shader_info.aniso_direction != MAT_SHDATTR_ANISO_DIRECTION_NORMAL)
         rend_data_ctx.shader_flags.arr[U_ANISO] = shader_info.aniso_direction;
 
     if (v4 == 1)
@@ -1010,7 +1020,7 @@ static void draw_object_vertex_attrib_set_cheap(
         uint32_t tex_index = material->material.texdata[0].tex_index;
 
         mats[0] = material->material.texdata[0].tex_coord_mat;
-        if (material->material.texdata[0].shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR)
+        if (material->material.texdata[0].shader_info.m.tex_type == TEX_SHDATTR_TEXTURE_COLOR)
             for (int32_t j = 0; j < args->texture_transform_count; j++)
                 if (args->texture_transform_array[j].texid == tex_index) {
                     mats[0] = args->texture_transform_array[j].mat;
@@ -1056,12 +1066,11 @@ static void draw_object_vertex_attrib_set_default(
         if (texdata->tex_index == -1)
             continue;
 
-        int32_t texcoord_index = obj_material_texture_type_get_texcoord_index(
-            texdata->shader_info.m.tex_type, j);
+        int32_t texcoord_index = get_texcoord(texdata->shader_info.m.tex_type, j);
         if (texcoord_index < 0)
             continue;
 
-        if (texdata->shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR)
+        if (texdata->shader_info.m.tex_type == TEX_SHDATTR_TEXTURE_COLOR)
             j++;
 
         l++;
@@ -1072,7 +1081,7 @@ static void draw_object_vertex_attrib_set_default(
         uint32_t texture_id = texdata->tex_index;
 
         mats[texcoord_index] = texdata->tex_coord_mat;
-        if (texdata->shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR)
+        if (texdata->shader_info.m.tex_type == TEX_SHDATTR_TEXTURE_COLOR)
             for (int32_t k = 0; k < args->texture_transform_count; k++)
                 if (args->texture_transform_array[k].texid == texture_id) {
                     mats[texcoord_index] = args->texture_transform_array[k].mat;
@@ -1108,3 +1117,66 @@ static void draw_object_vertex_attrib_set_default(
     else
         rend_data_ctx.shader_flags.arr[U_INSTANCE] = 0;*/
 }
+
+// 0x140440E00
+static MaterialLightingType get_lighting_type(const obj_material_shader_attrib* attrib) {
+    if (!attrib->m.is_lgt_diffuse && !attrib->m.is_lgt_specular)
+        return MAT_SHADER_LIGHTING_CONSTANT;
+    else if (!attrib->m.is_lgt_specular)
+        return MAT_SHADER_LIGHTING_LAMBERT;
+    else
+        return MAT_SHADER_LIGHTING_PHONG;
+}
+
+// 0x140440E40
+static int32_t get_tex_unit(TextureAttributeTextureType tex_type, int32_t tex_unit) {
+    switch (tex_type) {
+    case TEX_SHDATTR_TEXTURE_COLOR:
+    case TEX_SHDATTR_TEXTURE_ENV_SPHERE: // XHD
+        if (tex_unit < 2)
+            return tex_unit;
+    case TEX_SHDATTR_TEXTURE_NORMAL_MAP:
+        return 2;
+    case TEX_SHDATTR_TEXTURE_SPECULAR_MAP:
+        return 3;
+    case TEX_SHDATTR_TEXTURE_TRNSL_MAP:
+        return 1;
+    case TEX_SHDATTR_TEXTURE_TRNSP_MAP:
+        return 4;
+    //case TEX_SHDATTR_TEXTURE_ENV_SPHERE: // AFT
+    case TEX_SHDATTR_TEXTURE_ENV_CUBE:
+        return 5;
+    }
+    return -1;
+}
+
+// 0x140440EB0
+int32_t get_texcoord(TextureAttributeTextureType tex_type, int32_t index) {
+    switch (tex_type) {
+    case TEX_SHDATTR_TEXTURE_COLOR:
+    case TEX_SHDATTR_TEXTURE_ENV_SPHERE: // XHD
+        if (index < 2)
+            return index;
+    case TEX_SHDATTR_TEXTURE_NORMAL_MAP:
+    case TEX_SHDATTR_TEXTURE_SPECULAR_MAP:
+        return 0;
+    case TEX_SHDATTR_TEXTURE_TRNSL_MAP:
+    case TEX_SHDATTR_TEXTURE_TRNSP_MAP:
+        return 1;
+    }
+    return -1;
+}
+
+// 0x140440EE0
+static int32_t get_uniform_blend(const obj_texture_attrib* attrib) {
+    switch (attrib->m.blend) {
+    case 4:
+        return 2;
+    case 6:
+        return 1;
+    case 16:
+        return 3;
+    default:
+        return 0;
+    }
+}
diff --git a/src/CRE/object.cpp b/src/CRE/object.cpp
index a02db355..5a2fe390 100644
--- a/src/CRE/object.cpp
+++ b/src/CRE/object.cpp
@@ -105,45 +105,6 @@ ObjsetInfo::~ObjsetInfo() {
         farc_file_handler.reset();
 }
 
-inline int32_t obj_material_texture_type_get_texcoord_index(
-    obj_material_texture_type type, int32_t index) {
-    switch (type) {
-    case OBJ_MATERIAL_TEXTURE_COLOR:
-    case OBJ_MATERIAL_TEXTURE_ENVIRONMENT_SPHERE: // XHD
-        if (index < 2)
-            return index;
-    case OBJ_MATERIAL_TEXTURE_NORMAL:
-    case OBJ_MATERIAL_TEXTURE_SPECULAR:
-        return 0;
-    case OBJ_MATERIAL_TEXTURE_TRANSLUCENCY:
-    case OBJ_MATERIAL_TEXTURE_TRANSPARENCY:
-        return 1;
-    }
-    return -1;
-}
-
-inline int32_t obj_material_texture_type_get_texture_index(
-    obj_material_texture_type type, int32_t base_index) {
-    switch (type) {
-    case OBJ_MATERIAL_TEXTURE_COLOR:
-    case OBJ_MATERIAL_TEXTURE_ENVIRONMENT_SPHERE: // XHD
-        if (base_index < 2)
-            return base_index;
-    case OBJ_MATERIAL_TEXTURE_NORMAL:
-        return 2;
-    case OBJ_MATERIAL_TEXTURE_SPECULAR:
-        return 3;
-    case OBJ_MATERIAL_TEXTURE_TRANSLUCENCY:
-        return 1;
-    case OBJ_MATERIAL_TEXTURE_TRANSPARENCY:
-        return 4;
-    //case OBJ_MATERIAL_TEXTURE_ENVIRONMENT_SPHERE: // AFT
-    case OBJ_MATERIAL_TEXTURE_ENVIRONMENT_CUBE:
-        return 5;
-    }
-    return -1;
-}
-
 // 0x1405E9250
 void obj_skin_set_matrix_buffer(const obj_skin* s, const mat4* matrices,
     const mat4* ex_data_matrices, mat4* matrix_buffer, const mat4* mat, const mat4& global_mat) {
@@ -341,13 +302,13 @@ void object_material_msgpack_read(const char* path, const char* set_name,
                         if (shader_info) {
                             msgpack* vtx_trans_type = shader_info->read("vtx_trans_type");
                             if (vtx_trans_type)
-                                mat.shader_info.m.vtx_trans_type = (obj_material_vertex_translation_type)
+                                mat.shader_info.m.vtx_trans_type = (MaterialAttributeVertexTransType)
                                 vtx_trans_type->read_uint32_t();
 
                             msgpack* col_src = shader_info->read("col_src");
                             if (col_src)
                                 mat.shader_info.m.col_src
-                                = (obj_material_color_source_type)col_src->read_uint32_t("col_src");
+                                = (MaterialAttributeColorSourceType)col_src->read_uint32_t("col_src");
 
                             msgpack* is_lgt_diffuse = shader_info->read("is_lgt_diffuse");
                             if (is_lgt_diffuse)
@@ -366,17 +327,22 @@ void object_material_msgpack_read(const char* path, const char* set_name,
                                 mat.shader_info.m.is_lgt_double = is_lgt_double->read_bool() ? 1 : 0;
 
                             msgpack* bump_map_type = shader_info->read("bump_map_type");
-                            if (bump_map_type)
-                                mat.shader_info.m.bump_map_type = (obj_material_bump_map_type)
-                                bump_map_type->read_uint32_t();
+                            if (bump_map_type) {
+                                mat.shader_info.m.bump_map_type
+                                    = (MaterialAttributeBumpMapType)bump_map_type->read_uint32_t();
+                            }
 
                             msgpack* fresnel_type = shader_info->read("fresnel_type");
-                            if (fresnel_type)
-                                mat.shader_info.m.fresnel_type = fresnel_type->read_uint32_t();
+                            if (fresnel_type) {
+                                mat.shader_info.m.fresnel_type
+                                    = (MaterialAttributeFresnelType)fresnel_type->read_uint32_t();
+                            }
 
                             msgpack* line_light = shader_info->read("line_light");
-                            if (line_light)
-                                mat.shader_info.m.line_light = line_light->read_uint32_t();
+                            if (line_light) {
+                                mat.shader_info.m.line_light
+                                    = (MaterialAttributeLineLightType)line_light->read_uint32_t();
+                            }
 
                             msgpack* receive_shadow = shader_info->read({ "receive_shadow", "recieve_shadow" });
                             if (receive_shadow)
@@ -387,14 +353,16 @@ void object_material_msgpack_read(const char* path, const char* set_name,
                                 mat.shader_info.m.cast_shadow = cast_shadow->read_bool() ? 1 : 0;
 
                             msgpack* specular_quality = shader_info->read("specular_quality");
-                            if (specular_quality)
-                                mat.shader_info.m.specular_quality = (obj_material_specular_quality)
-                                specular_quality->read_uint32_t();
+                            if (specular_quality) {
+                                mat.shader_info.m.specular_quality
+                                    = (MaterialAttributeSpecularQuality)specular_quality->read_uint32_t();
+                            }
 
                             msgpack* aniso_direction = shader_info->read("aniso_direction");
-                            if (aniso_direction)
-                                mat.shader_info.m.aniso_direction = (obj_material_aniso_direction)
-                                aniso_direction->read_uint32_t();
+                            if (aniso_direction) {
+                                mat.shader_info.m.aniso_direction
+                                    = (MaterialAttributeAnisoDirection)aniso_direction->read_uint32_t();
+                            }
 
                             msgpack* dummy = shader_info->read("dummy");
                             if (dummy)
@@ -479,10 +447,10 @@ void object_material_msgpack_read(const char* path, const char* set_name,
 
                                 msgpack* shader_info = tex->read("shader_info");
                                 if (shader_info) {
-                                    l.shader_info.m.tex_type = (obj_material_texture_type)
+                                    l.shader_info.m.tex_type = (TextureAttributeTextureType)
                                         shader_info->read_uint32_t("tex_type");
                                     l.shader_info.m.uv_idx = shader_info->read_uint32_t("uv_idx");
-                                    l.shader_info.m.texcoord_trans = (obj_material_texture_coordinate_translation_type)
+                                    l.shader_info.m.texcoord_trans = (TextureAttributeTextureCoordTransType)
                                         shader_info->read_uint32_t("texcoord_trans");
                                     l.shader_info.m.dummy = shader_info->read_uint32_t("dummy");
                                 }
@@ -577,12 +545,12 @@ void object_material_msgpack_read(const char* path, const char* set_name,
 
                             msgpack* src_blend_factor = attrib->read("src_blend_factor");
                             if (src_blend_factor)
-                                mat.attrib.m.src_blend_factor = (obj_material_blend_factor)
+                                mat.attrib.m.src_blend_factor = (MaterialAttributeBlendFactor)
                                 src_blend_factor->read_uint32_t();
 
                             msgpack* dst_blend_factor = attrib->read("dst_blend_factor");
                             if (dst_blend_factor)
-                                mat.attrib.m.dst_blend_factor = (obj_material_blend_factor)
+                                mat.attrib.m.dst_blend_factor = (MaterialAttributeBlendFactor)
                                 dst_blend_factor->read_uint32_t();
 
                             msgpack* blend_operation = attrib->read("blend_operation");
diff --git a/src/CRE/object.hpp b/src/CRE/object.hpp
index 8aff19fc..24cbecb7 100644
--- a/src/CRE/object.hpp
+++ b/src/CRE/object.hpp
@@ -69,11 +69,6 @@ struct ObjsetInfoObject {
     int32_t index;
 };
 
-extern int32_t obj_material_texture_type_get_texcoord_index(
-    obj_material_texture_type type, int32_t index);
-extern int32_t obj_material_texture_type_get_texture_index(
-    obj_material_texture_type type, int32_t base_index);
-
 extern void obj_skin_set_matrix_buffer(const obj_skin* s, const mat4* matrices,
     const mat4* ex_data_matrices, mat4* matrix_buffer, const mat4* mat, const mat4& global_mat);
 
diff --git a/src/CRE/rob/rob.cpp b/src/CRE/rob/rob.cpp
index 716cdb47..18f2bb1b 100644
--- a/src/CRE/rob/rob.cpp
+++ b/src/CRE/rob/rob.cpp
@@ -3086,12 +3086,12 @@ float_t rob_chara::get_face_depth() const {
     return item.get_face_depth();
 }
 
-float_t rob_chara::get_pos_scale(ROB_COLLI_ID colli_id, vec3& center) {
-    if (colli_id < 0 || colli_id >= ROB_COLLI_ID_MAX)
+float_t rob_chara::get_pos_scale(CB cb, vec3& center) {
+    if (cb < 0 || cb >= CB_NUM)
         return 0.0f;
 
-    center = rob_base.collision.cb_hit[colli_id].ball.c;
-    return rob_base.collision.cb_hit[colli_id].ball.r;
+    center = rob_base.collision.cb_hit[cb].ball.c;
+    return rob_base.collision.cb_hit[cb].ball.r;
 }
 
 // 0x140532090
@@ -3170,7 +3170,7 @@ void rob_chara::init_colli_every_frame() {
     prj::BallCollision* cb_rob = collision.cb_rob;
     prj::BallCollision* cb_stg = collision.cb_stg;
 
-    for (int32_t i = 0; i < ROB_COLLI_ID_MAX; i++, cb_hit++, cb_rob++, cb_stg++) {
+    for (int32_t i = 0; i < CB_NUM; i++, cb_hit++, cb_rob++, cb_stg++) {
         if (max_ypos < cb_hit->ball.c.y) {
             max_ypos = cb_hit->ball.c.y;
             max_idx = i;
@@ -3868,7 +3868,7 @@ void rob_chara::ctrl_rob_disp_main() {
     disp->set_opd_blend_data(&bone_data->motion_loaded);
 
     vec3 pos = 0.0f;
-    get_pos_scale(ROB_COLLI_ID_KOSHI, pos);
+    get_pos_scale(CB_KOSI, pos);
     disp->position = pos;
     RobDisp_ctrl(disp);
     if (check_for_ageageagain_module()) {
@@ -5624,7 +5624,7 @@ void rob_chara::calc_rob_colli_matrix() {
     const RobCollisionData* colli = rob_data->colli_data;
     const RobCollisionData* push_colli = rob_data->push_colli_data;
     mat4 m;
-    for (int32_t i = 0; i < ROB_COLLI_ID_MAX; i++) {
+    for (int32_t i = 0; i < CB_NUM; i++) {
         mat4_mul_translate(bone_data->get_mats_mat(colli->bone), &colli->trans, &m);
         *mat = m;
 
@@ -6843,17 +6843,17 @@ void RobMhPp::func_31(
 
 static int32_t sub_140533440(int32_t a1) {
     static const uint8_t byte_140A2D538[] = {
-       ROB_COLLI_ID_KOSHI, ROB_COLLI_ID_MUNE_L, ROB_COLLI_ID_MUNE_R, ROB_COLLI_ID_KUBI, ROB_COLLI_ID_KAO,
-       ROB_COLLI_ID_KATA_L1, ROB_COLLI_ID_KATA_L2, ROB_COLLI_ID_UDE_L1, ROB_COLLI_ID_UDE_L2, ROB_COLLI_ID_TE_L,
-       ROB_COLLI_ID_KATA_R1, ROB_COLLI_ID_KATA_R2, ROB_COLLI_ID_UDE_R1, ROB_COLLI_ID_UDE_R2, ROB_COLLI_ID_TE_R,
-       ROB_COLLI_ID_MOMO_L1, ROB_COLLI_ID_MOMO_L2, ROB_COLLI_ID_SUNE_L1,
-       ROB_COLLI_ID_SUNE_L2, ROB_COLLI_ID_ASI_L, ROB_COLLI_ID_TOE_L,
-       ROB_COLLI_ID_MOMO_R1, ROB_COLLI_ID_MOMO_R2, ROB_COLLI_ID_SUNE_R1,
-       ROB_COLLI_ID_SUNE_R2, ROB_COLLI_ID_ASI_R, ROB_COLLI_ID_TOE_R,
+       CB_KOSI, CB_MUNE1, CB_MUNE2, CB_KUBI, CB_KAO,
+       CB_KATA_L1, CB_KATA_L2, CB_UDE_L1, CB_UDE_L2, CB_TE_L,
+       CB_KATA_R1, CB_KATA_R2, CB_UDE_R1, CB_UDE_R2, CB_TE_R,
+       CB_MOMO_L1, CB_MOMO_L2, CB_SUNE_L1,
+       CB_SUNE_L2, CB_ASI_L, CB_TOE_L,
+       CB_MOMO_R1, CB_MOMO_R2, CB_SUNE_R1,
+       CB_SUNE_R2, CB_ASI_R, CB_TOE_R,
     };
 
     int32_t v3 = a1 & 0xF800001F;
-    for (int32_t i = 0; i < ROB_COLLI_ID_MAX; i++)
+    for (int32_t i = 0; i < CB_NUM; i++)
         if (a1 & (1 << i))
             v3 |= 1 << byte_140A2D538[i];
     return v3;
@@ -6887,7 +6887,7 @@ void RobMhPp::func_32(
         if (!(v10 & (1 << i)))
             continue;
 
-        for (int32_t j = 0; j < ROB_COLLI_ID_MAX; j++) {
+        for (int32_t j = 0; j < CB_NUM; j++) {
             if (!(v5 & (1 << j)))
                 continue;
 
diff --git a/src/CRE/rob/rob.hpp b/src/CRE/rob/rob.hpp
index ba269bf5..91e3155a 100644
--- a/src/CRE/rob/rob.hpp
+++ b/src/CRE/rob/rob.hpp
@@ -728,12 +728,52 @@ enum BONE_NODE {
     BONE_NODE_MAX                     = 0xC9,
 };
 
+enum CB {
+    CB_NONE = -1,
+
+    CB_KOSI = 0,
+    CB_MUNE1,
+    CB_MUNE2,
+    CB_KUBI,
+    CB_KAO,
+    CB_KATA_R1,
+    CB_KATA_R2,
+    CB_UDE_R1,
+    CB_UDE_R2,
+    CB_TE_R,
+    CB_KATA_L1,
+    CB_KATA_L2,
+    CB_UDE_L1,
+    CB_UDE_L2,
+    CB_TE_L,
+    CB_MOMO_R1,
+    CB_MOMO_R2,
+    CB_SUNE_R1,
+    CB_SUNE_R2,
+    CB_ASI_R,
+    CB_TOE_R,
+    CB_MOMO_L1,
+    CB_MOMO_L2,
+    CB_SUNE_L1,
+    CB_SUNE_L2,
+    CB_ASI_L,
+    CB_TOE_L,
+    CB_NUM,
+};
+
 enum CCmdYkType {
     CCMD_YK_TYPE_NON = 0,
     CCMD_YK_TYPE_R,
     CCMD_YK_TYPE_L,
 };
 
+enum ColliBallType {
+    CB_TYPE_HIT = 0,
+    CB_TYPE_ROB,
+    CB_TYPE_STG,
+    CB_TYPE_MAX,
+};
+
 enum Expr_type {
     Expr_constant = 0,
     Expr_variable,
@@ -1795,40 +1835,6 @@ enum ReviseType {
     REVISE_TYPE_MAX,
 };
 
-// Pure assumption
-enum ROB_COLLI_ID {
-    ROB_COLLI_ID_DUMMY = -1,
-
-    ROB_COLLI_ID_KOSHI = 0,
-    ROB_COLLI_ID_MUNE_L,
-    ROB_COLLI_ID_MUNE_R,
-    ROB_COLLI_ID_KUBI,
-    ROB_COLLI_ID_KAO,
-    ROB_COLLI_ID_KATA_R1,
-    ROB_COLLI_ID_KATA_R2,
-    ROB_COLLI_ID_UDE_R1,
-    ROB_COLLI_ID_UDE_R2,
-    ROB_COLLI_ID_TE_R,
-    ROB_COLLI_ID_KATA_L1,
-    ROB_COLLI_ID_KATA_L2,
-    ROB_COLLI_ID_UDE_L1,
-    ROB_COLLI_ID_UDE_L2,
-    ROB_COLLI_ID_TE_L,
-    ROB_COLLI_ID_MOMO_R1,
-    ROB_COLLI_ID_MOMO_R2,
-    ROB_COLLI_ID_SUNE_R1,
-    ROB_COLLI_ID_SUNE_R2,
-    ROB_COLLI_ID_ASI_R,
-    ROB_COLLI_ID_TOE_R,
-    ROB_COLLI_ID_MOMO_L1,
-    ROB_COLLI_ID_MOMO_L2,
-    ROB_COLLI_ID_SUNE_L1,
-    ROB_COLLI_ID_SUNE_L2,
-    ROB_COLLI_ID_ASI_L,
-    ROB_COLLI_ID_TOE_L,
-    ROB_COLLI_ID_MAX,
-};
-
 enum ROB_ID {
     ROB_ID_1P = 0,
     ROB_ID_2P,
@@ -4699,9 +4705,9 @@ struct RobMotData {
     prj::BitArray<17> revise_flag;
     uint32_t rob_cam_flag;
     RobTarget target;
-    bool colliball_flag[3][ROB_COLLI_ID_MAX];
-    float_t colliball_ratio[3][ROB_COLLI_ID_MAX];
-    float_t colliball_timer[3][ROB_COLLI_ID_MAX];
+    bool colliball_flag[3][CB_NUM];
+    float_t colliball_ratio[3][CB_NUM];
+    float_t colliball_timer[3][CB_NUM];
     prj::BitArray<41> touch_nage_mask;
     float_t arm_adjust_next_value;  // X
     float_t arm_adjust_prev_value;  // X
@@ -4845,21 +4851,21 @@ struct RobCollision {
     float_t sink_wall;
     int32_t wall_idx;
     vec3 wall_hit_pos;
-    mat4 mat[ROB_COLLI_ID_MAX];
-    mat4 push_mat[ROB_COLLI_ID_MAX];
-    prj::BallCollision cb_hit[ROB_COLLI_ID_MAX];
-    prj::BallCollision cb_rob[ROB_COLLI_ID_MAX];
-    prj::BallCollision cb_stg[ROB_COLLI_ID_MAX];
-    pos_scale field_1AA0[ROB_COLLI_ID_MAX];
-    float_t field_1BE4[ROB_COLLI_ID_MAX];
+    mat4 mat[CB_NUM];
+    mat4 push_mat[CB_NUM];
+    prj::BallCollision cb_hit[CB_NUM];
+    prj::BallCollision cb_rob[CB_NUM];
+    prj::BallCollision cb_stg[CB_NUM];
+    pos_scale field_1AA0[CB_NUM];
+    float_t field_1BE4[CB_NUM];
     prj::vector_pair<int64_t, float_t> field_1C50;
     int64_t field_1C68;
     int64_t field_1C70;
     int64_t field_1C78;
     int64_t field_1C80;
-    int32_t field_1C88[ROB_COLLI_ID_MAX];
-    int32_t field_1CF4[ROB_COLLI_ID_MAX];
-    int32_t field_1D60[ROB_COLLI_ID_MAX];
+    int32_t field_1C88[CB_NUM];
+    int32_t field_1CF4[CB_NUM];
+    int32_t field_1D60[CB_NUM];
     int32_t field_1DCC;
     int32_t field_1DD0;
     int32_t field_1DD4;
@@ -5040,7 +5046,7 @@ public:
     const vec3* get_gpos() const;
     object_info get_rob_data_face_object(int32_t index);
     float_t get_face_depth() const;
-    float_t get_pos_scale(ROB_COLLI_ID colli_id, vec3& center);
+    float_t get_pos_scale(CB cb, vec3& center);
     const RobData* get_rob_data() const;
     const RobInit* get_rob_init() const;
     void init_colli_every_frame();
diff --git a/src/KKdLib/obj.cpp b/src/KKdLib/obj.cpp
index db83b9a9..f9f1a789 100644
--- a/src/KKdLib/obj.cpp
+++ b/src/KKdLib/obj.cpp
@@ -329,28 +329,6 @@ obj_bounding_sphere::obj_bounding_sphere(vec3 center, float_t radius) {
     this->radius = radius;
 }
 
-obj_material_shader_lighting_type obj_material_shader_attrib::get_lighting_type() const {
-    if (!m.is_lgt_diffuse && !m.is_lgt_specular)
-        return OBJ_MATERIAL_SHADER_LIGHTING_CONSTANT;
-    else if (!m.is_lgt_specular)
-        return OBJ_MATERIAL_SHADER_LIGHTING_LAMBERT;
-    else
-        return OBJ_MATERIAL_SHADER_LIGHTING_PHONG;
-}
-
-int32_t obj_texture_attrib::get_blend() const {
-    switch (m.blend) {
-    case 4:
-        return 2;
-    case 6:
-        return 1;
-    case 16:
-        return 3;
-    default:
-        return 0;
-    }
-}
-
 obj_material_texture_data::obj_material_texture_data() : attrib(),
 tex_index(), shader_info(), ex_shader(), weight(), reserved() {
 
diff --git a/src/KKdLib/obj.hpp b/src/KKdLib/obj.hpp
index 58c2af06..0c570b3e 100644
--- a/src/KKdLib/obj.hpp
+++ b/src/KKdLib/obj.hpp
@@ -11,82 +11,136 @@
 #include "mat.hpp"
 #include "vec.hpp"
 
+enum MaterialAttributeAnisoDirection : uint32_t {
+    MAT_SHDATTR_ANISO_DIRECTION_DEFAULT = 0,
+
+    MAT_SHDATTR_ANISO_DIRECTION_NORMAL = 0,
+    MAT_SHDATTR_ANISO_DIRECTION_U,
+    MAT_SHDATTR_ANISO_DIRECTION_V,
+    MAT_SHDATTR_ANISO_DIRECTION_RADIAL,
+    MAT_SHDATTR_ANISO_DIRECTION_MAX,
+};
+
+enum MaterialAttributeBlendFactor : uint32_t {
+    MAT_ATTR_BLEND_DEFAULT = 0,
+
+    MAT_ATTR_BLEND_ZERO = 0,
+    MAT_ATTR_BLEND_ONE,
+    MAT_ATTR_BLEND_SRC_COLOR,
+    MAT_ATTR_BLEND_INVERSE_SRC_COLOR,
+    MAT_ATTR_BLEND_SRC_ALPHA,
+    MAT_ATTR_BLEND_INVERSE_SRC_ALPHA,
+    MAT_ATTR_BLEND_DST_ALPHA,
+    MAT_ATTR_BLEND_INVERSE_DST_ALPHA,
+    MAT_ATTR_BLEND_DST_COLOR,
+    MAT_ATTR_BLEND_INVERSE_DST_COLOR,
+    MAT_ATTR_BLEND_ALPHA_SATURATE,
+    MAT_ATTR_BLEND_MAX,
+};
+
+enum MaterialAttributeBumpMapType : uint32_t {
+    MAT_SHDATTR_BUMP_DEFAULT = 0,
+
+    MAT_SHDATTR_BUMP_NONE = 0,
+    MAT_SHDATTR_BUMP_DOT,
+    MAT_SHDATTR_BUMP_ENV,
+    MAT_SHDATTR_BUMP_MAX,
+};
+
+enum MaterialAttributeColorSourceType : uint32_t {
+    MAT_SHDATTR_COL_SRC_DEFAULT = 0,
+
+    MAT_SHDATTR_COL_SRC_MATCOL = 0,
+    MAT_SHDATTR_COL_SRC_VTXCOL,
+    MAT_SHDATTR_COL_SRC_VTXMORPH,
+    MAT_SHDATTR_COL_SRC_MAX,
+};
+
+enum MaterialAttributeFresnelType : uint32_t {
+    MAT_SHDATTR_FRESNEL_DEFAULT = 0,
+
+    MAT_SHDATTR_FRESNEL_NONE = 0,
+    MAT_SHDATTR_FRESNEL_TYPE1,
+    MAT_SHDATTR_FRESNEL_TYPE2,
+    MAT_SHDATTR_FRESNEL_TYPE3,
+    MAT_SHDATTR_FRESNEL_TYPE4,
+    MAT_SHDATTR_FRESNEL_TYPE5,
+    MAT_SHDATTR_FRESNEL_TYPE6,
+    MAT_SHDATTR_FRESNEL_TYPE7,
+    MAT_SHDATTR_FRESNEL_TYPE8,
+    MAT_SHDATTR_FRESNEL_TYPE9,
+    MAT_SHDATTR_FRESNEL_TYPE10,
+    MAT_SHDATTR_FRESNEL_TYPE11,
+    MAT_SHDATTR_FRESNEL_TYPE12,
+    MAT_SHDATTR_FRESNEL_TYPE13,
+    MAT_SHDATTR_FRESNEL_TYPE14,
+    MAT_SHDATTR_FRESNEL_TYPE15,
+    MAT_SHDATTR_FRESNEL_MAX,
+};
+
+enum MaterialAttributeLineLightType : uint32_t {
+    MAT_SHDATTR_LINELIGHT_DEFAULT = 0,
+
+    MAT_SHDATTR_LINELIGHT_NONE = 0,
+    MAT_SHDATTR_LINELIGHT_TYPE1,
+    MAT_SHDATTR_LINELIGHT_TYPE2,
+    MAT_SHDATTR_LINELIGHT_TYPE3,
+    MAT_SHDATTR_LINELIGHT_TYPE4,
+    MAT_SHDATTR_LINELIGHT_TYPE5,
+    MAT_SHDATTR_LINELIGHT_TYPE6,
+    MAT_SHDATTR_LINELIGHT_TYPE7,
+    MAT_SHDATTR_LINELIGHT_TYPE8,
+    MAT_SHDATTR_LINELIGHT_TYPE9,
+    MAT_SHDATTR_LINELIGHT_MAX,
+};
+
+enum MaterialAttributeSpecularQuality : uint32_t {
+    MAT_SHDATTR_SPECULAR_QUALITY_DEFAULT = 0,
+
+    MAT_SHDATTR_SPECULAR_QUALITY_LOW = 0,
+    MAT_SHDATTR_SPECULAR_QUALITY_HIGH,
+    MAT_SHDATTR_SPECULAR_QUALITY_MAX,
+};
+
+enum TextureAttributeTextureCoordTransType : uint32_t {
+    TEX_SHDATTR_TEXCOORD_TRANS_DEFAULT = 0,
+
+    TEX_SHDATTR_TEXCOORD_TRANS_NONE = 0,
+    TEX_SHDATTR_TEXCOORD_TRANS_UV,
+    TEX_SHDATTR_TEXCOORD_TRANS_ENV_SPHERE,
+    TEX_SHDATTR_TEXCOORD_TRANS_ENV_CUBE,
+    TEX_SHDATTR_TEXCOORD_TRANS_MAX,
+};
+
+enum TextureAttributeTextureType : uint32_t {
+    TEX_SHDATTR_TEXTURE_DEFAULT = 0,
+
+    TEX_SHDATTR_TEXTURE_NONE = 0,
+    TEX_SHDATTR_TEXTURE_COLOR,
+    TEX_SHDATTR_TEXTURE_NORMAL_MAP,
+    TEX_SHDATTR_TEXTURE_SPECULAR_MAP,
+    TEX_SHDATTR_TEXTURE_HEIGHT_MAP,
+    TEX_SHDATTR_TEXTURE_REFLECT_MAP,
+    TEX_SHDATTR_TEXTURE_TRNSL_MAP,
+    TEX_SHDATTR_TEXTURE_TRNSP_MAP,
+    TEX_SHDATTR_TEXTURE_ENV_SPHERE,
+    TEX_SHDATTR_TEXTURE_ENV_CUBE,
+    TEX_SHDATTR_TEXTURE_TRANS_MAX,
+};
+
+enum MaterialAttributeVertexTransType : uint32_t {
+    MAT_SHDATTR_VERTEX_TRANS_DEFAULT = 0,
+    MAT_SHDATTR_VERTEX_TRANS_ENVELOPE,
+    MAT_SHDATTR_VERTEX_TRANS_MORPHING,
+    MAT_SHDATTR_VERTEX_TRANS_MAX,
+};
+
 enum obj_index_format : uint32_t {
     OBJ_INDEX_U8  = 0x00,
     OBJ_INDEX_U16 = 0x01,
     OBJ_INDEX_U32 = 0x02,
 };
 
-enum obj_material_aniso_direction : uint32_t {
-    OBJ_MATERIAL_ANISO_DIRECTION_NORMAL = 0,
-    OBJ_MATERIAL_ANISO_DIRECTION_U      = 1,
-    OBJ_MATERIAL_ANISO_DIRECTION_V      = 2,
-    OBJ_MATERIAL_ANISO_DIRECTION_RADIAL = 3,
-};
-
-enum obj_material_blend_factor : uint32_t {
-    OBJ_MATERIAL_BLEND_ZERO              = 0,
-    OBJ_MATERIAL_BLEND_ONE               = 1,
-    OBJ_MATERIAL_BLEND_SRC_COLOR         = 2,
-    OBJ_MATERIAL_BLEND_INVERSE_SRC_COLOR = 3,
-    OBJ_MATERIAL_BLEND_SRC_ALPHA         = 4,
-    OBJ_MATERIAL_BLEND_INVERSE_SRC_ALPHA = 5,
-    OBJ_MATERIAL_BLEND_DST_ALPHA         = 6,
-    OBJ_MATERIAL_BLEND_INVERSE_DST_ALPHA = 7,
-    OBJ_MATERIAL_BLEND_DST_COLOR         = 8,
-    OBJ_MATERIAL_BLEND_INVERSE_DST_COLOR = 9,
-    OBJ_MATERIAL_BLEND_ALPHA_SATURATE = 10,
-};
-
-enum obj_material_bump_map_type : uint32_t {
-    OBJ_MATERIAL_BUMP_MAP_NONE = 0,
-    OBJ_MATERIAL_BUMP_MAP_DOT  = 1,
-    OBJ_MATERIAL_BUMP_MAP_ENV  = 2,
-};
-
-enum obj_material_color_source_type : uint32_t {
-    OBJ_MATERIAL_COLOR_SOURCE_MATERIAL_COLOR = 0,
-    OBJ_MATERIAL_COLOR_SOURCE_VERTEX_COLOR   = 1,
-    OBJ_MATERIAL_COLOR_SOURCE_VERTEX_MORPH   = 2,
-};
-
-enum obj_material_shader_lighting_type : uint32_t {
-    OBJ_MATERIAL_SHADER_LIGHTING_LAMBERT  = 0x00,
-    OBJ_MATERIAL_SHADER_LIGHTING_CONSTANT = 0x01,
-    OBJ_MATERIAL_SHADER_LIGHTING_PHONG    = 0x02,
-};
-
-enum obj_material_specular_quality : uint32_t {
-    OBJ_MATERIAL_SPECULAR_QUALITY_LOW  = 0,
-    OBJ_MATERIAL_SPECULAR_QUALITY_HIGH = 1,
-};
-
-enum obj_material_texture_type : uint32_t {
-    OBJ_MATERIAL_TEXTURE_NONE               = 0x00,
-    OBJ_MATERIAL_TEXTURE_COLOR              = 0x01,
-    OBJ_MATERIAL_TEXTURE_NORMAL             = 0x02,
-    OBJ_MATERIAL_TEXTURE_SPECULAR           = 0x03,
-    OBJ_MATERIAL_TEXTURE_HEIGHT             = 0x04,
-    OBJ_MATERIAL_TEXTURE_REFLECTION         = 0x05,
-    OBJ_MATERIAL_TEXTURE_TRANSLUCENCY       = 0x06,
-    OBJ_MATERIAL_TEXTURE_TRANSPARENCY       = 0x07,
-    OBJ_MATERIAL_TEXTURE_ENVIRONMENT_SPHERE = 0x08,
-    OBJ_MATERIAL_TEXTURE_ENVIRONMENT_CUBE   = 0x09,
-};
-
-enum obj_material_texture_coordinate_translation_type : uint32_t {
-    OBJ_MATERIAL_TEXTURE_COORDINATE_TRANSLATION_NONE   = 0x00,
-    OBJ_MATERIAL_TEXTURE_COORDINATE_TRANSLATION_UV     = 0x01,
-    OBJ_MATERIAL_TEXTURE_COORDINATE_TRANSLATION_SPHERE = 0x02,
-    OBJ_MATERIAL_TEXTURE_COORDINATE_TRANSLATION_CUBE   = 0x03,
-};
-
-enum obj_material_vertex_translation_type : uint32_t {
-    OBJ_MATERIAL_VERTEX_TRANSLATION_DEFAULT  = 0,
-    OBJ_MATERIAL_VERTEX_TRANSLATION_ENVELOPE = 1,
-    OBJ_MATERIAL_VERTEX_TRANSLATION_MORPHING = 2,
-};
-
 enum obj_primitive_type : uint32_t {
     OBJ_PRIMITIVE_POINTS         = 0x00,
     OBJ_PRIMITIVE_LINES          = 0x01,
@@ -194,27 +248,25 @@ union obj_shader_compo {
 };
 
 struct obj_material_shader_attrib_member {
-    obj_material_vertex_translation_type vtx_trans_type : 2;
-    obj_material_color_source_type col_src : 2;
+    MaterialAttributeVertexTransType vtx_trans_type : 2;
+    MaterialAttributeColorSourceType col_src : 2;
     uint32_t is_lgt_diffuse : 1;
     uint32_t is_lgt_specular : 1;
     uint32_t is_lgt_per_pixel : 1;
     uint32_t is_lgt_double : 1;
-    obj_material_bump_map_type bump_map_type : 2;
-    uint32_t fresnel_type : 4;
-    uint32_t line_light : 4;
+    MaterialAttributeBumpMapType bump_map_type : 2;
+    MaterialAttributeFresnelType fresnel_type : 4;
+    MaterialAttributeLineLightType line_light : 4;
     uint32_t receive_shadow : 1;
     uint32_t cast_shadow : 1;
-    obj_material_specular_quality specular_quality : 1;
-    obj_material_aniso_direction aniso_direction : 2;
+    MaterialAttributeSpecularQuality specular_quality : 1;
+    MaterialAttributeAnisoDirection aniso_direction : 2;
     uint32_t dummy : 9;
 };
 
 union obj_material_shader_attrib {
     obj_material_shader_attrib_member m;
     uint32_t w;
-
-    obj_material_shader_lighting_type get_lighting_type() const;
 };
 
 struct obj_texture_attrib_member {
@@ -237,14 +289,12 @@ struct obj_texture_attrib_member {
 union obj_texture_attrib {
     obj_texture_attrib_member m;
     uint32_t w;
-
-    int32_t get_blend() const;
 };
 
 struct obj_texture_shader_attrib_member {
-    obj_material_texture_type tex_type : 4;
+    TextureAttributeTextureType tex_type : 4;
     int32_t uv_idx : 4;
-    obj_material_texture_coordinate_translation_type texcoord_trans : 3;
+    TextureAttributeTextureCoordTransType texcoord_trans : 3;
     uint32_t dummy : 21;
 };
 
@@ -274,8 +324,8 @@ struct obj_material_attrib_member {
     uint32_t punch_through : 1;
     uint32_t double_sided : 1;
     uint32_t normal_dir_light : 1;
-    obj_material_blend_factor src_blend_factor : 4;
-    obj_material_blend_factor dst_blend_factor : 4;
+    MaterialAttributeBlendFactor src_blend_factor : 4;
+    MaterialAttributeBlendFactor dst_blend_factor : 4;
     uint32_t blend_operation : 3;
     uint32_t zbias : 4;
     uint32_t no_z_fog : 1;
diff --git a/src/ReDIVA/graphics/material.cpp b/src/ReDIVA/graphics/material.cpp
index a952ebae..c9a01871 100644
--- a/src/ReDIVA/graphics/material.cpp
+++ b/src/ReDIVA/graphics/material.cpp
@@ -639,7 +639,7 @@ void MaterialDw::AnisoDirectionCallback(dw::ListBox* data) {
     obj_material_data* material_data = material_dw->GetMaterial();
     if (material_data)
         material_data->material.shader_info.m.aniso_direction
-        = (obj_material_aniso_direction)data->list->selected_item;
+        = (MaterialAttributeAnisoDirection)data->list->selected_item;
 }
 
 void MaterialDw::AnisoFilterCallback(dw::Slider* data) {
@@ -710,7 +710,7 @@ void MaterialDw::DstBlendFactorCallback(dw::ListBox* data) {
     obj_material_data* material_data = material_dw->GetMaterial();
     if (material_data)
         material_data->material.attrib.m.dst_blend_factor
-            = (obj_material_blend_factor)data->list->selected_item;
+            = (MaterialAttributeBlendFactor)data->list->selected_item;
 }
 
 void MaterialDw::EmissionACallback(dw::Slider* data) {
@@ -745,7 +745,7 @@ void MaterialDw::FresnelCallback(dw::Slider* data) {
     MaterialDw* material_dw = (MaterialDw*)data->callback_data.v64;
     obj_material_data* material_data = material_dw->GetMaterial();
     if (material_data)
-        material_data->material.shader_info.m.fresnel_type = (int32_t)data->GetValue();
+        material_data->material.shader_info.m.fresnel_type = (MaterialAttributeFresnelType)data->GetValue();
 }
 
 void MaterialDw::IntensityCallback(dw::Slider* data) {
@@ -759,7 +759,7 @@ void MaterialDw::LineLightCallback(dw::Slider* data) {
     MaterialDw* material_dw = (MaterialDw*)data->callback_data.v64;
     obj_material_data* material_data = material_dw->GetMaterial();
     if (material_data)
-        material_data->material.shader_info.m.line_light = (int32_t)data->GetValue();
+        material_data->material.shader_info.m.line_light = (MaterialAttributeLineLightType)data->GetValue();
 }
 
 void MaterialDw::MipmapBiasCallback(dw::Slider* data) {
@@ -853,12 +853,14 @@ void MaterialDw::ResetCallback(dw::Widget* data) {
     material.color.shininess = material_dw->shininess->GetValue();
     material.color.intensity = material_dw->intensity->GetValue();
     material.bump_depth = material_dw->bump_depth->GetValue();
-    material.shader_info.m.fresnel_type = (int32_t)material_dw->fresnel->GetValue();
-    material.shader_info.m.line_light = (int32_t)material_dw->line_light->GetValue();
+    material.shader_info.m.fresnel_type
+        = (MaterialAttributeFresnelType)material_dw->fresnel->GetValue();
+    material.shader_info.m.line_light
+        = (MaterialAttributeLineLightType)material_dw->line_light->GetValue();
     material.shader_info.m.specular_quality
-        = (obj_material_specular_quality)material_dw->specular_quality->list->selected_item;
+        = (MaterialAttributeSpecularQuality)material_dw->specular_quality->list->selected_item;
     material.shader_info.m.aniso_direction
-        = (obj_material_aniso_direction)material_dw->aniso_direction->list->selected_item;
+        = (MaterialAttributeAnisoDirection)material_dw->aniso_direction->list->selected_item;
     switch (material_dw->double_sided->list->selected_item) {
     case 0:
         material.attrib.m.double_sided = 0;
@@ -868,9 +870,9 @@ void MaterialDw::ResetCallback(dw::Widget* data) {
         break;
     }
     material.attrib.m.src_blend_factor
-        = (obj_material_blend_factor)material_dw->src_blend_factor->list->selected_item;
+        = (MaterialAttributeBlendFactor)material_dw->src_blend_factor->list->selected_item;
     material.attrib.m.dst_blend_factor
-        = (obj_material_blend_factor)material_dw->dst_blend_factor->list->selected_item;
+        = (MaterialAttributeBlendFactor)material_dw->dst_blend_factor->list->selected_item;
     material.attrib.m.zbias = (int32_t)material_dw->zbias->GetValue();
     material.texdata[0].attrib.m.mipmap_bias = (int32_t)material_dw->mipmap_bias->GetValue();
     material.texdata[0].attrib.m.aniso = (int32_t)material_dw->aniso_filter->GetValue();
@@ -902,7 +904,7 @@ void MaterialDw::SpecularQualityCallback(dw::ListBox* data) {
     obj_material_data* material_data = material_dw->GetMaterial();
     if (material_data)
         material_data->material.shader_info.m.specular_quality
-            = (obj_material_specular_quality)data->list->selected_item;
+            = (MaterialAttributeSpecularQuality)data->list->selected_item;
 }
 
 void MaterialDw::SpecularRCallback(dw::Slider* data) {
@@ -917,7 +919,7 @@ void MaterialDw::SrcBlendFactorCallback(dw::ListBox* data) {
     obj_material_data* material_data = material_dw->GetMaterial();
     if (material_data)
         material_data->material.attrib.m.src_blend_factor
-            = (obj_material_blend_factor)data->list->selected_item;
+            = (MaterialAttributeBlendFactor)data->list->selected_item;
 }
 
 void MaterialDw::TransparencyCallback(dw::Slider* data) {
diff --git a/src/ReDIVA/x_pv_game.cpp b/src/ReDIVA/x_pv_game.cpp
index 3014983c..34ff60b7 100644
--- a/src/ReDIVA/x_pv_game.cpp
+++ b/src/ReDIVA/x_pv_game.cpp
@@ -10635,13 +10635,13 @@ static void x_pv_game_read_object_reflect(const char* path, const char* set_name
                         if (shader_info) {
                             msgpack* vtx_trans_type = shader_info->read("vtx_trans_type");
                             if (vtx_trans_type)
-                                mat->shader_info.m.vtx_trans_type = (obj_material_vertex_translation_type)
+                                mat->shader_info.m.vtx_trans_type = (MaterialAttributeVertexTransType)
                                 vtx_trans_type->read_uint32_t();
 
                             msgpack* col_src = shader_info->read("col_src");
                             if (col_src)
                                 mat->shader_info.m.col_src
-                                    = (obj_material_color_source_type)col_src->read_uint32_t("col_src");
+                                    = (MaterialAttributeColorSourceType)col_src->read_uint32_t("col_src");
 
                             msgpack* is_lgt_diffuse = shader_info->read("is_lgt_diffuse");
                             if (is_lgt_diffuse)
@@ -10660,17 +10660,22 @@ static void x_pv_game_read_object_reflect(const char* path, const char* set_name
                                 mat->shader_info.m.is_lgt_double = is_lgt_double->read_bool() ? 1 : 0;
 
                             msgpack* bump_map_type = shader_info->read("bump_map_type");
-                            if (bump_map_type)
-                                mat->shader_info.m.bump_map_type = (obj_material_bump_map_type)
-                                bump_map_type->read_uint32_t();
+                            if (bump_map_type) {
+                                mat->shader_info.m.bump_map_type
+                                    = (MaterialAttributeBumpMapType)bump_map_type->read_uint32_t();
+                            }
 
                             msgpack* fresnel_type = shader_info->read("fresnel_type");
-                            if (fresnel_type)
-                                mat->shader_info.m.fresnel_type = fresnel_type->read_uint32_t();
+                            if (fresnel_type) {
+                                mat->shader_info.m.fresnel_type
+                                    = (MaterialAttributeFresnelType)fresnel_type->read_uint32_t();
+                            }
 
                             msgpack* line_light = shader_info->read("line_light");
-                            if (line_light)
-                                mat->shader_info.m.line_light = line_light->read_uint32_t();
+                            if (line_light) {
+                                mat->shader_info.m.line_light
+                                    = (MaterialAttributeLineLightType)line_light->read_uint32_t();
+                            }
 
                             msgpack* receive_shadow = shader_info->read({ "receive_shadow", "recieve_shadow" });
                             if (receive_shadow)
@@ -10681,14 +10686,16 @@ static void x_pv_game_read_object_reflect(const char* path, const char* set_name
                                 mat->shader_info.m.cast_shadow = cast_shadow->read_bool() ? 1 : 0;
 
                             msgpack* specular_quality = shader_info->read("specular_quality");
-                            if (specular_quality)
-                                mat->shader_info.m.specular_quality = (obj_material_specular_quality)
-                                specular_quality->read_uint32_t();
+                            if (specular_quality) {
+                                mat->shader_info.m.specular_quality
+                                    = (MaterialAttributeSpecularQuality)specular_quality->read_uint32_t();
+                            }
 
                             msgpack* aniso_direction = shader_info->read("aniso_direction");
-                            if (aniso_direction)
-                                mat->shader_info.m.aniso_direction = (obj_material_aniso_direction)
-                                aniso_direction->read_uint32_t();
+                            if (aniso_direction) {
+                                mat->shader_info.m.aniso_direction
+                                    = (MaterialAttributeAnisoDirection)aniso_direction->read_uint32_t();
+                            }
 
                             msgpack* dummy = shader_info->read("dummy");
                             if (dummy)
@@ -10774,7 +10781,7 @@ static void x_pv_game_read_object_reflect(const char* path, const char* set_name
                                 if (shader_info) {
                                     msgpack* tex_type = shader_info->read("tex_type");
                                     if (tex_type)
-                                        l.shader_info.m.tex_type = (obj_material_texture_type)
+                                        l.shader_info.m.tex_type = (TextureAttributeTextureType)
                                         tex_type->read_uint32_t();
 
                                     msgpack* uv_idx = shader_info->read("uv_idx");
@@ -10783,7 +10790,7 @@ static void x_pv_game_read_object_reflect(const char* path, const char* set_name
 
                                     msgpack* texcoord_trans = shader_info->read("texcoord_trans");
                                     if (texcoord_trans)
-                                        l.shader_info.m.texcoord_trans = (obj_material_texture_coordinate_translation_type)
+                                        l.shader_info.m.texcoord_trans = (TextureAttributeTextureCoordTransType)
                                         texcoord_trans->read_uint32_t();
 
                                     msgpack* dummy = shader_info->read("dummy");
@@ -10880,12 +10887,12 @@ static void x_pv_game_read_object_reflect(const char* path, const char* set_name
 
                             msgpack* src_blend_factor = attrib->read("src_blend_factor");
                             if (src_blend_factor)
-                                mat->attrib.m.src_blend_factor = (obj_material_blend_factor)
+                                mat->attrib.m.src_blend_factor = (MaterialAttributeBlendFactor)
                                 src_blend_factor->read_uint32_t();
 
                             msgpack* dst_blend_factor = attrib->read("dst_blend_factor");
                             if (dst_blend_factor)
-                                mat->attrib.m.dst_blend_factor = (obj_material_blend_factor)
+                                mat->attrib.m.dst_blend_factor = (MaterialAttributeBlendFactor)
                                 dst_blend_factor->read_uint32_t();
 
                             msgpack* blend_operation = attrib->read("blend_operation");