Method UpdateDeformationBuffer

Source/Engine/Level/Actors/SplineModel.cpp:220–324

}

void SplineModel::UpdateDeformationBuffer()
{
    PROFILE_CPU();

    // Deformation buffer contains precomputed matrices for each chunk of the spline segment (packed with transposed float3x4 matrix)
    _deformationDirty = false;
    if (!_deformationBuffer)
        _deformationBuffer = GPUDevice::Instance->CreateBuffer(GetName());
    const auto& keyframes = _spline->Curve.GetKeyframes();
    const int32 segments = keyframes.Count() - 1;
    const int32 chunksPerSegment = Math::Clamp(Math::CeilToInt(SPLINE_RESOLUTION * _quality), 2, 1024);
    const int32 count = (chunksPerSegment * segments + 1) * 3;
    const uint32 size = count * sizeof(Float4);
    if (_deformationBuffer->GetSize() != size)
    {
        if (_deformationBufferData)
        {
            Allocator::Free(_deformationBufferData);
            _deformationBufferData = nullptr;
        }
        if (_deformationBuffer->Init(GPUBufferDescription::Typed(count, PixelFormat::R32G32B32A32_Float, false, IsTransformStatic() ? GPUResourceUsage::Default : GPUResourceUsage::Dynamic)))
        {
            LOG(Error, "Failed to initialize the spline model {0} deformation buffer.", ToString());
            return;
        }
    }
    if (!_deformationBufferData)
        _deformationBufferData = Allocator::Allocate(size);
    _chunksPerSegment = (float)chunksPerSegment;

    // Update pre-calculated matrices for spline chunks
    auto ptr = (Matrix3x4*)_deformationBufferData;
    const float chunksPerSegmentInv = 1.0f / (float)chunksPerSegment;
    Matrix m;
    Transform transform, leftTangent, rightTangent;
    for (int32 segment = 0; segment < segments; segment++)
    {
        auto& instance = _instances[segment];
        const auto& start = keyframes[segment];
        const auto& end = keyframes[segment + 1];
        const float tangentScale = (end.Time - start.Time) / 3.0f;
        AnimationUtils::GetTangent(start.Value, start.TangentOut, tangentScale, leftTangent);
        AnimationUtils::GetTangent(end.Value, end.TangentIn, tangentScale, rightTangent);
        for (int32 chunk = 0; chunk < chunksPerSegment; chunk++)
        {
            const float alpha = (chunk == chunksPerSegment - 1) ? 1.0f : ((float)chunk * chunksPerSegmentInv);

            // Evaluate transformation at the curve
            AnimationUtils::Bezier(start.Value, leftTangent, rightTangent, end.Value, alpha, transform);

            // Apply spline direction (from position 1st derivative)
            Vector3 direction;
            AnimationUtils::BezierFirstDerivative(start.Value.Translation, leftTangent.Translation, rightTangent.Translation, end.Value.Translation, alpha, direction);
            direction.Normalize();
            Quaternion orientation;
            if (direction.IsZero())
                orientation = Quaternion::Identity;
            else if (Vector3::Dot(direction, Vector3::Up) >= 0.999f)