admin/omath
1
0
Fork 0
mirror of https://github.com/orange-cpp/omath.git synced 2026-02-13 07:03:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #44 from orange-cpp/feature/noexcept

Browse Source 
Feature/noexcept
This commit is contained in:
Orange++
2025-05-05 02:34:43 +03:00
committed by GitHub
parent f6f8bba032 5489c296e9
commit 1196bb86b4
35 changed files with 235 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/omath/3d_primitives/box.hpp
View File

@@ -13,5 +13,5 @@ namespace omath::primitives
[[nodiscard]]
std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
const Vector3<float>& dir_forward, const Vector3<float>& dir_right,
float ratio = 4.f);
float ratio = 4.f) noexcept;
}

36
include/omath/angle.hpp
View File

@@ -20,7 +20,7 @@ namespace omath
class Angle
{
Type m_angle;
constexpr explicit Angle(const Type& degrees)
constexpr explicit Angle(const Type& degrees) noexcept
{
if constexpr (flags == AngleFlags::Normalized)
m_angle = angles::wrap_angle(degrees, min, max);
@@ -36,68 +36,68 @@ namespace omath
public:
[[nodiscard]]
constexpr static Angle from_degrees(const Type& degrees)
constexpr static Angle from_degrees(const Type& degrees) noexcept
{
return Angle{degrees};
}
constexpr Angle(): m_angle(0)
constexpr Angle() noexcept: m_angle(0)
{
}
[[nodiscard]]
constexpr static Angle from_radians(const Type& degrees)
constexpr static Angle from_radians(const Type& degrees) noexcept
{
return Angle{angles::radians_to_degrees<Type>(degrees)};
}
[[nodiscard]]
constexpr const Type& operator*() const
constexpr const Type& operator*() const noexcept
{
return m_angle;
}
[[nodiscard]]
constexpr Type as_degrees() const
constexpr Type as_degrees() const noexcept
{
return m_angle;
}
[[nodiscard]]
constexpr Type as_radians() const
constexpr Type as_radians() const noexcept
{
return angles::degrees_to_radians(m_angle);
}
[[nodiscard]]
Type sin() const
Type sin() const noexcept
{
return std::sin(as_radians());
}
[[nodiscard]]
Type cos() const
Type cos() const noexcept
{
return std::cos(as_radians());
}
[[nodiscard]]
Type tan() const
Type tan() const noexcept
{
return std::tan(as_radians());
}
[[nodiscard]]
Type atan() const
Type atan() const noexcept
{
return std::atan(as_radians());
}
[[nodiscard]]
Type cot() const
Type cot() const noexcept
{
return cos() / sin();
}
constexpr Angle& operator+=(const Angle& other)
constexpr Angle& operator+=(const Angle& other) noexcept
{
if constexpr (flags == AngleFlags::Normalized)
m_angle = angles::wrap_angle(m_angle + other.m_angle, min, max);
@@ -114,15 +114,15 @@ namespace omath
}
[[nodiscard]]
constexpr std::partial_ordering operator<=>(const Angle& other) const = default;
constexpr std::partial_ordering operator<=>(const Angle& other) const noexcept = default;
constexpr Angle& operator-=(const Angle& other)
constexpr Angle& operator-=(const Angle& other) noexcept
{
return operator+=(-other);
}
[[nodiscard]]
constexpr Angle& operator+(const Angle& other)
constexpr Angle& operator+(const Angle& other) noexcept
{
if constexpr (flags == AngleFlags::Normalized)
return {angles::wrap_angle(m_angle + other.m_angle, min, max)};
@@ -137,13 +137,13 @@ namespace omath
}
[[nodiscard]]
constexpr Angle& operator-(const Angle& other)
constexpr Angle& operator-(const Angle& other) noexcept
{
return operator+(-other);
}
[[nodiscard]]
constexpr Angle operator-() const
constexpr Angle operator-() const noexcept
{
return Angle{-m_angle};
}

14
include/omath/angles.hpp
View File

@@ -10,21 +10,21 @@ namespace omath::angles
{
template<class Type>
requires std::is_floating_point_v<Type>
[[nodiscard]] constexpr Type radians_to_degrees(const Type& radians)
[[nodiscard]] constexpr Type radians_to_degrees(const Type& radians) noexcept
{
return radians * (static_cast<Type>(180) / std::numbers::pi_v<Type>);
}
template<class Type>
requires std::is_floating_point_v<Type>
[[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees)
[[nodiscard]] constexpr Type degrees_to_radians(const Type& degrees) noexcept
{
return degrees * (std::numbers::pi_v<Type> / static_cast<Type>(180));
}
template<class Type>
requires std::is_floating_point_v<Type>
[[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect)
[[nodiscard]] Type horizontal_fov_to_vertical(const Type& horizontal_fov, const Type& aspect) noexcept
{
const auto fov_rad = degrees_to_radians(horizontal_fov);
@@ -35,19 +35,19 @@ namespace omath::angles
template<class Type>
requires std::is_floating_point_v<Type>
[[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect)
[[nodiscard]] Type vertical_fov_to_horizontal(const Type& vertical_fov, const Type& aspect) noexcept
{
const auto fov_as_radians = degrees_to_radians(vertical_fov);
const auto horizontal_fov
= static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
const auto horizontal_fov =
static_cast<Type>(2) * std::atan(std::tan(fov_as_radians / static_cast<Type>(2)) * aspect);
return radians_to_degrees(horizontal_fov);
}
template<class Type>
requires std::is_arithmetic_v<Type>
[[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max)
[[nodiscard]] Type wrap_angle(const Type& angle, const Type& min, const Type& max) noexcept
{
if (angle <= max && angle >= min)
return angle;

8
include/omath/collision/line_tracer.hpp
View File

@@ -16,10 +16,10 @@ namespace omath::collision
bool infinite_length = false;
[[nodiscard]]
Vector3<float> direction_vector() const;
Vector3<float> direction_vector() const noexcept;
[[nodiscard]]
Vector3<float> direction_vector_normalized() const;
Vector3<float> direction_vector_normalized() const noexcept;
};
class LineTracer
{
@@ -27,11 +27,11 @@ namespace omath::collision
LineTracer() = delete;
[[nodiscard]]
static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle);
static bool can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
// Realization of Möller–Trumbore intersection algorithm
// https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm
[[nodiscard]]
static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle);
static Vector3<float> get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept;
};
} // namespace omath::collision

22
include/omath/color.hpp
View File

@@ -28,20 +28,20 @@ namespace omath
class Color final : public Vector4<float>
{
public:
constexpr Color(const float r, const float g, const float b, const float a): Vector4(r, g, b, a)
constexpr Color(const float r, const float g, const float b, const float a) noexcept: Vector4(r, g, b, a)
{
clamp(0.f, 1.f);
}
constexpr explicit Color() = default;
constexpr explicit Color() noexcept = default;
[[nodiscard]]
constexpr static Color from_rgba(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a)
constexpr static Color from_rgba(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a) noexcept
{
return Color{Vector4(r, g, b, a) / 255.f};
}
[[nodiscard]]
constexpr static Color from_hsv(float hue, const float saturation, const float value)
constexpr static Color from_hsv(float hue, const float saturation, const float value) noexcept
{
float r{}, g{}, b{};
@@ -82,13 +82,13 @@ namespace omath
}
[[nodiscard]]
constexpr static Color from_hsv(const Hsv& hsv)
constexpr static Color from_hsv(const Hsv& hsv) noexcept
{
return from_hsv(hsv.hue, hsv.saturation, hsv.value);
}
[[nodiscard]]
constexpr Hsv to_hsv() const
constexpr Hsv to_hsv() const noexcept
{
Hsv hsv_data;
@@ -120,11 +120,11 @@ namespace omath
return hsv_data;
}
constexpr explicit Color(const Vector4& vec): Vector4(vec)
constexpr explicit Color(const Vector4& vec) noexcept: Vector4(vec)
{
clamp(0.f, 1.f);
}
constexpr void set_hue(const float hue)
constexpr void set_hue(const float hue) noexcept
{
auto hsv = to_hsv();
hsv.hue = hue;
@@ -132,7 +132,7 @@ namespace omath
*this = from_hsv(hsv);
}
constexpr void set_saturation(const float saturation)
constexpr void set_saturation(const float saturation) noexcept
{
auto hsv = to_hsv();
hsv.saturation = saturation;
@@ -140,7 +140,7 @@ namespace omath
*this = from_hsv(hsv);
}
constexpr void set_value(const float value)
constexpr void set_value(const float value) noexcept
{
auto hsv = to_hsv();
hsv.value = value;
@@ -148,7 +148,7 @@ namespace omath
*this = from_hsv(hsv);
}
[[nodiscard]]
constexpr Color blend(const Color& other, float ratio) const
constexpr Color blend(const Color& other, float ratio) const noexcept
{
ratio = std::clamp(ratio, 0.f, 1.f);
return Color(*this * (1.f - ratio) + other * ratio);

4
include/omath/engines/iw_engine/camera.hpp
View File

@@ -16,7 +16,7 @@ namespace omath::iw_engine
void look_at(const Vector3<float>& target) override;
protected:
[[nodiscard]] Mat4X4 calc_view_matrix() const override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const override;
[[nodiscard]] Mat4X4 calc_view_matrix() const noexcept override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const noexcept override;
};
} // namespace omath::iw_engine

4
include/omath/engines/opengl_engine/camera.hpp
View File

@@ -13,7 +13,7 @@ namespace omath::opengl_engine
Camera(const Vector3<float>& position, const ViewAngles& view_angles, const projection::ViewPort& view_port,
const Angle<float, 0.f, 180.f, AngleFlags::Clamped>& fov, float near, float far);
void look_at(const Vector3<float>& target) override;
[[nodiscard]] Mat4X4 calc_view_matrix() const override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const override;
[[nodiscard]] Mat4X4 calc_view_matrix() const noexcept override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const noexcept override;
};
} // namespace omath::opengl_engine

12
include/omath/engines/opengl_engine/formulas.hpp
View File

@@ -8,19 +8,19 @@
namespace omath::opengl_engine
{
[[nodiscard]]
Vector3<float> forward_vector(const ViewAngles& angles);
Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
[[nodiscard]]
Vector3<float> right_vector(const ViewAngles& angles);
Vector3<float> right_vector(const ViewAngles& angles) noexcept;
[[nodiscard]]
Vector3<float> up_vector(const ViewAngles& angles);
Vector3<float> up_vector(const ViewAngles& angles) noexcept;
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
[[nodiscard]]
Mat4X4 rotation_matrix(const ViewAngles& angles);
Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
[[nodiscard]]
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
} // namespace omath::opengl_engine

4
include/omath/engines/source_engine/camera.hpp
View File

@@ -15,7 +15,7 @@ namespace omath::source_engine
void look_at(const Vector3<float>& target) override;
protected:
[[nodiscard]] Mat4X4 calc_view_matrix() const override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const override;
[[nodiscard]] Mat4X4 calc_view_matrix() const noexcept override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const noexcept override;
};
} // namespace omath::source_engine

12
include/omath/engines/source_engine/formulas.hpp
View File

@@ -7,19 +7,19 @@
namespace omath::source_engine
{
[[nodiscard]]
Vector3<float> forward_vector(const ViewAngles& angles);
Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
[[nodiscard]]
Mat4X4 rotation_matrix(const ViewAngles& angles);
Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
[[nodiscard]]
Vector3<float> right_vector(const ViewAngles& angles);
Vector3<float> right_vector(const ViewAngles& angles) noexcept;
[[nodiscard]]
Vector3<float> up_vector(const ViewAngles& angles);
Vector3<float> up_vector(const ViewAngles& angles) noexcept;
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
[[nodiscard]]
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
} // namespace omath::source_engine

4
include/omath/engines/unity_engine/camera.hpp
View File

@@ -16,7 +16,7 @@ namespace omath::unity_engine
void look_at(const Vector3<float>& target) override;
protected:
[[nodiscard]] Mat4X4 calc_view_matrix() const override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const override;
[[nodiscard]] Mat4X4 calc_view_matrix() const noexcept override;
[[nodiscard]] Mat4X4 calc_projection_matrix() const noexcept override;
};
} // namespace omath::unity_engine

