diff --git a/src/ObjLoading/Game/T6/XModel/JsonXModelLoader.cpp b/src/ObjLoading/Game/T6/XModel/JsonXModelLoader.cpp
index ea60842c..a1311d41 100644
--- a/src/ObjLoading/Game/T6/XModel/JsonXModelLoader.cpp
+++ b/src/ObjLoading/Game/T6/XModel/JsonXModelLoader.cpp
@@ -479,16 +479,50 @@ namespace
                                        });
         }
 
+        static void CalculateModelBounds(XModel& xmodel)
+        {
+            if (!xmodel.surfs)
+                return;
+
+            for (auto surfaceIndex = 0u; surfaceIndex < xmodel.lodInfo[0].numsurfs; surfaceIndex++)
+            {
+                const auto& surface = xmodel.surfs[surfaceIndex + xmodel.lodInfo[0].surfIndex];
+
+                if (!surface.verts0)
+                    continue;
+
+                for (auto vertIndex = 0u; vertIndex < surface.vertCount; vertIndex++)
+                {
+                    const auto& vertex = surface.verts0[vertIndex];
+
+                    xmodel.mins.x = std::min(xmodel.mins.x, vertex.xyz.v[0]);
+                    xmodel.mins.y = std::min(xmodel.mins.y, vertex.xyz.v[1]);
+                    xmodel.mins.z = std::min(xmodel.mins.z, vertex.xyz.v[2]);
+                    xmodel.maxs.x = std::max(xmodel.maxs.x, vertex.xyz.v[0]);
+                    xmodel.maxs.y = std::max(xmodel.maxs.y, vertex.xyz.v[1]);
+                    xmodel.maxs.z = std::max(xmodel.maxs.z, vertex.xyz.v[2]);
+                }
+            }
+
+            const auto maxX = std::max(std::abs(xmodel.mins.x), std::abs(xmodel.maxs.x));
+            const auto maxY = std::max(std::abs(xmodel.mins.y), std::abs(xmodel.maxs.y));
+            const auto maxZ = std::max(std::abs(xmodel.mins.z), std::abs(xmodel.maxs.z));
+            xmodel.radius = Eigen::Vector3f(maxX, maxY, maxZ).norm();
+        }
+
         bool CreateXModelFromJson(const JsonXModel& jXModel, XModel& xmodel)
         {
             auto lodNumber = 0u;
             for (const auto& jLod : jXModel.lods)
                 LoadLod(jLod, xmodel, lodNumber++);
+            xmodel.numLods = static_cast<uint16_t>(jXModel.lods.size());
 
             xmodel.numsurfs = static_cast<unsigned char>(m_surfaces.size());
             xmodel.surfs = m_memory.Alloc<XSurface>(xmodel.numsurfs);
             memcpy(xmodel.surfs, m_surfaces.data(), sizeof(XSurface) * xmodel.numsurfs);
 
+            CalculateModelBounds(xmodel);
+
             if (jXModel.collLod && jXModel.collLod.value() >= 0)
             {
                 if (static_cast<unsigned>(jXModel.collLod.value()) >= jXModel.lods.size())
diff --git a/src/ObjLoading/XModel/Gltf/GltfLoader.cpp b/src/ObjLoading/XModel/Gltf/GltfLoader.cpp
index 3de75c3f..b17011ca 100644
--- a/src/ObjLoading/XModel/Gltf/GltfLoader.cpp
+++ b/src/ObjLoading/XModel/Gltf/GltfLoader.cpp
@@ -267,13 +267,22 @@ namespace
                 unsigned joints[4];
                 float weights[4];
 
-                if (!positionAccessor->GetFloatVec3(vertexIndex, vertex.coordinates) || !normalAccessor->GetFloatVec3(vertexIndex, vertex.normal)
+                float coordinates[3];
+                float normal[3];
+                if (!positionAccessor->GetFloatVec3(vertexIndex, coordinates) || !normalAccessor->GetFloatVec3(vertexIndex, normal)
                     || !colorAccessor->GetFloatVec4(vertexIndex, vertex.color) || !colorAccessor->GetFloatVec2(vertexIndex, vertex.uv)
                     || !jointsAccessor->GetUnsignedVec4(vertexIndex, joints) || !weightsAccessor->GetFloatVec4(vertexIndex, weights))
                 {
                     return false;
                 }
 
+                vertex.coordinates[0] = coordinates[0];
+                vertex.coordinates[1] = -coordinates[2];
+                vertex.coordinates[2] = coordinates[1];
+                vertex.normal[0] = normal[0];
+                vertex.normal[1] = -normal[2];
+                vertex.normal[2] = normal[1];
+
                 common.m_vertices.emplace_back(vertex);
 
                 XModelVertexBoneWeights vertexWeights{common.m_bone_weight_data.weights.size(), 0u};