Feaute/projectile pred improvement

include/omath/engines/cry_engine/traits/pred_engine_trait.hpp

@@ -16,7 +16,8 @@ namespace omath::cry_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/frostbite_engine/traits/pred_engine_trait.hpp

@@ -16,7 +16,8 @@ namespace omath::frostbite_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/iw_engine/traits/pred_engine_trait.hpp

@@ -17,7 +17,8 @@ namespace omath::iw_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/opengl_engine/traits/pred_engine_trait.hpp

@@ -16,7 +16,8 @@ namespace omath::opengl_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/source_engine/traits/pred_engine_trait.hpp

@@ -17,7 +17,8 @@ namespace omath::source_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/unity_engine/traits/pred_engine_trait.hpp

@@ -16,7 +16,8 @@ namespace omath::unity_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/engines/unreal_engine/traits/pred_engine_trait.hpp

@@ -16,7 +16,8 @@ namespace omath::unreal_engine
                                                                     const float pitch, const float yaw,
                                                                     const float time, const float gravity) noexcept
         {
-            auto current_pos = projectile.m_origin
+            const auto launch_pos = projectile.m_origin + projectile.m_launch_offset;
+            auto current_pos = launch_pos
                                + forward_vector({PitchAngle::from_degrees(-pitch), YawAngle::from_degrees(yaw),
                                                  RollAngle::from_degrees(0)})
                                          * projectile.m_launch_speed * time;

include/omath/projectile_prediction/proj_pred_engine.hpp

@@ -8,12 +8,23 @@
 
 namespace omath::projectile_prediction
 {
+    struct AimAngles
+    {
+        float pitch{};
+        float yaw{};
+    };
+
     class ProjPredEngineInterface
     {
     public:
         [[nodiscard]]
         virtual std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
                                                                         const Target& target) const = 0;
+
+        [[nodiscard]]
+        virtual std::optional<AimAngles> maybe_calculate_aim_angles(const Projectile& projectile,
+                                                                     const Target& target) const = 0;
+
         virtual ~ProjPredEngineInterface() = default;
     };
 } // namespace omath::projectile_prediction

include/omath/projectile_prediction/proj_pred_engine_avx2.hpp

@@ -12,6 +12,9 @@ namespace omath::projectile_prediction
         [[nodiscard]] std::optional<Vector3<float>>
         maybe_calculate_aim_point(const Projectile& projectile, const Target& target) const override;
 
+        [[nodiscard]] std::optional<AimAngles>
+        maybe_calculate_aim_angles(const Projectile& projectile, const Target& target) const override;
+
         ProjPredEngineAvx2(float gravity_constant, float simulation_time_step, float maximum_simulation_time);
         ~ProjPredEngineAvx2() override = default;
 

include/omath/projectile_prediction/proj_pred_engine_legacy.hpp

@@ -54,6 +54,36 @@ namespace omath::projectile_prediction
         [[nodiscard]]
         std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
                                                                 const Target& target) const override
+        {
+            const auto solution = find_solution(projectile, target);
+            if (!solution)
+                return std::nullopt;
+
+            return EngineTrait::calc_viewpoint_from_angles(projectile, solution->predicted_target_position,
+                                                           solution->pitch);
+        }
+
+        [[nodiscard]]
+        std::optional<AimAngles> maybe_calculate_aim_angles(const Projectile& projectile,
+                                                             const Target& target) const override
+        {
+            const auto solution = find_solution(projectile, target);
+            if (!solution)
+                return std::nullopt;
+
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin + projectile.m_launch_offset, solution->predicted_target_position);
+            return AimAngles{solution->pitch, yaw};
+        }
+
+    private:
+        struct Solution
+        {
+            Vector3<float> predicted_target_position;
+            float pitch;
+        };
+
+        [[nodiscard]]
+        std::optional<Solution> find_solution(const Projectile& projectile, const Target& target) const
         {
             for (float time = 0.f; time < m_maximum_simulation_time; time += m_simulation_time_step)
             {
@@ -70,12 +100,11 @@ namespace omath::projectile_prediction
                                                   time))
                     continue;
 
