Method TransformBuffer

Source/Engine/Graphics/Models/ModelData.cpp:228–283

}

void MeshData::TransformBuffer(const Matrix& matrix)
{
    // Compute matrix inverse transpose
    Matrix inverseTransposeMatrix;
    Matrix::Invert(matrix, inverseTransposeMatrix);
    Matrix::Transpose(inverseTransposeMatrix, inverseTransposeMatrix);

    // Transform blend shapes
    for (auto& blendShape : BlendShapes)
    {
        const auto vv = blendShape.Vertices.Get();
        for (int32 i = 0; i < blendShape.Vertices.Count(); i++)
        {
            auto& v = vv[i];

            Float3 p = Positions[v.VertexIndex];
            Float3 vp = p + v.PositionDelta;
            Float3::Transform(vp, matrix, vp);
            Float3::Transform(p, matrix, p);
            v.PositionDelta = vp - p;

            Float3 n = Normals[v.VertexIndex];
            Float3 vn = n + v.NormalDelta;
            vn.Normalize();
            Float3::TransformNormal(vn, inverseTransposeMatrix, vn);
            vn.Normalize();
            Float3::TransformNormal(n, inverseTransposeMatrix, n);
            n.Normalize();
            v.NormalDelta = vn - n;
        }
    }

    // Transform positions
    const auto pp = Positions.Get();
    for (int32 i = 0; i < Positions.Count(); i++)
    {
        auto& p = pp[i];
        Float3::Transform(p, matrix, p);
    }

    // Transform normals and tangents
    const auto nn = Normals.Get();
    for (int32 i = 0; i < Normals.Count(); i++)
    {
        auto& n = nn[i];
        Float3::TransformNormal(n, inverseTransposeMatrix, n);
        n.Normalize();
    }
    const auto tt = Tangents.Get();
    for (int32 i = 0; i < Tangents.Count(); i++)
    {
        auto& t = tt[i];
        Float3::TransformNormal(t, inverseTransposeMatrix, t);
        t.Normalize();
    }
}

void MeshData::NormalizeBlendWeights()