diff --git a/src/CRE/auth_3d.cpp b/src/CRE/auth_3d.cpp
index d2dead68..47e0c17b 100644
--- a/src/CRE/auth_3d.cpp
+++ b/src/CRE/auth_3d.cpp
@@ -1075,16 +1075,16 @@ namespace auth_3d_detail {
             return;
 
         auth_3d_point& point = auth->point[index];
-        vec3 trans = point.model_transform.translation_value;
+        vec3 pos = point.model_transform.translation_value;
         if (auth->left_right_reverse)
-            trans.x = -trans.x;
+            pos.x = -pos.x;
 
-        mat4_transform_point(&auth->mat, &trans, &trans);
+        mat4_transform_point(&auth->mat, &pos, &pos);
         particle_event_data event;
         event.type = 1.0f;
         event.count = point.model_transform.scale_value.x * 100.0f;
         event.size = point.model_transform.scale_value.z;
-        event.trans = trans;
+        event.pos = pos;
         event.force = point.model_transform.scale_value.y;
         effect_manager_event(EFFECT_PARTICLE, 1, &event);
     }
diff --git a/src/CRE/effect.cpp b/src/CRE/effect.cpp
index d2fb129e..8785c915 100644
--- a/src/CRE/effect.cpp
+++ b/src/CRE/effect.cpp
@@ -29,7 +29,7 @@ struct particle_init_data {
     float_t field_0;
     float_t field_4;
     float_t field_8;
-    vec3 trans;
+    vec3 pos;
     float_t scale_y;
 };
 