-                return EngineTrait::calc_viewpoint_from_angles(projectile, predicted_target_position, projectile_pitch);
+                return Solution{predicted_target_position, projectile_pitch.value()};
             }
             return std::nullopt;
         }
 
-    private:
         const float m_gravity_constant;
         const float m_simulation_time_step;
         const float m_maximum_simulation_time;
@@ -100,10 +129,12 @@ namespace omath::projectile_prediction
         {
             const auto bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
 
+            const auto launch_origin = projectile.m_origin + projectile.m_launch_offset;
+
             if (bullet_gravity == 0.f)
-                return EngineTrait::calc_direct_pitch_angle(projectile.m_origin, target_position);
+                return EngineTrait::calc_direct_pitch_angle(launch_origin, target_position);
 
-            const auto delta = target_position - projectile.m_origin;
+            const auto delta = target_position - launch_origin;
 
             const auto distance2d = EngineTrait::calc_vector_2d_distance(delta);
             const auto distance2d_sqr = distance2d * distance2d;
@@ -126,7 +157,7 @@ namespace omath::projectile_prediction
         bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
                                           const float pitch, const float time) const noexcept
         {
-            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin, target_position);
+            const auto yaw = EngineTrait::calc_direct_yaw_angle(projectile.m_origin + projectile.m_launch_offset, target_position);
             const auto projectile_position =
                     EngineTrait::predict_projectile_position(projectile, pitch, yaw, time, m_gravity_constant);
 

include/omath/projectile_prediction/projectile.hpp

@@ -11,6 +11,7 @@ namespace omath::projectile_prediction
     {
     public:
         Vector3<float> m_origin;
+        Vector3<float> m_launch_offset{0.f, 0.f, 0.f};
         float m_launch_speed{};
         float m_gravity_scale{};
     };

source/projectile_prediction/proj_pred_engine_avx2.cpp

@@ -21,7 +21,7 @@ namespace omath::projectile_prediction
         const float bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
         const float v0 = projectile.m_launch_speed;
         const float v0_sqr = v0 * v0;
-        const Vector3 proj_origin = projectile.m_origin;
+        const Vector3 proj_origin = projectile.m_origin + projectile.m_launch_offset;
 
         constexpr int SIMD_FACTOR = 8;
         float current_time = m_simulation_time_step;
@@ -124,6 +124,110 @@ namespace omath::projectile_prediction
                 std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
 #endif
     }
