;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
Procedure.f min(a.f,b.f)
   If a<b
      ProcedureReturn a
   EndIf
   ProcedureReturn b
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
Procedure.f max(a.f,b.f)
   If a>b
      ProcedureReturn a
   EndIf
   ProcedureReturn b
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
Structure sVector2f
  x.f
  y.f
EndStructure
;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.i createVector2f(x.f, y.f)
  *v.sVector2f = AllocateMemory(SizeOf(sVector2f))
  If *v
    *v\x  = x
    *v\y  = y
    ProcedureReturn *v
  EndIf
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL deleteVector2f(*v.sVector2f)
  If *v
    *v\x = #Null
    *v\y = #Null
    FreeMemory(*v)
  EndIf
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL addVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  *result\x = *a\x + *b\x
  *result\y = *a\y + *b\y
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL subVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  *result\x = *a\x - *b\x
  *result\y = *a\y - *b\y
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL mulVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  *result\x = *a\x * *b\x
  *result\y = *a\y * *b\y
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL divVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  If *b\x <> 0
   *result\x = *a\x / *b\x
  EndIf

  If *b\y <> 0
   *result\y = *a\y / *b\y
  EndIf
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL scaleVector2f(*a.sVector2f, value.f)
  *a\x * value
  *a\y * value
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.f squareLengthVector2f(*v.sVector2f)
  ProcedureReturn (*v\x * *v\x) + (*v\y * *v\y)
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.f lengthVector2f(*v.sVector2f)
  ProcedureReturn Sqr((*v\x * *v\x) + (*v\y * *v\y))
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.f dotProductVector2f(*a.sVector2f, *b.sVector2f)
  ProcedureReturn (*a\x * *b\x) + (*a\y * *b\y)
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL normalizeVector2f(*v.sVector2f)
  l.f = Sqr((*v\x * *v\x) + (*v\y * *v\y))
  If l > 0
    *v\x / l
    *v\y / l
  EndIf
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL middlePointVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f)
  *result\x = (*a\x + *b\x) * 0.5
  *result\y = (*a\y + *b\y) * 0.5
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL lerpVector2f(*result.sVector2f, *a.sVector2f, *b.sVector2f, val.f)
  *result\x = *a\x + (*b\x - *a\x) * val
  *result\y = *a\y + (*b\y - *a\y) * val
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.f crossProductVector2f(*a.sVector2f, *b.sVector2f)
  ProcedureReturn *a\x * *b\y - *a\y * *b\x
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL randomDeviantVector2f(*v.sVector2f, angle.f)
  angle = angle * Random(angle) * (#PI*2)
  cosa.f = Cos(angle)
  sina.f = Cos(angle)
  *v\x = cosa * *v\x - sina - *v\y
  *v\y = sina * *v\x + cosa * *v\y
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL perpendicularVector2f(*v.sVector2f)
  Protected x.f = *v\x
  Protected y.f = *v\y
  *v\x = -y
  *v\y = x
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL reflectVector2f(*v.sVector2f, *normal.sVector2f)
  Protected dot.f = (*v\x * *normal\x) + (*v\y * *normal\y)
  *v\x = *v\x - ( 2 * dot * *normal\x )
  *v\y = *v\y - ( 2 * dot * *normal\y )
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
Procedure.b isCloseVector2f(*A.sVector2f , *B.sVector2f)
  tolerance.f = 0.01
  If (Abs(*A\x - *B\x) < tolerance) And (Abs(*A\y - *B\y) < tolerance)
    ProcedureReturn #True
  Else
    ProcedureReturn #False
  EndIf
EndProcedure

;//////////////////////////////////////////////////////////////////////////////
;//
;//////////////////////////////////////////////////////////////////////////////
ProcedureDLL.i intersectVector2f(*p1.sVector2f,*p2.sVector2f,*p3.sVector2f,*p4.sVector2f)

Protected.f x1 = *p1\x, x2 = *p2\x, x3 = *p3\x, x4 = *p4\x;
Protected.f y1 = *p1\y, y2 = *p2\y, y3 = *p3\y, y4 = *p4\y;

Protected.d d = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)

If d = 0
  ProcedureReturn #Null
EndIf

Protected.f pre = (x1*y2 - y1*x2), post = (x3*y4 - y3*x4)
Protected.f x   = ( pre * (x3 - x4) - (x1 - x2) * post ) / d
Protected.f y   = ( pre * (y3 - y4) - (y1 - y2) * post ) / d

If ( x < min(x1, x2) Or x > max(x1, x2) Or x < min(x3, x4) Or x > max(x3, x4) )
  ProcedureReturn #Null
EndIf

If ( y < min(y1, y2) Or y > max(y1, y2) Or y < min(y3, y4) Or y > max(y3, y4) )
  ProcedureReturn #Null
EndIf

ProcedureReturn createVector2f(x,y)
EndProcedure