; /////////////////////////////////////////////////////////////////////////////
;
;        ██████╗██████╗ ██╗     ██████╗  █████╗ ████████╗ ██████╗ ██████╗
;       ██╔════╝██╔══██╗██║     ██╔══██╗██╔══██╗╚══██╔══╝██╔═══██╗██╔══██╗
;       ██║     ██████╔╝██║     ██████╔╝███████║   ██║   ██║   ██║██████╔╝
;       ██║     ██╔═══╝ ██║     ██╔══██╗██╔══██║   ██║   ██║   ██║██╔══██╗
;       ╚██████╗██║     ███████╗██████╔╝██║  ██║   ██║   ╚██████╔╝██║  ██║
;        ╚═════╝╚═╝     ╚══════╝╚═════╝ ╚═╝  ╚═╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝
;
;
; MIT License
;
; Copyright (c) 2023 , CplBator
;
; Permission is hereby granted, free of charge, To any person obtaining a copy
; of this software And associated documentation files (the "Software"), To deal
; in the Software without restriction, including without limitation the rights
; To use, copy, modify, merge, publish, distribute, sublicense, And/Or sell
; copies of the Software, And To permit persons To whom the Software is
; furnished To do so, subject To the following conditions:
;
; The above copyright notice And this permission notice shall be included in all
; copies Or substantial portions of the Software.
;
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS Or
; IMPLIED, INCLUDING BUT Not LIMITED To THE WARRANTIES OF MERCHANTABILITY,
; FITNESS For A PARTICULAR PURPOSE And NONINFRINGEMENT. IN NO EVENT SHALL THE
; AUTHORS Or COPYRIGHT HOLDERS BE LIABLE For ANY CLAIM, DAMAGES Or OTHER
; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT Or OTHERWISE, ARISING FROM,
; OUT OF Or IN CONNECTION With THE SOFTWARE Or THE USE Or OTHER DEALINGS IN THE
; SOFTWARE.
;
; /////////////////////////////////////////////////////////////////////////////

XIncludeFile "Math.pbi"

