Implement core types about gdext HOT 7 CLOSED

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
use std::ops::*;

use godot_ffi as sys;
use sys::{ffi_methods, GodotFfi};

use super::math::*;

type Inner = glam::f32::Vec2;
//type Inner = glam::f64::DVec2;

#[derive(Default, Copy, Clone, Debug, PartialEq)]
#[repr(C)]
pub struct Vector2 {
    inner: Inner,
}

impl Vector2 {
    pub fn new(x: f32, y: f32) -> Self {
        Self {
            inner: Inner::new(x, y),
        }
    }

    pub fn abs(self) -> Self {
        Self::from_inner(glam::Vector2::abs(self.inner))
    }

    pub fn angle(self) -> f32 {
        self.inner.y.atan2(self.inner.x)
    }

    pub fn angle_to(self, to: Self) -> f32 {
        self.inner.angle_between(to.inner)
    }

    pub fn angle_to_point(self, to: Self) -> f32 {
        Self::from_inner(to - self).angle();
    }

    pub fn aspect(self) -> f32 {
        self.inner.x / self.inner.y
    }

    pub fn bezier_derivative(
        mut self,
        control_1: Self,
        control_2: Self,
        end: Self,
        t: f32,
    ) -> Self {
        self.inner.x = bezier_derivative(self.inner.x, control_1.x, control_2.x, end.x, t);
        self.inner.y = bezier_derivative(self.inner.y, control_1.y, control_2.y, end.y, t);
        self
    }

    pub fn bezier_interpolate(
        mut self,
        control_1: Self,
        control_2: Self,
        end: Self,
        t: f32,
    ) -> Self {
        self.inner.x = bezier_interpolate(self.inner.x, control_1.x, control_2.x, end.x, t);
        self.inner.y = bezier_interpolate(self.inner.y, control_1.y, control_2.y, end.y, t);
        self
    }

    pub fn bounce(self, normal: Self) -> Self {
        -self.reflect(normal)
    }

    pub fn ceil(self) -> Self {
        Self::from_inner(self.inner.ceil())
    }

    pub fn clamp(mut self, min: Self, max: Self) -> Self {
        self.inner.x = if self.inner.x > max.inner.x {
            max.inner.x
        } else if self.inner.x < min.inner.x {
            min.inner.x
        } else {
            self.inner.x
        };
        self.inner.x = if self.inner.y > max.inner.y {
            max.inner.y
        } else if self.inner.y < min.inner.y {
            min.inner.y
        } else {
            self.inner.y
        };
        self
    }

    pub fn cross(self, with: Self) -> f32 {
        Self::from_inner(self.inner.perp_dot(with.inner))
    }

    pub fn cubic_interpolate(mut self, b: Self, pre_a: Self, post_b: Self, weight: f32) -> Self {
        self.inner.x = cubic_interpolate(
            self.inner.x,
            b.inner.x,
            pre_a.inner.x,
            post_b.inner.x,
            weight,
        );
        self.inner.y = cubic_interpolate(
            self.inner.y,
            b.inner.y,
            pre_a.inner.y,
            post_b.inner.y,
            weight,
        );
        self
    }

    pub fn cubic_interpolate_in_time(
        mut self,
        b: Self,
        pre_a: Self,
        post_b: Self,
        weight: f32,
        b_t: f32,
        pre_a_t: f32,
        post_b_t: f32,
    ) -> Self {
        self.inner.x = cubic_interpolate_in_time(
            self.inner.x,
            b.inner.x,
            pre_a.inner.x,
            post_b.inner.x,
            weight,
            b_t,
            pre_a_t,
            post_b_t,
        );
        self.inner.y = cubic_interpolate_in_time(
            self.inner.y,
            b.inner.y,
            pre_a.inner.y,
            post_b.inner.y,
            weight,
            b_t,
            pre_a_t,
            post_b_t,
        );
        self
    }

    pub fn direction_to(self, to: Self) -> Self {
        (to - self).normalize()
    }

    pub fn distance_squared_to(self, to: Self) -> Self {
        Self::from_inner(self.inner.distance_squared(to.inner))
    }

    pub fn distance_to(self, to: Self) -> Self {
        Self::from_inner(self.inner.distance(to.inner))
    }

    pub fn dot(self, other: Self) -> Self {
        Self::from_inner(self.inner.dot(other.inner))
    }

    pub fn floor(self) -> Self {
        Self::from_inner(self.inner.floor())
    }

    pub fn from_angle(angle: f32) -> Self {
        Self::from_inner(Inner::from_angle(angle))
    }

    pub fn is_equal_approx(self, to: Self) -> bool {
        is_equal_approx(self.inner.x, to.inner.x) && is_equal_approx(self.inner.y, to.inner.y);
    }

    pub fn is_finite(self) -> bool {
        self.inner.is_finite()
    }

    pub fn is_normalized(self) -> bool {
        self.inner.is_normalized()
    }

    pub fn is_zero_approx(self) -> bool {
        is_zero_approx(self.inner.x) && is_zero_approx(self.inner.y)
    }

    pub fn length(self) -> f32 {
        self.inner.length()
    }

