Method OnSplineUpdated

Source/Engine/Level/Actors/SplineModel.cpp:118–218

}

void SplineModel::OnSplineUpdated()
{
    // Skip updates when actor is disabled or something is missing
    if (!_spline || !Model || !Model->IsLoaded() || !IsActiveInHierarchy() || _spline->GetSplinePointsCount() < 2)
    {
        _box = BoundingBox(_transform.Translation);
        BoundingSphere::FromBox(_box, _sphere);
        return;
    }
    PROFILE_CPU();

    // Setup model instances over the spline segments
    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 float chunksPerSegmentInv = 1.0f / (float)chunksPerSegment;
    const Transform splineTransform = GetTransform();
    _instances.Resize(segments, false);
    BoundingBox localModelBounds(Vector3::Maximum, Vector3::Minimum);
    {
        auto& meshes = Model->LODs[0].Meshes;
        Vector3 corners[8];
        for (int32 j = 0; j < meshes.Count(); j++)
        {
            const auto& mesh = meshes[j];
            mesh.GetBox().GetCorners(corners);

            for (int32 i = 0; i < 8; i++)
            {
                // Transform mesh corner using pre-transform but use double-precision to prevent issues when rotating model
                Vector3 tmp = corners[i] * _preTransform.Scale;
                double rotation[4] = { (double)_preTransform.Orientation.X, (double)_preTransform.Orientation.Y, (double)_preTransform.Orientation.Z, (double)_preTransform.Orientation.W };
                const double length = sqrt(rotation[0] * rotation[0] + rotation[1] * rotation[1] + rotation[2] * rotation[2] + rotation[3] * rotation[3]);
                rotation[0] /= length;
                rotation[1] /= length;
                rotation[2] /= length;
                rotation[3] /= length;
                double pos[3] = { (double)tmp.X, (double)tmp.Y, (double)tmp.Z };
                const double x = rotation[0] + rotation[0];
                const double y = rotation[1] + rotation[1];
                const double z = rotation[2] + rotation[2];
                const double wx = rotation[3] * x;
                const double wy = rotation[3] * y;
                const double wz = rotation[3] * z;
                const double xx = rotation[0] * x;
                const double xy = rotation[0] * y;
                const double xz = rotation[0] * z;
                const double yy = rotation[1] * y;
                const double yz = rotation[1] * z;
                const double zz = rotation[2] * z;
                tmp = Vector3(
                    (float)(pos[0] * (1.0 - yy - zz) + pos[1] * (xy - wz) + pos[2] * (xz + wy)) + _preTransform.Translation.X,
                    (float)(pos[0] * (xy + wz) + pos[1] * (1.0 - xx - zz) + pos[2] * (yz - wx)) + _preTransform.Translation.Y,
                    (float)(pos[0] * (xz - wy) + pos[1] * (yz + wx) + pos[2] * (1.0 - xx - yy)) + _preTransform.Translation.Z);

                localModelBounds.Minimum = Vector3::Min(localModelBounds.Minimum, tmp);
                localModelBounds.Maximum = Vector3::Max(localModelBounds.Maximum, tmp);
            }