;//////////////////////////////////////////////////////////////////////////////
;
;//////////////////////////////////////////////////////////////////////////////
DeclareModule Vector2

  Structure sVector2
    *vtable
    x.Math::real
    y.Math::real
  EndStructure

  Interface iVector2
    Free()
    Set(x.Math::real, y.Math::real)
    SetX(value.Math::real)
    X.Math::real()
    SetY(value.Math::real)
    Y.Math::real()
    Add(left.iVector2, right.iVector2)
    Sub(left.iVector2, right.iVector2)
    Mul(left.iVector2, right.iVector2)
    Div(left.iVector2, right.iVector2)
    Scale(value.f)
    Length.Math::real()
    SquaredLength.Math::real()
    Distance.Math::real(vector.iVector2)
    SquaredDistance.Math::real(vector.iVector2)
    DotProduct.Math::real(vector.iVector2)
    Normalize.Math::real()
    MidPoint(lhs.iVector2, rhs.iVector2)
    Floor(cmp.iVector2)
    Ceil(cmp.iVector2)
    Perpendicular()
    CrossProduct.Math::real(vec.iVector2)
    IsZeroLength.l()
    Reflect(normal.iVector2)
    AngleBetween.Math::real(vec.iVector2)
  EndInterface

  Declare.i New(x.Math::real = 0.0, y.Math::real = 0.0)
  Declare.i Copy(source.iVector2, destination.iVector2 = #Null)

EndDeclareModule



;//////////////////////////////////////////////////////////////////////////////
;
;//////////////////////////////////////////////////////////////////////////////
Module Vector2


  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.i New(x.Math::real = 0.0, y.Math::real = 0.0)
    *v.sVector2 = AllocateStructure(sVector2)
    If *v <> #Null
      *v\vtable = ?vtable
      *v\x = x
      *v\y = y
    EndIf
    ProcedureReturn *v
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Free(*v.sVector2)
    If *v <> #Null
      FreeStructure(*v)
    EndIf
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.i Copy(*source.sVector2, *destination.sVector2 = #Null)
    If *destination = #Null
      *destination = New(*source\x,*source\y)
    Else
      *destination\x = *source\x
      *destination\y = *source\y
    EndIf
    ProcedureReturn *destination
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Set(*v.sVector2, x.Math::real, y.Math::real)
    *v\x = x
    *v\y = y
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure SetX(*v.sVector2, value.Math::real)
    *v\x = value
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real X(*v.sVector2)
    ProcedureReturn *v\x
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure SetY(*v.sVector2, value.Math::real)
    *v\y = value
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real Y(*v.sVector2)
    ProcedureReturn *v\y
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Add(*v.sVector2, *left.sVector2, *right.sVector2)
    *v\x = *left\x + *right\x
    *v\y = *left\y + *right\y
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Sub(*v.sVector2, *left.sVector2, *right.sVector2)
    *v\x = *left\x + *right\x
    *v\y = *left\y + *right\y
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Mul(*v.sVector2, *left.sVector2, *right.sVector2)
    *v\x = *left\x * *right\x
    *v\y = *left\y * *right\y
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Div(*v.sVector2, *left.sVector2, *right.sVector2)
    *v\x = *left\x / *right\x
    *v\y = *left\y / *right\y
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Scale(*v.sVector2, value.Math::real)
    *v\x * value
    *v\y * value
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real Length(*v.sVector2)
    ProcedureReturn Sqr( *v\x * *v\x  + *v\y * *v\y )
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real SquaredLength(*v.sVector2)
    ProcedureReturn (*v\x * *v\x)  + (*v\y * *v\y)
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real Distance(*v.sVector2, *rhs.sVector2)
    temp.sVector2
    temp\x = *v\x - *rhs\x
    temp\y = *v\y - *rhs\y
    ProcedureReturn Length(@temp)
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real SquaredDistance(*v.sVector2, *rhs.sVector2)
    temp.sVector2
    temp\x = *v\x - *rhs\x
    temp\y = *v\y - *rhs\y
    ProcedureReturn SquaredLength(@temp)
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real DotProduct(*v.sVector2, *vec.sVector2)
    ProcedureReturn *v\x * *vec\x + *v\y * *vec\y
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real Normalize(*v.sVector2)
    fLength.Math::real = Length(*v)
    If fLength > 0.0
      fInvLength = 1.0 / fLength
      *v\x * fInvLength
      *v\y * fInvLength
    EndIf
    ProcedureReturn fLength
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure MidPoint(*v.sVector2, *lhs.sVector2, *rhs.sVector2)
    *v\x = (*lhs\x + *rhs\x) * 0.5
    *v\y = (*lhs\y + *rhs\y) * 0.5
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Floor(*v.sVector2, *cmp.sVector2)
    If *cmp\x < *v\x : *v\x = *cmp\x : EndIf
    If *cmp\y < *v\y : *v\y = *cmp\y : EndIf
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Ceil(*v.sVector2, *cmp.sVector2)
    If *cmp\x > *v\x : *v\x = *cmp\x : EndIf
    If *cmp\y > *v\y : *v\y = *cmp\y : EndIf
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Perpendicular(*v.sVector2)
    temp.Math::real = *v\x
    *v\x = -*v\y
    *v\y = temp
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real CrossProduct(*v.sVector2, *vec.sVector2)
    ProcedureReturn *v\x * *vec\y - *vec\x * *v\y
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.l IsZeroLength(*v.sVector2)
    fLength.Math::real = SquaredLength(*v)
    If fLength < (1e-06 * 1e-06)
      ProcedureReturn #True
    Else
      ProcedureReturn #False
    EndIf
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure Reflect(*v.sVector2, *normal.sVector2)
    fDot.Math::real = DotProduct(*v, *normal)
    *v\x = *v\x - 2 * fDot * *normal\x
    *v\y = *v\y - 2 * fDot * *normal\y
  EndProcedure

  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  Procedure.Math::real AngleBetween(*v.sVector2, *other.sVector2)
    angle.Math::real = ATan2(*other\y, -*other\x) - ATan2(*v\y, -*v\x)
    angle + #PI / 2.0
    If angle < 0 : angle + Math::#TWO_PI : EndIf
    ProcedureReturn angle
  EndProcedure



  ;////////////////////////////////////////////////////////////////////////////
  ;
  ;////////////////////////////////////////////////////////////////////////////
  DataSection
    vtable:
    Data.i @Free()
    Data.i @Set()
    Data.i @SetX()
    Data.i @X()
    Data.i @SetY()
    Data.i @Y()
    Data.i @Add()
    Data.i @Sub()
    Data.i @Mul()
    Data.i @Div()
    Data.i @Scale()
    Data.i @Length()
    Data.i @SquaredLength()
    Data.i @Distance()
    Data.i @SquaredDistance()
    Data.i @DotProduct()
    Data.i @Normalize()
    Data.i @MidPoint()
    Data.i @Floor()
    Data.i @Ceil()
    Data.i @Perpendicular()
    Data.i @CrossProduct()
    Data.i @IsZeroLength()
    Data.i @Reflect()
    Data.i @AngleBetween()
  EndDataSection

EndModule