@@ -356,7 +356,7 @@ struct ripple_emit_draw_data {
 
 struct struc_192 {
     int32_t index;
-    vec3 trans;
+    vec3 pos;
 
     struc_192();
 };
@@ -511,7 +511,7 @@ struct splash_particle {
 
 struct ParticleEmitter {
     splash_particle* splash;
-    vec3 trans;
+    vec3 pos;
     int32_t field_1C;
     float_t field_20;
     int field_24;
@@ -530,7 +530,7 @@ struct ParticleEmitter {
 struct ParticleEmitterRob : ParticleEmitter {
     int32_t chara_id;
     int32_t bone_index;
-    vec3 prev_trans;
+    vec3 prev_pos;
     vec3 velocity;
     vec3 prev_velocity;
     int32_t emit_num;
@@ -2456,14 +2456,14 @@ void EffectFogRing::sub_140347B40(float_t delta_time) {
             if (!mat)
                 continue;
 
-            vec3 trans;
-            mat4_get_translation(mat, &trans);
-            v8->position = trans;
+            vec3 pos;
+            mat4_get_translation(mat, &pos);
+            v8->position = pos;
 
             if (field_124 >= 10 || field_8)
                 continue;
 
-            vec3 v23 = (trans - v8->position) * (1.0f / delta_time);
+            vec3 v23 = (pos - v8->position) * (1.0f / delta_time);
             float_t v15 = vec3::length(v23);
 
             float_t v18;
@@ -2479,7 +2479,7 @@ void EffectFogRing::sub_140347B40(float_t delta_time) {
                 v19 = 0.5f;
             }
             else {
-                if (trans.y >= 0.2f || v8->position.y < 0.2f)
+                if (pos.y >= 0.2f || v8->position.y < 0.2f)
                     continue;
 
                 v18 = 2.2f;
@@ -2489,7 +2489,7 @@ void EffectFogRing::sub_140347B40(float_t delta_time) {
 
             struc_371& v20 = field_128[field_124++];
             v20.field_0 = 1;
-            v20.position = trans;
+            v20.position = pos;
             v20.field_10 = v19;
             v20.field_14 = v19 * v19;
             v20.direction = v23;
@@ -3189,7 +3189,7 @@ void EffectRipple::reset() {
     field_4F0 = 18;
     for (struc_207& i : field_4F4)
         for (int32_t j = 0; j < field_4F0; j++)
-            i.field_0[j].trans = 0.0f;
+            i.field_0[j].pos = 0.0f;
 
     field_30 = 60;
 
@@ -3257,7 +3257,7 @@ void EffectRipple::set_stage_indices(const std::vector<int32_t>& stage_indices)
     for (struc_207& i : field_4F4)
         for (int32_t j = 0; j < field_4F0; j++) {
             i.field_0[j].index = dword_1409E5330[j];
-            i.field_0[j].trans = 0.0f;
+            i.field_0[j].pos = 0.0f;
         }
 
     update = false;
@@ -3461,22 +3461,22 @@ void EffectRipple::sub_14035AED0() {
 
         for (int32_t j = 0; j < field_4F0; j++) {
             struc_192& v4 = i.field_0[j];
-            vec3 trans = 0.0f;
-            float_t scale = rob_chr->get_trans_scale(v4.index, trans);
-            if (trans.y - ground_y < scale) {
+            vec3 pos = 0.0f;
+            float_t scale = rob_chr->get_pos_scale(v4.index, pos);
+            if (pos.y - ground_y < scale) {
                 if (use_float_ripplemap)
-                    sub_1403587C0(trans, v4.trans, scale, v2.data, v3.data);
+                    sub_1403587C0(pos, v4.pos, scale, v2.data, v3.data);
                 else if (v2.data.count < 16) {
                     v2.data.position[v2.data.count].x = ((rand_state_array_get_float(4) - 0.5f)
-                        * 0.02f + trans.x) * emit_pos_scale + emit_pos_ofs_x;
-                    v2.data.position[v2.data.count].y = trans.y;
+                        * 0.02f + pos.x) * emit_pos_scale + emit_pos_ofs_x;
+                    v2.data.position[v2.data.count].y = pos.y;
                     v2.data.position[v2.data.count].z = ((rand_state_array_get_float(4) - 0.5f)
-                        * 0.02f + trans.z) * emit_pos_scale + emit_pos_ofs_z;
+                        * 0.02f + pos.z) * emit_pos_scale + emit_pos_ofs_z;
                     v2.data.color[v2.data.count] = { 0x00, 0x00, 0x00, 0x00 };
                     v2.data.count++;
                 }
             }
-            v4.trans = trans;
+            v4.pos = pos;
         }
 
         chara_id++;
@@ -3798,7 +3798,7 @@ void ParticleEmitter::restart() {
 
 void ParticleEmitter::reset_data() {
     splash = 0;
-    trans = 0.0f;
+    pos = 0.0f;
     field_1C = 0;
     field_20 = 1.0f;
     field_24 = 0;
@@ -3851,7 +3851,7 @@ void ParticleEmitterRob::ctrl(float_t delta_time) {
     if (v8 > 100.0f)
         return;
 
-    if (trans.y >= 0.3f)
+    if (pos.y >= 0.3f)
         field_60 = max_def(field_60 - delta_time * emission_ratio_attn, 0.0f);
     else
         field_60 = 1.0f;
@@ -3866,7 +3866,7 @@ void ParticleEmitterRob::ctrl(float_t delta_time) {
 
     vec3 prev_velocity = this->prev_velocity * emission_velocity_scale;
     vec3 velocity = this->velocity * emission_velocity_scale;;
-    vec3 trans_diff = trans - prev_trans;
+    vec3 trans_diff = pos - prev_pos;
     vec3 velocity_diff = velocity - prev_velocity;
 
     float_t v41 = flt_140C9A588;
@@ -3878,7 +3878,7 @@ void ParticleEmitterRob::ctrl(float_t delta_time) {
         float_t diff_scale = rand_a_get_float();
         vec3 rand_vec = rand_b_get_float();
 
-        ptcl->position = rand_vec * 0.05f + (trans_diff * diff_scale + prev_trans);
+        ptcl->position = rand_vec * 0.05f + (trans_diff * diff_scale + prev_pos);
         ptcl->direction = rand_vec * 0.65f + (velocity_diff * diff_scale + prev_velocity);
 
         float_t size_scale = rand_a_get_float();;
@@ -3886,7 +3886,7 @@ void ParticleEmitterRob::ctrl(float_t delta_time) {
         ptcl->flags = 0x01;
         ptcl->size = max_def(size_scale * size_scale * particle_size, 1.0f);
 
-        if (in_water && (trans_diff.y * diff_scale) + prev_trans.y < 0.3f) {
+        if (in_water && (trans_diff.y * diff_scale) + prev_pos.y < 0.3f) {
             ptcl->flags = 0x00;
             ptcl->size += v41;
             ptcl->direction.y += 0.8f;
@@ -3908,28 +3908,28 @@ void ParticleEmitterRob::restart() {
 }
 
 void ParticleEmitterRob::get_trans() {
-    vec3 trans;
-    rob_chara_array_get(chara_id)->get_trans_scale(bone_index, trans);
+    vec3 pos;
+    rob_chara_array_get(chara_id)->get_pos_scale(bone_index, pos);
 
     if (init_trans) {
-        prev_trans = trans;
+        prev_pos = pos;
         init_trans = false;
     }
     else
-        prev_trans = this->trans;
+        prev_pos = this->pos;
 
-    this->trans = trans;
+    this->pos = pos;
 }
 
 void ParticleEmitterRob::get_velocity(float_t delta_time) {
     prev_velocity = velocity;
-    velocity = (trans - prev_trans) * (1.0f / delta_time);
+    velocity = (pos - prev_pos) * (1.0f / delta_time);
 }
 
 void ParticleEmitterRob::reset_data() {
     bone_index = -1;
     chara_id = 0;
-    prev_trans = 0.0f;
+    prev_pos = 0.0f;
     velocity = 0.0f;
     prev_velocity = 0.0f;
     emit_num = 0;
@@ -3950,7 +3950,7 @@ void ParticleEmitterRob::set_chara(int32_t chara_id, int32_t bone_index, bool in
 
     this->chara_id = chara_id;
     this->bone_index = bone_index;
-    prev_trans = 0.0f;
+    prev_pos = 0.0f;
     velocity = 0.0f;
     prev_velocity = 0.0f;
     emit_num = 0;
@@ -6063,7 +6063,7 @@ static void particle_event(particle_event_data* event_data) {
     float_t type = event_data->type;
     int32_t count = (int32_t)event_data->count;
     float_t size = event_data->size;
-    vec3 trans = event_data->trans;
+    vec3 pos = event_data->pos;
     float_t force = event_data->force;
 
     if (type == 1.0f) {
@@ -6077,7 +6077,7 @@ static void particle_event(particle_event_data* event_data) {
             if (!data)
                 break;
 
-            data->position = trans;
+            data->position = pos;
             data->rotation.x = rand_state_array_get_float(4) * 6.28f;
             data->rotation.y = rand_state_array_get_float(4) * 6.28f;
             vec3 direction = vec3(cosf(data->rotation.x), 0.0f, sinf(data->rotation.x));
@@ -6109,7 +6109,7 @@ static void particle_event(particle_event_data* event_data) {
             if (!data)
                 break;
 
-            data->position = trans;
+            data->position = pos;
             data->normal = vec3(0.0f, 0.0f, 1.0f);
             data->rotation.x = rand_state_array_get_float(4) * 6.28f;
             data->rotation.y = rand_state_array_get_float(4) * 6.28f;
diff --git a/src/CRE/effect.hpp b/src/CRE/effect.hpp
index f7160a45..58377fdb 100644
--- a/src/CRE/effect.hpp
+++ b/src/CRE/effect.hpp
@@ -43,7 +43,7 @@ struct particle_event_data {
     float_t type;
     float_t count;
     float_t size;
-    vec3 trans;
+    vec3 pos;
     float_t force;
 
     particle_event_data();
diff --git a/src/CRE/rob/ex_block.cpp b/src/CRE/rob/ex_block.cpp
index 874ab96e..89218f13 100644
--- a/src/CRE/rob/ex_block.cpp
+++ b/src/CRE/rob/ex_block.cpp
@@ -87,12 +87,12 @@ static void sub_14047E1C0(RobOsage* rob_osg, vec3* scale);
 static void sub_14047F110(RobOsage* rob_osg, mat4* mat, const vec3* parent_scale, bool init_rot);
 static void sub_1404803B0(RobOsage* rob_osg, const mat4* root_matrix,
     const vec3* parent_scale, bool has_children_node);
-static void sub_140482180(RobOsageNode* node, float_t ring_y);
+static void sub_140482180(RobOsageNode* node, const float_t& floor_height);
 static void sub_140482300(vec3* a1, vec3* a2, vec3* a3, float_t osage_gravity_const, float_t weight);
 static void sub_140482490(RobOsageNode* node, float_t step, float_t a3);
 static void sub_140482F30(vec3* pos1, vec3* pos2, float_t length);
 static void sub_14047D8C0(RobOsage* rob_osg, const mat4* root_matrix,
-    const vec3* parent_scale, float_t step, bool a5);
+    const vec3* parent_scale, float_t step, bool ring_coli);
 static void sub_14047C750(RobOsage* rob_osg, const mat4* root_matrix,
     const vec3* parent_scale, float_t step);
 static void sub_14047C770(RobOsage* rob_osg, const mat4* root_matrix,
@@ -415,9 +415,8 @@ void opd_node_data_pair::set_data(opd_blend_data* blend_data, opd_node_data&& no
         opd_node_data::lerp(curr, curr, node_data, blend_data->blend);
 }
 
-RobOsageNode::RobOsageNode() : length(), trans(), trans_orig(), trans_diff(),
-field_28(), child_length(), bone_node_ptr(), bone_node_mat(), sibling_node(),
-max_distance(), field_94(), reset_data(), field_C8(), external_force(), mat() {
+RobOsageNode::RobOsageNode() : length(), child_length(), bone_node_ptr(),
+bone_node_mat(), sibling_node(), max_distance(), hit() {
     friction = 1.0f;
     force = 1.0f;
     data_ptr = &data;
@@ -430,21 +429,21 @@ RobOsageNode::~RobOsageNode() {
 
 void RobOsageNode::Reset() {
     length = 0.0f;
-    trans = 0.0f;
-    trans_orig = 0.0f;
-    trans_diff = 0.0f;
-    field_28 = 0.0f;
+    pos = 0.0f;
+    fixed_pos = 0.0f;
+    delta_pos = 0.0f;
+    vel = 0.0f;
     child_length = 0.0f;
     bone_node_ptr = 0;
     bone_node_mat = 0;
     sibling_node = 0;
     max_distance = 0.0f;
-    field_94 = 0.0f;
-    reset_data.trans = 0.0f;
-    reset_data.trans_diff = 0.0f;
+    rel_pos = 0.0f;
+    reset_data.pos = 0.0f;
+    reset_data.delta_pos = 0.0f;
     reset_data.rotation = 0.0f;
     reset_data.length = 0.0f;
-    field_C8 = 0.0f;
+    hit = 0.0f;
     friction = 1.0f;
     external_force = 0.0f;
     force = 1.0f;
@@ -820,6 +819,16 @@ osage_ring_data::~osage_ring_data() {
 
 }
 
+inline float_t osage_ring_data::get_floor_height(const vec3& pos, const float_t coli_r) {
+    if (pos.x < ring_rectangle_x - coli_r
+        || pos.z < ring_rectangle_y - coli_r
+        || pos.x > ring_rectangle_x + ring_rectangle_width
+        || pos.z > ring_rectangle_y + ring_rectangle_height)
+        return ring_out_height + coli_r;
+    else
+        return ring_height + coli_r;
+}
+
 CLOTHNode::CLOTHNode() : flags(), tangent_sign(), dist_top(),
 dist_bottom(), dist_right(), dist_left(), reset_data() {
 
@@ -851,13 +860,13 @@ void CLOTH::Init() {
             size_t v7 = i * root_count + j;
             v69.field_0 = v8;
             v69.field_8 = v7;
-            v69.length = vec3::distance(nodes.data()[v7].trans, nodes.data()[v8].trans);
+            v69.length = vec3::distance(nodes.data()[v7].pos, nodes.data()[v8].pos);
             field_58.push_back(v69);
             if (j < root_count - 1) {
                 size_t v32 = i * root_count + j + 1;
                 v69.field_0 = v7;
                 v69.field_8 = v32;
-                v69.length = vec3::distance(nodes.data()[v32].trans, nodes.data()[v7].trans);
+                v69.length = vec3::distance(nodes.data()[v32].pos, nodes.data()[v7].pos);
                 field_58.push_back(v69);
             }
         }
@@ -988,8 +997,8 @@ void RobCloth::ApplyResetData() {
     for (size_t i = 0; i < root_count; i++, root++) {
         CLOTHNode* node = &nodes.data()[i + root_count];
         for (size_t j = 1; j < nodes_count; j++, node += root_count) {
-            mat4_transform_point(&root->field_D8, &node->reset_data.trans, &node->trans);
-            mat4_transform_vector(&root->field_D8, &node->reset_data.trans_diff, &node->trans_diff);
+            mat4_transform_point(&root->field_D8, &node->reset_data.pos, &node->pos);
+            mat4_transform_vector(&root->field_D8, &node->reset_data.delta_pos, &node->delta_pos);
         }
     }
 }
@@ -1007,7 +1016,7 @@ void RobCloth::Disp(const mat4* mat, render_context* rctx) {
 
     std::vector<GLuint>* tex = objset_info_storage_get_obj_set_textures(itm_eq_obj->obj_info.set_id);
 
-    vec3 center = (nodes.data()[0].trans + nodes.data()[root_count * nodes_count - 1].trans) * 0.5f;
+    vec3 center = (nodes.data()[0].pos + nodes.data()[root_count * nodes_count - 1].pos) * 0.5f;
 
     ::obj o = *obj;
     o.num_mesh = index_buffer[1].buffer != 0 ? 2 : 1;
@@ -1086,7 +1095,7 @@ void RobCloth::InitData(size_t root_count, size_t nodes_count, obj_skin_block_cl
     for (size_t i = 0; i < root_count; i++) {
         this->root.push_back({});
         RobClothRoot& v34 = this->root.back();
-        v34.trans = root[i].trans;
+        v34.pos = root[i].pos;
         v34.normal = root[i].normal;
         for (int32_t j = 0; j < 4; j++) {
             obj_skin_block_cloth_root_bone_weight& bone_weight = root[i].bone_weights[j];
@@ -1108,8 +1117,8 @@ void RobCloth::InitData(size_t root_count, size_t nodes_count, obj_skin_block_cl
     for (size_t i = 0; i < root_count; i++) {
         this->nodes.push_back({});
         CLOTHNode& v55 = this->nodes.back();
-        v55.trans = root[i].trans;
-        v55.trans_orig = root[i].trans;
+        v55.pos = root[i].pos;
+        v55.fixed_pos = root[i].pos;
     }
 
     std::vector<size_t> index_array(root_count * nodes_count, 0);
@@ -1136,12 +1145,12 @@ void RobCloth::InitData(size_t root_count, size_t nodes_count, obj_skin_block_cl
             this->nodes.push_back({});
             obj_skin_block_cloth_node& node = nodes[(i - 1) * root_count + j];
             CLOTHNode& v72 = this->nodes.back();
-            v72.trans = node.trans;
-            v72.trans_orig = node.trans;
+            v72.pos = node.pos;
+            v72.fixed_pos = node.pos;
             v72.normal = { 0.0f, 0.0f, 1.0f };
             v72.tangent = { 1.0f, 0.0f, 0.0f };
-            v72.trans_diff = node.trans_diff;
-            v72.direction = vec3::normalize(node.trans_diff);
+            v72.delta_pos = node.delta_pos;
+            v72.direction = vec3::normalize(node.delta_pos);
             v72.dist_top = node.dist_top;
             v72.dist_bottom = node.dist_bottom;
             v72.dist_right = node.dist_right;
@@ -1247,9 +1256,9 @@ void RobCloth::SetOsagePlayData(std::vector<opd_blend_data>& opd_blend_data) {
         for (size_t j = 0; j < root_count; j++) {
             CLOTHNode& root_node = nodes.data()[j];
 
-            vec3 parent_trans = root_node.trans;
+            vec3 parent_trans = root_node.pos;
             mat4 mat = root.data()[j].field_98;
-            mat4_mul_translate(&mat, &root_node.trans_orig, &mat);
+            mat4_mul_translate(&mat, &root_node.fixed_pos, &mat);
 
             CLOTHNode* v29 = &nodes.data()[j + root_count];
 
@@ -1300,7 +1309,7 @@ void RobCloth::SetOsagePlayData(std::vector<opd_blend_data>& opd_blend_data) {
     for (size_t i = 0; i < root_count; i++) {
         CLOTHNode& root_node = nodes.data()[i];
         mat4 mat = root.data()[i].field_98;
-        mat4_mul_translate(&mat, &root_node.trans_orig, &mat);
+        mat4_mul_translate(&mat, &root_node.fixed_pos, &mat);
 
         CLOTHNode* v50 = &nodes.data()[i + root_count];
 
@@ -1314,7 +1323,7 @@ void RobCloth::SetOsagePlayData(std::vector<opd_blend_data>& opd_blend_data) {
             mat4_mul_rotate_z(&mat, v50->opd_node_data.curr.rotation.z, &mat);
             mat4_mul_rotate_y(&mat, v50->opd_node_data.curr.rotation.y, &mat);
             mat4_mul_translate(&mat, v50->opd_node_data.curr.length, 0.0f, 0.0f, &mat);
-            mat4_get_translation(&mat, &v50->trans);
+            mat4_get_translation(&mat, &v50->pos);
         }
     }
 }
@@ -1323,13 +1332,13 @@ const float_t* RobCloth::SetOsagePlayDataInit(const float_t* opdi_data) {
     CLOTHNode* i_begin = nodes.data() + root_count;
     CLOTHNode* i_end = nodes.data() + nodes.size();
     for (CLOTHNode* i = i_begin; i != i_end; i++) {
-        i->trans.x = *opdi_data++;
-        i->trans.y = *opdi_data++;
-        i->trans.z = *opdi_data++;
-        i->trans_diff.x = *opdi_data++;
-        i->trans_diff.y = *opdi_data++;
-        i->trans_diff.z = *opdi_data++;
-        i->prev_trans = i->trans;
+        i->pos.x = *opdi_data++;
+        i->pos.y = *opdi_data++;
+        i->pos.z = *opdi_data++;
+        i->delta_pos.x = *opdi_data++;
+        i->delta_pos.y = *opdi_data++;
+        i->delta_pos.z = *opdi_data++;
+        i->prev_trans = i->pos;
     }
     return opdi_data;
 }
@@ -1389,7 +1398,7 @@ void RobCloth::UpdateNormals() {
         for (size_t i = 1; i < nodes_count; i++, node++) {
             for (ssize_t j = 0; j < root_count - 1; j++, node++) {
                 node[0].tangent_sign = sub_14021A290(
-                    node[0].trans, node[-root_count].trans, node[1].trans,
+                    node[0].pos, node[-root_count].pos, node[1].pos,
                     node[0].texcoord, node[-root_count].texcoord, node[1].texcoord,
                     node[0].tangent, node[0].binormal, node[0].normal);
             }
@@ -1425,7 +1434,7 @@ void RobCloth::UpdateVertexBuffer(obj_mesh* mesh, obj_mesh_vertex_buffer* vertex
                 for (int32_t j = indices_count; j; j--, indices++) {
                     CLOTHNode* node = &nodes[*indices];
 
-                    *(vec3*)data = node->trans;
+                    *(vec3*)data = node->pos;
                     *(vec3*)(data + 0x0C) = node->normal * facing;
                     *(vec3*)(data + 0x18) = node->tangent;
                     *(float_t*)(data + 0x24) = node->tangent_sign;
@@ -1441,7 +1450,7 @@ void RobCloth::UpdateVertexBuffer(obj_mesh* mesh, obj_mesh_vertex_buffer* vertex
                 for (int32_t j = indices_count; j; j--, indices++) {
                     CLOTHNode* node = &nodes[*indices];
 
-                    *(vec3*)data = node->trans;
+                    *(vec3*)data = node->pos;
                     *(vec3*)(data + 0x0C) = node->normal * facing;
 
                     data += mesh->size_vertex;
@@ -1457,7 +1466,7 @@ void RobCloth::UpdateVertexBuffer(obj_mesh* mesh, obj_mesh_vertex_buffer* vertex
                 for (int32_t j = indices_count; j; j--, indices++) {
                     CLOTHNode* node = &nodes[*indices];
 
-                    *(vec3*)data = node->trans;
+                    *(vec3*)data = node->pos;
 
                     vec3_to_vec3i16(node->normal * (32767.0f * facing), *(vec3i16*)(data + 0x0C));
                     *(int16_t*)(data + 0x12) = 0;
@@ -1478,7 +1487,7 @@ void RobCloth::UpdateVertexBuffer(obj_mesh* mesh, obj_mesh_vertex_buffer* vertex
                 for (int32_t j = indices_count; j; j--, indices++) {
                     CLOTHNode* node = &nodes[*indices];
 
-                    *(vec3*)data = node->trans;
+                    *(vec3*)data = node->pos;
 
                     vec3_to_vec3i16(node->normal * (32767.0f * facing), *(vec3i16*)(data + 0x0C));
                     *(int16_t*)(data + 0x12) = 0;
@@ -1495,7 +1504,7 @@ void RobCloth::UpdateVertexBuffer(obj_mesh* mesh, obj_mesh_vertex_buffer* vertex
                 for (int32_t j = indices_count; j; j--, indices++) {
                     CLOTHNode* node = &nodes[*indices];
 
-                    *(vec3*)data = node->trans;
+                    *(vec3*)data = node->pos;
 
                     vec3i16 normal_int;
                     vec3_to_vec3i16(node->normal * 511.0f, normal_int);
@@ -1526,7 +1535,7 @@ void RobCloth::UpdateVertexBuffer(obj_mesh* mesh, obj_mesh_vertex_buffer* vertex
                 for (int32_t j = indices_count; j; j--, indices++) {
                     CLOTHNode* node = &nodes[*indices];
 
-                    *(vec3*)data = node->trans;
+                    *(vec3*)data = node->pos;
 
                     vec3i16 normal_int;
                     vec3_to_vec3i16(node->normal * 511.0f, normal_int);
@@ -1702,8 +1711,8 @@ void RobOsage::ApplyResetData(const mat4* mat) {
     RobOsageNode* i_begin = nodes.data() + 1;
     RobOsageNode* i_end = nodes.data() + nodes.size();
     for (RobOsageNode* i = i_begin; i != i_end; i++) {
-        mat4_transform_vector(mat, &i->reset_data.trans_diff, &i->trans_diff);
-        mat4_transform_point(mat, &i->reset_data.trans, &i->trans);
+        mat4_transform_vector(mat, &i->reset_data.delta_pos, &i->delta_pos);
+        mat4_transform_point(mat, &i->reset_data.pos, &i->pos);
     }
     root_matrix = *root_matrix_ptr;
 }
@@ -1769,30 +1778,30 @@ void RobOsage::InitData(obj_skin_block_osage* osg_data, obj_skin_osage_node* osg
     if (osg_data->count) {
         obj_skin_osage_node* node_array = osg_data->node_array;
         size_t v24 = 0;
-        RobOsageNode* v26 = &nodes.data()[1];
+        RobOsageNode* node = &nodes.data()[1];
         if (node_array)
-            for (size_t i = 0; i < osg_data->count; i++) {
+            for (size_t i = 0; i < osg_data->count; i++, node++) {
                 mat3 mat;
                 mat3_rotate_zyx(&node_array[i].rotation, &mat);
 
-                vec3 v49 = { v26[i].length, 0.0f, 0.0f };
-                mat3_transform_vector(&mat, &v49, &v26[i].field_94);
+                vec3 v49 = { node->length, 0.0f, 0.0f };
+                mat3_transform_vector(&mat, &v49, &node->rel_pos);
             }
         else
-            for (size_t i = 0; i < osg_data->count; i++)
-                v26[i].field_94 = { v26[i].length, 0.0f, 0.0f };
+            for (size_t i = 0; i < osg_data->count; i++, node++)
+                node->rel_pos = { node->length, 0.0f, 0.0f };
     }
 
     if (osg_data->count) {
-        RobOsageNode* v26 = &nodes.data()[1];
+        RobOsageNode* node = &nodes.data()[1];
         size_t v33 = 0;
-        for (int32_t i = 0; i < osg_data->count; i++) {
-            v26[i].mat = mat4_null;
+        for (int32_t i = 0; i < osg_data->count; i++, node++) {
+            node->mat = mat4_null;
 
             obj_skin_bone* bone = skin->bone_array;
             for (int32_t j = 0; j < skin->num_bone; j++, bone++)
                 if (bone->id == osg_nodes->name_index) {
-                    mat4_invert_fast(&bone->inv_bind_pose_mat, &v26[i].mat);
+                    mat4_invert_fast(&bone->inv_bind_pose_mat, &node->mat);
                     break;
                 }
 
@@ -1973,7 +1982,7 @@ void RobOsage::SetOsagePlayData(const mat4* root_matrix,
     vec3 v63 = exp_data.position * parent_scale;
 
     mat4 v85 = *root_matrix;
-    mat4_transform_point(&v85, &v63, &nodes.data()[0].trans);
+    mat4_transform_point(&v85, &v63, &nodes.data()[0].pos);
 
     sub_14047F110(this, &v85, &parent_scale, false);
     *nodes.data()[0].bone_node_mat = v85;
@@ -1997,8 +2006,8 @@ void RobOsage::SetOsagePlayData(const mat4* root_matrix,
         float_t inv_blend = 1.0f - blend;
 
         mat4 v87 = v85;
-        vec3 parent_curr_trans = nodes.data()[0].trans;
-        vec3 parent_next_trans = nodes.data()[0].trans;
+        vec3 parent_curr_trans = nodes.data()[0].pos;
+        vec3 parent_next_trans = nodes.data()[0].pos;
 
         RobOsageNode* j_begin = nodes.data() + 1;
         RobOsageNode* j_end = nodes.data() + nodes.size();
@@ -2055,8 +2064,8 @@ void RobOsage::SetOsagePlayData(const mat4* root_matrix,
             mat4_scale_rot(&v85, &parent_scale, j->bone_node_mat);
 
         mat4_mul_translate(&v85, j->opd_node_data.curr.length, 0.0f, 0.0f, &v85);
-        j->trans_orig = j->trans;
-        mat4_get_translation(&v85, &j->trans);
+        j->fixed_pos = j->pos;
+        mat4_get_translation(&v85, &j->pos);
     }
 
     if (nodes.size() && node.bone_node_mat) {
@@ -2074,13 +2083,13 @@ const float_t* RobOsage::SetOsagePlayDataInit(const float_t* opdi_data) {
     RobOsageNode* i_begin = nodes.data() + 1;
     RobOsageNode* i_end = nodes.data() + nodes.size();
     for (RobOsageNode* i = i_begin; i != i_end; i++) {
-        i->trans.x = *opdi_data++;
-        i->trans.y = *opdi_data++;
-        i->trans.z = *opdi_data++;
-        i->trans_diff.x = *opdi_data++;
-        i->trans_diff.y = *opdi_data++;
-        i->trans_diff.z = *opdi_data++;
-        i->trans_orig = i->trans;
+        i->pos.x = *opdi_data++;
+        i->pos.y = *opdi_data++;
+        i->pos.z = *opdi_data++;
+        i->delta_pos.x = *opdi_data++;
+        i->delta_pos.y = *opdi_data++;
+        i->delta_pos.z = *opdi_data++;
+        i->fixed_pos = i->pos;
     }
     return opdi_data;
 }
@@ -2438,15 +2447,15 @@ void ExConstraintBlock::Calc() {
     case OBJ_SKIN_BLOCK_CONSTRAINT_ORIENTATION: {
         obj_skin_block_constraint_orientation* orientation = cns_data->orientation;
 
-        vec3 trans;
-        mat4_get_translation(&mat, &trans);
+        vec3 pos;
+        mat4_get_translation(&mat, &pos);
 
         mat3 rot;
         mat4_to_mat3(source_node_bone_node->mat, &rot);
         mat3_normalize_rotation(&rot, &rot);
         mat3_mul_rotate_zyx(&rot, &orientation->offset, &rot);
         mat4_from_mat3(&rot, node->mat);
-        mat4_set_translation(node->mat, &trans);
+        mat4_set_translation(node->mat, &pos);
     } break;
     case OBJ_SKIN_BLOCK_CONSTRAINT_DIRECTION: {
         obj_skin_block_constraint_direction* direction = cns_data->direction;
@@ -3072,9 +3081,9 @@ static void sub_140218560(RobCloth* rob_cls, float_t step, bool a3) {
             mat4& mat = rob_cls->root.data()[i].field_D8;
             CLOTHNode* node = &rob_cls->nodes.data()[i + root_count];
             for (size_t j = 1; j < nodes_count; j++, node += root_count) {
-                vec3 trans;
-                mat4_transform_point(&mat, &node->reset_data.trans, &trans);
-                node->trans += (trans - node->trans) * move_cancel;
+                vec3 pos;
+                mat4_transform_point(&mat, &node->reset_data.pos, &pos);
+                node->pos += (pos - node->pos) * move_cancel;
             }
         }
     }
@@ -3118,17 +3127,17 @@ static void sub_1402187D0(RobCloth* rob_cls, bool a2) {
             float_t v25;
             if (!a2)
                 v25 = v7;
-            else if (node->trans_diff.y >= 0.0f)
+            else if (node->delta_pos.y >= 0.0f)
                 v25 = 1.0f;
             else
                 v25 = 0.0f;
 
-            v37 = v37 * force - node->trans_diff * v25 + external_force;
+            v37 = v37 * force - node->delta_pos * v25 + external_force;
             v37.y -= osage_gravity;
-            node->trans_diff += v37;
+            node->delta_pos += v37;
 
-            node->prev_trans = node->trans;
-            node->trans += node->trans_diff;
+            node->prev_trans = node->pos;
+            node->pos += node->delta_pos;
         }
         force *= rob_cls->skin_param_ptr->force_gain;
     }
@@ -3155,13 +3164,13 @@ static void sub_140219940(RobCloth* rob_cls) {
         }
         root.field_98 = m;
 
-        mat4_transform_point(&m, &root_node.trans_orig, &root_node.trans);
+        mat4_transform_point(&m, &root_node.fixed_pos, &root_node.pos);
         mat4_transform_vector(&m, &root.normal, &root_node.normal);
         mat4_transform_vector(&m, (vec3*)&root.tangent, &root_node.tangent);
         root_node.tangent_sign = root.tangent.w;
-        root_node.prev_trans = root_node.trans;
+        root_node.prev_trans = root_node.pos;
 
-        mat4_mul_translate(&m, &root_node.trans_orig, &m);
+        mat4_mul_translate(&m, &root_node.fixed_pos, &m);
         root.field_D8 = m;
         mat4_invert(&m, &m);
         root.field_118 = m;
@@ -3176,7 +3185,7 @@ static void sub_140219D10(RobCloth* rob_cls) {
     for (size_t i = nodes_count - 2; i; i--) {
         CLOTHNode* v7 = &node[root_count * i];
         for (ssize_t j = 0; j < root_count; j++, v7++)
-            sub_140482F30(&v7->trans, &v7[root_count].trans, v7->dist_bottom);
+            sub_140482F30(&v7->pos, &v7[root_count].pos, v7->dist_bottom);
     }
 
     if (nodes_count <= 1)
@@ -3197,8 +3206,8 @@ static void sub_140219D10(RobCloth* rob_cls) {
             vec3* v17a = v11;
             CLOTHNode* v18 = v15;
             for (ssize_t j = root_count; j > 0; j--, v17++, v17a++, v18++) {
-                *v17 = v18->trans;
-                *v17a = v18->trans;
+                *v17 = v18->pos;
+                *v17a = v18->pos;
             }
         }
 
@@ -3229,7 +3238,7 @@ static void sub_140219D10(RobCloth* rob_cls) {
             vec3* v28 = v12;
             CLOTHNode* v36 = v15;
             for (ssize_t j = root_count; j > 0; j--, v27++, v28++, v36++)
-                v36->trans = (*v27 + *v28) * 0.5f;
+                v36->pos = (*v27 + *v28) * 0.5f;
         }
         v16 += root_count;
         v15 += root_count;
@@ -3288,8 +3297,8 @@ static float_t sub_14021A5E0(const vec3& pos_a, const vec3& pos_b,
 }
 
 static void sub_14021A890(CLOTHNode* a1, CLOTHNode* a2, CLOTHNode* a3, CLOTHNode* a4, CLOTHNode* a5) {
-    vec3 pos_a = a4->trans - a5->trans;
-    vec3 pos_b = a3->trans - a2->trans;
+    vec3 pos_a = a4->pos - a5->pos;
+    vec3 pos_b = a3->pos - a2->pos;
 
     float_t pos_b_length = vec3::length(pos_a);
     float_t pos_a_length = vec3::length(pos_b);
@@ -3315,65 +3324,56 @@ void sub_14021AA60(RobCloth* rob_cls, float_t step, bool a3) {
 
     RobClothRoot* root = rob_cls->root.data();
     CLOTHNode* node = &rob_cls->nodes.data()[root_count];
-    float_t coli_r = rob_cls->skin_param_ptr->coli_r;
-    float_t ring_height;
-    if (node->trans.x < rob_cls->ring.ring_rectangle_x - coli_r
-        || node->trans.z < rob_cls->ring.ring_rectangle_y - coli_r
-        || node->trans.x > rob_cls->ring.ring_rectangle_x + rob_cls->ring.ring_rectangle_width
-        || node->trans.z > rob_cls->ring.ring_rectangle_y + rob_cls->ring.ring_rectangle_height)
-        ring_height = rob_cls->ring.ring_out_height;
-    else
-        ring_height = rob_cls->ring.ring_height;
-
-    float_t v19 = ring_height + coli_r;
+    const float_t floor_height = rob_cls->ring.get_floor_height(
+        node->pos, rob_cls->skin_param_ptr->coli_r);
 
     for (size_t i = 1; i < nodes_count; i++) {
         for (ssize_t j = 0; j < root_count; j++, node++) {
             float_t fric = (1.0f - rob_cls->field_44) * rob_cls->skin_param_ptr->friction;
             if (step != 1.0f) {
-                vec3 trans_diff = node->trans - node->prev_trans;
+                vec3 delta_pos = node->pos - node->prev_trans;
 
-                float_t trans_length = vec3::length(trans_diff);
+                float_t trans_length = vec3::length(delta_pos);
                 if (trans_length * step > 0.0f && trans_length != 0.0f)
-                    trans_diff *= 1.0f / trans_length;
+                    delta_pos *= 1.0f / trans_length;
 
-                node->trans = node->prev_trans + trans_diff * (trans_length * step);
+                node->pos = node->prev_trans + delta_pos * (trans_length * step);
             }
-            sub_140482F30(&node[0].trans, &node[-root_count].trans, node[0].dist_top);
+            sub_140482F30(&node[0].pos, &node[-root_count].pos, node[0].dist_top);
 
-            int32_t v39 = OsageCollision::osage_cls_work_list(node->trans,
+            int32_t v39 = OsageCollision::osage_cls_work_list(node->pos,
                 rob_cls->skin_param_ptr->coli_r, rob_cls->ring.coli, &fric);
-            v39 += OsageCollision::osage_cls(rob_cls->coli_ring, node->trans, rob_cls->skin_param_ptr->coli_r);
-            v39 += OsageCollision::osage_cls(rob_cls->coli, node->trans, rob_cls->skin_param_ptr->coli_r);
+            v39 += OsageCollision::osage_cls(rob_cls->coli_ring, node->pos, rob_cls->skin_param_ptr->coli_r);
+            v39 += OsageCollision::osage_cls(rob_cls->coli, node->pos, rob_cls->skin_param_ptr->coli_r);
 
-            if (v19 > node->trans.y && v19 < 1001.0) {
-                node->trans.y = v19;
-                node->trans_diff = 0.0f;
+            if (floor_height > node->pos.y && floor_height < 1001.0f) {
+                node->pos.y = floor_height;
+                node->delta_pos = 0.0f;
             }
 
             mat4 mat = root->field_98;
-            mat4_set_translation(&mat, &node[-root_count].trans);
+            mat4_set_translation(&mat, &node[-root_count].pos);
 
             int32_t yz_order = 1;
             sub_140482FF0(mat, node->direction, 0, 0, yz_order);
 
             vec3 direction;
-            mat4_inverse_transform_point(&mat, &node->trans, &direction);
+            mat4_inverse_transform_point(&mat, &node->pos, &direction);
 
             sub_140482FF0(mat, direction, &rob_cls->skin_param_ptr->hinge,
                 &node->reset_data.rotation, yz_order);
             mat4_mul_translate(&mat, node->dist_top, 0.0f, 0.0f, &mat);
-            mat4_get_translation(&mat, &node->trans);
+            mat4_get_translation(&mat, &node->pos);
 
             if (v39)
-                node->trans_diff *= fric;
+                node->delta_pos *= fric;
 
-            node->trans_diff = (node->trans - node->prev_trans) * v10;
+            node->delta_pos = (node->pos - node->prev_trans) * v10;
 
             if (!a3) {
                 mat4& v49 = rob_cls->root.data()[j].field_118;
-                mat4_transform_point(&v49, &node->trans, &node->reset_data.trans);
-                mat4_transform_vector(&v49, &node->trans_diff, &node->reset_data.trans_diff);
+                mat4_transform_point(&v49, &node->pos, &node->reset_data.pos);
+                mat4_transform_vector(&v49, &node->delta_pos, &node->reset_data.delta_pos);
             }
         }
     }
@@ -3388,17 +3388,8 @@ static void sub_14021D480(RobCloth* rob_cls) {
     size_t nodes_count = rob_cls->nodes_count;
 
     CLOTHNode* node = &rob_cls->nodes.data()[root_count];
-    float_t coli_r = rob_cls->skin_param_ptr->coli_r;
-    float_t ring_height;
-    if (node->trans.x < rob_cls->ring.ring_rectangle_x - coli_r
-        || node->trans.z < rob_cls->ring.ring_rectangle_y - coli_r
-        || node->trans.x > rob_cls->ring.ring_rectangle_x + rob_cls->ring.ring_rectangle_width
-        || node->trans.z > rob_cls->ring.ring_rectangle_y + rob_cls->ring.ring_rectangle_height)
-        ring_height = rob_cls->ring.ring_out_height;
-    else
-        ring_height = rob_cls->ring.ring_height;
-
-    float_t v10 = ring_height + coli_r;
+    const float_t floor_height = rob_cls->ring.get_floor_height(
+        node->pos, rob_cls->skin_param_ptr->coli_r);
 
     for (size_t i = 1; i < nodes_count; i++) {
         RobClothRoot* root = rob_cls->root.data();
@@ -3409,18 +3400,18 @@ static void sub_14021D480(RobCloth* rob_cls) {
             mat4_transform_vector(&mat, &node->direction, &v38);
             v38.y -= osage_gravity_const;
 
-            node[0].trans = node[-root_count].trans + vec3::normalize(v38) * node->dist_top;
+            node[0].pos = node[-root_count].pos + vec3::normalize(v38) * node->dist_top;
 
-            OsageCollision::osage_cls_work_list(node->trans,
+            OsageCollision::osage_cls_work_list(node->pos,
                 rob_cls->skin_param_ptr->coli_r, rob_cls->ring.coli);
-            OsageCollision::osage_cls(rob_cls->coli_ring, node->trans, rob_cls->skin_param_ptr->coli_r);
-            OsageCollision::osage_cls(rob_cls->coli, node->trans, rob_cls->skin_param_ptr->coli_r);
+            OsageCollision::osage_cls(rob_cls->coli_ring, node->pos, rob_cls->skin_param_ptr->coli_r);
+            OsageCollision::osage_cls(rob_cls->coli, node->pos, rob_cls->skin_param_ptr->coli_r);
 
-            if (v10 > node->trans.y && v10 < 1001.0f)
-                node->trans.y = v10;
+            if (floor_height > node->pos.y && floor_height < 1001.0f)
+                node->pos.y = floor_height;
 
-            node->trans_diff = 0.0f;
-            node->prev_trans = node->trans;
+            node->delta_pos = 0.0f;
+            node->prev_trans = node->pos;
         }
     }
 
@@ -3430,7 +3421,7 @@ static void sub_14021D480(RobCloth* rob_cls) {
     node = &rob_cls->nodes.data()[root_count];
     for (size_t i = 1; i < nodes_count; i++)
         for (ssize_t j = 0; j < root_count; j++, node++)
-            node->trans_diff = 0.0f;
+            node->delta_pos = 0.0f;
 }
 
 static void sub_14021DC60(RobCloth* rob_cls, float_t step) {
@@ -3457,12 +3448,12 @@ static void sub_14047C800(RobOsage* rob_osg, const mat4* root_matrix,
     sub_1404803B0(rob_osg, root_matrix, parent_scale, false);
 
     RobOsageNode* v17 = &rob_osg->nodes.data()[0];
-    v17->trans_orig = v17->trans;
+    v17->fixed_pos = v17->pos;
     vec3 v113 = rob_osg->exp_data.position * *parent_scale;
 
     mat4 v130 = *root_matrix;
-    mat4_transform_point(&v130, &v113, &v17->trans);
-    v17->trans_diff = v17->trans - v17->trans_orig;
+    mat4_transform_point(&v130, &v113, &v17->pos);
+    v17->delta_pos = v17->pos - v17->fixed_pos;
 
     sub_14047F110(rob_osg, &v130, parent_scale, false);
     *rob_osg->nodes.data()[0].bone_node_mat = v130;
@@ -3486,11 +3477,11 @@ static void sub_14047C800(RobOsage* rob_osg, const mat4* root_matrix,
         float_t weight = v31->skp_osg_node.weight;
         vec3 v111;
         if (!rob_osg->set_external_force) {
-            sub_140482300(&v111, &v26->trans, &v30->trans, osage_gravity_const, weight);
+            sub_140482300(&v111, &v26->pos, &v30->pos, osage_gravity_const, weight);
 
             if (v26 != v26_end - 1) {
                 vec3 v112;
-                sub_140482300(&v112, &v26->trans, &v26[1].trans, osage_gravity_const, weight);
+                sub_140482300(&v112, &v26->pos, &v26[1].pos, osage_gravity_const, weight);
                 v111 = (v111 + v112) * 0.5f;
             }
         }
@@ -3500,15 +3491,15 @@ static void sub_14047C800(RobOsage* rob_osg, const mat4* root_matrix,
         vec3 v127 = v128 * (v31->force * v26->force);
         float_t v41 = (1.0f - rob_osg->field_1EB4) * (1.0f - rob_osg->skin_param_ptr->air_res);
 
-        vec3 v126 = v111 + v127 - v26->trans_diff * v41 + v26->external_force * weight;
+        vec3 v126 = v111 + v127 - v26->delta_pos * v41 + v26->external_force * weight;
 
         if (!disable_external_force)
             v126 += rob_osg->wind_direction * rob_osg->skin_param_ptr->wind_afc;
 
         if (stiffness)
-            v126 -= (v26->trans_diff - v30->trans_diff) * (1.0f - rob_osg->skin_param_ptr->air_res);
+            v126 -= (v26->delta_pos - v30->delta_pos) * (1.0f - rob_osg->skin_param_ptr->air_res);
 
-        v26->field_28 = v126 * (1.0f / (weight - (weight - 1.0f) * v31->skp_osg_node.inertial_cancel));
+        v26->vel = v126 * (1.0f / (weight - (weight - 1.0f) * v31->skp_osg_node.inertial_cancel));
     }
 
     if (stiffness) {
@@ -3519,18 +3510,18 @@ static void sub_14047C800(RobOsage* rob_osg, const mat4* root_matrix,
         RobOsageNode* v55_begin = rob_osg->nodes.data() + 1;
         RobOsageNode* v55_end = rob_osg->nodes.data() + rob_osg->nodes.size();
         for (RobOsageNode* v55 = v55_begin; v55 != v55_end; v55++) {
-            mat4_transform_point(&v131, &v55->field_94, &v128);
+            mat4_transform_point(&v131, &v55->rel_pos, &v128);
 
-            vec3 v123 = v55->trans_diff + v55->field_28;
-            vec3 v126 = v55->trans + v123;
+            vec3 v123 = v55->delta_pos + v55->vel;
+            vec3 v126 = v55->pos + v123;
             sub_140482F30(&v126, &v111, v25 * v55->length);
 
             vec3 v117 = (v128 - v126) * rob_osg->skin_param_ptr->stiffness;
             float_t weight = v55->data_ptr->skp_osg_node.weight;
             float_t v74 = 1.0f / (weight - (weight - 1.0f) * v55->data_ptr->skp_osg_node.inertial_cancel);
-            v55->field_28 += v117 * v74;
+            v55->vel += v117 * v74;
 
-            v126 = v55->trans + v117 + v123;
+            v126 = v55->pos + v117 + v123;
 
             vec3 direction;
             mat4_inverse_transform_point(&v131, &v126, &direction);
@@ -3546,36 +3537,28 @@ static void sub_14047C800(RobOsage* rob_osg, const mat4* root_matrix,
     RobOsageNode* v82_begin = rob_osg->nodes.data() + 1;
     RobOsageNode* v82_end = rob_osg->nodes.data() + rob_osg->nodes.size();
     for (RobOsageNode* v82 = v82_begin; v82 != v82_end; v82++) {
-        v82->trans_orig = v82->trans;
-        v82->trans_diff += v82->field_28;
-        v82->trans += v82->trans_diff;
+        v82->fixed_pos = v82->pos;
+        v82->delta_pos += v82->vel;
+        v82->pos += v82->delta_pos;
     }
 
     if (rob_osg->nodes.size() > 1) {
         RobOsageNode* v90_begin = rob_osg->nodes.data() + rob_osg->nodes.size() - 2;
         RobOsageNode* v90_end = rob_osg->nodes.data();
         for (RobOsageNode* v90 = v90_begin; v90 != v90_end; v90--)
-            sub_140482F30(&v90[0].trans, &v90[1].trans, v25 * v90->child_length);
+            sub_140482F30(&v90[0].pos, &v90[1].pos, v25 * v90->child_length);
     }
 
     if (ring_coli) {
-        RobOsageNode* v91 = &rob_osg->nodes.data()[0];
-        float_t coli_r = v91->data_ptr->skp_osg_node.coli_r;
-        float_t ring_height;
-        if (v91->trans.x < rob_osg->ring.ring_rectangle_x - coli_r
-            || v91->trans.z < rob_osg->ring.ring_rectangle_y - coli_r
-            || v91->trans.x > rob_osg->ring.ring_rectangle_x + rob_osg->ring.ring_rectangle_width
-            || v91->trans.z > rob_osg->ring.ring_rectangle_y + rob_osg->ring.ring_rectangle_height)
-            ring_height = rob_osg->ring.ring_out_height;
-        else
-            ring_height = rob_osg->ring.ring_height;
+        RobOsageNode* node = &rob_osg->nodes.data()[0];
+        const float_t floor_height = rob_osg->ring.get_floor_height(
+            node->pos, node->data_ptr->skp_osg_node.coli_r);
 
-        float_t ring_y = ring_height + coli_r;
         RobOsageNode* v98_begin = rob_osg->nodes.data() + 1;
         RobOsageNode* v98_end = rob_osg->nodes.data() + rob_osg->nodes.size();
         for (RobOsageNode* v98 = v98_begin; v98 != v98_end; v98++) {
             sub_140482490(v98, step, v25);
-            sub_140482180(v98, ring_y);
+            sub_140482180(v98, floor_height);
         }
     }
 
@@ -3585,14 +3568,14 @@ static void sub_14047C800(RobOsage* rob_osg, const mat4* root_matrix,
         RobOsageNode* v99_end = rob_osg->nodes.data() + rob_osg->nodes.size();
         for (RobOsageNode* v99 = v99_begin; v99 != v99_end; v99++, v100++) {
             vec3 direction;
-            mat4_inverse_transform_point(&v130, &v99->trans, &direction);
+            mat4_inverse_transform_point(&v130, &v99->pos, &direction);
 
             bool v102 = sub_140482FF0(v130, direction,
                 &v99->data_ptr->skp_osg_node.hinge,
                 &v99->reset_data.rotation, rob_osg->yz_order);
             *v99->bone_node_ptr->ex_data_mat = v130;
 
-            float_t v104 = vec3::distance_squared(v99->trans, v100->trans);
+            float_t v104 = vec3::distance_squared(v99->pos, v100->pos);
             float_t v105 = v99->length * v25;
 
             bool v106;
@@ -3605,7 +3588,7 @@ static void sub_14047C800(RobOsage* rob_osg, const mat4* root_matrix,
 
             mat4_mul_translate(&v130, v105, 0.0f, 0.0f, &v130);
             if (v102 || v106)
-                mat4_get_translation(&v130, &v99->trans);
+                mat4_get_translation(&v130, &v99->pos);
         }
 
         if (rob_osg->nodes.size() && rob_osg->node.bone_node_mat) {
@@ -3643,7 +3626,7 @@ static void sub_1404803B0(RobOsage* rob_osg, const mat4* root_matrix,
     const vec3* parent_scale, bool has_children_node) {
     mat4 v47 = *root_matrix;
     vec3 v45 = rob_osg->exp_data.position * *parent_scale;
-    mat4_transform_point(&v47, &v45, &rob_osg->nodes.data()[0].trans);
+    mat4_transform_point(&v47, &v45, &rob_osg->nodes.data()[0].pos);
 
     if (rob_osg->osage_reset && !rob_osg->prev_osage_reset) {
         rob_osg->prev_osage_reset = true;
@@ -3662,9 +3645,9 @@ static void sub_1404803B0(RobOsage* rob_osg, const mat4* root_matrix,
             RobOsageNode* i_end = rob_osg->nodes.data() + rob_osg->nodes.size();
             for (RobOsageNode* i = i_begin; i != i_end; i++) {
                 vec3 v44;
-                mat4_inverse_transform_point(&rob_osg->root_matrix, &i->trans, &v44);
+                mat4_inverse_transform_point(&rob_osg->root_matrix, &i->pos, &v44);
                 mat4_transform_point(rob_osg->root_matrix_ptr, &v44, &v44);
-                i->trans += (v44 - i->trans) * move_cancel;
+                i->pos += (v44 - i->pos) * move_cancel;
             }
         }
     }
@@ -3680,13 +3663,13 @@ static void sub_1404803B0(RobOsage* rob_osg, const mat4* root_matrix,
     RobOsageNode* v30_end = rob_osg->nodes.data() + rob_osg->nodes.size();
     for (RobOsageNode* v30 = v30_begin; v30 != v30_end; v29++, v30++) {
         vec3 direction;
-        mat4_inverse_transform_point(&v47, &v30->trans, &direction);
+        mat4_inverse_transform_point(&v47, &v30->pos, &direction);
 
         bool v32 = sub_140482FF0(v47, direction, &v30->data_ptr->skp_osg_node.hinge,
             &v30->reset_data.rotation, rob_osg->yz_order);
         *v30->bone_node_ptr->ex_data_mat = v47;
 
-        float_t v34 = vec3::distance_squared(v30->trans, v29->trans);
+        float_t v34 = vec3::distance_squared(v30->pos, v29->pos);
         float_t v35 = v30->length * parent_scale->x;
 
         bool v36;
@@ -3699,7 +3682,7 @@ static void sub_1404803B0(RobOsage* rob_osg, const mat4* root_matrix,
 
         mat4_mul_translate(&v47, v35, 0.0f, 0.0f, &v47);
         if (v32 || v36)
-            mat4_get_translation(&v47, &v30->trans);
+            mat4_get_translation(&v47, &v30->pos);
     }
 
     if (rob_osg->nodes.size() && rob_osg->node.bone_node_mat) {
@@ -3709,15 +3692,15 @@ static void sub_1404803B0(RobOsage* rob_osg, const mat4* root_matrix,
     }
 }
 
-static void sub_140482180(RobOsageNode* node, float_t ring_y) {
-    float_t v2 = node->data_ptr->skp_osg_node.coli_r + ring_y;
-    if (v2 <= node->trans.y)
+static void sub_140482180(RobOsageNode* node, const float_t& floor_height) {
+    float_t pos_y = node->data_ptr->skp_osg_node.coli_r + floor_height;
+    if (pos_y <= node->pos.y)
         return;
 
-    node->trans.y = v2;
-    node->trans = node[-1].trans + vec3::normalize(node->trans - node[-1].trans) * node->length;
-    node->trans_diff = 0.0f;
-    node->field_C8 += 1.0f;
+    node->pos.y = pos_y;
+    node->pos = node[-1].pos + vec3::normalize(node->pos - node[-1].pos) * node->length;
+    node->delta_pos = 0.0f;
+    node->hit += 1.0f;
 }
 
 static void sub_140482300(vec3* a1, vec3* a2, vec3* a3, float_t osage_gravity_const, float_t weight) {
@@ -3735,17 +3718,17 @@ static void sub_140482300(vec3* a1, vec3* a2, vec3* a3, float_t osage_gravity_co
 
 static void sub_140482490(RobOsageNode* node, float_t step, float_t a3) {
     if (step != 1.0f) {
-        vec3 v4 = node->trans - node->trans_orig;
+        vec3 v4 = node->pos - node->fixed_pos;
 
         float_t v9 = vec3::length(v4);
         if (v9 != 0.0f)
             v4 *= 1.0f / v9;
-        node->trans = node->trans_orig + v4 * (step * v9);
+        node->pos = node->fixed_pos + v4 * (step * v9);
     }
 
-    sub_140482F30(&node[0].trans, &node[-1].trans, node->length * a3);
+    sub_140482F30(&node[0].pos, &node[-1].pos, node->length * a3);
     if (node->sibling_node)
-        sub_140482F30(&node->trans, &node->sibling_node->trans, node->max_distance);
+        sub_140482F30(&node->pos, &node->sibling_node->pos, node->max_distance);
 }
 
 static void sub_140482F30(vec3* pos1, vec3* pos2, float_t length) {
@@ -3756,43 +3739,34 @@ static void sub_140482F30(vec3* pos1, vec3* pos2, float_t length) {
 }
 
 static void sub_14047D8C0(RobOsage* rob_osg, const mat4* root_matrix,
-    const vec3* parent_scale, float_t step, bool a5) {
+    const vec3* parent_scale, float_t step, bool ring_coli) {
     if (!rob_osg->osage_reset && (get_pause() || step <= 0.0f))
         return;
 
-    OsageCollision::Work* coli = rob_osg->coli;
-    OsageCollision::Work* coli_ring = rob_osg->coli_ring;
-    OsageCollision& vec_ring_coli = rob_osg->ring.coli;
+    const OsageCollision::Work* coli = rob_osg->coli;
+    const OsageCollision::Work* coli_ring = rob_osg->coli_ring;
+    const OsageCollision& vec_ring_coli = rob_osg->ring.coli;
 
     float_t v9 = 0.0f;
     if (step > 0.0f)
         v9 = 1.0f / step;
 
     mat4 v64;
-    if (a5)
+    if (ring_coli)
         v64 = *rob_osg->nodes.data()[0].bone_node_mat;
     else {
         v64 = *root_matrix;
 
-        vec3 trans = rob_osg->exp_data.position * *parent_scale;
-        mat4_transform_point(&v64, &trans, &rob_osg->nodes.data()[0].trans);
+        vec3 pos = rob_osg->exp_data.position * *parent_scale;
+        mat4_transform_point(&v64, &pos, &rob_osg->nodes.data()[0].pos);
         sub_14047F110(rob_osg, &v64, parent_scale, false);
     }
 
-    float_t ring_y = -1000.0f;
-    if (a5) {
-        RobOsageNode* v16 = &rob_osg->nodes.data()[0];
-        float_t coli_r = v16->data_ptr->skp_osg_node.coli_r;
-        float_t ring_height;
-        if (v16->trans.x < rob_osg->ring.ring_rectangle_x - coli_r
-            || v16->trans.z < rob_osg->ring.ring_rectangle_y - coli_r
-            || v16->trans.x > rob_osg->ring.ring_rectangle_x + rob_osg->ring.ring_rectangle_width
-            || v16->trans.z > rob_osg->ring.ring_rectangle_y + rob_osg->ring.ring_rectangle_height)
-            ring_height = rob_osg->ring.ring_out_height;
-        else
-            ring_height = rob_osg->ring.ring_height;
-
-        ring_y = ring_height + coli_r;
+    float_t floor_height = -1000.0f;
+    if (ring_coli) {
+        RobOsageNode* node = &rob_osg->nodes.data()[0];
+        floor_height = rob_osg->ring.get_floor_height(
+            node->pos, node->data_ptr->skp_osg_node.coli_r);
     }
 
     float_t v23 = 0.2f;
@@ -3809,9 +3783,9 @@ static void sub_14047D8C0(RobOsage* rob_osg, const mat4* root_matrix,
             RobOsageNode* v30_begin = v24->data() + 1;
             RobOsageNode* v30_end = v24->data() + v24->size();
             for (RobOsageNode* v30 = v30_begin; v30 != v30_end; v30++)
-                OsageCollision::cls_ball_oidashi(v62, v27->trans, v30->trans,
+                OsageCollision::cls_ball_oidashi(v62, v27->pos, v30->pos,
                     v27->data_ptr->skp_osg_node.coli_r + v30->data_ptr->skp_osg_node.coli_r);
-            v27->trans += v62;
+            v27->pos += v62;
         }
     }
 
@@ -3820,21 +3794,21 @@ static void sub_14047D8C0(RobOsage* rob_osg, const mat4* root_matrix,
     for (RobOsageNode* v35 = v35_begin; v35 != v35_end; v35++) {
         skin_param_osage_node* skp_osg_node = &v35->data_ptr->skp_osg_node;
         float_t fric = (1.0f - rob_osg->field_1EB4) * rob_osg->skin_param_ptr->friction;
-        if (a5) {
+        if (ring_coli) {
             sub_140482490(v35, step, parent_scale->x);
-            v35->field_C8 = (float_t)OsageCollision::osage_cls_work_list(v35->trans,
+            v35->hit = (float_t)OsageCollision::osage_cls_work_list(v35->pos,
                 skp_osg_node->coli_r, vec_ring_coli, &v35->friction);
             if (!rob_osg->disable_collision) {
-                v35->field_C8 += (float_t)OsageCollision::osage_cls(coli_ring, v35->trans, skp_osg_node->coli_r);
-                v35->field_C8 += (float_t)OsageCollision::osage_cls(coli, v35->trans, skp_osg_node->coli_r);
+                v35->hit += (float_t)OsageCollision::osage_cls(coli_ring, v35->pos, skp_osg_node->coli_r);
+                v35->hit += (float_t)OsageCollision::osage_cls(coli, v35->pos, skp_osg_node->coli_r);
             }
-            sub_140482180(v35, ring_y);
+            sub_140482180(v35, floor_height);
         }
         else
-            sub_140482F30(&v35[0].trans, &v35[-1].trans, v35[0].length * parent_scale->x);
+            sub_140482F30(&v35[0].pos, &v35[-1].pos, v35[0].length * parent_scale->x);
 
         vec3 direction;
-        mat4_inverse_transform_point(&v64, &v35->trans, &direction);
+        mat4_inverse_transform_point(&v64, &v35->pos, &direction);
 
         bool v40 = sub_140482FF0(v64, direction, &skp_osg_node->hinge,
             &v35->reset_data.rotation, rob_osg->yz_order);
@@ -3844,7 +3818,7 @@ static void sub_14047D8C0(RobOsage* rob_osg, const mat4* root_matrix,
         if (v35->bone_node_mat)
             mat4_scale_rot(&v64, parent_scale, v35->bone_node_mat);
 
-        float_t v44 = vec3::distance_squared(v35[0].trans, v35[-1].trans);
+        float_t v44 = vec3::distance_squared(v35[0].pos, v35[-1].pos);
         float_t v42 = v35->length * parent_scale->x;
 
         bool v45;
@@ -3858,19 +3832,19 @@ static void sub_14047D8C0(RobOsage* rob_osg, const mat4* root_matrix,
         mat4_mul_translate(&v64, v42, 0.0f, 0.0f, &v64);
         v35->reset_data.length = v42;
         if (v40 || v45)
-            mat4_get_translation(&v64, &v35->trans);
+            mat4_get_translation(&v64, &v35->pos);
 
-        v35->trans_diff = (v35->trans - v35->trans_orig) * v9;
+        v35->delta_pos = (v35->pos - v35->fixed_pos) * v9;
 
-        if (v35->field_C8 > 0.0f)
-            v35->trans_diff *= min_def(fric, v35->friction);
+        if (v35->hit > 0.0f)
+            v35->delta_pos *= min_def(fric, v35->friction);
 
-        float_t v55 = vec3::length_squared(v35->trans_diff);
+        float_t v55 = vec3::length_squared(v35->delta_pos);
         if (v55 > v23 * v23)
-            v35->trans_diff *= v23 / sqrtf(v55);
+            v35->delta_pos *= v23 / sqrtf(v55);
 
-        mat4_inverse_transform_point(root_matrix, &v35->trans, &v35->reset_data.trans);
-        mat4_inverse_transform_vector(root_matrix, &v35->trans_diff, &v35->reset_data.trans_diff);
+        mat4_inverse_transform_point(root_matrix, &v35->pos, &v35->reset_data.pos);
+        mat4_inverse_transform_vector(root_matrix, &v35->delta_pos, &v35->reset_data.delta_pos);
     }
 
     if (rob_osg->nodes.size() && rob_osg->node.bone_node_mat) {
@@ -3900,62 +3874,63 @@ static void sub_14047D620(RobOsage* rob_osg, float_t step) {
         return;
 
     std::vector<RobOsageNode>& nodes = rob_osg->nodes;
-    vec3 v7 = nodes.data()[0].trans;
-    OsageCollision::Work* coli = rob_osg->coli;
-    OsageCollision::Work* coli_ring = rob_osg->coli_ring;
-    SkinParam::RootCollisionType  coli_type = rob_osg->skin_param_ptr->coli_type;
+    const vec3 pos = nodes.data()[0].pos;
+    const OsageCollision::Work* coli = rob_osg->coli;
+    const OsageCollision::Work* coli_ring = rob_osg->coli_ring;
+    const SkinParam::RootCollisionType coli_type = rob_osg->skin_param_ptr->coli_type;
+
     RobOsageNode* i_begin = nodes.data() + 1;
     RobOsageNode* i_end = nodes.data() + nodes.size();
     for (RobOsageNode* i = i_begin; i != i_end; i++) {
         RobOsageNodeData* data = i->data_ptr;
         for (RobOsageNode*& j : data->boc) {
             float_t v17 = (float_t)(
-                OsageCollision::osage_capsule_cls(coli_ring, i->trans, j->trans, data->skp_osg_node.coli_r)
-                + OsageCollision::osage_capsule_cls(coli, i->trans, j->trans, data->skp_osg_node.coli_r));
-            i->field_C8 += v17;
-            j->field_C8 += v17;
+                OsageCollision::osage_capsule_cls(coli_ring, i->pos, j->pos, data->skp_osg_node.coli_r)
+                + OsageCollision::osage_capsule_cls(coli, i->pos, j->pos, data->skp_osg_node.coli_r));
+            i->hit += v17;
+            j->hit += v17;
         }
 
         if (coli_type != SkinParam::RootCollisionTypeEnd
             && (coli_type != SkinParam::RootCollisionTypeBall || i != i_begin)) {
             float_t v20 = (float_t)(
-                OsageCollision::osage_capsule_cls(coli_ring, i[0].trans, i[-1].trans, data->skp_osg_node.coli_r)
-                + OsageCollision::osage_capsule_cls(coli, i[0].trans, i[-1].trans, data->skp_osg_node.coli_r));
-            i[0].field_C8 += v20;
-            i[-1].field_C8 += v20;
+                OsageCollision::osage_capsule_cls(coli_ring, i[0].pos, i[-1].pos, data->skp_osg_node.coli_r)
+                + OsageCollision::osage_capsule_cls(coli, i[0].pos, i[-1].pos, data->skp_osg_node.coli_r));
+            i[0].hit += v20;
+            i[-1].hit += v20;
         }
     }
-    nodes.data()[0].trans = v7;
+    nodes.data()[0].pos = pos;
 }
 
 static void sub_14047ECA0(RobOsage* rob_osg, float_t step) {
     if (get_pause() || step <= 0.0f)
         return;
 
-    OsageCollision::Work* coli_ring = rob_osg->coli_ring;
-    OsageCollision::Work* coli = rob_osg->coli;
-    OsageCollision& vec_coli = rob_osg->ring.coli;
+    const OsageCollision::Work* coli = rob_osg->coli;
+    const OsageCollision::Work* coli_ring = rob_osg->coli_ring;
+    const OsageCollision& vec_ring_coli = rob_osg->ring.coli;
 
     RobOsageNode* i_begin = rob_osg->nodes.data() + 1;
     RobOsageNode* i_end = rob_osg->nodes.data() + rob_osg->nodes.size();
     if (rob_osg->disable_collision)
         for (RobOsageNode* i = i_begin; i != i_end; i++) {
             RobOsageNodeData* data = i->data_ptr;
-            i->field_C8 += (float_t)OsageCollision::osage_cls_work_list(i->trans,
-                data->skp_osg_node.coli_r, vec_coli, &i->friction);
+            i->hit += (float_t)OsageCollision::osage_cls_work_list(i->pos,
+                data->skp_osg_node.coli_r, vec_ring_coli, &i->friction);
         }
     else
         for (RobOsageNode* i = i_begin; i != i_end; i++) {
             RobOsageNodeData* data = i->data_ptr;
-            i->field_C8 += (float_t)OsageCollision::osage_cls_work_list(i->trans,
-                data->skp_osg_node.coli_r, vec_coli, &i->friction);
+            i->hit += (float_t)OsageCollision::osage_cls_work_list(i->pos,
+                data->skp_osg_node.coli_r, vec_ring_coli, &i->friction);
             for (RobOsageNode*& j : data->boc) {
-                j->field_C8 += (float_t)OsageCollision::osage_cls(coli_ring, j->trans, data->skp_osg_node.coli_r);
-                j->field_C8 += (float_t)OsageCollision::osage_cls(coli, j->trans, data->skp_osg_node.coli_r);
+                j->hit += (float_t)OsageCollision::osage_cls(coli_ring, j->pos, data->skp_osg_node.coli_r);
+                j->hit += (float_t)OsageCollision::osage_cls(coli, j->pos, data->skp_osg_node.coli_r);
             }
 
-            i->field_C8 += (float_t)OsageCollision::osage_cls(coli_ring, i->trans, data->skp_osg_node.coli_r);
-            i->field_C8 += (float_t)OsageCollision::osage_cls(coli, i->trans, data->skp_osg_node.coli_r);
+            i->hit += (float_t)OsageCollision::osage_cls(coli_ring, i->pos, data->skp_osg_node.coli_r);
+            i->hit += (float_t)OsageCollision::osage_cls(coli, i->pos, data->skp_osg_node.coli_r);
         }
 }
 
@@ -3967,52 +3942,45 @@ static void sub_14047F990(RobOsage* rob_osg, const mat4* root_matrix,
     vec3 v76 = rob_osg->exp_data.position * *parent_scale;
     mat4_transform_point(root_matrix, &v76, &v76);
     RobOsageNode* v12 = &rob_osg->nodes.data()[0];
-    v12->trans = v76;
-    v12->trans_orig = v76;
-    v12->trans_diff = 0.0f;
+    v12->pos = v76;
+    v12->fixed_pos = v76;
+    v12->delta_pos = 0.0f;
 
-    float_t ring_height;
-    RobOsageNode* v14 = &rob_osg->nodes.data()[0];
-    float_t coli_r = v14->data_ptr->skp_osg_node.coli_r;
-    if (v14->trans.x < rob_osg->ring.ring_rectangle_x - coli_r
-        || v14->trans.z < rob_osg->ring.ring_rectangle_y - coli_r
-        || v14->trans.x > rob_osg->ring.ring_rectangle_x + rob_osg->ring.ring_rectangle_width
-        || v14->trans.z > rob_osg->ring.ring_rectangle_y + rob_osg->ring.ring_rectangle_height)
-        ring_height = rob_osg->ring.ring_out_height;
-    else
-        ring_height = rob_osg->ring.ring_height;
+    RobOsageNode* node = &rob_osg->nodes.data()[0];
+    const float_t floor_height = rob_osg->ring.get_floor_height(
+        node->pos, node->data_ptr->skp_osg_node.coli_r);
 
     mat4 v78 = *root_matrix;
     sub_14047F110(rob_osg, &v78, parent_scale, true);
     vec3 v60 = { 1.0f, 0.0f, 0.0f };
     mat4_transform_vector(&v78, &v60, &v60);
 
-    OsageCollision::Work* coli_ring = rob_osg->coli_ring;
-    OsageCollision::Work* coli = rob_osg->coli;
-    float_t v25 = ring_height + coli_r;
-    float_t v16 = parent_scale->x;
+    const OsageCollision::Work* coli = rob_osg->coli;
+    const OsageCollision::Work* coli_ring = rob_osg->coli_ring;
+
+    float_t parent_scale_x = parent_scale->x;
     RobOsageNode* i = rob_osg->nodes.data();
     RobOsageNode* j_begin = rob_osg->nodes.data() + 1;
     RobOsageNode* j_end = rob_osg->nodes.data() + rob_osg->nodes.size();
     for (RobOsageNode* j = j_begin; j != j_end; i++, j++) {
-        vec3 v74 = i->trans + vec3::normalize(v60) * (v16 * j->length);
+        vec3 v74 = i->pos + vec3::normalize(v60) * (parent_scale_x * j->length);
         if (a4 && j->sibling_node)
-            sub_140482F30(&v74, &j->sibling_node->trans, j->max_distance);
+            sub_140482F30(&v74, &j->sibling_node->pos, j->max_distance);
 
         skin_param_osage_node* v38 = &j->data_ptr->skp_osg_node;
         OsageCollision::osage_cls(coli_ring, v74, v38->coli_r);
         OsageCollision::osage_cls(coli, v74, v38->coli_r);
 
-        float_t v39 = v25 + v38->coli_r;
+        const float_t v39 = floor_height + v38->coli_r;
         if (v74.y < v39 && v39 < 1001.0f) {
             v74.y = v39;
-            v74 = vec3::normalize(v74 - i->trans) * (v16 * j->length) + i->trans;
+            v74 = vec3::normalize(v74 - i->pos) * (parent_scale_x * j->length) + i->pos;
         }
-        j->trans = v74;
-        j->trans_diff = 0.0f;
+        j->pos = v74;
+        j->delta_pos = 0.0f;
 
         vec3 direction;
-        mat4_inverse_transform_point(&v78, &j->trans, &direction);
+        mat4_inverse_transform_point(&v78, &j->pos, &direction);
 
         sub_140482FF0(v78, direction, &j->data_ptr->skp_osg_node.hinge,
             &j->reset_data.rotation, rob_osg->yz_order);
@@ -4022,18 +3990,18 @@ static void sub_14047F990(RobOsage* rob_osg, const mat4* root_matrix,
         if (j->bone_node_mat)
             mat4_scale_rot(&v78, parent_scale, j->bone_node_mat);
 
-        float_t v55 = vec3::distance(j->trans, i->trans);
-        float_t v56 = v16 * j->length;
+        float_t v55 = vec3::distance(j->pos, i->pos);
+        float_t v56 = parent_scale_x * j->length;
         if (v55 >= fabsf(v56))
             v56 = v55;
         mat4_mul_translate(&v78, v56, 0.0f, 0.0f, &v78);
-        mat4_get_translation(&v78, &j->trans);
-        v60 = j->trans - i->trans;
+        mat4_get_translation(&v78, &j->pos);
+        v60 = j->pos - i->pos;
     }
 
     if (rob_osg->nodes.size() && rob_osg->node.bone_node_mat) {
         mat4 v79 = *rob_osg->nodes.back().bone_node_ptr->ex_data_mat;
-        mat4_mul_translate(&v79, v16 * rob_osg->node.length, 0.0f, 0.0f, &v79);
+        mat4_mul_translate(&v79, parent_scale_x * rob_osg->node.length, 0.0f, 0.0f, &v79);
         *rob_osg->node.bone_node_ptr->ex_data_mat = v79;
         mat4_scale_rot(&v79, parent_scale, &v79);
         *rob_osg->node.bone_node_mat = v79;
@@ -4058,7 +4026,7 @@ static void sub_140480260(RobOsage* rob_osg, const mat4* root_matrix,
     rob_osg->prev_osage_reset = false;
 
     for (RobOsageNode& i : rob_osg->nodes) {
-        i.field_C8 = 0.0f;
+        i.hit = 0.0f;
         i.friction = 1.0f;
     }
 
diff --git a/src/CRE/rob/rob.cpp b/src/CRE/rob/rob.cpp
index 68f6c341..9957fe9e 100644
--- a/src/CRE/rob/rob.cpp
+++ b/src/CRE/rob/rob.cpp
@@ -101,11 +101,6 @@ struct osage_play_data_init_header {
     uint16_t nodes_count;
 };
 
-struct osage_play_data_init_node {
-    vec3 trans;
-    vec3 trans_diff;
-};
-
 struct osage_play_data_header {
     uint32_t signature;
     std::pair<uint16_t, uint16_t> obj_info;
@@ -429,7 +424,7 @@ struct rob_cmn_mottbl_header {
 };
 
 struct rob_chara_age_age_init_data {
-    vec3 trans;
+    vec3 pos;
     float_t rot_x;
     float_t offset;
     float_t gravity;
@@ -443,7 +438,7 @@ struct rob_chara_age_age_init_data {
 struct rob_chara_age_age_data {
     int32_t index;
     int32_t part_id;
-    vec3 trans;
+    vec3 pos;
     float_t field_14;
     float_t rot_z;
     int32_t field_1C;
@@ -485,7 +480,7 @@ struct rob_chara_age_age_object {
     int32_t vertex_array_size;
     obj_mesh_vertex_buffer obj_vert_buf;
     obj_mesh_index_buffer obj_index_buf;
-    vec3 trans[10];
+    vec3 pos[10];
     int32_t disp_count;
     int32_t count;
     bool field_C3C;
@@ -893,16 +888,16 @@ static float_t bone_data_limit_angle(float_t angle);
 static void bone_data_mult_0(bone_data* a1, int32_t skeleton_select);
 static void bone_data_mult_1(bone_data* a1, mat4* parent_mat, bone_data* a3, bool solve_ik);
 static bool bone_data_mult_1_ik(bone_data* a1, bone_data* a2);
-static void bone_data_mult_1_ik_hands(bone_data* a1, const vec3& trans);
-static void bone_data_mult_1_ik_hands_2(bone_data* a1, const vec3& trans, float_t angle_scale);
-static void bone_data_mult_1_ik_legs(bone_data* a1, const vec3& trans);
+static void bone_data_mult_1_ik_hands(bone_data* a1, const vec3& pos);
+static void bone_data_mult_1_ik_hands_2(bone_data* a1, const vec3& pos, float_t angle_scale);
+static void bone_data_mult_1_ik_legs(bone_data* a1, const vec3& pos);
 static bool bone_data_mult_1_exp_data(bone_data* a1, bone_node_expression_data* a2, bone_data* a3);
 static void bone_data_mult_ik(bone_data* a1, int32_t skeleton_select);
 
 static void bone_data_parent_data_init(bone_data_parent* bone,
     rob_chara_bone_data* rob_bone_data, const bone_database* bone_data);
 static void bone_data_parent_load_bone_database(bone_data_parent* bone,
-    const std::vector<bone_database_bone>* bones, const vec3* common_translation, const vec3* translation);
+    const std::vector<bone_database_bone>* bones, const vec3* common_position, const vec3* position);
 static void bone_data_parent_load_rob_chara(bone_data_parent* bone);
 
 static void mot_blend_interpolate(mot_blend* a1, std::vector<bone_data>& bones,
@@ -1086,7 +1081,7 @@ static void mothead_func_78(mothead_func_data* func_data,
     const void* data, const mothead_data* mhd_data, int32_t frame, const motion_database* mot_db);
 static void mothead_func_79_rob_chara_coli_ring(mothead_func_data* func_data,
     const void* data, const mothead_data* mhd_data, int32_t frame, const motion_database* mot_db);
-static void mothead_func_80_adjust_get_global_trans(mothead_func_data* func_data,
+static void mothead_func_80_adjust_get_global_pos(mothead_func_data* func_data,
     const void* data, const mothead_data* mhd_data, int32_t frame, const motion_database* mot_db);
 
 static void motion_blend_mot_interpolate(motion_blend_mot* a1);
@@ -1337,7 +1332,7 @@ static const mothead_func_struct mothead_func_array[] = {
     { mothead_func_77_disable_eye_motion, 0 },
     { mothead_func_78, 0 },
     { mothead_func_79_rob_chara_coli_ring, 0 },
-    { mothead_func_80_adjust_get_global_trans, 0 },
+    { mothead_func_80_adjust_get_global_pos, 0 },
 };
 
 static const struc_218 stru_140A24B50[] = {
@@ -2950,10 +2945,10 @@ uint32_t rob_chara::get_rob_cmn_mottbl_motion_id(int32_t id) {
     return -1;
 }
 
-float_t rob_chara::get_trans_scale(int32_t bone, vec3& trans) {
+float_t rob_chara::get_pos_scale(int32_t bone, vec3& pos) {
     if (bone < 0 || bone > 26)
         return 0.0f;
-    trans = data.field_1E68.field_DF8[bone].trans;
+    pos = data.field_1E68.field_DF8[bone].pos;
     return data.field_1E68.field_DF8[bone].scale;
 }
 
@@ -3428,7 +3423,7 @@ void rob_chara::load_motion(uint32_t motion_id, bool a3, float_t frame,
     data.adjust_data.offset_x = true;
     data.adjust_data.offset_y = false;
     data.adjust_data.offset_z = true;
-    data.adjust_data.get_global_trans = false;
+    data.adjust_data.get_global_pos = false;
 
     rob_chara_data_arm_adjust* arm_adjust = data.motion.arm_adjust;
     rob_chara_data_hand_adjust* hand_adjust = data.motion.hand_adjust;
@@ -3522,13 +3517,13 @@ static void rob_chara_bone_data_set_left_hand_scale(rob_chara_bone_data* rob_bon
     if (!kl_te_wj_mat)
         return;
 
-    vec3 trans;
-    mat4_get_translation(kl_te_wj_mat, &trans);
-    trans -= trans * scale;
+    vec3 pos;
+    mat4_get_translation(kl_te_wj_mat, &pos);
+    pos -= pos * scale;
 
     mat4 mat;
     mat4_scale(scale, scale, scale, &mat);
-    mat4_set_translation(&mat, &trans);
+    mat4_set_translation(&mat, &pos);
 
     for (int32_t i = ROB_BONE_KL_TE_L_WJ; i <= ROB_BONE_NL_OYA_C_L_WJ; i++) {
         mat4* m = rob_bone_data->get_mats_mat(i);
@@ -3548,13 +3543,13 @@ static void rob_chara_bone_data_set_right_hand_scale(rob_chara_bone_data* rob_bo
     if (!kl_te_wj_mat)
         return;
 
-    vec3 trans;
-    mat4_get_translation(kl_te_wj_mat, &trans);
-    trans -= trans * scale;
+    vec3 pos;
+    mat4_get_translation(kl_te_wj_mat, &pos);
+    pos -= pos * scale;
 
     mat4 mat;
     mat4_scale(scale, scale, scale, &mat);
-    mat4_set_translation(&mat, &trans);
+    mat4_set_translation(&mat, &pos);
 
     for (int32_t i = ROB_BONE_KL_TE_R_WJ; i <= ROB_BONE_NL_OYA_C_R_WJ; i++) {
         mat4* m = rob_bone_data->get_mats_mat(i);
@@ -3981,71 +3976,71 @@ static void sub_1405500F0(rob_chara* rob_chr) {
     }
 }
 
-static vec3* rob_chara_bone_data_get_global_trans(rob_chara_bone_data* rob_bone_data) {
-    return &rob_bone_data->motion_loaded.front()->bone_data.global_trans;
+static vec3* rob_chara_bone_data_get_global_position(rob_chara_bone_data* rob_bone_data) {
+    return &rob_bone_data->motion_loaded.front()->bone_data.global_position;
 }
 
-static void rob_chara_data_adjuct_set_trans(rob_chara_adjust_data* rob_chr_adj,
-    vec3& trans, bool pos_adjust, vec3* global_trans) {
+static void rob_chara_data_adjuct_set_pos(rob_chara_adjust_data* rob_chr_adj,
+    const vec3& pos, bool pos_adjust, const vec3* global_position) {
     float_t scale = rob_chr_adj->scale;
     float_t item_scale = rob_chr_adj->item_scale; // X
     vec3 _offset = rob_chr_adj->offset;
-    if (global_trans)
-        _offset.y += global_trans->y;
+    if (global_position)
+        _offset.y += global_position->y;
 
-    vec3 _trans = trans;
-    vec3 _item_trans = trans;
+    vec3 _pos = pos;
+    vec3 _item_pos = pos;
     if (rob_chr_adj->height_adjust) {
-        _trans.y += rob_chr_adj->pos_adjust_y;
-        _item_trans.y += rob_chr_adj->pos_adjust_y; // X
+        _pos.y += rob_chr_adj->pos_adjust_y;
+        _item_pos.y += rob_chr_adj->pos_adjust_y; // X
     }
     else {
-        vec3 temp = (_trans - _offset) * scale + _offset;
-        vec3 arm_temp = (_item_trans - _offset) * item_scale + _offset;
+        vec3 temp = (_pos - _offset) * scale + _offset;
+        vec3 arm_temp = (_item_pos - _offset) * item_scale + _offset;
 
         if (!rob_chr_adj->offset_x) {
-            _trans.x = temp.x;
-            _item_trans.x = arm_temp.x; // X
+            _pos.x = temp.x;
+            _item_pos.x = arm_temp.x; // X
         }
 
         if (!rob_chr_adj->offset_y) {
-            _trans.y = temp.y;
-            _item_trans.y = arm_temp.y; // X
+            _pos.y = temp.y;
+            _item_pos.y = arm_temp.y; // X
         }
 
         if (!rob_chr_adj->offset_z) {
-            _trans.z = temp.z;
-            _item_trans.z = arm_temp.z; // X
+            _pos.z = temp.z;
+            _item_pos.z = arm_temp.z; // X
         }
     }
 
     if (pos_adjust) {
-        _trans = rob_chr_adj->pos_adjust + _trans;
-        _item_trans = rob_chr_adj->pos_adjust + _item_trans; // X
+        _pos = rob_chr_adj->pos_adjust + _pos;
+        _item_pos = rob_chr_adj->pos_adjust + _item_pos; // X
     }
 
-    rob_chr_adj->trans = _trans - trans * scale;
-    rob_chr_adj->item_trans = _item_trans - trans * item_scale; // X
+    rob_chr_adj->pos = _pos - pos * scale;
+    rob_chr_adj->item_pos = _item_pos - pos * item_scale; // X
 }
 
 void rob_chara::set_data_adjust_mat(rob_chara_adjust_data* rob_chr_adj, bool pos_adjust) {
     mat4* mat = bone_data->get_mats_mat(ROB_BONE_N_HARA_CP);
 
-    vec3 trans;
-    mat4_get_translation(mat, &trans);
+    vec3 pos;
+    mat4_get_translation(mat, &pos);
 
-    vec3* global_trans = 0;
-    if (rob_chr_adj->get_global_trans)
-        global_trans = rob_chara_bone_data_get_global_trans(bone_data);
-    rob_chara_data_adjuct_set_trans(rob_chr_adj, trans, pos_adjust, global_trans);
+    vec3* global_position = 0;
+    if (rob_chr_adj->get_global_pos)
+        global_position = rob_chara_bone_data_get_global_position(bone_data);
+    rob_chara_data_adjuct_set_pos(rob_chr_adj, pos, pos_adjust, global_position);
 
     float_t scale = rob_chr_adj->scale;
     mat4_scale(scale, scale, scale, &rob_chr_adj->mat);
-    mat4_set_translation(&rob_chr_adj->mat, &rob_chr_adj->trans);
+    mat4_set_translation(&rob_chr_adj->mat, &rob_chr_adj->pos);
 
     float_t item_scale = rob_chr_adj->item_scale; // X
     mat4_scale(item_scale, item_scale, item_scale, &rob_chr_adj->item_mat);
-    mat4_set_translation(&rob_chr_adj->item_mat, &rob_chr_adj->item_trans);
+    mat4_set_translation(&rob_chr_adj->item_mat, &rob_chr_adj->item_pos);
 }
 
 void rob_chara::set_data_miku_rot_position(const vec3& value) {
@@ -5006,28 +5001,28 @@ void rob_chara::sub_140509D30() {
 
         float_t chara_scale = data.adjust_data.scale;
 
-        vec3 v23 = *(vec3*)&v42->row3 * chara_scale + data.adjust_data.trans;
+        vec3 v23 = *(vec3*)&v42->row3 * chara_scale + data.adjust_data.pos;
         *(vec3*)&v42->row3 = v23;
 
-        vec3 v29 = *(vec3*)&v43->row3 * chara_scale + data.adjust_data.trans;
+        vec3 v29 = *(vec3*)&v43->row3 * chara_scale + data.adjust_data.pos;
         *(vec3*)&v43->row3 = v29;
 
         float_t v20 = v3->scale * chara_scale;
         v39->scale = v20;
         v39->field_24 = v20;
-        v39->prev_trans = v39->trans;
-        v39->trans = v23;
+        v39->prev_pos = v39->pos;
+        v39->pos = v23;
 
         float_t v19 = v6->scale * chara_scale;
         v40->scale = v19;
         v40->field_24 = v19;
-        v40->prev_trans = v40->trans;
-        v40->trans = v29;
+        v40->prev_pos = v40->pos;
+        v40->pos = v29;
 
         v41->scale = v19;
         v41->field_24 = v19;
-        v41->prev_trans = v41->trans;
-        v41->trans = v29;
+        v41->prev_pos = v41->pos;
+        v41->pos = v29;
 
         v39++;
         v40++;
@@ -5338,12 +5333,12 @@ static void bone_data_mult_0(bone_data* a1, int32_t skeleton_select) {
         mat = mat4_identity;
 
     if (a1->type == BONE_DATABASE_BONE_POSITION) {
-        mat4_mul_translate(&mat, &a1->trans, &mat);
+        mat4_mul_translate(&mat, &a1->position, &mat);
         a1->rot_mat[0] = mat4_identity;
     }
     else if (a1->type == BONE_DATABASE_BONE_TYPE_1) {
-        mat4_inverse_transform_point(&mat, &a1->trans, &a1->trans);
-        mat4_mul_translate(&mat, &a1->trans, &mat);
+        mat4_inverse_transform_point(&mat, &a1->position, &a1->position);
+        mat4_mul_translate(&mat, &a1->position, &mat);
         a1->rot_mat[0] = mat4_identity;
     }
     else {
@@ -5359,11 +5354,11 @@ static void bone_data_mult_0(bone_data* a1, int32_t skeleton_select) {
         if (a1->type == BONE_DATABASE_BONE_POSITION_ROTATION)
             mat4_mul_rotate_zyx(&a1->rot_mat[0], &a1->rotation, &rot_mat);
         else {
-            a1->trans = a1->base_translation[skeleton_select];
+            a1->position = a1->base_position[skeleton_select];
             mat4_rotate_zyx(&a1->rotation, &rot_mat);
         }
 
-        mat4_mul_translate(&mat, &a1->trans, &mat);
+        mat4_mul_translate(&mat, &a1->position, &mat);
         mat4_mul(&rot_mat, &mat, &mat);
         a1->rot_mat[0] = rot_mat;
     }
@@ -5382,9 +5377,9 @@ static void bone_data_mult_1(bone_data* a1, mat4* parent_mat, bone_data* a3, boo
 
     if (a1->type != BONE_DATABASE_BONE_TYPE_1 && a1->type != BONE_DATABASE_BONE_POSITION) {
         if (a1->type != BONE_DATABASE_BONE_POSITION_ROTATION)
-            a1->trans = a1->base_translation[1];
+            a1->position = a1->base_position[1];
 
-        mat4_mul_translate(&mat, &a1->trans, &mat);
+        mat4_mul_translate(&mat, &a1->position, &mat);
         if (solve_ik) {
             a1->node[0].exp_data.rotation = 0.0f;
             if (!a1->check_flags_not_null())
@@ -5410,14 +5405,14 @@ static void bone_data_mult_1(bone_data* a1, mat4* parent_mat, bone_data* a3, boo
         mat4_mul(&a1->rot_mat[0], &mat, &mat);
     }
     else {
-        mat4_mul_translate(&mat, &a1->trans, &mat);
+        mat4_mul_translate(&mat, &a1->position, &mat);
         if (solve_ik)
             a1->node[0].exp_data.rotation = 0.0f;
     }
 
     *a1->node[0].mat = mat;
     if (solve_ik) {
-        a1->node[0].exp_data.position = a1->trans;
+        a1->node[0].exp_data.position = a1->position;
         a1->node[0].exp_data.reset_scale();
     }
 
@@ -5461,47 +5456,47 @@ static void bone_data_mult_1(bone_data* a1, mat4* parent_mat, bone_data* a3, boo
 }
 
 static bool bone_data_mult_1_ik(bone_data* a1, bone_data* a2) {
-    vec3 trans;
+    vec3 pos;
 
     switch (a1->motion_bone_index) {
     case MOTION_BONE_N_SKATA_L_WJ_CD_EX:
-        mat4_get_translation(a2[MOTION_BONE_C_KATA_L].node[2].mat, &trans);
-        bone_data_mult_1_ik_hands(a1, trans);
+        mat4_get_translation(a2[MOTION_BONE_C_KATA_L].node[2].mat, &pos);
+        bone_data_mult_1_ik_hands(a1, pos);
         break;
     case MOTION_BONE_N_SKATA_R_WJ_CD_EX:
-        mat4_get_translation(a2[MOTION_BONE_C_KATA_R].node[2].mat, &trans);
-        bone_data_mult_1_ik_hands(a1, trans);
+        mat4_get_translation(a2[MOTION_BONE_C_KATA_R].node[2].mat, &pos);
+        bone_data_mult_1_ik_hands(a1, pos);
         break;
     case MOTION_BONE_N_SKATA_B_L_WJ_CD_CU_EX:
-        mat4_get_translation(a2[MOTION_BONE_N_UP_KATA_L_EX].node[0].mat, &trans);
-        bone_data_mult_1_ik_hands_2(a1, trans, 0.333f);
+        mat4_get_translation(a2[MOTION_BONE_N_UP_KATA_L_EX].node[0].mat, &pos);
+        bone_data_mult_1_ik_hands_2(a1, pos, 0.333f);
         break;
     case MOTION_BONE_N_SKATA_B_R_WJ_CD_CU_EX:
-        mat4_get_translation(a2[MOTION_BONE_N_UP_KATA_R_EX].node[0].mat, &trans);
-        bone_data_mult_1_ik_hands_2(a1, trans, 0.333f);
+        mat4_get_translation(a2[MOTION_BONE_N_UP_KATA_R_EX].node[0].mat, &pos);
+        bone_data_mult_1_ik_hands_2(a1, pos, 0.333f);
         break;
     case MOTION_BONE_N_SKATA_C_L_WJ_CD_CU_EX:
-        mat4_get_translation(a2[MOTION_BONE_N_UP_KATA_L_EX].node[0].mat, &trans);
-        bone_data_mult_1_ik_hands_2(a1, trans, 0.5f);
+        mat4_get_translation(a2[MOTION_BONE_N_UP_KATA_L_EX].node[0].mat, &pos);
+        bone_data_mult_1_ik_hands_2(a1, pos, 0.5f);
         break;
     case MOTION_BONE_N_SKATA_C_R_WJ_CD_CU_EX:
-        mat4_get_translation(a2[MOTION_BONE_N_UP_KATA_R_EX].node[0].mat, &trans);
-        bone_data_mult_1_ik_hands_2(a1, trans, 0.5f);
+        mat4_get_translation(a2[MOTION_BONE_N_UP_KATA_R_EX].node[0].mat, &pos);
+        bone_data_mult_1_ik_hands_2(a1, pos, 0.5f);
         break;
     case MOTION_BONE_N_MOMO_A_L_WJ_CD_EX:
-        mat4_get_translation(a2[MOTION_BONE_CL_MOMO_L].node[2].mat, &trans);
-        mat4_inverse_transform_point(a1->node[0].mat, &trans, &trans);
-        bone_data_mult_1_ik_legs(a1, -trans);
+        mat4_get_translation(a2[MOTION_BONE_CL_MOMO_L].node[2].mat, &pos);
+        mat4_inverse_transform_point(a1->node[0].mat, &pos, &pos);
+        bone_data_mult_1_ik_legs(a1, -pos);
         break;
     case MOTION_BONE_N_MOMO_A_R_WJ_CD_EX:
-        mat4_get_translation(a2[MOTION_BONE_CL_MOMO_R].node[2].mat, &trans);
-        mat4_inverse_transform_point(a1->node[0].mat, &trans, &trans);
-        bone_data_mult_1_ik_legs(a1, -trans);
+        mat4_get_translation(a2[MOTION_BONE_CL_MOMO_R].node[2].mat, &pos);
+        mat4_inverse_transform_point(a1->node[0].mat, &pos, &pos);
+        bone_data_mult_1_ik_legs(a1, -pos);
         break;
     case MOTION_BONE_N_HARA_CD_EX:
-        mat4_get_translation(a2[MOTION_BONE_KL_MUNE_B_WJ].node[0].mat, &trans);
-        mat4_inverse_transform_point(a1->node[0].mat, &trans, &trans);
-        bone_data_mult_1_ik_legs(a1, trans);
+        mat4_get_translation(a2[MOTION_BONE_KL_MUNE_B_WJ].node[0].mat, &pos);
+        mat4_inverse_transform_point(a1->node[0].mat, &pos, &pos);
+        bone_data_mult_1_ik_legs(a1, pos);
         break;
     default:
         return false;
@@ -5509,9 +5504,9 @@ static bool bone_data_mult_1_ik(bone_data* a1, bone_data* a2) {
     return true;
 }
 
-static void bone_data_mult_1_ik_hands(bone_data* a1, const vec3& trans) {
+static void bone_data_mult_1_ik_hands(bone_data* a1, const vec3& pos) {
     vec3 v15;
-    mat4_inverse_transform_point(a1->node[0].mat, &trans, &v15);
+    mat4_inverse_transform_point(a1->node[0].mat, &pos, &v15);
 
     float_t len;
     len = vec3::length_squared(v15);
@@ -5545,9 +5540,9 @@ static void bone_data_mult_1_ik_hands(bone_data* a1, const vec3& trans) {
     mat4_mul(&rot_mat, a1->node[0].mat, a1->node[0].mat);
 }
 
-static void bone_data_mult_1_ik_hands_2(bone_data* a1, const vec3& trans, float_t angle_scale) {
+static void bone_data_mult_1_ik_hands_2(bone_data* a1, const vec3& pos, float_t angle_scale) {
     vec3 v8;
-    mat4_inverse_transform_point(a1->node[0].mat, &trans, &v8);
+    mat4_inverse_transform_point(a1->node[0].mat, &pos, &v8);
     v8.x = 0.0f;
 
     float_t len = vec3::length(v8);
@@ -5559,8 +5554,8 @@ static void bone_data_mult_1_ik_hands_2(bone_data* a1, const vec3& trans, float_
     mat4_mul_rotate_x(a1->node[0].mat, angle * angle_scale, a1->node[0].mat);
 }
 
-static void bone_data_mult_1_ik_legs(bone_data* a1, const vec3& trans) {
-    vec3 v9 = trans;
+static void bone_data_mult_1_ik_legs(bone_data* a1, const vec3& pos) {
+    vec3 v9 = pos;
 
     float_t len;
     len = vec3::length_squared(v9);
@@ -5806,18 +5801,18 @@ static void bone_data_parent_data_init(bone_data_parent* bone,
     const char* base_name = bone_database_skeleton_type_to_string(rob_bone_data->base_skeleton_type);
     const char* name = bone_database_skeleton_type_to_string(rob_bone_data->skeleton_type);
     const std::vector<bone_database_bone>* common_bones = bone_data->get_skeleton_bones(base_name);
-    const std::vector<vec3>* common_translation = bone_data->get_skeleton_positions(base_name);
-    const std::vector<vec3>* translation = bone_data->get_skeleton_positions(name);
-    if (!common_bones || !common_translation || !translation)
+    const std::vector<vec3>* common_position = bone_data->get_skeleton_positions(base_name);
+    const std::vector<vec3>* position = bone_data->get_skeleton_positions(name);
+    if (!common_bones || !common_position || !position)
         return;
 
     bone->rob_bone_data = rob_bone_data;
     bone_data_parent_load_rob_chara(bone);
-    bone_data_parent_load_bone_database(bone, common_bones, common_translation->data(), translation->data());
+    bone_data_parent_load_bone_database(bone, common_bones, common_position->data(), position->data());
 }
 
 static void bone_data_parent_load_bone_database(bone_data_parent* bone,
-    const std::vector<bone_database_bone>* bones, const vec3* common_translation, const vec3* translation) {
+    const std::vector<bone_database_bone>* bones, const vec3* common_position, const vec3* position) {
     rob_chara_bone_data* rob_bone_data = bone->rob_bone_data;
     size_t chain_pos = 0;
     size_t total_bone_count = 0;
@@ -5834,8 +5829,8 @@ static void bone_data_parent_load_bone_database(bone_data_parent* bone,
             bone_node->key_set_count = 6;
         else
             bone_node->key_set_count = 3;
-        bone_node->base_translation[0] = *common_translation++;
-        bone_node->base_translation[1] = *translation++;
+        bone_node->base_position[0] = *common_position++;
+        bone_node->base_position[1] = *position++;
         bone_node->node = &rob_bone_data->nodes[total_bone_count];
         bone_node->has_parent = i.has_parent;
         if (i.has_parent)
@@ -5857,8 +5852,8 @@ static void bone_data_parent_load_bone_database(bone_data_parent* bone,
             total_bone_count++;
             break;
         case BONE_DATABASE_BONE_HEAD_IK_ROTATION:
-            bone_node->ik_segment_length[0] = (common_translation++)->x;
-            bone_node->ik_segment_length[1] = (translation++)->x;
+            bone_node->ik_segment_length[0] = (common_position++)->x;
+            bone_node->ik_segment_length[1] = (position++)->x;
 
             chain_pos += 2;
             ik_bone_count++;
@@ -5866,10 +5861,10 @@ static void bone_data_parent_load_bone_database(bone_data_parent* bone,
             break;
         case BONE_DATABASE_BONE_ARM_IK_ROTATION:
         case BONE_DATABASE_BONE_LEGS_IK_ROTATION:
-            bone_node->ik_segment_length[0] = (common_translation++)->x;
-            bone_node->ik_segment_length[1] = (translation++)->x;
-            bone_node->ik_2nd_segment_length[0] = (common_translation++)->x;
-            bone_node->ik_2nd_segment_length[1] = (translation++)->x;
+            bone_node->ik_segment_length[0] = (common_position++)->x;
+            bone_node->ik_segment_length[1] = (position++)->x;
+            bone_node->ik_2nd_segment_length[0] = (common_position++)->x;
+            bone_node->ik_2nd_segment_length[1] = (position++)->x;
 
             mat4* pole_target = 0;
             if (i.pole_target)
@@ -7317,9 +7312,9 @@ static void mothead_func_79_rob_chara_coli_ring(mothead_func_data* func_data,
     //rob_chara_set_coli_ring(func_data->rob_chr, ((int8_t*)data)[0]);
 }
 
-static void mothead_func_80_adjust_get_global_trans(mothead_func_data* func_data,
+static void mothead_func_80_adjust_get_global_pos(mothead_func_data* func_data,
     const void* data, const mothead_data* mhd_data, int32_t frame, const motion_database* mot_db) {
-    func_data->rob_chr_data->adjust_data.get_global_trans = ((uint8_t*)data)[0];
+    func_data->rob_chr_data->adjust_data.get_global_pos = ((uint8_t*)data)[0];
 }
 
 static void motion_blend_mot_interpolate(motion_blend_mot* a1) {
@@ -7351,26 +7346,26 @@ static void motion_blend_mot_interpolate(motion_blend_mot* a1) {
     }
 
     keyframe_data = (vec3*)&a1->mot_key_data.key_set_data.data()[bone_key_set_count];
-    vec3 global_trans = reverse ? -keyframe_data[0] : keyframe_data[0];
+    vec3 global_position = reverse ? -keyframe_data[0] : keyframe_data[0];
     vec3 global_rotation = keyframe_data[1];
-    a1->bone_data.global_trans = global_trans;
+    a1->bone_data.global_position = global_position;
     a1->bone_data.global_rotation = global_rotation;
 
     float_t rot_y = a1->bone_data.rot_y;
     mat4 mat;
     mat4_rotate_y(rot_y, &mat);
-    mat4_mul_translate(&mat, &global_trans, &mat);
+    mat4_mul_translate(&mat, &global_position, &mat);
     mat4_mul_rotate_zyx(&mat, &global_rotation, &mat);
     for (bone_data& i : a1->bone_data.bones)
         switch (i.type) {
         case BONE_DATABASE_BONE_TYPE_1:
-            mat4_transform_point(&mat, &i.trans, &i.trans);
+            mat4_transform_point(&mat, &i.position, &i.position);
             break;
         case BONE_DATABASE_BONE_POSITION_ROTATION: {
             mat4 rot_mat;
             mat4_clear_trans(&mat, &rot_mat);
             i.rot_mat[0] = rot_mat;
-            mat4_transform_point(&mat, &i.trans, &i.trans);
+            mat4_transform_point(&mat, &i.position, &i.position);
         } break;
         case BONE_DATABASE_BONE_HEAD_IK_ROTATION:
         case BONE_DATABASE_BONE_ARM_IK_ROTATION:
@@ -7553,7 +7548,7 @@ static void sub_140412E10(motion_blend_mot* a1, int32_t skeleton_select) {
             & a1->field_0.field_8.bitfield.data()[i.motion_bone_index >> 5]) {
             i.store_curr_rot_trans(skeleton_select);
             if (i.type == BONE_DATABASE_BONE_POSITION_ROTATION && (a1->field_4F8.field_0 & 0x02))
-                i.trans_prev[skeleton_select] += a1->field_4F8.field_90;
+                i.position_prev[skeleton_select] += a1->field_4F8.field_90;
         }
 }
 
@@ -8447,13 +8442,13 @@ static object_info sub_140550310(rob_chara* rob_chr) {
     return rob_chr->data.motion.field_150.face_object;
 }
 
-static void sub_140412DA0(motion_blend_mot* a1, vec3* trans) {
+static void sub_140412DA0(motion_blend_mot* a1, vec3* position) {
     if (a1->bone_data.bones.size())
-        *trans = a1->bone_data.bones.front().trans;
+        *position = a1->bone_data.bones.front().position;
 }
 
-static void sub_140419800(rob_chara_bone_data* rob_bone_data, vec3* trans) {
-    sub_140412DA0(rob_bone_data->motion_loaded.front(), trans);
+static void sub_140419800(rob_chara_bone_data* rob_bone_data, vec3* position) {
+    sub_140412DA0(rob_bone_data->motion_loaded.front(), position);
 }
 
 static float_t sub_1405501F0(rob_chara* rob_chr) {
@@ -8743,9 +8738,9 @@ static void rob_disp_rob_chara_ctrl_thread_main(rob_chara* rob_chr) {
 
     rob_chr->item_equip->set_opd_blend_data(&rob_chr->bone_data->motion_loaded);
 
-    vec3 trans = 0.0f;
-    rob_chr->get_trans_scale(0, trans);
-    rob_chr->item_equip->position = trans;
+    vec3 pos = 0.0f;
+    rob_chr->get_pos_scale(0, pos);
+    rob_chr->item_equip->position = pos;
     rob_chara_item_equip_ctrl(rob_chr->item_equip);
     if (rob_chr->check_for_ageageagain_module()) {
         rob_chara_age_age_array_set_step(rob_chr->chara_id, 1, rob_chr->item_equip->osage_step);
@@ -10284,17 +10279,17 @@ static void rob_chara_bone_data_ik_scale_calculate(
     ::bone_data* b_c_kata_l = &bones[MOTION_BONE_C_KATA_L];
     ::bone_data* b_cl_momo_l = &bones[MOTION_BONE_CL_MOMO_L];
 
-    float_t base_height = fabsf(b_cl_momo_l->base_translation[0].y) + b_cl_momo_l->ik_segment_length[0]
+    float_t base_height = fabsf(b_cl_momo_l->base_position[0].y) + b_cl_momo_l->ik_segment_length[0]
         + b_cl_momo_l->ik_2nd_segment_length[0] + *base_heel_height;
-    float_t height = fabsf(b_cl_momo_l->base_translation[1].y) + b_cl_momo_l->ik_segment_length[1]
+    float_t height = fabsf(b_cl_momo_l->base_position[1].y) + b_cl_momo_l->ik_segment_length[1]
         + b_cl_momo_l->ik_2nd_segment_length[1] + *heel_height;
     ik_scale->ratio0 = height / base_height;
-    ik_scale->ratio1 = (fabsf(b_kl_kubi->base_translation[1].y) + b_cl_mune->ik_segment_length[1])
-        / (fabsf(b_kl_kubi->base_translation[0].y) + b_cl_mune->ik_segment_length[0]);
+    ik_scale->ratio1 = (fabsf(b_kl_kubi->base_position[1].y) + b_cl_mune->ik_segment_length[1])
+        / (fabsf(b_kl_kubi->base_position[0].y) + b_cl_mune->ik_segment_length[0]);
     ik_scale->ratio2 = (b_c_kata_l->ik_segment_length[1] + b_c_kata_l->ik_2nd_segment_length[1])
         / (b_c_kata_l->ik_segment_length[0] + b_c_kata_l->ik_2nd_segment_length[0]);
-    ik_scale->ratio3 = (fabsf(b_kl_kubi->base_translation[1].y) + b_cl_mune->ik_segment_length[1] + height)
-        / (fabsf(b_kl_kubi->base_translation[0].y) + b_cl_mune->ik_segment_length[0] + base_height);
+    ik_scale->ratio3 = (fabsf(b_kl_kubi->base_position[1].y) + b_cl_mune->ik_segment_length[1] + height)
+        / (fabsf(b_kl_kubi->base_position[0].y) + b_cl_mune->ik_segment_length[0] + base_height);
 }
 
 static void mot_key_data_reserve_key_sets_by_skeleton_type(mot_key_data* a1,
@@ -11041,24 +11036,24 @@ static void sub_14040FBF0(motion_blend_mot* a1, float_t a2) {
     float_t v8 = a1->field_4F8.field_C0;
     float_t v9 = a1->field_4F8.field_C4;
     vec3 v10 = a1->field_4F8.field_C8;
-    a1->field_4F8.field_A8 = b_n_hara_cp->trans;
+    a1->field_4F8.field_A8 = b_n_hara_cp->position;
     if (!a1->mot_key_data.skeleton_select) {
         if (a2 != v9) {
-            b_n_hara_cp->trans.x = (b_n_hara_cp->trans.x - v10.x) * v9 + v10.x;
-            b_n_hara_cp->trans.z = (b_n_hara_cp->trans.z - v10.z) * v9 + v10.z;
+            b_n_hara_cp->position.x = (b_n_hara_cp->position.x - v10.x) * v9 + v10.x;
+            b_n_hara_cp->position.z = (b_n_hara_cp->position.z - v10.z) * v9 + v10.z;
         }
-        b_n_hara_cp->trans.y = ((b_n_hara_cp->trans.y - v10.y) * v8) + v10.y;
+        b_n_hara_cp->position.y = ((b_n_hara_cp->position.y - v10.y) * v8) + v10.y;
     }
     else {
         if (a2 != v9) {
             v9 /= a2;
-            b_n_hara_cp->trans.x = (b_n_hara_cp->trans.x - v10.x) * v9 + v10.x;
-            b_n_hara_cp->trans.z = (b_n_hara_cp->trans.z - v10.z) * v9 + v10.z;
+            b_n_hara_cp->position.x = (b_n_hara_cp->position.x - v10.x) * v9 + v10.x;
+            b_n_hara_cp->position.z = (b_n_hara_cp->position.z - v10.z) * v9 + v10.z;
         }
 
         if (a2 != v8) {
             v8 /= a2;
-            b_n_hara_cp->trans.y = (b_n_hara_cp->trans.y - v10.y) * v8 + v10.y;
+            b_n_hara_cp->position.y = (b_n_hara_cp->position.y - v10.y) * v8 + v10.y;
         }
     }
 }
@@ -11151,10 +11146,10 @@ static void sub_1404182B0(rob_chara_bone_data* rob_bone_data) {
     sub_140410CB0(&rob_bone_data->eyelid, &v3->bone_data.bones);
 
     bone_data* v7 = &v3->bone_data.bones.data()[0];
-    v3->field_4F8.field_9C = v7->trans;
+    v3->field_4F8.field_9C = v7->position;
     if (sub_140413790(&v3->field_4F8)) { // WTF???
-        v3->field_4F8.field_90 = v7->trans;
-        v7->trans -= v7->trans;
+        v3->field_4F8.field_90 = v7->position;
+        v7->position -= v7->position;
     }
 }
 
@@ -12022,8 +12017,7 @@ eyes_adjust::eyes_adjust() : xrot_adjust(), base_adjust() {
 }
 
 bone_data::bone_data() : type(), has_parent(), motion_bone_index(), mirror(), parent(),
-flags(), key_set_offset(), key_set_count(), frame(), base_translation(), rotation(),
-ik_target(), trans(), rot_mat(), trans_prev(), rot_mat_prev(), pole_target_mat(),
+flags(), key_set_offset(), key_set_count(), frame(), ik_target(), pole_target_mat(),
 parent_mat(), node(), ik_segment_length(), ik_2nd_segment_length(), arm_length() {
     eyes_xrot_adjust_neg = 1.0f;
     eyes_xrot_adjust_pos = 1.0f;
@@ -12037,8 +12031,8 @@ void bone_data::copy_rot_trans(bone_data* data) {
     case BONE_DATABASE_BONE_TYPE_1:
     case BONE_DATABASE_BONE_POSITION:
     case BONE_DATABASE_BONE_POSITION_ROTATION:
-        trans = data->trans;
-        trans_prev[0] = data->trans_prev[0];
+        position = data->position;
+        position_prev[0] = data->position_prev[0];
         break;
     }
 
@@ -12076,9 +12070,9 @@ vec3* bone_data::set_key_data(vec3* keyframe_data,
     bone_database_skeleton_type skeleton_type, bool get_data, bool reverse_x) {
     if (type == BONE_DATABASE_BONE_POSITION_ROTATION) {
         if (get_data) {
-            trans = *keyframe_data;
+            position = *keyframe_data;
             if (reverse_x)
-                trans.x = -trans.x;
+                position.x = -position.x;
         }
         keyframe_data++;
     }
@@ -12094,9 +12088,9 @@ vec3* bone_data::set_key_data(vec3* keyframe_data,
 
     if (get_data) {
         if (type == BONE_DATABASE_BONE_TYPE_1 || type == BONE_DATABASE_BONE_POSITION) {
-            trans = *keyframe_data;
+            position = *keyframe_data;
             if (reverse_x)
-                trans.x = -trans.x;
+                position.x = -position.x;
         }
         else if (!flags) {
             rotation = *keyframe_data;
@@ -12124,7 +12118,7 @@ void bone_data::store_curr_rot_trans(int32_t skeleton_select) {
     case BONE_DATABASE_BONE_TYPE_1:
     case BONE_DATABASE_BONE_POSITION:
     case BONE_DATABASE_BONE_POSITION_ROTATION:
-        trans_prev[skeleton_select] = trans;
+        position_prev[skeleton_select] = position;
         break;
     }
 
@@ -12151,7 +12145,7 @@ void bone_data::store_curr_rot_trans(int32_t skeleton_select) {
 }
 
 bone_data_parent::bone_data_parent() : rob_bone_data(),
-motion_bone_count(), ik_bone_count(), chain_pos(), global_trans(),
+motion_bone_count(), ik_bone_count(), chain_pos(), global_position(),
 global_rotation(), bone_key_set_count(), global_key_set_count(), rot_y() {
 
 }
@@ -12316,15 +12310,16 @@ void MotionBlendCross::Blend(bone_data* curr, bone_data* prev) {
         break;
     case BONE_DATABASE_BONE_TYPE_1:
     case BONE_DATABASE_BONE_POSITION:
-        curr->trans = vec3::lerp(prev->trans, curr->trans, blend);
+        curr->position = vec3::lerp(prev->position, curr->position, blend);
         break;
     case BONE_DATABASE_BONE_POSITION_ROTATION:
         if (trans_xz) {
-            curr->trans.x = lerp_def(prev->trans.x, curr->trans.x, blend);
-            curr->trans.z = lerp_def(prev->trans.z, curr->trans.z, blend);
+            curr->position.x = lerp_def(prev->position.x, curr->position.x, blend);
+            curr->position.z = lerp_def(prev->position.z, curr->position.z, blend);
         }
+
         if (trans_y)
-            curr->trans.y = lerp_def(prev->trans.y, curr->trans.y, blend);
+            curr->position.y = lerp_def(prev->position.y, curr->position.y, blend);
         break;
     case BONE_DATABASE_BONE_HEAD_IK_ROTATION:
         if (curr->motion_bone_index == MOTION_BONE_CL_MUNE) {
@@ -12493,15 +12488,16 @@ void MotionBlendFreeze::Blend(bone_data* curr, bone_data* prev) {
         break;
     case BONE_DATABASE_BONE_TYPE_1:
     case BONE_DATABASE_BONE_POSITION:
-        curr->trans = vec3::lerp(curr->trans_prev[field_24], curr->trans, blend);
+        curr->position = vec3::lerp(curr->position_prev[field_24], curr->position, blend);
         break;
     case BONE_DATABASE_BONE_POSITION_ROTATION:
         if (trans_xz) {
-            curr->trans.x = lerp_def(curr->trans_prev[field_24].x, curr->trans.x, blend);
-            curr->trans.z = lerp_def(curr->trans_prev[field_24].z, curr->trans.z, blend);
+            curr->position.x = lerp_def(curr->position_prev[field_24].x, curr->position.x, blend);
+            curr->position.z = lerp_def(curr->position_prev[field_24].z, curr->position.z, blend);
         }
+
         if (trans_y)
-            curr->trans.y = lerp_def(curr->trans_prev[field_24].y, curr->trans.y, blend);
+            curr->position.y = lerp_def(curr->position_prev[field_24].y, curr->position.y, blend);
         break;
     case BONE_DATABASE_BONE_HEAD_IK_ROTATION:
         if (curr->motion_bone_index == MOTION_BONE_CL_MUNE) {
@@ -12579,11 +12575,11 @@ void PartialMotionBlendFreeze::Blend(bone_data* curr, bone_data* prev) {
         break;
     case BONE_DATABASE_BONE_POSITION:
     case BONE_DATABASE_BONE_TYPE_1:
-        curr->trans = vec3::lerp(curr->trans_prev[0], curr->trans, blend);
+        curr->position = vec3::lerp(curr->position_prev[0], curr->position, blend);
         break;
     case BONE_DATABASE_BONE_POSITION_ROTATION:
         mat4_lerp_rotation(&curr->rot_mat_prev[0][0], &curr->rot_mat[0], &curr->rot_mat[0], blend);
-        curr->trans = vec3::lerp(curr->trans_prev[0], curr->trans, blend);
+        curr->position = vec3::lerp(curr->position_prev[0], curr->position, blend);
         break;
     case BONE_DATABASE_BONE_ARM_IK_ROTATION:
     case BONE_DATABASE_BONE_LEGS_IK_ROTATION:
@@ -15620,7 +15616,7 @@ void rob_chara_data_miku_rot::reset() {
 }
 
 rob_chara_adjust_data::rob_chara_adjust_data() : scale(), height_adjust(), pos_adjust_y(),
-offset_x(), offset_y(), offset_z(), get_global_trans(), left_hand_scale(), right_hand_scale(),
+offset_x(), offset_y(), offset_z(), get_global_pos(), left_hand_scale(), right_hand_scale(),
 left_hand_scale_default(), right_hand_scale_default(), item_scale() {
     reset();
 }
@@ -15634,13 +15630,13 @@ void rob_chara_adjust_data::reset() {
     offset_x = true;
     offset_y = false;
     offset_z = true;
-    get_global_trans = false;
-    mat4_translate(&trans, &mat);
+    get_global_pos = false;
+    mat4_translate(&pos, &mat);
     left_hand_scale = -1.0f;
     right_hand_scale = -1.0f;
     left_hand_scale_default = -1.0f;
     right_hand_scale_default = -1.0f;
-    mat4_translate(&item_trans, &item_mat);
+    mat4_translate(&item_pos, &item_mat); // X
     item_scale = 1.0f; // X
 }
 
@@ -15653,9 +15649,9 @@ pos_scale::pos_scale() : scale() {
 }
 
 float_t pos_scale::get_screen_pos_scale(const mat4& mat,
-    const vec3& trans, float_t scale, bool apply_offset) {
+    const vec3& pos, float_t scale, bool apply_offset) {
     vec4 v19;
-    *(vec3*)&v19 = trans;
+    *(vec3*)&v19 = pos;
     v19.w = 1.0f;
     mat4_transform_vector(&mat, &v19, &v19);
 
@@ -15670,13 +15666,13 @@ float_t pos_scale::get_screen_pos_scale(const mat4& mat,
             v14 += (float_t)res_wind_int->x_offset;
             v15 += (float_t)(res_wind->height - res_wind_int->y_offset - res_wind_int->height);
         }
-        pos.x = v14;
-        pos.y = v15;
+        this->pos.x = v14;
+        this->pos.y = v15;
         this->scale = -v19.w;
         return fabsf(1.0f / v19.w) * (rctx_ptr->camera->depth * scale);
     }
     else {
-        pos = 0.0f;
+        this->pos = 0.0f;
         this->scale = 0.0f;
         return 0.0f;
     }
@@ -16579,9 +16575,9 @@ void opd_chara_data::add_frame_data() {
             RobOsageNode* k_end = j->rob.nodes.data() + j->rob.nodes.size();
             size_t l = 0;
             for (RobOsageNode* k = k_begin; k != k_end; k++, l++) {
-                opd_node_data.data()[l].x.data()[frame_index] = k->reset_data.trans.x;
-                opd_node_data.data()[l].y.data()[frame_index] = k->reset_data.trans.y;
-                opd_node_data.data()[l].z.data()[frame_index] = k->reset_data.trans.z;
+                opd_node_data.data()[l].x.data()[frame_index] = k->reset_data.pos.x;
+                opd_node_data.data()[l].y.data()[frame_index] = k->reset_data.pos.y;
+                opd_node_data.data()[l].z.data()[frame_index] = k->reset_data.pos.z;
             }
         }
 
@@ -16592,9 +16588,9 @@ void opd_chara_data::add_frame_data() {
             CLOTHNode* k_end = j->rob.nodes.data() + j->rob.nodes.size();
             size_t l = 0;
             for (CLOTHNode* k = k_begin; k != k_end; k++, l++) {
-                opd_node_data.data()[l].x.data()[frame_index] = k->reset_data.trans.x;
-                opd_node_data.data()[l].y.data()[frame_index] = k->reset_data.trans.y;
-                opd_node_data.data()[l].z.data()[frame_index] = k->reset_data.trans.z;
+                opd_node_data.data()[l].x.data()[frame_index] = k->reset_data.pos.x;
+                opd_node_data.data()[l].y.data()[frame_index] = k->reset_data.pos.y;
+                opd_node_data.data()[l].z.data()[frame_index] = k->reset_data.pos.z;
             }
         }
     }
@@ -16732,8 +16728,8 @@ void opd_chara_data::encode_init_data(uint32_t motion_id) {
             RobOsageNode* k_begin = j->rob.nodes.data() + 1;
             RobOsageNode* k_end = j->rob.nodes.data() + j->rob.nodes.size();
             for (RobOsageNode* k = k_begin; k != k_end; k++) {
-                d[0] = k->trans;
-                d[1] = k->trans_diff;
+                d[0] = k->pos;
+                d[1] = k->delta_pos;
                 d += 2;
             }
         }
@@ -16746,8 +16742,8 @@ void opd_chara_data::encode_init_data(uint32_t motion_id) {
             CLOTHNode* k_end = j->rob.nodes.data() + j->rob.nodes.size();
             size_t l = 0;
             for (CLOTHNode* k = k_begin; k != k_end; k++, l++) {
-                d[0] = k->trans;
-                d[1] = k->trans_diff;
+                d[0] = k->pos;
+                d[1] = k->delta_pos;
                 d += 2;
             }
         }
@@ -17881,7 +17877,7 @@ rot_z(), field_1C(), rot_speed(), gravity(), alpha(), alive() {
 void rob_chara_age_age_data::reset() {
     index = -1;
     part_id = 0;
-    trans = 0.0f;
+    pos = 0.0f;
     field_14 = 0.0f;
     rot_z = 0.0f;
     field_1C = 0;
@@ -17931,7 +17927,7 @@ void rob_chara_age_age_object::disp(render_context* rctx, size_t chara_index,
 
     std::pair<float_t, int32_t> v44[10];
     for (int32_t i = 0; i < disp_count; i++) {
-        v44[i].first = vec3::dot(trans[i], a5);
+        v44[i].first = vec3::dot(pos[i], a5);
         v44[i].second = i;
     }
 
@@ -18146,7 +18142,7 @@ void rob_chara_age_age_object::update(rob_chara_age_age_data* data, int32_t coun
     for (int32_t i = count; i > 0; i--, data++)
         if (data->remaining >= 0.0f && data->alive) {
             calc_vertex(vtx_data, m, data->mat_scale, alpha * data->alpha);
-            mat4_get_translation(&data->mat_scale, &trans[disp_count]);
+            mat4_get_translation(&data->mat_scale, &pos[disp_count]);
             scale = max_def(scale, data->scale);
             disp_count++;
         }
@@ -18158,12 +18154,12 @@ void rob_chara_age_age_object::update(rob_chara_age_age_data* data, int32_t coun
     float_t radius = scale * sm->bounding_sphere.radius;
 
     obj_bounding_sphere v75;
-    v75.center = trans[0];
+    v75.center = pos[0];
     v75.radius = radius;
 
     for (int32_t i = 1; i < disp_count; i++) {
         obj_bounding_sphere v74;
-        v74.center = trans[i];
+        v74.center = pos[i];
         v74.radius = radius;
         v75 = combine_bounding_spheres(&v75, &v74);
     }
@@ -18172,11 +18168,11 @@ void rob_chara_age_age_object::update(rob_chara_age_age_data* data, int32_t coun
     mesh.bounding_sphere = v75;
     obj.bounding_sphere = v75;
 
-    vec3 min = trans[0] - radius;
-    vec3 max = trans[0] + radius;
+    vec3 min = pos[0] - radius;
+    vec3 max = pos[0] + radius;
     for (int32_t i = 1; i < disp_count; i++) {
-        min = vec3::min(min, trans[i] - radius);
-        max = vec3::max(max, trans[i] + radius);
+        min = vec3::min(min, pos[i] - radius);
+        max = vec3::max(max, pos[i] + radius);
     }
     sub_mesh.axis_aligned_bounding_box.center = (max + min) * 0.5f;
     sub_mesh.axis_aligned_bounding_box.size = (max - min) * 0.5f;
@@ -18239,12 +18235,12 @@ void rob_chara_age_age::ctrl(mat4& mat) {
     float_t move_cancel = this->move_cancel;
     frame += step;
 
-    vec3 trans[2];
-    mat4_get_translation(&mat, &trans[0]);
-    mat4_get_translation(&this->mat, &trans[1]);
+    vec3 pos[2];
+    mat4_get_translation(&mat, &pos[0]);
+    mat4_get_translation(&this->mat, &pos[1]);
     this->mat = mat;
 
-    if (vec3::distance(trans[0], trans[1]) > 0.2f)
+    if (vec3::distance(pos[0], pos[1]) > 0.2f)
         frame += step * 2.0f;
 
     if (step_full) {
@@ -18290,18 +18286,18 @@ void rob_chara_age_age::ctrl_data(rob_chara_age_age_data* data, mat4& mat) {
             data->mat = mat;
             data->remaining = init_data->life_time;
 
-            vec3 trans[2];
-            mat4_get_translation(&mat, &trans[0]);
-            mat4_get_translation(&data->prev_parent_mat, &trans[1]);
+            vec3 pos[2];
+            mat4_get_translation(&mat, &pos[0]);
+            mat4_get_translation(&data->prev_parent_mat, &pos[1]);
 
-            vec3 v15 = (trans[0] - trans[1]) * (move_cancel - 1.0f);
+            vec3 v15 = (pos[0] - pos[1]) * (move_cancel - 1.0f);
             if (vec3::length(v15) <= 1.0f) {
-                data->trans = v15;
+                data->pos = v15;
                 data->field_14 = 0.0f;
                 data->rot_z = data->part_id == 1 ? -0.1f : 0.1f;
                 data->field_1C = 0;
                 data->rot_speed = init_data->rot_speed;
-                mat4_mul_translate(&data->mat, &init_data->trans, &data->mat);
+                mat4_mul_translate(&data->mat, &init_data->pos, &data->mat);
                 mat4_mul_rotate_x(&data->mat, init_data->rot_x, &data->mat);
                 mat4_mul_translate(&data->mat, 0.0f, 0.0f, init_data->offset, &data->mat);
                 data->scale = init_data->scale;
@@ -18316,16 +18312,16 @@ void rob_chara_age_age::ctrl_data(rob_chara_age_age_data* data, mat4& mat) {
     else if (data->alive) {
         if (data->remaining < 70.0f)
             data->rot_z += step * data->rot_speed * rot_speed;
-        data->trans.x += (90.0f - data->remaining) * (float_t)(1.0 / 90.0)
+        data->pos.x += (90.0f - data->remaining) * (float_t)(1.0 / 90.0)
             * data->gravity * 2.5f * step * rot_speed;
-        data->trans.z -= (90.0f - data->remaining) * 0.000011f * step * rot_speed;
+        data->pos.z -= (90.0f - data->remaining) * 0.000011f * step * rot_speed;
 
         mat4 m;
-        mat4_mul_translate(&mat, &init_data->trans, &m);
+        mat4_mul_translate(&mat, &init_data->pos, &m);
         mat4_mul_rotate_x(&m, init_data->rot_x, &m);
         mat4_mul_translate(&m, 0.0f, 0.0f, init_data->offset, &m);
         mat4_mul_rotate_y(&m, init_data->rot_y, &m);
-        mat4_mul_translate(&m, &data->trans, &m);
+        mat4_mul_translate(&m, &data->pos, &m);
         mat4_mul_rotate_z(&m, data->rot_z, &m);
         mat4_scale_rot(&m, data->scale, &m);
 
diff --git a/src/CRE/rob/rob.hpp b/src/CRE/rob/rob.hpp
index 79e37c69..9bb29d4e 100644
--- a/src/CRE/rob/rob.hpp
+++ b/src/CRE/rob/rob.hpp
@@ -340,7 +340,7 @@ enum mothead_data_type {
     MOTHEAD_DATA_DISABLE_EYE_MOTION          = 0x4D,
     MOTHEAD_DATA_TYPE_78                     = 0x4E,
     MOTHEAD_DATA_ROB_CHARA_COLI_RING         = 0x4F,
-    MOTHEAD_DATA_ADJUST_GET_GLOBAL_TRANS     = 0x50,
+    MOTHEAD_DATA_ADJUST_GET_GLOBAL_POS       = 0x50,
     MOTHEAD_DATA_MAX                         = 0x51,
 };
 
@@ -945,12 +945,12 @@ struct bone_data {
     int32_t key_set_offset;
     int32_t key_set_count;
     float_t frame;
-    vec3 base_translation[2];
+    vec3 base_position[2];
     vec3 rotation;
     vec3 ik_target;
-    vec3 trans;
+    vec3 position;
     mat4 rot_mat[3];
-    vec3 trans_prev[2];
+    vec3 position_prev[2];
     mat4 rot_mat_prev[3][2];
     mat4* pole_target_mat;
     mat4* parent_mat;
@@ -978,7 +978,7 @@ struct bone_data_parent {
     size_t chain_pos;
     std::vector<bone_data> bones;
     std::vector<uint16_t> bone_indices;
-    vec3 global_trans;
+    vec3 global_position;
     vec3 global_rotation;
     uint32_t bone_key_set_count;
     uint32_t global_key_set_count;
@@ -1548,8 +1548,8 @@ struct skin_param_osage_node {
 };
 
 struct RobOsageNodeResetData {
-    vec3 trans;
-    vec3 trans_diff;
+    vec3 pos;
+    vec3 delta_pos;
     vec3 rotation;
     float_t length;
 
@@ -1608,19 +1608,19 @@ struct opd_node_data_pair {
 
 struct RobOsageNode {
     float_t length;
-    vec3 trans;
-    vec3 trans_orig;
-    vec3 trans_diff;
-    vec3 field_28;
+    vec3 pos;
+    vec3 fixed_pos;
+    vec3 delta_pos;
+    vec3 vel;
     float_t child_length;
     bone_node* bone_node_ptr;
     mat4* bone_node_mat;
     mat4 mat;
     RobOsageNode* sibling_node;
     float_t max_distance;
-    vec3 field_94;
+    vec3 rel_pos;
     RobOsageNodeResetData reset_data;
-    float_t field_C8;
+    float_t hit;
     float_t friction;
     vec3 external_force;
     float_t force;
@@ -1790,16 +1790,18 @@ struct osage_ring_data {
 
     osage_ring_data();
     ~osage_ring_data();
+
+    float_t get_floor_height(const vec3& pos, const float_t coli_r);
 };
 
 struct skin_param_file_data;
 
 struct CLOTHNode {
     uint32_t flags;
-    vec3 trans;
-    vec3 trans_orig;
+    vec3 pos;
+    vec3 fixed_pos;
     vec3 prev_trans;
-    vec3 trans_diff;
+    vec3 delta_pos;
     vec3 normal;
     vec3 tangent;
     vec3 binormal;
@@ -1858,7 +1860,7 @@ struct CLOTH {
 };
 
 struct RobClothRoot {
-    vec3 trans;
+    vec3 pos;
     vec3 normal;
     vec4 tangent;
     bone_node* node[4];
@@ -3215,15 +3217,15 @@ struct rob_chara_adjust_data {
     bool offset_x;
     bool offset_y;
     bool offset_z;
-    bool get_global_trans;
-    vec3 trans;
+    bool get_global_pos;
+    vec3 pos;
     mat4 mat;
     float_t left_hand_scale;
     float_t right_hand_scale;
     float_t left_hand_scale_default;
     float_t right_hand_scale_default;
     mat4 item_mat;      // X
-    vec3 item_trans;    // X
+    vec3 item_pos;      // X
     float_t item_scale; // X
 
     rob_chara_adjust_data();
@@ -3232,8 +3234,8 @@ struct rob_chara_adjust_data {
 };
 
 struct struc_195 {
-    vec3 prev_trans;
-    vec3 trans;
+    vec3 prev_pos;
+    vec3 pos;
     float_t scale;
     float_t field_1C;
     float_t field_20;
@@ -3249,7 +3251,7 @@ struct pos_scale {
     pos_scale();
 
     float_t get_screen_pos_scale(const mat4& mat,
-        const vec3& trans, float_t scale = 0.0f, bool apply_offset = false);
+        const vec3& pos, float_t scale = 0.0f, bool apply_offset = false);
 };
 
 struct struc_267 {
@@ -3470,7 +3472,7 @@ struct rob_chara {
     float_t get_frame_count();
     float_t get_max_face_depth();
     uint32_t get_rob_cmn_mottbl_motion_id(int32_t id);
-    float_t get_trans_scale(int32_t bone, vec3& trans);
+    float_t get_pos_scale(int32_t bone, vec3& pos);
     void load_body_parts_object_info(item_id item_id, object_info obj_info,
         const bone_database* bone_data, void* data, const object_database* obj_db);
     void load_motion(uint32_t motion_id, bool a3, float_t frame,
diff --git a/src/DivaGL/bone_data.cpp b/src/DivaGL/bone_data.cpp
index cedb3205..101cb07a 100644
--- a/src/DivaGL/bone_data.cpp
+++ b/src/DivaGL/bone_data.cpp
@@ -35,6 +35,16 @@ void opd_node_data_pair::set_data(opd_blend_data* blend_data, opd_node_data&& no
         opd_node_data::lerp(curr, curr, node_data, blend_data->blend);
 }
 
+inline float_t osage_ring_data::get_floor_height(const vec3& pos, const float_t coli_r) {
+    if (pos.x < ring_rectangle_x - coli_r
+        || pos.z < ring_rectangle_y - coli_r
+        || pos.x > ring_rectangle_x + ring_rectangle_width
+        || pos.z > ring_rectangle_y + ring_rectangle_height)
+        return ring_out_height + coli_r;
+    else
+        return ring_height + coli_r;
+}
+
 // 0x140485450
 void OsageCollision::Work::update_cls_work(OsageCollision::Work* cls,
     SkinParam::CollisionParam* cls_param, const mat4* transform) {
@@ -453,22 +463,22 @@ static void RobOsageNode__Reset(RobOsageNode* node) {
     void (*sub_14021DCC0)(prj::vector<opd_vec3_data> *vec, size_t size)
         = (void (*)(prj::vector<opd_vec3_data>*, size_t))0x000000014021DCC0;
     node->length = 0.0f;
-    node->trans = 0.0f;
-    node->trans_orig = 0.0f;
-    node->trans_diff = 0.0f;
-    node->field_28 = 0.0f;
+    node->pos = 0.0f;
+    node->fixed_pos = 0.0f;
+    node->delta_pos = 0.0f;
+    node->vel = 0.0f;
     node->child_length = 0.0f;
     node->bone_node_ptr = 0;
     node->bone_node_mat = 0;
     node->sibling_node = 0;
     node->max_distance = 0.0f;
-    node->field_94 = 0.0f;
-    node->reset_data.trans = 0.0f;
-    node->reset_data.trans_diff = 0.0f;
+    node->rel_pos = 0.0f;
+    node->reset_data.pos = 0.0f;
+    node->reset_data.delta_pos = 0.0f;
     node->reset_data.rotation = 0.0f;
     node->reset_data.length = 0.0f;
-    node->field_C8 = 0.0f;
-    node->field_CC = 1.0f;
+    node->hit = 0.0f;
+    node->friction = 1.0f;
     node->external_force = 0.0f;
     node->force = 1.0f;
     RobOsage__node_data_init(&node->data);
@@ -541,8 +551,8 @@ static void RobOsage__ApplyResetData(RobOsage* rob_osg, mat4* mat) {
     RobOsageNode* i_begin = rob_osg->nodes.data() + 1;
     RobOsageNode* i_end = rob_osg->nodes.data() + rob_osg->nodes.size();
     for (RobOsageNode* i = i_begin; i != i_end; i++) {
-        mat4_transform_vector(&temp, &i->reset_data.trans_diff, &i->trans_diff);
-        mat4_transform_point(&temp, &i->reset_data.trans, &i->trans);
+        mat4_transform_vector(&temp, &i->reset_data.delta_pos, &i->delta_pos);
+        mat4_transform_point(&temp, &i->reset_data.pos, &i->pos);
     }
     rob_osg->parent_mat = *rob_osg->parent_mat_ptr;
 }
@@ -633,7 +643,7 @@ static void sub_1404803B0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
     mat4 v47 = *root_matrix;
     vec3 v45 = rob_osg->exp_data.position * *parent_scale;
     mat4_transpose(&v47, &v47);
-    mat4_transform_point(&v47, &v45, &rob_osg->nodes.data()[0].trans);
+    mat4_transform_point(&v47, &v45, &rob_osg->nodes.data()[0].pos);
 
     if (rob_osg->osage_reset && !rob_osg->prev_osage_reset) {
         rob_osg->prev_osage_reset = true;
@@ -656,10 +666,10 @@ static void sub_1404803B0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
                 mat4 parent_mat;
                 vec3 v44;
                 mat4_transpose(&rob_osg->parent_mat, &parent_mat);
-                mat4_inverse_transform_point(&parent_mat, &i->trans, &v44);
+                mat4_inverse_transform_point(&parent_mat, &i->pos, &v44);
                 mat4_transpose(rob_osg->parent_mat_ptr, &parent_mat);
                 mat4_transform_point(&parent_mat, &v44, &v44);
-                i->trans += (v44 - i->trans) * move_cancel;
+                i->pos += (v44 - i->pos) * move_cancel;
             }
         }
     }
@@ -677,7 +687,7 @@ static void sub_1404803B0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
     RobOsageNode* v30_end = rob_osg->nodes.data() + rob_osg->nodes.size();
     for (RobOsageNode* v30 = v30_begin; v30 != v30_end; v29++, v30++) {
         vec3 direction;
-        mat4_inverse_transform_point(&v47, &v30->trans, &direction);
+        mat4_inverse_transform_point(&v47, &v30->pos, &direction);
 
         mat4_transpose(&v47, &v47);
         bool v32 = sub_140482FF0(&v47, &direction, &v30->data_ptr->skp_osg_node.hinge,
@@ -685,7 +695,7 @@ static void sub_1404803B0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
         *v30->bone_node_ptr->ex_data_mat = v47;
         mat4_transpose(&v47, &v47);
 
-        float_t v34 = vec3::distance(v30->trans, v29->trans);
+        float_t v34 = vec3::distance(v30->pos, v29->pos);
         float_t v35 = parent_scale->x * v30->length;
         bool v36;
         if (v34 >= fabsf(v35)) {
@@ -697,7 +707,7 @@ static void sub_1404803B0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
 
         mat4_mul_translate(&v47, v35, 0.0f, 0.0f, &v47);
         if (v32 || v36)
-            mat4_get_translation(&v47, &v30->trans);
+            mat4_get_translation(&v47, &v30->pos);
     }
 
     if (rob_osg->nodes.size() && rob_osg->node.bone_node_mat) {
@@ -746,28 +756,28 @@ static void sub_140482F30(vec3* pos1, vec3* pos2, float_t length) {
 
 static void sub_140482490(RobOsageNode* node, float_t step, float_t a3) {
     if (step != 1.0f) {
-        vec3 v4 = node->trans - node->trans_orig;
+        vec3 v4 = node->pos - node->fixed_pos;
 
         float_t v9 = vec3::length(v4);
         if (v9 != 0.0f)
             v4 *= 1.0f / v9;
-        node->trans = node->trans_orig + v4 * (step * v9);
+        node->pos = node->fixed_pos + v4 * (step * v9);
     }
 
-    sub_140482F30(&node[0].trans, &node[-1].trans, node->length * a3);
+    sub_140482F30(&node[0].pos, &node[-1].pos, node->length * a3);
     if (node->sibling_node)
-        sub_140482F30(&node->trans, &node->sibling_node->trans, node->max_distance);
+        sub_140482F30(&node->pos, &node->sibling_node->pos, node->max_distance);
 }
 
 static void sub_140482180(RobOsageNode* node, float_t a2) {
-    float_t v2 = node->data_ptr->skp_osg_node.coli_r + a2;
-    if (v2 <= node->trans.y)
+    float_t pos_y = node->data_ptr->skp_osg_node.coli_r + a2;
+    if (pos_y <= node->pos.y)
         return;
 
-    node->trans.y = v2;
-    node->trans = node[-1].trans + vec3::normalize(node->trans - node[-1].trans) * node->length;
-    node->trans_diff = 0.0f;
-    node->field_C8 += 1.0f;
+    node->pos.y = pos_y;
+    node->pos = node[-1].pos + vec3::normalize(node->pos - node[-1].pos) * node->length;
+    node->delta_pos = 0.0f;
+    node->hit += 1.0f;
 }
 
 static void sub_14047C800(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_scale,
@@ -779,13 +789,13 @@ static void sub_14047C800(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
     sub_1404803B0(rob_osg, root_matrix, parent_scale, false);
 
     RobOsageNode* v17 = &rob_osg->nodes.data()[0];
-    v17->trans_orig = v17->trans;
+    v17->fixed_pos = v17->pos;
     vec3 v113 = rob_osg->exp_data.position * *parent_scale;
 
     mat4 v130 = *root_matrix;
     mat4_transpose(&v130, &v130);
-    mat4_transform_point(&v130, &v113, &v17->trans);
-    v17->trans_diff = v17->trans - v17->trans_orig;
+    mat4_transform_point(&v130, &v113, &v17->pos);
+    v17->delta_pos = v17->pos - v17->fixed_pos;
 
     mat4_transpose(&v130, &v130);
     sub_14047F110(rob_osg, &v130, parent_scale, false);
@@ -811,11 +821,11 @@ static void sub_14047C800(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
         float_t weight = v31->skp_osg_node.weight;
         vec3 v111;
         if (!rob_osg->set_external_force) {
-            sub_140482300(&v111, &v26->trans, &v30->trans, osage_gravity_const, weight);
+            sub_140482300(&v111, &v26->pos, &v30->pos, osage_gravity_const, weight);
 
             if (v26 != v26_end - 1) {
                 vec3 v112;
-                sub_140482300(&v112, &v26->trans, &v26[1].trans, osage_gravity_const, weight);
+                sub_140482300(&v112, &v26->pos, &v26[1].pos, osage_gravity_const, weight);
                 v111 = (v111 + v112) * 0.5f;
             }
         }
@@ -825,15 +835,15 @@ static void sub_14047C800(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
         vec3 v127 = v128 * (v31->force * v26->force);
         float_t v41 = (1.0f - rob_osg->field_1EB4) * (1.0f - rob_osg->skin_param_ptr->air_res);
 
-        vec3 v126 = v111 + v127 - v26->trans_diff * v41 + v26->external_force * weight;
+        vec3 v126 = v111 + v127 - v26->delta_pos * v41 + v26->external_force * weight;
 
         if (!disable_external_force)
             v126 += rob_osg->wind_direction * rob_osg->skin_param_ptr->wind_afc;
 
         if (stiffness)
-            v126 -= (v26->trans_diff - v30->trans_diff) * (1.0f - rob_osg->skin_param_ptr->air_res);
+            v126 -= (v26->delta_pos - v30->delta_pos) * (1.0f - rob_osg->skin_param_ptr->air_res);
 
-        v26->field_28 = v126 * (1.0f / (weight - (weight - 1.0f) * v31->skp_osg_node.inertial_cancel));
+        v26->vel = v126 * (1.0f / (weight - (weight - 1.0f) * v31->skp_osg_node.inertial_cancel));
     }
 
     if (stiffness) {
@@ -844,17 +854,17 @@ static void sub_14047C800(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
         RobOsageNode* v55_begin = rob_osg->nodes.data() + 1;
         RobOsageNode* v55_end = rob_osg->nodes.data() + rob_osg->nodes.size();
         for (RobOsageNode* v55 = v55_begin; v55 != v55_end; v55++) {
-            mat4_transform_point(&v131, &v55->field_94, &v128);
+            mat4_transform_point(&v131, &v55->rel_pos, &v128);
 
-            vec3 v126 = v55->trans + v55->trans_diff + v55->field_28;
+            vec3 v126 = v55->pos + v55->delta_pos + v55->vel;
             sub_140482F30(&v126, &v111, v25 * v55->length);
 
             vec3 v117 = (v128 - v126) * rob_osg->skin_param_ptr->stiffness;
             float_t weight = v55->data_ptr->skp_osg_node.weight;
             float_t v74 = 1.0f / (weight - (weight - 1.0f) * v55->data_ptr->skp_osg_node.inertial_cancel);
-            v55->field_28 += v117 * v74;
+            v55->vel += v117 * v74;
 
-            v126 = v55->trans + v55->trans_diff + v55->field_28;
+            v126 = v55->pos + v55->delta_pos + v55->vel;
 
             vec3 direction;
             mat4_inverse_transform_point(&v131, &v126, &direction);
@@ -872,36 +882,28 @@ static void sub_14047C800(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
     RobOsageNode* v82_begin = rob_osg->nodes.data() + 1;
     RobOsageNode* v82_end = rob_osg->nodes.data() + rob_osg->nodes.size();
     for (RobOsageNode* v82 = v82_begin; v82 != v82_end; v82++) {
-        v82->trans_orig = v82->trans;
-        v82->trans_diff += v82->field_28;
-        v82->trans += v82->trans_diff;
+        v82->fixed_pos = v82->pos;
+        v82->delta_pos += v82->vel;
+        v82->pos += v82->delta_pos;
     }
 
     if (rob_osg->nodes.size() > 1) {
         RobOsageNode* v90_begin = rob_osg->nodes.data() + rob_osg->nodes.size() - 2;
         RobOsageNode* v90_end = rob_osg->nodes.data();
         for (RobOsageNode* v90 = v90_begin; v90 != v90_end; v90--)
-            sub_140482F30(&v90[0].trans, &v90[1].trans, v25 * v90->child_length);
+            sub_140482F30(&v90[0].pos, &v90[1].pos, v25 * v90->child_length);
     }
 
     if (ring_coli) {
-        RobOsageNode* v91 = &rob_osg->nodes.data()[0];
-        float_t coli_r = v91->data_ptr->skp_osg_node.coli_r;
-        float_t ring_height;
-        if (v91->trans.x < rob_osg->ring.ring_rectangle_x - coli_r
-            || v91->trans.z < rob_osg->ring.ring_rectangle_y - coli_r
-            || v91->trans.x > rob_osg->ring.ring_rectangle_x + rob_osg->ring.ring_rectangle_width
-            || v91->trans.z > rob_osg->ring.ring_rectangle_y + rob_osg->ring.ring_rectangle_height)
-            ring_height = rob_osg->ring.ring_out_height;
-        else
-            ring_height = rob_osg->ring.ring_height;
+        RobOsageNode* node = &rob_osg->nodes.data()[0];
+        const float_t floor_height = rob_osg->ring.get_floor_height(
+            node->pos, node->data_ptr->skp_osg_node.coli_r);
 
-        float_t v96 = ring_height + coli_r;
         RobOsageNode* v98_begin = rob_osg->nodes.data() + 1;
         RobOsageNode* v98_end = rob_osg->nodes.data() + rob_osg->nodes.size();
         for (RobOsageNode* v98 = v98_begin; v98 != v98_end; v98++) {
             sub_140482490(v98, step, v25);
-            sub_140482180(v98, v96);
+            sub_140482180(v98, floor_height);
         }
     }
 
@@ -911,7 +913,7 @@ static void sub_14047C800(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
         RobOsageNode* v99_end = rob_osg->nodes.data() + rob_osg->nodes.size();
         for (RobOsageNode* v99 = v99_begin; v99 != v99_end; v99++, v100++) {
             vec3 direction;
-            mat4_inverse_transform_point(&v130, &v99->trans, &direction);
+            mat4_inverse_transform_point(&v130, &v99->pos, &direction);
 
             mat4_transpose(&v130, &v130);
             bool v102 = sub_140482FF0(&v130, &direction,
@@ -920,7 +922,7 @@ static void sub_14047C800(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
             *v99->bone_node_ptr->ex_data_mat = v130;
             mat4_transpose(&v130, &v130);
 
-            float_t v104 = vec3::distance_squared(v99->trans, v100->trans);
+            float_t v104 = vec3::distance_squared(v99->pos, v100->pos);
             float_t v105 = v25 * v99->length;
 
             bool v106;
@@ -933,7 +935,7 @@ static void sub_14047C800(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
 
             mat4_mul_translate(&v130, v105, 0.0f, 0.0f, &v130);
             if (v102 || v106)
-                mat4_get_translation(&v130, &v99->trans);
+                mat4_get_translation(&v130, &v99->pos);
         }
 
         if (rob_osg->nodes.size() && rob_osg->node.bone_node_mat) {
@@ -966,21 +968,21 @@ static void sub_14047ECA0(RobOsage* rob_osg, float_t step) {
     if (rob_osg->disable_collision)
         for (RobOsageNode* i = i_begin; i != i_end; i++) {
             RobOsageNodeData* data = i->data_ptr;
-            i->field_C8 += (float_t)OsageCollision::osage_cls_work_list(i->trans,
-                data->skp_osg_node.coli_r, vec_coli, &i->field_CC);
+            i->hit += (float_t)OsageCollision::osage_cls_work_list(i->pos,
+                data->skp_osg_node.coli_r, vec_coli, &i->friction);
         }
     else
         for (RobOsageNode* i = i_begin; i != i_end; i++) {
             RobOsageNodeData* data = i->data_ptr;
-            i->field_C8 += (float_t)OsageCollision::osage_cls_work_list(i->trans,
-                data->skp_osg_node.coli_r, vec_coli, &i->field_CC);
+            i->hit += (float_t)OsageCollision::osage_cls_work_list(i->pos,
+                data->skp_osg_node.coli_r, vec_coli, &i->friction);
             for (RobOsageNode*& j : data->boc) {
-                j->field_C8 += (float_t)OsageCollision::osage_cls(coli_ring, j->trans, data->skp_osg_node.coli_r);
-                j->field_C8 += (float_t)OsageCollision::osage_cls(coli, j->trans, data->skp_osg_node.coli_r);
+                j->hit += (float_t)OsageCollision::osage_cls(coli_ring, j->pos, data->skp_osg_node.coli_r);
+                j->hit += (float_t)OsageCollision::osage_cls(coli, j->pos, data->skp_osg_node.coli_r);
             }
 
-            i->field_C8 += (float_t)OsageCollision::osage_cls(coli_ring, i->trans, data->skp_osg_node.coli_r);
-            i->field_C8 += (float_t)OsageCollision::osage_cls(coli, i->trans, data->skp_osg_node.coli_r);
+            i->hit += (float_t)OsageCollision::osage_cls(coli_ring, i->pos, data->skp_osg_node.coli_r);
+            i->hit += (float_t)OsageCollision::osage_cls(coli, i->pos, data->skp_osg_node.coli_r);
         }
     }
 
@@ -989,7 +991,7 @@ static void sub_14047D620(RobOsage* rob_osg, float_t step) {
         return;
 
     prj::vector<RobOsageNode>& nodes = rob_osg->nodes;
-    vec3 v7 = nodes.data()[0].trans;
+    vec3 pos = nodes.data()[0].pos;
     OsageCollision::Work* coli = rob_osg->coli;
     OsageCollision::Work* coli_ring = rob_osg->coli_ring;
     SkinParam::RootCollisionType coli_type = rob_osg->skin_param_ptr->coli_type;
@@ -999,21 +1001,21 @@ static void sub_14047D620(RobOsage* rob_osg, float_t step) {
         RobOsageNodeData* data = i->data_ptr;
         for (RobOsageNode*& j : data->boc) {
             float_t v17 = (float_t)(
-                OsageCollision::osage_capsule_cls(coli_ring, i->trans, j->trans, data->skp_osg_node.coli_r)
-                + OsageCollision::osage_capsule_cls(coli, i->trans, j->trans, data->skp_osg_node.coli_r));
-            i->field_C8 += v17;
-            j->field_C8 += v17;
+                OsageCollision::osage_capsule_cls(coli_ring, i->pos, j->pos, data->skp_osg_node.coli_r)
+                + OsageCollision::osage_capsule_cls(coli, i->pos, j->pos, data->skp_osg_node.coli_r));
+            i->hit += v17;
+            j->hit += v17;
         }
         if (coli_type != SkinParam::RootCollisionTypeEnd
             && (coli_type != SkinParam::RootCollisionTypeBall || i != i_begin)) {
             float_t v20 = (float_t)(
-                OsageCollision::osage_capsule_cls(coli_ring, i[0].trans, i[-1].trans, data->skp_osg_node.coli_r)
-                + OsageCollision::osage_capsule_cls(coli, i[0].trans, i[-1].trans, data->skp_osg_node.coli_r));
-            i[0].field_C8 += v20;
-            i[-1].field_C8 += v20;
+                OsageCollision::osage_capsule_cls(coli_ring, i[0].pos, i[-1].pos, data->skp_osg_node.coli_r)
+                + OsageCollision::osage_capsule_cls(coli, i[0].pos, i[-1].pos, data->skp_osg_node.coli_r));
+            i[0].hit += v20;
+            i[-1].hit += v20;
         }
     }
-    nodes.data()[0].trans = v7;
+    nodes.data()[0].pos = pos;
 }
 
 static void sub_14047D8C0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_scale, float_t step, bool a5) {
@@ -1036,26 +1038,17 @@ static void sub_14047D8C0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
 
         vec3 trans = rob_osg->exp_data.position * *parent_scale;
         mat4_transpose(&v64, &v64);
-        mat4_transform_point(&v64, &trans, &rob_osg->nodes.data()[0].trans);
+        mat4_transform_point(&v64, &trans, &rob_osg->nodes.data()[0].pos);
         mat4_transpose(&v64, &v64);
         sub_14047F110(rob_osg, &v64, parent_scale, false);
     }
     mat4_transpose(&v64, &v64);
 
-    float_t v60 = -1000.0f;
+    float_t floor_height = -1000.0f;
     if (a5) {
-        RobOsageNode* v16 = &rob_osg->nodes.data()[0];
-        float_t coli_r = v16->data_ptr->skp_osg_node.coli_r;
-        float_t ring_height;
-        if (v16->trans.x < rob_osg->ring.ring_rectangle_x - coli_r
-            || v16->trans.z < rob_osg->ring.ring_rectangle_y - coli_r
-            || v16->trans.x > rob_osg->ring.ring_rectangle_x + rob_osg->ring.ring_rectangle_width
-            || v16->trans.z > rob_osg->ring.ring_rectangle_y + rob_osg->ring.ring_rectangle_height)
-            ring_height = rob_osg->ring.ring_out_height;
-        else
-            ring_height = rob_osg->ring.ring_height;
-
-        v60 = ring_height + coli_r;
+        RobOsageNode* node = &rob_osg->nodes.data()[0];
+        floor_height = rob_osg->ring.get_floor_height(
+            node->pos, node->data_ptr->skp_osg_node.coli_r);
     }
 
     float_t v23 = 0.2f;
@@ -1072,9 +1065,9 @@ static void sub_14047D8C0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
             RobOsageNode* v30_begin = v24->data() + 1;
             RobOsageNode* v30_end = v24->data() + v24->size();
             for (RobOsageNode* v30 = v30_begin; v30 != v30_end; v30++)
-                OsageCollision::cls_ball_oidashi(v62, v27->trans, v30->trans,
+                OsageCollision::cls_ball_oidashi(v62, v27->pos, v30->pos,
                     v27->data_ptr->skp_osg_node.coli_r + v30->data_ptr->skp_osg_node.coli_r);
-            v27->trans += v62;
+            v27->pos += v62;
         }
     }
 
@@ -1085,19 +1078,19 @@ static void sub_14047D8C0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
         float_t v37 = (1.0f - rob_osg->field_1EB4) * rob_osg->skin_param_ptr->friction;
         if (a5) {
             sub_140482490(v35, step, parent_scale->x);
-            v35->field_C8 = (float_t)OsageCollision::osage_cls_work_list(v35->trans,
-                skp_osg_node->coli_r, vec_coli, &v35->field_CC);
+            v35->hit = (float_t)OsageCollision::osage_cls_work_list(v35->pos,
+                skp_osg_node->coli_r, vec_coli, &v35->friction);
             if (!rob_osg->disable_collision) {
-                v35->field_C8 += (float_t)OsageCollision::osage_cls(coli_ring, v35->trans, skp_osg_node->coli_r);
-                v35->field_C8 += (float_t)OsageCollision::osage_cls(coli, v35->trans, skp_osg_node->coli_r);
+                v35->hit += (float_t)OsageCollision::osage_cls(coli_ring, v35->pos, skp_osg_node->coli_r);
+                v35->hit += (float_t)OsageCollision::osage_cls(coli, v35->pos, skp_osg_node->coli_r);
             }
-            sub_140482180(v35, v60);
+            sub_140482180(v35, floor_height);
         }
         else
-            sub_140482F30(&v35[0].trans, &v35[-1].trans, v35[0].length * parent_scale->x);
+            sub_140482F30(&v35[0].pos, &v35[-1].pos, v35[0].length * parent_scale->x);
 
         vec3 direction;
-        mat4_inverse_transform_point(&v64, &v35->trans, &direction);
+        mat4_inverse_transform_point(&v64, &v35->pos, &direction);
         mat4_transpose(&v64, &v64);
 
         bool v40 = sub_140482FF0(&v64, &direction, &skp_osg_node->hinge,
@@ -1113,7 +1106,7 @@ static void sub_14047D8C0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
         }
 
         float_t v42 = v35->length * parent_scale->x;
-        float_t v44 = vec3::distance_squared(v35[0].trans, v35[-1].trans);
+        float_t v44 = vec3::distance_squared(v35[0].pos, v35[-1].pos);
         bool v45;
         if (v44 >= v42 * v42) {
             v42 = sqrtf(v44);
@@ -1125,24 +1118,24 @@ static void sub_14047D8C0(RobOsage* rob_osg, mat4* root_matrix, vec3* parent_sca
         mat4_mul_translate(&v64, v42, 0.0f, 0.0f, &v64);
         v35->reset_data.length = v42;
         if (v40 || v45)
-            mat4_get_translation(&v64, &v35->trans);
+            mat4_get_translation(&v64, &v35->pos);
 
-        v35->trans_diff = (v35->trans - v35->trans_orig) * v9;
+        v35->delta_pos = (v35->pos - v35->fixed_pos) * v9;
 
-        if (v35->field_C8 > 0.0f) {
-            if (v37 > v35->field_CC)
-                v37 = v35->field_CC;
-            v35->trans_diff *= v37;
+        if (v35->hit > 0.0f) {
+            if (v37 > v35->friction)
+                v37 = v35->friction;
+            v35->delta_pos *= v37;
         }
 
-        float_t v55 = vec3::length_squared(v35->trans_diff);
+        float_t v55 = vec3::length_squared(v35->delta_pos);
         if (v55 > v23 * v23)
-            v35->trans_diff *= v23 / sqrtf(v55);
+            v35->delta_pos *= v23 / sqrtf(v55);
 
         mat4 v65;
         mat4_transpose(root_matrix, &v65);
-        mat4_inverse_transform_point(&v65, &v35->trans, &v35->reset_data.trans);
-        mat4_inverse_transform_vector(&v65, &v35->trans_diff, &v35->reset_data.trans_diff);
+        mat4_inverse_transform_point(&v65, &v35->pos, &v35->reset_data.pos);
+        mat4_inverse_transform_vector(&v65, &v35->delta_pos, &v35->reset_data.delta_pos);
     }
 
     if (rob_osg->nodes.size() && rob_osg->node.bone_node_mat) {
@@ -1208,8 +1201,8 @@ static void sub_140480260(RobOsage* rob_osg, mat4* root_matrix,
     RobOsageNode* i_begin = rob_osg->nodes.data() + 1;
     RobOsageNode* i_end = rob_osg->nodes.data() + rob_osg->nodes.size();
     for (RobOsageNode* i = i_begin; i != i_end; i++) {
-        i->field_C8 = 0.0f;
-        i->field_CC = 1.0f;
+        i->hit = 0.0f;
+        i->friction = 1.0f;
     }
 
     rob_osg->field_2A0 = true;
@@ -1311,7 +1304,7 @@ void RobOsage__set_osage_play_data(RobOsage* rob_osg, mat4* parent_mat,
 
     mat4 v85;
     mat4_transpose(parent_mat, &v85);
-    mat4_transform_point(&v85, &v63, &rob_osg->nodes.data()[0].trans);
+    mat4_transform_point(&v85, &v63, &rob_osg->nodes.data()[0].pos);
     mat4_transpose(&v85, &v85);
 
     sub_14047F110(rob_osg, &v85, parent_scale, false);
@@ -1338,8 +1331,8 @@ void RobOsage__set_osage_play_data(RobOsage* rob_osg, mat4* parent_mat,
         float_t inv_blend = 1.0f - blend;
 
         mat4 v87 = v85;
-        vec3 parent_curr_trans = rob_osg->nodes.data()[0].trans;
-        vec3 parent_next_trans = rob_osg->nodes.data()[0].trans;
+        vec3 parent_curr_pos = rob_osg->nodes.data()[0].pos;
+        vec3 parent_next_pos = rob_osg->nodes.data()[0].pos;
 
         RobOsageNode* j_begin = rob_osg->nodes.data() + 1;
         RobOsageNode* j_end = rob_osg->nodes.data() + rob_osg->nodes.size();
@@ -1349,20 +1342,20 @@ void RobOsage__set_osage_play_data(RobOsage* rob_osg, mat4* parent_mat,
             const float_t* opd_y = opd->y;
             const float_t* opd_z = opd->z;
 
-            vec3 curr_trans;
-            curr_trans.x = opd_x[curr_key];
-            curr_trans.y = opd_y[curr_key];
-            curr_trans.z = opd_z[curr_key];
+            vec3 curr_pos;
+            curr_pos.x = opd_x[curr_key];
+            curr_pos.y = opd_y[curr_key];
+            curr_pos.z = opd_z[curr_key];
 
-            vec3 next_trans;
-            next_trans.x = opd_x[next_key];
-            next_trans.y = opd_y[next_key];
-            next_trans.z = opd_z[next_key];
+            vec3 next_pos;
+            next_pos.x = opd_x[next_key];
+            next_pos.y = opd_y[next_key];
+            next_pos.z = opd_z[next_key];
 
-            mat4_transform_point(parent_mat, &curr_trans, &curr_trans);
-            mat4_transform_point(parent_mat, &next_trans, &next_trans);
+            mat4_transform_point(parent_mat, &curr_pos, &curr_pos);
+            mat4_transform_point(parent_mat, &next_pos, &next_pos);
 
-            vec3 _trans = curr_trans * inv_blend + next_trans * blend;
+            vec3 _trans = curr_pos * inv_blend + next_pos * blend;
 
             vec3 direction;
             mat4_inverse_transform_point(&v87, &_trans, &direction);
@@ -1373,12 +1366,12 @@ void RobOsage__set_osage_play_data(RobOsage* rob_osg, mat4* parent_mat,
             mat4_transpose(&v87, &v87);
             mat4_set_translation(&v87, &_trans);
 
-            float_t length = vec3::distance(curr_trans, parent_curr_trans) * inv_blend
-                + vec3::distance(next_trans, parent_next_trans) * blend;
+            float_t length = vec3::distance(curr_pos, parent_curr_pos) * inv_blend
+                + vec3::distance(next_pos, parent_next_pos) * blend;
             j->opd_node_data.set_data(i, { length, rotation });
 
-            parent_curr_trans = curr_trans;
-            parent_next_trans = next_trans;
+            parent_curr_pos = curr_pos;
+            parent_next_pos = next_pos;
         }
     }
     mat4_transpose(parent_mat, parent_mat);
@@ -1402,8 +1395,8 @@ void RobOsage__set_osage_play_data(RobOsage* rob_osg, mat4* parent_mat,
             mat4_transpose(&mat, j->bone_node_mat);
         }
         mat4_mul_translate(&v85, j->opd_node_data.curr.length, 0.0f, 0.0f, &v85);
-        j->trans_orig = j->trans;
-        mat4_get_translation(&v85, &j->trans);
+        j->fixed_pos = j->pos;
+        mat4_get_translation(&v85, &j->pos);
     }
 
     if (rob_osg->nodes.size() && rob_osg->node.bone_node_mat) {
diff --git a/src/DivaGL/bone_data.hpp b/src/DivaGL/bone_data.hpp
index ab83d87d..e428b2eb 100644
--- a/src/DivaGL/bone_data.hpp
+++ b/src/DivaGL/bone_data.hpp
@@ -264,7 +264,7 @@ enum mothead_data_type {
     MOTHEAD_DATA_DISABLE_EYE_MOTION          = 0x4D,
     MOTHEAD_DATA_TYPE_78                     = 0x4E,
     MOTHEAD_DATA_ROB_CHARA_COLI_RING         = 0x4F,
-    MOTHEAD_DATA_ADJUST_GET_GLOBAL_TRANS     = 0x50,
+    MOTHEAD_DATA_ADJUST_GET_GLOBAL_POS       = 0x50,
     MOTHEAD_DATA_MAX                         = 0x51,
 };
 
@@ -1617,8 +1617,8 @@ struct rob_chara_adjust_data {
     bool offset_x;
     bool offset_y;
     bool offset_z;
-    bool get_global_trans;
-    vec3 trans;
+    bool get_global_pos;
+    vec3 pos;
     mat4 mat;
     float_t left_hand_scale;
     float_t right_hand_scale;
@@ -1627,8 +1627,8 @@ struct rob_chara_adjust_data {
 };
 
 struct struc_195 {
-    vec3 prev_trans;
-    vec3 trans;
+    vec3 prev_pos;
+    vec3 pos;
     float_t scale;
     float_t field_1C;
     float_t field_20;
@@ -2553,12 +2553,12 @@ struct bone_data {
     int32_t key_set_offset;
     int32_t key_set_count;
     float_t frame;
-    vec3 base_translation[2];
+    vec3 base_position[2];
     vec3 rotation;
     vec3 ik_target;
-    vec3 trans;
+    vec3 position;
     mat4 rot_mat[3];
-    vec3 trans_prev[2];
+    vec3 position_prev[2];
     mat4 rot_mat_prev[3][2];
     mat4* pole_target_mat;
     mat4* parent_mat;
@@ -2781,7 +2781,7 @@ struct bone_data_parent {
     size_t chain_pos;
     prj::vector<bone_data> bones;
     prj::vector<uint16_t> bone_indices;
-    vec3 global_trans;
+    vec3 global_position;
     vec3 global_rotation;
     uint32_t bone_key_set_count;
     uint32_t global_key_set_count;
@@ -2910,7 +2910,7 @@ struct obj_skin_block_cloth_root_bone_weight {
 };
 
 struct obj_skin_block_cloth_root {
-    vec3 trans;
+    vec3 pos;
     vec3 normal;
     float_t field_18;
     int32_t field_1C;
@@ -2921,8 +2921,8 @@ struct obj_skin_block_cloth_root {
 
 struct obj_skin_block_cloth_node {
     uint32_t flags;
-    vec3 trans;
-    vec3 trans_prev;
+    vec3 pos;
+    vec3 delta_pos;
     float_t dist_top;
     float_t dist_bottom;
     float_t dist_right;
@@ -3148,28 +3148,28 @@ struct opd_node_data_pair {
 };
 
 struct RobOsageNodeResetData {
-    vec3 trans;
-    vec3 trans_diff;
+    vec3 pos;
+    vec3 delta_pos;
     vec3 rotation;
     float_t length;
 };
 
 struct RobOsageNode {
     float_t length;
-    vec3 trans;
-    vec3 trans_orig;
-    vec3 trans_diff;
-    vec3 field_28;
+    vec3 pos;
+    vec3 fixed_pos;
+    vec3 delta_pos;
+    vec3 vel;
     float_t child_length;
     bone_node* bone_node_ptr;
     mat4* bone_node_mat;
     mat4 mat;
     RobOsageNode* sibling_node;
     float_t max_distance;
-    vec3 field_94;
+    vec3 rel_pos;
     RobOsageNodeResetData reset_data;
-    float_t field_C8;
-    float_t field_CC;
+    float_t hit;
+    float_t friction;
     vec3 external_force;
     float_t force;
     RobOsageNodeData* data_ptr;
@@ -3242,6 +3242,8 @@ struct osage_ring_data {
     bool init;
     OsageCollision coli;
     prj::vector<SkinParam::CollisionParam> skp_root_coli;
+
+    float_t get_floor_height(const vec3& pos, const float_t coli_r);
 };
 
 struct osage_setting_osg_cat {
@@ -3396,10 +3398,10 @@ struct struc_342 {
 
 struct CLOTHNode {
     uint32_t flags;
-    vec3 trans;
-    vec3 trans_orig;
-    vec3 prev_trans;
-    vec3 trans_diff;
+    vec3 pos;
+    vec3 fixed_pos;
+    vec3 prev_pos;
+    vec3 delta_pos;
     vec3 normal;
     vec3 tangent;
     vec3 binormal;
@@ -3842,7 +3844,7 @@ struct struc_295 {
 };
 
 struct RobClothRoot {
-    vec3 trans;
+    vec3 pos;
     vec3 normal;
     vec4 tangent;
     bone_node* node[4];
diff --git a/src/KKdLib/obj.cpp b/src/KKdLib/obj.cpp
index 922b79cb..66116a1f 100644
--- a/src/KKdLib/obj.cpp
+++ b/src/KKdLib/obj.cpp
@@ -1020,7 +1020,7 @@ static obj_skin_block_cloth* obj_move_data_skin_block_cloth(const obj_skin_block
 static void obj_move_data_skin_block_cloth_root(obj_skin_block_cloth_root* cloth_root_dst,
     const obj_skin_block_cloth_root* cloth_root_src,
     prj::shared_ptr<prj::stack_allocator> alloc) {
-    cloth_root_dst->trans = cloth_root_src->trans;
+    cloth_root_dst->pos = cloth_root_src->pos;
     cloth_root_dst->normal = cloth_root_src->normal;
     cloth_root_dst->field_18 = cloth_root_src->field_18;
     cloth_root_dst->field_1C = cloth_root_src->field_1C;
@@ -2783,12 +2783,12 @@ static obj_skin_block_cloth* obj_classic_read_skin_block_cloth(
             for (int32_t j = 0; j < cls->num_root; j++) {
                 obj_skin_block_cloth_node* f = &cls->node_array[i * cls->num_root + j];
                 f->flags = s.read_uint32_t();
-                f->trans.x = s.read_float_t();
-                f->trans.y = s.read_float_t();
-                f->trans.z = s.read_float_t();
-                f->trans_diff.x = s.read_float_t();
-                f->trans_diff.y = s.read_float_t();
-                f->trans_diff.z = s.read_float_t();
+                f->pos.x = s.read_float_t();
+                f->pos.y = s.read_float_t();
+                f->pos.z = s.read_float_t();
+                f->delta_pos.x = s.read_float_t();
+                f->delta_pos.y = s.read_float_t();
+                f->delta_pos.z = s.read_float_t();
                 f->dist_top = s.read_float_t();
                 f->dist_bottom = s.read_float_t();
                 f->dist_right = s.read_float_t();
@@ -2893,12 +2893,12 @@ static void obj_classic_write_skin_block_cloth(obj_skin_block_cloth* cls,
             for (int32_t j = 0; j < num_root; j++) {
                 obj_skin_block_cloth_node* f = &node_array[i * cls->num_root + j];
                 s.write_uint32_t(f->flags);
-                s.write_float_t(f->trans.x);
-                s.write_float_t(f->trans.y);
-                s.write_float_t(f->trans.z);
-                s.write_float_t(f->trans_diff.x);
-                s.write_float_t(f->trans_diff.y);
-                s.write_float_t(f->trans_diff.z);
+                s.write_float_t(f->pos.x);
+                s.write_float_t(f->pos.y);
+                s.write_float_t(f->pos.z);
+                s.write_float_t(f->delta_pos.x);
+                s.write_float_t(f->delta_pos.y);
+                s.write_float_t(f->delta_pos.z);
                 s.write_float_t(f->dist_top);
                 s.write_float_t(f->dist_bottom);
                 s.write_float_t(f->dist_right);
@@ -2927,9 +2927,9 @@ static void obj_classic_write_skin_block_cloth(obj_skin_block_cloth* cls,
 
 static void obj_classic_read_skin_block_cloth_root(obj_skin_block_cloth_root* cloth_root,
     prj::shared_ptr<prj::stack_allocator> alloc, stream& s, const char** str) {
-    cloth_root->trans.x = s.read_float_t();
-    cloth_root->trans.y = s.read_float_t();
-    cloth_root->trans.z = s.read_float_t();
+    cloth_root->pos.x = s.read_float_t();
+    cloth_root->pos.y = s.read_float_t();
+    cloth_root->pos.z = s.read_float_t();
     cloth_root->normal.x = s.read_float_t();
     cloth_root->normal.y = s.read_float_t();
     cloth_root->normal.z = s.read_float_t();
@@ -2945,9 +2945,9 @@ static void obj_classic_read_skin_block_cloth_root(obj_skin_block_cloth_root* cl
 
 static void obj_classic_write_skin_block_cloth_root(obj_skin_block_cloth_root* cloth_root,
     stream& s, std::vector<string_hash>& strings, std::vector<int64_t>& string_offsets) {
-    s.write_float_t(cloth_root->trans.x);
-    s.write_float_t(cloth_root->trans.y);
-    s.write_float_t(cloth_root->trans.z);
+    s.write_float_t(cloth_root->pos.x);
+    s.write_float_t(cloth_root->pos.y);
+    s.write_float_t(cloth_root->pos.z);
     s.write_float_t(cloth_root->normal.x);
     s.write_float_t(cloth_root->normal.y);
     s.write_float_t(cloth_root->normal.z);
@@ -6825,12 +6825,12 @@ static obj_skin_block_cloth* obj_modern_read_skin_block_cloth(
             for (int32_t j = 0; j < num_root; j++) {
                 obj_skin_block_cloth_node* f = &node_array[(size_t)i * num_root + j];
                 f->flags = s.read_uint32_t_reverse_endianness();
-                f->trans.x = s.read_float_t_reverse_endianness();
-                f->trans.y = s.read_float_t_reverse_endianness();
-                f->trans.z = s.read_float_t_reverse_endianness();
-                f->trans_diff.x = s.read_float_t_reverse_endianness();
-                f->trans_diff.y = s.read_float_t_reverse_endianness();
-                f->trans_diff.z = s.read_float_t_reverse_endianness();
+                f->pos.x = s.read_float_t_reverse_endianness();
+                f->pos.y = s.read_float_t_reverse_endianness();
+                f->pos.z = s.read_float_t_reverse_endianness();
+                f->delta_pos.x = s.read_float_t_reverse_endianness();
+                f->delta_pos.y = s.read_float_t_reverse_endianness();
+                f->delta_pos.z = s.read_float_t_reverse_endianness();
                 f->dist_top = s.read_float_t_reverse_endianness();
                 f->dist_bottom = s.read_float_t_reverse_endianness();
                 f->dist_right = s.read_float_t_reverse_endianness();
@@ -6959,12 +6959,12 @@ static void obj_modern_write_skin_block_cloth(obj_skin_block_cloth* cls,
             for (int32_t j = 0; j < num_root; j++) {
                 obj_skin_block_cloth_node* f = &node_array[(size_t)i * num_root + j];
                 s.write_uint32_t_reverse_endianness(f->flags);
-                s.write_float_t_reverse_endianness(f->trans.x);
-                s.write_float_t_reverse_endianness(f->trans.y);
-                s.write_float_t_reverse_endianness(f->trans.z);
-                s.write_float_t_reverse_endianness(f->trans_diff.x);
-                s.write_float_t_reverse_endianness(f->trans_diff.y);
-                s.write_float_t_reverse_endianness(f->trans_diff.z);
+                s.write_float_t_reverse_endianness(f->pos.x);
+                s.write_float_t_reverse_endianness(f->pos.y);
+                s.write_float_t_reverse_endianness(f->pos.z);
+                s.write_float_t_reverse_endianness(f->delta_pos.x);
+                s.write_float_t_reverse_endianness(f->delta_pos.y);
+                s.write_float_t_reverse_endianness(f->delta_pos.z);
                 s.write_float_t_reverse_endianness(f->dist_top);
                 s.write_float_t_reverse_endianness(f->dist_bottom);
                 s.write_float_t_reverse_endianness(f->dist_right);
@@ -6997,9 +6997,9 @@ static void obj_modern_write_skin_block_cloth(obj_skin_block_cloth* cls,
 
 static void obj_modern_read_skin_block_cloth_root(obj_skin_block_cloth_root* cloth_root,
     prj::shared_ptr<prj::stack_allocator> alloc, stream& s, uint32_t header_length, const char** str, bool is_x) {
-    cloth_root->trans.x = s.read_float_t();
-    cloth_root->trans.y = s.read_float_t();
-    cloth_root->trans.z = s.read_float_t();
+    cloth_root->pos.x = s.read_float_t();
+    cloth_root->pos.y = s.read_float_t();
+    cloth_root->pos.z = s.read_float_t();
     cloth_root->normal.x = s.read_float_t();
     cloth_root->normal.y = s.read_float_t();
     cloth_root->normal.z = s.read_float_t();
@@ -7015,9 +7015,9 @@ static void obj_modern_read_skin_block_cloth_root(obj_skin_block_cloth_root* clo
 
 static void obj_modern_write_skin_block_cloth_root(obj_skin_block_cloth_root* cloth_root,
     stream& s, std::vector<string_hash>& strings, std::vector<int64_t>& string_offsets, bool is_x) {
-    s.write_float_t(cloth_root->trans.x);
-    s.write_float_t(cloth_root->trans.y);
-    s.write_float_t(cloth_root->trans.z);
+    s.write_float_t(cloth_root->pos.x);
+    s.write_float_t(cloth_root->pos.y);
+    s.write_float_t(cloth_root->pos.z);
     s.write_float_t(cloth_root->normal.x);
     s.write_float_t(cloth_root->normal.y);
     s.write_float_t(cloth_root->normal.z);
diff --git a/src/KKdLib/obj.hpp b/src/KKdLib/obj.hpp
index 2888ca4c..c2d75ac8 100644
--- a/src/KKdLib/obj.hpp
+++ b/src/KKdLib/obj.hpp
@@ -464,7 +464,7 @@ struct obj_skin_block_cloth_root_bone_weight {
 };
 
 struct obj_skin_block_cloth_root {
-    vec3 trans;
+    vec3 pos;
     vec3 normal;
     float_t field_18;
     int32_t field_1C;
@@ -477,8 +477,8 @@ struct obj_skin_block_cloth_root {
 
 struct obj_skin_block_cloth_node {
     uint32_t flags;
-    vec3 trans;
-    vec3 trans_diff;
+    vec3 pos;
+    vec3 delta_pos;
     float_t dist_top;
     float_t dist_bottom;
     float_t dist_right;
diff --git a/src/ReDIVA/data_test/rob_osage_test.cpp b/src/ReDIVA/data_test/rob_osage_test.cpp
index ef2f9a8e..6191db1d 100644
--- a/src/ReDIVA/data_test/rob_osage_test.cpp
+++ b/src/ReDIVA/data_test/rob_osage_test.cpp
@@ -1069,8 +1069,8 @@ void RobOsageTest::disp_coli() {
             etc.data.capsule.slices = 16;
             etc.data.capsule.stacks = 16;
             etc.data.capsule.wire = false;
-            etc.data.capsule.pos[0] = i[-1].trans;
-            etc.data.capsule.pos[1] = i[ 0].trans;
+            etc.data.capsule.pos[0] = i[-1].pos;
+            etc.data.capsule.pos[1] = i[ 0].pos;
             rctx_ptr->disp_manager->entry_obj_etc(&mat4_identity, &etc);
         }
     }
@@ -1089,7 +1089,7 @@ void RobOsageTest::disp_coli() {
             etc.data.sphere.wire = false;
 
             vec3 pos;
-            mat4_transform_point(&itm_eq_obj->item_equip->mat, &i->trans, &pos);
+            mat4_transform_point(&itm_eq_obj->item_equip->mat, &i->pos, &pos);
 
             mat4 mat;
             mat4_translate(&pos, &mat);