12
include/omath/engines/unity_engine/formulas.hpp
View File

@@ -8,19 +8,19 @@
namespace omath::unity_engine
{
[[nodiscard]]
Vector3<float> forward_vector(const ViewAngles& angles);
Vector3<float> forward_vector(const ViewAngles& angles) noexcept;
[[nodiscard]]
Vector3<float> right_vector(const ViewAngles& angles);
Vector3<float> right_vector(const ViewAngles& angles) noexcept;
[[nodiscard]]
Vector3<float> up_vector(const ViewAngles& angles);
Vector3<float> up_vector(const ViewAngles& angles) noexcept;
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin);
[[nodiscard]] Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept;
[[nodiscard]]
Mat4X4 rotation_matrix(const ViewAngles& angles);
Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept;
[[nodiscard]]
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far);
Mat4X4 calc_perspective_projection_matrix(float field_of_view, float aspect_ratio, float near, float far) noexcept;
} // namespace omath::unity_engine

6
include/omath/pathfinding/a_star.hpp
View File

@@ -15,16 +15,16 @@ namespace omath::pathfinding
public:
[[nodiscard]]
static std::vector<Vector3<float>> find_path(const Vector3<float>& start, const Vector3<float>& end,
const NavigationMesh& nav_mesh);
const NavigationMesh& nav_mesh) noexcept;
private:
[[nodiscard]]
static std::vector<Vector3<float>>
reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
const Vector3<float>& current);
const Vector3<float>& current) noexcept;
[[nodiscard]]
static auto get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
const Vector3<float>& end_vertex);
const Vector3<float>& end_vertex) noexcept;
};
} // namespace omath::pathfinding