+    std::optional<AimAngles>
+    ProjPredEngineAvx2::maybe_calculate_aim_angles([[maybe_unused]] const Projectile& projectile,
+                                                    [[maybe_unused]] const Target& target) const
+    {
+#if defined(OMATH_USE_AVX2) && defined(__i386__) && defined(__x86_64__)
+        const float bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
+        const float v0 = projectile.m_launch_speed;
+        const Vector3 proj_origin = projectile.m_origin + projectile.m_launch_offset;
+
+        constexpr int SIMD_FACTOR = 8;
+        float current_time = m_simulation_time_step;
+
+        for (; current_time <= m_maximum_simulation_time; current_time += m_simulation_time_step * SIMD_FACTOR)
+        {
+            const __m256 times
+                    = _mm256_setr_ps(current_time, current_time + m_simulation_time_step,
+                                     current_time + m_simulation_time_step * 2, current_time + m_simulation_time_step * 3,
+                                     current_time + m_simulation_time_step * 4, current_time + m_simulation_time_step * 5,
+                                     current_time + m_simulation_time_step * 6, current_time + m_simulation_time_step * 7);
+
+            const __m256 target_x
+                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.x), times, _mm256_set1_ps(target.m_origin.x));
+            const __m256 target_y
+                    = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.y), times, _mm256_set1_ps(target.m_origin.y));
+            const __m256 times_sq = _mm256_mul_ps(times, times);
+            const __m256 target_z = _mm256_fmadd_ps(_mm256_set1_ps(target.m_velocity.z), times,
+                                                   _mm256_fnmadd_ps(_mm256_set1_ps(0.5f * m_gravity_constant), times_sq,
+                                                                    _mm256_set1_ps(target.m_origin.z)));
+
+            const __m256 delta_x = _mm256_sub_ps(target_x, _mm256_set1_ps(proj_origin.x));
+            const __m256 delta_y = _mm256_sub_ps(target_y, _mm256_set1_ps(proj_origin.y));
+
+            const __m256 d_sqr = _mm256_add_ps(_mm256_mul_ps(delta_x, delta_x), _mm256_mul_ps(delta_y, delta_y));
+            const __m256 delta_z = _mm256_sub_ps(target_z, _mm256_set1_ps(proj_origin.z));
+
+            const __m256 bg_times_sq = _mm256_mul_ps(_mm256_set1_ps(bullet_gravity), times_sq);
+            const __m256 term = _mm256_add_ps(delta_z, _mm256_mul_ps(_mm256_set1_ps(0.5f), bg_times_sq));
+            const __m256 term_sq = _mm256_mul_ps(term, term);
+            const __m256 numerator = _mm256_add_ps(d_sqr, term_sq);
+            const __m256 denominator = _mm256_add_ps(times_sq, _mm256_set1_ps(1e-8f));
+            const __m256 required_v0_sqr = _mm256_div_ps(numerator, denominator);
+
+            const __m256 v0_sqr_vec = _mm256_set1_ps(v0 * v0 + 1e-3f);
+            const __m256 mask = _mm256_cmp_ps(required_v0_sqr, v0_sqr_vec, _CMP_LE_OQ);
+
+            const unsigned valid_mask = _mm256_movemask_ps(mask);
+            if (!valid_mask)
+                continue;
+
+            alignas(32) float valid_times[SIMD_FACTOR];
+            _mm256_store_ps(valid_times, times);
+
+            for (int i = 0; i < SIMD_FACTOR; ++i)
+            {
+                if (!(valid_mask & (1 << i)))
+                    continue;
+
+                const float candidate_time = valid_times[i];
+                if (candidate_time > m_maximum_simulation_time)
+                    continue;
+
+                for (float fine_time = candidate_time - m_simulation_time_step * 2;
+                     fine_time <= candidate_time + m_simulation_time_step * 2; fine_time += m_simulation_time_step)
+                {
+                    if (fine_time < 0)
+                        continue;
+
+                    Vector3 target_pos = target.m_origin + target.m_velocity * fine_time;
+                    if (target.m_is_airborne)
+                        target_pos.z -= 0.5f * m_gravity_constant * fine_time * fine_time;
+
+                    const auto pitch = calculate_pitch(proj_origin, target_pos, bullet_gravity, v0, fine_time);
+                    if (!pitch)
+                        continue;
+
+                    const Vector3 delta = target_pos - projectile.m_origin;
+                    const float yaw = angles::radians_to_degrees(std::atan2(delta.y, delta.x));
+                    return AimAngles{*pitch, yaw};
+                }
+            }
+        }
+
+        for (; current_time <= m_maximum_simulation_time; current_time += m_simulation_time_step)
+        {
+            Vector3 target_pos = target.m_origin + target.m_velocity * current_time;
+            if (target.m_is_airborne)
+                target_pos.z -= 0.5f * m_gravity_constant * current_time * current_time;
+
+            const auto pitch = calculate_pitch(proj_origin, target_pos, bullet_gravity, v0, current_time);
+            if (!pitch)
+                continue;
+
+            const Vector3 delta = target_pos - projectile.m_origin;
+            const float yaw = angles::radians_to_degrees(std::atan2(delta.y, delta.x));
+            return AimAngles{*pitch, yaw};
+        }
+
+        return std::nullopt;
+#else
+        throw std::runtime_error(
+                std::format("{} AVX2 feature is not enabled!", std::source_location::current().function_name()));
+#endif
+    }
+
     ProjPredEngineAvx2::ProjPredEngineAvx2(const float gravity_constant, const float simulation_time_step,
                                            const float maximum_simulation_time)
         : m_gravity_constant(gravity_constant), m_simulation_time_step(simulation_time_step),