    pub fn length_squared(self) -> f32 {
        self.inner.length_squared()
    }

    pub fn lerp(self, to: Self, weight: f32) -> Self {
        Self::from_inner(self.inner.lerp(to, weight))
    }

    pub fn limit_length(self, length: Option<f32>) -> Self {
        Self::from_inner(self.inner.clamp_length_max(length.unwrap_or(1.0)))
    }

    pub fn max_axis_index(self) -> i32 {
        if self.inner.max_element() == self.inner.x {
            0
        } else {
            1
        }
    }

    pub fn min_axis_index(self) -> i32 {
        if self.inner.min_element() == self.inner.x {
            0
        } else {
            1
        }
    }

    pub fn move_toward(mut self, to: Self, delta: f32) -> Self {
        let vd = to - self;
        let len = vd.length();
        Self::from_inner(if len <= delta || len < CMP_EPSILON {
            to
        } else {
            self + vd / len * delta
        });
    }

    pub fn normalized(self) -> Self {
        Self::from_inner(self.inner.normalized())
    }

    pub fn orthogonal(self) -> Self {
        Self::from_inner(self.inner.orthogonal())
    }

    pub fn posmod(self, pmod: f32) -> Self {
        Self::new(fposmod(self.inner.x, pmod), fposmod(self.inner.y, pmod))
    }

    pub fn posmodv(self, modv: Self) -> Self {
        Self::new(
            fposmod(self.inner.x, modv.inner.x),
            fposmod(self.inner.y, modv.inner.y),
        )
    }

    pub fn project(self, b: Self) -> Self {
        Self::from_inner(self.inner.project_onto(b.inner))
    }

    pub fn reflect(self, normal: Self) -> Self {
        //Self::from_inner(2.0 * normal.inner * self.dot(normal) - self.inner)
        Self::from_inner(self.inner.reject_from(normal.inner))
    }

    pub fn rotated(self, angle: f32) -> Self {
        Self::from_inner(self.inner.rotate(Self::from_angle(angle)))
    }

    pub fn round(self) -> Self {
        Self::from_inner(self.inner.round())
    }

    pub fn sign(self) -> Self {
        -self
    }

    pub fn slerp(self, to: Self, weight: f32) -> Self {
        let start_length_sq = self.length_squared();
        let end_length_sq = to.length_squared();
        if start_length_sq == 0.0 || end_length_sq == 0.0 {
            self.lerp(to, weight)
        }
        let start_length = start_length_sq.sqrt();
        let result_length = lerp(start_length, end_length_sq.sqrt(), weight);
        let angle = self.angle_to(to);
        self.rotated(angle * weight) * (result_length / start_length)
    }

    pub fn slide(self, normal: Self) -> Self {
        self - normal * self.dot(normal)
    }

    pub fn snapped(self, step: Self) -> Self {
        Self::new(snapped(self.inner.x, step), snapped(self.inner.y, step))
    }

    fn from_inner(inner: Inner) -> Self {
        Self { inner }
    }
}

impl Add for Vector2 {
    type Output = Self;

    fn add(self, other: Self) -> Self {
        Self::new(self.inner.x + other.inner.x, self.inner.y + other.inner.y)
    }
}

impl AddAssign for Vector2 {
    fn add_assign(&mut self, other: Self) {
        *self = self + other
    }
}

impl Sub for Vector2 {
    type Output = Self;

    fn sub(self, other: Self) -> Self {
        Self::new(self.inner.x - other.inner.x, self.inner.y - other.inner.y)
    }
}

impl SubAssign for Vector2 {
    fn sub_assign(&mut self, other: Self) {
        *self = self - other
    }
}

impl Mul for Vector2 {
    type Output = Self;

    fn mul(self, other: f32) -> Self {
        Self::new(self.inner.x * other, self.inner.y * other)
    }
}

impl MulAssign for Vector2 {
    fn mul_assign(&mut self, other: f32) {
        *self = self * other
    }
}

impl Div for Vector2 {
    type Output = Self;

    fn div(self, other: f32) -> Self {
        Self::new(self.inner.x / other, self.inner.y / other)
    }
}

impl DivAssign for Vector2 {
    fn div_assign(&mut self, other: f32) {
        *self = self / other
    }
}

impl Neg for Vector2 {
    type Output = Self;

    fn neg(self) -> Self {
        Self::new(-self.inner.x, -self.inner.y)
    }
}

impl GodotFfi for Vector2 {
    ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
}

impl std::fmt::Display for Vector2 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.inner.fmt(f)
    }
}

// ----------------------------------------------------------------------------------------------------------------------------------------------

type IInner = glam::IVec2;

#[derive(Default, Copy, Clone, Debug, Eq, PartialEq)]
#[repr(C)]
pub struct Vector2i {
    inner: IInner,
}

impl Vector2i {
    pub fn new(x: i32, y: i32) -> Self {
        Self {
            inner: IInner::new(x, y),
        }
    }
}

impl GodotFfi for Vector2i {
    ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
}

impl std::fmt::Display for Vector2i {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.inner.fmt(f)
    }
}