8
include/omath/pathfinding/navigation_mesh.hpp
View File

@@ -20,17 +20,17 @@ namespace omath::pathfinding
{
public:
[[nodiscard]]
std::expected<Vector3<float>, std::string> get_closest_vertex(const Vector3<float>& point) const;
std::expected<Vector3<float>, std::string> get_closest_vertex(const Vector3<float>& point) const noexcept;
[[nodiscard]]
const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const;
const std::vector<Vector3<float>>& get_neighbors(const Vector3<float>& vertex) const noexcept;
[[nodiscard]]
bool empty() const;
[[nodiscard]] std::vector<uint8_t> serialize() const;
[[nodiscard]] std::vector<uint8_t> serialize() const noexcept;
void deserialize(const std::vector<uint8_t>& raw);
void deserialize(const std::vector<uint8_t>& raw) noexcept;
std::unordered_map<Vector3<float>, std::vector<Vector3<float>>> m_vertex_map;
};

6
include/omath/projectile_prediction/proj_pred_engine_avx2.hpp
View File

@@ -9,8 +9,8 @@ namespace omath::projectile_prediction
class ProjPredEngineAvx2 final : public ProjPredEngine
{
public:
[[nodiscard]] std::optional<Vector3<float>> maybe_calculate_aim_point(const Projectile& projectile,
const Target& target) const override;
[[nodiscard]] std::optional<Vector3<float>>
maybe_calculate_aim_point(const Projectile& projectile, const Target& target) const override;
ProjPredEngineAvx2(float gravity_constant, float simulation_time_step, float maximum_simulation_time);
~ProjPredEngineAvx2() override = default;
@@ -18,7 +18,7 @@ namespace omath::projectile_prediction
private:
[[nodiscard]] static std::optional<float> calculate_pitch(const Vector3<float>& proj_origin,
const Vector3<float>& target_pos,
float bullet_gravity, float v0, float time);
float bullet_gravity, float v0, float time) ;
// We use [[maybe_unused]] here since AVX2 is not available for ARM and ARM64 CPU
[[maybe_unused]] const float m_gravity_constant;

7
include/omath/projectile_prediction/proj_pred_engine_legacy.hpp
View File

@@ -29,11 +29,12 @@ namespace omath::projectile_prediction
const float m_distance_tolerance;
[[nodiscard]]
std::optional<float> maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
const Vector3<float>& target_position) const;
std::optional<float>
maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
const Vector3<float>& target_position) const noexcept;
[[nodiscard]]
bool is_projectile_reached_target(const Vector3<float>& target_position, const Projectile& projectile,
float pitch, float time) const;
float pitch, float time) const noexcept;
};
} // namespace omath::projectile_prediction

2
include/omath/projectile_prediction/projectile.hpp
View File

@@ -11,7 +11,7 @@ namespace omath::projectile_prediction
{
public:
[[nodiscard]]
Vector3<float> predict_position(float pitch, float yaw, float time, float gravity) const;
Vector3<float> predict_position(float pitch, float yaw, float time, float gravity) const noexcept;
Vector3<float> m_origin;
float m_launch_speed{};

2
include/omath/projectile_prediction/target.hpp
View File

@@ -11,7 +11,7 @@ namespace omath::projectile_prediction
{
public:
[[nodiscard]]
constexpr Vector3<float> predict_position(const float time, const float gravity) const
constexpr Vector3<float> predict_position(const float time, const float gravity) const noexcept
{
auto predicted = m_origin + m_velocity * time;

43
include/omath/projection/camera.hpp
View File

@@ -32,7 +32,7 @@ namespace omath::projection
public:
virtual ~Camera() = default;
Camera(const Vector3<float>& position, const ViewAnglesType& view_angles, const ViewPort& view_port,
const FieldOfView& fov, const float near, const float far)
const FieldOfView& fov, const float near, const float far) noexcept
: m_view_port(view_port), m_field_of_view(fov), m_far_plane_distance(far), m_near_plane_distance(near),
m_view_angles(view_angles), m_origin(position)
{
@@ -41,17 +41,17 @@ namespace omath::projection
protected:
virtual void look_at(const Vector3<float>& target) = 0;
[[nodiscard]] virtual Mat4X4Type calc_view_matrix() const = 0;
[[nodiscard]] virtual Mat4X4Type calc_view_matrix() const noexcept = 0;
[[nodiscard]] virtual Mat4X4Type calc_projection_matrix() const = 0;
[[nodiscard]] virtual Mat4X4Type calc_projection_matrix() const noexcept = 0;
[[nodiscard]] Mat4X4Type calc_view_projection_matrix() const
[[nodiscard]] Mat4X4Type calc_view_projection_matrix() const noexcept
{
return calc_projection_matrix() * calc_view_matrix();
}
public:
[[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const
[[nodiscard]] const Mat4X4Type& get_view_projection_matrix() const noexcept
{
if (!m_view_projection_matrix.has_value())
m_view_projection_matrix = calc_view_projection_matrix();
@@ -59,68 +59,69 @@ namespace omath::projection
return m_view_projection_matrix.value();
}
void set_field_of_view(const FieldOfView& fov)
void set_field_of_view(const FieldOfView& fov) noexcept
{
m_field_of_view = fov;
m_view_projection_matrix = std::nullopt;
}
void set_near_plane(const float near)
void set_near_plane(const float near) noexcept
{
m_near_plane_distance = near;
m_view_projection_matrix = std::nullopt;
}
void set_far_plane(const float far)
void set_far_plane(const float far) noexcept
{
m_far_plane_distance = far;
m_view_projection_matrix = std::nullopt;
}
void set_view_angles(const ViewAnglesType& view_angles)
void set_view_angles(const ViewAnglesType& view_angles) noexcept
{
m_view_angles = view_angles;
m_view_projection_matrix = std::nullopt;
}
void set_origin(const Vector3<float>& origin)
void set_origin(const Vector3<float>& origin) noexcept
{
m_origin = origin;
m_view_projection_matrix = std::nullopt;
}
void set_view_port(const ViewPort& view_port)
void set_view_port(const ViewPort& view_port) noexcept
{
m_view_port = view_port;
m_view_projection_matrix = std::nullopt;
}
[[nodiscard]] const FieldOfView& get_field_of_view() const
[[nodiscard]] const FieldOfView& get_field_of_view() const noexcept
{
return m_field_of_view;
}
[[nodiscard]] const float& get_near_plane() const
[[nodiscard]] const float& get_near_plane() const noexcept
{
return m_near_plane_distance;
}
[[nodiscard]] const float& get_far_plane() const
[[nodiscard]] const float& get_far_plane() const noexcept
{
return m_far_plane_distance;
}
[[nodiscard]] const ViewAnglesType& get_view_angles() const
[[nodiscard]] const ViewAnglesType& get_view_angles() const noexcept
{
return m_view_angles;
}
[[nodiscard]] const Vector3<float>& get_origin() const
[[nodiscard]] const Vector3<float>& get_origin() const noexcept
{
return m_origin;
}
[[nodiscard]] std::expected<Vector3<float>, Error> world_to_screen(const Vector3<float>& world_position) const
[[nodiscard]] std::expected<Vector3<float>, Error>
world_to_screen(const Vector3<float>& world_position) const noexcept
{
auto normalized_cords = world_to_view_port(world_position);
@@ -131,7 +132,7 @@ namespace omath::projection
}
[[nodiscard]] std::expected<Vector3<float>, Error>
world_to_view_port(const Vector3<float>& world_position) const
world_to_view_port(const Vector3<float>& world_position) const noexcept
{
auto projected = get_view_projection_matrix()
* mat_column_from_vector<float, Mat4X4Type::get_store_ordering()>(world_position);
@@ -160,13 +161,13 @@ namespace omath::projection
Vector3<float> m_origin;
private:
template<class Type> [[nodiscard]]
constexpr static bool is_ndc_out_of_bounds(const Type& ndc)
template<class Type>
[[nodiscard]] constexpr static bool is_ndc_out_of_bounds(const Type& ndc) noexcept
{
return std::ranges::any_of(ndc.raw_array(), [](const auto& val) { return val < -1 || val > 1; });
}
[[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const
[[nodiscard]] Vector3<float> ndc_to_screen_position(const Vector3<float>& ndc) const noexcept
{
return {(ndc.x + 1.f) / 2.f * m_view_port.m_width, (1.f - ndc.y) / 2.f * m_view_port.m_height, ndc.z};
}

56
include/omath/vector2.hpp
View File

@@ -24,25 +24,25 @@ namespace omath
// Constructors
constexpr Vector2() = default;
constexpr Vector2(const Type& x, const Type& y): x(x), y(y)
constexpr Vector2(const Type& x, const Type& y) noexcept: x(x), y(y)
{
}
// Equality operators
[[nodiscard]]
constexpr bool operator==(const Vector2& src) const
constexpr bool operator==(const Vector2& src) const noexcept
{
return x == src.x && y == src.y;
}
[[nodiscard]]
constexpr bool operator!=(const Vector2& src) const
constexpr bool operator!=(const Vector2& src) const noexcept
{
return !(*this == src);
}
// Compound assignment operators
constexpr Vector2& operator+=(const Vector2& v)
constexpr Vector2& operator+=(const Vector2& v) noexcept
{
x += v.x;
y += v.y;
@@ -50,7 +50,7 @@ namespace omath
return *this;
}
constexpr Vector2& operator-=(const Vector2& v)
constexpr Vector2& operator-=(const Vector2& v) noexcept
{
x -= v.x;
y -= v.y;
@@ -58,7 +58,7 @@ namespace omath
return *this;
}
constexpr Vector2& operator*=(const Vector2& v)
constexpr Vector2& operator*=(const Vector2& v) noexcept
{
x *= v.x;
y *= v.y;
@@ -66,7 +66,7 @@ namespace omath
return *this;
}
constexpr Vector2& operator/=(const Vector2& v)
constexpr Vector2& operator/=(const Vector2& v) noexcept
{
x /= v.x;
y /= v.y;
@@ -74,7 +74,7 @@ namespace omath
return *this;
}
constexpr Vector2& operator*=(const Type& fl)
constexpr Vector2& operator*=(const Type& fl) noexcept
{
x *= fl;
y *= fl;
@@ -82,7 +82,7 @@ namespace omath
return *this;
}
constexpr Vector2& operator/=(const Type& fl)
constexpr Vector2& operator/=(const Type& fl) noexcept
{
x /= fl;
y /= fl;
@@ -90,7 +90,7 @@ namespace omath
return *this;
}
constexpr Vector2& operator+=(const Type& fl)
constexpr Vector2& operator+=(const Type& fl) noexcept
{
x += fl;
y += fl;
@@ -98,7 +98,7 @@ namespace omath
return *this;
}
constexpr Vector2& operator-=(const Type& fl)
constexpr Vector2& operator-=(const Type& fl) noexcept
{
x -= fl;
y -= fl;
@@ -107,50 +107,50 @@ namespace omath
}
// Basic vector operations
[[nodiscard]] Type distance_to(const Vector2& other) const
[[nodiscard]] Type distance_to(const Vector2& other) const noexcept
{
return std::sqrt(distance_to_sqr(other));
}
[[nodiscard]] constexpr Type distance_to_sqr(const Vector2& other) const
[[nodiscard]] constexpr Type distance_to_sqr(const Vector2& other) const noexcept
{
return (x - other.x) * (x - other.x) + (y - other.y) * (y - other.y);
}
[[nodiscard]] constexpr Type dot(const Vector2& other) const
[[nodiscard]] constexpr Type dot(const Vector2& other) const noexcept
{
return x * other.x + y * other.y;
}
#ifndef _MSC_VER
[[nodiscard]] constexpr Type length() const
[[nodiscard]] constexpr Type length() const noexcept
{
return std::hypot(this->x, this->y);
}
[[nodiscard]] constexpr Vector2 normalized() const
[[nodiscard]] constexpr Vector2 normalized() const noexcept
{
const Type len = length();
return len > 0.f ? *this / len : *this;
}
#else
[[nodiscard]] Type length() const
[[nodiscard]] Type length() const noexcept
{
return std::hypot(x, y);
}
[[nodiscard]] Vector2 normalized() const
[[nodiscard]] Vector2 normalized() const noexcept
{
const Type len = length();
return len > 0.f ? *this / len : *this;
}
#endif
[[nodiscard]] constexpr Type length_sqr() const
[[nodiscard]] constexpr Type length_sqr() const noexcept
{
return x * x + y * y;
}
constexpr Vector2& abs()
constexpr Vector2& abs() noexcept
{
// FIXME: Replace with std::abs, if it will become constexprable
x = x < 0 ? -x : x;
@@ -158,47 +158,47 @@ namespace omath
return *this;
}
[[nodiscard]] constexpr Vector2 operator-() const
[[nodiscard]] constexpr Vector2 operator-() const noexcept
{
return {-x, -y};
}
// Binary arithmetic operators
[[nodiscard]] constexpr Vector2 operator+(const Vector2& v) const
[[nodiscard]] constexpr Vector2 operator+(const Vector2& v) const noexcept
{
return {x + v.x, y + v.y};
}
[[nodiscard]] constexpr Vector2 operator-(const Vector2& v) const
[[nodiscard]] constexpr Vector2 operator-(const Vector2& v) const noexcept
{
return {x - v.x, y - v.y};
}
[[nodiscard]] constexpr Vector2 operator*(const float fl) const
[[nodiscard]] constexpr Vector2 operator*(const float fl) const noexcept
{
return {x * fl, y * fl};
}
[[nodiscard]] constexpr Vector2 operator/(const float fl) const
[[nodiscard]] constexpr Vector2 operator/(const float fl) const noexcept
{
return {x / fl, y / fl};
}
// Sum of elements
[[nodiscard]] constexpr Type sum() const
[[nodiscard]] constexpr Type sum() const noexcept
{
return x + y;
}
[[nodiscard]]
constexpr std::tuple<Type, Type> as_tuple() const
constexpr std::tuple<Type, Type> as_tuple() const noexcept
{
return std::make_tuple(x, y);
}
#ifdef OMATH_IMGUI_INTEGRATION
[[nodiscard]]
ImVec2 to_im_vec2() const
ImVec2 to_im_vec2() const noexcept
{
return {static_cast<float>(this->x), static_cast<float>(this->y)};
}

68
include/omath/vector3.hpp
View File

@@ -24,22 +24,22 @@ namespace omath
{
public:
Type z = static_cast<Type>(0);
constexpr Vector3(const Type& x, const Type& y, const Type& z): Vector2<Type>(x, y), z(z)
constexpr Vector3(const Type& x, const Type& y, const Type& z) noexcept: Vector2<Type>(x, y), z(z)
{
}
constexpr Vector3(): Vector2<Type>() {};
constexpr Vector3() noexcept: Vector2<Type>() {};
[[nodiscard]] constexpr bool operator==(const Vector3& src) const
[[nodiscard]] constexpr bool operator==(const Vector3& src) const noexcept
{
return Vector2<Type>::operator==(src) && (src.z == z);
}
[[nodiscard]] constexpr bool operator!=(const Vector3& src) const
[[nodiscard]] constexpr bool operator!=(const Vector3& src) const noexcept
{
return !(*this == src);
}
constexpr Vector3& operator+=(const Vector3& v)
constexpr Vector3& operator+=(const Vector3& v) noexcept
{
Vector2<Type>::operator+=(v);
z += v.z;
@@ -47,7 +47,7 @@ namespace omath
return *this;
}
constexpr Vector3& operator-=(const Vector3& v)
constexpr Vector3& operator-=(const Vector3& v) noexcept
{
Vector2<Type>::operator-=(v);
z -= v.z;
@@ -55,7 +55,7 @@ namespace omath
return *this;
}
constexpr Vector3& operator*=(const float fl)
constexpr Vector3& operator*=(const float fl) noexcept
{
Vector2<Type>::operator*=(fl);
z *= fl;
@@ -63,7 +63,7 @@ namespace omath
return *this;
}
constexpr Vector3& operator*=(const Vector3& v)
constexpr Vector3& operator*=(const Vector3& v) noexcept
{
Vector2<Type>::operator*=(v);
z *= v.z;
@@ -71,7 +71,7 @@ namespace omath
return *this;
}
constexpr Vector3& operator/=(const Vector3& v)
constexpr Vector3& operator/=(const Vector3& v) noexcept
{
Vector2<Type>::operator/=(v);
z /= v.z;
@@ -79,7 +79,7 @@ namespace omath
return *this;
}
constexpr Vector3& operator+=(const float fl)
constexpr Vector3& operator+=(const float fl) noexcept
{
Vector2<Type>::operator+=(fl);
z += fl;
@@ -87,7 +87,7 @@ namespace omath
return *this;
}
constexpr Vector3& operator/=(const float fl)
constexpr Vector3& operator/=(const float fl) noexcept
{
Vector2<Type>::operator/=(fl);
z /= fl;
@@ -95,7 +95,7 @@ namespace omath
return *this;
}
constexpr Vector3& operator-=(const float fl)
constexpr Vector3& operator-=(const float fl) noexcept
{
Vector2<Type>::operator-=(fl);
z -= fl;
@@ -103,7 +103,7 @@ namespace omath
return *this;
}
constexpr Vector3& abs()
constexpr Vector3& abs() noexcept
{
Vector2<Type>::abs();
z = z < 0.f ? -z : z;
@@ -111,12 +111,12 @@ namespace omath
return *this;
}
[[nodiscard]] constexpr Type distance_to_sqr(const Vector3& other) const
[[nodiscard]] constexpr Type distance_to_sqr(const Vector3& other) const noexcept
{
return (*this - other).length_sqr();
}
[[nodiscard]] constexpr Type dot(const Vector3& other) const
[[nodiscard]] constexpr Type dot(const Vector3& other) const noexcept
{
return Vector2<Type>::dot(other) + z * other.z;
}
@@ -142,80 +142,80 @@ namespace omath
return length_value != 0 ? *this / length_value : *this;
}
#else
[[nodiscard]] Type length() const
[[nodiscard]] Type length() const noexcept
{
return std::hypot(this->x, this->y, z);
}
[[nodiscard]] Vector3 normalized() const
[[nodiscard]] Vector3 normalized() const noexcept
{
const Type len = this->length();
return len != 0 ? *this / len : *this;
}
[[nodiscard]] Type length_2d() const
[[nodiscard]] Type length_2d() const noexcept
{
return Vector2<Type>::length();
}
[[nodiscard]] Type distance_to(const Vector3& vOther) const
[[nodiscard]] Type distance_to(const Vector3& vOther) const noexcept
{
return (*this - vOther).length();
}
#endif
[[nodiscard]] constexpr Type length_sqr() const
[[nodiscard]] constexpr Type length_sqr() const noexcept
{
return Vector2<Type>::length_sqr() + z * z;
}
[[nodiscard]] constexpr Vector3 operator-() const
[[nodiscard]] constexpr Vector3 operator-() const noexcept
{
return {-this->x, -this->y, -z};
}
[[nodiscard]] constexpr Vector3 operator+(const Vector3& v) const
[[nodiscard]] constexpr Vector3 operator+(const Vector3& v) const noexcept
{
return {this->x + v.x, this->y + v.y, z + v.z};
}
[[nodiscard]] constexpr Vector3 operator-(const Vector3& v) const
[[nodiscard]] constexpr Vector3 operator-(const Vector3& v) const noexcept
{
return {this->x - v.x, this->y - v.y, z - v.z};
}
[[nodiscard]] constexpr Vector3 operator*(const float fl) const
[[nodiscard]] constexpr Vector3 operator*(const float fl) const noexcept
{
return {this->x * fl, this->y * fl, z * fl};
}
[[nodiscard]] constexpr Vector3 operator*(const Vector3& v) const
[[nodiscard]] constexpr Vector3 operator*(const Vector3& v) const noexcept
{
return {this->x * v.x, this->y * v.y, z * v.z};
}
[[nodiscard]] constexpr Vector3 operator/(const float fl) const
[[nodiscard]] constexpr Vector3 operator/(const float fl) const noexcept
{
return {this->x / fl, this->y / fl, z / fl};
}
[[nodiscard]] constexpr Vector3 operator/(const Vector3& v) const
[[nodiscard]] constexpr Vector3 operator/(const Vector3& v) const noexcept
{
return {this->x / v.x, this->y / v.y, z / v.z};
}
[[nodiscard]] constexpr Vector3 cross(const Vector3& v) const
[[nodiscard]] constexpr Vector3 cross(const Vector3& v) const noexcept
{
return {this->y * v.z - z * v.y, z * v.x - this->x * v.z, this->x * v.y - this->y * v.x};
}
[[nodiscard]] constexpr Type sum() const
[[nodiscard]] constexpr Type sum() const noexcept
{
return sum_2d() + z;
}
[[nodiscard]] std::expected<Angle<float, 0.f, 180.f, AngleFlags::Clamped>, Vector3Error>
angle_between(const Vector3& other) const
angle_between(const Vector3& other) const noexcept
{
const auto bottom = length() * other.length();
@@ -225,7 +225,7 @@ namespace omath
return Angle<float, 0.f, 180.f, AngleFlags::Clamped>::from_radians(std::acos(dot(other) / bottom));
}
[[nodiscard]] bool is_perpendicular(const Vector3& other) const
[[nodiscard]] bool is_perpendicular(const Vector3& other) const noexcept
{
if (const auto angle = angle_between(other))
return angle->as_degrees() == 90.f;
@@ -233,17 +233,17 @@ namespace omath
return false;
}
[[nodiscard]] constexpr Type sum_2d() const
[[nodiscard]] constexpr Type sum_2d() const noexcept
{
return Vector2<Type>::sum();
}
[[nodiscard]] constexpr std::tuple<Type, Type, Type> as_tuple() const
[[nodiscard]] constexpr std::tuple<Type, Type, Type> as_tuple() const noexcept
{
return std::make_tuple(this->x, this->y, z);
}
[[nodiscard]] Vector3 view_angle_to(const Vector3& other) const
[[nodiscard]] Vector3 view_angle_to(const Vector3& other) const noexcept
{
const float distance = distance_to(other);
const auto delta = other - *this;

46
include/omath/vector4.hpp
View File

@@ -17,21 +17,21 @@ namespace omath
constexpr Vector4(const Type& x, const Type& y, const Type& z, const Type& w): Vector3<Type>(x, y, z), w(w)
{
}
constexpr Vector4(): Vector3<Type>(), w(0) {};
constexpr Vector4() noexcept : Vector3<Type>(), w(0) {};
[[nodiscard]]
constexpr bool operator==(const Vector4& src) const
constexpr bool operator==(const Vector4& src) const noexcept
{
return Vector3<Type>::operator==(src) && w == src.w;
}
[[nodiscard]]
constexpr bool operator!=(const Vector4& src) const
constexpr bool operator!=(const Vector4& src) const noexcept
{
return !(*this == src);
}
constexpr Vector4& operator+=(const Vector4& v)
constexpr Vector4& operator+=(const Vector4& v) noexcept
{
Vector3<Type>::operator+=(v);
w += v.w;
@@ -39,7 +39,7 @@ namespace omath
return *this;
}
constexpr Vector4& operator-=(const Vector4& v)
constexpr Vector4& operator-=(const Vector4& v) noexcept
{
Vector3<Type>::operator-=(v);
w -= v.w;
@@ -47,7 +47,7 @@ namespace omath
return *this;
}
constexpr Vector4& operator*=(const float scalar)
constexpr Vector4& operator*=(const float scalar) noexcept
{
Vector3<Type>::operator*=(scalar);
w *= scalar;
@@ -55,7 +55,7 @@ namespace omath
return *this;
}
constexpr Vector4& operator*=(const Vector4& v)
constexpr Vector4& operator*=(const Vector4& v) noexcept
{
Vector3<Type>::operator*=(v);
w *= v.w;
@@ -63,7 +63,7 @@ namespace omath
return *this;
}
constexpr Vector4& operator/=(const float scalar)
constexpr Vector4& operator/=(const float scalar) noexcept
{
Vector3<Type>::operator/=(scalar);
w /= scalar;
@@ -71,36 +71,36 @@ namespace omath
return *this;
}
constexpr Vector4& operator/=(const Vector4& v)
constexpr Vector4& operator/=(const Vector4& v) noexcept
{
Vector3<Type>::operator/=(v);
w /= v.w;
return *this;
}
[[nodiscard]] constexpr Type length_sqr() const
[[nodiscard]] constexpr Type length_sqr() const noexcept
{
return Vector3<Type>::length_sqr() + w * w;
}
[[nodiscard]] constexpr Type dot(const Vector4& other) const
[[nodiscard]] constexpr Type dot(const Vector4& other) const noexcept
{
return Vector3<Type>::dot(other) + w * other.w;
}
[[nodiscard]] Vector3<Type> length() const
[[nodiscard]] Vector3<Type> length() const noexcept
{
return std::sqrt(length_sqr());
}
constexpr Vector4& abs()
constexpr Vector4& abs() noexcept
{
Vector3<Type>::abs();
w = w < 0.f ? -w : w;
return *this;
}
constexpr Vector4& clamp(const Type& min, const Type& max)
constexpr Vector4& clamp(const Type& min, const Type& max) noexcept
{
this->x = std::clamp(this->x, min, max);
this->y = std::clamp(this->y, min, max);
@@ -110,56 +110,56 @@ namespace omath
}
[[nodiscard]]
constexpr Vector4 operator-() const
constexpr Vector4 operator-() const noexcept
{
return {-this->x, -this->y, -this->z, -w};
}
[[nodiscard]]
constexpr Vector4 operator+(const Vector4& v) const
constexpr Vector4 operator+(const Vector4& v) const noexcept
{
return {this->x + v.x, this->y + v.y, this->z + v.z, w + v.w};
}
[[nodiscard]]
constexpr Vector4 operator-(const Vector4& v) const
constexpr Vector4 operator-(const Vector4& v) const noexcept
{
return {this->x - v.x, this->y - v.y, this->z - v.z, w - v.w};
}
[[nodiscard]]
constexpr Vector4 operator*(const Type& scalar) const
constexpr Vector4 operator*(const Type& scalar) const noexcept
{
return {this->x * scalar, this->y * scalar, this->z * scalar, w * scalar};
}
[[nodiscard]]
constexpr Vector4 operator*(const Vector4& v) const
constexpr Vector4 operator*(const Vector4& v) const noexcept
{
return {this->x * v.x, this->y * v.y, this->z * v.z, w * v.w};
}
[[nodiscard]]
constexpr Vector4 operator/(const Type& scalar) const
constexpr Vector4 operator/(const Type& scalar) const noexcept
{
return {this->x / scalar, this->y / scalar, this->z / scalar, w / scalar};
}
[[nodiscard]]
constexpr Vector4 operator/(const Vector4& v) const
constexpr Vector4 operator/(const Vector4& v) const noexcept
{
return {this->x / v.x, this->y / v.y, this->z / v.z, w / v.w};
}
[[nodiscard]]
constexpr Type sum() const
constexpr Type sum() const noexcept
{
return Vector3<Type>::sum() + w;
}
#ifdef OMATH_IMGUI_INTEGRATION
[[nodiscard]]
ImVec4 to_im_vec4() const
ImVec4 to_im_vec4() const noexcept
{
return {
static_cast<float>(this->x),

2
source/3d_primitives/box.cpp
View File

@@ -7,7 +7,7 @@ namespace omath::primitives
{
std::array<Triangle<Vector3<float>>, 12> create_box(const Vector3<float>& top, const Vector3<float>& bottom,
const Vector3<float>& dir_forward,
const Vector3<float>& dir_right, const float ratio)
const Vector3<float>& dir_right, const float ratio) noexcept
{
const auto height = top.distance_to(bottom);
const auto side_size = height / ratio;

8
source/collision/line_tracer.cpp
View File

@@ -5,21 +5,21 @@
namespace omath::collision
{
bool LineTracer::can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle)
bool LineTracer::can_trace_line(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept
{
return get_ray_hit_point(ray, triangle) == ray.end;
}
Vector3<float> Ray::direction_vector() const
Vector3<float> Ray::direction_vector() const noexcept
{
return end - start;
}
Vector3<float> Ray::direction_vector_normalized() const
Vector3<float> Ray::direction_vector_normalized() const noexcept
{
return direction_vector().normalized();
}
Vector3<float> LineTracer::get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle)
Vector3<float> LineTracer::get_ray_hit_point(const Ray& ray, const Triangle<Vector3<float>>& triangle) noexcept
{
constexpr float k_epsilon = std::numeric_limits<float>::epsilon();

4
source/engines/iw_engine/camera.cpp
View File

@@ -21,11 +21,11 @@ namespace omath::iw_engine
m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
m_view_angles.roll = RollAngle::from_radians(0.f);
}
Mat4X4 Camera::calc_view_matrix() const
Mat4X4 Camera::calc_view_matrix() const noexcept
{
return iw_engine::calc_view_matrix(m_view_angles, m_origin);
}
Mat4X4 Camera::calc_projection_matrix() const
Mat4X4 Camera::calc_projection_matrix() const noexcept
{
return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
m_near_plane_distance, m_far_plane_distance);

4
source/engines/opengl_engine/camera.cpp
View File

@@ -21,11 +21,11 @@ namespace omath::opengl_engine
m_view_angles.yaw = -YawAngle::from_radians(std::atan2(delta.y, delta.x));
m_view_angles.roll = RollAngle::from_radians(0.f);
}
Mat4X4 Camera::calc_view_matrix() const
Mat4X4 Camera::calc_view_matrix() const noexcept
{
return opengl_engine::calc_view_matrix(m_view_angles, m_origin);
}
Mat4X4 Camera::calc_projection_matrix() const
Mat4X4 Camera::calc_projection_matrix() const noexcept
{
return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
m_near_plane_distance, m_far_plane_distance);

12
source/engines/opengl_engine/formulas.cpp
View File

@@ -6,39 +6,39 @@
namespace omath::opengl_engine
{
Vector3<float> forward_vector(const ViewAngles& angles)
Vector3<float> forward_vector(const ViewAngles& angles) noexcept
{
const auto vec
= rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_forward);
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> right_vector(const ViewAngles& angles)
Vector3<float> right_vector(const ViewAngles& angles) noexcept
{
const auto vec
= rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_right);
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> up_vector(const ViewAngles& angles)
Vector3<float> up_vector(const ViewAngles& angles) noexcept
{
const auto vec = rotation_matrix(angles) * mat_column_from_vector<float, MatStoreType::COLUMN_MAJOR>(k_abs_up);
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
{
return mat_camera_view<float, MatStoreType::COLUMN_MAJOR>(-forward_vector(angles), right_vector(angles),
up_vector(angles), cam_origin);
}
Mat4X4 rotation_matrix(const ViewAngles& angles)
Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
{
return mat_rotation_axis_x<float, MatStoreType::COLUMN_MAJOR>(-angles.pitch)
* mat_rotation_axis_y<float, MatStoreType::COLUMN_MAJOR>(-angles.yaw)
* mat_rotation_axis_z<float, MatStoreType::COLUMN_MAJOR>(angles.roll);
}
Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
const float far)
const float far) noexcept
{
const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);

4
source/engines/source_engine/camera.cpp
View File

@@ -22,12 +22,12 @@ namespace omath::source_engine
m_view_angles.roll = RollAngle::from_radians(0.f);
}
Mat4X4 Camera::calc_view_matrix() const
Mat4X4 Camera::calc_view_matrix() const noexcept
{
return source_engine::calc_view_matrix(m_view_angles, m_origin);
}
Mat4X4 Camera::calc_projection_matrix() const
Mat4X4 Camera::calc_projection_matrix() const noexcept
{
return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
m_near_plane_distance, m_far_plane_distance);

12
source/engines/source_engine/formulas.cpp
View File

@@ -5,38 +5,38 @@
namespace omath::source_engine
{
Vector3<float> forward_vector(const ViewAngles& angles)
Vector3<float> forward_vector(const ViewAngles& angles) noexcept
{
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Mat4X4 rotation_matrix(const ViewAngles& angles)
Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
{
return mat_rotation_axis_z(angles.yaw) * mat_rotation_axis_y(angles.pitch) * mat_rotation_axis_x(angles.roll);
}
Vector3<float> right_vector(const ViewAngles& angles)
Vector3<float> right_vector(const ViewAngles& angles) noexcept
{
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> up_vector(const ViewAngles& angles)
Vector3<float> up_vector(const ViewAngles& angles) noexcept
{
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
{
return mat_camera_view(forward_vector(angles), right_vector(angles), up_vector(angles), cam_origin);
}
Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
const float far)
const float far) noexcept
{
// NOTE: Need magic number to fix fov calculation, since source inherit Quake proj matrix calculation
constexpr auto k_multiply_factor = 0.75f;

4
source/engines/unity_engine/camera.cpp
View File

@@ -15,11 +15,11 @@ namespace omath::unity_engine
{
throw std::runtime_error("Not implemented");
}
Mat4X4 Camera::calc_view_matrix() const
Mat4X4 Camera::calc_view_matrix() const noexcept
{
return unity_engine::calc_view_matrix(m_view_angles, m_origin);
}
Mat4X4 Camera::calc_projection_matrix() const
Mat4X4 Camera::calc_projection_matrix() const noexcept
{
return calc_perspective_projection_matrix(m_field_of_view.as_degrees(), m_view_port.aspect_ratio(),
m_near_plane_distance, m_far_plane_distance);

12
source/engines/unity_engine/formulas.cpp
View File

@@ -5,37 +5,37 @@
namespace omath::unity_engine
{
Vector3<float> forward_vector(const ViewAngles& angles)
Vector3<float> forward_vector(const ViewAngles& angles) noexcept
{
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_forward);
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> right_vector(const ViewAngles& angles)
Vector3<float> right_vector(const ViewAngles& angles) noexcept
{
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_right);
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Vector3<float> up_vector(const ViewAngles& angles)
Vector3<float> up_vector(const ViewAngles& angles) noexcept
{
const auto vec = rotation_matrix(angles) * mat_column_from_vector(k_abs_up);
return {vec.at(0, 0), vec.at(1, 0), vec.at(2, 0)};
}
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin)
Mat4X4 calc_view_matrix(const ViewAngles& angles, const Vector3<float>& cam_origin) noexcept
{
return mat_camera_view<float, MatStoreType::ROW_MAJOR>(forward_vector(angles), -right_vector(angles),
up_vector(angles), cam_origin);
}
Mat4X4 rotation_matrix(const ViewAngles& angles)
Mat4X4 rotation_matrix(const ViewAngles& angles) noexcept
{
return mat_rotation_axis_x<float, MatStoreType::ROW_MAJOR>(angles.pitch)
* mat_rotation_axis_y<float, MatStoreType::ROW_MAJOR>(angles.yaw)
* mat_rotation_axis_z<float, MatStoreType::ROW_MAJOR>(angles.roll);
}
Mat4X4 calc_perspective_projection_matrix(const float field_of_view, const float aspect_ratio, const float near,
const float far)
const float far) noexcept
{
const float fov_half_tan = std::tan(angles::degrees_to_radians(field_of_view) / 2.f);

6
source/pathfinding/a_star.cpp
View File

@@ -17,7 +17,7 @@ namespace omath::pathfinding
std::vector<Vector3<float>>
Astar::reconstruct_final_path(const std::unordered_map<Vector3<float>, PathNode>& closed_list,
const Vector3<float>& current)
const Vector3<float>& current) noexcept
{
std::vector<Vector3<float>> path;
std::optional current_opt = current;
@@ -38,7 +38,7 @@ namespace omath::pathfinding
return path;
}
auto Astar::get_perfect_node(const std::unordered_map<Vector3<float>, PathNode>& open_list,
const Vector3<float>& end_vertex)
const Vector3<float>& end_vertex) noexcept
{
return std::ranges::min_element(open_list,
[&end_vertex](const auto& a, const auto& b)
@@ -50,7 +50,7 @@ namespace omath::pathfinding
}
std::vector<Vector3<float>> Astar::find_path(const Vector3<float>& start, const Vector3<float>& end,
const NavigationMesh& nav_mesh)
const NavigationMesh& nav_mesh) noexcept
{
std::unordered_map<Vector3<float>, PathNode> closed_list;
std::unordered_map<Vector3<float>, PathNode> open_list;

9
source/pathfinding/navigation_mesh.cpp
View File

@@ -6,7 +6,8 @@
#include <stdexcept>
namespace omath::pathfinding
{
std::expected<Vector3<float>, std::string> NavigationMesh::get_closest_vertex(const Vector3<float>& point) const
std::expected<Vector3<float>, std::string>
NavigationMesh::get_closest_vertex(const Vector3<float>& point) const noexcept
{
const auto res = std::ranges::min_element(m_vertex_map, [&point](const auto& a, const auto& b)
{ return a.first.distance_to(point) < b.first.distance_to(point); });
@@ -17,7 +18,7 @@ namespace omath::pathfinding
return res->first;
}
const std::vector<Vector3<float>>& NavigationMesh::get_neighbors(const Vector3<float>& vertex) const
const std::vector<Vector3<float>>& NavigationMesh::get_neighbors(const Vector3<float>& vertex) const noexcept
{
return m_vertex_map.at(vertex);
}
@@ -27,7 +28,7 @@ namespace omath::pathfinding
return m_vertex_map.empty();
}
std::vector<uint8_t> NavigationMesh::serialize() const
std::vector<uint8_t> NavigationMesh::serialize() const noexcept
{
auto dump_to_vector = []<typename T>(const T& t, std::vector<uint8_t>& vec)
{
@@ -50,7 +51,7 @@ namespace omath::pathfinding
return raw;
}
void NavigationMesh::deserialize(const std::vector<uint8_t>& raw)
void NavigationMesh::deserialize(const std::vector<uint8_t>& raw) noexcept
{
auto load_from_vector = [](const std::vector<uint8_t>& vec, size_t& offset, auto& value)
{

11
source/projectile_prediction/proj_pred_engine_legacy.cpp
View File

@@ -18,8 +18,8 @@ namespace omath::projectile_prediction
{
const auto predicted_target_position = target.predict_position(time, m_gravity_constant);
const auto projectile_pitch
= maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
const auto projectile_pitch =
maybe_calculate_projectile_launch_pitch_angle(projectile, predicted_target_position);
if (!projectile_pitch.has_value()) [[unlikely]]
continue;
@@ -35,9 +35,8 @@ namespace omath::projectile_prediction
return std::nullopt;
}
std::optional<float>
ProjPredEngineLegacy::maybe_calculate_projectile_launch_pitch_angle(const Projectile& projectile,
const Vector3<float>& target_position) const
std::optional<float> ProjPredEngineLegacy::maybe_calculate_projectile_launch_pitch_angle(
const Projectile& projectile, const Vector3<float>& target_position) const noexcept
{
const auto bullet_gravity = m_gravity_constant * projectile.m_gravity_scale;
const auto delta = target_position - projectile.m_origin;
@@ -60,7 +59,7 @@ namespace omath::projectile_prediction
bool ProjPredEngineLegacy::is_projectile_reached_target(const Vector3<float>& target_position,
const Projectile& projectile, const float pitch,
const float time) const
const float time) const noexcept
{
const auto yaw = projectile.m_origin.view_angle_to(target_position).y;
const auto projectile_position = projectile.predict_position(pitch, yaw, time, m_gravity_constant);

2
source/projectile_prediction/projectile.cpp
View File

@@ -8,7 +8,7 @@
namespace omath::projectile_prediction
{
Vector3<float> Projectile::predict_position(const float pitch, const float yaw, const float time,
const float gravity) const
const float gravity) const noexcept
{
auto current_pos = m_origin
+ source_engine::forward_vector({source_engine::PitchAngle::from_degrees(-pitch),